[C++] クラスは変数をオーバーライドしなくても継承先でアクセス可能

Q: privateメンバ変数は継承先でどう扱う？

privateメンバ変数は、親クラスの外部からは直接アクセスできませんが、継承先のクラスからも同様にアクセスできません。 親クラスのprivateメンバ変数にアクセスするためには、親クラス内にpublicまたはprotectedのメンバ関数を用意し、その関数を通じて値を取得したり設定したりする必要があります。 これにより、カプセル化を保ちながら、必要な情報を派生クラスで利用することができます。

C++では、クラスを継承する際、親クラスのメンバ変数はオーバーライドする必要はなく、継承先のクラスからもアクセス可能です。

ただし、アクセス修飾子に依存します。

publicまたはprotectedで宣言されたメンバ変数は、継承先のクラスから直接アクセスできますが、privateで宣言されたメンバ変数は継承先からは直接アクセスできません。

protectedにすることで、継承先からアクセス可能にしつつ、外部からのアクセスを制限できます。

この記事でわかること

クラスの継承におけるメンバ変数のアクセス方法
アクセス修飾子の役割と影響
メンバ変数の初期化の仕組み
シャドウイングのリスクと対策
継承とコンポジションの使い分け

目次から探す

クラスの継承におけるメンバ変数のアクセス

C++におけるクラスの継承は、オブジェクト指向プログラミングの重要な概念の一つです。

継承を利用することで、既存のクラス(親クラス)の特性を新しいクラス(派生クラス)に引き継ぐことができます。

特に、親クラスのメンバ変数へのアクセスは、アクセス修飾子によって制御されます。

これにより、派生クラスは親クラスのメンバ変数をオーバーライドすることなく、直接利用することが可能です。

この特性を理解することで、より効率的なクラス設計が実現でき、コードの再利用性が向上します。

この記事では、継承におけるメンバ変数のアクセス方法やその利点について詳しく解説します。

アクセス修飾子によるメンバ変数のアクセス制御

C++では、クラスのメンバ変数やメンバ関数へのアクセスを制御するために、アクセス修飾子が使用されます。

主にpublic、protected、privateの3つの修飾子があり、これらは継承時のアクセス権にも影響を与えます。

以下に、それぞれの修飾子によるアクセス制御の違いを説明します。

public継承の場合

public継承を使用すると、親クラスのpublicメンバ変数は派生クラスから直接アクセス可能です。

また、派生クラスのインスタンスを通じて、親クラスのpublicメンバ変数にもアクセスできます。

#include <iostream>
using namespace std;
class Parent {
public:
    int publicVar; // publicメンバ変数
    Parent() : publicVar(10) {}
};
class Child : public Parent {
public:
    void display() {
        cout << "親クラスのpublicメンバ変数: " << publicVar << endl;
    }
};
int main() {
    Child child;
    child.display(); // 親クラスのpublicメンバ変数にアクセス
    return 0;
}

親クラスのpublicメンバ変数: 10

protected継承の場合

protected継承を使用すると、親クラスのprotectedメンバ変数は派生クラスからアクセス可能ですが、外部からはアクセスできません。

これにより、派生クラス内での利用は可能ですが、外部からのアクセスは制限されます。

#include <iostream>
using namespace std;
class Parent {
protected:
    int protectedVar; // protectedメンバ変数
    Parent() : protectedVar(20) {}
};
class Child : protected Parent {
public:
    void display() {
        cout << "親クラスのprotectedメンバ変数: " << protectedVar << endl;
    }
};
int main() {
    Child child;
    child.display(); // 親クラスのprotectedメンバ変数にアクセス
    return 0;
}

親クラスのprotectedメンバ変数: 20

private継承の場合

private継承を使用すると、親クラスのprivateメンバ変数は派生クラスからもアクセスできません。

親クラスのメンバはすべてprivateとして扱われ、外部からもアクセスできないため、継承の意味が薄れることがあります。

#include <iostream>
using namespace std;
class Parent {
private:
    int privateVar; // privateメンバ変数
public:
    Parent() : privateVar(30) {}
    int getPrivateVar() { return privateVar; } // アクセス用のメンバ関数
};
class Child : private Parent {
public:
    void display() {
        cout << "親クラスのprivateメンバ変数: " << getPrivateVar() << endl;
    }
};
int main() {
    Child child;
    child.display(); // 親クラスのprivateメンバ変数にアクセス
    return 0;
}

親クラスのprivateメンバ変数: 30

継承先でのアクセス制限の回避方法

継承先で親クラスのメンバ変数にアクセスする際、アクセス制限を回避する方法として、親クラスにpublicまたはprotectedのメンバ関数を用意することが考えられます。

これにより、外部からの直接アクセスを防ぎつつ、必要な情報を取得できます。

フレンドクラスを使ったアクセス

フレンドクラスを使用することで、特定のクラスに対して親クラスのprivateメンバ変数へのアクセスを許可することができます。

フレンドクラスは、親クラスの内部にアクセスできる特権を持つため、柔軟な設計が可能です。

#include <iostream>
using namespace std;
class Parent {
private:
    int privateVar; // privateメンバ変数
public:
    Parent() : privateVar(40) {}
    friend class FriendClass; // フレンドクラスの宣言
};
class FriendClass {
public:
    void display(Parent& p) {
        cout << "親クラスのprivateメンバ変数: " << p.privateVar << endl;
    }
};
int main() {
    Parent parent;
    FriendClass friendClass;
    friendClass.display(parent); // フレンドクラスを通じてアクセス
    return 0;
}

親クラスのprivateメンバ変数: 40

継承先でのメンバ変数の利用方法

継承を利用することで、親クラスのメンバ変数を派生クラスで効果的に利用することができます。

ここでは、親クラスのメンバ変数へのアクセス方法や初期化、シャドウイング、再定義について詳しく解説します。

親クラスのメンバ変数へのアクセス方法

親クラスのメンバ変数にアクセスする方法は、アクセス修飾子によって異なります。

publicやprotectedで宣言されたメンバ変数は、派生クラスから直接アクセスできます。

以下の例では、親クラスのpublicメンバ変数にアクセスしています。

#include <iostream>
using namespace std;
class Parent {
public:
    int publicVar; // publicメンバ変数
    Parent() : publicVar(50) {}
};
class Child : public Parent {
public:
    void display() {
        cout << "親クラスのpublicメンバ変数: " << publicVar << endl;
    }
};
int main() {
    Child child;
    child.display(); // 親クラスのpublicメンバ変数にアクセス
    return 0;
}

親クラスのpublicメンバ変数: 50

継承先でのメンバ変数の初期化

継承先のクラスでメンバ変数を初期化する場合、コンストラクタを使用します。

親クラスのコンストラクタが呼ばれた後、派生クラスのコンストラクタが実行されます。

以下の例では、派生クラスのコンストラクタで新しいメンバ変数を初期化しています。

#include <iostream>
using namespace std;
class Parent {
public:
    int publicVar; // publicメンバ変数
    Parent() : publicVar(60) {}
};
class Child : public Parent {
public:
    int childVar; // 派生クラスのメンバ変数
    Child() : childVar(70) {
        // 親クラスのコンストラクタが先に呼ばれる
    }
    void display() {
        cout << "親クラスのpublicメンバ変数: " << publicVar << endl;
        cout << "派生クラスのメンバ変数: " << childVar << endl;
    }
};
int main() {
    Child child;
    child.display(); // メンバ変数の表示
    return 0;
}

親クラスのpublicメンバ変数: 60
派生クラスのメンバ変数: 70

コンストラクタでの親クラスのメンバ変数の初期化

親クラスのメンバ変数を初期化するためには、親クラスのコンストラクタを呼び出す必要があります。

派生クラスのコンストラクタで、親クラスのコンストラクタを明示的に呼び出すことができます。

以下の例では、親クラスのコンストラクタを使用してメンバ変数を初期化しています。

#include <iostream>
using namespace std;
class Parent {
public:
    int publicVar; // publicメンバ変数
    Parent(int value) : publicVar(value) {}
};
class Child : public Parent {
public:
    Child(int value) : Parent(value) {
        // 親クラスのコンストラクタを呼び出す
    }
    void display() {
        cout << "親クラスのpublicメンバ変数: " << publicVar << endl;
    }
};
int main() {
    Child child(80); // 親クラスのメンバ変数を初期化
    child.display(); // メンバ変数の表示
    return 0;
}

親クラスのpublicメンバ変数: 80

メンバ変数のシャドウイングとその影響

シャドウイングとは、派生クラスで親クラスと同名のメンバ変数を定義することを指します。

この場合、派生クラスのメンバ変数が優先され、親クラスのメンバ変数にはアクセスできなくなります。

以下の例では、シャドウイングの影響を示しています。

#include <iostream>
using namespace std;
class Parent {
public:
    int value; // 親クラスのメンバ変数
    Parent() : value(90) {}
};
class Child : public Parent {
public:
    int value; // シャドウイング
    Child() : value(100) {}
    void display() {
        cout << "親クラスのvalue: " << Parent::value << endl; // 親クラスのメンバ変数にアクセス
        cout << "派生クラスのvalue: " << value << endl; // 派生クラスのメンバ変数
    }
};
int main() {
    Child child;
    child.display(); // メンバ変数の表示
    return 0;
}

親クラスのvalue: 90
派生クラスのvalue: 100

継承先でのメンバ変数の再定義

継承先でメンバ変数を再定義することも可能ですが、これはシャドウイングと同様の影響を持ちます。

親クラスのメンバ変数と同名の変数を派生クラスで定義すると、親クラスのメンバ変数にはアクセスできなくなります。

再定義を行う際は、意図的に行う必要があります。

以下の例では、再定義の影響を示しています。

#include <iostream>
using namespace std;
class Parent {
public:
    int number; // 親クラスのメンバ変数
    Parent() : number(110) {}
};
class Child : public Parent {
public:
    int number; // 再定義
    Child() : number(120) {}
    void display() {
        cout << "親クラスのnumber: " << Parent::number << endl; // 親クラスのメンバ変数にアクセス
        cout << "派生クラスのnumber: " << number << endl; // 派生クラスのメンバ変数
    }
};
int main() {
    Child child;
    child.display(); // メンバ変数の表示
    return 0;
}

親クラスのnumber: 110
派生クラスのnumber: 120

メンバ変数のオーバーライドが不要な理由

C++において、メンバ変数はオーバーライドの対象ではありません。

これは、メンバ関数とメンバ変数の性質の違いに起因しています。

以下では、メンバ変数とメンバ関数のオーバーライドの違いや、メンバ変数の再定義との関係について詳しく解説します。

メンバ変数とメンバ関数のオーバーライドの違い

メンバ関数は、仮想関数として宣言することでオーバーライドが可能です。

オーバーライドとは、派生クラスで親クラスのメンバ関数を再定義し、動的ポリモーフィズムを実現する手法です。

一方、メンバ変数はその性質上、オーバーライドの概念が適用されません。

メンバ変数は、クラスのインスタンスに固有のデータを保持するため、同じ名前の変数を持つことはできますが、オーバーライドは行われません。

メンバ変数のオーバーライドができない理由

メンバ変数は、クラスのインスタンスに関連付けられたデータを表します。

C++では、メンバ変数はクラスのスコープ内で定義され、親クラスと派生クラスで同名のメンバ変数を持つことができますが、これはシャドウイングと呼ばれ、オーバーライドとは異なります。

シャドウイングでは、派生クラスのメンバ変数が優先され、親クラスのメンバ変数にはアクセスできなくなります。

メンバ変数の再定義とオーバーライドの違い

再定義は、派生クラスで親クラスと同名のメンバ変数を定義することを指します。

再定義されたメンバ変数は、親クラスのメンバ変数を隠すことになりますが、オーバーライドとは異なり、親クラスのメンバ変数は依然として存在します。

再定義は、親クラスのメンバ変数にアクセスするためにParent::variableNameのように明示的に指定する必要があります。

メンバ変数のアクセスとポリモーフィズムの関係

ポリモーフィズムは、同じインターフェースを持つ異なるクラスのオブジェクトを扱う能力を指します。

メンバ関数はポリモーフィズムを実現するためにオーバーライドされますが、メンバ変数はその性質上、ポリモーフィズムの対象にはなりません。

メンバ変数は、クラスのインスタンスに固有のデータを保持するため、ポリモーフィズムの概念とは直接的な関係がありません。

したがって、メンバ変数のオーバーライドは不要であり、代わりに再定義を通じて異なるデータを持たせることができます。

応用例：継承を使ったクラス設計

継承は、オブジェクト指向プログラミングにおいて非常に強力な機能であり、クラス設計においてコードの再利用や拡張性を高めるために利用されます。

以下では、継承を使ったクラス設計の具体例や、設計上の考慮点について解説します。

基本クラスと派生クラスの設計例

基本クラス(親クラス)と派生クラス(子クラス)の設計は、オブジェクト指向プログラミングの基本です。

以下の例では、Animalクラスを基本クラスとして、DogとCatという派生クラスを設計しています。

#include <iostream>
using namespace std;
class Animal {
public:
    void speak() {
        cout << "動物の鳴き声" << endl;
    }
};
class Dog : public Animal {
public:
    void speak() { // オーバーライド
        cout << "ワンワン" << endl;
    }
};
class Cat : public Animal {
public:
    void speak() { // オーバーライド
        cout << "ニャー" << endl;
    }
};
int main() {
    Dog dog;
    Cat cat;
    dog.speak(); // Dogクラスのメソッド
    cat.speak(); // Catクラスのメソッド
    return 0;
}

ワンワン
ニャー

継承を使ったコードの再利用

継承を利用することで、既存のクラスの機能を再利用し、新しいクラスを簡単に作成できます。

基本クラスに共通の機能を持たせ、派生クラスで特有の機能を追加することで、コードの重複を避けることができます。

上記の例では、Animalクラスのspeakメソッドを再利用しています。

継承とカプセル化のバランス

継承を利用する際は、カプセル化とのバランスを考慮することが重要です。

カプセル化は、クラスの内部状態を隠蔽し、外部からの不正なアクセスを防ぐための手法です。

親クラスのメンバ変数をprivateにすることで、派生クラスから直接アクセスできなくなりますが、必要な場合はprotectedやpublicのメンバ関数を通じてアクセスできるように設計することが求められます。

継承とコンポジションの使い分け

継承とコンポジションは、オブジェクト指向プログラミングにおける2つの主要な設計手法です。

継承は is-a 関係を表現するのに対し、コンポジションは has-a 関係を表現します。

例えば、CarクラスがEngineクラスを持つ場合、コンポジションを使用するのが適切です。

継承とコンポジションを使い分けることで、より柔軟で拡張性のある設計が可能になります。

仮想継承とメンバ変数の扱い

仮想継承は、多重継承におけるダイヤモンド問題を解決するための手法です。

仮想継承を使用すると、親クラスのインスタンスが一つだけ生成され、派生クラスはそのインスタンスを共有します。

これにより、メンバ変数の重複を避けることができます。

以下の例では、仮想継承を使用したクラス設計を示します。

#include <iostream>
using namespace std;
class Base {
public:
    int value;
    Base() : value(200) {}
};
class Derived1 : virtual public Base {
public:
    void display() {
        cout << "Derived1のvalue: " << value << endl;
    }
};
class Derived2 : virtual public Base {
public:
    void display() {
        cout << "Derived2のvalue: " << value << endl;
    }
};
class Final : public Derived1, public Derived2 {
public:
    void display() {
        cout << "Finalのvalue: " << value << endl; // Baseのvalueにアクセス
    }
};
int main() {
    Final finalObj;
    finalObj.display(); // 仮想継承を通じてBaseのvalueにアクセス
    return 0;
}

Finalのvalue: 200

このように、仮想継承を使用することで、メンバ変数の重複を避け、クラス設計をよりシンプルに保つことができます。

よくある質問

privateメンバ変数は継承先でどう扱う？

privateメンバ変数は、親クラスの外部からは直接アクセスできませんが、継承先のクラスからも同様にアクセスできません。

親クラスのprivateメンバ変数にアクセスするためには、親クラス内にpublicまたはprotectedのメンバ関数を用意し、その関数を通じて値を取得したり設定したりする必要があります。

これにより、カプセル化を保ちながら、必要な情報を派生クラスで利用することができます。

メンバ変数のシャドウイングは避けるべき？

メンバ変数のシャドウイングは、親クラスと派生クラスで同名のメンバ変数を定義することを指します。

シャドウイングは、意図しないバグを引き起こす可能性があるため、避けるべきです。

特に、親クラスのメンバ変数にアクセスしたい場合、明示的にParent::variableNameのように指定する必要があり、コードが煩雑になります。

したがって、異なる名前を使用するか、必要に応じて明示的にアクセスすることが推奨されます。

継承先でメンバ変数を初期化する方法は？

継承先でメンバ変数を初期化するには、派生クラスのコンストラクタを使用します。

親クラスのコンストラクタは、派生クラスのコンストラクタ内で呼び出すことができ、これにより親クラスのメンバ変数を初期化することができます。

また、派生クラスのコンストラクタ内で新しいメンバ変数を初期化することも可能です。

以下のように、コンストラクタの初期化リストを使用して初期化を行います。

class Parent {
public:
    int parentVar;
    Parent(int value) : parentVar(value) {}
};
class Child : public Parent {
public:
    int childVar;
    Child(int parentValue, int childValue) : Parent(parentValue), childVar(childValue) {}
};

このように、コンストラクタを通じて親クラスと派生クラスのメンバ変数を初期化することができます。