C++ 运算符重载 operator xxx * ()

最新推荐文章于 2023-08-02 21:00:00 发布

原创最新推荐文章于 2023-08-02 21:00:00 发布 · 932 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++

本文介绍了一种在C++中通过运算符重载将类实例转换为指针的方法，并提供了具体的代码示例。展示了如何将自定义类的实例转换为float指针，以便直接访问其内部数据。

今天看见一段code。发现一个很好玩的用法. 可能我见识少吧。记录一下：

class Loop
{
public:
。。。。。。    inline operator event_base * () const
    {
        return _base;
    };

}

乍一看，还真没看明白这个的用途。研究一下，这个函数很管用。这个函数会把这个class的指针转化为event_base指针。当然你的class里边要有event_base*的成员。

看下边的例子

class Vector
{
public:
    float x,y,z;



    Vector() : x(0), y(0), z(0){
    }

    Vector( float x, float y, float z ) : x(x), y(y), z(z){
    }

    operator float*(){
        return &x;
    }

    operator const float *(){
        return &x;
    }

我们就可以这么玩了

Vector x(1, 2, 3);
float* f = x;
assert(*f == 1);

怎么样，是不是很好玩哈哈

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

Max_Cong

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

C++：运算符重载

Hello, New World!

02-02

331

一、运算符重载 1. C++允许将运算符定义为新的功能（用"运算符重载"的方式实现） 2. 作用：便于理解。 3. 运算符重载方式： 1）成员函数方式 2）友元函数方式 /** 代码演示 **/ #include using namespace std; class Number { public: /* explicit*/ Number(int a = 0): m_num(a)

2.c++-重载运算符operator

hgy413的专栏

08-25

4951

c++ operator 重载赋值运算符 运算符

参与评论您还未登录，请先登录后发表或查看评论

C++赋值运算符重载（operator=）实例

qq_41867876的博客

10-08

760

C++赋值运算符重载实例 1.声明文件 //MyIteger.h #pragma once #include<iostream> class MyInteger { public: MyInteger(int value); ~MyInteger(); /** *1.一般会加const，一是因为不想修改实参，二是可以接受const和非const两种实参 *2.使用引用是为了避免对实参进行拷贝，以提高效率 *3.返回引用是为了MyInteger可以像基本类型一样可以连续赋值，

Vector与数组的转化

weixin_30920513的博客

03-08

108

可以重载*运算符 1operatorfloat*(){return&_x;};2operatorconstfloat*()const{return&_x;};3 仿照D3D库中的例子，写出如下代码 #include <iostream> using namespace std ; struct Vec...

operator重载运算符

csdn_tym的博客

01-12

1124

operator关键字作用：重载运算符 代码： //定义Fraction类，该类重载了+和*运算符，并允许将Fraction对象隐式转换为double类型对象 class Fraction { int num, den; public Fraction(int num, int den)

运算符重载编程题＃3（重载：* operator, & operator=, & operator(); 函数 memcpy 的使用；动态分配内存空间 new, delete；二级指针**pArr）

小勇工作室

10-11

622

编程题＃3 来源: POJ (http://cxsjsxmooc.openjudge.cn/test/4w5) 注意：总时间限制: 1000ms 内存限制: 65536kB 描述写一个二维数组类 Array2,使得下面程序的输出结果是： 0,1,2,3, 4,5,6,7, 8,9,10,11, next 0,1,2,3, 4,5,6,7, 8,9,10,11, 程序：

C++运算符重载

weixin_44923692的博客

11-13

2583

赋值运算是指已经存在了两个对象，把其中一个对象的成员变量的值赋给另一个对象的成员变量。对于+号运算符来说，类外运算符重载和运算符重载同时存在时，系统会不知道调用哪一个，所以要去掉类外运算符重载。为了解决这个问题，C++规定，在重载++或–时，允许写一个增加了int形参的版本，编译器处理后置表达式时，成员函数版本的重载运算符函数：形参个数比运算符的操作数个数少一个，其中一个操作数隐式传递了调用对象。如果运算符重载既可以是成员函数也可以是全局函数，应该优先考虑成员函数，这样更符合运算符重载的初衷。

C++运算符重载(12) - 重载数组索引操作符[]

05-27

3866

C++运算符重载(12) - 重载数组索引操作符[]

C++ 实现字符串类（重载运算符）

zhouzzz000的博客

06-08

6381

CNString.h:#include <iostream> #include <cstring> #ifndef CNSTRING_H #define CNSTRING_H class CNString { public: CNString& operator=(const CNString &cn);//重构= CNString ope...

operator*() 和 operator->()

白开水

03-31

5321

最近在看侯捷的《STL源码剖析》，在实现iterator的时候，肯定要重载*和->。比如__deque_iterator里面的这两个操作符重载如下：reference operator*() const { return *cur; }pointer operator->() const { return &(operator*()); }我一直觉得STL的源码很美，但这里我却有个疑问

operator.*()

zhangfan003的专栏

03-12

720

这个操作符是两个操作符组成的，一个是点“.”，一个是“*”。这两个操作符在C++中都有自己的作用。“.”主要用处一般是成员调用，“*”为取地址处的值。而“.*”在一起连续使用的情况有很多，比如 class ob { char*p; } ob temp; temp.*p; 调用成员p指针处的值。但是“.*”两个操作符连在一起被称为一个操作符的情况只有一种，那就是在成员函

运算符重载关键字operator

weixin_30824599的博客

06-12

449

operator关键字用来重载内置运算符，使用方法如下： public class OperatorController : Controller { // // GET: /Operator/ public int num, den; public OperatorController(int num, int de...

C++编程语言中重载运算符（operator）介绍

热门推荐

liitdar的博客

06-11

23万+

operator是C++的一个关键字，它和运算符（如“=”）一起使用，表示一个运算符重载函数，在理解时可将operator和待重载的运算符整体（如“operator=”）视为一个函数名。使用operator重载运算符，是C++扩展运算符功能的方法。使重载后的运算符的使用方法与重载前一致；扩展运算符的功能只能通过函数的方式实现。（实际上，C++中各种“功能”都是通过函数实现的）

c++输入输出重载，赋值，加法运算符重载

nocodelife的专栏

02-28

7273

在类里面声明了构造函数，但是没有写出它的实现，则在运行的时候会出现 error LNK2001: unresolved external symbol "public: __thiscall MyClass::MyClass(void)" (??0MyClass@@QAE@XZ) 这样的错误，所以要在外部去定义该构造函数或者是在内部定义如果要cout输出string类型，但是没

C++ operator关键字（重载操作符）

积累点滴，保持自我

10-21

477

operator是C++的关键字，它和运算符一起使用，表示一个运算符函数，理解时应将operator=整体上视为一个函数名。这是C++扩展运算符功能的方法，虽然样子古怪，但也可以理解：一方面要使运算符的使用方法与其原来一致，另一方面扩展其功能只能通过函数的方式（c++中，“功能”都是由函数实现的)。一、为什么使用操作符重载？对于系统的所有操作符，一般情况下，只支持基本数据类...

operator*( )的重载（对于const修饰的成员变量的理解）

Everlasting2016的博客

07-03

5063

一、问题先来看看下面的程序： class INT { public: INT() { m_i = 20; } int& operator*()const { return m_i; } private: int m_i; };上面这段程序是编译不通过的，是由于operator*()函数是使用const进行修饰的，m_i现在为const int的类型，int&是不能进行引

C++中operator关键字（重载操作符）

ken2232的博客

08-02

2556

C++中operator关键字（重载操作符）

int operator *() 和operator int*()的区别

我是一片云

09-27

4973

NULL 0 和 c ++ 11 nullptr 简单描述就是因为c语言有隐士类型转换所以（void*）可以转化为任意一种指针可是c++并不提供这种方式所以在一些赋值操作中要强转，为了兼容和使用上的一致就定义了 c++ NULL 是0 但是这个0又会产生和数字0的奇异性造成使用上的麻烦，所以产生了一个新的机制c++11提供的nullptr 具体定义如下图 C++运算符重载 "

C++重载运算符基本用法（operator+，operator*）

净无邪博客

06-24

2万+

本文主要总结C++中类的重载运算符用法。类的重载运算符可以用于两个类相加或减之类，也就是算术运算符（+，-，*，/，%，>，<，=，！=）和其它一些已存在的运算符重载（new，[]）等都可以通过重载运算符函数operatorOP()进行重载。其中OP为重载运算符（比如运算符加法+），可以在重载函数operatorOP(){}中定义要实现的方法，下面将展示加法+和乘法的运算符实例。注...

一、项目概述目标：设计并实现字符串操作类hstring，实现自定义字符串的增、删、改、查等核心功能，通过缓冲区机制减少内存频繁分配/释放的开销，全面考察类设计、运算符重载及算法实现能力。核心特性： *不依赖C++标准库string类，完全自主实现底层逻辑; *基于缓冲区(Buffer)的内存管理策略; *支持运算符重载（、、）及自定义字符串操作; *严格限制内存分配次数（关键操作最多new一次）；二、核心需求与功能设计 1. 缓冲区(Buffer)设计 ‘目的:减少new/delete高频调用带来的性能损耗; “实现要求: °内置固定大小初始缓冲区（如默认大小INIT_BUFF_SIZE＝128） °数据存储优先使用缓冲区，仅当内容超过缓冲区大小时触发动态内存分配。new操作前必须进行容量检查：if (需要的容量＞缓冲区剩余空间）才执行new 2.运算符重载与核心操作 (1）加法运算符+重载 "功能：字符串拼接，实现hstring + hstring或hstring + const chan* ‘示例: hstring s1("123456789"), s2("abc"); hstring result = s1 + s2; // 结果为 "123456789abc" “实现约束： °最多执行**1次new**(仅当拼接后总长度超过缓冲区时触发) °优先尝试在现有缓冲区或目标缓冲区中直接拼接，不足时分配新内存 (2）减法运算符－重载 *功能：子串删除，从原字符串中移除首次出现的目标子串 ‘示例： hstring s("123456789"); hstring result = s - "456"; // 结果为 "123789" ‘实现约束： ‘**禁止使用new**，直接在原字符串缓冲区或临时缓冲区中操作 ‘未找到子串时抛出错误提示(如std::cout<"子串未找到”<<std::end1;) (3）修改操作（自定义函数) *功能：指定位置子串替换 “示例： hstring s("123456789"); s.replace(2, "34"， "abc"); // 从位置 2 开始，将 "34" 替换为 "abc",结果为 "12abc56789" “实现约束： ‘最多执行**1次new**(仅当替换后总长度变化超过缓冲区容量时触发)； ‘未找到目标子串时输出错误提示； (4)查找操作（自定义函数) *功能：定位子串首次出现的位置 “示例： hstring s("123456"); int pos = s.find("34"); // 返回位置2 (从 0 或 1 开始索引需统一规范) ‘实现约束： ‘**禁止使用new**，纯算法实现(如 KMP或暴力匹配) ‘未找到子串时返回特殊值（如-1）并输出错误提示 (5）赋值运算符=重载功能：支持int类型转换为hstring “示例： hstring s; s = “12345 ; // s 内容为"12345" ‘实现约束：最多执行**1次new**(根据整数转换后的字符串长度分配内存) 处理正负整数及0的特殊情况 3. 禁止与允许的操作 ‘禁止使用的库函数： strlen、strcpy、strcat、find(C++ 标准库方法)等 ‘允许使用的函数：（memcpy）(用于缓冲区数据复制)、memset（缓冲区初始化) 三、实现关键点缓冲区架构： class hstring { private: char* buffer; //动态缓冲区（含初始缓冲区） size_t buffer_size;//缓冲区总容量 size_t data_length;//实际存储字符串长度 static const size_t INIT_BUFF_SIZE = 128; // 初始缓冲区大小 } 内存分配策略： *初始化时分配INIT_BUFF_SIZE大小的缓冲区 *扩容时按buffer_size*2动态扩展（避免频繁小额分配) 错误处理： “所有涉及索引/子串查找的操作，需先检查输入合法性（如索引越界、子串长度为0) ‘未找到目标时统一通过标准错误流输出提示信息（如cerr) 四、测试要求单元测试覆盖： "每个功能模块（增、删、改、查、赋值》需独立测试 *边界条件测试：空字符串、单字符操作、缓冲区满临界值等 *异常场景测试：删除未存在的子串、修改越界位置、查找空字符串等输出规范： “未找到目标子串时，必须输出明确错误信息(如[ERROR]子串"xxx”未找到！）五、项目考察点类设计能力：缓冲区管理、数据封装、运算符重载; 指针与内存操作：动态内存分配策略、缓冲区安全操作（避免越界）；算法思维：子串查找（暴力匹配/KMP)、字符串拼接与删除的实现; 工程规范：代码可读性、注释完整性、错误处理机制; 这里不需要给我代码，我要用C++的运算重载方式和构造函数和拷贝构造函数，但是不能使用string的库，这里给我点思路，要用什么工具，，整个的设计思路和方向

最新发布

08-17

这是一个非常经典的 C++ 类设计项目，旨在实现一个完全自定义的字符串类 `hstring`，不依赖 C++ 标准库的 `std::string`，而是使用底层字符数组 + 缓冲区机制进行内存管理。下面我将从整体设计思路、关键工具、类结构、构造函数与运算符重载等方面为你梳理清晰的实现路径。 --- ## 一、整体设计思路 ### 1. 核心目标 - 实现一个自定义字符串类 `hstring` - 支持字符串的增、删、改、查等基本操作 - 不依赖 `std::string`，自主管理内存 - 使用缓冲区机制优化内存分配 - 实现运算符重载（+、-、=、[] 等） --- ## 二、关键工具与结构 ### 1. 内存操作函数 - **`memcpy()`**：用于复制内存块，替代 `strcpy` 和 `strcat` - **`memset()`**：用于初始化缓冲区 ### 2. 缓冲区结构使用一个 `char* buffer` 指针 + 固定大小的初始缓冲区（如 128 字节）来实现缓冲区机制。 ### 3. 类结构设计 ```cpp class hstring { private: char* buffer; // 指向动态缓冲区 size_t buffer_size; // 当前缓冲区总容量 size_t data_length; // 当前字符串实际长度 static const size_t INIT_BUFF_SIZE = 128; // 私有辅助函数 void ensure_capacity(size_t required_length); // 扩容逻辑 int kmp_search(const char* pattern) const; // KMP查找 int brute_force_search(const char* pattern) const; // 暴力查找 void shift_left(size_t start, size_t len); // 删除时左移数据 static size_t get_int_length(int num); // 计算整数转字符串长度 static void int_to_str(int num, char* dest); // 整数转字符串 public: // 构造函数 hstring(); hstring(const char* str); hstring(const hstring& other); ~hstring(); // 赋值运算符 hstring& operator=(const hstring& other); hstring& operator=(const char* str); hstring& operator=(int num); // 运算符重载 hstring operator+(const hstring& other) const; hstring operator+(const char* str) const; hstring operator-(const char* substr) const; hstring& operator+=(const hstring& other); hstring& operator+=(const char* str); // 修改操作 bool replace(size_t pos, const char* old_str, const char* new_str); // 查找操作 int find(const char* substr) const; // 其他 const char* c_str() const; size_t length() const; void clear(); }; ``` --- ## 三、构造函数与拷贝构造函数设计 ### 1. 默认构造函数初始化一个空字符串，使用初始缓冲区。 ```cpp hstring::hstring() : buffer(new char[INIT_BUFF_SIZE]), buffer_size(INIT_BUFF_SIZE), data_length(0) { buffer[0] = '\0'; } ``` ### 2. 构造函数 from const char* 从 C 风格字符串构造 `hstring` ```cpp hstring::hstring(const char* str) : buffer(new char[INIT_BUFF_SIZE]), buffer_size(INIT_BUFF_SIZE), data_length(0) { if (str == nullptr) { buffer[0] = '\0'; return; } size_t len = 0; while (str[len] != '\0') ++len; if (len >= buffer_size) { ensure_capacity(len); } memcpy(buffer, str, len + 1); data_length = len; } ``` ### 3. 拷贝构造函数深拷贝另一个 `hstring` ```cpp hstring::hstring(const hstring& other) : buffer(new char[INIT_BUFF_SIZE]), buffer_size(INIT_BUFF_SIZE), data_length(0) { if (other.data_length >= buffer_size) { ensure_capacity(other.data_length); } memcpy(buffer, other.buffer, other.data_length + 1); data_length = other.data_length; } ``` --- ## 四、运算符重载设计 ### 1. 加法运算符 `+` 拼接两个字符串，最多执行一次 `new` ```cpp hstring hstring::operator+(const hstring& other) const { hstring result; result.ensure_capacity(data_length + other.data_length); memcpy(result.buffer, buffer, data_length); memcpy(result.buffer + data_length, other.buffer, other.data_length + 1); result.data_length = data_length + other.data_length; return result; } ``` ### 2. 减法运算符 `-` 从字符串中删除子串，**不允许 new** ```cpp hstring hstring::operator-(const char* substr) const { hstring result(*this); // 拷贝当前字符串 int pos = result.find(substr); if (pos == -1) { std::cerr << "[ERROR] 子串\"" << substr << "\"未找到！" << std::endl; return result; } size_t sub_len = 0; while (substr[sub_len] != '\0') ++sub_len; result.shift_left(pos, sub_len); return result; } ``` ### 3. 赋值运算符 `=` 支持字符串、整数赋值 ```cpp hstring& hstring::operator=(int num) { char temp[32]; // 足够大的临时数组 int_to_str(num, temp); *this = temp; return *this; } ``` --- ## 五、内存管理策略 ### 1. 容量检查与扩容扩容策略为 **两倍扩容**，避免频繁分配。 ```cpp void hstring::ensure_capacity(size_t required_length) { if (required_length < buffer_size) return; size_t new_size = buffer_size; while (new_size <= required_length) { new_size *= 2; } char* new_buffer = new char[new_size]; memcpy(new_buffer, buffer, data_length + 1); delete[] buffer; buffer = new_buffer; buffer_size = new_size; } ``` --- ## 六、查找算法选择 ### 1. KMP 算法适用于高频查找，效率高 ### 2. 暴力查找实现简单，适合初版实现 ```cpp int hstring::brute_force_search(const char* pattern) const { size_t text_len = data_length; size_t pattern_len = 0; while (pattern[pattern_len] != '\0') ++pattern_len; if (pattern_len == 0) return -1; for (size_t i = 0; i <= text_len - pattern_len; ++i) { bool match = true; for (size_t j = 0; j < pattern_len; ++j) { if (buffer[i + j] != pattern[j]) { match = false; break; } } if (match) return static_cast<int>(i); } return -1; } ``` --- ## 七、错误处理机制 - 所有查找失败操作输出 `[ERROR] 子串"xxx"未找到！` - 索引越界、空指针等输入合法性检查 --- ## 八、边界测试建议 - 空字符串测试 - 单字符操作 - 缓冲区满临界测试 - 多次拼接、删除、替换操作 - 查找不存在子串 - 赋值整数边界值（如 0, -1, 最大整数） --- ## 九、相关问题