[C++] 基底クラスのメソッドをオーバーライドする方法

Q: overrideキーワードは必須なのか？

overrideキーワードは必須ではありませんが、使用することが推奨されます。 このキーワードを使用することで、派生クラスのメソッドが基底クラスの仮想関数をオーバーライドしていることを明示的に示すことができます。 これにより、シグネチャの不一致や誤ったオーバーライドを防ぎ、コンパイル時にエラーを検出することができます。 したがって、コードの可読性と安全性を向上させるために、overrideを使用することが望ましいです。

Q: オーバーライドしたメソッドから基底クラスのメソッドを呼び出すには？

オーバーライドしたメソッドから基底クラスのメソッドを呼び出すには、スコープ解決演算子::を使用します。 これにより、基底クラスのメソッドを明示的に指定して呼び出すことができます。 以下はその例です。 #include <iostream>using namespace std;class Base {public: virtual void show() { cout << "基底クラスのメソッド" << endl; }};class Derived : public Base {public: void show() override { // オーバーライド Base::show(); // 基底クラスのメソッドを呼び出す cout << "派生クラスのメソッド" << endl; }};int main() { Derived d; d.show(); // オーバーライドしたメソッドが呼ばれる return 0;} 基底クラスのメソッド派生クラスのメソッド このように、オーバーライドしたメソッド内で基底クラスのメソッドを呼び出すことができます。

C++で基底クラスのメソッドをオーバーライドするには、派生クラスで基底クラスのメソッドと同じ名前、引数、戻り値の型を持つメソッドを定義します。

基底クラスのメソッドが仮想関数virtualとして宣言されている必要があります。

C++11以降では、オーバーライドするメソッドにoverrideキーワードを付けることで、オーバーライドが正しく行われているかコンパイラがチェックします。

この記事でわかること

オーバーライドの基本
基底クラスと派生クラスの関係
仮想関数の役割と使い方
多重継承と仮想継承の理解
ポリモーフィズムの活用方法

目次から探す

C++におけるオーバーライドの基本

基底クラスと派生クラスの関係

C++において、基底クラスは他のクラス(派生クラス)に継承されるクラスです。

基底クラスは共通の機能を持ち、派生クラスはその機能を拡張または変更することができます。

この関係により、コードの再利用性が向上し、オブジェクト指向プログラミングの利点を活かすことができます。

仮想関数(virtual)の役割

仮想関数は、基底クラスで定義され、派生クラスでオーバーライドされることを意図した関数です。

仮想関数を使用することで、ポリモーフィズム(多態性)を実現し、基底クラスのポインタや参照を通じて派生クラスのメソッドを呼び出すことができます。

#include <iostream>
using namespace std;
class Base {
public:
    virtual void show() { // 仮想関数
        cout << "基底クラスのメソッド" << endl;
    }
};
class Derived : public Base {
public:
    void show() override { // オーバーライド
        cout << "派生クラスのメソッド" << endl;
    }
};
int main() {
    Base* b = new Derived(); // 基底クラスのポインタ
    b->show(); // 派生クラスのメソッドが呼ばれる
    delete b;
    return 0;
}

派生クラスのメソッド

オーバーライドの基本的な書き方

オーバーライドは、派生クラスで基底クラスの仮想関数を再定義することです。

派生クラスで同じ関数名、戻り値の型、引数の型を持つメソッドを定義することで実現します。

C++11以降は、overrideキーワードを使用することで、オーバーライドであることを明示できます。

C++11以降のoverrideキーワード

C++11から導入されたoverrideキーワードは、派生クラスのメソッドが基底クラスの仮想関数をオーバーライドしていることを示します。

このキーワードを使用することで、誤って関数のシグネチャを変更してしまった場合にコンパイルエラーが発生し、バグを防ぐことができます。

#include <iostream>
using namespace std;
class Base {
public:
    virtual void show() {
        cout << "基底クラスのメソッド" << endl;
    }
};
class Derived : public Base {
public:
    void show() override { // overrideキーワードを使用
        cout << "派生クラスのメソッド" << endl;
    }
};
int main() {
    Base* b = new Derived();
    b->show();
    delete b;
    return 0;
}

派生クラスのメソッド

オーバーライド時のアクセス指定子(public, protected, private)

オーバーライドする際のアクセス指定子は、基底クラスのメソッドと同じである必要があります。

アクセス指定子は、メソッドの可視性を制御します。

以下のように、public、protected、privateのいずれかを使用できます。

スクロールできます

アクセス指定子	説明
public	どこからでもアクセス可能
protected	派生クラスからアクセス可能
private	同じクラス内からのみアクセス可能

オーバーライドする際は、基底クラスのメソッドのアクセス指定子を考慮し、適切な指定子を使用することが重要です。

オーバーライドの具体例

基本的なオーバーライドの例

基本的なオーバーライドの例として、基底クラスに仮想関数を定義し、派生クラスでその関数をオーバーライドする方法を示します。

この例では、動物を表すクラスを作成し、各動物の鳴き声をオーバーライドします。

#include <iostream>
using namespace std;
class Animal {
public:
    virtual void sound() { // 仮想関数
        cout << "動物の鳴き声" << endl;
    }
};
class Dog : public Animal {
public:
    void sound() override { // オーバーライド
        cout << "ワンワン" << endl;
    }
};
class Cat : public Animal {
public:
    void sound() override { // オーバーライド
        cout << "ニャー" << endl;
    }
};
int main() {
    Animal* a1 = new Dog();
    Animal* a2 = new Cat();
    
    a1->sound(); // Dogの鳴き声
    a2->sound(); // Catの鳴き声
    
    delete a1;
    delete a2;
    return 0;
}

ワンワン
ニャー

コンストラクタやデストラクタのオーバーライド

C++では、コンストラクタやデストラクタはオーバーライドできませんが、基底クラスのコンストラクタやデストラクタを呼び出すことができます。

派生クラスのコンストラクタ内で基底クラスのコンストラクタを明示的に呼び出すことが重要です。

#include <iostream>
using namespace std;
class Base {
public:
    Base() { // 基底クラスのコンストラクタ
        cout << "基底クラスのコンストラクタ" << endl;
    }
    virtual ~Base() { // 基底クラスのデストラクタ
        cout << "基底クラスのデストラクタ" << endl;
    }
};
class Derived : public Base {
public:
    Derived() { // 派生クラスのコンストラクタ
        cout << "派生クラスのコンストラクタ" << endl;
    }
    ~Derived() { // 派生クラスのデストラクタ
        cout << "派生クラスのデストラクタ" << endl;
    }
};
int main() {
    Base* b = new Derived(); // 派生クラスのインスタンスを生成
    delete b; // デストラクタが呼ばれる
    return 0;
}

基底クラスのコンストラクタ
派生クラスのコンストラクタ
派生クラスのデストラクタ
基底クラスのデストラクタ

純粋仮想関数のオーバーライド

純粋仮想関数は、基底クラスで定義され、派生クラスで必ずオーバーライドしなければならない関数です。

純粋仮想関数を使用することで、インターフェースを定義し、派生クラスに具体的な実装を強制することができます。

#include <iostream>
using namespace std;
class Shape {
public:
    virtual void draw() = 0; // 純粋仮想関数
};
class Circle : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "円を描く" << endl;
    }
};
class Square : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "四角を描く" << endl;
    }
};
int main() {
    Shape* s1 = new Circle();
    Shape* s2 = new Square();
    
    s1->draw(); // Circleの描画
    s2->draw(); // Squareの描画
    
    delete s1;
    delete s2;
    return 0;
}

円を描く
四角を描く

複数の派生クラスでのオーバーライド

C++では、1つの基底クラスから複数の派生クラスを作成し、それぞれでオーバーライドを行うことができます。

これにより、異なる動作を持つオブジェクトを生成することが可能です。

#include <iostream>
using namespace std;
class Vehicle {
public:
    virtual void start() { // 仮想関数
        cout << "車両が始動します" << endl;
    }
};
class Car : public Vehicle {
public:
    void start() override { // オーバーライド
        cout << "車が始動します" << endl;
    }
};
class Bike : public Vehicle {
public:
    void start() override { // オーバーライド
        cout << "バイクが始動します" << endl;
    }
};
int main() {
    Vehicle* v1 = new Car();
    Vehicle* v2 = new Bike();
    
    v1->start(); // Carの始動
    v2->start(); // Bikeの始動
    
    delete v1;
    delete v2;
    return 0;
}

車が始動します
バイクが始動します

オーバーライドにおける注意点

基底クラスのメソッドとシグネチャが異なる場合

オーバーライドを行う際、基底クラスのメソッドと派生クラスのメソッドのシグネチャ(戻り値の型、関数名、引数の型と数)が一致している必要があります。

シグネチャが異なる場合、オーバーライドではなく新しいメソッドとして扱われ、基底クラスのメソッドは呼び出されません。

これにより、意図しない動作を引き起こす可能性があります。

#include <iostream>
using namespace std;
class Base {
public:
    virtual void show(int x) { // 基底クラスのメソッド
        cout << "基底クラスのメソッド: " << x << endl;
    }
};
class Derived : public Base {
public:
    void show() { // シグネチャが異なる
        cout << "派生クラスのメソッド" << endl;
    }
};
int main() {
    Base* b = new Derived();
    b->show(10); // 基底クラスのメソッドが呼ばれる
    delete b;
    return 0;
}

基底クラスのメソッド: 10

overrideキーワードを使わない場合のリスク

overrideキーワードを使用しない場合、基底クラスのメソッドのシグネチャを誤って変更してしまった場合でも、コンパイルエラーが発生しません。

その結果、意図しない動作を引き起こす可能性があります。

overrideを使用することで、オーバーライドの意図を明示し、エラーを防ぐことができます。

#include <iostream>
using namespace std;
class Base {
public:
    virtual void display() {
        cout << "基底クラスのメソッド" << endl;
    }
};
class Derived : public Base {
public:
    void display(int x) { // シグネチャが異なる
        cout << "派生クラスのメソッド: " << x << endl;
    }
};
int main() {
    Base* b = new Derived();
    b->display(); // 基底クラスのメソッドが呼ばれる
    delete b;
    return 0;
}

基底クラスのメソッド

オーバーライドとオーバーロードの混同

オーバーライドとオーバーロードは異なる概念です。

オーバーライドは基底クラスの仮想関数を派生クラスで再定義することを指し、オーバーロードは同じ関数名で異なるシグネチャの関数を定義することを指します。

これらを混同すると、意図しない動作やエラーを引き起こす可能性があります。

#include <iostream>
using namespace std;
class Example {
public:
    void func(int x) { // オーバーロード
        cout << "整数: " << x << endl;
    }
    
    void func(double x) { // オーバーロード
        cout << "浮動小数点: " << x << endl;
    }
};
int main() {
    Example ex;
    ex.func(10);    // 整数のオーバーロード
    ex.func(10.5);  // 浮動小数点のオーバーロード
    return 0;
}

整数: 10
浮動小数点: 10.5

オーバーライドと名前隠蔽(名前のシャドウイング)

オーバーライドを行う際、基底クラスのメソッドと同名のメソッドを派生クラスで定義すると、名前隠蔽が発生します。

これにより、基底クラスのメソッドが隠され、意図しない動作を引き起こす可能性があります。

名前隠蔽を避けるためには、基底クラスのメソッドをオーバーライドする際に、overrideキーワードを使用し、シグネチャを正確に一致させることが重要です。

#include <iostream>
using namespace std;
class Base {
public:
    void show() { // 基底クラスのメソッド
        cout << "基底クラスのメソッド" << endl;
    }
};
class Derived : public Base {
public:
    void show() { // 名前隠蔽
        cout << "派生クラスのメソッド" << endl;
    }
};
int main() {
    Base* b = new Derived();
    b->show(); // 基底クラスのメソッドが呼ばれる
    delete b;
    return 0;
}

基底クラスのメソッド

このように、オーバーライドにおいては、シグネチャの一致やoverrideキーワードの使用、名前隠蔽に注意することが重要です。

オーバーライドの応用

多重継承とオーバーライド

C++では、1つのクラスが複数の基底クラスを持つ多重継承が可能です。

この場合、オーバーライドを行う際には、どの基底クラスのメソッドをオーバーライドするかを明確にする必要があります。

特に、同名のメソッドが複数の基底クラスに存在する場合、どのメソッドが呼び出されるかを理解しておくことが重要です。

#include <iostream>
using namespace std;
class Base1 {
public:
    virtual void show() {
        cout << "Base1のメソッド" << endl;
    }
};
class Base2 {
public:
    virtual void show() {
        cout << "Base2のメソッド" << endl;
    }
};
class Derived : public Base1, public Base2 {
public:
    void show() override { // オーバーライド
        Base1::show(); // Base1のメソッドを呼び出す
    }
};
int main() {
    Derived d;
    d.show(); // Base1のメソッドが呼ばれる
    return 0;
}

Base1のメソッド

仮想継承とオーバーライド

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

仮想継承を使用することで、基底クラスのインスタンスが1つだけ生成され、オーバーライドを行う際に一貫性を保つことができます。

仮想継承を使用する場合、基底クラスのメソッドをオーバーライドする際には、仮想基底クラスとしての特性を考慮する必要があります。

#include <iostream>
using namespace std;
class Base {
public:
    virtual void show() {
        cout << "Baseのメソッド" << endl;
    }
};
class Derived1 : virtual public Base {
public:
    void show() override { // オーバーライド
        cout << "Derived1のメソッド" << endl;
    }
};
class Derived2 : virtual public Base {
public:
    void show() override { // オーバーライド
        cout << "Derived2のメソッド" << endl;
    }
};
class Final : public Derived1, public Derived2 {
};
int main() {
    Final f;
    f.show(); // Derived1のメソッドが呼ばれる
    return 0;
}

Derived1のメソッド

テンプレートクラスでのオーバーライド

C++のテンプレートクラスでもオーバーライドを使用することができます。

テンプレートクラスを使用することで、型に依存しない柔軟なクラス設計が可能になります。

オーバーライドを行う際には、テンプレートパラメータを考慮する必要があります。

#include <iostream>
using namespace std;
template <typename T>
class Base {
public:
    virtual void show() {
        cout << "Baseのメソッド: " << typeid(T).name() << endl;
    }
};
template <typename T>
class Derived : public Base<T> {
public:
    void show() override { // オーバーライド
        cout << "Derivedのメソッド: " << typeid(T).name() << endl;
    }
};
int main() {
    Derived<int> d;
    d.show(); // Derivedのメソッドが呼ばれる
    return 0;
}

Derivedのメソッド: int

インターフェースクラスのオーバーライド

C++では、インターフェースクラスを作成するために、純粋仮想関数を使用します。

インターフェースクラスを継承した派生クラスは、必ずその純粋仮想関数をオーバーライドする必要があります。

これにより、特定の機能を持つクラスを強制的に実装させることができます。

#include <iostream>
using namespace std;
class IShape {
public:
    virtual void draw() = 0; // 純粋仮想関数
};
class Circle : public IShape {
public:
    void draw() override { // オーバーライド
        cout << "円を描く" << endl;
    }
};
class Square : public IShape {
public:
    void draw() override { // オーバーライド
        cout << "四角を描く" << endl;
    }
};
int main() {
    IShape* shapes[2];
    shapes[0] = new Circle();
    shapes[1] = new Square();
    
    for (int i = 0; i < 2; i++) {
        shapes[i]->draw(); // 各形状の描画
    }
    
    delete shapes[0];
    delete shapes[1];
    return 0;
}

円を描く
四角を描く

オーバーライドとポリモーフィズムの活用

オーバーライドを使用することで、ポリモーフィズム(多態性)を実現できます。

ポリモーフィズムを活用することで、基底クラスのポインタや参照を通じて、派生クラスのメソッドを呼び出すことが可能になります。

これにより、柔軟で拡張性のあるプログラムを構築することができます。

#include <iostream>
using namespace std;
class Animal {
public:
    virtual void sound() { // 仮想関数
        cout << "動物の鳴き声" << endl;
    }
};
class Dog : public Animal {
public:
    void sound() override { // オーバーライド
        cout << "ワンワン" << endl;
    }
};
class Cat : public Animal {
public:
    void sound() override { // オーバーライド
        cout << "ニャー" << endl;
    }
};
void makeSound(Animal* animal) {
    animal->sound(); // ポリモーフィズムを活用
}
int main() {
    Dog dog;
    Cat cat;
    
    makeSound(&dog); // Dogの鳴き声
    makeSound(&cat); // Catの鳴き声
    
    return 0;
}

ワンワン
ニャー

このように、オーバーライドは多重継承、仮想継承、テンプレートクラス、インターフェースクラス、ポリモーフィズムなど、さまざまな場面で活用され、柔軟で強力なプログラム設計を可能にします。

よくある質問

オーバーライドとオーバーロードはどう違うのか？

オーバーライドとオーバーロードは異なる概念です。

オーバーライドは、基底クラスの仮想関数を派生クラスで再定義することを指し、同じシグネチャを持つ必要があります。

一方、オーバーロードは、同じ関数名で異なるシグネチャ(引数の型や数)を持つ複数の関数を定義することを指します。

オーバーライドは継承に関連し、オーバーロードは同じスコープ内での関数の多様性を提供します。

overrideキーワードは必須なのか？

overrideキーワードは必須ではありませんが、使用することが推奨されます。

このキーワードを使用することで、派生クラスのメソッドが基底クラスの仮想関数をオーバーライドしていることを明示的に示すことができます。

これにより、シグネチャの不一致や誤ったオーバーライドを防ぎ、コンパイル時にエラーを検出することができます。

したがって、コードの可読性と安全性を向上させるために、overrideを使用することが望ましいです。

オーバーライドしたメソッドから基底クラスのメソッドを呼び出すには？

オーバーライドしたメソッドから基底クラスのメソッドを呼び出すには、スコープ解決演算子::を使用します。

これにより、基底クラスのメソッドを明示的に指定して呼び出すことができます。

以下はその例です。

#include <iostream>
using namespace std;
class Base {
public:
    virtual void show() {
        cout << "基底クラスのメソッド" << endl;
    }
};
class Derived : public Base {
public:
    void show() override { // オーバーライド
        Base::show(); // 基底クラスのメソッドを呼び出す
        cout << "派生クラスのメソッド" << endl;
    }
};
int main() {
    Derived d;
    d.show(); // オーバーライドしたメソッドが呼ばれる
    return 0;
}

基底クラスのメソッド
派生クラスのメソッド

このように、オーバーライドしたメソッド内で基底クラスのメソッドを呼び出すことができます。

まとめ

この記事では、C++におけるオーバーライドの基本から応用までを詳しく解説しました。

オーバーライドは、基底クラスの仮想関数を派生クラスで再定義する重要な機能であり、ポリモーフィズムを実現するための鍵となります。

これを活用することで、柔軟で拡張性のあるプログラムを構築することが可能です。

ぜひ、実際のプログラミングにおいてオーバーライドを積極的に活用し、より効果的なコード設計を目指してください。

URLをコピーしました！

[C++] 基底クラスのメソッドをオーバーライドする方法

C++におけるオーバーライドの基本

基底クラスと派生クラスの関係

仮想関数(virtual)の役割

オーバーライドの基本的な書き方

C++11以降のoverrideキーワード

オーバーライド時のアクセス指定子(public, protected, private)

オーバーライドの具体例

基本的なオーバーライドの例

コンストラクタやデストラクタのオーバーライド

純粋仮想関数のオーバーライド

複数の派生クラスでのオーバーライド

オーバーライドにおける注意点

基底クラスのメソッドとシグネチャが異なる場合

overrideキーワードを使わない場合のリスク

オーバーライドとオーバーロードの混同

オーバーライドと名前隠蔽(名前のシャドウイング)

オーバーライドの応用

多重継承とオーバーライド

仮想継承とオーバーライド

テンプレートクラスでのオーバーライド

インターフェースクラスのオーバーライド

オーバーライドとポリモーフィズムの活用

よくある質問

オーバーライドとオーバーロードはどう違うのか？

overrideキーワードは必須なのか？

オーバーライドしたメソッドから基底クラスのメソッドを呼び出すには？

まとめ

キーワードから探す

関連カテゴリーから探す

[C++] 基底クラスのメソッドをオーバーライドする方法

C++におけるオーバーライドの基本

基底クラスと派生クラスの関係

仮想関数(virtual)の役割

オーバーライドの基本的な書き方

C++11以降のoverrideキーワード

オーバーライド時のアクセス指定子(public, protected, private)

オーバーライドの具体例

基本的なオーバーライドの例

コンストラクタやデストラクタのオーバーライド

純粋仮想関数のオーバーライド

複数の派生クラスでのオーバーライド

オーバーライドにおける注意点

基底クラスのメソッドとシグネチャが異なる場合

overrideキーワードを使わない場合のリスク

オーバーライドとオーバーロードの混同

オーバーライドと名前隠蔽(名前のシャドウイング)

オーバーライドの応用

多重継承とオーバーライド

仮想継承とオーバーライド

テンプレートクラスでのオーバーライド

インターフェースクラスのオーバーライド

オーバーライドとポリモーフィズムの活用

よくある質問

オーバーライドとオーバーロードはどう違うのか？

overrideキーワードは必須なのか？

オーバーライドしたメソッドから基底クラスのメソッドを呼び出すには？

まとめ

キーワードから探す

関連カテゴリーから探す

関連記事