std::variant와 union의 차이는?

variant는 타입 안전하고 생성자/소멸자를 호출하지만, union은 타입 불안전하고 수동 관리가 필요합니다.

언제 std::variant를 쓰나요?

타입 안전성이 중요하고, 복잡한 타입을 저장할 때 사용합니다.

std::variant는 어떻게 사용하나요?

std::get, std::get_if, std::visit로 안전하게 접근합니다.

union의 문제점은?

어떤 타입이 활성화되어 있는지 추적해야 하고, 생성자/소멸자가 호출되지 않습니다.

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

Q: 언제 union을 쓰나요?

C 호환이 필요하거나, POD 타입만 저장하고, 성능이 매우 중요할 때 사용합니다.

2026년 3월 28일 · 13분 읽기 · 수정 2026년 3월 28일 중급 비교

이 글의 핵심

C++ std::variant vs union의 C++, std::variant, union, 들어가며: "여러 타입 중 하나를 저장하고 싶어요"를 실전 예제와 함께 상세히 설명합니다.

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

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

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

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

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

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

C/C++ 예제 코드입니다.

// ❌ 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 차이

비교표

항목	union	std::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: 자동 관리

C/C++ 예제 코드입니다.

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

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

3. 방문자 패턴

std::visit: 타입별 처리

C/C++ 예제 코드입니다.

// ✅ 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/C++ 예제 코드입니다.

// ✅ 오버로드 패턴 (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  (최적화 시 동일)

메모리 크기

C/C++ 예제 코드입니다.

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: 에러 처리

isOk 함수의 구현 예제입니다.

// ✅ 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 호환

process_ip 함수의 구현 예제입니다.

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

비트 조작

C/C++ 예제 코드입니다.

// ✅ 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

핵심 규칙

기본: std::variant (타입 안전)
C 호환: union
복잡한 타입: std::variant
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바이트 (예상보다 큼)

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

해결:

C/C++ 예제 코드입니다.

// 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;

문제: 방문자 패턴 복잡도

증상:

C/C++ 예제 코드입니다.

// 복잡한 방문자 코드
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);

해결:

C/C++ 예제 코드입니다.

// 오버로드 패턴 헬퍼
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);

성능 분석 상세

메모리 레이아웃

C/C++ 예제 코드입니다.

// 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. 코드 리뷰 체크포인트

C/C++ 예제 코드입니다.

// 🔍 리뷰 시 확인사항

// 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/C++ 예제 코드입니다.

// 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 타입에 적합합니다.

핵심 원칙:

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

실무 팁:

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

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

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

C++ Union과 Variant |

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ std::variant vs union | ‘타입 안전성’ 완벽 비교」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ std::variant vs union | ‘타입 안전성’ 완벽 비교」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

자주 묻는 질문 (FAQ)

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

A. Everything about C++ std::variant vs union : from basic concepts to practical applications. Master key content quickly w… 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.

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

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

Q. 더 깊이 공부하려면?

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

이 글이 도움이 되셨나요?

여러분의 피드백은 더 나은 콘텐츠를 만드는 데 도움이 됩니다

문제가 있거나 개선 제안이 있으시면 연락처로 알려주세요.

Keyboard Shortcuts

이 글의 핵심

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

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

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

1. std::variant vs union 차이

비교표

union: 타입 불안전

std::variant: 타입 안전

2. 타입 안전성

union: 생성자/소멸자 문제

std::variant: 자동 관리

3. 방문자 패턴

std::visit: 타입별 처리

오버로드 패턴

4. 성능 비교

벤치마크: 저장/접근

메모리 크기

실전 예시

예시 1: JSON 값

예시 2: AST 노드

예시 3: 에러 처리

union 사용 사례

C 호환

비트 조작

정리

std::variant vs union 선택

핵심 규칙

체크리스트

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

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

실전 팁

디버깅 팁

성능 팁

코드 리뷰 팁

자주 하는 실수

실수 1: union에 비POD 타입

실수 2: variant 타입 체크 누락

실수 3: union 타입 추적 누락

실무 트러블슈팅

문제: variant 크기 최적화

문제: 방문자 패턴 복잡도

성능 분석 상세

메모리 레이아웃

접근 성능

베스트 프랙티스

1. variant 타입 설계

2. 방문자 패턴 활용

3. 코드 리뷰 체크포인트

실무 시나리오

시나리오 1: 컴파일러 AST

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

시나리오 3: 설정 값

C++23 개선사항

visit with index

마치며

관련 글

심화 부록: 구현·운영 관점

내부 동작과 핵심 메커니즘

프로덕션 운영 패턴

확장 예시: 엔드투엔드 미니 시나리오

문제 해결(Troubleshooting)

자주 묻는 질문 (FAQ)

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

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

Q. 더 깊이 공부하려면?

이 글이 도움이 되셨나요?