1. C++ 言語講習会第 2 回資料
書いた人:@sunaemon0(回路屋 2 年)

2. 1 継承
あるクラスにあるメンバ変数やメンバ関数を受け継いだクラ
スを作ることができます。
継承元のクラスを基底クラス、継承して新たに作られるクラ
スを派生クラスと言います。
list 1 inheritance0.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
# include <iostream >
class A {
public :
int value ;
virtual int f() = 0;
};
class B : public A {
public :
int f() { return 1; }
};
int main(int , char **) {

3. 14
15
16
17
18
19
20
B *b = new b;
A &a = b;
a. value = 1;
std :: cout << b.f_B () << std :: endl;
std :: cout << b.f_A () << std :: endl;
}

4. 前回は private と public しかやりませんでしたが、アクセス
指定子は全部で public, protected, private の三種類あります。
基本的な意味は以下のとおりです。
• public なメンバ変数/メンバ関数は、どこからでもアクセス
できます。
• protected なメンバ変数/メンバ関数は、それが属すクラス
とそれを継承するクラスのメンバ関数とフレンド関数から
アクセスすることができます。
• private なメンバ変数/メンバ関数は、それが属すクラスと
フレンド関数からアクセスすることができます。
実は基底クラスにも public, protected, private の三種類があ
ります。class の場合は特に明示しない場合は暗黙的に

5. private 基底になりま f す。struct なら public 基底になります。
上で述べたのは public 基底の場合の話です。private 基底や
protected 基底は特に普通の設計では使わないので省きます。

6. 2 アップキャスト
list 2 upcast0.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class
class
class
class
Base {};
Derived0 : private Base {};
Derived1 : protected Base {};
Derived2 : public Base {};
int main(int , char **) {
Derived0 d0;
Derived1 d1;
Derived2 d2;
Base &a0 = d0; // error : ‘’ Base is an inaccessible base of ‘’ Derived0
Base &a1 = d1; // error : ‘’ Base is an inaccessible base of ‘’ Derived1
Base &a2 = d2; // OK
}
基底クラスのリファレンスには、派生クラスのインスタンス
を代入することができます。これをアップキャストと言い
ます。

7. ダイアモンド継承を、仮想基底を使わずに行ったりなどの場
合を除けばアップキャストは無条件に成功します。
基底クラスへのリファレンスから派生クラスのリファレンス
へのキャストをダウンキャストと言います
ダウンキャストは常に成功するとは限りません。
dynamic cast や static cast を使う必要があります。

8. 3 仮想関数
list 3 virtual0.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# include <iostream >
class A
public :
int
};
class B
public :
int
};
{
f() { return 0; }
: public A {
f() { return 1; }
int main(int , char **) {
B b;
A a;
A &a0 = b;
A &a1 = a;
std :: cout << b.f() << std :: endl; // 1
std :: cout << a0.f() << std :: endl; // 0
std :: cout << a1.f() << std :: endl; // 0
}
上のように定義した場合は、どのクラスのインスタンスかと

9. いうのには関係なしに、そのリファレンスの型によって呼び
出される関数が決定されます。
list 4 virtual1.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# include <iostream >
class A {
public :
virtual int f() { return 0; }
};
class B : public A {
public :
int f() override { return 1; }
};
int main(int , char **) {
B b;
A a;
A &a0 = b;
A &a1 = a;
std :: cout << b.f() << std :: endl; // 1
std :: cout << a0.f() << std :: endl; // 1
std :: cout << a1.f() << std :: endl; // 0
}

10. 一方、上のように定義した場合は、どのクラスのインスタン
スであるのかによってどの関数が呼ばれるのか変わります。
virtual0 のように基底クラスに非仮想関数 A::f と、その派生
クラスに B::f があるとき B::f は A::f を隠すと言います。
virtual1 のように基底クラスに仮想関数 A::f と、派生クラス
に B::f があり、両者の方が一致するとき、B::f は A::f をオー
バーライドすると言います。
A::f は自動的に仮想関数になります。
この時、B::f に override というキーワードを付けることで
オーバーライドしなかった時にエラーが出るように出来
ます。

11. 4 仮想関数テーブル
gcc などにといてどのように仮想関数が実装されているのか
簡単に説明します。
仮想関数のあるクラスのインスタンスには暗黙的に仮想関数
テーブルへのポインタが含まれます。
仮想関数テーブルには、そのクラスのインスタンスのある仮
想関数が呼ばれた時に実行されて欲しい関数へのポインタな
どを登録してあります。
virtual 関数への呼び出しは、インスタンスの vptr を参照した
後、仮想関数テーブルから呼び出した仮想関数へのアドレス
を取得それを呼び出すことによって行われます。
大体以下のようなことが行われています。

12. list 5 vtable0.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# include <iostream >
int get_value_Base () {
return 1;
}
int get_value_Derived () {
return 2;
}
struct vtbl {
int (* get_value )();
};
vtbl Base_table = { get_value_Base };
vtbl Derived_table = { get_value_Derived };
struct Base {
vtbl *vptr;
Base () {
vptr = & Base_table ;
}
};
struct Derived : Base{
Derived () {
vptr = & Derived_table ;

13. 28
29
30
31
32
33
34
35
36
37
38
39
}
};
int main () {
Derived d;
Base * d_in_b = &d;
Base b;
std :: cout << d.vptr -> get_value () << std :: endl;
// 2
std :: cout << d_in_b ->vptr -> get_value () << std :: endl; // 2
std :: cout << b.vptr -> get_value () << std :: endl;
// 1
}
クラス型へのリファレンスの中に実際どのクラスのインスタ
ンスが入っているのか知りたい時があります。これは実行時
にしかわからないので実行時型情報 (RTTI) と呼ばれます。
RTTI の情報も仮想関数テーブルに載っています。

14. 5 純粋仮想関数
クラスの宣言で=0 が付けられた関数は純粋仮想関数と呼ば
れます。
純粋仮想関数を直接持つか、派生クラスで直接ないし間接的
な基底クラスにある純粋仮想関数を全てオーバーロードしな
い関数は抽象クラスと言います。
抽象クラスでないクラスは具体クラスと言います。
抽象クラスはインスタンスを作ることができません。

15. 6 final
ある仮想関数をオーバーライドされたくない場合、final を付
けることでオーバーライドできなくなります。

16. 7 コンストラクタとデストラクタ
コンストラクタは以下のことを順番に行います。
• 基底クラスのコンストラクタを呼び出す。(多重継承して
いれば左側から、仮想基底クラスについては別のところで
呼ばれていればもう呼ばない)
• vptr を自分のクラスのものに更新。
• メンバ変数のコンストラクタを宣言順に呼ぶ。
• コンストラクタ本体に書いてある処理を実行

17. デストラクタは逆順に行います。
•
•
•
•
vptr を自分のクラスのものに更新。
デストラクタ本体に書いてある処理を実行。
メンバ変数を宣言順と逆順に解体。
基底クラスのコンストラクタを呼び出す。(多重継承して
いれば右側から、仮想基底クラスについては別のところで
呼ばれていればもう呼ばない)

18. あるインスタンスを解体する際、それが属するクラスのデス
トラクタを呼ぶ必要があります。そのため普通デストラクタ
は仮想関数にします。

19. 8 ポリモーフィズム
大事なことなのでもう一度言います。
基底クラスのリファレンスには、派生クラスのインスタンス
を代入することができます。この際型が変わるのでこれを
アップキャストと言います。
つまりクラス型へのリファレンスは中に派生クラスのインス
タンスが入っている可能性があわけです。
これをポリモーフィズムと言います。

20. テンプレートでも似たようなことができますが、テンプレー
トだと型はコンパイル時に決定されます。なのでテンプレー
トを使って同じようなことをするのを静的ポリもーフィズム
と言います、
一方継承の場合、どのような関数が呼び出されるかは実行時
に決定されます。これを動的ポリモーフィズムといいます。
もちろん両者は共存することができます。

21. 9 多重継承と仮想基底
C++ では基底クラスは必ずしも一つではありません。その
結果として、

22. list 6 diamond0.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# include <iostream >
class A
public :
int
};
class B
public :
int
};
class C
public :
int
};
class D
{
f() { return 0; }
:
public A {
f() { return 1; }
: public A {
f() { return 2; }
: public B, public C {
};
int main(int , char **) {
D d;
A &a = d;
std :: cout << d.f() << std :: endl; // ?!
}
このような不思議な状況が発生しえます。継承グラフが木構
造になっていないこのような状況をダイアモンド継承と言い

23. ます。
また、基底には、virtual な基底と virtual でない基底がありま
す。さっきまでやってきたのは virtual でない基底ですが、
virtual な基底にはオーバーロードの決定や、初期化において
闇が潜んでいるのでここではやりません。

24. list 7 diamond1.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# include <iostream >
class A {
public :
virtual int f() { return 0; }
};
class B : virtual public A {
public :
int f() override { return 1; }
};
class C : virtual public A {
public :
int f() override { return 2; }
};
class D : public B, public C {
};
int main(int , char **) {
D d;
A &a = d;
std :: cout << d.f() << std :: endl; // ?!
}

25. 10 例外
C でのエラー通知は、例えば負の値を返すことなどによって
実現されていました。
しかし、これだと以下のように資源管理をちゃんとしようと
すると面倒です。また戻り値をチェックとい本筋の処理と関
係ないコードがあって面倒です。また一つ一つの関数でエ
ラー処理を行なっているため、エラーが起きていない時も大
量の if 文を通過する必要が出てしまっています。
list 8 exception0.cpp
1
2
3
4
5
6
int func(char *a, char *b)
{
if (!a || !b)
throw exception ();
}

26. 7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int dosth () {
char *a, *b;
if (!(a= malloc (10)))
return -1;
if (!(b= malloc (10))) {
free(a);
return -2;
}
if(func(a,b) < 0) {
free(a);
free(b);
return -3;
}
// etc ....
free(a);
free(b);
return 0;
}
それを回避するために C++ では例外を使います。

27. list 9 exception1.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# include <iostream >
# include <exception >
# include <stdexcept >
using namespace std;
int main () {
try {
cerr << "a" << endl;
throw exception ();
cerr << "b" << endl;
// never called
} catch ( exception &e) {
cerr << e.what () << endl;
}
}
throw 式で例外を投げられます。基本的には、std::exception
の派生クラスを投げるようにしてください。
投げられた例外は最も内側の try 文の後ろにある例外ハンド
ラでマッチングされます。例外ハンドラというのは catch 文

28. のことです。
基本的には型が厳密に一致する例外ハンドラが呼び出されま
すが、派生クラスのリファレンスは基底クラスのリファレン
スを受け取る例外ハンドラにマッチします。
catch 文のなかで throw; と書くと今処理している例外を再度
投げられます。これを rethrow と言います。
そのあと制御は最後の catch の後に移ります。

29. 11 スタック巻き戻し
例外は関数の中から外にも投げられます。
詳しく言うと、例外が投げられると、関数を飛び越えて直近
と try ブロックまでジャンプします。
普通ローカル変数のインスタンスは関数から return するとき
に解体されます。
例外処理の場合は return するわけではないですから別の仕組
みで解体を行います。
具体的には try ブロックが呼ばれたところまでスタックを下
ろして、そのインスタンスを解体するという事を行います。
この際デストラクタが呼ばれるのですが、デストラクタ自体

30. が例外を投げた場合スタック巻き戻しが失敗してしまってプ
ログラムが強制終了してしまいます。なのでデストラクタか
らは例外を投げては行けません。

31. 12 RAII
関数内である資源を獲得したとします。
関数の最後にその資源を開放する処理を書いたとしても途中
で例外が投げられた場合その処理は実行されない恐れがあり
ます。
それを避けるため C++ では、資源を管理するためのクラス
を作りコンストラクタでその資源を獲得、デストラクタでそ
の資源を開放するようにした上で、そのクラスのインスタン
スをローカル変数として持つという事が普通行われます。
これこそ前回やった RAII です。

32. 13 演習問題
仮想関数テーブルの大きさを調べよ。