运算符重载

• 运算符重载实际上是通过定义一个函数来实现的

  运算符重载归根结底是函数的重载，编译器选择重载的运算符是遵循函数重载的选择原则，即按不同类型或个数的参数来选择不同的重载运算符。

• 运算符重载应符合使用习惯，便于理解

• 运算符重载不能创造新的运算符号

• 运算符重载要保持原运算符的下述特性不变

  • 优先级和结合性不变

  • 操作个数不变

  • 语法结构不变

C++ 中，运算符重载是通过运算符重载函数实现的，运算符重载函数一般采用以下两种形式之一

• 成员函数形式

• 友元函数形式

  	成员函数形式	友元函数形式
  单目运算	隐式：对象 显式：对象.operator()	隐式：对象 显式：operator(对象)
  双目运算	隐式：对象A#对象B 显式：对象A.operator(对象B)	隐式：对象A#对象B 显式：operator(对象A, 对象B)

1. 成员函数形式运算符操作

   参考语法形式

   <函数类型> <类名>::operator<符号>(参数表) {
   	//相对该类而定义的操作（运算符重载函数体）
   }

   参数表列出该运算符需要的操作数。单目运算参数表中无参数，调用该函数的对象为操作数。双目运算参数表中有一个参数，调用该函数的对象为第一操作数，参数表中的参数为第二操作数。

   #include<iostream>
   using namespace std;
   class CCounter {
   public:
   	CCounter() {
   		m_nValue = 0;
   	}
   	void operator++() {
   		if (m_nValue < 65535)
   			m_nValue++;
   	}
   	int operator*() {
   		return m_nValue;
   	}
   private:
   	int m_nValue;
   };
   int main()
   {
   	CCounter objCounter;
   	++objCounter;
   	objCounter.operator++();//单目运算符
   	cout << *objCounter << endl;
   	objCounter.operator*();
   	return 0;
   }

   class CCounter {
   private:
   	int m_nValue;
   public:
   	CCounter(int nNum) {
   		m_nValue = nNum;
   	}
   	void operator+(CCounter &obj) {
   		m_nValue += obj.m_nValue;
   	}
   	int operator*() {
   		return m_nValue;
   	}
   };
   int main()
   {
   	CCounter objCounterA(5), objCounterB(5);
   	objCounterA + objCounterB;
   	objCounterA.operator+(objCounterB);//双目运算符
   
   	cout << *objCounterA << endl;//输出objCounterA的值
   	objCounterA.operator*();
   
   	cout << *objCounterB << endl;//输出objCounterB的值
   	objCounterB.operator*();
   
   	return 0;
   }

2. 友元函数形式运算符重载

   单目运算符：

   class CCounter {
   public:
   	CCounter() {
   		m_nValue = 0;
   	}
   	friend void operator++(CCounter &obj) {
   		if (obj.m_nValue < 65535)
   			obj.m_nValue++;
   	}
   	int operator*() {
   		return m_nValue;
   	}
   private:
   	int m_nValue;
   };
   int main()
   {
   	CCounter objCounter;
   	++objCounter;
   	operator++(objCounter);
   	cout << *objCounter << endl;
   	objCounter.operator*();
   	return 0;
   }

   双目运算符：

   class CCounter {
   private:
   	int m_nValue;
   public:
   	CCounter(int nNum) {
   		m_nValue = nNum;
   	}
   	friend void operator+(CCounter &objA, CCounter objB) {
   		objA.m_nValue += objB.m_nValue;
   	}
   	friend int operator*(CCounter obj) {
   		return obj.m_nValue;
   	}
   };
   int main()
   {
   	CCounter objCounterA(5), objCounterB(5);
   	objCounterA + objCounterB;
   	operator+(objCounterA, objCounterB);
   
   	cout << *objCounterA << endl;//输出objCounterA的值
   	operator*(objCounterA);
   
   	cout << *objCounterB << endl;//输出objCounterB的值
   	operator*(objCounterB);
   
   	return 0;
   }

3. 特殊符号的重载

   等号的重载：

   class CCounter {
   private:
   	int m_nValue;
   public:
   	CCounter(int nNum) {
   		m_nValue = nNum;
   	}
   	CCounter(CCounter &obj) {
   		m_nValue = obj.m_nValue;
   	}
   	CCounter& operator=(CCounter &obj) {
   		m_nValue = obj.m_nValue;
   		return *this;
   	}
   	int operator*() {
   		return m_nValue;
   	}
   };
   int main()
   {
   	CCounter objA(15), objB(5);
   	objA = objB;
   	cout << *objA << endl;
   	objA.operator*();
   	return 0;
   }

   数组的重载：

   class CCounter {
   private:
   	int m_nValue[15];
   public:
   	CCounter() {
   		for (int i = 0; i < 15; i++)
   			m_nValue[i] = i;
   	}
   	
   	int operator[](int nCount) {
   		return m_nValue[nCount];
   	}
   };
   int main()
   {
   	CCounter objA;
   	for(int i = 0; i < 15; i++)
   		cout << objA[i] << " ";
   	return 0;
   }

   输入输出的重载

   class CCounter {
   private:
   	char m_szStr[15];//输入的字符最后一个是0
   public:
   	CCounter() {
   		memset(m_szStr, 0, sizeof(m_szStr));
   	}
   	friend ostream& operator<<(ostream& output, CCounter &obj) {//输出
   		output << obj.m_szStr;
   		return output;
   	}
   
   	friend istream& operator>>(istream& input, CCounter &obj) {//输入
   		input.getline(obj.m_szStr, 15);
   		return input;
   	}
   };
   int main()
   {
   	CCounter obj;
   	cin >> obj;
   	cout << obj;
   	return 0;
   }