1:  class Integer {

   2:      int _val;

   3:  public:

   4:      Integer(int val = 0) : _val(val) {}

   5:      

   6:      // 二元运算符重载为成员函数

   7:      const Integer operator+(const Integer& i) const {

   8:              return Integer(_val + i._val);

   9:      }

  10:      // 二元运算符重载为友元函数 

  11:      friend const Integer operator-(const Integer& ,const Integer&);

  12:  };

  13:  const Integer operator-(const Integer& l,const Integer& r) {

  14:      return Integer(l._val-r._val);

  15:  }

  16:   

  17:  Integer a(40), b(12);

  18:   

  19:  a+b;       

  20:  a+1;    //  正确, 左操作数为Integer对象, +按照Integer的成员函数解析右操作数为1, 进行自动类型转换

  21:  1+a;    //  错误, 左操作数为1, +按照常规操作符解析, 而右操作符为Integer对象,1无法进行转化 

  22:  a-b;    //  正确       

  23:  a-1;    //  正确

  24:  1-a;    //  正确, 左操作数为1, 而右操作符为Integer对象,-作为Integer的一个友元函数,1被转化为Integer对象

   1:  class Example{

   2:  public:

   3:  Example(int i,int j) { _x = i; _y = j;}

   4:  // 前缀形式(++i)重载的时候没有虚参,通过引用返回*this,也就是返回变化之后的数值

   5:  const Example& Example::operator++ () {

   6:            ++_x;

   7:            ++_y;

   8:            return *this;

   9:  }

  10:  // 后缀形式(i++)重载的时候有一个int类型的虚参, 返回原状态的拷贝

  11:  const Example Example::operator++ (int) {

  12:              Example tmp(*this);

  13:              ++_x;

  14:              ++_y;

  15:              return tmp;    

  16:  }

  17:  int _x, _y;        

  18:  };

  19:   

因为下标运算符可以出现在=的左边或右边,因此它的返回值必须是个左值,一般是把返回值指定为一个引用。而为了能访问const对象，下标运算符重载有非const和const两个版本。

   1:  class Array {

   2:  public:

   3:      Array(int size) : _size(size) { _val = new int[_size];}

   4:      int& operator[] (int index) { return _val[index]; }

   5:      const int& operator[] (int index) const { return _val[index]; }

   6:  private:    

   7:      int _size;

   8:      int* _val;

   9:  };

  10:  Array array_a(10);

  11:  array_a[0] = 1;  // []的重载版本有非const版本

   1:  class A

   2:  {

   3:  private:

   4:      int a,b;

   5:  public:

   6:      A(int na = 0, int nb = 0):a(na), b(nb){}

   7:      friend istream& operator>>(istream& is, A& aa);

   8:      friend ostream& operator<<(ostream& os, const A& aa);

   9:   

  10:  };

  11:  ostream& operator<<(ostream& os, const A& aa) {

  12:      os << aa.a << " " << aa.b;

  13:      return os;

  14:  }

  15:   

  16:  istream& operator>>(istream& is, A& aa) {

  17:      is >> aa.a >> aa.b;

  18:      return is;

  19:  }