C++ std::variant vs union | "타입 안전성" 완벽 비교

· 13분 읽기 · 수정 중급 비교
C++ std::variant vs union | "타입 안전성" 완벽 비교

이 글의 핵심

C++ std::variant vs union에 대한 실전 가이드입니다.

들어가며: “여러 타입 중 하나를 저장하고 싶어요"

"union을 쓰면 타입 안전성이 없어요”

C++에서 여러 타입 중 하나를 저장하려면 union이나 std::variant(C++17)를 사용합니다. variant는 타입 안전하지만, union은 수동 관리가 필요합니다.

비유로 말씀드리면, union은 여러 형태의 물건을 같은 서랍 칸에 억지로 넣는 것이고, variant는 “지금은 이 타입”이라는 꼬리표가 붙은 서랍입니다. 꼬리표 없이 꺼내면 엉뚱한 타입으로 읽는 미정의 동작이 생길 수 있습니다.

언제 std::variant를, 언제 union을 쓰나요?

관점std::variantunion
성능안전한 접근에 약간의 비용POD·C 레이아웃에 맞출 때 최소
사용성visit, get_if로 활성 타입 추적활성 멤버를 직접 기억해야 함
적용 시나리오현대 C++ 도메인 모델FFI·비트 패킹·레거시
// ❌ union: 타입 불안전
union Data {
    int i;
    double d;
    char c;
};

Data data;
data.i = 42;
std::cout << data.d << '\n';  // ❌ 미정의 동작 (int를 double로 읽음)

// ✅ std::variant: 타입 안전
std::variant<int, double, char> data;
data = 42;  // int 저장
// std::cout << std::get<double>(data) << '\n';  // ❌ 예외 던짐
std::cout << std::get<int>(data) << '\n';  // ✅ 42

이 글에서 다루는 것:

  • std::variant vs union 차이
  • 타입 안전성
  • 방문자 패턴
  • 실전 선택 가이드

목차

  1. std::variant vs union 차이
  2. 타입 안전성
  3. 방문자 패턴
  4. 성능 비교
  5. 정리

1. std::variant vs union 차이

비교표

항목unionstd::variant
타입 안전성❌ 없음✅ 있음
생성자/소멸자❌ 호출 안 됨✅ 호출됨
활성 타입 추적수동자동
복잡한 타입❌ (제한적)✅
방문자 패턴❌✅
C 호환✅❌
메모리최대 크기최대 크기 + 인덱스
C++ 버전모든 버전C++17 이후

union: 타입 불안전

// ❌ union: 수동 타입 추적
enum class DataType {
    INT, DOUBLE, STRING
};

struct Data {
    DataType type;
    union {
        int i;
        double d;
        std::string s;  // ❌ 컴파일 에러 (생성자 있음)
    };
};

// POD 타입만 가능
union SimpleData {
    int i;
    double d;
    char c;
};

SimpleData data;
data.i = 42;

// ❌ 어떤 타입인지 모름
std::cout << data.d << '\n';  // 미정의 동작

std::variant: 타입 안전

// ✅ std::variant: 자동 타입 추적
std::variant<int, double, std::string> data;

// 타입 저장
data = 42;                    // int
data = 3.14;                  // double
data = std::string("Hello");  // string

// 안전한 접근
if (std::holds_alternative<int>(data)) {
    std::cout << std::get<int>(data) << '\n';
}

// 예외로 타입 체크
try {
    std::cout << std::get<double>(data) << '\n';
} catch (const std::bad_variant_access& e) {
    std::cout << "잘못된 타입: " << e.what() << '\n';
}

// get_if: nullptr 반환
if (auto* ptr = std::get_if<std::string>(&data)) {
    std::cout << *ptr << '\n';  // "Hello"
}

2. 타입 안전성

union: 생성자/소멸자 문제

// ❌ union: 생성자/소멸자 호출 안 됨
union Data {
    int i;
    std::string s;  // ❌ 컴파일 에러
};
// error: union member 'std::string s' with non-trivial constructor

// 해결책: placement new + 수동 소멸자
union Data {
    int i;
    char s[sizeof(std::string)];  // 원시 메모리
};

enum class Type { INT, STRING };

struct SafeData {
    Type type;
    Data data;
    
    SafeData(int value) : type(Type::INT) {
        data.i = value;
    }
    
    SafeData(const std::string& value) : type(Type::STRING) {
        new (data.s) std::string(value);  // placement new
    }
    
    ~SafeData() {
        if (type == Type::STRING) {
            reinterpret_cast<std::string*>(data.s)->~std::string();  // 수동 소멸
        }
    }
    
    // 복사/이동 생성자도 구현 필요...
};

std::variant: 자동 관리

// ✅ std::variant: 자동 생성자/소멸자
std::variant<int, std::string> data;

data = 42;  // int 생성
data = std::string("Hello");  // int 소멸 → string 생성
// data 소멸 시 자동으로 string 소멸자 호출

3. 방문자 패턴

std::visit: 타입별 처리

// ✅ std::visit: 방문자 패턴
std::variant<int, double, std::string> data = 42;

// 방문자 함수
std::visit( {
    using T = std::decay_t<decltype(arg)>;
    
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg << '\n';
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << arg << '\n';
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "string: " << arg << '\n';
    }
}, data);

// 출력: int: 42

오버로드 패턴

// ✅ 오버로드 패턴 (C++17)
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

std::variant<int, double, std::string> data = 3.14;

std::visit(overloaded{
     { std::cout << "int: " << arg << '\n'; },
     { std::cout << "double: " << arg << '\n'; },
     { std::cout << "string: " << arg << '\n'; }
}, data);

// 출력: double: 3.14

4. 성능 비교

벤치마크: 저장/접근

#include <benchmark/benchmark.h>
#include <variant>

// union
static void BM_Union(benchmark::State& state) {
    union Data {
        int i;
        double d;
    };
    
    for (auto _ : state) {
        Data data;
        data.i = 42;
        int x = data.i;
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_Union);

// std::variant
static void BM_Variant(benchmark::State& state) {
    for (auto _ : state) {
        std::variant<int, double> data;
        data = 42;
        int x = std::get<int>(data);
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_Variant);

결과 (GCC 13, -O3):

BM_Union      1 ns
BM_Variant    1 ns  (최적화 시 동일)

메모리 크기

union Data {
    int i;      // 4바이트
    double d;   // 8바이트
    char c;     // 1바이트
};

std::cout << sizeof(Data) << '\n';  // 8 (최대 크기)

std::variant<int, double, char> data;
std::cout << sizeof(data) << '\n';  // 16 (최대 크기 8 + 인덱스 + 패딩)

실전 예시

예시 1: JSON 값

// ✅ std::variant: JSON 값
using JsonValue = std::variant<
    std::nullptr_t,
    bool,
    int64_t,
    double,
    std::string,
    std::vector<JsonValue>,
    std::map<std::string, JsonValue>
>;

class Json {
    JsonValue value_;
    
public:
    Json() : value_(nullptr) {}
    Json(bool v) : value_(v) {}
    Json(int v) : value_(static_cast<int64_t>(v)) {}
    Json(double v) : value_(v) {}
    Json(const std::string& v) : value_(v) {}
    
    template <typename T>
    T get() const {
        return std::get<T>(value_);
    }
    
    void print() const {
        std::visit(overloaded{
             { std::cout << "null"; },
             { std::cout << (v ? "true" : "false"); },
             { std::cout << v; },
             { std::cout << v; },
             { std::cout << "\"" << v << "\""; },
             { std::cout << "[complex]"; }
        }, value_);
    }
};

int main() {
    Json j1 = 42;
    Json j2 = 3.14;
    Json j3 = std::string("Hello");
    
    j1.print();  // 42
    std::cout << '\n';
    j2.print();  // 3.14
    std::cout << '\n';
    j3.print();  // "Hello"
    std::cout << '\n';
}

예시 2: AST 노드

// ✅ std::variant: AST 노드
struct NumberNode {
    double value;
};

struct StringNode {
    std::string value;
};

struct BinaryOpNode {
    char op;
    std::unique_ptr<AstNode> left;
    std::unique_ptr<AstNode> right;
};

using AstNode = std::variant<NumberNode, StringNode, BinaryOpNode>;

double evaluate(const AstNode& node) {
    return std::visit(overloaded{
         { return n.value; },
         { return static_cast<double>(s.value.size()); },
         {
            double left = evaluate(*op.left);
            double right = evaluate(*op.right);
            switch (op.op) {
                case '+': return left + right;
                case '-': return left - right;
                case '*': return left * right;
                case '/': return left / right;
                default: return 0.0;
            }
        }
    }, node);
}

예시 3: 에러 처리

// ✅ std::variant: Result 타입
template <typename T, typename E>
class Result {
    std::variant<T, E> value_;
    
public:
    Result(T value) : value_(std::move(value)) {}
    Result(E error) : value_(std::move(error)) {}
    
    bool isOk() const {
        return std::holds_alternative<T>(value_);
    }
    
    bool isErr() const {
        return std::holds_alternative<E>(value_);
    }
    
    T& value() {
        return std::get<T>(value_);
    }
    
    E& error() {
        return std::get<E>(value_);
    }
    
    T valueOr(T defaultValue) const {
        if (isOk()) {
            return std::get<T>(value_);
        }
        return defaultValue;
    }
};

Result<int, std::string> divide(int a, int b) {
    if (b == 0) {
        return std::string("0으로 나눌 수 없음");
    }
    return a / b;
}

int main() {
    auto result1 = divide(10, 2);
    if (result1.isOk()) {
        std::cout << "결과: " << result1.value() << '\n';  // 5
    }
    
    auto result2 = divide(10, 0);
    if (result2.isErr()) {
        std::cout << "에러: " << result2.error() << '\n';  // 0으로 나눌 수 없음
    }
}

union 사용 사례

C 호환

// ✅ union: C 호환
extern "C" {
    union IpAddress {
        uint32_t ipv4;
        uint8_t ipv6[16];
    };
    
    void process_ip(IpAddress addr, bool isIpv6);
}

비트 조작

// ✅ union: 비트 조작
union FloatBits {
    float f;
    uint32_t bits;
};

FloatBits fb;
fb.f = 3.14f;
std::cout << "비트: " << std::hex << fb.bits << '\n';

정리

std::variant vs union 선택

상황사용
타입 안전성std::variant
복잡한 타입std::variant
생성자/소멸자std::variant
방문자 패턴std::variant
C 호환union
POD 타입만union
비트 조작union

핵심 규칙

  1. 기본: std::variant (타입 안전)
  2. C 호환: union
  3. 복잡한 타입: std::variant
  4. POD만: union

체크리스트

  • 타입 안전성이 필요한가?
  • 복잡한 타입을 저장하는가?
  • C 호환이 필요한가?
  • 방문자 패턴을 사용하는가?

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

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

  • C++ std::variant 기초 | 완벽 가이드
  • C++ union 기초 | Union 가이드
  • C++ 방문자 패턴 | Visitor Pattern
  • C++ std::optional | null 처리

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

std::variant, union, variant vs union, 타입 안전성, 방문자 패턴 등으로 검색하시면 이 글이 도움이 됩니다.

실전 팁

실무에서 바로 적용할 수 있는 팁입니다.

디버깅 팁

  • std::variant는 index()로 활성 타입을 확인하세요
  • union은 수동으로 타입을 추적해야 합니다
  • std::visit로 모든 타입을 처리하세요

성능 팁

  • 최적화 시 성능 차이는 거의 없습니다
  • std::variant는 약간의 메모리 오버헤드가 있습니다
  • union은 POD 타입만 사용하세요

코드 리뷰 팁

  • union을 std::variant로 바꾸세요 (타입 안전성)
  • C 호환이 필요한 경우만 union을 사용하세요
  • 복잡한 타입은 std::variant를 사용하세요

자주 하는 실수

실수 1: union에 비POD 타입

// ❌ 실수: 생성자 있는 타입
union Data {
    int i;
    std::string s;  // 컴파일 에러
};
// error: union member 'std::string s' with non-trivial constructor

// ✅ std::variant 사용
std::variant<int, std::string> data;
data = 42;
data = std::string("Hello");

실수 2: variant 타입 체크 누락

// ❌ 실수: 타입 체크 없음
std::variant<int, double, std::string> data = 42;
auto value = std::get<double>(data);  // ❌ 예외 던짐

// ✅ 타입 체크
if (std::holds_alternative<int>(data)) {
    auto value = std::get<int>(data);
}

// ✅ get_if 사용
if (auto* ptr = std::get_if<int>(&data)) {
    std::cout << *ptr << '\n';
}

실수 3: union 타입 추적 누락

// ❌ 실수: 타입 추적 없음
union Data {
    int i;
    double d;
};

Data data;
data.i = 42;
std::cout << data.d << '\n';  // ❌ 미정의 동작

// ✅ 타입 추적
enum class Type { INT, DOUBLE };
struct TaggedData {
    Type type;
    union {
        int i;
        double d;
    };
};

실무 트러블슈팅

문제: variant 크기 최적화

증상:

std::variant<char, int, std::string> data;
std::cout << sizeof(data) << '\n';  // 40바이트 (예상보다 큼)

원인: 가장 큰 타입 + 인덱스 + 패딩

해결:

// 1. 작은 타입만 사용
std::variant<char, short, int> data;  // 8바이트

// 2. 포인터 사용
std::variant<char, int, std::string*> data;  // 16바이트

// 3. 타입 재설계
using SmallString = std::array<char, 16>;
std::variant<char, int, SmallString> data;

문제: 방문자 패턴 복잡도

증상:

// 복잡한 방문자 코드
std::visit( {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>) { /* ... */ }
    else if constexpr (std::is_same_v<T, double>) { /* ... */ }
    // ...
}, data);

해결:

// 오버로드 패턴 헬퍼
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

std::visit(overloaded{
     { std::cout << "int: " << arg << '\n'; },
     { std::cout << "double: " << arg << '\n'; },
     { std::cout << "string: " << arg << '\n'; }
}, data);

성능 분석 상세

메모리 레이아웃

// union: 최대 크기
union Data {
    char c;     // 1바이트
    int i;      // 4바이트
    double d;   // 8바이트
};
sizeof(Data);  // 8바이트 (최대 크기)

// std::variant: 최대 크기 + 인덱스
std::variant<char, int, double> data;
sizeof(data);  // 16바이트 (8 + 인덱스 + 패딩)

// 메모리 레이아웃
// [데이터 8바이트][인덱스 1바이트][패딩 7바이트]

접근 성능

// 벤치마크: 1백만 번 접근
// union (직접 접근): 1ns
// variant (std::get): 1ns (최적화 시 동일)
// variant (std::visit): 2ns (간접 호출)

베스트 프랙티스

1. variant 타입 설계

// ✅ 명확한 타입 이름
using JsonValue = std::variant<
    std::nullptr_t,
    bool,
    int64_t,
    double,
    std::string,
    std::vector<JsonValue>,
    std::map<std::string, JsonValue>
>;

// ✅ 작은 타입 우선
std::variant<int, double, std::string>;  // int가 가장 작음

// ❌ 중복 타입
std::variant<int, int>;  // 컴파일 에러

2. 방문자 패턴 활용

// ✅ 타입별 처리
template <typename... Ts>
struct Visitor : Ts... { using Ts::operator()...; };

template <typename... Ts>
Visitor(Ts...) -> Visitor<Ts...>;

// 사용
std::variant<int, double, std::string> data = 42;

std::visit(Visitor{
     { std::cout << "정수: " << x << '\n'; },
     { std::cout << "실수: " << x << '\n'; },
     { std::cout << "문자열: " << x << '\n'; }
}, data);

3. 코드 리뷰 체크포인트

// 🔍 리뷰 시 확인사항

// 1. union 타입 추적
union Data { int i; double d; };  // ⚠️ 타입 추적?

// 2. variant 타입 체크
std::get<int>(data);  // ⚠️ 예외 처리?

// 3. 생성자/소멸자
union Data { std::string s; };  // ⚠️ 컴파일 에러

// 4. C 호환
union IpAddr { /* ... */ };  // ✅ C 호환 필요?

실무 시나리오

시나리오 1: 컴파일러 AST

// ✅ 실무 예시: AST 노드
struct BinaryOp;
struct UnaryOp;
struct Literal;
struct Variable;

using Expr = std::variant<
    Literal,
    Variable,
    std::unique_ptr<BinaryOp>,
    std::unique_ptr<UnaryOp>
>;

struct BinaryOp {
    char op;  // '+', '-', '*', '/'
    Expr left;
    Expr right;
};

struct Literal {
    double value;
};

// 평가
double evaluate(const Expr& expr) {
    return std::visit(overloaded{
         { return lit.value; },
         { return lookupVariable(var); },
         {
            double left = evaluate(op->left);
            double right = evaluate(op->right);
            switch (op->op) {
                case '+': return left + right;
                case '-': return left - right;
                case '*': return left * right;
                case '/': return left / right;
            }
            return 0.0;
        },
         {
            return -evaluate(op->operand);
        }
    }, expr);
}

시나리오 2: 프로토콜 메시지

// ✅ 실무 예시: 네트워크 메시지
struct LoginMessage {
    std::string username;
    std::string password;
};

struct ChatMessage {
    std::string sender;
    std::string content;
};

struct FileTransfer {
    std::string filename;
    std::vector<uint8_t> data;
};

using Message = std::variant<
    LoginMessage,
    ChatMessage,
    FileTransfer
>;

class MessageHandler {
public:
    void handle(const Message& msg) {
        std::visit(overloaded{
            [this](const LoginMessage& m) { handleLogin(m); },
            [this](const ChatMessage& m) { handleChat(m); },
            [this](const FileTransfer& m) { handleFile(m); }
        }, msg);
    }
    
private:
    void handleLogin(const LoginMessage& msg) {
        std::cout << "로그인: " << msg.username << '\n';
    }
    
    void handleChat(const ChatMessage& msg) {
        std::cout << msg.sender << ": " << msg.content << '\n';
    }
    
    void handleFile(const FileTransfer& msg) {
        std::cout << "파일 수신: " << msg.filename 
                  << " (" << msg.data.size() << " 바이트)\n";
    }
};

시나리오 3: 설정 값

// ✅ 실무 예시: 설정 시스템
using ConfigValue = std::variant<
    bool,
    int,
    double,
    std::string,
    std::vector<std::string>
>;

class Config {
    std::map<std::string, ConfigValue> values_;
    
public:
    void set(const std::string& key, ConfigValue value) {
        values_[key] = value;
    }
    
    template <typename T>
    std::optional<T> get(const std::string& key) const {
        auto it = values_.find(key);
        if (it != values_.end()) {
            if (auto* ptr = std::get_if<T>(&it->second)) {
                return *ptr;
            }
        }
        return std::nullopt;
    }
    
    std::string toString(const std::string& key) const {
        auto it = values_.find(key);
        if (it == values_.end()) {
            return "";
        }
        
        return std::visit(overloaded{
             { return v ? "true" : "false"; },
             { return std::to_string(v); },
             { return std::to_string(v); },
             { return v; },
             {
                std::string result = "[";
                for (size_t i = 0; i < v.size(); ++i) {
                    if (i > 0) result += ", ";
                    result += v[i];
                }
                result += "]";
                return result;
            }
        }, it->second);
    }
};

// 사용
Config config;
config.set("port", 8080);
config.set("host", std::string("localhost"));
config.set("debug", true);
config.set("allowed_origins", std::vector<std::string>{"*"});

auto port = config.get<int>("port");  // std::optional<int>
std::cout << config.toString("allowed_origins") << '\n';  // [*]

C++23 개선사항

visit with index

// C++23: visit with index
std::variant<int, double, std::string> data = 42;

std::visit( {
    std::cout << "인덱스: " << index << ", 값: " << arg << '\n';
}, data);

마치며

std::variant는 타입 안전하고 사용하기 쉽지만, union은 C 호환과 POD 타입에 적합합니다.

핵심 원칙:

  1. 기본: std::variant
  2. C 호환: union
  3. 타입 안전성 우선

실무 팁:

  • AST, 프로토콜 메시지, 설정 값에 활용
  • 오버로드 패턴으로 방문자 간소화
  • 타입 체크는 get_if 사용

타입 안전성이 중요하면 std::variant를 사용하세요.

다음 단계: std::variant를 이해했다면, C++ std::any 가이드에서 더 깊이 배워보세요.

관련 글

  • C++ Union과 Variant |