C++メタプログラミングで実現する高度なポリモーフィズム技法

メタプログラミングは、プログラムが他のプログラムを生成、変換、操作する技術です。この技法を利用することで、コードの再利用性が向上し、複雑な設計もシンプルに実現できます。本記事では、C++におけるメタプログラミングを活用して、ポリモーフィズム（多態性）を高度に実現する方法について解説します。ポリモーフィズムは、オブジェクト指向プログラミングの核心であり、異なるデータ型に対して同一のインターフェースを提供する手法です。C++の強力なテンプレート機能とメタプログラミングを組み合わせることで、コンパイル時に安全で効率的なポリモーフィズムを達成することが可能です。この記事では、その具体的な手法と応用例を通じて、メタプログラミングによるポリモーフィズムの実現方法を詳しく説明します。

メタプログラミングとは
ポリモーフィズムの基本
メタプログラミングによるポリモーフィズムの実現方法
テンプレートメタプログラミングの基礎
コンパイル時ポリモーフィズムの実装例
実行時ポリモーフィズムとの違い
型特性と型特性メタプログラミング
高度なメタプログラミング技法
パフォーマンスの考慮
応用例：DSL（ドメイン特化言語）の実装
演習問題
まとめ

メタプログラミングとは

メタプログラミングは、プログラムが他のプログラムを生成、変換、操作する技術です。これは「コードを生成するコード」として理解されることが多く、プログラムの柔軟性と再利用性を高めるために使用されます。C++では、テンプレートを用いることでコンパイル時にメタプログラミングを実現することができます。テンプレートメタプログラミング（TMP）は、コードの生成をコンパイル時に行い、実行時のパフォーマンスを最適化する強力な手法です。次に、メタプログラミングの利点とその基本的な利用方法について詳しく見ていきましょう。

ポリモーフィズムの基本

ポリモーフィズム（多態性）は、オブジェクト指向プログラミングの重要な概念の一つで、異なるデータ型が同一のインターフェースを通じて操作されることを指します。これにより、コードの再利用性が向上し、拡張性が高まります。C++においては、ポリモーフィズムは主に二つの形態で実現されます：実行時ポリモーフィズム（ランタイムポリモーフィズム）とコンパイル時ポリモーフィズム（コンパイルタイムポリモーフィズム）です。実行時ポリモーフィズムは、仮想関数を使用して動的にオブジェクトのメソッドを呼び出す方法で、コンパイル時ポリモーフィズムは、テンプレートを使用してコンパイル時に型を決定する方法です。次に、これらのポリモーフィズムの違いと、メタプログラミングを利用してどのように実現できるかを詳しく見ていきます。

メタプログラミングによるポリモーフィズムの実現方法

メタプログラミングを活用することで、C++でのポリモーフィズムをさらに強力にすることができます。特にテンプレートメタプログラミングを使用することで、コンパイル時に型を決定し、パフォーマンスを最適化しながらポリモーフィズムを実現します。

テンプレートを用いた基本的なポリモーフィズム

テンプレートを使うことで、同一の関数やクラスが異なる型に対して動作するように設計できます。以下は、簡単なテンプレート関数の例です。

template<typename T>
void print(const T& value) {
    std::cout << value << std::endl;
}

この関数は、引数の型に依存せずに任意の型の値を出力します。

コンパイル時条件分岐による柔軟な設計

テンプレートメタプログラミングでは、コンパイル時に条件分岐を行うことで、より柔軟なコードを記述できます。例えば、std::enable_ifを用いることで、条件に応じて異なる実装を提供できます。

template<typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
process(const T& value) {
    std::cout << "Integer: " << value << std::endl;
}

template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
process(const T& value) {
    std::cout << "Floating point: " << value << std::endl;
}

この例では、process関数が整数型と浮動小数点型で異なる動作をします。

ポリシークラスを用いた高度なポリモーフィズム

ポリシークラスを使用することで、アルゴリズムの一部をテンプレート引数として外部から注入することができます。これにより、動的な多態性をコンパイル時に実現できます。

template<typename T, typename Policy>
class Container {
public:
    void executePolicy(const T& value) {
        Policy::execute(value);
    }
};

struct PrintPolicy {
    template<typename T>
    static void execute(const T& value) {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    Container<int, PrintPolicy> container;
    container.executePolicy(42);
    return 0;
}

この例では、ContainerクラスがPrintPolicyを用いて値を出力します。ポリシーを変更することで、動作を柔軟に変更できます。

以上のように、メタプログラミングを利用することで、C++におけるポリモーフィズムを強化し、コンパイル時に安全かつ効率的なコードを実現できます。次に、テンプレートメタプログラミングの基礎について詳しく見ていきましょう。

テンプレートメタプログラミングの基礎

テンプレートメタプログラミング（TMP）は、コンパイル時にコードを生成する強力な技法です。C++のテンプレート機能を活用することで、コードの再利用性を高め、コンパイル時のエラー検出を強化できます。

基本的なテンプレート構文

テンプレートは、クラスや関数の定義において型パラメータを使用することで、汎用性を持たせることができます。以下は基本的なテンプレートクラスの例です。

template<typename T>
class MyClass {
public:
    MyClass(T value) : value_(value) {}
    void print() const {
        std::cout << value_ << std::endl;
    }
private:
    T value_;
};

このクラスは、任意の型Tを受け取り、その型の値を保持します。

テンプレート特殊化

テンプレートの特殊化は、特定の型に対して異なる実装を提供する手法です。これにより、汎用的なテンプレートコードを特定のケースに最適化できます。

template<>
class MyClass<int> {
public:
    MyClass(int value) : value_(value) {}
    void print() const {
        std::cout << "Specialized for int: " << value_ << std::endl;
    }
private:
    int value_;
};

この例では、int型に対する特殊化が行われ、printメソッドの出力が異なります。

テンプレートメタプログラミングの再帰

TMPでは、再帰的なテンプレートを用いて計算を行うことが一般的です。以下は、コンパイル時に階乗を計算するテンプレートの例です。

template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static const int value = 1;
};

このコードは、コンパイル時にFactorial<5>::valueとして使用することで、5の階乗を計算します。

型特性を用いたテンプレートメタプログラミング

std::is_sameやstd::is_integralといった型特性を利用することで、テンプレートの動作を型に基づいて分岐させることができます。

template<typename T>
void checkType() {
    if (std::is_integral<T>::value) {
        std::cout << "Type is integral" << std::endl;
    } else {
        std::cout << "Type is not integral" << std::endl;
    }
}

この関数は、渡された型が整数型かどうかを判定します。

以上のように、テンプレートメタプログラミングの基礎を理解することで、C++における強力なコード生成と最適化を実現できます。次に、具体的なコンパイル時ポリモーフィズムの実装例を見ていきましょう。

コンパイル時ポリモーフィズムの実装例

コンパイル時ポリモーフィズムは、テンプレートメタプログラミングを利用して、コンパイル時に型を決定し、多態性を実現する手法です。以下に、具体的な実装例をいくつか紹介します。

型特性を利用したポリモーフィズム

型特性を利用することで、異なる型に対して異なる動作を実装できます。以下は、整数型と浮動小数点型に対して異なる処理を行う例です。

template<typename T>
struct TypeHandler;

template<>
struct TypeHandler<int> {
    static void process(int value) {
        std::cout << "Processing integer: " << value << std::endl;
    }
};

template<>
struct TypeHandler<double> {
    static void process(double value) {
        std::cout << "Processing double: " << value << std::endl;
    }
};

template<typename T>
void handleType(T value) {
    TypeHandler<T>::process(value);
}

int main() {
    handleType(42);
    handleType(3.14);
    return 0;
}

この例では、handleType関数が引数の型に基づいて適切なTypeHandlerを選び、そのprocessメソッドを呼び出します。

タグディスパッチによるポリモーフィズム

タグディスパッチを用いることで、型情報に基づいて異なる関数を呼び出すことができます。以下は、その具体例です。

struct IntTag {};
struct DoubleTag {};

template<typename T>
struct TypeTag;

template<>
struct TypeTag<int> {
    using type = IntTag;
};

template<>
struct TypeTag<double> {
    using type = DoubleTag;
};

void process(IntTag, int value) {
    std::cout << "Processing integer via tag: " << value << std::endl;
}

void process(DoubleTag, double value) {
    std::cout << "Processing double via tag: " << value << std::endl;
}

template<typename T>
void process(T value) {
    process(typename TypeTag<T>::type{}, value);
}

int main() {
    process(42);
    process(3.14);
    return 0;
}

この例では、TypeTagを使って型ごとに異なるタグを割り当て、process関数でタグに基づいて適切な処理を行います。

テンプレートテンプレートパラメータによるポリモーフィズム

テンプレートテンプレートパラメータを利用することで、さらに柔軟なポリモーフィズムを実現できます。以下は、その具体例です。

template<template<typename> class Policy, typename T>
class Processor {
public:
    void process(const T& value) {
        Policy<T>::execute(value);
    }
};

template<typename T>
struct PrintPolicy {
    static void execute(const T& value) {
        std::cout << "Value: " << value << std::endl;
    }
};

template<typename T>
struct MultiplyPolicy {
    static void execute(const T& value) {
        std::cout << "Value * 2: " << value * 2 << std::endl;
    }
};

int main() {
    Processor<PrintPolicy, int> printProcessor;
    printProcessor.process(42);

    Processor<MultiplyPolicy, double> multiplyProcessor;
    multiplyProcessor.process(3.14);

    return 0;
}

この例では、Processorクラスがテンプレートテンプレートパラメータを受け取り、異なるポリシーに基づいて処理を実行します。

これらの例を通じて、コンパイル時ポリモーフィズムの強力な手法と、その実装方法を理解できたでしょう。次に、コンパイル時ポリモーフィズムと実行時ポリモーフィズムの違いについて詳しく解説します。

実行時ポリモーフィズムとの違い

コンパイル時ポリモーフィズムと実行時ポリモーフィズムは、どちらもC++における多態性を実現する手法ですが、動作タイミングや実装方法に大きな違いがあります。

実行時ポリモーフィズム

実行時ポリモーフィズムは、オブジェクト指向プログラミングの基本概念で、動的にオブジェクトのメソッドを呼び出す手法です。主に仮想関数と継承を使用して実現されます。以下は、その具体例です。

class Base {
public:
    virtual void show() const {
        std::cout << "Base class" << std::endl;
    }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void show() const override {
        std::cout << "Derived class" << std::endl;
    }
};

void display(const Base& obj) {
    obj.show();
}

int main() {
    Base base;
    Derived derived;
    display(base);
    display(derived);
    return 0;
}

この例では、display関数がBase型の参照を受け取り、実行時に実際のオブジェクトの型に応じて適切なshowメソッドが呼び出されます。

コンパイル時ポリモーフィズム

一方、コンパイル時ポリモーフィズムは、テンプレートメタプログラミングを利用して、コンパイル時に型を決定し、多態性を実現する手法です。これは、テンプレートの型引数により、異なる型に対して異なる動作を提供するものです。以下は、その具体例です。

template<typename T>
void show(const T& obj) {
    obj.show();
}

class Base {
public:
    void show() const {
        std::cout << "Base class" << std::endl;
    }
};

class Derived {
public:
    void show() const {
        std::cout << "Derived class" << std::endl;
    }
};

int main() {
    Base base;
    Derived derived;
    show(base);
    show(derived);
    return 0;
}

この例では、show関数がテンプレートとして定義されており、引数の型に応じて異なるshowメソッドがコンパイル時に決定されます。

違いの比較

実行時ポリモーフィズム:
動的に型を決定するため、実行時にオーバーヘッドが発生します。
仮想関数テーブルを使用し、動的なタイプチェックとメソッドの呼び出しが行われます。
柔軟で直感的なオブジェクト指向設計をサポートしますが、パフォーマンス面で不利です。
コンパイル時ポリモーフィズム:
コンパイル時に型を決定するため、実行時のオーバーヘッドがありません。
テンプレートメタプログラミングを利用し、型安全性を強化できます。
パフォーマンスが高く、コードの再利用性が向上しますが、テンプレートの複雑さを管理する必要があります。

これらの違いを理解することで、適切な状況でそれぞれのポリモーフィズムを効果的に利用することができます。次に、型特性と型特性メタプログラミングについて詳しく見ていきましょう。

型特性と型特性メタプログラミング

型特性は、型の特定の性質や特性を表現するために使用されるメタプログラミングの概念です。C++の標準ライブラリでは、多くの型特性が提供されており、これらを活用することで、より柔軟で強力なテンプレートプログラミングが可能になります。

基本的な型特性の利用

型特性は、std::is_integralやstd::is_floating_pointなどの型トレイトを使用して、型の特定の特性をチェックするために使用されます。以下は、型特性を用いた簡単な例です。

#include <iostream>
#include <type_traits>

template<typename T>
void checkType(T value) {
    if (std::is_integral<T>::value) {
        std::cout << "Type is integral" << std::endl;
    } else if (std::is_floating_point<T>::value) {
        std::cout << "Type is floating point" << std::endl;
    } else {
        std::cout << "Type is something else" << std::endl;
    }
}

int main() {
    checkType(42);       // 出力: Type is integral
    checkType(3.14);     // 出力: Type is floating point
    checkType("hello");  // 出力: Type is something else
    return 0;
}

この例では、std::is_integralとstd::is_floating_pointを使用して、与えられた型が整数型か浮動小数点型かを判定しています。

カスタム型特性の定義

独自の型特性を定義することも可能です。以下は、カスタム型特性を定義して特定の条件をチェックする例です。

#include <iostream>
#include <type_traits>

// カスタム型特性: 文字列型かどうかをチェック
template<typename T>
struct is_string {
    static const bool value = false;
};

template<>
struct is_string<std::string> {
    static const bool value = true;
};

template<typename T>
void checkStringType(T value) {
    if (is_string<T>::value) {
        std::cout << "Type is string" << std::endl;
    } else {
        std::cout << "Type is not string" << std::endl;
    }
}

int main() {
    checkStringType(42);           // 出力: Type is not string
    checkStringType(std::string("hello")); // 出力: Type is string
    return 0;
}

この例では、is_string型特性を定義し、std::string型かどうかを判定しています。

型特性メタプログラミングの応用例

型特性を組み合わせることで、より高度なメタプログラミングが可能です。以下は、複数の型特性を組み合わせて関数の動作を制御する例です。

#include <iostream>
#include <type_traits>

// 複数の型特性を組み合わせる例
template<typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
process(T value) {
    std::cout << "Processing integral type: " << value << std::endl;
}

template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
process(T value) {
    std::cout << "Processing floating point type: " << value << std::endl;
}

int main() {
    process(42);      // 出力: Processing integral type: 42
    process(3.14);    // 出力: Processing floating point type: 3.14
    return 0;
}

この例では、std::enable_ifと型特性を組み合わせて、整数型と浮動小数点型で異なる処理を行っています。

型特性を活用することで、より型安全で柔軟なコードを実現することができます。次に、さらに高度なメタプログラミング技法について詳しく見ていきましょう。

高度なメタプログラミング技法

メタプログラミングの基本を理解した後は、より高度な技法を学ぶことで、さらに強力なコードを記述できるようになります。ここでは、高度なメタプログラミング技法をいくつか紹介します。

テンプレートの再帰的使用

テンプレートの再帰的使用は、コンパイル時に計算を行うための一般的な手法です。以下は、フィボナッチ数列をコンパイル時に計算する例です。

#include <iostream>

// フィボナッチ数列のテンプレート再帰
template<int N>
struct Fibonacci {
    static const int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};

template<>
struct Fibonacci<0> {
    static const int value = 0;
};

template<>
struct Fibonacci<1> {
    static const int value = 1;
};

int main() {
    std::cout << "Fibonacci<10>::value = " << Fibonacci<10>::value << std::endl; // 出力: 55
    return 0;
}

この例では、テンプレートの再帰を用いてフィボナッチ数列の値をコンパイル時に計算しています。

テンプレートの分岐

テンプレートの分岐は、条件に応じて異なるテンプレートを選択するために使用されます。std::conditionalを利用することで実現できます。

#include <iostream>
#include <type_traits>

// テンプレートの分岐
template<bool Condition, typename TrueType, typename FalseType>
struct Conditional {
    using type = TrueType;
};

template<typename TrueType, typename FalseType>
struct Conditional<false, TrueType, FalseType> {
    using type = FalseType;
};

int main() {
    using SelectedType = Conditional<true, int, double>::type;
    SelectedType value = 42;
    std::cout << "SelectedType is int: " << value << std::endl; // 出力: 42

    return 0;
}

この例では、条件に応じてint型かdouble型を選択しています。

テンプレートメタプログラミングによるDSLの実装

ドメイン特化言語（DSL）をテンプレートメタプログラミングで実装することで、特定のドメインに特化した柔軟なコードを記述できます。以下は、簡単なDSLを用いて数式を評価する例です。

#include <iostream>

// DSLの基本要素
template<int N>
struct Value {
    static const int value = N;
};

template<typename L, typename R>
struct Add {
    static const int value = L::value + R::value;
};

template<typename L, typename R>
struct Subtract {
    static const int value = L::value - R::value;
};

int main() {
    using Expression = Add<Value<10>, Subtract<Value<5>, Value<3>>>;
    std::cout << "Expression value: " << Expression::value << std::endl; // 出力: 12

    return 0;
}

この例では、テンプレートを用いて数式を定義し、コンパイル時に評価しています。

型リストとメタ関数

型リストは、テンプレートメタプログラミングにおいて複数の型を扱うための便利な手法です。以下は、型リストを操作するメタ関数の例です。

#include <iostream>
#include <type_traits>

// 型リストの定義
template<typename... Types>
struct TypeList {};

// 型リストの長さを求めるメタ関数
template<typename List>
struct Length;

template<typename... Types>
struct Length<TypeList<Types...>> {
    static const size_t value = sizeof...(Types);
};

int main() {
    using MyTypes = TypeList<int, double, char>;
    std::cout << "Length of MyTypes: " << Length<MyTypes>::value << std::endl; // 出力: 3

    return 0;
}

この例では、型リストを定義し、その長さを求めるメタ関数を実装しています。

これらの高度なメタプログラミング技法を駆使することで、C++プログラムの柔軟性と効率性を大幅に向上させることができます。次に、メタプログラミングを用いる際のパフォーマンス面の考慮点について見ていきましょう。

パフォーマンスの考慮

メタプログラミングを用いる際には、パフォーマンス面の考慮が重要です。特に、コンパイル時と実行時のパフォーマンスに影響を与える要因を理解し、最適化することが求められます。

コンパイル時間の増加

テンプレートメタプログラミングは、コンパイル時に多くの計算やコード生成を行うため、コンパイル時間が長くなることがあります。これを最小限に抑えるためには、以下の点に注意が必要です。

テンプレートのインスタンス化を減らす: 不必要なテンプレートのインスタンス化を避け、必要最小限のテンプレートを使用します。
コードの分割: ヘッダーファイルと実装ファイルを適切に分割し、コンパイルユニットを小さく保つことで、コンパイル時間を短縮します。

実行時パフォーマンスの最適化

メタプログラミングにより生成されたコードは、手書きの最適化コードと同等の実行時パフォーマンスを持つことが期待されます。以下の点を考慮することで、実行時パフォーマンスを最適化できます。

インライン展開: メタプログラミングを使用することで、多くのコードがインライン展開されます。これにより、関数呼び出しのオーバーヘッドが削減され、実行時のパフォーマンスが向上します。
定数畳み込み: コンパイル時に計算が行われるため、定数畳み込みが発生し、実行時の計算コストが削減されます。

メモリ使用量の管理

メタプログラミングを使用すると、生成されるコードが増加し、メモリ使用量が増える可能性があります。メモリ使用量を管理するための方法をいくつか紹介します。

不要なコード生成の抑制: 使用されないテンプレートインスタンス化を避け、メモリ使用量を削減します。
適切なデータ構造の選択: メタプログラミングを使用する際には、効率的なデータ構造を選択し、メモリの無駄遣いを避けます。

デバッグの難易度

メタプログラミングは高度で複雑なコードを生成するため、デバッグが難しくなることがあります。以下の方法でデバッグを容易にすることができます。

静的アサーション: static_assertを使用して、コンパイル時に条件をチェックし、エラーを早期に検出します。
型トレイトの利用: 型トレイトを利用して、型に関する情報を明示的に示し、デバッグを容易にします。

パフォーマンスと可読性のバランス

メタプログラミングを用いることで得られるパフォーマンスの向上と、コードの可読性や保守性とのバランスを取ることが重要です。高性能なコードを実現するためには、以下のポイントに注意します。

コードのドキュメント化: メタプログラミングの意図や仕組みを明確にするために、コードに適切なコメントを付けます。
シンプルな設計: 可能な限りシンプルな設計を心掛け、複雑なメタプログラミング技法は必要な場合にのみ使用します。

これらの考慮点を踏まえ、メタプログラミングを効果的に活用することで、高性能かつ保守性の高いC++コードを実現できます。次に、メタプログラミングを応用した具体的なドメイン特化言語（DSL）の実装例について見ていきましょう。

応用例：DSL（ドメイン特化言語）の実装

ドメイン特化言語（DSL）は、特定の問題領域に特化した簡潔な言語です。メタプログラミングを用いることで、C++内でDSLを実装し、特定のタスクを効率的に表現することができます。ここでは、数式を評価するDSLの実装例を紹介します。

基本構造の定義

まず、DSLの基本構造となる要素を定義します。ここでは、値を保持する構造と、演算を表現する構造を定義します。

#include <iostream>

// DSLの基本要素
template<int N>
struct Value {
    static const int value = N;
};

template<typename L, typename R>
struct Add {
    static const int value = L::value + R::value;
};

template<typename L, typename R>
struct Subtract {
    static const int value = L::value - R::value;
};

このコードでは、Valueが定数値を保持し、AddとSubtractが加算と減算を表現します。

DSLの利用例

次に、このDSLを利用して数式を定義し、評価します。

int main() {
    using Expression = Add<Value<10>, Subtract<Value<5>, Value<3>>>;
    std::cout << "Expression value: " << Expression::value << std::endl; // 出力: 12

    return 0;
}

この例では、AddとSubtractを組み合わせて、10 + (5 - 3)という数式を定義し、その結果を評価しています。

複雑な演算の追加

DSLを拡張して、乗算と除算もサポートするようにします。

template<typename L, typename R>
struct Multiply {
    static const int value = L::value * R::value;
};

template<typename L, typename R>
struct Divide {
    static const int value = L::value / R::value;
};

この拡張により、より複雑な数式を扱うことができるようになります。

複雑な数式の評価

新しい演算を追加したDSLを使って、複雑な数式を評価します。

int main() {
    using Expression = Divide<Multiply<Add<Value<10>, Value<5>>, Value<2>>, Value<3>>;
    std::cout << "Expression value: " << Expression::value << std::endl; // 出力: 10

    return 0;
}

この例では、(10 + 5) * 2 / 3という複雑な数式を評価しています。

型特性を用いたDSLの拡張

型特性を利用して、DSLの柔軟性をさらに高めることができます。例えば、整数型と浮動小数点型の両方をサポートするようにDSLを拡張することが可能です。

template<typename T>
struct Value {
    static const T value;
};

template<typename T>
const T Value<T>::value = T();

template<typename T, typename U>
struct Add {
    static const auto value = T::value + U::value;
};

template<typename T, typename U>
struct Subtract {
    static const auto value = T::value - U::value;
};

int main() {
    using Expression = Add<Value<int>, Subtract<Value<double>, Value<float>>>;
    std::cout << "Expression value: " << Expression::value << std::endl; // 型に応じた結果を出力

    return 0;
}

この例では、Valueが任意の型をサポートするようにし、演算も対応するように拡張しています。

まとめ

このように、メタプログラミングを用いることで、C++内でDSLを実装し、特定のドメインに特化した効率的なコードを記述することができます。DSLの実装は、特定のタスクを簡潔に表現する手段を提供し、コードの可読性と保守性を向上させます。次に、理解を深めるための演習問題を提示します。

演習問題

メタプログラミングとポリモーフィズムに関する理解を深めるために、以下の演習問題に取り組んでみましょう。

問題1: フィボナッチ数列の実装

テンプレートメタプログラミングを用いて、コンパイル時にフィボナッチ数列を計算する構造を実装してください。特定の値Nに対するフィボナッチ数を計算するFibonacciテンプレートを定義します。

template<int N>
struct Fibonacci {
    static const int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};

template<>
struct Fibonacci<0> {
    static const int value = 0;
};

template<>
struct Fibonacci<1> {
    static const int value = 1;
};

// 使用例
int main() {
    std::cout << "Fibonacci<10>::value = " << Fibonacci<10>::value << std::endl; // 出力: 55
    return 0;
}

問題2: 型特性の定義

独自の型特性is_pointerを定義し、渡された型がポインタ型であるかどうかを判定するメタプログラムを実装してください。

template<typename T>
struct is_pointer {
    static const bool value = false;
};

template<typename T>
struct is_pointer<T*> {
    static const bool value = true;
};

// 使用例
int main() {
    std::cout << "is_pointer<int>::value = " << is_pointer<int>::value << std::endl; // 出力: 0
    std::cout << "is_pointer<int*>::value = " << is_pointer<int*>::value << std::endl; // 出力: 1
    return 0;
}

問題3: タグディスパッチの実装

タグディスパッチを用いて、整数型と浮動小数点型に対して異なる処理を行う関数processを実装してください。

struct IntTag {};
struct FloatTag {};

template<typename T>
struct TypeTag;

template<>
struct TypeTag<int> {
    using type = IntTag;
};

template<>
struct TypeTag<float> {
    using type = FloatTag;
};

void process(IntTag, int value) {
    std::cout << "Processing int: " << value << std::endl;
}

void process(FloatTag, float value) {
    std::cout << "Processing float: " << value << std::endl;
}

template<typename T>
void process(T value) {
    process(typename TypeTag<T>::type{}, value);
}

// 使用例
int main() {
    process(42);      // 出力: Processing int: 42
    process(3.14f);   // 出力: Processing float: 3.14
    return 0;
}

問題4: コンパイル時条件分岐

std::enable_ifを用いて、整数型のみに適用される関数is_evenを実装してください。関数は、与えられた整数が偶数かどうかを判定します。

template<typename T>
typename std::enable_if<std::is_integral<T>::value, bool>::type
is_even(T value) {
    return value % 2 == 0;
}

// 使用例
int main() {
    std::cout << "is_even(4) = " << is_even(4) << std::endl; // 出力: 1 (true)
    std::cout << "is_even(5) = " << is_even(5) << std::endl; // 出力: 0 (false)
    // std::cout << "is_even(3.14) = " << is_even(3.14) << std::endl; // コンパイルエラー
    return 0;
}

問題5: メタプログラミングによる型リストの操作

型リストを定義し、その長さを計算するメタプログラムLengthを実装してください。また、型リストに新しい型を追加するAppendメタプログラムも実装してください。

template<typename... Types>
struct TypeList {};

template<typename List>
struct Length;

template<typename... Types>
struct Length<TypeList<Types...>> {
    static const size_t value = sizeof...(Types);
};

template<typename List, typename NewType>
struct Append;

template<typename... Types, typename NewType>
struct Append<TypeList<Types...>, NewType> {
    using type = TypeList<Types..., NewType>;
};

// 使用例
using MyTypes = TypeList<int, double, char>;
std::cout << "Length of MyTypes: " << Length<MyTypes>::value << std::endl; // 出力: 3

using NewTypes = Append<MyTypes, float>::type;
std::cout << "Length of NewTypes: " << Length<NewTypes>::value << std::endl; // 出力: 4

これらの演習問題に取り組むことで、メタプログラミングとポリモーフィズムに対する理解が深まるでしょう。最後に、この記事の内容をまとめます。

まとめ

本記事では、C++のメタプログラミングによるポリモーフィズムの実現方法について詳しく解説しました。メタプログラミングの基本概念から始まり、ポリモーフィズムの基本、テンプレートメタプログラミングの基礎、そして高度なメタプログラミング技法まで、幅広いトピックをカバーしました。特に、コンパイル時ポリモーフィズムの具体的な実装例や、型特性を用いた柔軟なメタプログラミング技法、パフォーマンス面での考慮点について詳述しました。さらに、応用例としてドメイン特化言語（DSL）の実装方法を紹介し、理解を深めるための演習問題を提供しました。これらの知識を活用することで、C++プログラムの柔軟性と効率性を大幅に向上させることができるでしょう。