Thinking again in C++（四）运算符重载形式推导

                          Thinking again in C++（四）运算符重载形式推导

    关键字：C++,运算符,operator,重载,overload,形式推导

                          大前提

    定理：自定义类型不要毫无价值地与内建类型不兼容（Effective C++ 2e）。这个定理是本篇所有内容的理论基础，可见它的重要性。但我无法证明，只是从直觉上认为它是正确的，如果允许的话，我更乐意把它称为公理。

                          小前提

    内建类型的运算符串链规则：
     int a=1,b=2,c=3;
     a=(b+=c);     //[A]     ok
     (b+=c)=a;     //[B]     ok
     (a+b)=c;      //[C]     error
     (a=b)=c;      //[D]     ok
     (++a)=b;      //[E]     ok
     (a++)=b;      //[F]     error

                          结论

    成员函数版运算符重载的声明形式：
     class Arrow
     {
     private:
          double x;
          double y;
     public:
          Arrow & operator+=(const Arrow & r);            //[1]
          const Arrow operator+(const Arrow & r) const;   //[2]
          double operator*(const Arrow & r) const;        //[3]
          Arrow & operator=(const Arrow & r);             //[4]
          Arrow & operator++();                           //[5]
          const Arrow operator++(int);                    //[6]
     };
    Arrow的真实含义是矢量，也就是数学中有大小和方向的量，本来英文名应该是vector，但STL中已经有了同名但不同义的东西，为以示区别就取了这个不伦不类的名字。对这个类来说，++运算符没有意义，另外，赋值运算符使用编译器的默认版本即可，写它们纯粹是起示例作用。

                          推导手段

    通过合理使用const修饰符和引用，使重载运算符的行为同内建类型一致。

                          单个解析

    [1]由于[A][B]的关系，+=运算符的返回值应能够被改写，所以传回*this的引用。
     Arrow & Arrow::operator+=(const Arrow & r)
     {
          x += r.x;
          y += r.y;
          return *this;
     }

    [2]+运算符不改变左操作数，所以函数为const性质。+的结果存放在函数的local对象中，出于安全上的考虑，local对象不能作为引用返回，又因为[C]的关系，所以传回local对象的const拷贝。
     const Arrow Arrow::operator+(const Arrow & r) const
     {
          return Arrow(x+r.x,y+r.y);
     }
    Arrow的构造器省略。

    [3]内建类型的返回值被编译器约定不能作左值，此时可省略返回值的const。其他同[2]。
     double Arrow::operator*(const Arrow & r) const
     {
          return x*r.x+y*r.y;
     }
    矢量相乘得到它们的内积，内积是数而不是矢量。

    [4]由于[D]的关系，同[1]。
     Arrow & Arrow::operator=(const Arrow & r)
     {
          x = r.x;
          y = r.y;
          return *this;
     }

    [5]自增运算符的前缀版本返回改变后的对象，又由于[E]的关系，所以传回*this的引用。
     Arrow & Arrow::operator++()
     {
          //...
          return *this;
     }

    [6]自增运算符的后缀版本返回改变前的对象，所以必须建立一个local对象保存原状态，于是函数返回值同[2]。
     const Arrow Arrow::operator++(int)
     {
          Arrow arr(*this);
          //...
          return arr;
     }

                          逆推

    从[1][4][5]的实现可以看到，我们能够自然提供[A][B][D][E]，同时保证足够的严谨。而对于[2]，不存在安全的手段，让形如[C]的式子通过编译。还有，为什么内建类型的串链规则[E][F]有如此微妙的差异，从[5][6]可以看出来，因为函数可以安全地返回改变后的对象，却无法安全地返回改变前的对象。
    这些都增加了大前提定理的可信度，小前提也显得更加合理。

后记：
1.限于篇幅，这里只列出了最简单的运算符重载，省略了很多关于复杂、特种运算符的讨论。
2.+、*这类二元运算符最好采用非成员形式，也就是友元形式。
如果希望看到进一步的讨论，我会再写一点。