C++ 메타프로그래밍 고급 | SFINAE·Concepts·constexpr·타입 트레이트 가이드

Q: 선행으로 읽으면 좋은 글은?

각 글 하단의 이전 글 링크를 따라가면 순서대로 배울 수 있습니다. C++ 시리즈 목차에서 전체 흐름을 확인할 수 있습니다.

2026년 4월 7일 · 35분 읽기 · 수정 2026년 4월 7일 고급 실습

이 글의 핵심

템플릿 오버로드 실패, 컴파일 에러 지옥 해결. SFINAE·Concepts·constexpr·타입 트레이트 완전 예제, 흔한 에러, 성능 팁, 프로덕션 패턴까지 실전 코드로 다룹니다.

들어가며: “템플릿 하나 추가했는데 컴파일 에러가 100줄이에요"

"정수만 받는 함수가 실수도 받아버려요”

제네릭 프로그래밍에서 타입 제약이 없으면, 의도하지 않은 타입이 들어와도 컴파일됩니다. 예를 들어 int만 받아야 하는 함수에 double을 넘기면 암시적 변환이 일어나고, std::string을 넘기면 예상치 못한 동작이 발생합니다. 비유하면 “정수만 받는 기계에 소수를 넣으면 기계가 잘못 돌아가는” 것처럼, 타입 제약이 없으면 런타임 에러나 논리적 버그가 생깁니다.

또한 컴파일 에러가 길고 난해합니다. “템플릿 인스턴스화 실패” 뒤에 50줄의 에러 메시지가 나오면, 원인을 찾기 어렵습니다.

다음은 mermaid를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

flowchart LR
  subgraph problem[문제 상황]
    P1[타입 제약 없음]
    P2[암시적 변환]
    P3[컴파일 에러 지옥]
    P4[런타임 버그]
  end

  subgraph solution[해결 도구]
    S1[SFINAE]
    S2[Concepts]
    S3[constexpr]
    S4[타입 트레이트]
  end

  P1 --> S1
  P2 --> S2
  P3 --> S3
  P4 --> S4

이 글을 읽으면:

SFINAE, Concepts, constexpr, 타입 트레이트의 완전한 구현 예제를 익힐 수 있습니다.
자주 발생하는 에러와 해결법을 알 수 있습니다.
프로덕션 환경에서의 패턴과 성능 팁을 활용할 수 있습니다.

요구 환경: C++17 이상 (Concepts는 C++20)

실무 적용 경험: 이 글은 대규모 C++ 프로젝트에서 실제로 겪은 문제와 해결 과정을 바탕으로 작성되었습니다. 책이나 문서에서 다루지 않는 실전 함정과 디버깅 팁을 포함합니다.

추가 문제 시나리오

시나리오 1: JSON 직렬화에서 타입별 분기
std::string, int, double, std::vector 등을 각각 다르게 직렬화해야 합니다. if constexpr와 타입 트레이트로 is_string, is_integral 등을 체크해 분기합니다.

시나리오 2: 반복자만 받는 알고리즘
begin/end가 있는 컨테이너만 받고 싶습니다. std::begin()이 호출 가능한지 SFINAE나 Concepts로 검사해, std::vector·std::array는 허용하고 int는 거부합니다.

시나리오 3: 컴파일 타임 상수 계산
피보나치 수, 팩토리얼, CRC32 등을 컴파일 타임에 계산해 상수로 쓰고 싶습니다. constexpr 함수로 구현하면 런타임 비용이 없습니다.

시나리오 4: 라이브러리 API 설계
”덧셈 가능한 타입”만 받는 add 함수를 만들고 싶습니다. C++17에서는 std::void_t와 SFINAE, C++20에서는 concept Addable로 표현합니다.

시나리오 5: 프로덕션 로깅
디버그 빌드에서는 상세 로그, 릴리즈 빌드에서는 로그 제거. if constexpr (std::is_same_v<DebugLevel, ...>)로 컴파일 타임 분기해 릴리즈 빌드에서는 로그 코드가 완전히 제거됩니다.

시나리오	특징	권장 기법
타입별 분기	직렬화, 포맷팅	`if constexpr`, 타입 트레이트
반복자/컨테이너 제약	`begin`/`end` 검사	Concepts, SFINAE
컴파일 타임 계산	상수, 피보나치	`constexpr`
연산 가능 타입 제약	`Addable`, `Comparable`	Concepts, SFINAE
빌드별 분기	디버그/릴리즈	`if constexpr`

1. SFINAE 완전 예제

SFINAE란?

SFINAE는 “Substitution Failure Is Not An Error”의 약자입니다. 템플릿 인스턴스화 시 템플릿 인자 치환이 실패하면, 그 오버로드는 에러가 아니라 후보에서 제외됩니다. 이 특성을 이용해 “특정 조건을 만족하는 타입만” 오버로드를 선택하도록 합니다.

기본 예제: 정수만 받는 함수

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
#include <type_traits>

// 정수 타입만 받는 함수 (SFINAE)
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
add(T a, T b) {
    return a + b;
}

// 정수가 아닌 타입: 이 오버로드는 인스턴스화되지 않음 (치환 실패)
template <typename T>
typename std::enable_if<!std::is_integral<T>::value, T>::type
add(T a, T b) = delete;  // 또는 다른 구현

int main() {
    std::cout << add(1, 2) << "\n";        // 3 (OK)
    std::cout << add(1u, 2u) << "\n";      // 3 (OK)
    // add(1.0, 2.0);  // 컴파일 에러: deleted 함수
}

동작 원리:

std::enable_if<조건, T>::type: 조건이 true면 T를 반환 타입으로 사용
조건이 false면 ::type이 없어 치환 실패 → 해당 오버로드 제외
std::is_integral<T>::value: T가 정수 타입인지 검사

C++14/17 스타일: enable_if_t, is_integral_v

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <type_traits>

// C++14: enable_if_t
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T>
add(T a, T b) {
    return a + b;
}

// 반환 타입 대신 템플릿 매개변수에 사용
template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
T multiply(T a, T b) {
    return a * b;
}

void_t 패턴: 멤버 존재 여부 검사

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <type_traits>

// std::void_t: C++17
template <typename...>
using void_t = void;

// has_begin_t: begin()이 호출 가능한지 검사
template <typename T, typename = void>
struct has_begin : std::false_type {};

template <typename T>
struct has_begin<T, void_t<decltype(std::begin(std::declval<T>()))>>
    : std::true_type {};

template <typename T>
inline constexpr bool has_begin_v = has_begin<T>::value;

// 사용 예
static_assert(has_begin_v<std::vector<int>>);
static_assert(has_begin_v<std::array<int, 3>>);
static_assert(!has_begin_v<int>);

동작 원리:

std::declval<T>(): T의 rvalue 참조를 “가짜”로 만듦 (생성자 호출 없이)
decltype(std::begin(...)): begin()이 호출 가능하면 타입이 존재, 아니면 치환 실패
void_t<...>: 타입이 있으면 void로 치환 성공, 없으면 실패

SFINAE로 함수 오버로드 선택

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
#include <string>
#include <type_traits>

// 1. 반복 가능한 경우 (begin/end 있음)
template <typename T>
auto print(const T& container)
    -> std::void_t<decltype(std::begin(container)), decltype(std::end(container))> {
    std::cout << "[ ";
    for (const auto& x : container) {
        std::cout << x << " ";
    }
    std::cout << "]\n";
}

// 2. 그 외: 일반 출력
template <typename T>
auto print(const T& value) -> std::enable_if_t<std::is_arithmetic_v<T>> {
    std::cout << value << "\n";
}

int main() {
    std::vector<int> v = {1, 2, 3};
    print(v);  // [ 1 2 3 ]

    print(42);  // 42
}

2. Concepts 완전 예제

Concepts란? (C++20)

Concepts는 타입이 만족해야 할 제약 조건을 선언적으로 표현합니다. SFINAE보다 읽기 쉽고, 컴파일 에러 메시지도 훨씬 명확합니다.

기본 개념 정의

#include <concepts>
#include <iostream>
#include <vector>

// 1. 표준 concepts 사용
template <std::integral T>
T add(T a, T b) {
    return a + b;
}

// 2. 커스텀 concept 정의
template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

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

// 3. 반복 가능 (range) concept
template <typename T>
concept Iterable = requires(T t) {
    std::begin(t);
    std::end(t);
};

template <Iterable T>
void print(const T& container) {
    std::cout << "[ ";
    for (const auto& x : container) {
        std::cout << x << " ";
    }
    std::cout << "]\n";
}

int main() {
    std::cout << add(1, 2) << "\n";  // 3
    std::vector<int> v = {1, 2, 3};
    print(v);  // [ 1 2 3 ]
}

복합 concept

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <concepts>

// "정수이면서 4바이트 이상이어야 함"
template <typename T>
concept LargeIntegral = std::integral<T> && sizeof(T) >= 4;

template <LargeIntegral T>
T safe_multiply(T a, T b) {
    return a * b;
}

// "덧셈과 뺄셈이 모두 가능"
template <typename T>
concept AddableSubtractable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
    { a - b } -> std::convertible_to<T>;
};

template <AddableSubtractable T>
T compute(T a, T b) {
    return (a + b) - (a - b);
}

requires 절로 세밀한 제약

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <concepts>
#include <iterator>

// 반복자 타입 제약
template <typename It>
concept RandomAccessIterator = std::random_access_iterator<It>;

// sort: RandomAccessIterator만 받음
template <RandomAccessIterator It>
void my_sort(It first, It last) {
    std::sort(first, last);
}

// 컨테이너 concept
template <typename C>
concept Container = requires(C c) {
    std::begin(c);
    std::end(c);
    typename C::value_type;
    typename C::size_type;
};

Concepts vs SFINAE 비교

항목	SFINAE	Concepts
가독성	낮음	높음
에러 메시지	복잡	명확
컴파일 속도	비슷	일부 개선 가능
C++ 표준	C++11~	C++20

권장: C++20 이상이면 Concepts를 쓰고, 레거시 코드는 SFINAE를 이해해 두세요.

3. constexpr 완전 예제

constexpr란?

constexpr는 컴파일 타임에 계산 가능한 값·함수를 표시합니다. 컴파일러가 컴파일 시점에 값이 결정되면, 런타임 비용이 없습니다.

기본: constexpr 변수와 함수

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>

// 컴파일 타임 상수
constexpr int MAX_SIZE = 1024;
constexpr double PI = 3.14159265359;

// constexpr 함수: 인자가 모두 상수면 컴파일 타임 계산
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr int result = factorial(5);  // 120, 컴파일 타임
    std::cout << result << "\n";

    int x = 10;
    int runtime_result = factorial(x);  // 런타임 계산
}

constexpr if: 컴파일 타임 분기

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
#include <string>
#include <type_traits>

template <typename T>
std::string to_string(const T& value) {
    if constexpr (std::is_same_v<T, std::string>) {
        return value;
    } else if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else if constexpr (std::is_pointer_v<T>) {
        return value ? std::to_string(reinterpret_cast<uintptr_t>(value)) : "nullptr";
    } else {
        return "[unknown]";
    }
}

int main() {
    std::cout << to_string(42) << "\n";           // "42"
    std::cout << to_string(3.14) << "\n";         // "3.140000"
    std::cout << to_string(std::string("hi")) << "\n";  // "hi"
}

핵심: if constexpr에서 선택되지 않은 분기는 컴파일되지 않습니다. 따라서 std::to_string이 std::string에 없어도, 해당 분기가 선택되지 않으면 에러가 나지 않습니다.

constexpr 피보나치

아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

constexpr int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

int main() {
    constexpr int f10 = fib(10);  // 55, 컴파일 타임
    std::cout << f10 << "\n";
}

constexpr 메타 프로그래밍: 타입 리스트 크기

#include <type_traits>

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

template <typename List>
struct size;

template <template <typename...> class List, typename... Ts>
struct size<List<Ts...>> : std::integral_constant<size_t, sizeof...(Ts)> {};

template <typename List>
inline constexpr size_t size_v = size<List>::value;

// 사용
using my_list = type_list<int, double, char>;
static_assert(size_v<my_list> == 3);

constexpr와 std::array

#include <array>
#include <iostream>

constexpr std::array<int, 10> make_table() {
    std::array<int, 10> arr{};
    for (size_t i = 0; i < arr.size(); ++i) {
        arr[i] = static_cast<int>(i * i);
    }
    return arr;
}

int main() {
    constexpr auto table = make_table();
    // table은 컴파일 타임에 생성됨
    for (int x : table) {
        std::cout << x << " ";
    }
    std::cout << "\n";
}

4. 타입 트레이트 완전 예제

표준 타입 트레이트

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <type_traits>
#include <iostream>

// is_integral, is_floating_point, is_arithmetic
static_assert(std::is_integral_v<int>);
static_assert(std::is_integral_v<unsigned long>);
static_assert(!std::is_integral_v<double>);

static_assert(std::is_arithmetic_v<int>);
static_assert(std::is_arithmetic_v<double>);
static_assert(!std::is_arithmetic_v<std::string>);

// is_same
static_assert(std::is_same_v<int, int>);
static_assert(!std::is_same_v<int, long>);

// is_convertible
static_assert(std::is_convertible_v<int, double>);
static_assert(!std::is_convertible_v<double*, int>);

// remove_reference, remove_const
static_assert(std::is_same_v<std::remove_reference_t<int&>, int>);
static_assert(std::is_same_v<std::remove_const_t<const int>, int>);

커스텀 타입 트레이트: has_member

#include <type_traits>

// T에 size() 멤버가 있는지 검사
template <typename T, typename = void>
struct has_size_member : std::false_type {};

template <typename T>
struct has_size_member<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type {};

template <typename T>
inline constexpr bool has_size_member_v = has_size_member<T>::value;

// 사용
static_assert(has_size_member_v<std::vector<int>>);
static_assert(has_size_member_v<std::string>);
static_assert(!has_size_member_v<int>);

커스텀 타입 트레이트: is_callable

#include <type_traits>

template <typename F, typename... Args>
struct is_callable {
private:
    template <typename G>
    static auto test(int) -> decltype(std::declval<G>()(std::declval<Args>()...), std::true_type{});
    template <typename>
    static std::false_type test(...);

public:
    static constexpr bool value = decltype(test<F>(0))::value;
};

template <typename F, typename... Args>
inline constexpr bool is_callable_v = is_callable<F, Args...>::value;

// 사용
static_assert(is_callable_v<int(*)(int), int>);
static_assert(!is_callable_v<int, int>);

타입 트레이트로 조건부 컴파일

#include <type_traits>
#include <iostream>

template <typename T>
void process(T value) {
    if constexpr (std::is_pointer_v<T>) {
        std::cout << "Pointer: " << *value << "\n";
    } else if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer: " << value << "\n";
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "Float: " << value << "\n";
    } else {
        std::cout << "Other\n";
    }
}

int main() {
    process(42);
    int x = 10;
    process(&x);
    process(3.14);
}

decay, remove_cvref

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <type_traits>

// 함수 인자로 받을 때 "원본 타입" 추출
template <typename T>
void foo(T&& arg) {
    using decayed = std::decay_t<T>;
    using clean = std::remove_cvref_t<T>;
    // decayed: T& -> T, T[] -> T*, 함수 -> 함수 포인터
    // remove_cvref: const, volatile, 참조 제거
}

// C++20 remove_cvref
static_assert(std::is_same_v<std::remove_cvref_t<const int&>, int>);

5. 자주 발생하는 에러와 해결법

에러 1: SFINAE 조건이 잘못되어 모든 오버로드 제외

증상: “no matching function for call” 에러. 모든 오버로드가 치환 실패로 제외됨.

원인: enable_if 조건이 너무 엄격하거나, std::void_t 패턴에서 decltype 표현식이 잘못됨.

// ❌ 잘못된 코드: decltype이 항상 실패
template <typename T>
struct has_foo<T, void_t<decltype(T::foo)>>  // T::foo가 멤버 변수면 OK, 함수면 다름

해결법:

// ✅ 올바른 코드: 호출 가능한지 검사
template <typename T>
struct has_foo<T, void_t<decltype(std::declval<T>().foo())>> : std::true_type {};

에러 2: return std::move()로 RVO 방해 (constexpr 맥락)

증상: constexpr 함수에서 return std::move(x)를 쓰면 컴파일 에러.

원인: constexpr에서 이동은 제한적. 지역 변수 반환 시 return x만 사용.

아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// ❌ 잘못된 코드
constexpr std::array<int, 3> make() {
    std::array<int, 3> a{1, 2, 3};
    return std::move(a);  // constexpr에서 문제 가능
}

// ✅ 올바른 코드
constexpr std::array<int, 3> make() {
    std::array<int, 3> a{1, 2, 3};
    return a;  // RVO 또는 복사
}

에러 3: if constexpr에서 선택되지 않은 분기의 오류

증상: if constexpr의 false 분기에서 문법 오류가 있으면 컴파일 에러.

원인: C++17에서 if constexpr는 선택되지 않은 분기의 잘못된 문법은 여전히 검사합니다. (템플릿이 인스턴스화되는 경우)

아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 잘못된 코드: T가 int가 아닐 때 std::to_string(T)가 없을 수 있음
template <typename T>
void print(T x) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << std::to_string(x) << "\n";  // int는 OK
    } else {
        std::cout << std::to_string(x) << "\n";  // T가 std::string이면 에러!
    }
}

해결법:

아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// ✅ 올바른 코드: 각 분기에서 유효한 표현식만 사용
template <typename T>
void print(T x) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << std::to_string(x) << "\n";
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << x << "\n";
    } else {
        std::cout << "[?]\n";
    }
}

에러 4: Concepts의 requires 순서

증상: concept이 여러 개일 때 “constraint not satisfied” 에러.

원인: concept의 requires 절에서 T가 아직 완전히 정의되지 않았을 수 있음.

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 잘못된 코드: 순환 의존
template <typename T>
concept A = B<T>;  // B가 T를 사용

template <typename T>
concept B = A<T>;

해결법:

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ✅ 올바른 코드: 단방향 의존
template <typename T>
concept HasSize = requires(T t) { t.size(); };

template <typename T>
concept Container = HasSize<T> && requires(T t) { std::begin(t); std::end(t); };

에러 5: 타입 트레이트에서 incomplete type

증상: sizeof(T)나 T::value 사용 시 “incomplete type” 에러.

원인: 전방 선언만 된 타입에 대해 sizeof 등을 적용.

// ❌ 잘못된 코드
struct ForwardDeclared;
static_assert(sizeof(ForwardDeclared) > 0);  // incomplete type

해결법:

// ✅ 올바른 코드: 정의가 있는 타입에서만 사용
struct Defined { int x; };
static_assert(sizeof(Defined) > 0);

에러 6: std::declval을 런타임에서 사용

증상: std::declval<T>()를 실제로 호출하면 링크 에러 또는 undefined behavior.

원인: declval은 decltype 등 컴파일 타임에만 사용. 정의가 없음.

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 잘못된 코드
auto x = std::declval<int>();  // 링크 에러 또는 UB

// ✅ 올바른 코드
using type = decltype(std::declval<int>());  // int

에러 7: enable_if의 기본 템플릿 인자 충돌

증상: 두 개의 enable_if 조건이 다른 템플릿이 있을 때, typename = std::enable_if_t<...>를 두 번 쓰면 충돌.

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 잘못된 코드
template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
void foo(T);

template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
void foo(T);  // 재정의: 기본 인자만 다름

해결법:

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ✅ 올바른 코드: 서로 다른 기본 인자 타입 사용
template <typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void foo(T);

template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
void foo(T);

6. 성능 최적화 팁

팁 1: 컴파일 타임 계산 활용

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// constexpr로 컴파일 타임에 계산
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

// 런타임 비용 0
constexpr int f10 = factorial(10);  // 3628800

적용: 작은 상수(10 이하)의 팩토리얼, 피보나치, 테이블 생성 등.

팁 2: if constexpr로 분기 제거

아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

template <typename T>
void process(T value) {
    if constexpr (sizeof(T) == 4) {
        // 4바이트 타입 전용 처리
    } else {
        // 그 외
    }
}

선택되지 않은 분기는 바이너리에 포함되지 않음. 런타임 if보다 코드 크기·분기 예측에 유리.

팁 3: 타입 트레이트 캐싱

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 코드를 직접 실행해보면서 동작을 확인해보세요.

// 복잡한 타입 트레이트는 using으로 재사용
template <typename T>
using is_my_container = std::conjunction<
    has_begin<T>,
    has_end<T>,
    has_size_member<T>
>;

팁 4: Concepts로 컴파일 시간 단축

Concepts는 SFINAE보다 조기 실패가 가능해, 일부 케이스에서 컴파일 시간이 단축될 수 있습니다. (구현에 따라 다름)

팁 5: extern template로 인스턴스화 제한

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// header
template <typename T>
void process(T value);

// source
extern template void process<int>(int);
extern template void process<double>(double);

자주 쓰는 타입만 명시적으로 인스턴스화해, 컴파일 단위마다 중복 인스턴스화를 줄입니다.

성능 비교 요약

기법	컴파일 시간	가독성
SFINAE	보통	낮음
Concepts	보통~빠름	높음
constexpr	증가 가능	높음
타입 트레이트	보통	중간

7. 프로덕션 패턴

패턴 1: 타입 안전한 직렬화

#include <string>
#include <type_traits>

template <typename T>
std::string serialize(const T& value) {
    if constexpr (std::is_same_v<T, std::string>) {
        return value;
    } else if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else if constexpr (std::is_pointer_v<T>) {
        return value ? std::to_string(reinterpret_cast<uintptr_t>(value)) : "null";
    } else {
        return "[serializable]";
    }
}

패턴 2: 디버그/릴리즈 분기

#include <iostream>

enum class Build { Debug, Release };

struct BuildConfig {
    static constexpr Build value = Build::Release;
};

template <typename Config>
void log(const char* msg) {
    if constexpr (Config::value == Build::Debug) {
        std::cerr << "[DEBUG] " << msg << "\n";
    }
    // Release에서는 빈 함수, 컴파일러가 제거
}

패턴 3: 반복자 범위 알고리즘

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iterator>
#include <algorithm>

template <std::random_access_iterator It>
void my_sort(It first, It last) {
    std::sort(first, last);
}

template <std::forward_iterator It>
void my_advance(It& it, typename std::iterator_traits<It>::difference_type n) {
    while (n--) ++it;
}

패턴 4: CRTP + 타입 트레이트

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <type_traits>

template <typename Derived>
struct Base {
    void interface() {
        static_cast<Derived*>(this)->impl();
    }
};

template <typename T>
struct has_impl : std::false_type {};

template <typename D>
struct has_impl<Base<D>> : std::true_type {};

패턴 5: 조건부 noexcept

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고, 에러 처리를 통해 안정성을 확보합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

#include <type_traits>

template <typename T>
void swap(T& a, T& b) noexcept(std::is_nothrow_move_constructible_v<T> &&
                                std::is_nothrow_move_assignable_v<T>) {
    T temp = std::move(a);
    a = std::move(b);
    b = std::move(temp);
}

패턴 6: 태그 디스패칭

#include <iterator>

template <typename It>
void advance_impl(It& it, typename std::iterator_traits<It>::difference_type n,
                 std::random_access_iterator_tag) {
    it += n;
}

template <typename It>
void advance_impl(It& it, typename std::iterator_traits<It>::difference_type n,
                 std::forward_iterator_tag) {
    while (n--) ++it;
}

template <typename It>
void my_advance(It& it, typename std::iterator_traits<It>::difference_type n) {
    advance_impl(it, n, typename std::iterator_traits<It>::iterator_category{});
}

프로덕션 체크리스트

C++20 이상이면 Concepts 우선 사용
constexpr 함수는 가능한 한 constexpr로
SFINAE 사용 시 enable_if 조건을 명확히
if constexpr에서 선택되지 않은 분기에 유효하지 않은 코드 없도록
타입 트레이트는 _v, _t 접미사 활용
Clang-Tidy의 modernize-use-nodiscard 등 메타프로그래밍 관련 검사 활성화

8. 정리

항목	설명
SFINAE	치환 실패는 에러가 아님. `enable_if`, `void_t`로 타입 제약
Concepts	C++20 타입 제약. 가독성·에러 메시지 우수
constexpr	컴파일 타임 계산. `if constexpr`로 분기
타입 트레이트	`is_integral`, `is_same`, 커스텀 `has_*` 등

핵심 원칙:

C++20이면 Concepts 우선
컴파일 타임에 끝낼 수 있는 것은 constexpr로
타입별 분기는 if constexpr + 타입 트레이트
SFINAE는 레거시 이해용으로 익혀 두기

자주 묻는 질문 (FAQ)

Q. 이 내용을 실무에서 언제 쓰나요?

A. 라이브러리 개발, 제네릭 프로그래밍, 컴파일 타임 최적화 등에 활용합니다. 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.

Q. SFINAE와 Concepts 중 뭘 써야 하나요?

A. C++20 이상이면 Concepts를 쓰는 것이 훨씬 읽기 쉽고 에러 메시지도 좋습니다. 레거시 코드는 SFINAE를 이해해야 합니다.

Q. 선행으로 읽으면 좋은 글은?

A. 각 글 하단의 이전 글 링크를 따라가면 순서대로 배울 수 있습니다. C++ 시리즈 목차에서 전체 흐름을 확인할 수 있습니다.

Q. 더 깊이 공부하려면?

A. cppreference와 해당 라이브러리 공식 문서를 참고하세요. 글 말미의 참고 자료 링크도 활용하면 좋습니다.

한 줄 요약: SFINAE·Concepts·constexpr·타입 트레이트를 마스터할 수 있습니다.

C++ 리플렉션 구현 | 타입 정보·메타데이터·자동 직렬화 [#55-1]

이 글의 핵심

들어가며: “템플릿 하나 추가했는데 컴파일 에러가 100줄이에요"

"정수만 받는 함수가 실수도 받아버려요”

추가 문제 시나리오

목차

1. SFINAE 완전 예제

SFINAE란?

기본 예제: 정수만 받는 함수

C++14/17 스타일: enable_if_t, is_integral_v

void_t 패턴: 멤버 존재 여부 검사

SFINAE로 함수 오버로드 선택

2. Concepts 완전 예제

Concepts란? (C++20)

기본 개념 정의

복합 concept

requires 절로 세밀한 제약

Concepts vs SFINAE 비교

3. constexpr 완전 예제

constexpr란?

기본: constexpr 변수와 함수

constexpr if: 컴파일 타임 분기

constexpr 피보나치

constexpr 메타 프로그래밍: 타입 리스트 크기

constexpr와 std::array

4. 타입 트레이트 완전 예제

표준 타입 트레이트

커스텀 타입 트레이트: has_member

커스텀 타입 트레이트: is_callable

타입 트레이트로 조건부 컴파일

decay, remove_cvref

5. 자주 발생하는 에러와 해결법

에러 1: SFINAE 조건이 잘못되어 모든 오버로드 제외

에러 2: return std::move()로 RVO 방해 (constexpr 맥락)

에러 3: if constexpr에서 선택되지 않은 분기의 오류

에러 4: Concepts의 requires 순서

에러 5: 타입 트레이트에서 incomplete type

에러 6: std::declval을 런타임에서 사용

에러 7: enable_if의 기본 템플릿 인자 충돌

6. 성능 최적화 팁

팁 1: 컴파일 타임 계산 활용

팁 2: if constexpr로 분기 제거

팁 3: 타입 트레이트 캐싱

팁 4: Concepts로 컴파일 시간 단축

팁 5: extern template로 인스턴스화 제한

성능 비교 요약

7. 프로덕션 패턴

패턴 1: 타입 안전한 직렬화

패턴 2: 디버그/릴리즈 분기

패턴 3: 반복자 범위 알고리즘

패턴 4: CRTP + 타입 트레이트

패턴 5: 조건부 noexcept

패턴 6: 태그 디스패칭

프로덕션 체크리스트

8. 정리

자주 묻는 질문 (FAQ)

Q. 이 내용을 실무에서 언제 쓰나요?

Q. SFINAE와 Concepts 중 뭘 써야 하나요?

Q. 선행으로 읽으면 좋은 글은?

Q. 더 깊이 공부하려면?

관련 글