操作符重载

• 双目操作符重载

• 单目操作符重载

• 操作符++和–的重载

实现途径

• operator #
• “#”代表任意可重载的操作符

//成员函数
class Complex
{ public:
  Complex operator + (const Complex& x) const
  { Complex temp;
   temp.real = real+x.real;
   temp.imag = imag+x.imag;
   return temp;
  }
    ......
};

//全局函数
class Complex
{ ......
 friend Complex operator + (const Complex& c1, 
                const Complex& c2);
};
Complex operator + (const Complex& c1, 
            const Complex& c2)
{ Complex temp;
 temp.real = c1.real + c2.real;
 temp.imag = c1.imag + c2.imag;
 return temp;
}
……
Complex a(1.0,2.0),b(3.0,4.0),c;
c = a + b;

基本原则

• 只能重载C++语言中已有的操作符，不可臆造新的操作符
• 不能重载 . .* ?: :: sizeof
• 不能改变操作数个数。
• 不改变原操作符的优先级和结合性

双目操作符重载

成员变量函数

class <类名>
{ ......
 <返回值类型> operator # (<类型>); //#代表可重载的操作符
};
<返回值类型> <类名>::operator # (<类型> <参数>) { ...... }

<类名> a;
<类型> b;

a # b
a.operator#(b)	//两种都可以

全局函数

<返回值类型> operator #(<类型1> <参数1>,
            		  <类型2> <参数2>) 
{……}
//<类型1>和<类型2>中至少应该有一个是类、结构、枚举或它们的引用类型

单目操作符重载

• 作为成员函数重载
• 作为全局（友元）函数重载

操作符++和–的重载

class Counter
{  int value;
 public:
  Counter() { value = 0; }
  Counter& operator ++()  //前置的++重载函数 ++a
  { value++;
   return *this;
  }
  const Counter operator ++(int)  //后置的++重载函数 a++
  { Counter temp=*this; //保存原来的对象
   value++; //写成：++(*this);更好！调用前置的++重载函数
   return temp; //返回原来的对象
  }
};
.....
Counter a,b,c;
++a;  //使用的是不带参数的操作符++重载函数
a++;  //使用的是带int型参数的操作符++重载函数
b = ++a;  //加一之后的a赋值给b
c = a++;  //加一之前的a赋值给c
++(++a);或 (++a)++; //OK，a加2
++(a++);或 (a++)++; //Error，编译不通过

重载操作符new

• 操作符new必须作为静态的成员函数来重载（static说明可以不写），其格式为：

  void *operator new(size_t size);

• 返回类型必须为void *

• 参数size表示对象所需空间的大小，其类型为size_t

#include <cstring>
class A
{  int x,y;
 public:
  void *operator new(size_t size)
  { void *p=malloc(size); //调用系统堆空间分配操作。
   memset(p,0,size); //把申请到的堆空间初始化为全“0”。
   return p;
  }
  ......
};
//把动态对象初始化为全‘0’

重载delete

• 操作符delete也必须作为静态的成员函数来重载（static说明可以不写），其格式为：

  void operator delete(void *p, size_t size);

• 返回类型必须为void

• 第一个参数类型为void *，指向对象的内存空间

• 第二个参数可有可无，如果有，则必须是size_t类型。