MENU
  1. ホーム
  2. C++
  3. C++基底クラスと派生クラスの定義方法：基本から応用まで

C++基底クラスと派生クラスの定義方法：基本から応用まで

C++

C++の基底クラスと派生クラスの定義方法を学ぶことで、オブジェクト指向プログラミングの基礎から応用までを理解し、効率的なコードの設計と再利用が可能になります。本記事では、基底クラスと派生クラスの基本的な定義方法から応用例までを詳しく解説します。

目次

基底クラスの定義方法

C++で基底クラスを定義する方法は、クラスの基本的な構文を理解することから始まります。基底クラスは他のクラスに継承されるためのクラスであり、共通の機能やプロパティを提供します。

基底クラスの基本構文

基底クラスを定義するための基本的な構文は以下の通りです：

class BaseClass {
public:
    // コンストラクタ
    BaseClass() {
        // 初期化処理
    }

    // メンバ関数
    void baseFunction() {
        // 基底クラスの処理
    }

protected:
    // 基底クラスのメンバ変数
    int baseValue;
};

基底クラスのコンストラクタとメンバ関数

基底クラスのコンストラクタは、オブジェクトの初期化を行うための特別な関数です。また、メンバ関数は基底クラスが提供する機能を実装します。例えば、上記の baseFunction は基底クラスの特定の処理を行います。

基底クラスの定義は、オブジェクト指向プログラミングの基盤となり、コードの再利用性と保守性を向上させます。次に、派生クラスの定義方法について見ていきます。

派生クラスの定義方法

派生クラスは、基底クラスを継承し、その機能を拡張するためのクラスです。派生クラスを定義することで、基底クラスの機能を再利用しながら、新しい機能を追加することができます。

派生クラスの基本構文

派生クラスを定義するための基本的な構文は以下の通りです：

class DerivedClass : public BaseClass {
public:
    // コンストラクタ
    DerivedClass() : BaseClass() {
        // 初期化処理
    }

    // メンバ関数
    void derivedFunction() {
        // 派生クラスの処理
    }
};

基底クラスとの関係性

派生クラスは : の後に基底クラスの名前を記述し、継承のアクセス指定子（通常は public）を指定します。これにより、派生クラスは基底クラスのメンバ変数やメンバ関数を引き継ぎます。

class BaseClass {
public:
    void baseFunction() {
        // 基底クラスの処理
    }

protected:
    int baseValue;
};

class DerivedClass : public BaseClass {
public:
    void derivedFunction() {
        // 派生クラスの処理
        baseFunction(); // 基底クラスの関数を呼び出す
    }
};

派生クラスのコンストラクタ

派生クラスのコンストラクタは、基底クラスのコンストラクタを呼び出すことで、基底クラスの初期化を行います。これにより、基底クラスのメンバ変数も適切に初期化されます。

派生クラスを定義することで、オブジェクト指向プログラミングの継承を活用し、コードの再利用性と拡張性を高めることができます。次に、基底クラスと派生クラスの具体的な使用例を見ていきましょう。

基底クラスと派生クラスの使用例

実際のコード例を通じて、基底クラスと派生クラスの使用方法を理解しましょう。これにより、クラスの継承の概念がより具体的にわかります。

基底クラスと派生クラスのコード例

以下に、基底クラス Animal と派生クラス Dog を定義した例を示します。

#include <iostream>
using namespace std;

// 基底クラス
class Animal {
public:
    Animal() {
        cout << "Animal constructor called" << endl;
    }

    void speak() {
        cout << "Animal speaks" << endl;
    }

protected:
    int age;
};

// 派生クラス
class Dog : public Animal {
public:
    Dog() {
        cout << "Dog constructor called" << endl;
    }

    void bark() {
        cout << "Dog barks" << endl;
    }
};

int main() {
    Dog myDog;
    myDog.speak(); // 基底クラスのメンバ関数を呼び出し
    myDog.bark();  // 派生クラスのメンバ関数を呼び出し

    return 0;
}

基底クラスのメンバ関数の利用

上記の例では、基底クラス Animal のメンバ関数 speak を派生クラス Dog のインスタンス myDog で呼び出しています。これにより、基底クラスの機能をそのまま利用できることがわかります。

派生クラス独自のメンバ関数

派生クラス Dog は独自のメンバ関数 bark を持ち、基底クラスにはない機能を提供しています。これにより、派生クラスは基底クラスの機能を拡張できます。

実行結果

上記のコードを実行すると、以下のような出力が得られます：

Animal constructor called
Dog constructor called
Animal speaks
Dog barks

このように、基底クラスと派生クラスの関係を利用することで、オブジェクト指向プログラミングの強力な機能を活用できます。次に、仮想関数とオーバーライドについて解説します。

仮想関数とオーバーライド

仮想関数は、基底クラスで宣言され、派生クラスでオーバーライドされることを意図した関数です。これにより、ポリモーフィズムを実現し、基底クラスのポインタや参照を使って派生クラスのメソッドを呼び出すことができます。

仮想関数の定義方法

仮想関数を定義するには、基底クラスのメンバ関数に virtual キーワードを付けます。

class BaseClass {
public:
    virtual void showMessage() {
        cout << "BaseClass message" << endl;
    }
};

オーバーライドの方法

派生クラスで仮想関数をオーバーライドするには、同じ関数シグネチャで再定義します。override キーワードを使うことで、オーバーライドしていることを明示できます。

class DerivedClass : public BaseClass {
public:
    void showMessage() override {
        cout << "DerivedClass message" << endl;
    }
};

ポリモーフィズムの実現

仮想関数を使うことで、基底クラスのポインタや参照を通じて派生クラスのメソッドを呼び出すことができます。これにより、柔軟で拡張性の高いコードを実現できます。

int main() {
    BaseClass* ptr;
    DerivedClass derived;
    ptr = &derived;

    // 基底クラスのポインタを使って派生クラスのメソッドを呼び出す
    ptr->showMessage();

    return 0;
}

実行結果

上記のコードを実行すると、派生クラスのメソッドが呼び出されます：

DerivedClass message

仮想関数の利点

仮想関数を使うことで、以下のような利点があります：

  1. 柔軟性の向上: 基底クラスのインターフェースを変更せずに、派生クラスで機能を拡張できます。
  2. コードの再利用: 基底クラスのコードを再利用しつつ、派生クラスで新たな機能を追加できます。
  3. 拡張性の確保: 新しい派生クラスを追加しても、既存のコードを変更する必要がありません。

仮想関数とオーバーライドを理解することで、C++のオブジェクト指向プログラミングをより効果的に活用できます。次に、基底クラスのコンストラクタとデストラクタについて説明します。

基底クラスのコンストラクタとデストラクタ

基底クラスのコンストラクタとデストラクタは、クラスのオブジェクトが生成されるときや破棄されるときに自動的に呼び出される特別な関数です。派生クラスの初期化とクリーンアップにおいて重要な役割を果たします。

基底クラスのコンストラクタ

基底クラスのコンストラクタは、オブジェクトの初期化を行います。派生クラスのコンストラクタが呼び出される前に、基底クラスのコンストラクタが呼び出されます。

class BaseClass {
public:
    BaseClass() {
        cout << "BaseClass constructor called" << endl;
    }
};

派生クラスのコンストラクタ

派生クラスのコンストラクタは、基底クラスのコンストラクタを呼び出すことで、基底クラスのメンバ変数も初期化します。これはコンストラクタ初期化リストを使用して行います。

class DerivedClass : public BaseClass {
public:
    DerivedClass() : BaseClass() {
        cout << "DerivedClass constructor called" << endl;
    }
};

基底クラスのデストラクタ

基底クラスのデストラクタは、オブジェクトが破棄されるときにリソースのクリーンアップを行います。派生クラスのデストラクタが呼び出される前に、基底クラスのデストラクタが呼び出されます。

class BaseClass {
public:
    virtual ~BaseClass() {
        cout << "BaseClass destructor called" << endl;
    }
};

派生クラスのデストラクタ

派生クラスのデストラクタは、基底クラスのデストラクタを呼び出すことで、基底クラスのリソースも適切に解放します。

class DerivedClass : public BaseClass {
public:
    ~DerivedClass() {
        cout << "DerivedClass destructor called" << endl;
    }
};

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

オブジェクトの生成と破棄の際、コンストラクタとデストラクタは以下の順序で呼び出されます：

  1. 基底クラスのコンストラクタ
  2. 派生クラスのコンストラクタ
  3. 派生クラスのデストラクタ
  4. 基底クラスのデストラクタ
int main() {
    DerivedClass myObject;

    return 0;
}

実行結果

上記のコードを実行すると、次のような出力が得られます：

BaseClass constructor called
DerivedClass constructor called
DerivedClass destructor called
BaseClass destructor called

このように、基底クラスと派生クラスのコンストラクタとデストラクタの役割を理解することで、クラスの初期化とクリーンアップを効果的に管理できます。次に、アクセス指定子と継承について詳しく解説します。

アクセス指定子と継承

C++では、アクセス指定子（public、protected、private）を使用して、クラスのメンバ変数やメンバ関数へのアクセス権を制御します。これにより、継承時のクラスメンバの可視性が決定されます。

アクセス指定子の種類

アクセス指定子には以下の3種類があります：

  1. public：公開メンバ。どこからでもアクセス可能。
  2. protected：保護されたメンバ。基底クラスと派生クラスからアクセス可能。
  3. private：非公開メンバ。基底クラス内からのみアクセス可能。

アクセス指定子と継承の関係

継承の際、アクセス指定子が継承の仕方に影響を与えます。以下の例で詳しく見ていきます。

class BaseClass {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};

// public継承
class PublicDerived : public BaseClass {
public:
    void accessMembers() {
        publicVar = 1;      // OK
        protectedVar = 2;   // OK
        // privateVar = 3;  // エラー：基底クラスのprivateメンバにはアクセスできない
    }
};

// protected継承
class ProtectedDerived : protected BaseClass {
public:
    void accessMembers() {
        publicVar = 1;      // OK
        protectedVar = 2;   // OK
        // privateVar = 3;  // エラー
    }
};

// private継承
class PrivateDerived : private BaseClass {
public:
    void accessMembers() {
        publicVar = 1;      // OK
        protectedVar = 2;   // OK
        // privateVar = 3;  // エラー
    }
};

public継承

基底クラスのpublicメンバとprotectedメンバは、派生クラスでそのままのアクセス権を維持しますが、privateメンバにはアクセスできません。

protected継承

基底クラスのpublicメンバとprotectedメンバは、派生クラス内ではprotectedメンバとして扱われ、外部からはアクセスできません。

private継承

基底クラスのpublicメンバとprotectedメンバは、派生クラス内ではprivateメンバとして扱われ、派生クラス外部からはアクセスできません。

実行例

以下のコードを使用して、アクセス指定子と継承の動作を確認できます。

int main() {
    PublicDerived publicDerived;
    publicDerived.publicVar = 1;   // OK
    // publicDerived.protectedVar = 2; // エラー：protectedメンバにはアクセスできない

    ProtectedDerived protectedDerived;
    // protectedDerived.publicVar = 1; // エラー：protected継承でpublicメンバもprotectedになる

    PrivateDerived privateDerived;
    // privateDerived.publicVar = 1; // エラー：private継承でpublicメンバもprivateになる

    return 0;
}

アクセス指定子を理解することで、クラス設計におけるデータの隠蔽とアクセス制御を適切に行うことができます。次に、ポリモーフィズムの実装について説明します。

ポリモーフィズムの実装

ポリモーフィズムは、同じインターフェースを持つ異なるクラスが異なる動作を実装できるようにする、オブジェクト指向プログラミングの重要な概念です。C++では、仮想関数を使用してポリモーフィズムを実現します。

ポリモーフィズムの基本概念

ポリモーフィズムにより、基底クラスのポインタや参照を使って、派生クラスのオブジェクトを操作することができます。これにより、コードの柔軟性と拡張性が向上します。

仮想関数を用いたポリモーフィズムの実装

以下に、ポリモーフィズムを実装した例を示します。基底クラス Animal に仮想関数 speak を定義し、派生クラス Dog と Cat でオーバーライドします。

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() {
        cout << "Animal speaks" << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        cout << "Dog barks" << endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        cout << "Cat meows" << endl;
    }
};

void makeAnimalSpeak(Animal& animal) {
    animal.speak();
}

int main() {
    Dog dog;
    Cat cat;

    makeAnimalSpeak(dog); // Dog barks
    makeAnimalSpeak(cat); // Cat meows

    return 0;
}

ポリモーフィズムの利点

ポリモーフィズムを利用することで、以下の利点があります：

  1. コードの柔軟性：異なるクラスのオブジェクトを同じインターフェースで扱うことができ、コードの変更が容易になります。
  2. 拡張性：新しい派生クラスを追加しても、既存のコードを変更する必要がありません。
  3. 再利用性：基底クラスのインターフェースを利用して、異なる派生クラスの機能を共通に扱えます。

仮想デストラクタの重要性

ポリモーフィズムを利用する際は、基底クラスに仮想デストラクタを定義することが重要です。これにより、派生クラスのデストラクタが正しく呼び出され、リソースのクリーンアップが確実に行われます。

class Animal {
public:
    virtual ~Animal() {
        cout << "Animal destructor called" << endl;
    }
};

class Dog : public Animal {
public:
    ~Dog() {
        cout << "Dog destructor called" << endl;
    }
};

実行結果

上記のコードを実行すると、以下のように派生クラスのメソッドが呼び出されます：

Dog barks
Cat meows

ポリモーフィズムを効果的に利用することで、C++のオブジェクト指向プログラミングの利点を最大限に引き出すことができます。次に、インターフェースクラスの定義について解説します。

インターフェースクラスの定義

インターフェースクラスは、純粋仮想関数のみを持つクラスで、他のクラスにインターフェースを提供するために使われます。インターフェースクラスを使うことで、異なるクラスが共通の操作を実装することができます。

インターフェースクラスの基本構文

インターフェースクラスは、純粋仮想関数のみを持ち、具体的な実装を含まないクラスです。純粋仮想関数は = 0 を使って定義します。

class IShape {
public:
    virtual void draw() const = 0; // 純粋仮想関数
    virtual ~IShape() {} // 仮想デストラクタ
};

インターフェースクラスの利用方法

インターフェースクラスを利用する場合、他のクラスがこのインターフェースを実装します。これにより、共通のインターフェースを持つ異なるクラスを統一的に扱うことができます。

class Circle : public IShape {
public:
    void draw() const override {
        cout << "Drawing Circle" << endl;
    }
};

class Square : public IShape {
public:
    void draw() const override {
        cout << "Drawing Square" << endl;
    }
};

インターフェースを利用したポリモーフィズム

インターフェースクラスを使うことで、ポリモーフィズムを実現できます。異なる具体的なクラスを同じインターフェースで操作できるようになります。

void drawShape(const IShape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Square square;

    drawShape(circle); // Drawing Circle
    drawShape(square); // Drawing Square

    return 0;
}

インターフェースクラスの利点

インターフェースクラスを使うことの利点は次の通りです：

  1. コードの一貫性：共通のインターフェースを通じて異なるクラスを同様に操作できます。
  2. 拡張性：新しいクラスを追加しても、既存のインターフェースを変更する必要がありません。
  3. 柔軟性：異なる実装を持つクラスを統一的に扱うことができ、コードの柔軟性が向上します。

インターフェースクラスの実例

以下は、インターフェースクラス IShape を実装する Circle と Square の例です。これにより、異なる図形クラスが共通のインターフェースを持つことになります。

int main() {
    Circle circle;
    Square square;

    drawShape(circle); // Drawing Circle
    drawShape(square); // Drawing Square

    return 0;
}

このように、インターフェースクラスを利用することで、C++のオブジェクト指向プログラミングの柔軟性と拡張性を高めることができます。次に、抽象クラスと純粋仮想関数について説明します。

抽象クラスと純粋仮想関数

抽象クラスは、少なくとも一つの純粋仮想関数を持つクラスで、直接インスタンス化することはできません。抽象クラスは、共通のインターフェースを提供し、派生クラスに具体的な実装を要求します。

抽象クラスの定義方法

抽象クラスは、純粋仮想関数を1つ以上持つクラスとして定義されます。純粋仮想関数は = 0 で定義されます。

class AbstractShape {
public:
    virtual void draw() const = 0; // 純粋仮想関数
    virtual ~AbstractShape() {} // 仮想デストラクタ
};

純粋仮想関数の役割

純粋仮想関数は、派生クラスで必ずオーバーライドされるべき関数です。これにより、基底クラスでは具体的な実装を提供せず、派生クラスに具体的な動作を委ねます。

class Circle : public AbstractShape {
public:
    void draw() const override {
        cout << "Drawing Circle" << endl;
    }
};

class Square : public AbstractShape {
public:
    void draw() const override {
        cout << "Drawing Square" << endl;
    }
};

抽象クラスの使用例

以下に、抽象クラス AbstractShape を利用して、具体的なクラス Circle と Square を操作する例を示します。

void renderShape(const AbstractShape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Square square;

    renderShape(circle); // Drawing Circle
    renderShape(square); // Drawing Square

    return 0;
}

抽象クラスの利点

抽象クラスを使用することで、以下のような利点があります：

  1. 設計の一貫性：共通のインターフェースを提供することで、コードの設計が一貫します。
  2. 実装の強制：派生クラスに具体的な実装を強制することで、クラスの意図した動作を確保します。
  3. ポリモーフィズムの実現：基底クラスのポインタや参照を使用して、異なる派生クラスのメソッドを呼び出すことができます。

実行結果

上記のコードを実行すると、派生クラスの draw メソッドが呼び出され、以下のように出力されます：

Drawing Circle
Drawing Square

このように、抽象クラスと純粋仮想関数を利用することで、C++のオブジェクト指向プログラミングの設計が強化され、コードの拡張性と保守性が向上します。次に、テンプレートクラスとの組み合わせについて解説します。

テンプレートクラスとの組み合わせ

テンプレートクラスと継承を組み合わせることで、型に依存しない柔軟なクラス設計が可能になります。テンプレートクラスは、異なるデータ型を扱う汎用的なクラスを定義するために使用されます。

テンプレートクラスの基本構文

テンプレートクラスを定義するための基本構文は以下の通りです：

template <typename T>
class BaseTemplate {
public:
    void setValue(T value) {
        this->value = value;
    }

    T getValue() const {
        return value;
    }

protected:
    T value;
};

テンプレートクラスの継承

テンプレートクラスを基底クラスとして派生クラスを定義することも可能です。派生クラスはテンプレート引数を継承し、基底クラスの機能を拡張できます。

template <typename T>
class DerivedTemplate : public BaseTemplate<T> {
public:
    void displayValue() const {
        std::cout << "Value: " << this->value << std::endl;
    }
};

テンプレートクラスの使用例

テンプレートクラスとその派生クラスを使った例を示します。異なるデータ型に対して同じ操作を実行することができます。

int main() {
    DerivedTemplate<int> intObject;
    intObject.setValue(42);
    intObject.displayValue(); // Value: 42

    DerivedTemplate<std::string> stringObject;
    stringObject.setValue("Hello, World!");
    stringObject.displayValue(); // Value: Hello, World!

    return 0;
}

テンプレートクラスの利点

テンプレートクラスを使用することで、以下のような利点があります：

  1. コードの再利用性：異なるデータ型に対して同じクラスを使用できるため、コードの再利用性が向上します。
  2. 型安全性：テンプレートを使用することで、コンパイル時に型の一致がチェックされ、型安全性が確保されます。
  3. 柔軟性：テンプレートを使用することで、様々なデータ型に対して汎用的なクラス設計が可能になります。

実行結果

上記のコードを実行すると、次のような出力が得られます：

Value: 42
Value: Hello, World!

このように、テンプレートクラスと継承を組み合わせることで、C++のクラス設計がより柔軟になり、様々なデータ型に対して共通の操作を提供することができます。次に、応用例と演習問題を通じてさらに理解を深めましょう。

応用例と演習問題

ここでは、基底クラスと派生クラス、そしてテンプレートクラスの概念を応用した実践例を示します。さらに、理解を深めるための演習問題も提供します。

応用例：図形の描画システム

以下に、図形を描画するシステムの実装例を示します。Shapeという抽象クラスを基底クラスとして、具体的な図形クラス（CircleやRectangle）を派生クラスとして定義します。さらに、これらをテンプレートクラスとして汎用的に扱います。

#include <iostream>
#include <vector>
#include <memory>
using namespace std;

// 抽象基底クラス
class Shape {
public:
    virtual void draw() const = 0; // 純粋仮想関数
    virtual ~Shape() {}
};

// 派生クラス：Circle
class Circle : public Shape {
public:
    void draw() const override {
        cout << "Drawing Circle" << endl;
    }
};

// 派生クラス：Rectangle
class Rectangle : public Shape {
public:
    void draw() const override {
        cout << "Drawing Rectangle" << endl;
    }
};

// テンプレートクラス
template <typename T>
class ShapeCollection {
public:
    void addShape(shared_ptr<T> shape) {
        shapes.push_back(shape);
    }

    void drawAll() const {
        for (const auto& shape : shapes) {
            shape->draw();
        }
    }

private:
    vector<shared_ptr<T>> shapes;
};

int main() {
    ShapeCollection<Shape> shapeCollection;

    shared_ptr<Shape> circle = make_shared<Circle>();
    shared_ptr<Shape> rectangle = make_shared<Rectangle>();

    shapeCollection.addShape(circle);
    shapeCollection.addShape(rectangle);

    shapeCollection.drawAll();

    return 0;
}

実行結果

上記のコードを実行すると、以下のような出力が得られます：

Drawing Circle
Drawing Rectangle

この例では、Shapeという抽象クラスを使って共通のインターフェースを提供し、CircleとRectangleが具体的な実装を提供しています。ShapeCollectionはテンプレートクラスとして、異なる図形クラスを統一的に扱っています。

演習問題

以下の演習問題を解いて、基底クラスと派生クラス、テンプレートクラスの理解を深めましょう。

  1. 新しい図形クラスの追加：
    • 上記のコードに新しい図形クラスTriangleを追加し、ShapeCollectionに追加して描画するように実装してください。
    class Triangle : public Shape { public: void draw() const override { cout << "Drawing Triangle" << endl; } };
  2. ShapeCollectionクラスの機能拡張：
    • ShapeCollectionクラスに、図形を削除するメソッド removeShape を追加してください。
    template <typename T> class ShapeCollection { public: void addShape(shared_ptr<T> shape) { shapes.push_back(shape); }void removeShape(shared_ptr&lt;T&gt; shape) { shapes.erase(remove(shapes.begin(), shapes.end(), shape), shapes.end()); } void drawAll() const { for (const auto&amp; shape : shapes) { shape-&gt;draw(); } }private: vector<shared_ptr<T>> shapes; };
  3. 異なる型の図形コレクションの作成：
    • テンプレートクラスを使って、異なる型（例：intやdouble）の図形コレクションを作成し、それらの値を操作するクラスを作成してください。

演習問題を通じて、クラスの継承やテンプレートの使い方を実践的に理解できます。最後に、本記事のまとめを行います。

まとめ

本記事では、C++の基底クラスと派生クラスの定義方法について、基本から応用まで詳しく解説しました。基底クラスと派生クラスを使用することで、オブジェクト指向プログラミングの強力な機能を活用し、コードの再利用性や保守性を向上させることができます。また、仮想関数を使ったポリモーフィズムや、テンプレートクラスを組み合わせた柔軟なクラス設計についても学びました。

以下は、本記事のポイントです：

  1. 基底クラスと派生クラスの定義方法：基本的なクラス構造を理解し、適切に継承する方法を学びました。
  2. 仮想関数とオーバーライド：ポリモーフィズムを実現し、基底クラスのインターフェースを通じて派生クラスの動作を統一的に扱う方法を学びました。
  3. コンストラクタとデストラクタ：オブジェクトの初期化とクリーンアップを適切に管理するための方法を学びました。
  4. アクセス指定子と継承：アクセス指定子を使って、クラスメンバの可視性とアクセス権を制御する方法を学びました。
  5. インターフェースクラスの定義：抽象クラスと純粋仮想関数を利用して、共通のインターフェースを提供する方法を学びました。
  6. テンプレートクラスとの組み合わせ：テンプレートクラスを利用して、型に依存しない柔軟なクラス設計を実現する方法を学びました。

これらの知識を活用することで、C++でのオブジェクト指向プログラミングの理解が深まり、実践的なアプリケーション開発に役立てることができます。応用例と演習問題を通じて、さらに理解を深め、自身のプロジェクトに応用してみてください。

以上で、C++の基底クラスと派生クラスの定義方法に関する解説を終了します。ありがとうございました。

C++
プログラミング コード例 オブジェクト指向 C++ 基底クラス 派生クラス

コメント

コメントする

目次