l VisualC クラス(一覧)_1 '97. 7.00
l.お知らせ 内容 LINK FILE   HTML Win PC Unix MS-DOS C C++ Mfc Java 
目次.C++言語_ 1 クラス 2 派生クラス 5 演算子のオーバーロード クラス(1)
 準備 3 オブジェクト 6 テンプレート 8 etc クラス(2)
 CC++ 4 フレンド・多重継承 7 メモリ確保・例外処理 未使用
クラスの基本型   アクセス指定子   メンバデータ   メンバ関数(クラスの中に記述)   メンバ関数(クラスの外に記述)   メンバ関数の呼び出し   関数のオーバーロード   仮想関数   純粋仮想関数と抽象クラス   メンバオブジェクト   メンバイニシャライザ   オブジェクトの宣言   コピーコンストラクタ   this ポインタ   フレンド関数   多重継承と仮想クラス  

以下のコード例はコピーできます。(コード部分に全角スペースを含みません。)
用例 C1 =クラス名  OB =オブジェクト名(ob =引数)  func() =関数名  a x 変数名 /**/ =省略


T クラスの基本型   基本クラス 派生クラス フレンドクラス
class C1 { public : int a }; // 基本クラス C1
 
class C2 : public C1 // 派生クラス C2 (基本クラスは C1) public/private/protected
{ private : /**/     // メンバデータの宣言/定義        public/private/protected
  public :  /**/     // メンバ関数の宣言/定義
  friend class C3;   // フレンドクラスの指定
};
class C3 { /**/ };  // C2 のフレンドクラス C3 (C2 の private メンバにアクセス可)
// クラスの中に関数の定義をすると inline の指定をしなくてもインライン関数になる。
// フレンドクラス C3 はアクセスが許可されるだけで、派生クラスとは別。
T アクセス指定子
クラスのメンバを、どこからならアクセスを許すかを指定する。
public : どこからでもアクセスできます。
private : そのクラスのメンバ関数だけがアクセスできます。
protected : そのクラスと派生クラスのメンバ関数だけがアクセスできます。


T メンバデータ
public : int a; // メンバデータの宣言
public : static int b; // スタティックメンバデータの宣言
// スタティックメンバ変数は、グローバル変数を、クラスのメンバにします。
// 従って次のように、{クラス}の後に必要なグローバル変数を書きます。
int C1:: b; // クラス C1 で使用するグローバル変数の宣言

T メンバ関数 {クラス}の中の記述
C2 () { }
~C2 () { }
void func1 () { a=1; }
// デフォルトコンストラクタの宣言/{定義}(インライン関数)
// デストラクタの宣言/{定義}(インライン関数)
//
メンバ関数の宣言/{定義}(インライン関数)
// クラスの中に関数の定義をすると、inline の指定をしなくてもインライン関数になる。
C2(int x);
void
func2 ();
inline
void func3 ();
void
inline func3 ();
void
func4 () const;
static
void func5 ();
// コンストラクタの宣言(オーバーロード = 同名関数の宣言) 
//
メンバ関数の宣言
//
メンバ関数の宣言 (インライン関数)
//
(ふたつの書式があります)
//
メンバ関数の宣言 (const 関数)
//
メンバ関数の宣言 (static メンバだけを扱う場合)

T メンバ関数 {クラス}の外に記述   (クラス名も記述します。)
C2::C2(int x) { a=1; }
void C2::func2() { a=1; }
inline void C2::func3() { a=10; }
void inline C2::func3() { a=10; }
void C2::func4() const { a=2; }
static void C2::func5() { a=1; }
// コンストラクタの定義
// メンバ関数の定義
// メンバ関数の定義(インライン関数)
// (こちらの書式でも可)
// メンバ関数の定義(const 関数)
//
メンバ関数の宣言 (static メンバだけを扱う場合)
// const 関数は、const オブジェクトのメンバデータの、読み出し専用関数。

T メンバ関数の呼び出し   (オブジェクトを指定して呼び出します。)
C2 OB;
C2 OB(35);
C2
<int, char, 5> OB;
C2 <int, char, 5> OB(35);
OB.func1(
);
OB.C2::func2( );
// デフォルトコンストラクタの呼び出し。 ( )は書きません。
// 引数があるコンストラクタの呼び出し
//
テンプレート化クラスのコンストラクタの呼び出し
//  〃
//
その他のメンバ関数の呼び出し
// 〃 (クラスの指定を明確にするとき)

T 関数のオーバーロード
仮引数の、型または数 だけが異なる同じ名前の関数を、複数宣言します。
void func(int a) { cout << a << endl; }
void func(char b){ cout << b << endl; }
int func(int a,int b){ cout << a+b << endl; return a+b; }

T 仮想関数
派生クラスでオーバーライドされることを前提にした、基本クラスのメンバ関数。
派生クラスで基本クラス型のポインタを使うと、メンバ解決演算子を使う必要がなくなる。

virtual void func() { cout << "基本クラスの仮想関数"; }
void func() { cout << "派生クラスでオーバーライド"; }

T 純粋仮想関数と抽象クラス
純粋仮想関数は、定義内容が空の仮想関数。
純粋仮想関数を含むクラスはオブジェクトを作れず、抽象クラスという。

virtual void func()=0;
純粋仮想関数

T メンバオブジェクト
class C2
{
public:
C1 OB;
void func2()
{ OB.C1::func1(); }
};
// クラス C2 の宣言
 
// メンバオブジェクトを宣言(クラス C1 のオブジェクト)
// プライベートメンバは、クラス C1 のメンバ関数で処理します。
 
 

T メンバイニシャライザ   (コンストラクタの、初期化専用の部分)
コンストラクタの引数を使って、メンバデータを初期化します。

C1(int i, int j)
: a(i), b(j), OB(i, j)
{ /**/ }
// コンストラクタ
//  メンバイニシャライザ (メンバオブジェクト OB も初期化する例)
//  その他の定義内容
// メンバオブジェクトの初期化 OB(i, j) では、オブジェクトのクラスのコンストラクタが呼び出される。

T オブジェクトの宣言
C1 OB1;
C1 OB1(55);
C1 OB1[3]={C1(1,2),C1(3,4),C1(5,6) };
static C1 OB1(1,2);
const C1 OB1(1,2);
// 普通のオブジェクト
//  〃
// オブジェクトの配列
// スタティックオブジェクト
// const(代入禁止)オブジェクト

const オブジェクトのメンバを読み出すメンバ関数は、あらかじめ定義しておきます。
void func() const { cout << a << endl; }

関数やクラスの外に宣言したオブジェクトはグローバルオブジェクト。
class C2
{ public :
C1 OB1(1,2);
/**/
} OB21(5) ;
C1
OB22;
// クラス C2 の宣言
 
// メンバオブジェクト
// クラス内のその他の定義
//
グローバルオブジェクト
//  〃


T コピーコンストラクタ
(引数)にオブジェクトを受取って、オブジェクトのコピーを作るためのコンストラクタです。
C1(C1 ob) { a=ob.a; }

T this ポインタ
クラスにデフォルトで用意される、オブジェクトのポインタを保持しているポインタです。

T フレンド関数   (クラスの中に書いたグローバル関数)
 引数にそのクラスのオブジェクトを使うことで、そのクラス用の関数にしているだけです。
 引数は、オブジェクトのポインタや参照でも可。

friend void funcF(C1 ob) { cout << ob.a << endl;} // フレンド関数の宣言
funcF(OB); // フレンド関数の呼び出し (グローバル関数と同じ書式)

T 多重継承と仮想クラス   (複数のクラスを基本クラスにする)
メンバの重複を禁止するには、基本クラスで、その前の基本クラスを virtual に指定します。

class C1{ public: int D1; };
class C2{ public: int D2; };
class C3{ public: int D3; };
// 基本クラス 1
// 基本クラス 2
// 基本クラス 3


class C4 : public C1, public virtual C2 { /**/ }; // C4 には D1 D2 がコピーされます。
class C5 : virtual public C2, public C3 { /**/ }; // C5 には D2 D3 がコピーされます。
// C4 C5 は、基本クラス C2 を仮想クラスに指定して、
// C4 C5 の派生クラス C6 に、同一メンバ D2 の重複コピーを禁止します。
//
class C6 : public C4, public C5 { /**/ }; // C6 には D1 D2 D3 がコピーされます。
// C6 の基本クラス C4 C5 で、C2 を仮想クラスに指定しているので、C2 の D2 は二重コピーされません。
上記で virtual の指定をせず、C6 でさらに同じ名前のメンバを追加したとき、
それらを区別するには基本クラスを記述します。

クラス C6 の D2 を区別する例
OB6.C4::D2=4;
OB6.C5::D2=5;
OB6.C6::D2=6;
...C4 からコピーされた D2 に代入
...C5 からコピーされた D2 〃
...C6 で新しく追加した D2 〃

T

C++言語  クラス(1)  クラス(2)
 
  mtoga@sannet.ne.jp   登録日 '96. 6.15
URL : http://www.page.sannet.ne.jp/mtoga/index.html