C++：运算符重载函数之"++"、"--"、"[ ]"、"=="的应用

 对于前缀方式++ob，可以用运算符函数重载为：
            ob.operator++()         //成员函数重载
         或
            operator++(X &ob)       //友元函数重载,其中ob为类X的对象的引用 
            
           
          对于后缀方式++ob，可以用运算符函数重载为：
            ob.operator++(int)      //成员函数重载
         或
            operator++(X &ob,int)   //友元函数重载,其中ob为类X的对象的引用 
            
         调用时，参数int一般被传递给值0，例如：
         class X{
           ...
           public:
           ...
            X operator++();         //前缀方式 
            X operator++(int);      //后缀方式
         };
         int main()
         {
           X ob;
           ...
           ++ob;                //隐式调用ob.operator++() 
           ob++;                //隐式调用ob.operator++(int)
           ob.operator++();     //显式调用ob.operator++()，意为++ob 
           ob.operator++(0);    //显式调用ob.operator++(int),意为ob++
         }
         
         类似的，也可以重载为友元函数，例如：
         
         class Y{
           ...
           public:
           ...
            firend Y operator++(Y &);         //前缀方式 
            friend Y operator++(Y &,int);      //后缀方式
         };
         int main()
         {
           Y ob;
           ...
           ++ob;                //隐式调用ob.operator++(Y&) 
           ob++;                //隐式调用ob.operator++(Y&,int)
           operator++(ob);      //显式调用ob.operator++(Y&)，意为++ob 
           operator++(ob,0);    //显式调用ob.operator++(Y&,int),意为ob++
         }

#include<iostream>
using namespace std;
class Three{
  public:
   Three(int I1=0,int I2=0,int I3=0)
   {
    i1 = I1;
    i2 = I2;
    i3 = I3;
   }
   Three operator--();              //声明自减运算符--重载成员函数(前缀方式) 
   Three operator--(int a);        //声明自减运算符--重载成员函数(后缀方式)
   void show(); 
  private:
   int i1,i2,i3;
};
Three Three::operator--()           //定义自减运算符--重载成员函数(前缀方式)
{
  --i1;
  --i2;
  --i3;
  return *this;   //返回自减后的当前对象 
}
Three Three::operator--(int a)          //定义自减运算符--重载成员函数(后缀方式)
{
  Three temp(*this);    
  i1--;
  i2--;
  i3--;
  return temp;  //返回自减前的当前对象
} 
void Three::show()
{
 cout<<"i1="<<i1<<",";
 cout<<"i2="<<i2<<",";
 cout<<"i3="<<i3<<endl;
}
int main()
{
 Three t1(4,5,6),t2,t3(11,12,13),t4;
 t1.show();
 
 --t1;                       //隐式调用(前缀方式)
 t1.show();                  //显示执行--t1后的值 
 t2=t1--;                      //隐式调用(后缀方式)，将t1自减前的值赋给t2 
 t2.show();                  //显示t2保存的是执行t1--之前的t1的值 
 t1.show();                  //显示执行t1--之后的t1的值 
 cout<<endl;
 
 t3.show();
 t3.operator--();           //显示调用(前缀方式)
 t3.show(); 
 t4=t3.operator--(0);       //显示调用(后缀方式)
 t4.show();
 t3.show();
 
 return 0; 
}

#include<iostream>
using namespace std;
class Three{
  public:
   Three(int I1=0,int I2=0,int I3=0)
   {
    i1 = I1;
    i2 = I2;
    i3 = I3;
   }
   friend Three operator++(Three &);              //声明自加运算符++重载成员函数(前缀方式) 
   friend Three operator++(Three &,int );         //声明自加运算符++重载成员函数(后缀方式)
   void show(); 
  private:
   int i1,i2,i3;
};
Three operator++(Three &T)                //声明自加运算符++重载友元函数(前缀方式)
{
  ++T.i1;
  ++T.i2;
  ++T.i3;
  return T;   //返回自加后的对象 
}
Three operator++(Three &T,int a)          //声明自加运算符--重载友元函数(后缀方式)
{
  Three temp(T);    
  T.i1++;
  T.i2++;
  T.i3++;
  return temp;  //返回自加前的对象
} 
void Three::show()
{
 cout<<"i1="<<i1<<",";
 cout<<"i2="<<i2<<",";
 cout<<"i3="<<i3<<endl;
}
int main()
{
 Three t1(4,5,6),t2,t3(14,15,16),t4;
 t1.show();
 
 ++t1;                       //隐式调用(前缀方式)
 t1.show();                  //显示执行++t1后的值 
 t2=t1++;                      //隐式调用(后缀方式)，将t1自加前的值赋给t2 
 t2.show();                  //显示t2保存的是执行t1++之前的t1的值 
 t1.show();                  //显示执行t1++之后的t1的值 
 cout<<endl;
 
 t3.show();
 operator++(t3);           //显示调用(前缀方式)
 t3.show(); 
 t4=operator++(t3,0);       //显示调用(后缀方式)
 t4.show();
 t3.show();
 
 return 0; 
}

#include<iostream>
using namespace std;
class Vector4{
 public:
  Vector4(int a1,int a2,int a3,int a4)
  {
   v[0]=a1;
   v[1]=a2;
   v[2]=a3;
   v[3]=a4;
  }
  private:
    int v[4];
}; 
int main()
{
 Vector4 ve(1,2,3,4);
 cout<<v[2];   //运行错误，v[2]是类Vector4的私有成员，即使是公有成员，输出格式应为ve.v[2]; 
 return 0;
}

 可是，如果对[]进行重载，即使v[2]是私有成员，也可以运行成功，直接访问。即：
   int &Vector::operator[](int bi)
   {
       if(bi<0||bi>=4)
       {
       cout<<"Bad subscript!\n";
          exit(1);
       }
       return v[bi];  //v[bi]被解释为v.operator[](2) 
   }

#include<iostream>
using namespace std;
class Vector4{
 public:
  Vector4(int a1,int a2,int a3,int a4)
  {
   v[0]=a1;
   v[1]=a2;
   v[2]=a3;
   v[3]=a4;
  }
  int &operator[](int ); 
  private:
    int v[4];
}; 
int &Vector4::operator[](int bi)  //返回一个int型的引用 
{
  if(bi<0||bi>=4)
   {
    cout<<"Bad subscript!\n";
       exit(1);
   }
  return v[bi];  //v[bi]被解释为v.operator[](2) 
}
int main()
{
 Vector4 v(1,2,3,4);
 int i=0;
 for(;i<4;i++)
 cout<<"v["<<i<<"]="<<v[i]<<"\n";  //v[i]被解释为v.operator[](i); 
 cout<<endl;
 
 v[3]=v[2];        //v[2]被解释为v.operator[](2); 
 cout<<"v[3]="<<v[3]<<endl; //v[3]被解释为v.operator[](3);
 
 v[2]=22;
 cout<<"v[2]="<<v[2]<<endl;
    
 return 0;
}
/*
运行结果： 
v[0]=1
v[1]=2
v[2]=3
v[3]=4

v[3]=3
v[2]=22
*/

#include<iostream>
using namespace std;
class STRING{
  public:
   STRING(char* s)
   {
    cout<<"Constructor called."<<endl;
    pt = new char(strlen(s)+1);
    strcpy(pt,s); 
   }
   ~STRING()
   {
    cout<<"Destructor called."<<pt<<endl;
    delete pt;
   }
  private:
   char* pt;
};
int main()
{
 STRING p1("book");
 STRING p2("jeep");
 p2=p1;
 return 0;
}

#include<iostream>
using namespace std;
class STRING{
  public:
   STRING(char* s)
   {
    cout<<"Constructor called."<<endl;
    pt = new char(strlen(s)+1);
    strcpy(pt,s); 
   }
   STRING &operator=(const STRING &s);     //声明赋值运算符重载函数 
   ~STRING()
   {
    cout<<"Destructor called."<<pt<<endl;
    delete pt;
   }
  private:
   char* pt;
};
STRING &STRING::operator=(const STRING &s) //定义赋值运算符重载函数 
{
  if(this==&s)  return *this;         //防止s=s的赋值 
  delete pt;                          //释放掉原区域 
  pt = new char(strlen(s.pt)+1);      //分配新区域 
  strcpy(pt,s.pt);                    //字符串复制 
  return *this;
}
int main()
{
 STRING p1("book");
 STRING p2("jeep");
 p2=p1;
 return 0;
}