C++ SFINAE 완벽 가이드 | enable_if·void_t

들어가며: “이 타입에 size()가 있는지 컴파일 타임에 알고 싶어요”

구체적인 문제 시나리오

템플릿을 작성하다 보면 이런 상황을 자주 겪습니다:

• 정수형만 받는 함수를 만들었는데, std::vector를 넘기면 50줄 넘는 템플릿 인스턴스화 에러가 난다
• 컨테이너를 받아 size()로 크기를 반환하고 싶은데, int나 double도 넘어올 수 있어서 “이 타입에 size()가 있는지”를 컴파일 타임에 검사하고 싶다
• 직렬화 함수에서 operator<<가 있는 타입만 처리하고, 없으면 to_string()으로 폴백하고 싶다
• 반복자를 받는 알고리즘에서 std::random_access_iterator인지 std::forward_iterator인지에 따라 다른 구현을 선택하고 싶다

이런 “타입에 따라 다른 오버로드를 선택”하거나 “표현식이 유효한지 검사”하는 기법이 SFINAE(Substitution Failure Is Not An Error)입니다. 비유하면 “이 자리에 맞는 부품만 끼워 넣을 수 있다”고 규칙을 두면, 맞지 않는 부품은 “에러”가 아니라 “이 오버로드는 후보에서 제외”되는 것입니다.

SFINAE 동작 원리 시각화

flowchart TD
    A[템플릿 인스턴스화 시도] --> B{치환 Substitution 성공?}
    B -->|예| C[오버로드 후보에 포함]
    B -->|아니오| D[에러가 아님 - 후보에서 제외]
    D --> E{다른 후보가 있음?}
    E -->|예| F[다른 후보로 해결]
    E -->|아니오| G[no matching function 에러]

추가 문제 시나리오

시나리오 1: JSON 직렬화
int, double, std::string, std::vector 등 타입별로 직렬화 방식이 다릅니다. operator<<가 있는 타입은 스트림으로, begin()/end()가 있는 타입은 배열로 출력하고 싶습니다. SFINAE로 “이 타입에 begin()이 있는지” 검사해 오버로드를 분기합니다.

시나리오 2: 로깅 유틸리티
log(T x)에서 T가 std::string이면 그대로, int*면 역참조해서 출력하고, std::vector면 [1,2,3] 형태로 출력하고 싶습니다. std::enable_if로 타입별 오버로드를 나눕니다.

시나리오 3: 알고리즘 최적화
std::vector는 []로 O(1) 접근이 가능하지만 std::list는 불가능합니다. “이 컨테이너에 operator[]가 있는지” 검사해 random_access 구현과 forward 구현을 분리합니다.

시나리오 4: 스마트 포인터 래퍼
T*와 std::unique_ptr<T>를 모두 받는 함수에서, T*는 그대로 사용하고 unique_ptr은 .get()으로 포인터를 꺼내야 합니다. std::is_pointer_v와 has_get_member 같은 detection으로 분기합니다.

시나리오 5: 프로토콜 버퍼
has_serialize() 메서드가 있는 타입만 직렬화하고, 없으면 static_assert로 컴파일 에러를 내고 싶습니다. Detection idiom으로 “이 타입에 serialize(OutputStream&)가 있는지” 검사합니다.

시나리오 6: 테스트 목 오브젝트
Mock 클래스에 expect_call() 메서드가 있는지 검사해, 있으면 Mock 모드로, 없으면 실제 구현으로 분기하는 테스트 유틸리티를 만들 때 SFINAE를 사용합니다.

이 글을 읽으면

• SFINAE의 동작 원리와 “치환 실패 = 에러가 아님”을 이해할 수 있습니다.
• std::enable_if로 타입 조건에 따라 오버로드를 활성화/비활성화할 수 있습니다.
• void_t와 Detection idiom으로 “이 타입에 X가 있는지”를 검사할 수 있습니다.
• is_detected 패턴으로 재사용 가능한 타입 검사를 만들 수 있습니다.
• 자주 발생하는 에러와 해결법을 알 수 있습니다.
• 프로덕션에서 바로 쓸 수 있는 패턴을 적용할 수 있습니다.

---

목차

1. SFINAE 기초
2. std::enable_if 완전 예제
3. void_t와 표현식 검사
4. Detection Idiom
5. is_detected 패턴
6. 자주 발생하는 에러와 해결법
7. 베스트 프랙티스
8. 프로덕션 패턴
9. SFINAE vs Concepts

---

1. SFINAE 기초

1.1 SFINAE란?

SFINAE(Substitution Failure Is Not An Error)는 C++ 템플릿에서 치환(Substitution) 과정에서 발생하는 실패를 에러로 처리하지 않고, 해당 오버로드 후보만 제외하는 규칙입니다.

템플릿을 인스턴스화할 때, 컴파일러는 템플릿 파라미터를 실제 타입으로 치환합니다. 이 과정에서 std::enable_if<false, T>::type처럼 유효하지 않은 타입이 나오면, 그 오버로드는 “에러”가 아니라 후보에서 제외됩니다. 다른 오버로드가 매칭되면 정상적으로 컴파일됩니다.

1.2 치환이 일어나는 곳

SFINAE가 적용되는 곳은 함수 타입에 직접 관여하는 부분입니다:

• 함수 반환 타입
• 함수 파라미터 타입
• 템플릿 파라미터의 기본값
• 함수 noexcept 지정자 (C++11~)

다음은 SFINAE가 적용되지 않는 곳입니다 (치환 실패 시 에러):

• 함수 본문 안
• static_assert (함수 본문에 있으면 인스턴스화 시 평가됨)

1.3 최소 예제: 정수형만 받는 add

#include <type_traits>
#include <iostream>

// T가 정수형일 때만 이 오버로드 활성화
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(3, 5) << "\n";        // 8
    std::cout << add(3u, 5u) << "\n";      // 8
    // add(3.0, 5.0);  // 컴파일 에러: is_integral<double> = false
    return 0;
}

설명: std::enable_if<std::is_integral<T>::value, T>::type에서 is_integral<T>::value가 false이면 enable_if는 ::type을 정의하지 않습니다. 따라서 치환 실패가 발생하고, 이 오버로드는 후보에서 제외됩니다. add(3.0, 5.0)을 호출하면 “no matching function” 에러가 나지만, “정수형이 아님”이라는 의도가 드러납니다.

1.4 SFINAE 적용 위치 비교

flowchart LR
    subgraph valid["SFINAE 적용됨"]
        V1[반환 타입]
        V2[파라미터 타입]
        V3[템플릿 기본값]
        V4[noexcept]
    end
    subgraph invalid["SFINAE 적용 안 됨"]
        I1[함수 본문]
        I2[클래스 본문]
    end

---

2. std::enable_if 완전 예제

2.1 enable_if 동작 원리

std::enable_if<Cond, T>는 조건 Cond가 true일 때만 ::type이 T로 정의됩니다. Cond가 false면 ::type이 없어서 치환 실패가 발생합니다.

// <type_traits> 내부 개념
template <bool B, typename T = void>
struct enable_if {};

template <typename T>
struct enable_if<true, T> {
    using type = T;
};

// C++14: _t 별칭
template <bool B, typename T = void>
using enable_if_t = typename enable_if<B, T>::type;

2.2 반환 타입에 enable_if 사용

#include <type_traits>
#include <iostream>

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

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

int main() {
    std::cout << add(3, 5) << "\n";      // 8 (정수)
    std::cout << add(3.0, 5.0) << "\n"; // 8.0 (부동소수)
    // add("a", "b");  // 에러: 매칭되는 오버로드 없음
    return 0;
}

주의: add(3, 5)와 add(3.0, 5.0)은 서로 다른 오버로드입니다. 정수형과 부동소수형을 같은 함수에서 처리하려면 if constexpr나 Concepts를 사용하는 것이 좋습니다.

2.3 파라미터에 enable_if 사용 (더미 파라미터)

#include <type_traits>
#include <iostream>

template <typename T>
T add(T a, T b, typename std::enable_if<std::is_integral<T>::value, int>::type = 0) {
    return a + b;
}

int main() {
    std::cout << add(3, 5) << "\n";  // 8
    return 0;
}

설명: 세 번째 파라미터는 “더미”입니다. enable_if가 성공하면 int 타입에 기본값 0이 붙고, 실패하면 ::type이 없어 치환 실패가 됩니다. 호출 시 add(3, 5)처럼 두 인자만 넘기면 됩니다.

2.4 템플릿 기본값에 enable_if 사용

#include <type_traits>
#include <iostream>

template <typename T,
          typename = std::enable_if_t<std::is_integral<T>::value>>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(3, 5) << "\n";  // 8
    return 0;
}

주의: 이 방식은 오버로드 구분에 한계가 있습니다. 두 개의 add(정수용, 부동소수용)를 만들 때, 둘 다 typename = enable_if_t<...>를 쓰면 기본 템플릿 파라미터가 같아져 재선언 에러가 날 수 있습니다. 이때는 typename std::enable_if<...>::type* = nullptr처럼 서로 다른 형태를 씁니다.

2.5 enable_if로 오버로드 분리 (정수 vs 부동소수)

#include <type_traits>
#include <iostream>

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

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

// 포인터는 제외
template <typename T>
std::enable_if_t<std::is_pointer_v<T>, T> add(T a, T b) = delete;

int main() {
    std::cout << add(3, 5) << "\n";
    std::cout << add(3.0, 5.0) << "\n";
    // int x = 1, y = 2;
    // add(&x, &y);  // deleted function
    return 0;
}

2.6 enable_if로 클래스 템플릿 특수화

#include <type_traits>
#include <iostream>

template <typename T, typename = void>
struct Printer {
    static void print(const T& x) {
        std::cout << "default: " << x << "\n";
    }
};

// operator<<가 있는 타입
template <typename T>
struct Printer<T, std::void_t<decltype(std::cout << std::declval<T>())>> {
    static void print(const T& x) {
        std::cout << "stream: " << x << "\n";
    }
};

int main() {
    Printer<int>::print(42);           // stream: 42
    Printer<std::string>::print("hi"); // stream: hi
    return 0;
}

---

3. void_t와 표현식 검사

3.1 void_t란?

std::void_t(C++17)는 임의의 타입들을 받아서 void로 매핑하는 메타 함수입니다. 표현식이 유효한지 검사할 때 사용합니다.

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

// 사용 예
std::void_t<int>;           // void
std::void_t<int, double>;   // void
std::void_t<decltype(x)>;   // x가 유효하면 void, 아니면 치환 실패

3.2 void_t로 “이 타입에 size()가 있는지” 검사

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

template <typename T, typename = void>
struct has_size : std::false_type {};

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

template <typename T>
inline constexpr bool has_size_v = has_size<T>::value;

template <typename T>
std::enable_if_t<has_size_v<T>, size_t> get_size(const T& x) {
    return x.size();
}

template <typename T>
std::enable_if_t<!has_size_v<T>, size_t> get_size(const T&) {
    return sizeof(T);
}

int main() {
    std::vector<int> v{1, 2, 3};
    std::cout << get_size(v) << "\n";   // 3
    std::cout << get_size(42) << "\n";  // sizeof(int)
    return 0;
}

동작 원리:

1. has_size<T, void>는 기본적으로 false_type을 상속합니다.
2. has_size<T, void_t<decltype(std::declval<T>().size())>>에서 T().size()가 유효한 표현식이면 void_t<...>는 void가 됩니다.
3. void는 두 번째 템플릿 파라미터의 기본값과 같으므로, 이 특수화가 선택됩니다.
4. T().size()가 유효하지 않으면 decltype이 실패해 치환 실패가 되고, 기본 정의가 사용됩니다.

3.3 void_t로 “이 타입에 begin()/end()가 있는지” 검사

#include <type_traits>
#include <vector>
#include <iostream>

template <typename T, typename = void>
struct is_iterable : std::false_type {};

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

template <typename T>
inline constexpr bool is_iterable_v = is_iterable<T>::value;

template <typename T>
std::enable_if_t<is_iterable_v<T>> print_container(const T& c) {
    for (const auto& x : c)
        std::cout << x << " ";
    std::cout << "\n";
}

int main() {
    std::vector<int> v{1, 2, 3};
    print_container(v);  // 1 2 3
    // print_container(42);  // 에러: is_iterable_v<int> = false
    return 0;
}

3.4 void_t로 멤버 타입 검사

#include <type_traits>

template <typename T, typename = void>
struct has_value_type : std::false_type {};

template <typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

template <typename T>
inline constexpr bool has_value_type_v = has_value_type<T>::value;

// 사용
static_assert(has_value_type_v<std::vector<int>>);
static_assert(has_value_type_v<std::map<int, int>>);
static_assert(!has_value_type_v<int>);

---

4. Detection Idiom

4.1 Detection Idiom이란?

Detection idiom은 “타입 T에 특정 표현식이 유효한지”를 검사하는 패턴입니다. void_t를 활용해, 유효하면 한 특수화가 매칭되고, 유효하지 않으면 기본 정의가 매칭됩니다.

4.2 표현식 검사 템플릿

#include <type_traits>
#include <utility>

template <typename AlwaysVoid, template <typename...> class Op, typename... Args>
struct detector : std::false_type {};

template <template <typename...> class Op, typename... Args>
struct detector<std::void_t<Op<Args...>>, Op, Args...> : std::true_type {};

template <template <typename...> class Op, typename... Args>
inline constexpr bool is_detected_v = detector<void, Op, Args...>::value;

설명: Op<Args...>가 유효한 타입이면 void_t<Op<Args...>>는 void가 되고, detector<void, Op, Args...> 특수화가 매칭됩니다. Op<Args...>가 유효하지 않으면 치환 실패로 기본 정의가 사용됩니다.

4.3 “size() 멤버 함수” 검사

#include <type_traits>
#include <utility>
#include <vector>
#include <iostream>

template <typename AlwaysVoid, template <typename...> class Op, typename... Args>
struct detector : std::false_type {};

template <template <typename...> class Op, typename... Args>
struct detector<std::void_t<Op<Args...>>, Op, Args...> : std::true_type {};

template <template <typename...> class Op, typename... Args>
inline constexpr bool is_detected_v = detector<void, Op, Args...>::value;

template <typename T>
using size_result_t = decltype(std::declval<T>().size());

int main() {
    std::cout << std::boolalpha;
    std::cout << is_detected_v<size_result_t, std::vector<int>> << "\n";  // true
    std::cout << is_detected_v<size_result_t, int> << "\n";               // false
    return 0;
}

4.4 “operator<<” 검사

#include <type_traits>
#include <utility>
#include <iostream>

template <typename T>
using ostreamable_t = decltype(std::declval<std::ostream&>() << std::declval<T>());

template <typename AlwaysVoid, template <typename...> class Op, typename... Args>
struct detector : std::false_type {};

template <template <typename...> class Op, typename... Args>
struct detector<std::void_t<Op<Args...>>, Op, Args...> : std::true_type {};

template <template <typename...> class Op, typename... Args>
inline constexpr bool is_detected_v = detector<void, Op, Args...>::value;

template <typename T>
void print_if_streamable(const T& x) {
    if constexpr (is_detected_v<ostreamable_t, T>) {
        std::cout << x << "\n";
    } else {
        std::cout << "[not streamable]\n";
    }
}

int main() {
    print_if_streamable(42);       // 42
    print_if_streamable("hello"); // hello
    // print_if_streamable(std::vector<int>{});  // [not streamable] (operator<< 없음)
    return 0;
}

---

5. is_detected 패턴

5.1 is_detected 완전 구현

C++17 표준에는 std::experimental::is_detected가 있지만, 표준 라이브러리에 포함되지 않았습니다. 직접 구현하는 패턴입니다.

#include <type_traits>
#include <utility>

namespace detail {
    template <typename AlwaysVoid, template <typename...> class Op, typename... Args>
    struct detector {
        using value_t = std::false_type;
    };

    template <template <typename...> class Op, typename... Args>
    struct detector<std::void_t<Op<Args...>>, Op, Args...> {
        using value_t = std::true_type;
    };
}

template <template <typename...> class Op, typename... Args>
struct is_detected : detail::detector<void, Op, Args...>::value_t {};

template <template <typename...> class Op, typename... Args>
inline constexpr bool is_detected_v = is_detected<Op, Args...>::value;

5.2 detected_t: 검사된 타입 추출

#include <type_traits>
#include <utility>

namespace detail {
    template <typename Default, typename AlwaysVoid, template <typename...> class Op, typename... Args>
    struct detector {
        using value_t = Default;
    };

    template <typename Default, template <typename...> class Op, typename... Args>
    struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
        using value_t = Op<Args...>;
    };
}

template <typename Default, template <typename...> class Op, typename... Args>
using detected_t = typename detail::detector<Default, void, Op, Args...>::value_t;

// 사용: size() 반환 타입 추출, 없으면 void
template <typename T>
using size_result_t = decltype(std::declval<T>().size());

template <typename T>
using size_type_t = detected_t<void, size_result_t, T>;

// vector<int>::size() -> size_t
// int에는 size() 없음 -> void

5.3 is_detected_exact: 반환 타입까지 검사

#include <type_traits>
#include <utility>

template <typename Expected, template <typename...> class Op, typename... Args>
struct is_detected_exact : std::false_type {};

template <typename Expected, template <typename...> class Op, typename... Args>
struct is_detected_exact<Expected, Op, Args...>
    : std::is_same<Expected, detected_t<void, Op, Args...>> {};

5.4 실전: has_reserve 검사

#include <type_traits>
#include <utility>
#include <vector>
#include <list>
#include <iostream>

template <typename T>
using reserve_expr = decltype(std::declval<T>().reserve(std::declval<size_t>()));

template <typename AlwaysVoid, template <typename...> class Op, typename... Args>
struct detector : std::false_type {};

template <template <typename...> class Op, typename... Args>
struct detector<std::void_t<Op<Args...>>, Op, Args...> : std::true_type {};

template <template <typename...> class Op, typename... Args>
inline constexpr bool is_detected_v = detector<void, Op, Args...>::value;

template <typename T>
inline constexpr bool has_reserve_v = is_detected_v<reserve_expr, T>;

template <typename T>
std::enable_if_t<has_reserve_v<T>> maybe_reserve(T& c, size_t n) {
    c.reserve(n);
}

template <typename T>
std::enable_if_t<!has_reserve_v<T>> maybe_reserve(T&, size_t) {
    // reserve 없음: 아무것도 안 함
}

int main() {
    std::vector<int> v;
    maybe_reserve(v, 100);  // v.reserve(100) 호출됨

    std::list<int> l;
    maybe_reserve(l, 100);  // 아무것도 안 함 (list에는 reserve 없음)
    return 0;
}

---

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

에러 1: enable_if가 함수 본문에 있어서 SFINAE가 안 됨

원인: SFINAE는 함수 시그니처에만 적용됩니다. 본문 안의 if (std::is_integral_v<T>) 같은 코드는 인스턴스화 후에 평가되므로, T가 정수가 아니면 이미 본문에서 에러가 난 뒤입니다.

// ❌ 잘못된 예: 본문에서 is_integral 사용
template <typename T>
T add(T a, T b) {
    if (std::is_integral_v<T>)  // T가 vector면 a+b에서 이미 에러
        return a + b;
    return a + b;
}

// ✅ 올바른 예: 반환 타입에 enable_if
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T> add(T a, T b) {
    return a + b;
}

에러 2: 기본 템플릿 파라미터 중복으로 재선언 에러

원인: 두 오버로드가 모두 template <typename T, typename = enable_if_t<...>>를 쓰면, 기본 파라미터가 같아져 재선언으로 인식됩니다.

// ❌ 잘못된 예
template <typename T, typename = 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_floating_point_v<T>>>
T add(T a, T b) { return a + b; }  // 재선언 에러!

// ✅ 올바른 예: 반환 타입이나 서로 다른 기본 파라미터 사용
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T> add(T a, T b) { return a + b; }

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

에러 3: void_t에 잘못된 표현식

원인: void_t 안의 표현식이 타입이어야 합니다. decltype(expr)을 사용해 타입으로 만듭니다.

// ❌ 잘못된 예
std::void_t<std::declval<T>().size()>;  // size()는 값, 타입 아님

// ✅ 올바른 예
std::void_t<decltype(std::declval<T>().size())>;

에러 4: declval을 잘못된 컨텍스트에서 사용

원인: std::declval<T>()는 선언 전용입니다. sizeof나 decltype 안에서만 사용해야 합니다.

// ❌ 잘못된 예
auto x = std::declval<T>();  // 링크 에러 또는 정의 필요

// ✅ 올바른 예
decltype(std::declval<T>().size());

에러 5: const/참조 무시

원인: std::declval<T>()는 T&&를 반환합니다. const T&로 호출하고 싶으면 std::declval<const T&>()를 사용합니다.

template <typename T>
using size_expr = decltype(std::declval<const T&>().size());

에러 6: 중첩된 템플릿에서 쉼표 해석

원인: std::void_t<A, B>에서 쉼표가 “함수 인자 구분”으로 해석될 수 있습니다. (void)A, (void)B처럼 괄호로 감싸거나, 단일 decltype((expr))로 묶습니다.

// ✅ 안전한 다중 표현식 검사
template <typename T>
struct has_begin_end : std::false_type {};

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

에러 7: 모든 오버로드가 SFINAE로 제외됨

원인: 조건이 너무 엄격해 어떤 타입도 매칭되지 않을 수 있습니다.

// ❌ int와 double 둘 다 is_integral, is_floating_point가 false인 경우?
// (실제로는 int는 integral, double은 floating_point)

// ✅ 폴백 오버로드 제공
template <typename T>
std::enable_if_t<std::is_arithmetic_v<T>, T> add(T a, T b) {
    return a + b;
}

에러 8: MSVC에서 void_t 특수화 문제

원인: 일부 구 MSVC는 void_t 특수화를 다르게 처리할 수 있습니다.

해결: __void_t 같은 컴파일러 확장 대신, struct detector 패턴을 명시적으로 사용합니다.

에러 9: static_assert를 SFINAE 대신 사용

원인: static_assert는 치환 실패가 아니라 컴파일 에러를 발생시킵니다. 오버로드 후보를 “제외”하는 것이 아니라, 인스턴스화 자체를 막습니다.

// ❌ 오버로드 분기가 아님
template <typename T>
T add(T a, T b) {
    static_assert(std::is_integral_v<T>, "T must be integral");
    return a + b;
}
// add(3.0, 5.0) -> static_assert 실패로 컴파일 에러

// ✅ SFINAE: 다른 오버로드가 받을 수 있음
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T> add(T a, T b) { return a + b; }
template <typename T>
std::enable_if_t<std::is_floating_point_v<T>, T> add(T a, T b) { return a + b; }

에러 10: C++20에서 Concepts와 혼용 시 혼란

원인: requires와 enable_if를 같은 함수에 섞어 쓰면 의도가 불명확해집니다.

해결: C++20 이상에서는 Concepts를 우선 사용하고, SFINAE는 레거시 호환용으로만 유지합니다.

// ✅ C++20: Concepts 사용
template <std::integral T>
T add(T a, T b) { return a + b; }

---

7. 베스트 프랙티스

1. C++20이 가능하면 Concepts 사용

Concepts가 더 읽기 쉽고 에러 메시지도 좋습니다.

// ✅ C++20
template <std::integral T>
T add(T a, T b) { return a + b; }

// SFINAE는 레거시 또는 라이브러리 호환용

2. enable_if는 반환 타입에 두기

반환 타입이 가장 눈에 잘 띄고, 오버로드 구분도 명확합니다.

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

3. 검사 로직을 별도 트레이트로 분리

has_size, is_iterable 등을 재사용 가능한 트레이트로 만들어 두면 유지보수가 쉽습니다.

template <typename T>
inline constexpr bool has_size_v = /* ... */;

template <typename T>
std::enable_if_t<has_size_v<T>, size_t> get_size(const T& x) { return x.size(); }

4. void_t는 표준 std::void_t 사용 (C++17)

C++17에서는 std::void_t를 사용하고, C++11/14에서는 template<typename...> using void_t = void;를 직접 정의합니다.

5. detected_t로 반환 타입 추출

표현식이 유효할 때 그 결과 타입도 필요하면 detected_t를 사용합니다.

template <typename T>
using size_type_t = detected_t<void, decltype(std::declval<T>().size()), T>;

6. const/참조 일관성

const T&로 호출할 함수라면 std::declval<const T&>()를 사용해 검사합니다.

7. 문서화

SFINAE 조건이 복잡하면 “이 오버로드는 T에 size()가 있을 때만 활성화”처럼 주석을 달아 둡니다.

---

8. 프로덕션 패턴

패턴 1: JSON 직렬화 타입 분기

#include <type_traits>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>

template <typename T, typename = void>
struct JsonSerializer {
    static std::string serialize(const T& x) {
        return std::to_string(x);
    }
};

template <typename T>
struct JsonSerializer<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<T>())>> {
    static std::string serialize(const T& x) {
        std::ostringstream oss;
        oss << x;
        return "\"" + oss.str() + "\"";
    }
};

template <typename T>
struct JsonSerializer<T, std::void_t<
    decltype(std::declval<T>().begin()),
    decltype(std::declval<T>().end())
>> {
    static std::string serialize(const T& x) {
        std::string result = "[";
        bool first = true;
        for (const auto& e : x) {
            if (!first) result += ",";
            result += JsonSerializer<std::decay_t<decltype(e)>>::serialize(e);
            first = false;
        }
        result += "]";
        return result;
    }
};

패턴 2: 컨테이너 reserve 최적화

template <typename Container>
void append_reserved(Container& c, size_t extra) {
    if constexpr (is_detected_v<reserve_expr, Container>) {
        c.reserve(c.size() + extra);
    }
    // reserve 없으면 그냥 push_back
}

패턴 3: 스마트 포인터/ raw 포인터 통합

template <typename T>
using get_expr = decltype(std::declval<T>().get());

template <typename T>
std::enable_if_t<std::is_pointer_v<T>, std::remove_pointer_t<T>&> deref(T p) {
    return *p;
}

template <typename T>
std::enable_if_t<is_detected_v<get_expr, T>, typename T::element_type&> deref(T& smart) {
    return *smart.get();
}

패턴 4: 반복자 카테고리별 알고리즘

template <typename It>
std::enable_if_t<std::is_same_v<typename std::iterator_traits<It>::iterator_category,
                                std::random_access_iterator_tag>, void>
advance_many(It& it, size_t n) {
    it += n;
}

template <typename It>
std::enable_if_t<!std::is_same_v<typename std::iterator_traits<It>::iterator_category,
                                 std::random_access_iterator_tag>, void>
advance_many(It& it, size_t n) {
    while (n--) ++it;
}

패턴 5: 로깅 유틸리티

template <typename T>
std::enable_if_t<std::is_arithmetic_v<T>> log_value(const T& x) {
    std::cout << "value: " << x << "\n";
}

template <typename T>
std::enable_if_t<std::is_pointer_v<T>> log_value(T p) {
    std::cout << "ptr: " << (p ? std::to_string(*p) : "null") << "\n";
}

template <typename T>
std::enable_if_t<is_iterable_v<T> && !std::is_pointer_v<T>> log_value(const T& c) {
    std::cout << "container: [";
    for (const auto& x : c) std::cout << x << " ";
    std::cout << "]\n";
}

패턴 6: 타입 안전한 to_string

template <typename T>
std::enable_if_t<std::is_arithmetic_v<T>, std::string> to_string_safe(const T& x) {
    return std::to_string(x);
}

template <typename T>
std::enable_if_t<std::is_same_v<T, std::string>, std::string> to_string_safe(const T& s) {
    return s;
}

template <typename T>
std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, std::string>, std::string>
to_string_safe(const T&) {
    return "[non-serializable]";
}

패턴 7: 프로토콜 버퍼 has_serialize 검사

template <typename T>
using serialize_expr = decltype(std::declval<T>().serialize(std::declval<std::ostream&>()));

template <typename T>
inline constexpr bool has_serialize_v = is_detected_v<serialize_expr, T>;

template <typename T>
std::enable_if_t<has_serialize_v<T>> save(const T& obj, std::ostream& out) {
    obj.serialize(out);
}

template <typename T>
std::enable_if_t<!has_serialize_v<T>> save(const T& obj, std::ostream& out) {
    static_assert(has_serialize_v<T>, "T must have serialize(ostream&)");
}

---

9. SFINAE vs Concepts

비교표

항목	SFINAE	Concepts (C++20)
가독성	enable_if 등으로 복잡	requires로 선언적
에러 메시지	인스턴스화 스택이 길음	”constraints not satisfied” 등 명확
작성 난이도	높음	상대적으로 낮음
C++ 표준	C++11~	C++20~
레거시 호환	널리 사용됨	C++20 컴파일러 필요

마이그레이션 예시

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

// Concepts (C++20)
template <std::integral T>
T add(T a, T b) { return a + b; }

---

SFINAE 적용 체크리스트

실무에서 SFINAE를 도입할 때 확인할 항목입니다.

• C++20이 가능한가? → Concepts 우선 검토
• 조건이 함수 시그니처(반환 타입, 파라미터, 템플릿 기본값)에 있는가? → 본문이 아닌 시그니처
• 오버로드 간 기본 템플릿 파라미터가 겹치지 않는가?
• void_t 안에 decltype으로 타입을 넘기는가?
• std::declval을 sizeof/decltype 안에서만 사용하는가?
• 폴백 오버로드가 필요한가? (모든 타입이 제외되지 않도록)
• 문서화가 되어 있는가? (복잡한 조건일 때)
• 모든 코드 블록에 언어 태그(cpp, mermaid)가 있는가?

---

정리

항목	내용
SFINAE	치환 실패 시 에러가 아니라 오버로드 후보에서 제외
enable_if	조건이 true일 때만 ::type이 정의됨 → 치환 실패로 오버로드 제외
void_t	표현식이 유효하면 void, 아니면 치환 실패
Detection idiom	void_t로 “이 타입에 X가 있는지” 검사
is_detected	재사용 가능한 표현식 검사 패턴
적용 위치	반환 타입, 파라미터, 템플릿 기본값, noexcept
C++20	Concepts로 많은 use case 대체 가능

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ Type Traits 완벽 가이드 | std::is_integral·std::enable_if
• C++ 템플릿 특수화 완벽 가이드 | 완전·부분 특수화, 문제 시나리오, 프로덕션 패턴
• C++ constexpr 완벽 가이드 | 컴파일 타임 계산·if constexpr·consteval 실전
• C++ 메타프로그래밍의 진화: Template에서 Constexpr, 그리고 Reflection까지

---

이 글에서 다루는 키워드 (관련 검색어)

C++ SFINAE, std::enable_if, void_t, detection idiom, is_detected, 템플릿 메타프로그래밍, 타입 트레이트, 컴파일 타임 타입 검사 등으로 검색하시면 이 글이 도움이 됩니다.

---

한 줄 요약: SFINAE로 타입 조건에 따라 오버로드를 분기하고, void_t·detection idiom으로 “이 타입에 X가 있는지”를 컴파일 타임에 검사할 수 있습니다. C++20에서는 Concepts를 우선 고려하세요.

실전 체크리스트

실무에서 이 개념을 적용할 때 확인해야 할 사항입니다.

코드 작성 전

• 이 기법이 현재 문제를 해결하는 최선의 방법인가?
• 팀원들이 이 코드를 이해하고 유지보수할 수 있는가?
• 성능 요구사항을 만족하는가?

코드 작성 중

• 컴파일러 경고를 모두 해결했는가?
• 엣지 케이스를 고려했는가?
• 에러 처리가 적절한가?

코드 리뷰 시

• 코드의 의도가 명확한가?
• 테스트 케이스가 충분한가?
• 문서화가 되어 있는가?

이 체크리스트를 활용하여 실수를 줄이고 코드 품질을 높이세요.

---

자주 묻는 질문 (FAQ)

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

A. C++ SFINAE로 템플릿 오버로드 분기·타입 검사·컴파일 타임 조건부 활성화. 문제 시나리오, enable_if·void_t·detection idiom·is_detected 완전 예제, 자주 발생하는 에러, 베… 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.

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

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

Q. 더 깊이 공부하려면?

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

다음 글: C++ 메타프로그래밍 진화 (#44-3)

---

관련 글

• C++ 메타프로그래밍의 진화: Template에서 Constexpr, 그리고 Reflection까지
• C++26 프리뷰: Reflection과 신규 표준 라이브러리 제안들 [#44-1]
• C++와 Rust: 두 언어의 상호 운용성과 Memory Safety 논쟁의 실체 [#44-2]
• C++ Fold Expression 완벽 가이드 | 단항·이항·쉼표 fold·커스텀 연산자 실전
• C++ constexpr 완벽 가이드 | 컴파일 타임 계산·if constexpr·consteval 실전