pkglog

C++ std::optional vs 포인터: 값이 없을 수 있는 반환값을 어떻게 표현할까

작성 · · 17분 읽기 · 수정 중급 비교

이 글의 핵심

optional은 힙 할당 없이 값과 존재 여부를 함께 담지만, 참조를 담을 수 없고 비어 있을 때 value()를 부르면 예외가 납니다. 설정 파일 파싱, 검색 함수, 캐시 예제로 쓰임새를 보고, optional 남용이나 optional 체인이 길어지는 문제 같은 실수를 해결법과 함께 짚습니다.

“값이 없음”을 표현하는 두 가지 방법

C++에서 “값이 없음”을 표현하는 방법은 여러 가지인데, 가장 흔한 두 가지가 포인터의 nullptr과 C++17의 std::optional입니다. optional은 값과 “있음/없음” 표시를 한 객체 안에 함께 담고, 포인터는 다른 곳에 있는 객체를 가리키기만 합니다. 이 차이에서 소유권, 수명, 다형성 지원 여부가 모두 갈립니다.

관점std::optional포인터(또는 스마트 포인터)
성능힙 할당 없이 값 부재를 표현간접 참조, 대상이 흩어져 있으면 캐시 미스
사용성값이 없을 수 있다는 사실이 타입에 드러남nullptr 검사 관례에 의존
적용 상황없을 수 있는 반환값, 지역 상태다형성, 소유하지 않는 참조
// 포인터 방식: 원소의 위치를 돌려준다
const int* findValuePtr(const std::vector<int>& vec, int target) {
    for (const auto& val : vec) {
        if (val == target) {
            return &val;  // vec이 수정·파괴되면 댕글링
        }
    }
    return nullptr;
}

// optional 방식 (C++17): 원소의 값을 복사해 돌려준다
std::optional<int> findValueOpt(const std::vector<int>& vec, int target) {
    for (auto val : vec) {
        if (val == target) {
            return val;
        }
    }
    return std::nullopt;  // 값 없음
}

C++은 반환 타입만 다른 오버로드를 허용하지 않으므로 두 함수의 이름을 다르게 붙였습니다. 두 함수는 계약이 다릅니다. 포인터 버전은 원소의 위치를 돌려주므로 호출자가 그 원소를 직접 읽을 수 있지만, 반환된 포인터는 vec이 살아 있고 재할당되지 않는 동안만 유효합니다. 호출 후 vec.push_back()을 한 번만 해도 용량이 바뀌면 포인터는 해제된 메모리를 가리킵니다. optional 버전은 값을 복사해서 돌려주므로 원본의 수명과 무관하게 안전한 대신, 원소를 수정할 수 없고 큰 타입이면 복사 비용이 듭니다. 즉 “optional이 무조건 안전하다”가 아니라, 값이 필요하면 optional, 위치(원본 접근)가 필요하면 포인터나 반복자라는 기준으로 고르는 것이 맞습니다.

저장 위치와 소유권으로 본 차이

항목std::optionalT*
저장 위치선언된 곳에 값이 직접 들어감 (힙 할당 없음)포인터 자체는 선언된 곳, 대상은 어디든 (스택·힙·정적)
소유권소유참조
null 표현std::nulloptnullptr
값 접근value(), *, ->*, ->
검사되는 접근value()만 (빈 경우 예외)없음
메모리 할당없음대상이 동적 할당된 경우 있음
크기대략 sizeof(T) + 정렬 단위 (bool 플래그 + 패딩)sizeof(void*)
C++ 버전C++17모든 버전

optional이 포인터보다 “타입 안전하다”는 말은 과장하면 안 됩니다. optional도 *opt나 opt->로 접근하면 비어 있어도 검사하지 않으며, 이는 null 포인터 역참조와 똑같은 미정의 동작입니다. 검사가 붙는 것은 value()(빈 경우 std::bad_optional_access 예외)뿐입니다. optional이 주는 진짜 이득은 함수 시그니처만 보고 “없을 수 있다”는 사실을 알 수 있다는 점과, 포인터처럼 “이 포인터를 내가 delete해야 하나?” 같은 소유권 질문이 아예 생기지 않는다는 점입니다.

기본 사용법 비교

// std::optional
std::optional<int> opt1;  // 값 없음
std::optional<int> opt2 = 42;  // 값 있음
std::optional<int> opt3 = std::nullopt;  // 값 없음

if (opt2) {
    std::cout << *opt2 << '\n';  // 42
}

// 포인터
int* ptr1 = nullptr;  // null
int value = 42;
int* ptr2 = &value;  // 값 가리킴

if (ptr2 != nullptr) {
    std::cout << *ptr2 << '\n';  // 42
}

비어 있는 값에 접근할 때

optional: 확인용 인터페이스가 타입에 붙어 있다

#include <iostream>
std::optional<int> getValue(bool success) {
    if (success) {
        return 42;
    }
    return std::nullopt;
}

int main() {
    auto result = getValue(false);

    // has_value()로 확인
    if (result.has_value()) {
        std::cout << result.value() << '\n';
    }

    // value_or()로 기본값
    std::cout << result.value_or(0) << '\n';  // 0

    // 비어 있을 때 value()는 예외를 던진다
    try {
        std::cout << result.value() << '\n';
    } catch (const std::bad_optional_access& e) {
        std::cout << "값 없음: " << e.what() << '\n';
    }
}

컴파일러가 확인을 강제하지는 않지만, value_or나 value()처럼 빈 경우를 다루는 방법이 타입에 붙어 있어서 호출자가 처리 방식을 고르게 됩니다.

포인터: nullptr 역참조가 런타임까지 숨는다

#include <iostream>
int* getValue(bool success) {
    if (success) {
        static int value = 42;
        return &value;
    }
    return nullptr;
}

int main() {
    int* result = getValue(false);

    // nullptr 검사 없이 접근하면 미정의 동작 (보통 크래시)
    // std::cout << *result << '\n';

    if (result != nullptr) {
        std::cout << *result << '\n';
    }
}

메모리 레이아웃·벤치마크·캐시 효율

메모리 레이아웃

struct Data {
    int x, y, z;
};

std::optional<Data> opt;
// sizeof(Data) == 12, 플래그 1바이트 → 패딩 포함 보통 16바이트
// opt가 지역 변수면 스택에, 멤버면 바깥 객체 안에 놓인다

Data* ptr = new Data{1, 2, 3};
// 포인터 8바이트(64비트) + 힙의 12바이트 + 할당자 관리 오버헤드

벤치마크

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

// optional
static void BM_Optional(benchmark::State& state) {
    for (auto _ : state) {
        std::optional<int> opt = 42;
        int x = opt.value_or(0);
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_Optional);

// 포인터 (스택)
static void BM_PointerStack(benchmark::State& state) {
    for (auto _ : state) {
        int value = 42;
        int* ptr = &value;
        int x = (ptr != nullptr) ? *ptr : 0;
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_PointerStack);

// 포인터 (힙)
static void BM_PointerHeap(benchmark::State& state) {
    for (auto _ : state) {
        int* ptr = new int(42);
        int x = (ptr != nullptr) ? *ptr : 0;
        delete ptr;
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_PointerHeap);

이 벤치마크는 결과 해석에 주의가 필요합니다. -O2 이상에서 BM_Optional과 BM_PointerStack은 컴파일러가 상수 42로 접어 버려 사실상 빈 루프를 재는 것이 되고, 둘의 차이는 측정 오차 수준이 됩니다. 의미 있는 차이가 날 수 있는 것은 BM_PointerHeap뿐이며, 이것은 “포인터가 느리다”가 아니라 new/delete 한 쌍의 비용입니다. 컴파일러에 따라 이 할당마저 제거될 수 있으니 생성된 어셈블리를 함께 확인해야 합니다. 결국 optional과 포인터의 성능 차이는 접근 방식이 아니라 힙 할당을 하느냐, 그리고 데이터가 메모리에 연속으로 놓이느냐에서 결정됩니다.

캐시 효율성

// optional: 값이 vector 버퍼 안에 연속으로 놓인다
std::vector<std::optional<int>> values(1000);

// 포인터: 포인터들은 연속이지만, 가리키는 데이터는 흩어질 수 있다
std::vector<int*> pointers(1000);

optional<int>는 보통 8바이트라 int 배열보다 두 배 크지만, 순회할 때 다른 메모리를 따라가지 않습니다. 포인터 배열은 각 대상이 따로 할당되어 있으면 순회할 때마다 다른 캐시 라인을 읽게 됩니다.

optional이 맞는 곳과 포인터가 맞는 곳

없을 수 있는 반환값: optional

#include <iostream>
#include <string>
std::optional<std::string> getEnv(const char* name) {
    const char* value = std::getenv(name);
    if (value != nullptr) {
        return std::string(value);
    }
    return std::nullopt;
}

int main() {
    auto path = getEnv("PATH");
    if (path) {
        std::cout << "PATH: " << *path << '\n';
    } else {
        std::cout << "PATH 없음\n";
    }
}

선택적 매개변수: optional

#include <iostream>
#include <string>
void connect(const std::string& host,
             std::optional<int> port = std::nullopt) {
    int actualPort = port.value_or(80);  // 기본값 80
    std::cout << "연결: " << host << ":" << actualPort << '\n';
}

int main() {
    connect("example.com");        // 포트 80
    connect("example.com", 443);   // 포트 443
}

선택적 매개변수에 optional을 쓰면 “기본값 80”을 함수 안에 숨길 수 있지만, 단순히 기본값만 필요하다면 int port = 80이라는 기본 인자가 더 간단합니다. optional이 의미를 갖는 것은 “호출자가 지정하지 않았음”과 “호출자가 특정 값을 지정했음”을 구분해야 할 때입니다. 예를 들어 설정 파일에 값이 없으면 환경 변수를 보고, 그래도 없으면 기본값을 쓰는 식의 우선순위 로직입니다. 또 std::optional<std::string>을 값으로 받으면 호출할 때마다 문자열이 복사되므로, 큰 타입은 const T*(없으면 nullptr)가 복사 없이 같은 의미를 전달하기도 합니다. const std::optional<T>& 매개변수는 호출자가 T를 넘길 때 임시 optional을 만들면서 결국 복사가 일어나므로 이 문제를 해결하지 못합니다.

초기화 지연: optional

class Database {
    std::optional<Connection> conn_;

public:
    void connect(const std::string& host) {
        conn_.emplace(host);  // 필요할 때 optional 안에서 바로 생성
    }

    void query(const std::string& sql) {
        if (!conn_) {
            throw std::runtime_error("연결 안 됨");
        }
        conn_->execute(sql);
    }
};

conn_ = Connection(host);처럼 대입하면 임시 객체를 만든 뒤 이동합니다. Connection이 이동 불가능한 타입(뮤텍스를 직접 멤버로 들고 있는 경우 등)이면 컴파일되지 않으므로 위 코드처럼 emplace로 optional 안에서 바로 생성하는 편이 안전합니다. emplace는 이미 값이 있으면 기존 객체를 먼저 파괴하고 새로 만든다는 점도 기억해 두세요.

다형성: 포인터(또는 참조)

#include <iostream>
class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Circle\n";
    }
};

void render(Shape* shape) {  // nullptr 허용
    if (shape != nullptr) {
        shape->draw();
    }
}

int main() {
    Circle circle;
    render(&circle);
}

render(Shape*)에서 포인터를 쓰는 진짜 이유는 다형성이 아니라 nullptr을 허용하기 위해서입니다. 가상 함수 호출은 참조(Shape&)로도 똑같이 동작하므로, 인자가 항상 있어야 한다면 void render(Shape& shape)가 더 정확한 시그니처입니다. optional이 다형성에 쓰일 수 없는 이유는 std::optional<Shape>가 Shape 크기만큼의 저장 공간만 갖기 때문입니다. Circle을 넣으면 파생 부분이 잘리는 객체 슬라이싱이 일어나고, 이 예제처럼 Shape가 추상 클래스라면 아예 컴파일되지 않습니다.

복사하기 큰 객체 참조: 포인터

#include <memory>
struct BigData {
    int data[1000000];  // 약 4MB
};

void process(const BigData* data) {  // 포인터로 전달 (복사 없음)
    if (data != nullptr) {
        // 처리
    }
}

int main() {
    auto data = std::make_unique<BigData>();  // 4MB를 스택에 두지 않는다
    process(data.get());
}

4MB짜리 객체를 BigData data;처럼 지역 변수로 만들면 Windows의 기본 스택(1MB)을 넘어 바로 스택 오버플로가 나므로 힙에 할당했습니다. 인자가 반드시 있어야 한다면 const BigData&가 더 정확하고, “없을 수도 있음”까지 표현해야 할 때 포인터가 맞습니다.

설정·검색·캐시·DB·HTTP에 적용하기

설정 클래스의 선택 필드

#include <iostream>
#include <string>
#include <map>
class Config {
    std::map<std::string, std::string> values_;

public:
    std::optional<int> getInt(const std::string& key) const {
        auto it = values_.find(key);
        if (it != values_.end()) {
            try {
                return std::stoi(it->second);
            } catch (...) {
                return std::nullopt;
            }
        }
        return std::nullopt;
    }

    std::optional<std::string> getString(const std::string& key) const {
        auto it = values_.find(key);
        if (it != values_.end()) {
            return it->second;
        }
        return std::nullopt;
    }
};

int main() {
    Config config;

    auto port = config.getInt("port").value_or(8080);
    auto host = config.getString("host").value_or("localhost");

    std::cout << "서버: " << host << ":" << port << '\n';
}

std::stoi를 catch (...)로 감싸는 방식은 예외를 흐름 제어에 쓰는 셈이라 느리고, "8080abc"처럼 앞부분만 숫자인 문자열도 조용히 8080으로 받아들인다는 함정이 있습니다. C++17의 std::from_chars는 예외 없이 결과 코드와 파싱이 끝난 위치를 돌려주므로, ptr == str.data() + str.size()까지 확인하면 “전체가 정확히 정수인지”를 엄격하게 검사할 수 있어 설정 파싱에 더 잘 맞습니다.

#include <charconv>

std::optional<int> parseInt(std::string_view s) {
    int value{};
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value);
    if (ec != std::errc{} || ptr != s.data() + s.size()) {
        return std::nullopt;
    }
    return value;
}

같은 방식으로 "true"/"false" 문자열을 std::optional<bool>로 바꾸는 함수를 만들면, “키가 없음”과 “값이 잘못됨”을 모두 nullopt로 돌려주고 호출자는 value_or로 기본값을 고를 수 있습니다. 둘을 구분해야 한다면 optional로는 부족하고, 오류 정보를 담을 수 있는 C++23 std::expected가 맞습니다.

찾지 못할 수 있는 검색 함수

#include <iostream>
#include <vector>
template <typename T, typename Pred>
std::optional<T> findIf(const std::vector<T>& vec, Pred predicate) {
    for (const auto& item : vec) {
        if (predicate(item)) {
            return item;
        }
    }
    return std::nullopt;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    auto result = findIf(numbers, [](int x) { return x > 3; });

    if (result) {
        std::cout << "찾음: " << *result << '\n';  // 4
    } else {
        std::cout << "못 찾음\n";
    }
}

조건자 매개변수를 std::function<bool(const T&)>로 선언하면 람다를 넘길 때 템플릿 인자 추론이 실패해 컴파일되지 않습니다. 람다는 std::function이 아니라 고유한 클로저 타입이기 때문입니다. 위처럼 조건자 타입을 별도 템플릿 매개변수로 받으면 추론 문제도 없고 std::function의 타입 소거 비용도 없습니다.

캐시 조회 결과

#include <iostream>
#include <string>
#include <map>
class Cache {
    std::map<std::string, std::string> data_;

public:
    std::optional<std::string> get(const std::string& key) const {
        auto it = data_.find(key);
        if (it != data_.end()) {
            return it->second;
        }
        return std::nullopt;
    }

    void set(const std::string& key, const std::string& value) {
        data_[key] = value;
    }
};

int main() {
    Cache cache;
    cache.set("user:1", "Alice");

    auto user = cache.get("user:1");
    if (user) {
        std::cout << "사용자: " << *user << '\n';
    }

    auto missing = cache.get("user:2");
    std::cout << "사용자: " << missing.value_or("없음") << '\n';
}

get이 std::optional<std::string>을 돌려주므로 조회할 때마다 문자열이 복사됩니다. 값이 크고 조회가 잦다면 const std::string*를 돌려주는 방식도 고려할 수 있는데, 이때는 다음 set이 같은 키를 덮어쓰기 전까지만 포인터가 유효하다는 계약을 문서로 남겨야 합니다.

데이터베이스 단건 조회

class UserRepository {
public:
    std::optional<User> findById(int id) {
        auto result = db_.query("SELECT * FROM users WHERE id = ?", id);
        if (result.empty()) {
            return std::nullopt;
        }
        return User::fromRow(result[0]);
    }

    std::vector<User> findAll() {
        // 여러 건 조회는 빈 벡터가 곧 "없음"이므로 optional이 필요 없다
        auto results = db_.query("SELECT * FROM users");
        std::vector<User> users;
        for (auto& row : results) {
            users.push_back(User::fromRow(row));
        }
        return users;
    }
};

// 사용
auto user = repo.findById(123);
if (user) {
    std::cout << "사용자: " << user->name << '\n';
} else {
    std::cout << "사용자 없음\n";
}

HTTP 응답 헤더

class HttpResponse {
    std::map<std::string, std::string> headers_;

public:
    std::optional<std::string> getHeader(const std::string& name) const {
        auto it = headers_.find(name);
        if (it != headers_.end()) {
            return it->second;
        }
        return std::nullopt;
    }

    std::string getHeaderOr(const std::string& name,
                            const std::string& defaultValue) const {
        return getHeader(name).value_or(defaultValue);
    }
};

// 사용
HttpResponse response;
auto contentType = response.getHeader("Content-Type");
if (contentType) {
    std::cout << "타입: " << *contentType << '\n';
}

auto encoding = response.getHeaderOr("Content-Encoding", "identity");

HTTP 헤더 이름은 대소문자를 구분하지 않으므로, 실제 구현에서는 저장할 때 이름을 소문자로 정규화하거나 대소문자를 무시하는 비교자를 std::map에 넘겨야 content-type으로 들어온 헤더도 찾을 수 있습니다.

반환값·파라미터·멤버 변수별 선택 기준

함수 반환값

// 값이 없을 수 있음 → optional
std::optional<User> findUser(int id);

// 다른 곳이 소유한 객체를 가리킴, 없을 수 있음 → 포인터
User* getCurrentUser();

// 반드시 있어야 함 → 참조 (없으면 예외)
User& getUser(int id);

함수 파라미터

// 선택적 값 파라미터
void connect(const std::string& host,
             std::optional<int> port = std::nullopt);

// nullptr 가능한 비소유 파라미터
void process(const Data* data);

// 반드시 필요한 파라미터 (nullptr 불가)
void process(const Data& data);

멤버 변수

class Widget {
    // 지연 초기화되는 값
    std::optional<Connection> conn_;

    // 다형성 객체를 소유
    std::unique_ptr<Renderer> renderer_;

    // 항상 존재하는 값
    std::string name_;
};

optional 참조·value() 예외·체인에서 막히는 경우

optional<T&>는 만들 수 없다

// std::optional<int&> opt;  // C++17~23에서는 컴파일 에러

// 포인터 사용
int* ptr = nullptr;

// 또는 reference_wrapper
std::optional<std::reference_wrapper<int>> ref;

optional<T&>가 C++17에서 빠진 이유는 대입 의미론 때문입니다. 값이 있는 optional<int&>에 다른 int를 대입하면 “참조 대상을 바꾸는 것”인지 “참조된 원본에 값을 쓰는 것”인지 모호해서 합의하지 못했습니다. 이 논의는 C++26에서 참조 대상을 다시 묶는(rebind) 의미로 std::optional<T&>를 도입하는 것으로 정리되었지만, 현재 대부분의 코드베이스에서는 여전히 T*가 가장 단순한 “없을 수도 있는 참조”입니다. 어느 방식이든 원본 객체의 수명은 관리하지 않으므로 원본보다 오래 들고 있으면 안 됩니다.

value()의 bad_optional_access를 처리하지 않음

std::optional<int> opt;
// int x = opt.value();  // bad_optional_access 예외

// has_value() 확인 후 접근
if (opt.has_value()) {
    int x = *opt;
}

// value_or() 사용
int y = opt.value_or(0);

value()를 부르는 순간 예외 가능성이 생기므로, 이미 if (opt)로 확인한 블록 안에서는 *opt를 쓰는 것이 관례입니다. 반대로 value_or()는 인자를 항상 먼저 평가한다는 점을 조심해야 합니다. opt.value_or(loadDefaultFromDisk())는 opt에 값이 있어도 디스크를 읽습니다. 기본값 계산이 비싸다면 opt ? *opt : loadDefaultFromDisk()나 C++23의 or_else를 씁니다.

필요 없는 곳에 optional을 씀

// 항상 값이 있는데 optional을 쓰면 호출자가 쓸데없는 검사를 하게 된다
std::optional<int> getId() {
    return 42;
}

// 일반 타입이면 충분
int getId2() {
    return 42;
}

중첩된 optional 체인이 길어질 때

std::optional<User> getUser(int id);
std::optional<Address> getAddress(const User& user);

// 단계마다 중첩 검사가 필요하다
auto user = getUser(123);
if (user) {
    auto address = getAddress(*user);
    if (address) {
        std::cout << address->street << '\n';
    }
}

C++23의 and_then과 transform을 쓰면 이 중첩을 체인으로 펼 수 있습니다.

auto street = getUser(123)
    .and_then([](const User& user) { return getAddress(user); })  // optional<Address>
    .transform([](const Address& addr) { return addr.street; });  // optional<std::string>

if (street) {
    std::cout << *street << '\n';
}

and_then에 넘기는 함수는 optional을 반환해야 하고(실패할 수 있는 다음 단계), transform에 넘기는 함수는 일반 값을 반환합니다(항상 성공하는 변환). or_else는 비어 있을 때만 호출되어 대체 optional을 돌려줍니다. std::optional<void>는 표준에서 허용되지 않는 타입이라 부수 효과만 있는 마지막 단계를 transform에 넣을 수는 없으므로, 체인으로 값을 만든 뒤 마지막에 if로 한 번 꺼내 쓰는 형태가 가장 읽기 쉽습니다.

큰 객체를 optional로 반환할 때의 비용

// 큰 객체를 값으로 담으면 이동해도 비용이 줄지 않는다
std::optional<BigData> getData() {
    BigData data;  // int[1000000] → 약 4MB, 스택 오버플로 위험
    // ...
    return data;   // optional로 이동 생성되지만, 배열 멤버의 이동은 결국 전체 복사
}

// 힙에 두고 소유권만 넘긴다 (nullptr이 "없음")
std::unique_ptr<BigData> getDataPtr() {
    auto data = std::make_unique<BigData>();
    // ...
    return data;
}

// 또는 호출자가 준비한 객체를 채운다
bool fillData(BigData& out) {
    // ...
    return true;  // 성공 여부
}

getData()의 문제는 optional 자체보다 이동해도 싸지지 않는 타입에 있습니다. 반환문 return data;는 C++14 이후 optional의 변환 생성자로 암묵적 이동이 적용되지만, BigData처럼 고정 크기 배열을 멤버로 가진 타입은 이동이 곧 4MB 복사입니다. 또 이 크기의 지역 변수는 Windows 기본 스택(1MB)이나 Linux 스레드 스택(보통 8MB, 워커 스레드는 더 작게 설정되기도 함)을 넘길 수 있어, 성능 이전에 크래시가 납니다. 반대로 std::vector<int>를 멤버로 가진 타입이라면 이동은 포인터 몇 개 복사로 끝나므로 optional<T> 반환이 전혀 문제가 되지 않습니다.

상황별 선택표

상황사용
값이 없을 수 있는 반환값std::optional<T>
”지정 안 함”을 구분해야 하는 선택적 매개변수std::optional<T>
초기화 지연 멤버std::optional<T>
없을 수 있는 다형성 객체 참조T*
항상 있는 다형성 객체 참조T&
다형성 객체 소유std::unique_ptr<T>
소유권 공유std::shared_ptr<T>
연속된 원소 범위std::vector<T>, std::span<T>(C++20)
실패 이유까지 전달std::expected<T, E>(C++23)

optional 다음으로 여러 타입 중 하나를 담는 경우가 궁금하다면 C++ std::variant vs union: 타입 안전성과 비용 비교로 이어집니다.

참고 자료

같이 보면 좋은 글