#include <iostream.h>                /* 関数の中にオブジェクトを構築 */
class C1        // クラス C1 の宣言
{ private: int a;
  public: C1(int i) { a=i; }                  // コンストラクタ
          void func1() { cout << a << endl; } // 表示用のメンバ関数
};

class C2   // クラス C2 の宣言
{ public:
  void func2()
  { C1 OB(5);   // クラス C1 のオブジェクトを宣言　
    OB.func1(); // クラス C1 のメンバ関数を呼び出し
  }
};
// クラス C1 を、C2 のメンバとしてではなく、そのまま使っています。
// オブジェクト OB は、関数 func1 の動作が終了すると消去されます。

void main()
{ C2 OB2;      // クラス C2 のオブジェクトを宣言
  OB2.func2(); // クラス C2 のメンバ関数を呼び出し
  cout << "文字を入力して下さい"; char x; cin >> x;
}

#include <iostream.h>          /* メンバオブジェクト(メンバイニシャライザなし) */
class C1  // クラス C1 の宣言
{ private: int a;
  public: void set(int i) { a=i; }            // 代入用のメンバ関数
          void func1() { cout << a << endl; } // 表示用のメンバ関数
};

class C2  // クラス C2 の宣言
{ public:
  C1 OB;  // メンバオブジェクトを宣言(クラス C1 のオブジェクト)
   // クラス C1 のデフォルトコンストラクタが呼び出されます。
   // メンバの宣言なので引数付のコンストラクタは使用できません。
  void func2()
  { OB.C1::set(5);  // クラス C1 のメンバ関数を呼び出します。
    OB.C1::func1(); // 　　〃
  }
};
// オブジェクト OB は、クラス C2 のオブジェクト(OB2)が構築されるときに作られ、
// クラス C2 のオブジェクト(OB2)が消滅するときに消去されます。

void main()
{ C2 OB2;      // クラス C2 のオブジェクトを宣言
  OB2.func2(); // クラス C2 のメンバ関数を呼び出し
  cout << "文字を入力して下さい"; char x; cin >> x;
}

#include <iostream.h>           /* メンバオブジェクト(メンバイニシャライザあり) */
class C1  // クラス C1 の宣言
{ private: int a;
  public: C1(int i) { a=i; }                  // コンストラクタ
          void func1() { cout << a << endl; } // 表示用のメンバ関数
};

class C2  // クラス C2 の宣言
{ public:
  int b;    // メンバデータ
  C1 OB;    // メンバオブジェクトを宣言(クラス C1 のオブジェクト)
  C2()      // コンストラクタ(デフォルトコンストラクタ)
  : OB(5),b(7) // メンバイニシャライザ
  { cout << "コンストラクタ C2 が呼び出されました" << endl; }
   // OB(5)の基本イニシャライザは、C1 のコンストラクタを呼び出します。
   // b(7)のイニシャライザは、メンバ b を 7 で初期化します。
   // コンストラクタ C2 は、クラス C2 のオブジェクトを作る他に、以上の動作をします。
  void func2()
  { OB.C1::func1();    // クラス C1 のメンバ関数を呼び出します。(表示)
    cout << b << endl; // メンバ b の値を表示します。
  }
};

void main()
{ C2 OB2;      // クラス C2 のオブジェクトを宣言
  OB2.func2(); // クラス C2 のメンバ関数を呼び出し
  cout << "文字を入力して下さい"; char x; cin >> x;
}

#include <iostream.h>           /* グローバルオブジェクト */


class C1  // クラス C1 の宣言
{ private: int a;
  public: C1(int i) { a=i; }                  // コンストラクタ
          void func1() { cout << a << endl; } // 表示用のメンバ関数　
} OB(5);   // グローバルオブジェクト OB を宣言
C1 OB3(2); //　　〃　　　OB3
// オブジェクト OB と OB3 は、プログラムが終了するまで消去されません。

class C2  // クラス C2 の宣言
{ public:
  void func2()
  { OB.C1::func1(); } // クラス C1 のメンバ関数を呼び出します。
};
void main( )
{ C2 OB2;      // クラス C2 のオブジェクトを宣言
  OB2.func2(); // クラス C2 のメンバ関数を呼び出し
  char q; cin >> q;
}

#include <iostream.h>               /* スタティックオブジェクト */
class C1        // クラス C1 の宣言
{ private: int a;
  public: C1(int i) { a=i; }                  // コンストラクタ
          void func1() { cout << a << endl; } // 表示用のメンバ関数
          void funcA() { a=a+1; }             // a を +1 するメンバ関数
};

C1 *p;     // ポインタ変数 p を宣言(グローバル変数)
// この p にスタティックオブジェクトのポインタを格納します。
　
class C2   // クラス C2 の宣言
{ public:
  void func_S()
  { static C1 OB(5); // スタティックオブジェクトを宣言( C1 のオブジェクト)
  // スタティックオブジェクトは、プログラムが終了するまで消去されません。
    p=&OB;           // スタティックオブジェクトのポインタを p に格納　
  }
  void func2()
  { p->func1(); // クラス C1 のメンバ関数を呼び出し(表示)
    p->funcA(); //　　〃　　　　　　(a を +1 する。)
  }
};

void main()
{ C2 func_S(); // クラス C2 のオブジェクトを宣言
  OB2.func2(); // クラス C2 のメンバ関数を呼び出し
  // オブジェクト OB は、関数 func2 の動作が終了してもそのまま残っています。
  OB2.func2(); // クラス C2 のメンバ関数を再び呼び出し
  // func2() を呼び出すたびに a の値が +1 されていて、
  // オブジェクトがそのまま残っていることがわかります。
  cout << "文字を入力して下さい"; char x; cin >> x;
}

#include <iostream.h>               /* オブジェクトの配列 */
class C1        // クラス C1 の宣言
{ private: int a; int b;
  public: C1(int i,int j) { a=i; b=j; }            // コンストラクタ
          void func1() { cout<<a<<" "<< b<<endl; } // 表示用のメンバ関数
};

class C2   // クラス C2 の宣言
{ public:
  void func2()
  { C1 OBa(2,5);              // クラス C1 のオブジェクトを宣言　
    C1 OBb[3]={C1(1,2),C1(3,4),C1(5,6)}; // オブジェクトの配列を宣言　
    // この場合はプライベートデータメンバなので、配列全体を初期化します。
    // パブリックデータメンバなら、最初の一部だけの初期化が可能です。
    OBb[0].func1(); // クラス C1 のメンバ関数を呼び出し
  }
};

void main()
{ C2 OB2;      // クラス C2 のオブジェクトを宣言
  OB2.func2(); // クラス C2 のメンバ関数を呼び出し
  cout << "文字を入力して下さい"; char x; cin >> x;
}

#include <iostream.h>               /* 代入禁止オブジェクト */
class C1        // クラス C1 の宣言
{ public: int a;
          C1(int i){ a=i; }                      // コンストラクタ
          void func()const{ cout << a << endl; } // 表示用のメンバ関数　
          // const オブジェクトで使う関数はあらかじめ const を書いておきます。
};

class C2   // クラス C2 の宣言
{ public:
  void funcA()
  { C1 OBa(5);       // クラス C1 のオブジェクトを宣言　
    OBa.a=3;         // パブリックメンバには別な値を代入できます。
    OBa.func();      // クラス C1 のメンバ関数を呼び出し(表示)
    // const メンバ関数は、代入可能オブジェクトにもそのまま使用できます。
  }
  void funcB()
  { const C1 OBb(7); // const オブジェクトを宣言　
    // パブリックメンバでも const と宣言したオブジェクトのメンバには
    // 別な値を代入することはできません。
    OBb.func();      // クラス C1 のメンバ関数を呼び出し(表示)
  }
};

void main()
{ C2 OB2;      // クラス C2 のオブジェクトを宣言
  OB2.funcA(); // クラス C2 のメンバ関数を呼び出し
  OB2.funcB(); //　　〃
  cout << "文字を入力して下さい"; char x; cin >> x;
}

#include <iostream.h>          /* コピーコンストラクタ */


class C1        // クラス C1 の宣言
{ private: int a;
  public: C1(int i) { a=i; }                  // コンストラクタ
  public: C1(C1 ob) { a=ob.a; }               // コピーコンストラクタ
  // 仮引数 ob に既存オブジェクトがコピーされます。(ob は後で消滅します。)
  // ob.a の値を、新しく構築するオブジェクトのメンバ a にコピーします。
  // メンバ関数は同じだからコピーする必要はありません。
          void func1() { cout << a << endl; } // 表示用のメンバ関数
};

class C2   // クラス C2 の宣言
{ public:
  void func2()
  { C1 OBa(5);     // クラス C1 のオブジェクト OBa を宣言　
    C1 OBb(OBa);   // OBa のコピー OBb を宣言　
    OB.func1();    // クラス C1 のメンバ関数を呼び出し(表示)
  }
};

void main()
{ C2 OB2;      // クラス C2 のオブジェクトを宣言
  OB2.func2(); // クラス C2 のメンバ関数を呼び出し
  cout << "文字を入力して下さい"; char x; cin >> x;
}