Abseil Code Review · 51/79

absl::variant 분석

2026년 6월 12일 · Hawk · 2분 읽기

#std와의 관계

absl::variant는 absl::optional과 같은 방식으로 C++17 이상에서는 std의 별칭이다.

1
#include "absl/types/variant.h"
2

3
absl::variant<int, std::string, double> v = 42;
4
v = std::string("hello");
5
v = 3.14;

C++14/Abseil-polyfill 시기에 작성된 코드도 그대로 동작한다.

#기본 사용

1
absl::variant<int, std::string> v = 10;
2

3
// 현재 들어 있는 인덱스
4
size_t i = v.index();   // 0
5

6
// 타입 검사
7
if (absl::holds_alternative<int>(v)) {
8
    int x = absl::get<int>(v);
9
}
10

11
// 인덱스 기반
12
double d = absl::get<0>(v);   // ❌ 타입 안 맞음 — bad_variant_access
13

14
// 안전 getter
15
if (const int* p = absl::get_if<int>(&v)) {
16
    use(*p);
17
}

#Visitor 패턴

여러 타입을 한 번에 처리하려면 visitor.

1
absl::variant<int, std::string, double> v = ...;
2

3
std::string s = absl::visit([](const auto& val) -> std::string {
4
    if constexpr (std::is_same_v<std::decay_t<decltype(val)>, int>) {
5
        return absl::StrCat("int=", val);
6
    } else if constexpr (std::is_same_v<std::decay_t<decltype(val)>, std::string>) {
7
        return absl::StrCat("str=", val);
8
    } else {
9
        return absl::StrCat("dbl=", val);
10
    }
11
}, v);

C++17 if constexpr + lambda 조합이 표준 visitor 작성법이다. 더 깔끔하게는 overloaded 패턴:

1
template <typename... Ts>
2
struct overloaded : Ts... { using Ts::operator()...; };
3
template <typename... Ts> overloaded(Ts...) -> overloaded<Ts...>;
4

5
absl::variant<int, std::string, double> v = ...;
6
std::string s = absl::visit(overloaded{
7
    [](int n)              { return absl::StrCat("int=", n); },
8
    [](const std::string& s){ return absl::StrCat("str=", s); },
9
    [](double d)           { return absl::StrCat("dbl=", d); },
10
}, v);

가독성이 크게 좋다.

#언제 variant를 쓰나

여러 동등한 의미의 타입이 한 슬롯에 들어갈 때.

1
// API 응답 — 성공 or 에러 메시지 or rate-limited
2
absl::variant<Response, ApiError, RateLimited> result = Call();
3

4
// 토큰 — 숫자, 식별자, 문자열 리터럴
5
absl::variant<int64_t, std::string, double> Token;
6

7
// 이벤트 — 각각 다른 페이로드
8
struct ClickEvent { int x, y; };
9
struct KeyEvent { int code; };
10
struct ScrollEvent { double delta; };
11
absl::variant<ClickEvent, KeyEvent, ScrollEvent> Event;

상속 + virtual 함수 대안으로 closed set에 적합. 새 타입을 추가할 때 모든 visitor가 컴파일 에러로 알려준다(빠진 case 발견).

#monostate — 비어 있는 상태

variant는 기본 생성 시 첫 번째 타입의 기본값을 가진다. “비어 있음” 상태가 필요하면 monostate를 첫 번째로.

1
absl::variant<absl::monostate, Request, Response> conn;
2
// 기본 — monostate (아직 어떤 메시지도 안 옴)

#get vs get_if

1
absl::variant<int, std::string> v = "hello";
2

3
// get<T> — 잘못된 타입이면 throw
4
auto s = absl::get<std::string>(v);   // OK
5
auto n = absl::get<int>(v);            // ❌ throw absl::bad_variant_access
6

7
// get_if<T> — 잘못된 타입이면 nullptr
8
if (auto* p = absl::get_if<std::string>(&v)) {
9
    use(*p);
10
}

코드 리뷰에서 get을 무방비로 부르는 것은 흔한 지적이다. 항상 holds_alternative 가드 또는 get_if 사용.

#비교

같은 인덱스의 같은 타입이면 그 타입의 비교. 인덱스가 다르면 인덱스 순서.

1
absl::variant<int, std::string> a = 5;
2
absl::variant<int, std::string> b = std::string("hello");
3

4
a < b;   // true — int(index 0) < string(index 1)

이 의미가 헷갈리므로 변형 비교는 가급적 명시적 visit으로 한다.

#variant의 비용

측면	비용
sizeof	`max(sizeof(Ts)) + index` (정렬 패딩 포함)
접근	tag check + branch — branchless 불가
visit	constexpr-resolved jump table (대부분 분기 한 번)
construct/destroy	활성 타입의 ctor/dtor 호출

union 직접 사용보다 살짝 무겁지만(인덱스 1바이트 + 동적 분기) type safety가 그 비용을 정당화한다.

#회피 패턴

1
// 회피 — variant<int, int> 같은 모호한 alternative
2
absl::variant<int, int> v;   // ❌ 컴파일 에러는 아니지만 의미 불분명
3

4
// Good — 별칭으로 의도 분리
5
struct UserId { int v; };
6
struct OrderId { int v; };
7
absl::variant<UserId, OrderId> v;

1
// 회피 — visitor에 모든 alternative 안 다룸
2
absl::visit(overloaded{
3
    [](int n) { /* ... */ },
4
    // string은? — overload mismatch → 컴파일 에러로 잡힘 (good!)
5
}, v);

overloaded 패턴의 장점이 여기서 드러난다. 새 alternative를 추가하면 컴파일이 깨져서 모든 호출 지점에서 처리하게 강제한다.

#작은 예시 — 토큰화 결과

1
struct Number { double value; };
2
struct Identifier { std::string name; };
3
struct StringLit { std::string text; };
4
struct Punct { char ch; };
5

6
using Token = absl::variant<Number, Identifier, StringLit, Punct>;
7

8
std::string Print(const Token& t) {
9
    return absl::visit(overloaded{
10
        [](const Number& n)    { return absl::StrCat("NUM(", n.value, ")"); },
11
        [](const Identifier& i){ return absl::StrCat("ID(", i.name, ")"); },
12
        [](const StringLit& s) { return absl::StrCat("STR(\"", s.text, "\")"); },
13
        [](const Punct& p)     { return absl::StrCat("'", std::string(1, p.ch), "'"); },
14
    }, t);
15
}