関数の overload と同様に 演算子 を overload( 拡張 )する仕組み
    C++ では 同一の関数名でも, 引数が違えば 定義できる
    ただし 返値 のみが異なる場合は無理かも
    ( gcc では可能 )

  POINT
    使いどころは、よく使う関数を短い記述で書くときに使う。
    表記は演算子だが、関数がコールされる。( 表現の問題 )

    vec3 x, y, z;
    z = x.add( y );
    
    // 演算子をオーバーロードすると簡単かつ直感的にかける
    z = x + y;

    vec3::operator +( const vec3 &rhs )
    vec3::add( const vec3 &rhs )



  WARNING: 
    operator->() は禁止. 
       class T{
          public:
           T* operator->(){ return this; }
           int Fuga(){ return 4; } 
       };

       // 中略
       void main()
       {
         Hoge hoge;          // この定義と矛盾して見える. 
         printf("%d\n", hoge->Fuga() ); // 4 hoge の定義と離れていたら悪夢
       }

  WARNING 
    // operator=() は ちょうど 1 ARG が必要
     void operator=( int i );

    operator= の signature は 現在 2 つある. ( 組み込み型と同様にふるまうようにするには, 自身の参照をかえす. )

   Cls &operator=( const Cls &);

      次は operator=() が call されない. なぜかわかる.  ? 
      
      {
    Foo f1;

    // CopyCtor が走るらしい. ( CMP /Od にしても発生. -> 要は CopyCtor と同じ意味. ? )
    Foo f2 = f1;    // Call されない. 

    // OK
    Foo f2;
    f2 = f1;
      }




  POINT
    Foo f = 10; ->  f(10); に変換される
      -> Foo( int ) がないと cmp におこられる. 
      -> メタファーとしては, char *str[] = {"aa", "bb", "cc" };
    1 引数のみは Foo = 10; のような記述できる
    引数をひとつだけとる ctor のことを，“変換コンストラクタ（converting constructor）”という



  POINT
    left operand は暗黙として this pointer で渡される
  WARNING 
    演算子が受け取る param list 数の変更は不可

    +  : nr = 2
    ++ : nr = 1


  POINT
    通常の演算子と同様に動作することを保障すべき

  class integer{
    int val;
    
  public :
    int operator +( integer obj ){
      return this->val + obj.val;
    }
  }


___
■ operator++

class point{
public :
  int x, y;
  void operator ++( int n ){    // 後置を表現する prototype
    x++; y++;
  }
  point operator ++(){      // 前置
    x++; y++;
    return *this;
  }
}


  POINT
  default 後置 increment は値を返却 -> increment
    int val = 3;
    int foo =  val++; // foo = 3;

  point o1, o2;
  o2 = ++o1;
  o2++;


___
■ operator[]

  添え字演算子
    class array{
      int arr[2];
    public
      int & operator []( int n ){
        return arr[ n ];        // これで参照を返すことになる ? 
      }
    }




___
■ operator()

  SYNTAX 
    void operator()()

  DESC
    Functor と言われるクラスがもつメソッド
    関数のフリをしたクラスに使う。

    class Foo
    {
     public:
      void operator()() { 
          printf("fucntor\n");
      }
    }; 

    {
      Foo f;
      f();
    }


___
■ operator=.代入演算子


    member 変数をすべてコピーする。
    コンパイラが自動生成。

___
■ operator< < 

   DESC
     operator< < (a, b) == a< < b

    ostream& operator< <  (ostream& o, const fraction &n ) throw()
    {
      return o < <  n.nr < <  "/" < <  n.denom;
    }


___
■ operator ++

  SYNTAX
    T& operator++()

  DESC
    前置インクリメント演算子
    この式は先にインクリメントする前の値を返すこと。


    class Number {
      Number & operator++() {  
        m_i ++;
        return m_i;
      }

      int m_i;
    };
    




___
■ operator ++(int)

  SYNTAX
    T operator++(int)

  DESC
    後置インクリメント演算子
    この式はインクリメントした後の値を返すこと。


    class Number {
      Number operator++(int) {  
      // ここでコピーコンストラクタが発生する
        Number old = *this;
        m_i ++;
        return old;
      }

      int m_i;
    };