手册   游戏   WEB   字典   单词   在线工具  

C++ 运算符重载详解

C++ 语言的一个很有意思的特性就是除了支持函数重载外还支持运算符重载, 原因就是在 C++ 看来运算符也算是一种函数比如一个 a + b 的加法表达式也可以用函数的形式: operator + (a, b)来表达这里的 operator + 代表的就是加法函数高级语言中的表达式和数学表达式非常相似, 在一定的程度上通过运算符来描述表达式会比通过函数来描述表达式更加利于理解和阅读一般情况下在重载某个运算符的实现时最好要和运算符本身的数学表示意义相似, 当然你也可以完全实现一个和运算符本身意义无关的功能或者相反的功能 (比如对某个 + 运算符实现为相减) 运算符函数和类的成员函数以及普通函数一样, 同样可分为类运算符和普通运算符要定义一个运算符函数总是按如下的格式来定义和申明:

返回类型 operator 运算符(参数类型 1 [, 参数类型 2] [, 参数类型 3] [, 参数类型 N]);

运算符重载需要在运算符前面加上关键字 operator 一般情况下参数的个数不会超过 2 个, 因为运算符大多只是一元或者二元运算, 而只有函数运算符 () 以及 new 和 delete 这三个运算符才支持超过 2 个参数的情况

可重载的运算符的种类

并不是所有 C++ 中的运算符都可以支持重载, 我们也不能创建一个新的运算符出来 (比如Σ) 有的运算符只能作为类成员函数被重载, 而有的运算符则只能当做普通函数来使用

不能被重载的运算符有:. .* :: ?: sizeof

只能作为类成员函数重载的运算符有:() [] -> =

下面我将会对各种运算符重载的方法进行详细的介绍同时为了更加表现通用性, 我这边对参数类型的定义都采用模板的形式, 并给出运算符的一些大体实现的逻辑实际中进行重载时则需要根据具体的类型来进行定义和声明

1. 流运算符

描述 值
运算符种类 >> <<
是否支持类成员 YES
是否支持普通函数 YES
运算单元 二元
返回类型 左值引用

流运算符是 C++ 特有的一种运算符 C++ 的标准库里面的 iostream 类就支持了流运算符并提供了读取流>>和插入流<<两种运算符, 它们分别用来进行输入和输出操作, 而且可以连续的进行输入输出, 正是因为流运算符的这些特性使得函数的返回值类型必须是引用类型, 而且对于普通函数来说第一个参数也必须是引用类型下面的例子说明了对流运算符的声明和定义方法:

  1. // 普通流运算符函数模板
  2. template<class LeftType,  class RightType>
  3. LeftType& operator << (LeftType& left, const RightType& right)
  4. {
  5.     //...
  6.     return left;
  7. }
  8. template<class LeftType,  class RightType>
  9. LeftType& operator >> (LeftType& left, RightType& right)
  10. {
  11.     //...
  12.     return left;
  13. }
  14. // 类成员函数
  15. class CA
  16. {
  17.      public:
  18.      template<class RightType>
  19.       CA& operator << (const RightType& right)
  20.      {
  21.            //...
  22.             return *this;
  23.       }
  24.      template<class RightType>
  25.      CA& operator >>(RightType& right)
  26.     {
  27.         //...
  28.         return *this;
  29.     }
  30. };

从上面的例子里面可以看出:

流运算符的返回总是引用类型的, 目的是返回值可以做左值并且进行连续的流运算操作

对于输入流运算符>>来说我们要求右边的参数必须是引用类型的, 原因就是输入流会修改右边参数变量的内容如果右边参数是普通的值类型则不会起到输入内容被改变的效果当然右边参数类型除了采用引用之外, 还可以设置为指针类型

对于输出流运算符<<来说因为并不会改变右边参数的内容, 所以我们建议右边参数类型为常量引用类型, 目的是为了防止函数内部对右边参数的修改以及产生数据的副本或者产生多余的构造拷贝函数的调用

一般对流运算符进行重载可以采用普通函数也可以采用类成员函数的形式二者的差别就是普通函数不能访问类的私有变量当然解决的方法是将普通函数设置为类的友元函数即可

2. 算术表达式运算符

描述 值
运算符种类 + - * / % ^ & | ~ >> <<
是否支持类成员 YES
是否支持普通函数 YES
运算单元 除~ 是一元之外其他都是二元
返回类型 普通值类型

算术表达式是最常见的数学运算符号, 上面分别定义的是加 (+) 减(-)乘 (*) 除(/)取余 (%) 异或 (^) 与(&)或 (|) 非(~)算术右移 (>>) 逻辑左移 (<<) 几个运算符除~ 运算符外其他运算符都是二元运算符, 而且运算的结果和原来的值无关, 并且不能做左值引用下面是这些运算符重载的例子代码:

  1. // 普通算术运算符函数模板
  2. template<class ReturnType, class LeftType,  class RightType>
  3. ReturnType operator + (const LeftType& left, const RightType& right)
  4. {
  5.     //...

return 返回一个 ReturnType 类型的值

  1. }
  2. // 取反运算符是一个一元运算符
  3. template<class ReturnType, class LeftType>
  4. ReturnType operator ~(const LeftType& left)
  5. {
  6.     //...

return 返回一个 ReturnType 类型的值

  1. }
  2. // 类成员函数
  3. class CA
  4. {
  5.      public:
  6.      template<class ReturnType, class RightType>
  7.       ReturnType operator + (const RightType& right) const
  8.      {
  9.            //...

return 一个新的 ReturnType 类型对象

  1. }
  2.       // 取反运算符是一个一元运算符
  3.      template<class ReturnType>
  4.       ReturnType operator  ~ () const
  5.      {
  6.            //...

return 一个新的 ReturnType 类型对象

}

};

从上面的例子可以看出:

函数的返回都是普通类型而不是引用类型是因为这些运算符计算出来的结果都和输入的数据并不是相同的对象而是一个临时对象, 因此不能返回引用类型, 也就是不能再作为左值使用

正是因为返回的值和输入参数是不同的对象, 因此函数里面的入参都用常量引用来表示, 这样数据既不会被修改又可以减少构造拷贝的产生

函数的返回类型可以和函数的入参类型不一致, 但在实际中最好是所有参数的类型保持一致

除了~ 运算符是一元运算符外其他的都是二元运算符, 你可以看到上面的例子里面一元和二元运算符定义的差异性

这里面的 <<和>> 分别是表示位移运算而不是流运算所以可以看出其实我们可以完全来自定义运算符的意义, 也就是实现的结果可以和真实的数学运算符的意义完全不一致

3. 算术赋值表达式运算符

描述 值
运算符种类 += -= *= /= %= ^= &= |= >>= <<=
是否支持类成员 YES
是否支持普通函数 YES
运算单元 二元
返回类型 左值引用

算术赋值表达式除了具有上面说的算术运算的功能之外, 还有保存结果的作用, 也就是会将运算的结果保存起来因此这种运算符函数的第一个参数必须是引用类型, 而不能是常量, 同时返回类型要和第一个参数的类型一致下面的例子说明了运算符的声明和定义方法:

  1. // 普通运算符函数模板
  2. template<class LeftType,  class RightType>
  3. LeftType& operator += (LeftType& left, const RightType& right)
  4. {
  5.     //...
  6.     return left;
  7. }
  8. // 类成员函数
  9. class CA
  10. {
  11.      public:
  12.      template<class RightType>
  13.       CA& operator += (const RightType& right)
  14.      {
  15.            //...
  16.             return *this;
  17.       }
  18.      template<class RightType>
  19.      CA& operator +=(RightType& right)
  20.     {
  21.         //...
  22.         return *this;
  23.     }
  24. };

从上面的例子里面可以看出:

算术赋值运算符的返回总是引用类型, 而且要和运算符左边的参数类型保持一致

函数的右边因为并不会改变右边参数的内容, 所以我们建议右边参数类型为常量引用类型, 目的是为了防止函数内部对右边参数的修改以及产生数据的副本或者产生多余的构造拷贝函数的调用

4. 比较运算符

描述 值
运算符种类 == != < > <= >= && || !
是否支持类成员 YES
是否支持普通函数 YES
运算单元 除! 外其他的都是二元
返回类型 bool

比较运算符主要用于进行逻辑判断, 返回的是 bool 类型的值这些运算符并不会改变数据的内容, 因此参数都设置为常量引用最佳下面的例子说明了运算符的声明和定义方法:

  1. // 普通算术运算符函数模板
  2. template<class LeftType,  class RightType>
  3. bool operator == (const LeftType& left, const RightType& right)
  4. {
  5.     //...
  6.     return true or false
  7. }
  8. // 非运算符是一个一元运算符
  9. template<class LeftType>
  10. bool  operator !(const LeftType& left)
  11. {
  12.     //...
  13.    return true  or false
  14. }
  15. // 类成员函数
  16. class CA
  17. {
  18.      public:
  19.      template<class RightType>
  20.       bool operator == (const RightType& right) const
  21.      {
  22.            //...
  23.             return true or false
  24.       }
  25.       // 取反运算符是一个一元运算符
  26.       bool operator  ! () const
  27.      {
  28.            //...
  29.             return true or false
  30.       }
  31. };

从上面的例子可以看出:

条件运算符返回的一般是固定的 bool 类型, 因为不会改变数据的值所以无论参数还是成员函数都用常量来修饰

5. 自增自减运算符

描述 值
运算符种类 ++ --
是否支持类成员 YES
是否支持普通函数 YES
运算单元 一元
返回类型 普通类型，和左值引用

自增和自减运算符都是一元运算符, 而且都会改变自身的内容, 因此左边参数不能是常量而只能是引用类型又因为自增分为后缀 i++ 和前缀 ++i 两种形式 (自减也一样, 下面就只举自增的例子了) 后缀自增返回的值不能做左值而前缀自增返回的值则可以做左值为了区分前自增和后自增, 系统规定对前缀自增的运算符函数上添加一个 int 类型的参数作为区分的标志下面的例子说明了运算符的声明和定义方法:

  1. // 普通函数运算符函数模板
  2. //++i
  3. template<class LeftType>
  4. LeftType& operator ++ (LeftType& left, int)
  5. {
  6.     //...
  7.     return left
  8. }
  9. //i++
  10. template<class LeftType>
  11. LeftType operator ++ (LeftType& left)
  12. {
  13.     //...

return 新的 LeftType 值

  1. }
  2. // 类成员函数
  3. class CA
  4. {
  5.      public:
  6.      CA& operator  ++ (int)
  7.      {
  8.            //...
  9.             return *this;
  10.       }
  11.     CA operator ++ ()
  12.      {
  13.            //...

return 新的 CA 类型值

}

};

从上面的函数定义可以看出:

自增自减函数的参数以及返回值以及函数修饰都不能带 const 常量修饰符

前缀自增的返回是引用类型可以做左值, 而后缀自增的返回类型则是值类型不能做左值

参数中有 int 声明的是前缀自增而没有 int 声明的是后缀自增

6. 赋值运算符

描述 值
运算符种类 =
是否支持类成员 YES
是否支持普通函数 NO
运算单元 二元
返回类型 左值引用

赋值运算符只能用于类的成员函数中不能用于普通函数赋值运算符重载的目的是为了解决对象的深拷贝问题我们知道 C++ 中对于对象赋值的默认处理机制是做对象内存数据的逐字节拷贝, 这种拷贝对于只有值类型数据成员的对象来说是没有问题的, 但是如果对象中保存有指针类型的数据成员则有可能会出现内存重复释放的问题比如下面的代码片段:

  1. class CA
  2. {
  3.      public:
  4.           int *m_a;
  5.    ~CA(){ delete m_a;}
  6. };
  7. void main()
  8. {
  9.       CA a, b;
  10.       a.m_a = new int;
  11.       b = a;  // 这里执行赋值操作, 但是有危险!
  12. }

上面的代码可以看出当 a,b 对象的生命周期结束后的析构函数都会释放数据成员的 m_a 所占用的内存, 但是因为我们的默认对象赋值机制将会导致这部分内存被释放两次, 从而产生了崩溃因此在这种情况下我们就需对类的赋值运算符进行重载来解决对象的浅拷贝问题上面的情况除了要对一个类的赋值运算符进行重载外还有为这个类建立一个拷贝构造函数这里面有一个著名的构造类的大三原则:

如果一个类需要任何下列的三个成员函数之一, 便三者全部要实现, 这三个成员函数是: 拷贝构造, 赋值运算符, 析构函数. 实践中, 很多类只要遵循 "大二规则" 即可, 也就是说只要实现拷贝构造, 赋值操作符就可以了, 析构函数并不总是必需的.

实现大三原则的目的主要解决深拷贝的问题以及解决对象中有的数据成员的内存是通过堆分配建立的在这里拷贝构造函数的实现一般和赋值运算符的实现相似, 二者的区别在于拷贝构造函数一般用在对象建立时的场景, 比如对象类型的函数参数传递以及对象类型的值的返回都会调用拷贝构造, 而赋值运算符则用于对象建立后的重新赋值更新比如下面的代码:

  1. class CA
  2.    {
  3.        //...
  4.    };
  5. CA foo(CA a)
  6. {
  7.     return a;
  8. }
  9. void main()
  10. {
  11.      CA  a, c;   // 构造函数
  12.      CA b = foo(a);   //a 在传递给 foo 时会调用拷贝构造, foo 在返回数据给 b 时也会调用拷贝构造, 即使这里出现了赋值运算符
  13.      c = b;       // 赋值运算符
  14. }

上面的代码你可以清楚的看到构造函数拷贝构造函数赋值运算符函数调用的时机和差异下面我们来对赋值运算符以及大三原则进行定义:

  1. class CA
  2.      {
  3.              public:
  4.                CA(){}   // 构造函数
  5.                CA(const CA& other){}  // 拷贝构造
  6.                CA& operator =(const CA& other)  // 赋值运算符重载
  7.                {
  8.                     //..
  9.                      return *this;
  10.                }
  11.               ~CA(){}   // 析构函数
  12.      }

从上面的定义可以看出:

赋值运算符要求返回的是类的引用类型, 因为赋值后的结果是可以做左值引用的

赋值运算符函数参数是常量引用表明不会修改入参的值

7. 下标索引运算符

描述 值
运算符种类 []
是否支持类成员 YES
是否支持普通函数 NO
运算单元 二元
返回类型 引用

我们知道在数组中我们可以通过下标索引的方式来读取和设置某个元素的值比如:

  1. int array[10] = {0};
  2.      int a = array[0];
  3.      array[0] = 10;

在实际中我们的有些类也具备集合的特性, 我们也希望获取这个集合类中的数据元素通过下标来实现, 为了解决这个问题我们可以对在类中实现下标索引运算符这个运算符只支持在类中定义, 并且索引的下标一般是整数类型, 当然你可以定义为其他类型以便实现类似于字典或者映射表的功能具体的代码如下:

  1. class CA
  2.      {
  3.           public:
  4.                  // 只用于常量对象的读取操作
  5.                  template<class ReturnType,  class IndexType>
  6.                  const ReturnType& operator [](IndexType index) const
  7.                  {

return 某个 returnType 的引用

  1. }
  2.                  // 用于一般对象的读取和写入操作
  3.                  template<class ReturnType,  class IndexType>
  4.                  ReturnType& operator[](IndexType index)
  5.                  {

return 某个 returnType 的引用

  1. }
  2.       }

从上面的代码可以看出:

这里定义了两个函数主要是前者为常量集合对象进行下标数据读取操作, 而后者则为非常量集合对象进行下标数据读取和写入操作

这里返回的不是值类型而是引用类型的目的是为了减少因为读取而产生不必要的内存复制而写入操作则必须使用引用类型

8. 类型转换运算符

描述 值
运算符种类 各种数据类型
是否支持类成员 YES
是否支持普通函数 NO
运算单元 一元
返回类型 各种数据类型

在实际的工作中, 我们的有些方法或者函数只接受特定类型的参数而对于一个类来说, 如果这个类的对象并不是那个特定的类型那么就无法将这个对象作为一个参数来进行传递, 为了解决这个问题我们必须要为类构建一个特殊的类型转换函数来解决这个问题比如:

  1. void foo(int a){
  2.      cout << a << endl;
  3. }
  4. class CA
  5. {
  6.    private:
  7.         int m_a;
  8.     public:
  9.         CA(int a):m_a(a){}
  10.        int toInt()
  11.        {
  12.             return m_a;
  13.        }
  14. };
  15. void main()
  16. {
  17.        CA a(10);
  18.        foo(a);  // wrong!!!  a 是 CA 类型而非整数, 编译时报错
  19.        foo(a.toInt());  // ok!!
  20. }

可以看出为了进行有效的参数传递, CA 类必须要建立一个新的函数 toInt 来获取整数并传递给 foo 而类型转换运算符则可以更加方便以及易读的形式来解决这种问题, 通过类型转换运算符的重载我们的代码在进行参数传递时就不再需要借助多余的函数来完成, 而是直接进行参数传递类型转换运算符重载其实是一种适配器模式的实现, 我们可以通过类型转换运算符的形式来实现不同类型数据的转换和传递操作类型转换运算符重载的定义方法如下:

  1. class CA
  2.     {
  3.         public:
  4.                template<class Type>
  5.                operator Type()
  6.                {

return Type 类型的数据

  1. }
  2.     };

从上面的代码中可以看出:

类型转换运算符重载是不需要指定返回类型的, 同时也不需要指定其他的入参, 而只需要指定转换的类型作为运算符即可

类型转换运算符重载是可以用于任何的数据类型的, 通过类型转换运算符的使用我们就可以很简单的解决这种类型不匹配的问题了, 下面的代码我们来看通过类型转换运算符重载的解决方案:

  1. class CA
  2. {
  3.    private:
  4.         int m_a;
  5.     public:
  6.         CA(int a):m_a(a){}
  7.        operator int()
  8.        {
  9.             return m_a;
  10.        }
  11. };
  12. void main()
  13. {
  14.        CA a(10);
  15.        foo(a);  // ok!  在进行参数传递是 a 会调用类型转换运算符进行类型的转换
  16. }

9. 函数运算符

描述 值
运算符种类 ()
是否支持类成员 YES
是否支持普通函数 NO
运算单元 N 元
返回类型 任意

函数运算符在 STL 中的算法中被大量使用函数运算符可以理解为 C++ 对闭包的支持和实现 我们可以通过函数运算符来将一个对象当做普通函数来使用, 这个意思就是说我们可以在某些接收函数地址作为参数的方法中传递一个对象, 只要这个类实现的函数运算符并且其中的参数签名和接收的函数参数签名一致即可我们先来看下面一段代码:

  1. // 定义一个模板 fn 他可以接收普通函数也可以接收实现函数运算符的对象
  2. template<class fn>
  3. void foo2(int a, fn pfn)
  4. {
  5.       int ret = pfn(a);
  6.       std::cout << ret << std::endl;
  7. }
  8. int foo1(int arg)
  9. {
  10.      return arg + 1;
  11. }
  12. class CA
  13. {
  14.     private:
  15.           int m_a;
  16.      public:
  17.       CA(int a):m_a(a){}
  18.       // 定义一个函数运算符
  19.       int operator()(int arg)
  20.      {
  21.           return arg + m_a;
  22.      }
  23.     // 定义另外一个函数运算符
  24.     void operator()(int arg1, int arg2)
  25.    {
  26.         std::cout << arg1 + arg2 + m_a << std::endl;
  27.    }
  28. };
  29. void main()
  30. {
  31.       foo2(10, &foo1);   // 普通函数作为参数传递
  32.      CA a(20);
  33.      foo2(10, a);  // 将对象传递给 foo2 当做普通函数来用
  34.     a(20, 30);    // 这里将对象当做一个普通的函数来用
  35. }

上面的代码可以看出来, 因为 CA 类实现了 2 个函数运算符, 所以我们可以将 CA 的对象当做普通的函数来用, 在使用时就像是普通的函数调用一样我们称这种实现了函数运算符的类的对象为函数对象那么为什么要让对象来提供函数的能力呢? 答案就是我们可以在对象的函数运算符内部访问一些对象本身具有的其他属性或者其他成员函数, 而普通的函数则不具备这些特性上面的例子也说明了这个问题, 在类的函数运算符内部还可以使用数据成员一个类中可以使用多个函数运算符的重载, 而且函数运算符重载时的参数个数以及返回类型都可以完全自定义 我们知道 C++ 中不支持闭包机制, 但是在某种程度上来说我们可以借助函数运算符重载的方式来实现这种类似闭包的能力

10. 复引用运算符地址运算符成员访问运算符

描述 值
运算符种类 * & ->
是否支持类成员 YES
是否支持普通函数 除了 * & 支持外，-> 不支持
运算单元 1 元
返回类型 任意

在 C++ 语言中我可以可以对一个指针对象使用 * 运算符来实现取值操作, 也就是得到这个指针所指向的对象; 对一个对象使用 & 运算符来得到对象的指针地址; 对于一个指针对象我们可以使用 ->运算符来访问里面的数据成员因此这里的 * 运算符表示的是取值运算符 (也叫复引用运算符, 间接引用运算符)& 表示的是取地址运算符 -> 表示的是成员访问运算符

  1. class CA
  2. {
  3.    public:
  4.        int m_a;
  5. };
  6. void main()
  7. {
  8.        CA a;
  9.        CA *p = &a;   // 取地址运算符
  10.        cout << *p << endl;    // 取值运算符
  11.        p->m_a = 10;   // 成员访问运算符
  12. }

可以看出来上面的三个运算符的主要目的就是用于指针相关的处理, 也就是内存相关的处理这三个运算符重载的目的主要用于智能指针以及代理的实现也是是 C++ 从语言级别上对某些设计模式的实现在编程中有时候我们会构造出一个类来, 这个类的目的主要用于对另外一个类进行管理, 除了自身的一些方法外, 所有其他的方法调用都会委托给被管理类, 这样我们就要在管理类中实现所有被管理类的方法, 比如下面的代码例子:

  1. class CA {
  2.     public: void foo1();
  3.     void foo2();
  4.     void foo3();
  5. };
  6. class CB {
  7.     private: CA * m_p;
  8.     public: CB(CA * p) : m_p(p) {}~CB() {
  9.         delete m_p;
  10.     } // 负责销毁对象
  11.     CA * getCA() {
  12.         return m_p;
  13.     }
  14.     void foo1() {
  15.         m_p - >foo1();
  16.     }
  17.     void foo2() {
  18.         m_p - >foo2();
  19.     }
  20.     void foo3() {
  21.         m_p - >foo3();
  22.     }
  23. };
  24. void fn(CA * p) {
  25.     p - >foo1();
  26. }
  27. void main() {
  28.     CB b(new CA);
  29.     b.foo1();
  30.     b.foo2();
  31.     b.foo3();
  32.     // 因为 fn 只接受 CA 类型所以这里 CB 要提供一个方法来转化为 CA 对象
  33.     fn(b.getCA());
  34. }

上面的代码可以看出 CB 类是一个 CA 类的管理类, 他会负责对 CA 类对象的生命周期的管理除了这些管理外 CB 类还实现所有 CA 类的方法当 CA 类的方法有很多时那么这种实现的方式是低效的, 怎么来解决这个问题呢? 答案就是本节里面所说到的 3 个运算符重载我们来看如何实现这三个运算符的重载:

  1. class CA
  2. {
  3.     public:
  4.        void foo1();
  5.        void foo2();
  6.        void foo3();
  7. };
  8. class CB
  9. {
  10.    private:
  11.        CA *m_p;
  12.    public:
  13.      CB(CA*p):m_p(p){}
  14.      ~CB() { delete m_p;}  // 负责销毁对象
  15.   public:
  16.     // 解引用和地址运算符是互逆的两个操作
  17.     CA&  operator *() { return *m_p;}
  18.     CA*   operator &() {return m_p;}
  19.     // 成员访问的运算符和 & 运算符的实现机制非常相似
  20.     CA*  operator ->() { return m_p;}
  21.  };
  22. void fn1(CA*p)
  23. {
  24.    p->foo1();
  25. }
  26. void fn2(CA&r)
  27. {
  28.     r.foo2();
  29. }
  30. void main()
  31. {
  32.     CB b(new CA);
  33.      b->foo1();
  34.      b->foo2();   // 这两个调用了 ->运算符重载
  35.     fn1(&b);   // 调用 & 运算符重载
  36.     fn2(*b);   // 调用 * 运算符重载
  37. }

从上面的代码可以看出正是因为实现了对三个运算符的重载使得我们不需要在 CB 类中重写 foo1-foo3 的实现, 以及我们不需要提供特殊的类型转换方法, 而是直接通过运算符的方式就可以转化为 CA 对象的并使用当然一个完整的智能指针的封装不仅仅是对三个运算符的重载, 我们还需要对构造函数拷贝构造赋值运算符类型转化运算符析构函数进行处理如果你要想更加的了解智能指针就请去看看 STL 中的 auto_ptr 类

11. 内存分配和销毁运算符

描述 值
运算符种类 new delete
是否支持类成员 YES
是否支持普通函数 YES
运算单元 N 元
返回类型 new 返回指针, delete 不返回

是的, 你没有看错 C++ 中对内存分配 new 以及内存销毁 delete 也是支持重载的, 也就是说 new 和 delete 也是一种运算符默认情况下 C++ 中的 new 和 delete 都是在堆中进行内存分配和销毁, 有时候我们想对某个类的内存分配方式进行定制化处理, 这时候就需要通过对 new 和 delete 进行重载处理了并且系统规定如果实现了 new 的重载就必须实现 delete 的重载处理关于对内存分配和销毁部分我想单独开辟一篇文章来进行详细介绍这里面就只简单了举例如何来实现 new 和 delete 的重载:

  1. class CA
  2. {
  3.     public:
  4.      CA* operator new(size_t t){  return  malloc(t);}
  5.      void operator delete(void *p) { free(p);}
  6. };

关于对 new 和 delete 运算符的详细介绍请参考文章: C++ 的 new 和 delete 详解

来源: https://juejin.im/post/5a9171306fb9a063557dc6cb


与本文相关文章

  1. JavaScript 之运算符 (一)
  2. 《Inside C#》笔记(十一) 运算符重载
  3. C 语言编程基础入门学习运算符
  4. C++ 运算符重载讲解与经典实例
  5. c语言入门：c++运算符重载
  6. C++学习笔记12：运算符重载（赋值操作符1）
  7. c++位运算符介绍
  8. C 语言编程学习: 逻辑运算符
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1