MENU
  1. ホーム
  2. C++
  3. 基礎構文
  4. クラス
  5. [C++] 親クラスのメンバ変数を継承先クラスで参照する方法

[C++] 親クラスのメンバ変数を継承先クラスで参照する方法

C++で親クラスのメンバ変数を継承先クラスで参照するには、継承先クラス内でそのメンバ変数を直接使用することができます。

親クラスのメンバ変数がpublicまたはprotectedであれば、継承先クラスでそのままアクセス可能です。

privateの場合は直接アクセスできないため、親クラスにアクセサメソッド(ゲッターやセッター)を用意する必要があります。

継承先クラスで親クラスのメンバ変数を参照する際は、thisポインタを使うこともできますが、通常は変数名をそのまま使用します。

この記事でわかること
  • C++の継承の基本
  • メンバ変数のアクセス修飾子の違い
  • 継承先クラスでのメンバ変数の参照方法
  • コンストラクタとデストラクタの動作
  • 多重継承や仮想継承の活用方法

目次から探す

継承の基本

C++における継承は、クラス間の関係を構築するための重要な機能です。

親クラス(基底クラス)から子クラス(派生クラス)へとメンバ変数やメソッドを引き継ぐことができ、コードの再利用性を高め、プログラムの構造を整理するのに役立ちます。

継承を利用することで、共通の機能を持つクラスを簡単に作成でき、オブジェクト指向プログラミングの基本的な概念である IS-A 関係を表現することが可能です。

継承の仕組みを理解することで、より効率的で柔軟なプログラムを構築できるようになります。

親クラスのメンバ変数のアクセス修飾子

C++では、クラスのメンバ変数に対してアクセス修飾子を設定することができます。

これにより、メンバ変数へのアクセスの可否が制御されます。

主なアクセス修飾子には、public、protected、privateの3つがあります。

それぞれの特徴を以下に示します。

スクロールできます
アクセス修飾子説明アクセス可能なクラス
publicどこからでもアクセス可能親クラス、派生クラス、外部クラス
protected派生クラスからアクセス可能親クラス、派生クラス
private親クラス内のみアクセス可能親クラスのみ

publicメンバ変数のアクセス

public修飾子が付けられたメンバ変数は、どのクラスからでもアクセス可能です。

これにより、外部から直接値を取得したり、設定したりすることができます。

以下は、publicメンバ変数の例です。

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

protectedメンバ変数のアクセス

protected修飾子が付けられたメンバ変数は、親クラスとその派生クラスからアクセス可能です。

外部のクラスからはアクセスできないため、カプセル化が強化されます。

以下は、protectedメンバ変数の例です。

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

privateメンバ変数のアクセスと制限

private修飾子が付けられたメンバ変数は、親クラス内からのみアクセス可能で、派生クラスや外部クラスからはアクセスできません。

このため、データの隠蔽が強化されます。

以下は、privateメンバ変数の例です。

#include <iostream>
using namespace std;
class Parent {
private:
    int privateVar; // privateメンバ変数
public:
    void setPrivateVar(int value) {
        privateVar = value; // 親クラス内からアクセス
    }
    void display() {
        cout << "privateVar: " << privateVar << endl;
    }
};
class Child : public Parent {
public:
    void tryAccess() {
        // privateVarにアクセスできないため、以下の行はエラーになる
        // privateVar = 30; // エラー
    }
};
int main() {
    Parent parent;
    parent.setPrivateVar(30);
    parent.display();
    return 0;
}
privateVar: 30

このように、privateメンバ変数は親クラス内でのみ操作でき、派生クラスからは直接アクセスできないため、データの保護が強化されます。

継承先クラスでのメンバ変数の参照方法

継承先クラスでは、親クラスのメンバ変数にアクセスするためのいくつかの方法があります。

これらの方法を理解することで、より効果的にクラスを設計し、メンバ変数を操作することができます。

以下に、主な参照方法を示します。

直接参照の方法

継承先クラスから親クラスのpublicまたはprotectedメンバ変数に直接アクセスすることができます。

以下は、直接参照の例です。

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

アクセサメソッドを使った参照

親クラスにアクセサメソッド(getter)を定義することで、継承先クラスから親クラスのメンバ変数にアクセスすることができます。

この方法は、カプセル化を保ちながらデータにアクセスするのに役立ちます。

以下は、アクセサメソッドを使った参照の例です。

#include <iostream>
using namespace std;
class Parent {
private:
    int privateVar; // privateメンバ変数
public:
    Parent() : privateVar(10) {} // コンストラクタで初期化
    // アクセサメソッド
    int getPrivateVar() const {
        return privateVar; // privateメンバ変数を返す
    }
};
class Child : public Parent {
public:
    void display() {
        // アクセサメソッドを使って親クラスのprivateメンバ変数にアクセス
        cout << "privateVar: " << getPrivateVar() << endl;
    }
};
int main() {
    Child child;
    child.display();
    return 0;
}
privateVar: 10

thisポインタを用いた参照

thisポインタを使用することで、現在のオブジェクトのメンバ変数にアクセスすることができます。

継承先クラスから親クラスのメンバ変数にアクセスする際にも利用できます。

以下は、thisポインタを用いた参照の例です。

#include <iostream>
using namespace std;
class Parent {
protected:
    int protectedVar; // protectedメンバ変数
public:
    Parent() : protectedVar(15) {} // コンストラクタで初期化
};
class Child : public Parent {
public:
    void display() {
        // thisポインタを使って親クラスのprotectedメンバ変数にアクセス
        cout << "protectedVar: " << this->protectedVar << endl;
    }
};
int main() {
    Child child;
    child.display();
    return 0;
}
protectedVar: 15

このように、継承先クラスではさまざまな方法で親クラスのメンバ変数にアクセスすることができ、プログラムの設計に応じて適切な方法を選択することが重要です。

継承におけるコンストラクタとデストラクタ

継承を使用する際、親クラスと子クラスのコンストラクタおよびデストラクタの動作を理解することは非常に重要です。

これにより、オブジェクトの初期化や解放が適切に行われ、メモリ管理やリソース管理が効率的に行えます。

以下に、継承におけるコンストラクタとデストラクタの重要なポイントを示します。

親クラスのコンストラクタの呼び出し

子クラスのコンストラクタが呼び出される際、親クラスのコンストラクタも自動的に呼び出されます。

これにより、親クラスのメンバ変数が正しく初期化されます。

親クラスのコンストラクタを明示的に呼び出すことも可能です。

以下は、親クラスのコンストラクタの呼び出しの例です。

#include <iostream>
using namespace std;
class Parent {
public:
    Parent() {
        cout << "親クラスのコンストラクタが呼ばれました。" << endl;
    }
};
class Child : public Parent {
public:
    Child() {
        cout << "子クラスのコンストラクタが呼ばれました。" << endl;
    }
};
int main() {
    Child child; // 子クラスのインスタンスを生成
    return 0;
}
親クラスのコンストラクタが呼ばれました。
子クラスのコンストラクタが呼ばれました。

デストラクタの動作

デストラクタは、オブジェクトが破棄される際に呼び出される特別なメソッドです。

子クラスのデストラクタが呼ばれると、まず子クラスのデストラクタが実行され、その後に親クラスのデストラクタが呼び出されます。

これにより、リソースの解放が適切に行われます。

以下は、デストラクタの動作の例です。

#include <iostream>
using namespace std;
class Parent {
public:
    ~Parent() {
        cout << "親クラスのデストラクタが呼ばれました。" << endl;
    }
};
class Child : public Parent {
public:
    ~Child() {
        cout << "子クラスのデストラクタが呼ばれました。" << endl;
    }
};
int main() {
    Child child; // 子クラスのインスタンスを生成
    return 0; // プログラム終了時にデストラクタが呼ばれる
}
子クラスのデストラクタが呼ばれました。
親クラスのデストラクタが呼ばれました。

コンストラクタの初期化リスト

コンストラクタの初期化リストを使用することで、親クラスのコンストラクタに引数を渡すことができます。

これにより、親クラスのメンバ変数を初期化する際に、必要な値を指定することができます。

以下は、コンストラクタの初期化リストの例です。

#include <iostream>
using namespace std;
class Parent {
public:
    Parent(int value) {
        cout << "親クラスのコンストラクタが呼ばれました。値: " << value << endl;
    }
};
class Child : public Parent {
public:
    Child(int value) : Parent(value) { // 初期化リストで親クラスのコンストラクタを呼び出す
        cout << "子クラスのコンストラクタが呼ばれました。" << endl;
    }
};
int main() {
    Child child(42); // 子クラスのインスタンスを生成
    return 0;
}
親クラスのコンストラクタが呼ばれました。値: 42
子クラスのコンストラクタが呼ばれました。

このように、継承におけるコンストラクタとデストラクタの動作を理解することで、オブジェクトの初期化や解放を適切に行うことができ、プログラムの安定性と効率性を向上させることができます。

応用例

継承の概念は、さまざまな状況で応用可能です。

ここでは、多重継承、仮想継承、テンプレートクラスを用いた継承の例を紹介します。

これらの技術を理解することで、より柔軟で強力なクラス設計が可能になります。

多重継承でのメンバ変数の参照

C++では、1つのクラスが複数の親クラスを持つことができる多重継承が可能です。

この場合、親クラスのメンバ変数にアクセスする際には、どの親クラスのメンバ変数を参照するかを明示する必要があります。

以下は、多重継承でのメンバ変数の参照の例です。

#include <iostream>
using namespace std;
class Parent1 {
public:
    int value1;
    Parent1() : value1(10) {}
};
class Parent2 {
public:
    int value2;
    Parent2() : value2(20) {}
};
class Child : public Parent1, public Parent2 {
public:
    void display() {
        cout << "value1: " << value1 << endl; // Parent1のメンバ変数
        cout << "value2: " << value2 << endl; // Parent2のメンバ変数
    }
};
int main() {
    Child child;
    child.display();
    return 0;
}
value1: 10
value2: 20

仮想継承を用いた参照

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

仮想基底クラスを使用することで、親クラスのメンバ変数が一度だけ継承されるようになります。

以下は、仮想継承を用いた参照の例です。

#include <iostream>
using namespace std;
class Base {
public:
    int baseValue;
    Base() : baseValue(30) {}
};
class Derived1 : virtual public Base {
public:
    void display() {
        cout << "Derived1からのbaseValue: " << baseValue << endl;
    }
};
class Derived2 : virtual public Base {
public:
    void display() {
        cout << "Derived2からのbaseValue: " << baseValue << endl;
    }
};
class Child : public Derived1, public Derived2 {
public:
    void displayAll() {
        Derived1::display(); // Derived1のメソッドを呼び出す
        Derived2::display(); // Derived2のメソッドを呼び出す
    }
};
int main() {
    Child child;
    child.displayAll();
    return 0;
}
Derived1からのbaseValue: 30
Derived2からのbaseValue: 30

テンプレートクラスでの継承と参照

C++のテンプレートを使用することで、型に依存しないクラスを作成することができます。

テンプレートクラスを継承することで、柔軟なクラス設計が可能になります。

以下は、テンプレートクラスでの継承と参照の例です。

#include <iostream>
using namespace std;
template <typename T>
class Base {
public:
    T value;
    Base(T val) : value(val) {}
};
template <typename T>
class Derived : public Base<T> {
public:
    Derived(T val) : Base<T>(val) {} // 親クラスのコンストラクタを呼び出す
    void display() {
        cout << "value: " << this->value << endl; // 親クラスのメンバ変数にアクセス
    }
};
int main() {
    Derived<int> derived(50); // int型のDerivedクラスを生成
    derived.display();
    return 0;
}
value: 50

これらの応用例を通じて、C++の継承の強力な機能を活用し、より複雑なクラス設計を行うことができるようになります。

多重継承や仮想継承、テンプレートクラスを適切に使用することで、柔軟で再利用可能なコードを作成することが可能です。

よくある質問

protectedメンバ変数はどこまでアクセス可能？

protectedメンバ変数は、親クラス内およびその派生クラスからアクセス可能です。

つまり、親クラスのメンバ関数や、派生クラスのメンバ関数からは直接参照できますが、外部のクラスや関数からはアクセスできません。

この特性により、データのカプセル化が強化され、派生クラスに対してのみアクセスを許可することができます。

privateメンバ変数を継承先で使う方法は？

privateメンバ変数は、親クラス内からのみアクセス可能で、派生クラスからは直接参照できません。

しかし、親クラスにアクセサメソッド(getter)やミューテータメソッド(setter)を定義することで、派生クラスから間接的にprivateメンバ変数にアクセスすることができます。

これにより、データの隠蔽を保ちながら、必要な操作を行うことが可能です。

継承先で親クラスのメンバ変数をオーバーライドできる？

C++では、親クラスのメンバ変数を直接オーバーライドすることはできませんが、親クラスのメンバ関数をオーバーライドすることは可能です。

親クラスのメンバ変数をオーバーライドしたい場合は、派生クラスで同名のメンバ変数を定義することができますが、これは新しい変数を定義することになるため、親クラスのメンバ変数とは異なる扱いになります。

オーバーライドの概念は主にメンバ関数に適用されるため、注意が必要です。

まとめ

この記事では、C++における親クラスのメンバ変数を継承先クラスで参照する方法について詳しく解説しました。

継承の基本から、アクセス修飾子の役割、コンストラクタやデストラクタの動作、さらには多重継承や仮想継承、テンプレートクラスを用いた応用例まで幅広く取り上げました。

これらの知識を活用して、より効率的で柔軟なクラス設計を行い、実際のプログラミングに役立ててみてください。

目次に戻る

当サイトはリンクフリーです。出典元を明記していただければ、ご自由に引用していただいて構いません。

C言語
C++
Python
HTML
Java
HTTP

関連カテゴリーから探す

クラス
  • URLをコピーしました！

関連記事

目次から探す