0、重载一元操作符的方法
一元运算符即只需要一个操作用的运算符，如取地址运算符(&)、复数(-)、自减(--)、自加(++)等。
运算符重载可以分为3种方式：类的非静态成员函数、类的友元函数、普通函数。
例如有 1 个操作数 a，一元运算符 ? (表示一个一元运算符)，a? 或者?a 的操作会被解释为下面2种形式之一
//a? or ?a
a.operator?(); //类的非静态成员函数
operator？(a); //友元函数 和 普通函数
第一种形式是运算符被重载为类的非静态成员函数，没有参数。
这种方式要求操作数(即a)必须是一个对象，operator？是这个对象的非静态成员函数，
第二种形式是运算符被重载为类的友元函数 或 普通函数，有1个参数。
重载为 类的友元函数 和 普通函数的区别是 类的友元函数可以直接访问类的私有成员，而普通函数不可以。
1、重载++、--（前置 和 后置）
自增运算符（++）和 自减运算符（--）都有 前置 和 后置 2中情况。
C++中为了区分前置和后置规定：前置重载与普通运算符重载一致，后置重载需要在参数列表中加入一个无用的参数。
++/-- 的3种重载方式如下: 前置的情况可以返回类的引用,后置的情况只能返回临时对象。
//类的非静态成员函数
class X
{
X& operator++(){...} //前置++
X operator++(int){...} //后置++ X& operator--(){...} //前置--
X operator--(int){...} //后置--
}
/*-----------------------------------------------------*/
//类的友元函数
class X
{
friend X& operator++(X& ref){...} //前置++
friend X operator++(X& ref, int){...} //后置++ friend X& operator--(X& ref){...} //前置--
friend X operator--(X& ref, int){...} //后置--
}
/*-----------------------------------------------------*/
//普通函数
class X
{
...
}
X& operator++(X& ref){...} //前置++
X operator++(X& ref, int){...} //后置++ X& operator--(X& ref){...} //前置--
X operator--(X& ref, int){...} //后置--
下例中有3个Counter类 CounterA、CounterB 和CounterC，3个类都重载了前置++、-- 和后置++、--。
其中CounterA使用类的非静态成员函数方式重载，CounterB使用类的友元函数方式重载，CounterC使用普通函数方式重载。
#include <iostream>
using namespace std; class CounterA
{
public:
//默认构造函数（Default constructor）
CounterA(){cout<<"Default Constructor"<<endl;}
//带参数的构造函数(The constructor with parameters)
CounterA(int m):n(m){cout<<"Parameter Constructor"<<endl;}
//拷贝构造函数（Copy constructor）
CounterA(const CounterA& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
//析构函数(destructor)
~CounterA(){cout<<"Destructor"<<endl;} //重载运算符 ++（前置)
const CounterA& operator++(){++n; return *this;}
//重载运算符 ++（后置）
const CounterA operator++(int dump){CounterA Tmp(*this);++n; return Tmp;}
//重载运算符 --（前置）
const CounterA& operator--(){--n; return *this;}
//重载运算符 --（后置）
const CounterA operator--(int dump){CounterA Tmp(*this);--n; return Tmp;} //输出用函数
void display(void){cout<<"n = " << n << endl;}
//GetData
int GetVal(void){return n;} private:
int n;
}; class CounterB
{
public:
//默认构造函数（Default constructor）
CounterB(){cout<<"Default Constructor"<<endl;}
//带参数的构造函数(The constructor with parameters)
CounterB(int m):n(m){cout<<"Parameter Constructor"<<endl;}
//拷贝构造函数（Copy constructor）
CounterB(const CounterB& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
//析构函数(destructor)
~CounterB(){cout<<"Destructor"<<endl;} //重载运算符 ++（前置)
friend const CounterB& operator++(CounterB& ref){ref.n += ;return ref;}
//重载运算符 ++（后置）
friend const CounterB operator++(CounterB& ref, int dump){CounterB Tmp(ref);ref.n += ; return Tmp;}
//重载运算符 --（前置）
friend const CounterB& operator--(CounterB& ref){ref.n -= ;return ref;}
//重载运算符 --（后置）
friend const CounterB operator--(CounterB& ref, int dump){CounterB Tmp(ref);ref.n -= ; return Tmp;} //输出用函数
void display(void){cout<<"n = " << n << endl;}
//GetData
int GetVal(void){return n;}
//SetData
void SetVal(int val){n = val;} private:
int n;
}; class CounterC
{
public:
//默认构造函数（Default constructor）
CounterC(){cout<<"Default Constructor"<<endl;}
//带参数的构造函数(The constructor with parameters)
CounterC(int m):n(m){cout<<"Parameter Constructor"<<endl;}
//拷贝构造函数（Copy constructor）
CounterC(const CounterC& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
//析构函数(destructor)
~CounterC(){cout<<"Destructor"<<endl;} //输出用函数
void display(void){cout<<"n = " << n << endl;}
//GetData
int GetVal(void){return n;}
//SetData
void SetVal(int val){n = val;} private:
int n;
};
//重载运算符 ++（前置)
const CounterC& operator++(CounterC& ref){ref.SetVal(ref.GetVal()+);return ref;}
//重载运算符 ++（后置）
const CounterC operator++(CounterC& ref, int dump){CounterC Tmp(ref);ref.SetVal(ref.GetVal()+); return Tmp;}
//重载运算符 --（前置）
const CounterC& operator--(CounterC& ref){ref.SetVal(ref.GetVal()-);return ref;}
//重载运算符 --（后置）
const CounterC operator--(CounterC& ref, int dump){CounterC Tmp(ref);ref.SetVal(ref.GetVal()-); return Tmp;} int main(void)
{
CounterA cp1();cp1.display();
++cp1;cp1.display();
--cp1;cp1.display();
CounterA cp2(cp1++);cp2.display();
CounterA cp3(cp1--);cp3.display(); CounterB cp4();cp4.display();
++cp4;cp4.display();
--cp4;cp4.display();
CounterB cp5(cp4++);cp5.display();
CounterB cp6(cp4--);cp6.display(); CounterC cp7();cp7.display();
++cp7;cp7.display();
--cp7;cp7.display();
CounterC cp8(cp7++);cp8.display();
CounterC cp9(cp7--);cp9.display(); return ;
}
2、重载负号（-）
下例中有3个Complex类 ComplexA、ComplexB 和ComplexC，3个类都重载了负号。
其中ComplexA使用类的非静态成员函数方式重载，ComplexB使用类的友元函数方式重载，ComplexC使用普通函数方式重载。
#include <iostream>
using namespace std; class ComplexA
{
public:
//constructor
ComplexA(double re, double im):real(re),image(im){}
//Operator Overload : -
ComplexA operator-(){return ComplexA(-real, -image);}
//display
void display(void){if (image>)cout<<real<<"+"<<image<<endl;else cout<<real<<image<<endl;} private:
double real;
double image;
}; class ComplexB
{
public:
//constructor
ComplexB(double re, double im):real(re),image(im){}
//Operator Overload : -
friend ComplexB operator-(ComplexB& ref){return ComplexB(-ref.real, -ref.image);}
//display
void display(void){if (image>)cout<<real<<"+"<<image<<endl;else cout<<real<<image<<endl;}
private:
double real;
double image;
}; class ComplexC
{
public:
//constructor
ComplexC(double re, double im):real(re),image(im){}
//GetData
double GetReal(void){return real;}
double GetImage(void){return image;}
//display
void display(void){if (image>)cout<<real<<"+"<<image<<endl;else cout<<real<<image<<endl;} private:
double real;
double image;
}; //Operator Overload : -
ComplexC operator-(ComplexC& ref){return ComplexC(-ref.GetReal(), -ref.GetImage());} int main(void)
{
ComplexA a1(,);a1.display();
ComplexA a2(-a1);a2.display(); ComplexB b1(,);b1.display();
ComplexB b2(-b1);b2.display(); ComplexC c1(,);c1.display();
ComplexC c2(-c1);c2.display(); return ;
}