#include <iostream.h>           /* 演算子のオーバーロード */
class C1
{ public : int a;
//         void       func (int i) { a=i; } ...普通の代入用メンバ関数
           void operator = (int i) { a=i; } // 演算子のオーバーロード　
};
void main()
{ C1 X;     // オブジェクトの宣言 (C1 型の変数の宣言)
  C1 Y;
//X.func(3); ...普通のメンバ関数で代入するとき
  X = 3;    // 代入
  Y = 5;
  cout << X.a << " " << Y.a << endl; // 代入されているか確認　3 5
  int xx; cin >> xx;
}

#include <iostream.h>           /*  二項演算子 ＝  */
class C1
{ public : int a;
//         void       func (int i) { a=i; }
           void operator = (int i) { a=i; }    // 定数を代入する演算子
//         void       func (C1 ob) { a=ob.a; }
           void operator = (C1 ob) { a=ob.a; } // 変数を代入する演算子
};
void main()
{ C1 X;     // オブジェクトの宣言 (変数の宣言)
  C1 Y;
//X.func(5);
  X = 5;    // 定数を代入
//Y.func(X);
  Y = X;    // 変数を代入
  cout << X.a << " " << Y.a << endl; // 代入されているか確認　
  int xx; cin >> xx;
}

#include <iostream.h> // cout を使うために必要           /* 文字列の代入 */
#include <string.h>   // strcpy() を使うために必要
class C1
{ public :
   char s[50];   // データメンバ (ここに文字列を格納)
// void       func (char *p) { strcpy(s,p); }          // *p を s[50] にコピー
   void operator = (char *p) { strcpy(s,p); }          // 定数を代入
// void       func (C1 ob) { strcpy(s,(char *)ob.s); } // ob.s を s[50] にコピー
   void operator = (C1 ob) { strcpy(this->s,ob.s); }   // 変数を代入
};
void main()
{ C1 X, Y;       // オブジェクト X と Y の宣言 (変数の宣言)
//X.func("ABC"); // ABC を、X.s[50] にコピー
  X="ABC";
//Y.func(X);     // Y.s[50] に、X.s[50] をコピー
  Y=X;
  cout << X.s << " " << Y.s << endl; // 代入されているか確認　ABC ABC　
  int xx; cin >> xx;
}

#include <iostream.h>          /*  Y=++X  */
class C1
{ public :
   int x;      // データメンバ 
   void operator =(int i){ x=i;}      // 定数の代入
   void operator =(C1 ob){ x=ob.x;}   // 変数の代入
//        int       func (){ x=x+2; return x; } // 普通のメンバ関数
//        int operator ++(){ x=x+2; return x; } // 演算子で呼び出せるように変更。
   friend int operator ++(C1 &ob)     // フレンド関数
   { ob.x=ob.x+2;    // x を +2 する
     return ob.x;    // x を返す
   }
};
void main()
{ C1 X, Y;     // オブジェクト X と Y の宣言 (変数の宣言)
  X=10;        // X.x に 10 を代入
  Y=++X;       // X.x を +2 し、Y.x に代入
  cout << X.x << ' ' << Y.x << endl; // 確認　X.x=12, Y.x=12
  int q; cin >> q;
}

#include <iostream.h>          /*  Y=X++  */
class C1
{ public :
   int x, h; C1 *p;   // データメンバ 
   void operator =(int i){ x=i;}       // 定数の代入 ( X=10; で呼び出されます)
   void operator =(C1 ob)              // 変数の代入 ( Y=X++; で呼び出されます)
                  { x=ob.x;
                    p=this; // オブジェクト Y のポインタを p に保存
                  }
   friend int operator ++(C1 &ob, int) // フレンド関数　後置演算子++
   { ob.p->h = ob.x;      // x を h に保存
     ob.x = ob.x+2;       // x を +2 する
     return ob.p->h;      // 保存しておいた h を返す
   }
};
void main()
{ C1 X, Y;       // オブジェクト X と Y の宣言 (変数の宣言)
  X=10; 
  Y=X++;   // X を +2 し、Y に代入
  // Y= では、オブジェクトのポインタがに保存されます。 X++ の返り値を待って、10 が代入されます。
  // X++ で X=12 になります。この返り値は加算前の 10
  cout << X.x << ' ' << Y.x << endl; // 確認　X.x=12, Y.x=10　
  int q; cin >> q;
}

#include <iostream.h>          /* Y=10+X */
class C1
{ public :
   int x; C1 *p;   // データメンバ 
   void operator =(int i){ x=i;}        // 定数の代入 ( X=5; で呼び出されます)
   void operator =(C1 ob){ x=ob.x; }    // 変数の代入 ( Y=10+X; で呼び出されます)
   friend int operator +(int i, C1 &ob) // フレンド関数　定数加算演算子 ＋
   { return ob.p->x+i; }
};
void main()
{ C1 X, Y;       // オブジェクト X と Y の宣言 (変数の宣言)
  X=5;           // X.x に 5 を代入
  Y=10+X;        // Y.x に 10+X を代入
  // Y= では、10+X の返り値を待って、15 が代入されます。
  // 10+X の返り値 p->x+i は 15 です。X.x の値は 5 のままです。
  cout << X.x << ' ' << Y.x << endl; // 確認　X.x=5, Y.x=15　
  int q; cin >> q;
}