C++の継承：基底クラスと派生クラスを解説

クラスを拡張して再利用する

あなたはコンストラクタでクラスを組み立て、デストラクタで後始末をしてきました。継承はその次のステップです。あるクラスのメンバを別のクラスにコピーする代わりに、新しいクラスが既存のクラスの特殊化された版であると宣言し、すべてを自動的に受け継がせます。

既存のクラスが基底クラス（親）で、新しいクラスが派生クラス（子）です。派生クラスは基底クラスのすべてのデータと振る舞いから出発し、そこに違いとなる部分を追加したり変更したりします。これはC++が「is-a」関係を表現するための主要な道具です。Dog は Animal であり、SavingsAccount は BankAccount です。

基本構文：class Derived : public Base

派生クラス名のあとにコロン、アクセス指定子、基底クラス名を続けることで継承します。最も一般的な形はpublic継承です。

#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
    string name;
    void eat() {
        cout << name << " is eating." << endl;
    }
};

// Dog は Animal である：name と eat() を無料で手に入れる
class Dog : public Animal {
public:
    void bark() {
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog d;
    d.name = "Rex";   // 継承したメンバ
    d.eat();          // 継承したメソッド
    d.bark();         // Dog 独自のメソッド
    return 0;
}

Dog は name も eat() も一切宣言していませんが、どちらも Animal から継承されているため Dog オブジェクトで動作します。派生クラスは、基底クラスがまったく知らない bark() のようなメンバを自由に追加できます。

protected：子クラス専用のメンバ

基底クラスの private メンバは派生クラスの内部からもアクセスできません。継承はカプセル化を壊しません。基底クラスの内部実装を外部からは隠しつつサブクラスには使わせたいときは、アクセス指定子 protected を使います。

#include <iostream>
using namespace std;

class BankAccount {
protected:
    double balance = 0;   // 派生クラスには見えるが、外部からは見えない
public:
    void deposit(double amount) { balance += amount; }
    double getBalance() const { return balance; }
};

class SavingsAccount : public BankAccount {
public:
    void addInterest(double rate) {
        balance += balance * rate;   // OK: protected メンバにここからアクセスできる
    }
};

int main() {
    SavingsAccount s;
    s.deposit(1000);
    s.addInterest(0.05);
    cout << s.getBalance() << endl; // 1050
    // s.balance = 0;   // エラー: protected なので main からはアクセス不可
    return 0;
}

3つのレベルを同心円としてイメージしてください。private は「このクラスだけ」、protected は「このクラスとその子孫」、public は「すべての人」です。全体像についてはアクセス指定子を参照してください。

コンストラクタとデストラクタの順序

派生オブジェクトは基底クラスのサブオブジェクトを内部に含んでおり、派生部分が組み立てられる前に、その基底部分が生きている必要があります。そのため、構築は基底クラスから先に、破棄は派生クラスから先に（ちょうど逆順で）行われます。基底クラスがコンストラクタの引数を必要とする場合は、メンバ初期化リストを通じて渡します。

#include <iostream>
#include <string>
using namespace std;

class Animal {
    string name;
public:
    Animal(string n) : name(n) {
        cout << "Animal ctor: " << name << endl;
    }
    ~Animal() { cout << "Animal dtor: " << name << endl; }
};

class Dog : public Animal {
public:
    // 引数を基底クラスのコンストラクタに転送する
    Dog(string n) : Animal(n) {
        cout << "Dog ctor" << endl;
    }
    ~Dog() { cout << "Dog dtor" << endl; }
};

int main() {
    Dog d("Rex");
    return 0;
}

出力がこの順序を具体的に示します。

Animal ctor: Rex   // 基底クラスが先に構築される
Dog ctor           // 次に派生部分
Dog dtor           // 逆順で破棄される...
Animal dtor: Rex   // ...基底クラスが最後

: Animal(n) を書き忘れ、しかも基底クラスにデフォルトコンストラクタがない場合、コードはコンパイルできません。C++は基底部分をどう組み立てればよいか分からないからです。継承の対象にするつもりの基底クラスは、ほぼ常にデストラクタを宣言すべきです（そして、次のページで示すように、多くの場合は仮想デストラクタを）。

オーバーライド：基底クラスのメソッドを再定義する

派生クラスは、同じシグネチャを持つメソッドを宣言することで、継承したメソッドを置き換えられます。元のものには Base::method() を通じて引き続きアクセスできます。

#include <iostream>
using namespace std;

class Shape {
public:
    void describe() const { cout << "A generic shape" << endl; }
};

class Circle : public Shape {
public:
    void describe() const {
        Shape::describe();              // 基底クラス版を明示的に呼び出す
        cout << "...specifically a circle" << endl;
    }
};

int main() {
    Circle c;
    c.describe();
    return 0;
}

これは単なる*名前の隠蔽（name hiding）*であって、ポリモーフィズムではありません。どの describe() が実行されるかは、変数の静的な型によってコンパイル時に決まります。これは重大な制限です。実際には Circle を指している Shape& や Shape* を通じて呼び出しても、やはり Shape::describe() が実行されてしまいます。これを解決するには virtual が必要で、それが次のページのテーマです。

オブジェクトスライシングに注意

基底クラスの参照やポインタは派生オブジェクトを指せるため、派生オブジェクトを基底型の変数にコピーしたくなります。やめましょう。派生部分が切り落とされてしまいます。

#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
    string name = "?";
};

class Dog : public Animal {
public:
    string breed = "Labrador";
};

int main() {
    Dog d;
    d.name = "Rex";

    Animal a = d;   // スライシング: Animal の部分だけがコピーされる
    cout << a.name << endl;   // Rex
    // a.breed は消えてしまった - そもそも Animal の一部ではなかった
    return 0;
}

a は基底クラスのラベルを貼った Dog ではなく、正真正銘の Animal なので、breed はそこには存在しません。派生オブジェクトを多態的に扱うには、基底クラスの参照（Animal&）かポインタ（Animal*）を使う必要があり、基底クラスの値を使ってはいけません。スライシングは静かに起こります。問題なくコンパイルされ、ただこっそりデータを捨てるだけなので、本番環境まで紛れ込みやすい継承のバグの一つです。

よくある間違いと避け方

• 基底クラスの private メンバが子クラスから触れると思い込む。 触れません。派生クラスが正当に必要とするデータには protected を使い、本当に内部だけの状態は private のままにしてください。
• 基底クラスのコンストラクタ引数の転送を忘れる。 基底クラスにデフォルトコンストラクタがない場合は、派生クラスのコンストラクタの初期化リストで明示的に呼び出す必要があります（: Base(args)）。
• 派生オブジェクトを基底クラスの値にスライスしてしまう。 Dog を Animal にコピーすると、Dog 固有のものはすべて失われます。代わりに基底クラスの参照やポインタを渡し、保持してください。
• コード再利用のために継承を使いすぎる。 継承は「is-a」をモデル化します。関係が実際には「has-a（〜を持つ）」である場合（Car は Engine を持つ）、継承よりもコンポジション（メンバオブジェクト）を選びましょう。

次へ：仮想関数

先ほど見たオーバーライドはコンパイル時に解決されたため、基底ポインタを通じた呼び出しは派生版を無視しました。次のページ、仮想関数では、キーワード virtual と override を紹介します。これは実行時の型にどのメソッドを実行するかを決めさせる仕組みで、真のポリモーフィズムを可能にし、なぜ基底クラスに仮想デストラクタが必要なのかを説明します。