C++メタプログラミングを使った条件付きコンパイルとコンパイル時文字列操作の実践ガイド

#ifdef FEATURE_ENABLED
    // FEATURE_ENABLEDが定義されている場合にコンパイルされるコード
#endif

#ifndef FEATURE_DISABLED
    // FEATURE_DISABLEDが定義されていない場合にコンパイルされるコード
#endif

#if defined(WINDOWS)
    // Windowsプラットフォーム用のコード
#elif defined(LINUX)
    // Linuxプラットフォーム用のコード
#else
    // その他のプラットフォーム用のコード
#endif

#define FEATURE_X_ENABLED

#ifdef FEATURE_X_ENABLED
void useFeatureX() {
    // Feature Xを使用するためのコード
}
#else
void useFeatureX() {
    // Feature Xが無効な場合の代替コード
}
#endif

template <int N>
struct IsEven {
    static const bool value = (N % 2) == 0;
};

template <bool Condition>
struct ConditionalCompiler;

template <>
struct ConditionalCompiler<true> {
    static void execute() {
        // 条件がtrueの場合に実行されるコード
        std::cout << "Condition is true." << std::endl;
    }
};

template <>
struct ConditionalCompiler<false> {
    static void execute() {
        // 条件がfalseの場合に実行されるコード
        std::cout << "Condition is false." << std::endl;
    }
};

int main() {
    const int number = 4;
    ConditionalCompiler<IsEven<number>::value>::execute();
    return 0;
}

constexpr size_t strlen_constexpr(const char* str) {
    return *str ? 1 + strlen_constexpr(str + 1) : 0;
}

int main() {
    constexpr size_t length = strlen_constexpr("Hello, World!");
    static_assert(length == 13, "Length should be 13");
    return 0;
}

template <char... Chars>
struct String {
    static constexpr const char value[sizeof...(Chars) + 1] = { Chars..., '\0' };
};

template <typename S, char C>
struct Append;

template <char... Chars, char C>
struct Append<String<Chars...>, C> {
    using type = String<Chars..., C>;
};

template <typename S>
struct Reverse;

template <char First, char... Rest>
struct Reverse<String<First, Rest...>> {
    using type = typename Append<typename Reverse<String<Rest...>>::type, First>::type;
};

template <>
struct Reverse<String<>> {
    using type = String<>;
};

int main() {
    using Original = String<'H', 'e', 'l', 'l', 'o'>;
    using Reversed = Reverse<Original>::type;
    constexpr const char* reversed_str = Reversed::value;
    return 0;
}

template <size_t N>
constexpr size_t length(const char (&)[N]) {
    return N - 1;
}

template <size_t N1, size_t N2>
constexpr auto concat(const char (&s1)[N1], const char (&s2)[N2]) {
    char result[N1 + N2 - 1] = {};
    for (size_t i = 0; i < N1 - 1; ++i) {
        result[i] = s1[i];
    }
    for (size_t i = 0; i < N2; ++i) {
        result[N1 - 1 + i] = s2[i];
    }
    return result;
}

int main() {
    constexpr auto result = concat("Hello, ", "World!");
    static_assert(length(result) == 13, "Length should be 13");
    return 0;
}

constexpr char to_upper(char c) {
    return (c >= 'a' && c <= 'z') ? c - 32 : c;
}

template <size_t N>
constexpr auto to_uppercase(const char (&str)[N]) {
    char result[N] = {};
    for (size_t i = 0; i < N - 1; ++i) {
        result[i] = to_upper(str[i]);
    }
    result[N - 1] = '\0';
    return result;
}

int main() {
    constexpr auto upper = to_uppercase("Hello, World!");
    static_assert(upper[0] == 'H' && upper[7] == 'W', "First and seventh characters should be uppercase");
    return 0;
}

template <size_t N>
constexpr size_t count_char(const char (&str)[N], char target) {
    size_t count = 0;
    for (size_t i = 0; i < N - 1; ++i) {
        if (str[i] == target) {
            ++count;
        }
    }
    return count;
}

int main() {
    constexpr auto count = count_char("Hello, World!", 'o');
    static_assert(count == 2, "Count of 'o' should be 2");
    return 0;
}

#include <iostream>
#include <type_traits>

template <typename T>
void printTypeInfo() {
    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 unknown." << std::endl;
    }
}

int main() {
    printTypeInfo<int>();           // Type is integral.
    printTypeInfo<double>();        // Type is floating point.
    printTypeInfo<std::string>();   // Type is unknown.
    return 0;
}

#include <iostream>
#include <type_traits>

template <bool B, typename T = void>
using EnableIf = typename std::enable_if<B, T>::type;

template <typename T, typename Enable = void>
struct TypeSelector;

template <typename T>
struct TypeSelector<T, EnableIf<std::is_integral<T>::value>> {
    using type = int;
};

template <typename T>
struct TypeSelector<T, EnableIf<std::is_floating_point<T>::value>> {
    using type = double;
};

int main() {
    typename TypeSelector<int>::type intVar = 42;         // intVar is of type int
    typename TypeSelector<double>::type doubleVar = 3.14; // doubleVar is of type double

    std::cout << "intVar: " << intVar << std::endl;
    std::cout << "doubleVar: " << doubleVar << std::endl;

    return 0;
}

#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 << "Factorial of 5: " << Factorial<5>::value << std::endl; // Factorial of 5: 120
    return 0;
}

template <typename T>
struct Example {
    static void func() {
        // 共通の処理
    }
};

// 特殊化
template <>
struct Example<int> {
    static void func() {
        // int型に特化した処理
    }
};

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

int main() {
    constexpr int result = factorial(5); // コンパイル時に計算される
    return 0;
}

template <typename T>
struct Add;

template <>
struct Add<int> {
    static int compute(int a, int b) {
        return a + b;
    }
};

template <>
struct Add<double> {
    static double compute(double a, double b) {
        return a + b;
    }
};

#if defined(_WIN32) && defined(DEBUG)
    #include <windows.h>
    void log(const char* message) {
        OutputDebugStringA(message);
    }
#elif defined(_WIN32)
    void log(const char* message) {
        // Windows用のリリースビルドのログ処理
    }
#elif defined(__linux__) && defined(DEBUG)
    #include <iostream>
    void log(const char* message) {
        std::cerr << "Debug: " << message << std::endl;
    }
#elif defined(__linux__)
    void log(const char* message) {
        // Linux用のリリースビルドのログ処理
    }
#else
    void log(const char* message) {
        // 他のプラットフォーム用の処理
    }
#endif

#include <iostream>
#include <type_traits>

template <typename T>
struct LogHandler;

template <>
struct LogHandler<int> {
    static void log(T value) {
        std::cout << "Logging integer: " << value << std::endl;
    }
};

template <>
struct LogHandler<double> {
    static void log(T value) {
        std::cout << "Logging double: " << value << std::endl;
    }
};

template <>
struct LogHandler<std::string> {
    static void log(const T& value) {
        std::cout << "Logging string: " << value << std::endl;
    }
};

template <typename T>
void log(T value) {
    LogHandler<T>::log(value);
}

int main() {
    log(42);          // Logging integer: 42
    log(3.14);        // Logging double: 3.14
    log("Hello");     // Logging string: Hello
    return 0;
}

#include <iostream>

// コンパイル時文字列連結
template <size_t N1, size_t N2>
constexpr auto concat(const char (&s1)[N1], const char (&s2)[N2]) {
    char result[N1 + N2 - 1] = {};
    for (size_t i = 0; i < N1 - 1; ++i) {
        result[i] = s1[i];
    }
    for (size_t i = 0; i < N2; ++i) {
        result[N1 - 1 + i] = s2[i];
    }
    return result;
}

// コンパイル時文字列の大文字化
constexpr char to_upper(char c) {
    return (c >= 'a' && c <= 'z') ? c - 32 : c;
}

template <size_t N>
constexpr auto to_uppercase(const char (&str)[N]) {
    char result[N] = {};
    for (size_t i = 0; i < N - 1; ++i) {
        result[i] = to_upper(str[i]);
    }
    result[N - 1] = '\0';
    return result;
}

int main() {
    constexpr auto concatenated = concat("Hello, ", "World!");
    constexpr auto upper = to_uppercase(concatenated);
    std::cout << concatenated << std::endl; // Hello, World!
    std::cout << upper << std::endl;        // HELLO, WORLD!
    return 0;
}

#include <iostream>

// コンパイル時正規表現パーサー
constexpr bool match(const char* str, const char* pattern) {
    return (*pattern == '\0') ? (*str == '\0') :
           (*pattern == '*') ? (match(str, pattern + 1) || (*str != '\0' && match(str + 1, pattern))) :
           (*pattern == *str) ? match(str + 1, pattern + 1) : false;
}

int main() {
    static_assert(match("hello", "h*o"), "Pattern should match.");
    static_assert(!match("hello", "h*l"), "Pattern should not match.");
    std::cout << "All static assertions passed." << std::endl;
    return 0;
}

#include <iostream>

// コンパイル時ハッシュ計算
constexpr uint32_t hash(const char* str, uint32_t value = 0x811c9dc5) {
    return (*str == '\0') ? value :
           hash(str + 1, (value ^ static_cast<uint32_t>(*str)) * 0x01000193);
}

int main() {
    constexpr uint32_t hash_value = hash("Hello, World!");
    static_assert(hash_value == 0x4f9f2cab, "Hash value should match.");
    std::cout << "Hash value: " << std::hex << hash_value << std::endl; // Hash value: 4f9f2cab
    return 0;
}

// コンパイル時フィボナッチ数列計算
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() {
    static_assert(Fibonacci<10>::value == 55, "Fibonacci of 10 should be 55");
    return 0;
}

#include <iostream>

#if defined(_WIN32)
    void platformMessage() {
        std::cout << "Running on Windows" << std::endl;
    }
#elif defined(__linux__)
    void platformMessage() {
        std::cout << "Running on Linux" << std::endl;
    }
#else
    void platformMessage() {
        std::cout << "Running on an unknown platform" << std::endl;
    }
#endif

int main() {
    platformMessage();
    return 0;
}

#include <iostream>

template <char... Chars>
struct String {
    static constexpr const char value[sizeof...(Chars) + 1] = { Chars..., '\0' };
};

template <typename S, char C>
struct Append;

template <char... Chars, char C>
struct Append<String<Chars...>, C> {
    using type = String<Chars..., C>;
};

template <typename S>
struct Reverse;

template <char First, char... Rest>
struct Reverse<String<First, Rest...>> {
    using type = typename Append<typename Reverse<String<Rest...>>::type, First>::type;
};

template <>
struct Reverse<String<>> {
    using type = String<>;
};

int main() {
    using Original = String<'H', 'e', 'l', 'l', 'o'>;
    using Reversed = Reverse<Original>::type;
    constexpr const char* reversed_str = Reversed::value;
    std::cout << reversed_str << std::endl; // "olleH"
    return 0;
}

#include <iostream>

constexpr uint32_t hash(const char* str, uint32_t value = 0x811c9dc5) {
    return (*str == '\0') ? value :
           hash(str + 1, (value ^ static_cast<uint32_t>(*str)) * 0x01000193);
}

int main() {
    constexpr uint32_t hash_value = hash("CompileTimeHash");
    static_assert(hash_value == 0x3b8f24e7, "Hash value should match");
    std::cout << "Hash value: " << std::hex << hash_value << std::endl; // "Hash value: 3b8f24e7"
    return 0;
}

#include <iostream>
#include <type_traits>

template <bool Condition, typename T = void>
using EnableIf = typename std::enable_if<Condition, T>::type;

template <typename T>
void process(T value, EnableIf<std::is_integral<T>::value>* = nullptr) {
    std::cout << "Processing integral type: " << value << std::endl;
}

template <typename T>
void process(T value, EnableIf<std::is_floating_point<T>::value>* = nullptr) {
    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;
}