C++运算符重载学习总结

在C ++中，咱们可使运算符适用于用户定义的类。 这意味着C ++可以为运算符提供数据类型的特殊含义，这种能力称为运算符重载。

例如，咱们能够在像String这样的类中重载运算符'+'，这样咱们就能够经过使用+来链接两个字符串。

其它示例中算术运算符能够重载的的类是复数，小数，大整数等。

运算符重载的语法格式：

Return_Type classname :: operator op(Argument list)

{

    Function Body

}

在上面的语法中，Return_Type是要返回给另外一个对象的值类型，operator op是运算符是关键字的函数，op是要重载的运算符。

运算符函数必须是非静态（成员函数）或友元函数。

运算符重载能够经过三种方法完成，它们是

1)      重载一元运算符。

2)      重载二元运算符。

3)      使用友元函数重载二元运算符。

 

如下是定义运算符函数的一些条件/规则：

l  在非静态函数的状况下，二元运算符应该只有一个参数，而一元不该该有一个参数。

l  在友元函数的状况下，二元运算符应该只有两个参数，而一元应该只有一个参数。

l  若是实现了运算符重载，则全部类成员对象都应该是公共的。

 

运算符函数和普通函数有什么区别？

运算符函数与普通函数相同。 惟一的区别是，运算符函数的名称始终是operator关键字，后跟运算符符号，而且在使用相应的运算符时调用运算符函数。

 

除了极个别的运算符外，大部分运算符均可以被重载。

如下是能够重载的运算符列表：

如下是不能够重载的运算符列表：

为何（点），::，？：和sizeof不能够重载看这里解释。

 

关于运算符重载的重要方面：

1）为了使操做符重载起做用，其中一个操做数必须是用户定义的类对象。

2）赋值运算符：编译器自动为每一个类建立一个默认赋值运算符。 默认赋值运算符确实将右侧的全部成员分配到左侧，而且在大多数状况下都能正常工做（此行为与复制构造函数相同）。

3）转换运算符：咱们还能够编写可用于将一种类型转换为另外一种类型的转换运算符。重载的转换运算符必须是成员方法。 其余运算符能够是成员方法或全局方法。

4）任何能够用单个参数调用的构造函数均可以用做转换构造函数，这意味着它也能够用于隐式转换为正在构造的类。

 

综合例子：学习测试，仅供参考！

OperatorOverloadingClass.h

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

#ifndef  OPERATOROVERLOADINGCLASS_H #define  OPERATOROVERLOADINGCLASS_H #include  <iostream> using   namespace  std; const   int  SIZE =  10 ; class  OperatorOverloadingClass { public :     OperatorOverloadingClass();     OperatorOverloadingClass( const   int  &number,                               const   float  &fnumber);      // 赋值运算符      void   operator  = ( const  OperatorOverloadingClass &obj)     {         m_number = obj.m_number;     }      // 函数调用()运算符     OperatorOverloadingClass  operator ()( int  a,  int  b,  int  c)     {         OperatorOverloadingClass D;          // just put random calculation         D.m_number = a + b + c;          return  D;     }      void  print();      /* OperatorOverloading     */      // 算术运算符      // +     OperatorOverloadingClass  operator  + ( const  OperatorOverloadingClass &obj);      // -     OperatorOverloadingClass  operator  - ( const  OperatorOverloadingClass &obj);      // *     OperatorOverloadingClass  operator  * ( const  OperatorOverloadingClass &obj);      // /     OperatorOverloadingClass  operator  / ( const  OperatorOverloadingClass &obj);      // %     OperatorOverloadingClass  operator  % ( const  OperatorOverloadingClass &obj);      // 关系运算符      // <      bool   operator  < ( const  OperatorOverloadingClass &obj);      // >      bool   operator  > ( const  OperatorOverloadingClass &obj);      // <=      bool   operator  <= ( const  OperatorOverloadingClass &obj);      // >=      bool   operator  >= ( const  OperatorOverloadingClass &obj);      // ==      bool   operator  == ( const  OperatorOverloadingClass &obj);      // !=      bool   operator  != ( const  OperatorOverloadingClass &obj);      // 位运算符      // ^     OperatorOverloadingClass  operator  ^ ( const  OperatorOverloadingClass &obj);      // &     OperatorOverloadingClass  operator  & ( const  OperatorOverloadingClass &obj);      // |     OperatorOverloadingClass  operator  | ( const  OperatorOverloadingClass &obj);      // 逻辑运算符      // &&      bool   operator  && ( const  OperatorOverloadingClass &obj);      // ||      bool   operator  || ( const  OperatorOverloadingClass &obj);      // 取地址运算符&      int  * operator  &()     {          return  & this ->m_number;     }      // 内存操做运算符*      int   operator  *(OperatorOverloadingClass *obj)     {          return  obj->m_number;     }      // 输入输出运算符      // <<      friend  ostream & operator <<(ostream &output,  const  OperatorOverloadingClass &obj )     {         output <<  "number : "  << obj.m_number;          return  output;     }      // >>      friend  istream & operator >>(istream &input, OperatorOverloadingClass &obj)     {         input >> obj.m_number;          return  input;     }      // 自增自减运算符      // ++i     OperatorOverloadingClass  operator  ++();      // i++     OperatorOverloadingClass  operator  ++( int );      // --i     OperatorOverloadingClass  operator  --();      // i--     OperatorOverloadingClass  operator  --( int );      // 数组成员访问运算符[]      int  & operator []( int  i)     {          if ( i > SIZE )         {             cout <<  "Index out of bounds"  << endl;              // return first element.              return  arr[ 0 ];         }          return  arr[i];     }      // 类成员访问运算符->      // https://www.cnblogs.com/codingmengmeng/p/9064702.html      // 复合赋值运算符：+=、-=、*=、/=、%=、<<=、>>=、^=、&=、|=      void   operator  += ( const  OperatorOverloadingClass &obj)     {         m_number += obj.m_number;     }      // 其他相似      // 重载类型转换      operator   int ()     {          return  m_number;     }      operator   float ()     {          return  m_fnumber;     }      // new delete      void  * operator   new (size_t size);      void   operator   delete ( void  *p);      void  * operator   new [](size_t size);      void   operator   delete []( void  *p, size_t size); private :      int      m_number;      float    m_fnumber;      int      arr[SIZE]; }; #endif   // OPERATOROVERLOADINGCLASS_H

 OperatorOverloadingClass.cpp

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212

#include   "OperatorOverloadingClass.h" #include  <QDebug> OperatorOverloadingClass::OperatorOverloadingClass() {     m_number =  0 ;     m_fnumber =  0 . 0 ;      for ( int  i =  0 ; i < SIZE; i++)     {         arr[i] = i;     } } OperatorOverloadingClass::OperatorOverloadingClass( const   int  &number,          const   float  &fnumber)     : m_number(number)     , m_fnumber(fnumber) {      for ( int  i =  0 ; i < SIZE; i++)     {         arr[i] = i;     } } void  OperatorOverloadingClass::print() {     qDebug() <<  "m_number ="  << m_number; } OperatorOverloadingClass OperatorOverloadingClass:: operator  +( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number =  this ->m_number + obj.m_number;      return  out; } OperatorOverloadingClass OperatorOverloadingClass:: operator  -( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number =  this ->m_number - obj.m_number;      return  out; } OperatorOverloadingClass OperatorOverloadingClass:: operator  *( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number =  this ->m_number * obj.m_number;      return  out; } OperatorOverloadingClass OperatorOverloadingClass:: operator  /( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number =  this ->m_number / obj.m_number;      return  out; } OperatorOverloadingClass OperatorOverloadingClass:: operator  %( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number =  this ->m_number % obj.m_number;      return  out; } OperatorOverloadingClass OperatorOverloadingClass:: operator  ^( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number = ( this ->m_number) ^ (obj.m_number);      return  out; } OperatorOverloadingClass OperatorOverloadingClass:: operator  &( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number = ( this ->m_number) & (obj.m_number);      return  out; } OperatorOverloadingClass OperatorOverloadingClass:: operator  |( const  OperatorOverloadingClass &obj) {     OperatorOverloadingClass out;     out.m_number = ( this ->m_number) | (obj.m_number);      return  out; } bool  OperatorOverloadingClass:: operator  &&( const  OperatorOverloadingClass &obj) {      return  ( this ->m_number) && (obj.m_number); } bool  OperatorOverloadingClass:: operator  ||( const  OperatorOverloadingClass &obj) {      return  ( this ->m_number) || (obj.m_number); } bool  OperatorOverloadingClass:: operator  <( const  OperatorOverloadingClass &obj) {      if (m_number < obj.m_number)     {          return   true ;     }      return   false ; } bool  OperatorOverloadingClass:: operator  >( const  OperatorOverloadingClass &obj) {      if (m_number > obj.m_number)     {          return   true ;     }      return   false ; } bool  OperatorOverloadingClass:: operator  <=( const  OperatorOverloadingClass &obj) {      if (m_number <= obj.m_number)     {          return   true ;     }      return   false ; } bool  OperatorOverloadingClass:: operator  >=( const  OperatorOverloadingClass &obj) {      if (m_number >= obj.m_number)     {          return   true ;     }      return   false ; } bool  OperatorOverloadingClass:: operator  ==( const  OperatorOverloadingClass &obj) {      if (m_number == obj.m_number)     {          return   true ;     }      return   false ; } bool  OperatorOverloadingClass:: operator  !=( const  OperatorOverloadingClass &obj) {      if (m_number != obj.m_number)     {          return   true ;     }      return   false ; } // overloaded prefix ++ operator OperatorOverloadingClass OperatorOverloadingClass::  operator ++ () {     ++m_number;           // increment this object      return  OperatorOverloadingClass(m_number,  0 . 0 ); } // overloaded postfix ++ operator OperatorOverloadingClass OperatorOverloadingClass::  operator ++(  int  ) {      // save the orignal value     OperatorOverloadingClass T(m_number,  0 . 0 );      // increment this object     ++m_number;      // return old original value      return  T; } // overloaded prefix -- operator OperatorOverloadingClass OperatorOverloadingClass::  operator -- () {     --m_number;           // increment this object      return  OperatorOverloadingClass(m_number,  0 . 0 ); } // overloaded postfix -- operator OperatorOverloadingClass OperatorOverloadingClass::  operator --(  int  ) {      // save the orignal value     OperatorOverloadingClass T(m_number,  0 . 0 );      // increment this object     --m_number;      // return old original value      return  T; } void  *OperatorOverloadingClass:: operator   new (size_t size) {      return  malloc(size); } void  OperatorOverloadingClass:: operator   delete ( void  *p) {     free(p); } inline   void  *OperatorOverloadingClass:: operator   new [](size_t size) {     OperatorOverloadingClass *p = (OperatorOverloadingClass *)malloc(size);      return  p; } inline   void  OperatorOverloadingClass:: operator   delete []( void  *p, size_t size) {     free(p); }