新标准C++程序设计读书笔记_运算符重载

形式

返回值类型 operator 运算符（形参表）
{
    ……
}

运算符重载

（1）运算符重载的实质是函数重载
（2）可以重载为普通函数，也可以重载为成员函数

 class Complex
 {
 public:
     double real,imag;
     Complex( double r = 0.0, double i= 0.0 ):real(r),imag(i) { }
     Complex operator-(const Complex & c);
 };

 Complex operator+( const Complex & a, const Complex & b)
 {
     return Complex( a.real + b.real, a.imag + b.imag); //返回一个临时对象
 }

 Complex Complex::operator-(const Complex & c)
 {
     return Complex(real - c.real, imag - c.imag); //返回一个临时对象
 }

 int main()
 {
     Complex a(,),b(,),c;

     //等价于c=operator+(a,b);
     c = a + b;
     cout << c.real << "," << c.imag << endl;

     //a-b等价于a.operator-(b)
     cout << (a - b).real << "," << (a - b).imag << endl;
     return ;
 }

（3）把含运算符的表达式转换成对运算符函数的调用
（4）把运算符的操作数转换成运算符函数的参数
（5）运算符被多次重载时，根据实参的类型决定调用哪个运算符函数
（6）重载为成员函数时， 参数个数为运算符目数减一；重载为普通函数时， 参数个数为运算符目数

赋值运算符 ‘ =’重载

赋值运算符“ =”只能重载为成员函数

 #include <iostream>

 using namespace std;

 class String
 {
 private:
     char * str;
 public:
     String ():str(new char[]) { str[] = ;}
     const char * c_str() { return str; };
     String & operator = (const char * s);
     String::~String( ) { delete [] str; }
 };

 String & String::operator = (const char * s)
 {
     //重载“=”以使得 obj = “hello”能够成立
     delete [] str;
     str = new char[strlen(s)+];
     strcpy( str, s);
     return * this;
 }

 int main()
 {
     String s;
     s = "Good Luck," ; //等价于 s.operator=("Good Luck,");
     cout << s.c_str() << endl;

     /* 这条语句要是不注释掉就会出错，因为这是一个初始化语句而并不是赋值语句 */
     // String s2 = "hello!"; 

     s = "Shenzhou 8!"; //等价于 s.operator=("Shenzhou 8!");
     cout << s.c_str() << endl;
     return ;
 }

浅拷贝和深拷贝

考察下面的代码

 String S1, S2;
 S1 = “this”;
 S2 = “that”;
 S1 = S2;

如果还用上面的运算符重载，那就会出现问题

（1）如不定义自己的赋值运算符，那么S1=S2实际上导致 S1.str和 S2.str指向同一地方。
（2）如果S1对象消亡，析构函数将释放S1.str指向的空间，再访问S2的时候就好玩儿了。
（3）另外，如果执行 S1 = "other"；会导致S2.str指向的地方被delete

因此，要做如下修改：

 String & operator = (const String & s)
 {
     if( this == & s)
         return * this;

     delete [] str;
     str = new char[strlen(s.str)+];
     strcpy( str,s.str);
     return * this;
 }

ps：详细完成一个完整的String类，后续再补充

运算符重载为友元函数

一般情况下，将运算符重载为类的成员函数，是较好的选择。但有时，重载为成员函数不能满足使用要求，重载为普通函数，又不能访问类的私有成员，所以需要将运算符重载为友元。

 class Complex
 {
     double real,imag;
 public:
     Complex( double r, double i):real(r),imag(i){ };
     Complex operator+( double r );
 };

 Complex Complex::operator+( double r )
 {
     //能解释 c+5
     return Complex(real + r,imag);
 }

上面的类中重载的加号有局限性

Complex c ;
c = c + 5; //有定义，相当于 c = c.operator +(5);
但是：
c = 5 + c; //编译出错

为了使得上述的表达式能成立，需要将 + 重载为普通函数。但是普通函数又不能访问私有成员，所以，需要将运算符 + 重载为友元。

 class Complex
 {
     double real,imag;
 public:
     Complex( double r, double i):real(r),imag(i){ };
     Complex operator+( double r );
     friend Complex operator + (double r,const Complex & c);
 };

 Complex Complex::operator+( double r )
 {
     //能解释 c+5
     return Complex(real + r,imag);
 }

 Complex operator+ (double r,const Complex & c)
 {
     //能解释 5+c
     return Complex( c.real + r, c.imag);
 }

设计一个变长数组类

想要达到下面目的

 int main()
 {
     CArray a; //开始里的数组是空的
     /*
         要用动态分配的内存来存放数组元素，需要一个指针成员变量
      */
     for( int i = ;i < ;++i)
         a.push_back(i);

     CArray a2,a3;
     /*
         要重载“=”
      */
     a2 = a;
     for( int i = ; i < a.length(); ++i )
         /*
             要重载“[ ]”
          */
         cout << a2[i] << " " ;

     a2 = a3; //a2是空的
     for( int i = ; i < a2.length(); ++i ) //a2.length()返回0
         cout << a2[i] << " ";
     cout << endl;

     a[] = ;
     /*
         要自己写复制构造函数
      */
     CArray a4(a);
     for( int i = ; i < a4.length(); ++i )
         cout << a4[i] << " ";

     return ;
 }

类的设计如下：

 class CArray {
     int size; //数组元素的个数
     int *ptr; //指向动态分配的数组
 public:
     CArray(int s = ); //s代表数组元素的个数
     CArray(CArray & a);
     ~CArray();
     void push_back(int v); //用于在数组尾部添加一个元素v
     CArray & operator=( const CArray & a);
     //用于数组对象间的赋值
     int length() { return size; } //返回数组元素个数
     int & CArray::operator[](int i) //返回值为 int 不行!不支持 a[i] = 4
     {
         //用以支持根据下标访问数组元素，
         // 如n = a[i] 和a[i] = 4; 这样的语句
         return ptr[i];
     }
 };

 CArray::CArray(int s):size(s)
 {
     if( s == )
         ptr = NULL;
     else
         ptr = new int[s];
 }

 CArray::CArray(CArray & a)
 {
     if( !a.ptr) {
         ptr = NULL;
         size = ;
         return;
     }
     ptr = new int[a.size];
     memcpy( ptr, a.ptr, sizeof(int ) * a.size);
     size = a.size;
 }

 CArray::~CArray()
 {
     if( ptr) delete [] ptr;
 }

 CArray & CArray::operator=( const CArray & a)
 {
     //赋值号的作用是使“=”左边对象里存放的数组，大小和内容都和右边的对象一样
     if( ptr == a.ptr) //防止a=a这样的赋值导致出错
         return * this;

     if( a.ptr == NULL) { //如果a里面的数组是空的
         if( ptr )
             delete [] ptr;
         ptr = NULL;
         size = ;
         return * this;
     }

     if( size < a.size) { //如果原有空间够大，就不用分配新的空间
         if(ptr)
             delete [] ptr;
         ptr = new int[a.size];
     }

     memcpy( ptr, a.ptr, sizeof(int) * a.size);
     size = a.size;
     return * this;
 } 

 void CArray::push_back(int v)
 {
     //在数组尾部添加一个元素
     if( ptr) {
         int * tmpPtr = new int[size + ]; //重新分配空间
         memcpy(tmpPtr, ptr, sizeof(int) * size); //拷贝原数组内容
         delete [] ptr;
         ptr = tmpPtr;
     }
     else //数组本来是空的
         ptr = new int[];

     ptr[size++] = v; //加入新的数组元素
 }

流运算符的重载

假定c是Complex复数类的对象，现在希望写“ cout << c;”，就能以“ a+bi”的形式输出c的值，写“ cin>>c;”，就能从键盘接受“ a+bi”形式的输入，并且使得c.real = a,c.imag = b。

 class Complex
 {
     double real,imag;
 public:
     Complex( double r=, double i=):real(r),imag(i){ };
     friend ostream & operator<<( ostream & os, const Complex & c);
     friend istream & operator>>( istream & is,Complex & c);
 };

 ostream & operator<<( ostream & os,const Complex & c)
 {
     os << c.real << "+" << c.imag << "i"; //以"a+bi"的形式输出
     return os;
 }

 istream & operator>>( istream & is,Complex & c)
 {
     string s;
     is >> s; //将"a+bi"作为字符串读入, “a+bi” 中间不能有空格
     int pos = s.find("+", );
     string sTmp = s.substr(, pos); //分离出代表实部的字符串
     c.real = atof(sTmp.c_str()); //atof库函数能将const char*指针指向的内容转换成 float
     sTmp = s.substr(pos+, s.length()-pos-); //分离出代表虚部的字符串
     c.imag = atof(sTmp.c_str());
     return is;
 }

类型转换运算符

类型强制转换运算符被重载时不能写返回值类型，实际上其返回值类型就是该类型强制转换运算符代表的类型

 #include <iostream>
 using namespace std;
 class Complex
 {
     double real,imag;
 public:
     Complex(double r=,double i=):real(r),imag(i) { };
     //重载强制类型转换运算符 double
     operator double () { return real; }

 };

 int main()
 {
     Complex c(1.2,3.4);
     cout << (double)c << endl; //输出 1.2
     double n =  + c; //等价于 double n=2+c.operator double()
     cout << n; //输出 3.2
 }

自增，自减运算符的重载

1、前置运算符作为一元运算符重载
（1）重载为成员函数：
T & operator++();
T & operator--();
（2）重载为全局函数：
T1 & operator++(T2);
T1 & operator—(T2);

2、后置运算符作为二元运算符重载，多写一个没用的参数
（1）重载为成员函数：
T operator++(int);
T operator--(int);
（2）重载为全局函数：
T1 operator++(T2,int );
T1 operator—( T2,int);

 class CDemo
 {
 private:
     int n;
 public:
     CDemo(int i=):n(i) { }
     CDemo & operator++(); //用于前置形式
     CDemo operator++( int ); //用于后置形式
     operator int ( ) { return n; }
     friend CDemo & operator--(CDemo & );
     friend CDemo operator--(CDemo & ,int);
 };

 CDemo & CDemo::operator++()
 {
     //前置 ++
     n++;
     return * this;
 } // ++s即为: s.operator++();

 CDemo CDemo::operator++( int k )
 {
     //后置 ++
     CDemo tmp(* this); //记录修改前的对象
     n++;
     return tmp; //返回修改前的对象
 } // s++即为: s.operator++(0);

 CDemo & operator--(CDemo & d)
 {
     //前置--
     d.n--;
     return d;
 } //--s即为: operator--(s);

 CDemo operator--(CDemo & d,int)
 {
     //后置--
     CDemo tmp(d);
     d.n--;
     return tmp;
 } //s--即为: operator--(s, 0);

 int main()
 {
     CDemo d();
     cout << (d++ ) << ","; //等价于 d.operator++(0);
     cout << d << ",";
     cout << (++d) << ","; //等价于 d.operator++();
     cout << d << endl;
     cout << (d-- ) << ","; //等价于 operator--(d,0);
     cout << d << ",";
     cout << (--d) << ","; //等价于 operator--(d);
     cout << d << endl;
     return ;
 }

运算符重载的注意事项
（1）C++不允许定义新的运算符 ；
（2）重载后运算符的含义应该符合日常习惯；
complex_a + complex_b
word_a > word_b
date_b = date_a + n
（3）运算符重载不改变运算符的优先级；
（4）以下运算符不能被重载：“.” 、“.*” 、“::” 、“?:” 、 sizeof；
（5）重载运算符()、 []、 ->或者赋值运算符=时，运算符重载函数必须声明为类的成员函数。