C++ 메타 프로그래밍: 컴파일 타임 게임 구현 🎮

안녕하세요, 프로그래밍 열정가 여러분! 오늘은 C++의 강력한 기능 중 하나인 메타 프로그래밍에 대해 깊이 있게 탐구해보려고 합니다. 특히, 컴파일 타임에 게임을 구현하는 흥미진진한 주제로 여러분을 안내하겠습니다. 이 여정을 통해 C++의 숨겨진 잠재력을 발견하고, 프로그래밍의 새로운 차원을 경험하실 수 있을 거예요. 🚀

메타 프로그래밍은 단순히 코드를 작성하는 것을 넘어서, 코드가 다른 코드를 생성하거나 조작하는 고급 기법입니다. C++에서 이는 주로 템플릿과 컴파일 타임 계산을 통해 이루어집니다. 이를 통해 우리는 런타임 성능을 희생하지 않고도 유연하고 강력한 코드를 작성할 수 있죠.

이 글에서는 메타 프로그래밍의 기본 개념부터 시작하여, 점진적으로 복잡한 기법들을 소개하고, 최종적으로는 컴파일 타임에 동작하는 간단한 게임을 구현해볼 것입니다. 이 과정에서 여러분은 C++의 템플릿 시스템, constexpr, type traits 등 다양한 고급 기능들을 자연스럽게 익히게 될 거예요.

프로그래밍 세계에서 지속적인 학습과 새로운 기술 습득은 매우 중요합니다. 이런 맥락에서, 재능넷(https://www.jaenung.net)과 같은 재능 공유 플랫폼은 프로그래머들이 서로의 지식과 경험을 나누는 훌륭한 공간이 될 수 있습니다. 여러분도 이 글을 통해 얻은 지식을 바탕으로 다른 이들과 공유하고 토론하는 기회를 가져보는 건 어떨까요? 🌟

자, 이제 C++ 메타 프로그래밍의 흥미진진한 세계로 함께 떠나볼까요? 준비되셨나요? 그럼 시작해봅시다! 🏁

1. 메타 프로그래밍의 기초 🧱

메타 프로그래밍을 이해하기 위해서는 먼저 그 기본 개념과 C++에서의 구현 방법을 알아야 합니다. 이 섹션에서는 메타 프로그래밍의 핵심 아이디어와 C++에서 이를 가능하게 하는 주요 기능들을 살펴보겠습니다.

1.1 메타 프로그래밍이란?

메타 프로그래밍은 프로그램이 다른 프로그램을 데이터로 취급하여 읽고, 생성하고, 분석하거나 변환하는 기법을 말합니다. C++에서 메타 프로그래밍은 주로 컴파일 타임에 이루어지며, 이를 통해 다음과 같은 이점을 얻을 수 있습니다:

코드 생성 자동화
타입 안전성 향상
런타임 성능 최적화
추상화 수준 향상

메타 프로그래밍을 통해 우리는 컴파일러가 우리를 위해 코드를 생성하도록 할 수 있습니다. 이는 마치 우리가 프로그래머이면서 동시에 컴파일러의 프로그래머가 되는 것과 같죠. 😎

1.2 C++에서의 메타 프로그래밍 도구

C++는 강력한 메타 프로그래밍 기능을 제공합니다. 주요 도구들을 살펴보겠습니다:

1.2.1 템플릿 (Templates)

템플릿은 C++ 메타 프로그래밍의 핵심입니다. 이를 통해 타입이나 값을 매개변수로 받아 컴파일 타임에 코드를 생성할 수 있습니다.

template <typename T>
T add(T a, T b) {
    return a + b;
}

이 간단한 예제에서 add 함수는 어떤 타입 T에 대해서도 동작합니다. 컴파일러는 이 템플릿을 바탕으로 필요한 함수를 자동으로 생성합니다.

1.2.2 템플릿 특수화 (Template Specialization)

템플릿 특수화를 통해 특정 타입이나 조건에 대해 다른 구현을 제공할 수 있습니다.

template <>
const char* add<const char*>(const char* a, const char* b) {
    // 문자열 연결 로직
    // (실제 구현은 더 복잡할 수 있습니다)
}

이 특수화된 버전은 const char* 타입에 대해서만 동작하며, 문자열 연결을 수행합니다.

1.2.3 constexpr

constexpr 키워드는 컴파일 타임 계산을 가능하게 합니다. 이를 통해 런타임 비용 없이 복잡한 계산을 수행할 수 있습니다.

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

constexpr int result = factorial(5);  // 컴파일 타임에 계산됨

이 예제에서 factorial 함수는 컴파일 타임에 실행되어 그 결과가 result에 저장됩니다.

1.2.4 type traits

C++ 표준 라이브러리는 <type_traits> 헤더를 통해 타입에 대한 정보를 컴파일 타임에 조회하고 조작할 수 있는 도구를 제공합니다.

#include <type_traits>

template <typename T>
void process(T value) {
    if constexpr (std::is_integral_v<T>) {
        // 정수 타입에 대한 처리
    } else if constexpr (std::is_floating_point_v<T>) {
        // 부동소수점 타입에 대한 처리
    } else {
        // 기타 타입에 대한 처리
    }
}

이 예제에서는 std::is_integral_v와 std::is_floating_point_v를 사용하여 컴파일 타임에 타입 정보를 확인하고, 그에 따라 다른 코드 경로를 선택합니다.

1.3 메타 프로그래밍의 응용

메타 프로그래밍은 다양한 분야에서 활용될 수 있습니다:

코드 최적화: 컴파일 타임 계산을 통해 런타임 성능을 향상시킬 수 있습니다.
일반화된 알고리즘: 다양한 타입에 대해 동작하는 범용 알고리즘을 작성할 수 있습니다.
도메인 특화 언어(DSL) 구현: C++ 내에서 특정 도메인에 최적화된 미니 언어를 만들 수 있습니다.
컴파일 타임 검사: 런타임 에러를 컴파일 타임 에러로 전환하여 프로그램의 안정성을 높일 수 있습니다.

이러한 기초적인 개념과 도구들을 바탕으로, 우리는 점차 더 복잡하고 강력한 메타 프로그래밍 기법들을 탐구해 나갈 것입니다. 다음 섹션에서는 이러한 개념들을 더 깊이 있게 살펴보고, 실제 예제를 통해 그 활용법을 익혀보겠습니다. 🚀

2. 템플릿 메타 프로그래밍 심화 🧠

이제 메타 프로그래밍의 기초를 이해했으니, 더 깊이 있는 주제로 들어가 보겠습니다. 이 섹션에서는 템플릿 메타 프로그래밍의 고급 기법들을 살펴보고, 이를 통해 어떻게 복잡한 컴파일 타임 연산을 수행할 수 있는지 알아보겠습니다.

2.1 템플릿 재귀

템플릿 재귀는 컴파일 타임에 반복적인 연산을 수행하는 강력한 도구입니다. 다음은 컴파일 타임에 팩토리얼을 계산하는 예제입니다:

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

template <>
struct Factorial<0> {
    static constexpr unsigned value = 1;
};

constexpr unsigned fact_5 = Factorial<5>::value;  // 120

이 예제에서 Factorial 템플릿은 자기 자신을 재귀적으로 인스턴스화하면서 팩토리얼 값을 계산합니다. Factorial<0>에 대한 특수화는 재귀의 기저 조건 역할을 합니다.

2.2 SFINAE (Substitution Failure Is Not An Error)

SFINAE는 C++ 템플릿 메타 프로그래밍의 핵심 개념 중 하나입니다. 이를 통해 컴파일러가 적절한 함수 오버로드를 선택할 수 있게 됩니다.

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

template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, bool>::type
is_even(T t) {
    return std::fmod(t, 2.0) == 0.0;
}

이 예제에서 std::enable_if를 사용하여 정수 타입과 부동소수점 타입에 대해 서로 다른 is_even 함수를 정의했습니다. 컴파일러는 SFINAE를 통해 적절한 함수를 선택합니다.

2.3 타입 리스트와 가변 템플릿

가변 템플릿을 사용하면 임의의 개수의 템플릿 인자를 받을 수 있습니다. 이를 활용하여 타입 리스트를 구현할 수 있습니다:

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

template <typename T, typename... Ts>
struct CountTypes {
    static constexpr size_t value = 1 + CountTypes<Ts...>::value;
};

template <typename T>
struct CountTypes<T> {
    static constexpr size_t value = 1;
};

using MyList = TypeList<int, double, char>;
constexpr size_t count = CountTypes<int, double, char>::value;  // 3

이 예제에서는 TypeList를 정의하고, CountTypes를 사용하여 리스트의 요소 개수를 컴파일 타임에 계산합니다.

2.4 태그 디스패치

태그 디스패치는 오버로딩 해결을 위한 또 다른 기법입니다. 이를 통해 컴파일 타임에 적절한 함수를 선택할 수 있습니다:

struct fast_tag {};
struct safe_tag {};

template <typename T>
void process(T& container, fast_tag) {
    // 빠르지만 안전하지 않은 처리
}

template <typename T>
void process(T& container, safe_tag) {
    // 안전하지만 느린 처리
}

template <typename T>
void process(T& container) {
    process(container, typename std::conditional<
        std::is_trivially_copyable<typename T::value_type>::value,
        fast_tag,
        safe_tag
    >::type{});
}

이 예제에서는 컨테이너의 요소 타입이 trivially copyable인지에 따라 다른 처리 방식을 선택합니다.

2.5 표현식 템플릿

표현식 템플릿은 수식을 나타내는 템플릿 객체를 만들어 최적화된 계산을 수행하는 기법입니다. 다음은 간단한 벡터 연산을 위한 표현식 템플릿의 예입니다:

template <typename T, size_t N>
class Vector {
    T data[N];
public:
    // ... 생성자 등 다른 멤버 함수들 ...

    T& operator[](size_t i) { return data[i]; }
    const T& operator[](size_t i) const { return data[i]; }
};

template <typename LHS, typename RHS>
class VectorSum {
    const LHS& lhs;
    const RHS& rhs;
public:
    VectorSum(const LHS& lhs, const RHS& rhs) : lhs(lhs), rhs(rhs) {}
    
    auto operator[](size_t i) const -> decltype(lhs[i] + rhs[i]) {
        return lhs[i] + rhs[i];
    }
};

template <typename LHS, typename RHS>
VectorSum<LHS, RHS> operator+(const LHS& lhs, const RHS& rhs) {
    return VectorSum<LHS, RHS>(lhs, rhs);
}

// 사용 예
Vector<int, 3> v1 = {1, 2, 3};
Vector<int, 3> v2 = {4, 5, 6};
Vector<int, 3> v3 = {7, 8, 9};

auto result = v1 + v2 + v3;  // 실제 계산은 여기서 지연됨
int sum = result[0];  // 이 시점에 실제 계산이 수행됨 (1 + 4 + 7)

이 예제에서 VectorSum 클래스는 벡터 덧셈 연산을 나타내는 표현식 템플릿입니다. 실제 계산은 operator[]가 호출될 때까지 지연됩니다.

2.6 정책 기반 설계

정책 기반 설계는 알고리즘의 세부 동작을 템플릿 인자로 받아 유연성을 높이는 기법입니다:

template <typename T, typename ComparePolicy = std::less<T>>
class PriorityQueue {
    std::vector<T> data;
    ComparePolicy compare;

public:
    void push(const T& value) {
        data.push_back(value);
        std::push_heap(data.begin(), data.end(), compare);
    }

    T pop() {
        T top = data.front();
        std::pop_heap(data.begin(), data.end(), compare);
        data.pop_back();
        return top;
    }
};

// 사용 예
PriorityQueue<int> min_queue;  // 기본적으로 최소 힙
PriorityQueue<int, std::greater<int>> max_queue;  // 최대 힙

이 예제에서 PriorityQueue 클래스는 비교 정책을 템플릿 인자로 받아 최소 힙 또는 최대 힙으로 동작할 수 있습니다.

2.7 컴파일 타임 if

C++17부터는 if constexpr을 사용하여 컴파일 타임에 조건부 코드 생성이 가능해졌습니다:

template <typename T>
auto get_value(T t) {
    if constexpr (std::is_pointer_v<T>) {
        return *t;
    } else {
        return t;
    }
}

이 예제에서 get_value 함수는 T가 포인터 타입인 경우에만 역참조 연산을 수행합니다. 컴파일러는 각 인스턴스화에 대해 적절한 코드만을 생성합니다.

2.8 타입 특성과 개념 (Concepts)

C++20에서 도입된 개념(Concepts)을 사용하면 템플릿 인자에 대한 제약을 명시적으로 표현할 수 있습니다:

template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

template <Addable T>
T sum(const std::vector<T>& v) {
    T result = T{};
    for (const auto& elem : v) {
        result = result + elem;
    }
    return result;
}

이 예제에서 Addable 개념은 두 값을 더할 수 있는 타입을 정의합니다. sum 함수는 이 개념을 만족하는 타입에 대해서만 동작합니다.

이러한 고급 템플릿 메타 프로그래밍 기법들을 마스터하면, 여러분은 C++의 타입 시스템과 컴파일러를 최대한 활용하여 강력하고 유연한 코드를 작성할 수 있게 됩니다. 다음 섹션에서는 이러한 기법들을 활용하여 실제로 컴파일 타임 게임을 구현하는 방법을 살펴보겠습니다. 준비되셨나요? 더 흥미진진한 여정이 기다리고 있습니다! 🚀

3. 컴파일 타임 게임 설계 🎲

이제 우리는 메타 프로그래밍의 기본 개념과 고급 기법들을 살펴보았습니다. 이 지식을 바탕으로, 실제로 컴파일 타임에 동작하는 간단한 게임을 설계해 보겠습니다. 우리의 목표는 컴파일러가 게임을 "플레이"하고, 그 결과를 컴파일 타임에 결정하는 것입니다.

3.1 게임 선택: 숫자 맞추기 게임

우리가 구현할 게임은 간단한 숫자 맞추기 게임입니다. 규칙은 다음과 같습니다:

컴파일러가 1부터 100 사이의 숫자를 "선택"합니다.
플레이어(프로그래머)가 숫자를 추측합니다.
컴파일러는 추측이 맞았는지, 높은지 낮은지를 알려줍니다.
정답을 맞출 때까지 이 과정을 반복합니다.

이 게임을 컴파일 타임에 구현하기 위해, 우리는 다음과 같은 메타 프로그래밍 기법들을 사용할 것입니다:

템플릿 메타 프로그래밍
컴파일 타임 상수
재귀적 템플릿 인스턴스화
타입 기반 상태 표현

3.2 게임 상태 표현

먼저, 게임의 상태를 표현하는 타입을 정의해 보겠습니다:

enum class GuessResult { TooLow, TooHigh, Correct };

template <int Target, int GuessCount>
struct GameState {
    static constexpr int target = Target;
    static constexpr int guessCount = GuessCount;
};

GameState는 목표 숫자(Target)와 현재까지의 추측 횟수(GuessCount)를 저장합니다.

3.3 게임 로직 구현

이제 게임의 핵심 로직을 구현해 보겠습니다:

template <typename State, int Guess>
struct MakeGuess {
    static constexpr GuessResult result = 
        (Guess < State::target) ? GuessResult::TooLow :
        (Guess > State::target) ? GuessResult::TooHigh :
                                   GuessResult::Correct;

    using NewState = GameState<State::target, State::guessCount + 1>;
};

MakeGuess 구조체는 현재 게임 상태와 추측값을 받아, 결과를 계산하고 새로운 게임 상태를 생성합니다.

3.4 게임 진행 로직

게임을 진행하는 로직을 구현해 봅시다:

template <typename State, int Guess>
struct PlayGame {
    using GuessResult = MakeGuess<State, Guess>;
    using NewState = typename GuessResult::NewState;

    static constexpr int guessCount = NewState::guessCount;
    static constexpr bool isCorrect = (GuessResult::result == GuessResult::Correct);

    // 게임 결과 메시지
    static constexpr const char* message = 
        isCorrect ? "Correct! You won!" :
        (GuessResult::result == GuessResult::TooLow) ? "Too low! Try again." :
                                                       "Too high! Try again.";

    // 다음 게임 상태로 재귀
    using NextGame = PlayGame<NewState, Guess>;
};

// 게임 종료 조건
template <typename State, int Guess>
struct PlayGame<State, Guess, 
    typename std::enable_if<MakeGuess<State, Guess>::result == GuessResult::Correct>::type> {
    static constexpr int guessCount = State::guessCount + 1;
    static constexpr bool isCorrect = true;
    static constexpr const char* message = "Correct! You won!";
};

이 구현에서 PlayGame은 재귀적으로 자기 자신을 인스턴스화하면서 게임을 진행합니다. 정답을 맞추면 재귀가 종료됩니다.

3.5 게임 시작 및 결과 출력

마지막으로, 게임을 시작하고 결과를 출력하는 코드를 작성해 봅시다:

template <int Target, int GuessCount = 0>
struct StartGame {
    using InitialState = GameState<Target, GuessCount>;

    template <int Guess>
    static void play() {
        using Game = PlayGame<InitialState, Guess>;
        
        st  atic_assert(Game::isCorrect, Game::message);
        std::cout << "You guessed the number " << Target << " in " 
                  << Game::guessCount << " attempts!" << std::endl;
    }
};

StartGame 구조체는 목표 숫자를 설정하고 게임을 시작합니다. play 함수는 플레이어의 추측을 받아 게임을 진행합니다.

3.6 게임 실행

이제 우리의 컴파일 타임 게임을 실행해 봅시다:

#include <iostream>

int main() {
    // 컴파일러가 42를 "선택"했다고 가정합니다.
    using Game = StartGame<42>;
    
    // 플레이어의 추측
    Game::play<10>();  // 컴파일 에러: Too low! Try again.
    Game::play<50>();  // 컴파일 에러: Too high! Try again.
    Game::play<42>();  // 컴파일 성공: You guessed the number 42 in 3 attempts!
    
    return 0;
}

이 예제에서 컴파일러는 실제로 게임을 "플레이"하고 있습니다. 잘못된 추측은 컴파일 에러를 발생시키고, 올바른 추측은 컴파일을 성공시킵니다.

3.7 게임 확장: 자동 이진 검색

우리의 게임을 좀 더 흥미롭게 만들기 위해, 컴파일 타임에 자동으로 이진 검색을 수행하는 기능을 추가해 봅시다:

template <typename State, int Low, int High>
struct AutoPlay {
    static constexpr int mid = (Low + High) / 2;
    using GuessResult = MakeGuess<State, mid>;
    
    using NextGame = typename std::conditional<
        GuessResult::result == GuessResult::Correct,
        PlayGame<typename GuessResult::NewState, mid>,
        typename std::conditional<
            GuessResult::result == GuessResult::TooLow,
            AutoPlay<typename GuessResult::NewState, mid + 1, High>,
            AutoPlay<typename GuessResult::NewState, Low, mid - 1>
        >::type
    >::type;

    static constexpr int guessCount = NextGame::guessCount;
    static constexpr bool isCorrect = NextGame::isCorrect;
    static constexpr const char* message = NextGame::message;
};

AutoPlay 구조체는 자동으로 이진 검색을 수행하여 목표 숫자를 찾습니다.

3.8 자동 게임 실행

이제 자동 게임을 실행해 봅시다:

int main() {
    using Game = StartGame<42>;
    using AutoGame = AutoPlay<Game::InitialState, 1, 100>;
    
    static_assert(AutoGame::isCorrect, "Game should always be won");
    std::cout << "Auto player guessed the number 42 in " 
              << AutoGame::guessCount << " attempts!" << std::endl;
    
    return 0;
}

이 코드는 컴파일 타임에 자동으로 숫자를 맞추고, 추측 횟수를 출력합니다.

3.9 결론

우리는 C++ 템플릿 메타 프로그래밍을 사용하여 컴파일 타임에 동작하는 숫자 맞추기 게임을 구현했습니다. 이 과정에서 다음과 같은 고급 C++ 기능들을 활용했습니다:

템플릿 메타 프로그래밍
컴파일 타임 상수 및 계산
타입 기반 상태 표현
재귀적 템플릿 인스턴스화
SFINAE와 std::enable_if
static_assert를 이용한 컴파일 타임 검증

이 예제는 C++ 메타 프로그래밍의 강력함을 보여줍니다. 컴파일 타임 프로그래밍을 통해 우리는 런타임 오버헤드 없이 복잡한 로직을 구현할 수 있으며, 컴파일러의 타입 검사 기능을 활용하여 프로그램의 정확성을 높일 수 있습니다.

물론, 이 게임은 단순한 예제이지만, 이러한 기법들은 실제로 라이브러리 설계, 최적화, 일반화된 알고리즘 구현 등 다양한 분야에서 활용됩니다. C++ 메타 프로그래밍을 마스터함으로써, 여러분은 더 효율적이고 유연한 코드를 작성할 수 있게 될 것입니다.

앞으로 여러분이 C++ 메타 프로그래밍의 세계를 더 깊이 탐험하고, 이를 통해 혁신적인 솔루션을 만들어내기를 바랍니다. 화이팅! 🚀🎮

4. 메타 프로그래밍의 실제 응용 사례 💼

지금까지 우리는 C++ 메타 프로그래밍의 기본 개념부터 고급 기법까지 살펴보았고, 심지어 컴파일 타임 게임도 구현해 보았습니다. 이제 이러한 기술들이 실제 소프트웨어 개발에서 어떻게 활용되는지 알아보겠습니다.

4.1 고성능 수학 라이브러리

메타 프로그래밍은 수학 라이브러리에서 특히 유용합니다. 예를 들어, Eigen이라는 유명한 C++ 선형 대수 라이브러리는 메타 프로그래밍을 광범위하게 사용합니다.

// Eigen 라이브러리 사용 예
#include <Eigen/Dense>

Eigen::Matrix<float, 3, 3> matrix;
Eigen::Vector<float, 3> vector;

auto result = matrix * vector;  // 컴파일 타임에 최적화된 연산

Eigen은 메타 프로그래밍을 통해 행렬과 벡터의 크기에 따라 최적화된 코드를 생성합니다. 이는 런타임 성능을 크게 향상시킵니다.

4.2 단위 변환 및 차원 검사

메타 프로그래밍은 물리량의 단위를 컴파일 타임에 검사하는 데 사용될 수 있습니다. 이를 통해 단위 오류를 런타임이 아닌 컴파일 타임에 잡아낼 수 있습니다.

template <int M, int K, int S>
struct Unit {
    static constexpr int mass = M;
    static constexpr int distance = K;
    static constexpr int time = S;
};

template <typename UnitType, typename T = double>
class Quantity {
    T value;
public:
    explicit Quantity(T v) : value(v) {}
    // ... 연산자 오버로딩 등
};

using Meter = Unit<0, 1, 0>;
using Second = Unit<0, 0, 1>;
using MeterPerSecond = Unit<0, 1, -1>;

template <typename U1, typename U2>
auto operator/(const Quantity<U1>& lhs, const Quantity<U2>& rhs) {
    using ResultUnit = Unit<
        U1::mass - U2::mass,
        U1::distance - U2::distance,
        U1::time - U2::time
    >;
    return Quantity<ResultUnit>(lhs.value() / rhs.value());
}

// 사용 예
Quantity<Meter> distance(100.0);
Quantity<Second> time(10.0);
auto speed = distance / time;  // Quantity<MeterPerSecond>

이 예제에서는 물리량의 단위를 타입 수준에서 표현하고, 연산 시 단위가 올바르게 조합되는지 컴파일 타임에 확인합니다.

4.3 설계 패턴 구현

메타 프로그래밍은 일부 설계 패턴을 더 효율적으로 구현하는 데 사용될 수 있습니다. 예를 들어, 팩토리 패턴을 컴파일 타임에 구현할 수 있습니다.

// 제품 인터페이스
struct Product {
    virtual void use() = 0;
    virtual ~Product() = default;
};

// 구체적인 제품들
struct ConcreteProduct1 : Product {
    void use() override { std::cout << "Using ConcreteProduct1" << std::endl; }
};

struct ConcreteProduct2 : Product {
    void use() override { std::cout << "Using ConcreteProduct2" << std::endl; }
};

// 컴파일 타임 팩토리
template <typename... Products>
class Factory {
    template <typename T>
    static std::unique_ptr<Product> createProduct() {
        return std::make_unique<T>();
    }

    using ProductCreator = std::unique_ptr<Product>(*)();
    std::unordered_map<std::string, ProductCreator> creators;

public:
    Factory() {
        (creators[typeid(Products).name()] = &createProduct<Products>, ...);
    }

    std::unique_ptr<Product> create(const std::string& type) {
        auto it = creators.find(type);
        if (it != creators.end()) {
            return it->second();
        }
        throw std::runtime_error("Unknown product type");
    }
};

// 사용 예
int main() {
    Factory<ConcreteProduct1, ConcreteProduct2> factory;
    
    auto product1 = factory.create(typeid(ConcreteProduct1).name());
    product1->use();  // Outputs: Using ConcreteProduct1
    
    auto product2 = factory.create(typeid(ConcreteProduct2).name());
    product2->use();  // Outputs: Using ConcreteProduct2
    
    return 0;
}

이 구현에서는 가변 템플릿을 사용하여 팩토리가 생성할 수 있는 제품 타입들을 컴파일 타임에 등록합니다.

4.4 리플렉션 시뮬레이션

C++은 기본적으로 리플렉션을 지원하지 않지만, 메타 프로그래밍을 사용하여 제한적인 형태의 리플렉션을 구현할 수 있습니다.

#include <tuple>
#include <string_view>

// 필드 정보를 저장하는 구조체
template <typename T, typename U>
struct Field {
    std::string_view name;
    U T::* ptr;
};

// 매크로를 사용하여 필드 정보 생성
#define FIELD(Name) Field<T, decltype(T::Name)>{#Name, &T::Name}

// 클래스의 메타 정보를 저장하는 구조체
template <typename T, typename... Fields>
struct ClassInfo {
    std::string_view name;
    std::tuple<Fields...> fields;
};

// 예시 클래스
struct Person {
    std::string name;
    int age;
};

// Person 클래스의 메타 정보 정의
template <>
inline constexpr auto classInfo<Person> = ClassInfo<Person,
    Field<Person, std::string>,
    Field<Person, int>
>{
    "Person",
    std::make_tuple(
        FIELD(name),
        FIELD(age)
    )
};

// 리플렉션 기능 사용 예
template <typename T>
void printObjectInfo(const T& obj) {
    constexpr auto info = classInfo<T>;
    std::cout << "Class name: " << info.name << std::endl;
    
    std::apply([&](auto&&... fields) {
        ((std::cout << "Field: " << fields.name << " = " << obj.*(fields.ptr) << std::endl), ...);
    }, info.fields);
}

int main() {
    Person p{"Alice", 30};
    printObjectInfo(p);
    return 0;
}

이 예제에서는 클래스의 필드 정보를 컴파일 타임에 저장하고, 이를 사용하여 런타임에 객체의 정보를 출력합니다.

4.5 도메인 특화 언어(DSL) 구현

메타 프로그래밍은 C++ 내에서 도메인 특화 언어를 구현하는 데 사용될 수 있습니다. 예를 들어, 복잡한 쿼리를 표현하는 DSL을 만들 수 있습니다.

// 간단한 쿼리 DSL 예제
template <typename T>
struct Column {
    std::string name;
};

template <typename T>
struct Table {
    std::string name;
};

template <typename T>
struct Select {
    Column<T> column;
};

template <typename T>
struct From {
    Table<T> table;
};

template <typename SelectClause, typename FromClause>
struct Query {
    SelectClause select;
    FromClause from;

    std::string toString() const {
        return "SELECT " + select.column.name + " FROM " + from.table.name;
    }
};

// 사용자 정의 리터럴을 사용한 DSL 구문
Column<int> operator""_column(const char* name, size_t) {
    return Column<int>{name};
}

Table<int> operator""_table(const char* name, size_t) {
    return Table<int>{name};
}

template <typename T>
auto select(Column<T> column) {
    return Select<T>{column};
}

template <typename T>
auto from(Table<T> table) {
    return From<T>{table};
}

template <typename SelectClause, typename FromClause>
auto makeQuery(SelectClause select, FromClause from) {
    return Query<SelectClause, FromClause>{select, from};
}

// 사용 예
int main() {
    auto query = makeQuery(select("id"_column), from("users"_table));
    std::cout << query.toString() << std::endl;  // Outputs: SELECT id FROM users
    return 0;
}

이 예제에서는 SQL과 유사한 문법을 C++ 코드 내에서 사용할 수 있게 해주는 간단한 DSL을 구현했습니다.