C++メタプログラミングと最適化技法を徹底解説

#include <iostream>

// 階乗を計算するメタ関数
template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

// 階乗計算の終了条件
template<>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    std::cout << "5! = " << Factorial<5>::value << std::endl;
    return 0;
}

#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;
    return 0;
}

#include <iostream>

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

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

int main() {
    std::cout << "2^10 = " << PowerOfTwo<10>::value << std::endl;
    return 0;
}

#include <iostream>

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : (n * factorial(n - 1));
}

int main() {
    constexpr int result = factorial(5);
    std::cout << "5! = " << result << std::endl;
    return 0;
}

#include <iostream>

template<typename T>
struct DataType;

template<>
struct DataType<int> {
    static void print() {
        std::cout << "Type: int" << std::endl;
    }
};

template<>
struct DataType<double> {
    static void print() {
        std::cout << "Type: double" << std::endl;
    }
};

int main() {
    DataType<int>::print();
    DataType<double>::print();
    return 0;
}

#include <iostream>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/for_each.hpp>

namespace mpl = boost::mpl;

struct print_type {
    template <typename T>
    void operator()(T) {
        std::cout << typeid(T).name() << std::endl;
    }
};

int main() {
    typedef mpl::vector<int, double, char> types;
    typedef mpl::push_back<types, float>::type new_types;

    mpl::for_each<new_types>(print_type());
    return 0;
}

#include <iostream>
#include <boost/mpl/int.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/times.hpp>

namespace mpl = boost::mpl;

int main() {
    typedef mpl::int_<5> five;
    typedef mpl::int_<10> ten;

    typedef mpl::plus<five, ten>::type fifteen;
    typedef mpl::times<fifteen, five>::type seventy_five;

    std::cout << "5 + 10 = " << fifteen::value << std::endl;
    std::cout << "15 * 5 = " << seventy_five::value << std::endl;

    return 0;
}

#include <iostream>

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : (n * factorial(n - 1));
}

int main() {
    constexpr int result = factorial(5);
    std::cout << "5! = " << result << std::endl;
    return 0;
}

constexpr int x = 10;
constexpr int y = x + 5;

constexpr int add(int a, int b) {
    return a + b;
}

int main() {
    constexpr int sum = add(x, y);
    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

#include <iostream>

constexpr int fibonacci(int n) {
    return (n <= 1) ? n : (fibonacci(n - 1) + fibonacci(n - 2));
}

int main() {
    constexpr int size = fibonacci(10);
    int arr[size]; // size is determined at compile-time

    std::cout << "Array size: " << size << std::endl;
    return 0;
}

#include <iostream>

template<int N>
constexpr int power(int base) {
    return (N == 0) ? 1 : (base * power<N - 1>(base));
}

int main() {
    constexpr int result = power<3>(2); // 2^3
    std::cout << "2^3 = " << result << std::endl;
    return 0;
}

#include <iostream>
#include <type_traits>

// 型変換のためのメタ関数
template<typename T>
struct TypeIdentity {
    using type = T;
};

// 特定の型を別の型に変換
template<>
struct TypeIdentity<int> {
    using type = double;
};

int main() {
    TypeIdentity<int>::type value = 3.14; // int が double に変換される
    std::cout << value << std::endl;      // 出力: 3.14
    return 0;
}

#include <iostream>

// 配列要素の累積を計算するメタ関数
template<int... Ns>
struct ArraySum;

template<int N, int... Ns>
struct ArraySum<N, Ns...> {
    static const int value = N + ArraySum<Ns...>::value;
};

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

int main() {
    std::cout << "Sum: " << ArraySum<1, 2, 3, 4, 5>::value << std::endl; // 出力: 15
    return 0;
}

#include <iostream>

// 二分木のノードを表すメタ構造体
template<typename Left, typename Right>
struct Node {};

// 葉ノードを表すメタ構造体
struct Leaf {};

// 二分木を生成するメタ関数
template<int N>
struct GenerateTree {
    using type = Node<typename GenerateTree<N-1>::type, typename GenerateTree<N-1>::type>;
};

template<>
struct GenerateTree<0> {
    using type = Leaf;
};

int main() {
    using Tree = GenerateTree<3>::type; // 高さ3の二分木を生成
    std::cout << "Tree generated." << std::endl;
    return 0;
}

#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;
    return 0;
}

#include <iostream>
#include <type_traits>

// 型特化によるメタ関数
template<typename T>
struct TypeTrait;

template<>
struct TypeTrait<int> {
    static void print() {
        std::cout << "Type: int" << std::endl;
    }
};

template<>
struct TypeTrait<double> {
    static void print() {
        std::cout << "Type: double" << std::endl;
    }
};

template<>
struct TypeTrait<char> {
    static void print() {
        std::cout << "Type: char" << std::endl;
    }
};

int main() {
    TypeTrait<int>::print();    // 出力: Type: int
    TypeTrait<double>::print(); // 出力: Type: double
    TypeTrait<char>::print();   // 出力: Type: char
    return 0;
}

#include <iostream>

// 配列要素の和を計算するメタ関数
template<int... Ns>
struct ArraySum;

template<int N, int... Ns>
struct ArraySum<N, Ns...> {
    static const int value = N + ArraySum<Ns...>::value;
};

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

int main() {
    std::cout << "ArraySum<1, 2, 3, 4, 5>::value = " << ArraySum<1, 2, 3, 4, 5>::value << std::endl; // 出力: 15
    return 0;
}

#include <iostream>

struct Base {
    virtual void execute() = 0;
};

struct Derived1 : Base {
    void execute() override {
        std::cout << "Derived1 execute" << std::endl;
    }
};

struct Derived2 : Base {
    void execute() override {
        std::cout << "Derived2 execute" << std::endl;
    }
};

template<typename T>
void call_execute(T& obj) {
    obj.execute();
}

int main() {
    Derived1 d1;
    Derived2 d2;

    call_execute(d1); // 出力: Derived1 execute
    call_execute(d2); // 出力: Derived2 execute

    return 0;
}

# Unix系システムでのコンパイル時間測定
time g++ -o my_program my_program.cpp

#include <iostream>
#include <chrono>

// ベンチマーク対象の関数
template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

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

int main() {
    auto start = std::chrono::high_resolution_clock::now();

    // メタプログラミングによる計算
    volatile int result = Factorial<10>::value;

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration = end - start;

    std::cout << "Execution time: " << duration.count() << " seconds" << std::endl;
    return 0;
}

# Unix系システムでのメモリ使用量測定
/usr/bin/time -v g++ -o my_program my_program.cpp

#include <iostream>

// コンパイル時に最大値を計算するメタ関数
template<int A, int B>
struct Max {
    static const int value = (A > B) ? A : B;
};

template<int A, int B, int... Rest>
struct Max<A, B, Rest...> {
    static const int value = Max<Max<A, B>::value, Rest...>::value;
};

int main() {
    std::cout << "Max value: " << Max<3, 8, 1, 7, 2, 9>::value << std::endl; // 出力: 9
    return 0;
}

#include <iostream>
#include <array>

// フィボナッチ数をコンパイル時に計算するメタ関数
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;
};

// フィボナッチ数列を配列に格納するメタ関数
template<int... Ns>
struct FibonacciArray;

template<int N, int... Ns>
struct FibonacciArray<N, Ns...> {
    static const std::array<int, N + 1> value;
};

template<int N, int... Ns>
const std::array<int, N + 1> FibonacciArray<N, Ns...>::value = { Fibonacci<Ns>::value... };

template<int N, int... Ns>
struct GenerateFibonacciArray {
    using type = FibonacciArray<N, Ns...>;
};

template<int N>
struct GenerateFibonacciArray<N> {
    using type = typename GenerateFibonacciArray<N - 1, N>::type;
};

template<>
struct GenerateFibonacciArray<0> {
    using type = FibonacciArray<0>;
};

int main() {
    constexpr auto fib_array = GenerateFibonacciArray<10>::type::value;
    for (int i = 0; i <= 10; ++i) {
        std::cout << "Fibonacci[" << i << "] = " << fib_array[i] << std::endl;
    }
    return 0;
}

#include <iostream>

// 型リストを表現するテンプレート
template<typename... Types>
struct TypeList {};

// 型リストのサイズを計算するメタ関数
template<typename T>
struct SizeOfTypeList;

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

int main() {
    using MyTypeList = TypeList<int, double, char, float>;
    std::cout << "Size of type list: " << SizeOfTypeList<MyTypeList>::value << std::endl; // 出力: 4
    return 0;
}