テンプレート

[C++] クラステンプレートを継承したクラスの書き方を解説

C++でクラステンプレートを継承する場合、派生クラスは基底クラスのテンプレートパラメータを指定する必要があります。

基底クラスがテンプレートであることを明示するためにtypenameやtemplateを使用する場合があります。

例えば、template<class T> class Baseを継承する場合、class Derived : public Base<T>のように記述します。

テンプレートパラメータのスコープや依存名に注意が必要です。

目次から探す

クラステンプレートの継承の基本
- クラステンプレートの定義
- クラステンプレートの継承
クラステンプレート継承の実践例
- 基本クラスの定義
- 派生クラスの定義
名前空間とクラステンプレートの継承
- 名前空間の定義
- 派生クラスの定義
クラステンプレート継承における特殊なケース
実用的な応用例
まとめ

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

C++におけるクラステンプレートの継承は、型に依存しないクラスの設計を可能にします。

これにより、コードの再利用性が向上し、柔軟なプログラミングが実現します。

以下では、クラステンプレートの基本的な継承の方法について解説します。

クラステンプレートの定義

まず、クラステンプレートを定義する方法を見てみましょう。

以下のコードは、基本的なクラステンプレートの定義を示しています。

#include <iostream>
template <typename T>
class Base {
public:
    void show() {
        std::cout << "Base class with type: " << typeid(T).name() << std::endl;
    }
};

このコードでは、Baseという名前のクラステンプレートを定義しています。

Tはテンプレートパラメータで、任意の型を受け取ることができます。

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

次に、上記のBaseクラスを継承したクラステンプレートを作成します。

以下のコードは、Derivedという名前のクラステンプレートを定義しています。

#include <iostream>
#include <typeinfo>
template <typename T>
class Base {
public:
    void show() {
        std::cout << "Base class with type: " << typeid(T).name() << std::endl;
    }
};
template <typename T>
class Derived : public Base<T> { // Baseクラスを継承
public:
    void display() {
        std::cout << "Derived class with type: " << typeid(T).name() << std::endl;
    }
};
int main() {
    Derived<int> obj; // int型のDerivedクラスのインスタンスを作成
    obj.show();       // Baseクラスのメソッドを呼び出し
    obj.display();    // Derivedクラスのメソッドを呼び出し
    return 0;
}

このコードでは、DerivedクラスがBaseクラスを継承しています。

Derivedクラスは、Baseクラスのメソッドshowを利用できるため、オブジェクトを通じて両方のクラスの機能を使用できます。

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

Base class with type: int
Derived class with type: int

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

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

クラステンプレートの継承は、実際のアプリケーションで非常に役立ちます。

ここでは、具体的な実践例として、数値の演算を行うクラスを作成し、基本クラスを継承した派生クラスを定義します。

この例を通じて、クラステンプレートの継承の利点を理解しましょう。

基本クラスの定義

まず、数値の演算を行う基本クラスCalculatorを定義します。

このクラスは、加算と減算の機能を持ちます。

#include <iostream>
template <typename T>
class Calculator {
public:
    T add(T a, T b) {
        return a + b; // 加算
    }
    T subtract(T a, T b) {
        return a - b; // 減算
    }
};

このCalculatorクラスは、任意の型Tに対して加算と減算を行うメソッドを提供します。

派生クラスの定義

次に、Calculatorクラスを継承したAdvancedCalculatorクラスを定義します。

このクラスでは、乗算と除算の機能を追加します。

#include <iostream>
template <typename T>
class Calculator {
public:
    T add(T a, T b) {
        return a + b; // 加算
    }
    T subtract(T a, T b) {
        return a - b; // 減算
    }
};
template <typename T>
class AdvancedCalculator : public Calculator<T> { // Calculatorクラスを継承
public:
    T multiply(T a, T b) {
        return a * b; // 乗算
    }
    T divide(T a, T b) {
        if (b != 0) {
            return a / b; // 除算
        } else {
            throw std::invalid_argument("ゼロで割ることはできません。"); // ゼロ除算のエラーハンドリング
        }
    }
};
int main() {
    AdvancedCalculator<int> calc; // int型のAdvancedCalculatorのインスタンスを作成
    std::cout << "加算: " << calc.add(5, 3) << std::endl;       // 5 + 3
    std::cout << "減算: " << calc.subtract(5, 3) << std::endl; // 5 - 3
    std::cout << "乗算: " << calc.multiply(5, 3) << std::endl; // 5 * 3
    std::cout << "除算: " << calc.divide(5, 3) << std::endl;   // 5 / 3
    return 0;
}

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

加算: 8
減算: 2
乗算: 15
除算: 1

この実践例では、Calculatorクラスを基にしてAdvancedCalculatorクラスを作成しました。

これにより、基本的な演算機能を持つクラスを拡張し、より複雑な機能を持つクラスを簡単に作成できることが示されました。

クラステンプレートの継承を利用することで、コードの再利用性が高まり、メンテナンスが容易になります。

名前空間とクラステンプレートの継承

C++では、名前空間を使用することで、クラスや関数の名前の衝突を避けることができます。

特に、クラステンプレートを継承する際に名前空間を適切に使用することで、コードの可読性と管理性が向上します。

ここでは、名前空間を利用したクラステンプレートの継承の例を示します。

名前空間の定義

まず、基本クラスと派生クラスを異なる名前空間に定義します。

以下のコードでは、Mathという名前空間を作成し、その中にCalculatorクラスを定義します。

#include <iostream>
namespace Math { // Math名前空間
    template <typename T>
    class Calculator {
    public:
        T add(T a, T b) {
            return a + b; // 加算
        }
        T subtract(T a, T b) {
            return a - b; // 減算
        }
    };
}

このCalculatorクラスは、Math名前空間内に定義されているため、他の名前空間やグローバルスコープと衝突することはありません。

派生クラスの定義

次に、Calculatorクラスを継承したAdvancedCalculatorクラスを別の名前空間AdvancedMathに定義します。

#include <iostream>
namespace Math { // Math名前空間
    template <typename T>
    class Calculator {
    public:
        T add(T a, T b) {
            return a + b; // 加算
        }
        T subtract(T a, T b) {
            return a - b; // 減算
        }
    };
}
namespace AdvancedMath { // AdvancedMath名前空間
    template <typename T>
    class AdvancedCalculator : public Math::Calculator<T> { // Math名前空間のCalculatorを継承
    public:
        T multiply(T a, T b) {
            return a * b; // 乗算
        }
        T divide(T a, T b) {
            if (b != 0) {
                return a / b; // 除算
            } else {
                throw std::invalid_argument("ゼロで割ることはできません。"); // ゼロ除算のエラーハンドリング
            }
        }
    };
}
int main() {
    AdvancedMath::AdvancedCalculator<int> calc; // AdvancedMath名前空間のAdvancedCalculatorのインスタンスを作成
    std::cout << "加算: " << calc.add(5, 3) << std::endl;       // 5 + 3
    std::cout << "減算: " << calc.subtract(5, 3) << std::endl; // 5 - 3
    std::cout << "乗算: " << calc.multiply(5, 3) << std::endl; // 5 * 3
    std::cout << "除算: " << calc.divide(5, 3) << std::endl;   // 5 / 3
    return 0;
}

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

加算: 8
減算: 2
乗算: 15
除算: 1

この例では、Math名前空間にCalculatorクラスを定義し、AdvancedMath名前空間にAdvancedCalculatorクラスを定義しました。

これにより、異なる名前空間に同名のクラスを定義することができ、名前の衝突を避けることができます。

名前空間を利用することで、コードの構造が明確になり、メンテナンスが容易になります。

クラステンプレート継承における特殊なケース

クラステンプレートの継承には、いくつかの特殊なケースがあります。

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

ここでは、特に注意が必要な特殊なケースについて解説します。

1. テンプレートパラメータのデフォルト値

クラステンプレートの継承において、テンプレートパラメータにデフォルト値を設定することができます。

これにより、派生クラスでテンプレートパラメータを省略することが可能になります。

#include <iostream>
template <typename T = int> // デフォルト値を設定
class Base {
public:
    void show() {
        std::cout << "Base class with type: " << typeid(T).name() << std::endl;
    }
};
template <typename T = int> // デフォルト値を設定
class Derived : public Base<T> {
public:
    void display() {
        std::cout << "Derived class with type: " << typeid(T).name() << std::endl;
    }
};
int main() {
    Derived<> obj; // デフォルト値を使用
    obj.show();    // Baseクラスのメソッドを呼び出し
    obj.display(); // Derivedクラスのメソッドを呼び出し
    return 0;
}

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

Base class with type: int
Derived class with type: int

この例では、BaseおよびDerivedクラスのテンプレートパラメータにデフォルト値intを設定しています。

これにより、Derivedクラスのインスタンスを作成する際に、型を省略することができました。

2. 多重継承

C++では、クラステンプレートの多重継承も可能です。

これにより、複数の基底クラスから機能を継承することができます。

以下の例では、Base1とBase2という2つの基底クラスを持つDerivedクラスを定義します。

#include <iostream>
template <typename T>
class Base1 {
public:
    void showBase1() {
        std::cout << "Base1 class with type: " << typeid(T).name() << std::endl;
    }
};
template <typename T>
class Base2 {
public:
    void showBase2() {
        std::cout << "Base2 class with type: " << typeid(T).name() << std::endl;
    }
};
template <typename T>
class Derived : public Base1<T>, public Base2<T> { // 多重継承
public:
    void display() {
        std::cout << "Derived class with type: " << typeid(T).name() << std::endl;
    }
};
int main() {
    Derived<double> obj; // double型のDerivedクラスのインスタンスを作成
    obj.showBase1();     // Base1クラスのメソッドを呼び出し
    obj.showBase2();     // Base2クラスのメソッドを呼び出し
    obj.display();       // Derivedクラスのメソッドを呼び出し
    return 0;
}

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

Base1 class with type: double
Base2 class with type: double
Derived class with type: double

この例では、DerivedクラスがBase1とBase2の両方を継承しています。

これにより、Derivedクラスは両方の基底クラスの機能を持つことができます。

多重継承を利用することで、より複雑なクラス設計が可能になりますが、注意が必要です。

特に、名前の衝突やダイヤモンド問題に対処する必要があります。

3. テンプレートの特化

クラステンプレートの継承において、特定の型に対して特化したクラスを定義することも可能です。

これにより、特定の型に対して異なる動作を実装できます。

以下の例では、Baseクラスを特化したDerivedクラスを定義します。

#include <iostream>
template <typename T>
class Base {
public:
    void show() {
        std::cout << "Base class with type: " << typeid(T).name() << std::endl;
    }
};
template <>
class Base<int> { // int型に特化
public:
    void show() {
        std::cout << "Base class specialized for int" << std::endl;
    }
};
template <typename T>
class Derived : public Base<T> {
public:
    void display() {
        this->show(); // Baseクラスのメソッドを呼び出し
    }
};
int main() {
    Derived<double> obj1; // double型のDerivedクラスのインスタンスを作成
    obj1.display();       // Baseクラスのメソッドを呼び出し
    Derived<int> obj2;    // int型のDerivedクラスのインスタンスを作成
    obj2.display();       // 特化されたBaseクラスのメソッドを呼び出し
    return 0;
}

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

Base class with type: double
Base class specialized for int

この例では、Baseクラスをint型に特化させ、特化されたクラスのメソッドを呼び出すことができました。

テンプレートの特化を利用することで、特定の型に対して異なる動作を実装することが可能になります。

これらの特殊なケースを理解することで、クラステンプレートの継承をより効果的に活用できるようになります。

実用的な応用例

クラステンプレートの継承は、さまざまな実用的なシナリオで活用されます。

ここでは、特に役立つ応用例として、データ構造の実装や、型に依存しないアルゴリズムの実装を紹介します。

これにより、クラステンプレートの継承の利点を具体的に理解できるでしょう。

1. スタックの実装

スタックは、LIFO(Last In, First Out)方式でデータを管理するデータ構造です。

クラステンプレートを使用して、型に依存しないスタックを実装し、基本的な操作を提供します。

以下のコードは、スタックの基本的な実装を示しています。

#include <iostream>
#include <vector>
#include <stdexcept>
template <typename T>
class Stack {
private:
    std::vector<T> elements; // スタックの要素を格納するベクター
public:
    void push(const T& element) {
        elements.push_back(element); // 要素をスタックに追加
    }
    void pop() {
        if (elements.empty()) {
            throw std::out_of_range("スタックが空です。"); // 空のスタックからのポップ
        }
        elements.pop_back(); // 最後の要素を削除
    }
    T top() const {
        if (elements.empty()) {
            throw std::out_of_range("スタックが空です。"); // 空のスタックからのトップ取得
        }
        return elements.back(); // 最後の要素を返す
    }
    bool isEmpty() const {
        return elements.empty(); // スタックが空かどうかを確認
    }
};
int main() {
    Stack<int> intStack; // int型のスタックを作成
    intStack.push(10);
    intStack.push(20);
    std::cout << "スタックのトップ: " << intStack.top() << std::endl; // 20
    intStack.pop();
    std::cout << "スタックのトップ: " << intStack.top() << std::endl; // 10
    return 0;
}

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

スタックのトップ: 20
スタックのトップ: 10

このスタックの実装では、Stackクラスがテンプレートとして定義されているため、任意の型のスタックを作成できます。

これにより、コードの再利用性が高まり、さまざまなデータ型に対応できます。

2. ソートアルゴリズムの実装

次に、クラステンプレートを使用して、型に依存しないソートアルゴリズムを実装します。

以下のコードでは、バブルソートをテンプレートとして定義し、任意の型の配列をソートします。

#include <iostream>
#include <vector>
template <typename T>
void bubbleSort(std::vector<T>& arr) {
    size_t n = arr.size();
    for (size_t i = 0; i < n - 1; ++i) {
        for (size_t j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]); // 要素を交換
            }
        }
    }
}
int main() {
    std::vector<int> intArray = {5, 2, 9, 1, 5, 6};
    bubbleSort(intArray); // int型の配列をソート
    std::cout << "ソートされた配列: ";
    for (const auto& num : intArray) {
        std::cout << num << " "; // ソートされた配列を表示
    }
    std::cout << std::endl;
    return 0;
}

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

ソートされた配列: 1 2 5 5 6 9

このバブルソートの実装では、bubbleSort関数がテンプレートとして定義されているため、任意の型の配列をソートすることができます。

これにより、整数だけでなく、浮動小数点数や文字列など、さまざまなデータ型に対応できます。

3. データベースのエンティティ管理

クラステンプレートの継承は、データベースのエンティティ管理にも応用できます。

以下の例では、基本的なエンティティクラスを定義し、特定のエンティティに対して派生クラスを作成します。

#include <iostream>
#include <string>
template <typename T>
class Entity {
protected:
    T id; // エンティティのID
public:
    Entity(T id) : id(id) {} // コンストラクタ
    T getId() const {
        return id; // IDを取得
    }
};
class User : public Entity<int> { // int型のIDを持つUserクラス
public:
    User(int id) : Entity(id) {} // コンストラクタ
};
class Product : public Entity<std::string> { // string型のIDを持つProductクラス
public:
    Product(const std::string& id) : Entity(id) {} // コンストラクタ
};
int main() {
    User user(1); // Userエンティティを作成
    Product product("A001"); // Productエンティティを作成
    std::cout << "User ID: " << user.getId() << std::endl; // UserのIDを表示
    std::cout << "Product ID: " << product.getId() << std::endl; // ProductのIDを表示
    return 0;
}

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