Abseil Code Review · 9/79

Abseil type_traits — negation·conjunction·void_t

2026년 6월 9일 · Hawk · 3분 읽기

cpp abseil type-traits sfinae meta-programming

한 줄 요약: absl::negation, absl::conjunction, absl::disjunction, absl::void_t는 C++17이 표준화한 type_traits 유틸리티의 C++14 polyfill이다. short-circuit evaluation과 SFINAE 친화성이 핵심이다.

#어떤 문제를 푸는가

template metaprogramming에서 “조건을 합치는” 작업은 흔하다.

1
template <typename T>
2
std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, void>
3
DoSomething(T t);

&&로 직접 묶는 방식은 C++14까지는 SFINAE에서 short-circuit이 보장되지 않았다. 즉, 첫 조건이 거짓이어도 두 번째 조건이 instantiated되어 hard error를 일으킬 수 있다. C++17의 std::conjunction이 이 문제를 해결했고, absl::conjunction은 C++14에서도 같은 동작을 제공한다.

#absl::negation — 부정

1
template <typename T>
2
struct negation : std::integral_constant<bool, !T::value> {};

std::negation (C++17)과 동일.

1
template <typename T>
2
using is_not_void = absl::negation<std::is_void<T>>;
3

4
static_assert(is_not_void<int>::value);
5
static_assert(!is_not_void<void>::value);

! 한 번 쓰는 것과 차이는 없어 보이지만, 다른 traits와 조합할 때 의미가 살아난다.

#absl::conjunction — AND (short-circuit)

1
template <typename... Ts>
2
struct conjunction : std::true_type {};
3

4
template <typename T>
5
struct conjunction<T> : T {};
6

7
template <typename T, typename... Ts>
8
struct conjunction<T, Ts...>
9
    : std::conditional_t<bool(T::value), conjunction<Ts...>, T> {};

핵심은 std::conditional_t다. 첫 조건이 false면 나머지를 instantiate하지 않는다.

1
// 위험한 패턴 — &&로 합치면 두 번째가 항상 instantiated
2
template <typename T>
3
std::enable_if_t<
4
    sizeof(T) > 0 && HasIteratorTrait<T>::value,
5
    void
6
> Process(T t);
7

8
// 안전한 방식 — conjunction으로 short-circuit
9
template <typename T>
10
std::enable_if_t<
11
    absl::conjunction<
12
        std::integral_constant<bool, (sizeof(T) > 0)>,
13
        HasIteratorTrait<T>
14
    >::value,
15
    void
16
> Process(T t);

#absl::disjunction — OR (short-circuit)

1
template <typename... Ts>
2
struct disjunction : std::false_type {};
3

4
template <typename T>
5
struct disjunction<T> : T {};
6

7
template <typename T, typename... Ts>
8
struct disjunction<T, Ts...>
9
    : std::conditional_t<bool(T::value), T, disjunction<Ts...>> {};

대칭 구조다. 첫 조건이 true면 나머지를 instantiate하지 않는다.

1
template <typename T>
2
using is_numeric = absl::disjunction<
3
    std::is_integral<T>,
4
    std::is_floating_point<T>
5
>;
6

7
static_assert(is_numeric<int>::value);
8
static_assert(is_numeric<double>::value);
9
static_assert(!is_numeric<std::string>::value);

#absl::void_t — SFINAE 핵심 도구

1
template <typename...>
2
using void_t = void;

단순해 보이지만 SFINAE의 가장 강력한 도구 중 하나. “이 type 표현식이 valid한가”를 검사한다.

1
// T가 iterator를 가졌는가?
2
template <typename T, typename = void>
3
struct has_iterator : std::false_type {};
4

5
template <typename T>
6
struct has_iterator<T, absl::void_t<typename T::iterator>>
7
    : std::true_type {};
8

9
static_assert(has_iterator<std::vector<int>>::value);
10
static_assert(!has_iterator<int>::value);

작동 원리:

primary template은 false_type 상속.
partial specialization이 T::iterator를 시도. 성공하면 void로 evaluation되어 specialization 선택.
실패하면 SFINAE로 primary template fallback.

#더 복잡한 예시 — detection idiom

1
// T가 begin()을 가졌는가?
2
template <typename T, typename = void>
3
struct has_begin : std::false_type {};
4

5
template <typename T>
6
struct has_begin<T, absl::void_t<decltype(std::declval<T>().begin())>>
7
    : std::true_type {};
8

9
// begin()과 end()를 모두 가졌는가?
10
template <typename T, typename = void>
11
struct is_iterable : std::false_type {};
12

13
template <typename T>
14
struct is_iterable<T, absl::void_t<
15
    decltype(std::declval<T>().begin()),
16
    decltype(std::declval<T>().end())
17
>> : std::true_type {};

void_t는 가변 인자 template이므로 여러 표현식을 한꺼번에 검사할 수 있다.

#std와의 비교

C++17 이후로는 표준 type_traits가 같은 기능을 제공한다.

Abseil	C++17 std
`absl::negation<T>`	`std::negation<T>`
`absl::conjunction<Ts...>`	`std::conjunction<Ts...>`
`absl::disjunction<Ts...>`	`std::disjunction<Ts...>`
`absl::void_t<Ts...>`	`std::void_t<Ts...>`

C++14를 타깃하는 코드에서는 Abseil 버전이 필요. C++17 이상이면 std로 옮기는 것이 권장된다.

1
// 권장 마이그레이션
2
// before
3
using has_x = absl::conjunction<HasFoo<T>, HasBar<T>>;
4

5
// after (C++17+)
6
using has_x = std::conjunction<HasFoo<T>, HasBar<T>>;

#absl 추가 traits

표준에 없는 traits도 있다.

#type_identity

C++20에서 표준화된 type_identity의 polyfill.

1
template <typename T>
2
struct type_identity { using type = T; };
3

4
template <typename T>
5
void Print(T value, typename absl::type_identity<T>::type other);
6
// 두 인자가 다른 type이면 첫 인자만 deduction

#is_trivially_*

오래된 컴파일러에서 부정확한 std::is_trivially_*를 컴파일러 builtin으로 직접 구현. 지금은 대부분의 컴파일러가 표준 traits를 정확히 구현하므로 사용 빈도 감소.

#코드 리뷰 포인트

1
// 회피 — &&로 SFINAE 조건을 합침 (C++14)
2
template <typename T>
3
std::enable_if_t<
4
    std::is_integral_v<T> && (sizeof(T) > 4),
5
    void
6
> Process(T t);
7

8
// Good — conjunction
9
template <typename T>
10
std::enable_if_t<
11
    absl::conjunction<
12
        std::is_integral<T>,
13
        std::integral_constant<bool, (sizeof(T) > 4)>
14
    >::value,
15
    void
16
> Process(T t);

1
// 회피 — detection을 매번 손으로
2
template <typename T>
3
auto HasBegin(int) -> decltype(std::declval<T>().begin(), std::true_type{});
4
template <typename T>
5
auto HasBegin(...) -> std::false_type;
6

7
// Good — void_t 패턴
8
template <typename T, typename = void>
9
struct HasBegin : std::false_type {};
10

11
template <typename T>
12
struct HasBegin<T, absl::void_t<decltype(std::declval<T>().begin())>>
13
    : std::true_type {};

리뷰에서:

C++ 표준 버전이 무엇인가 — C++17+이면 std로 옮길 것.
SFINAE에서 &&를 쓰는가 — short-circuit이 필요하면 conjunction.
detection idiom을 재발명하는가 — void_t 패턴 권장.

#자주 보는 안티패턴

1
// 회피 — concept이 있는데도 conjunction 사용 (C++20)
2
template <typename T>
3
requires absl::conjunction<...>::value
4
void Process(T t);
5

6
// Good — concept 직접 사용
7
template <typename T>
8
requires std::integral<T>
9
void Process(T t);

1
// 회피 — type_traits를 macro로 감쌈
2
#define HAS_BEGIN(T) HasBegin<T>::value
3
if constexpr (HAS_BEGIN(MyType)) { ... }
4
// 매크로보다 traits를 직접 쓰는 게 디버깅에 유리.

#정리

absl::conjunction, absl::disjunction은 short-circuit AND/OR. C++17 std::conjunction의 polyfill.
absl::negation은 traits 부정.
absl::void_t는 detection idiom의 핵심. “이 표현식이 valid한가”를 검사.
C++17 이상이면 std로 옮길 것.
C++20 concept이 있으면 traits보다 우선.