Previous
Next
C++ std::optional·std::variant 완벽 가이드 | nullptr 대신 타입 안전하게

C++ std::optional·std::variant 완벽 가이드 | nullptr 대신 타입 안전하게

· 28분 읽기 · 수정 중급 개념
C++ std::optional·std::variant 완벽 가이드 | nullptr 대신 타입 안전하게

이 글의 핵심

C++ nullptr 체크 지겹다. std::optional로 값 유무를, std::variant로 여러 타입 중 하나를 타입 안전하게. has_value, value_or, std::visit, std::get, std::holds_alternative 실전 활용.

들어가며: nullptr 체크에 지쳤다

”값이 없을 수도 있는데 어떻게 표현하죠?”

사용자 정보를 조회하는 함수를 만들었습니다. 하지만 사용자가 없을 때를 표현하기 어려웠습니다.
std::optional은 “값이 있거나 없거나”를 타입으로 표현해서 nullptr·예외·bool+참조 패턴보다 명확하고, 호출하는 쪽에서 반드시 유무를 확인하게 만들 수 있습니다. std::variant는 정해진 타입 목록 중 하나를 담아, void*나 union보다 타입 안전하게 “여러 타입 중 하나”를 다룰 수 있습니다. 문제의 코드:

// ❌ 방법 1: 포인터 (메모리 관리 복잡)
User* findUser(int id) {
    if (존재하지않음) return nullptr;
    return new User{...};  // 누가 delete?
}
// ❌ 방법 2: 예외 (성능 문제)
User findUser(int id) {
    if (존재하지않음) throw std::runtime_error("Not found");
    return User{...};
}
// ❌ 방법 3: bool + 참조 (복잡)
bool findUser(int id, User& out) {
    if (존재하지않음) return false;
    out = User{...};
    return true;
}

optional로 해결:

// 실행 예제
std::optional<User> findUser(int id) {
    if (존재하지않음) {
        return std::nullopt;  // 값 없음
    }
    return User{...};  // 값 있음
}
int main() {
    auto user = findUser(123);
    if (user) {
        std::cout << "Found: " << user->name << "\n";
    } else {
        std::cout << "Not found\n";
    }
}

이 글을 읽으면:

  • optional로 값의 존재 여부를 안전하게 표현할 수 있습니다.
  • variant로 여러 타입 중 하나를 타입 안전하게 저장할 수 있습니다.
  • has_value, value_or, std::visit, std::get, std::holds_alternative를 실전에서 활용할 수 있습니다.
  • 자주 발생하는 에러와 프로덕션 패턴을 알 수 있습니다.

개념을 잡는 비유

optional은 값이 비어 있을 수도 있는 상자, string_view·span은 원본 문자열·배열의 별명 카드처럼 소유하지 않고 범위만 가리킵니다. RAII·unique_ptr는 자동문처럼 스코프를 나가면 자원을 닫습니다.

실무 적용 경험: 이 글은 대규모 C++ 프로젝트에서 실제로 겪은 문제와 해결 과정을 바탕으로 작성되었습니다. 책이나 문서에서 다루지 않는 실전 함정과 디버깅 팁을 포함합니다.

1. 실무에서 겪는 문제 시나리오

시나리오 1: nullptr 체크 누락으로 크래시

문제: DB에서 사용자를 조회한 뒤 user->name을 출력하는데, 사용자가 없을 때 nullptr 체크를 깜빡하면 Segmentation fault가 발생합니다. 코드 리뷰에서도 놓치기 쉽습니다.

// ❌ 문제: nullptr 체크를 깜빡하면 크래시
User* user = findUser(123);
std::cout << user->name << "\n";  // user가 nullptr면 Segmentation fault!
// ✅ 해결: optional은 타입으로 "없을 수 있음"을 강제
std::optional<User> user = findUser(123);
// std::cout << user->name;  // 컴파일 에러! optional은 -> 연산자로 바로 접근 불가
if (user) {
    std::cout << user->name << "\n";  // 안전
}

시나리오 2: JSON/설정 파싱 시 타입 혼동

문제: 설정 파일에서 “port”는 정수, “host”는 문자열, “ratio”는 실수입니다. void*나 any로 반환하면 호출부에서 타입을 잘못 캐스팅할 위험이 있습니다.

// ❌ 문제: "port"가 정수인지 문자열인지 런타임에만 알 수 있음
void* getConfig(const std::string& key);  // 반환 타입이 뭔지 모름
// ✅ 해결: variant로 허용 타입을 명시
using ConfigValue = std::variant<int, double, std::string, bool>;
std::optional<ConfigValue> getConfig(const std::string& key);

시나리오 3: 파싱 실패를 예외로 처리하는 부담

문제: std::stoi, std::stod 등은 파싱 실패 시 예외를 던집니다. “잘못된 입력”이 정상 경로인데 예외로 처리하면 성능 부담과 try-catch 복잡도가 증가합니다.

// ❌ 예외에 의존
int port = std::stoi(str);  // 파싱 실패 시 예외
// ✅ optional로 "실패"를 값으로 표현
std::optional<int> port = parseInt(str);
if (port) {
    usePort(*port);
}

시나리오 4: 이벤트/상태가 여러 타입 중 하나

문제: GUI 이벤트가 MouseClick, KeyPress, TimerTick 중 하나일 때, 상속 + dynamic_cast는 RTTI 비용이 들고, switch문은 새 타입 추가 시 누락하기 쉽습니다.

// ❌ dynamic_cast 남발
if (auto* e = dynamic_cast<MouseEvent*>(event)) { ....}
else if (auto* e = dynamic_cast<KeyEvent*>(event)) { ....}
// ✅ variant + std::visit로 타입 안전
using Event = std::variant<MouseClick, KeyPress, TimerTick>;
std::visit(overloaded{ 람다들 }, e);

시나리오 5: API 응답이 성공/에러 중 하나

문제: REST API가 성공 시 JSON, 실패 시 에러 메시지와 코드를 반환합니다. optional만 쓰면 에러 정보를 담기 어렵고, 별도 구조체는 호출부에서 분기 처리가 번거롭습니다.

// ✅ variant로 Result 타입
using ApiResult = std::variant<SuccessResponse, ErrorResponse>;

타입 선택 흐름도

flowchart TD
    A[값이 없을 수 있나?] -->|예| B["std optional"]
    A -->|아니오| C[여러 타입 중 하나?]
    C -->|예, 타입 고정| D["std variant"]
    C -->|아니오| F[일반 타입]

2. std::optional 완전 가이드

기본 사용법

std::optional<T>는 “T 타입 값이 있거나, 없거나”를 하나의 타입으로 표현합니다. 0으로 나누는 경우처럼 유효한 값을 반환할 수 없는 상황에서 std::nullopt를 반환하고, 정상일 때만 값을 담아 반환합니다.

// 복사해 붙여넣은 뒤: g++ -std=c++17 -o optional_divide optional_divide.cpp && ./optional_divide
#include <optional>
#include <iostream>
std::optional<int> divide(int a, int b) {
    if (b == 0) {
        return std::nullopt;  // 값 없음
    }
    return a / b;  // 값 있음
}
int main() {
    auto result = divide(10, 2);
    if (result) {
        std::cout << "Result: " << *result << "\n";  // 5
    }
    auto fail = divide(10, 0);
    if (!fail) {
        std::cout << "Division by zero\n";
    }
    return 0;
}

실행 결과: Result: 5 한 줄, 이어서 Division by zero 한 줄이 출력됩니다.

has_value() — 값 존재 여부 확인

has_value()는 optional에 값이 있는지 bool로 반환합니다. if (opt)와 동일한 의미입니다.

#include <optional>
#include <iostream>
#include <string>
std::optional<std::string> getName() {
    return "Alice";
}
int main() {
    auto name = getName();
    // has_value() 사용
    if (name.has_value()) {
        std::cout << "Name: " << name.value() << "\n";
    }
    // operator bool과 동일
    if (name) {
        std::cout << "Name: " << *name << "\n";
    }
    // 값이 없을 때
    std::optional<int> empty;
    if (!empty.has_value()) {
        std::cout << "Empty optional\n";
    }
    return 0;
}

value_or() — 기본값으로 대체

값이 없을 때 기본값을 반환하려면 value_or(기본값)을 사용합니다. 예외 없이 안전하게 처리할 수 있습니다.

#include <optional>
#include <iostream>
#include <string>
std::optional<std::string> getEnv(const std::string& key) {
    // 환경 변수 조회 시뮬레이션
    if (key == "HOME") return "/home/user";
    return std::nullopt;
}
int main() {
    // 값이 있으면 그대로, 없으면 "Unknown" 반환
    std::string home = getEnv("HOME").value_or("Unknown");
    std::cout << "HOME: " << home << "\n";
    std::string missing = getEnv("NOT_EXIST").value_or("Unknown");
    std::cout << "NOT_EXIST: " << missing << "\n";
    // 숫자도 동일
    std::optional<int> opt;
    int value = opt.value_or(42);
    std::cout << "value: " << value << "\n";  // 42
    return 0;
}

value() — 값 접근 (예외 가능)

value()는 값이 있으면 반환하고, 없으면 std::bad_optional_access 예외를 던집니다. 확실히 값이 있을 때만 사용하거나, try-catch로 처리합니다.

#include <optional>
#include <iostream>
#include <stdexcept>
int main() {
    std::optional<int> opt = 42;
    // 값이 있을 때
    int v = opt.value();
    std::cout << "Value: " << v << "\n";
    std::optional<int> empty;
    // ❌ 값이 없으면 예외
    try {
        int x = empty.value();
    } catch (const std::bad_optional_access& e) {
        std::cerr << "No value: " << e.what() << "\n";
    }
    // ✅ 권장: value_or 사용
    int safe = empty.value_or(0);
    return 0;
}

optional 생성·수정

#include <optional>
#include <string>
int main() {
    // 빈 optional
    std::optional<int> opt1;
    std::optional<int> opt2 = std::nullopt;
    // 값 있는 optional
    std::optional<int> opt3 = 42;
    std::optional<int> opt4{42};
    std::optional<int> opt5 = std::make_optional(42);
    // in-place 생성 (생성자 인자 직접 전달)
    std::optional<std::string> opt6(std::in_place, 10, 'x');  // "xxxxxxxxxx"
    // 값 할당
    opt1 = 100;
    // 값 제거
    opt1.reset();
    opt1 = std::nullopt;
    // emplace
    opt1.emplace(200);
    return 0;
}

완전한 optional 예제: 사용자 조회 시스템

// g++ -std=c++17 -o optional_user optional_user.cpp && ./optional_user
#include <optional>
#include <iostream>
#include <string>
#include <map>
struct User {
    int id;
    std::string name;
    int age;
};
std::map<int, User> db = {
    {1, {1, "Alice", 25}},
    {2, {2, "Bob", 30}},
};
std::optional<User> findUser(int id) {
    auto it = db.find(id);
    if (it == db.end()) {
        return std::nullopt;
    }
    return it->second;
}
int main() {
    // 케이스 1: 사용자 있음 — has_value 확인
    if (auto user = findUser(1)) {
        std::cout << "Found: " << user->name << ", " << user->age << "\n";
    }
    // 케이스 2: 사용자 없음
    auto missing = findUser(999);
    std::cout << "User 999: " << (missing.has_value() ? "Found" : "Not found") << "\n";
    // 케이스 3: value_or로 기본값
    auto user = findUser(2).value_or(User{0, "Guest", 0});
    std::cout << "User 2 or Guest: " << user.name << "\n";
    // 케이스 4: value() — 확실할 때만
    auto u = findUser(1);
    if (u.has_value()) {
        std::cout << "Name: " << u.value().name << "\n";
    }
    return 0;
}

optional과 함수 체이닝

#include <optional>
#include <iostream>
#include <string>
std::optional<std::string> getName(int id) {
    if (id == 1) return "Alice";
    return std::nullopt;
}
std::optional<int> getAge(const std::string& name) {
    if (name == "Alice") return 25;
    return std::nullopt;
}
int main() {
    auto name = getName(1);
    if (name) {
        auto age = getAge(*name);
        if (age) {
            std::cout << *name << " is " << *age << "\n";
        }
    }
    return 0;
}

3. std::variant 완전 가이드

기본 사용법

std::variant<A, B, C>는 A, B, C 중 정확히 하나를 담습니다. union과 달리 타입 정보가 유지되고, std::visit로 각 타입별 처리를 한곳에서 할 수 있습니다.

#include <variant>
#include <string>
#include <iostream>
int main() {
    std::variant<int, double, std::string> value;
    value = 42;                    // int
    value = 3.14;                  // double
    value = std::string("hello");  // string
    std::cout << "index: " << value.index() << "\n";  // 현재 타입 인덱스
    return 0;
}

std::get — 특정 타입으로 접근

std::get<T>(v)는 variant가 T를 담고 있으면 참조를 반환하고, 아니면 std::bad_variant_access 예외를 던집니다. std::get<인덱스>(v)로 인덱스로도 접근할 수 있습니다.

#include <variant>
#include <iostream>
#include <string>
int main() {
    std::variant<int, double, std::string> v = 42;
    // std::get<T> — 타입으로 접근
    int i = std::get<int>(v);
    std::cout << "int: " << i << "\n";
    // std::get<인덱스> — int는 0번
    int j = std::get<0>(v);
    std::cout << "get<0>: " << j << "\n";
    // 잘못된 타입 요청 시 예외
    try {
        double d = std::get<double>(v);  // v는 int를 담고 있음
    } catch (const std::bad_variant_access& e) {
        std::cerr << "Wrong type: " << e.what() << "\n";
    }
    return 0;
}

std::get_if — 안전한 접근

std::get_if<T>(&v)는 variant가 T를 담고 있으면 포인터를, 아니면 nullptr을 반환합니다. 예외 없이 안전하게 확인할 수 있습니다.

#include <variant>
#include <iostream>
#include <string>
int main() {
    std::variant<int, double, std::string> v = 3.14;
    if (auto ptr = std::get_if<int>(&v)) {
        std::cout << "int: " << *ptr << "\n";
    } else if (auto ptr = std::get_if<double>(&v)) {
        std::cout << "double: " << *ptr << "\n";
    } else if (auto ptr = std::get_if<std::string>(&v)) {
        std::cout << "string: " << *ptr << "\n";
    }
    return 0;
}

std::holds_alternative — 타입 확인

std::holds_alternative<T>(v)는 variant가 T를 담고 있는지 bool로 반환합니다. get_if 전에 확인하거나, 분기 로직에 활용합니다.

#include <variant>
#include <iostream>
#include <string>
int main() {
    std::variant<int, double, std::string> v = "hello";
    if (std::holds_alternative<int>(v)) {
        std::cout << "It's int\n";
    } else if (std::holds_alternative<double>(v)) {
        std::cout << "It's double\n";
    } else if (std::holds_alternative<std::string>(v)) {
        std::cout << "It's string\n";
    }
    // index()로 인덱스 확인
    std::cout << "index: " << v.index() << "\n";  // 2 (string은 세 번째)
    return 0;
}

std::visit — 모든 타입 일괄 처리

std::visit는 방문자(함수 객체)와 variant를 받아, 현재 담긴 타입에 맞는 operator() 오버로드를 호출합니다. overloaded 패턴으로 여러 람다를 하나의 방문자로 묶습니다.

#include <variant>
#include <iostream>
#include <string>
// 여러 람다를 하나의 방문자로 묶는 표준 패턴
template <class....Ts>
struct overloaded : Ts....{
    using Ts::operator()...;
};
template <class....Ts>
overloaded(Ts...) -> overloaded<Ts...>;
int main() {
    std::variant<int, double, std::string> v = "hello";
    std::visit(overloaded{
         { std::cout << "int: " << i << "\n"; },
         { std::cout << "double: " << d << "\n"; },
         { std::cout << "string: " << s << "\n"; }
    }, v);
    return 0;
}

visit + if constexpr (타입별 분기)

#include <variant>
#include <iostream>
#include <string>
#include <type_traits>
int main() {
    std::variant<int, double, std::string> v = 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";
        }
    }, v);
    return 0;
}

완전한 variant 예제: Result 타입 (에러 처리)

// g++ -std=c++17 -o variant_result variant_result.cpp && ./variant_result
#include <variant>
#include <iostream>
#include <string>
template <class....Ts>
struct overloaded : Ts....{
    using Ts::operator()...;
};
template <class....Ts>
overloaded(Ts...) -> overloaded<Ts...>;
struct Error {
    std::string message;
    int code;
};
template <typename T>
using Result = std::variant<T, Error>;
Result<int> divide(int a, int b) {
    if (b == 0) {
        return Error{"Division by zero", -1};
    }
    return a / b;
}
int main() {
    auto r1 = divide(10, 2);
    std::visit(overloaded{
         { std::cout << "Result: " << v << "\n"; },
         { std::cerr << "Error: " << e.message << "\n"; }
    }, r1);
    auto r2 = divide(10, 0);
    std::visit(overloaded{
         { std::cout << "Result: " << v << "\n"; },
         {
            std::cerr << "Error: " << e.message << " (code=" << e.code << ")\n";
        }
    }, r2);
    return 0;
}

완전한 variant 예제: 이벤트 시스템

// g++ -std=c++17 -o variant_event variant_event.cpp && ./variant_event
#include <variant>
#include <iostream>
struct MouseClick {
    int x, y;
};
struct KeyPress {
    char key;
};
struct TimerTick {
    int id;
};
using Event = std::variant<MouseClick, KeyPress, TimerTick>;
template <class....Ts>
struct overloaded : Ts....{
    using Ts::operator()...;
};
template <class....Ts>
overloaded(Ts...) -> overloaded<Ts...>;
void handle(const Event& e) {
    std::visit(overloaded{
         {
            std::cout << "Mouse: (" << c.x << ", " << c.y << ")\n";
        },
         {
            std::cout << "Key: " << k.key << "\n";
        },
         {
            std::cout << "Timer: " << t.id << "\n";
        }
    }, e);
}
int main() {
    handle(Event{MouseClick{10, 20}});
    handle(Event{KeyPress{'A'}});
    handle(Event{TimerTick{1}});
    return 0;
}

std::monostate — “빈” 상태 표현

variant에 void는 넣을 수 없습니다. “값 없음”을 표현하려면 std::monostate를 사용합니다.

#include <variant>
#include <iostream>
int main() {
    std::variant<std::monostate, int, std::string> v;
    v = std::monostate{};  // "빈" 상태
    if (std::holds_alternative<std::monostate>(v)) {
        std::cout << "Empty\n";
    }
    v = 42;
    v = std::string("hello");
    return 0;
}

4. 자주 발생하는 에러와 해결법

문제 1: optional에 값 없는데 value()나 *opt 호출

증상: std::bad_optional_access 예외 또는 정의되지 않은 동작(UB)

// ❌ 잘못된 사용
std::optional<int> opt;
int x = opt.value();  // 예외!
int y = *opt;         // UB!
// ✅ 해결
if (opt.has_value()) {
    int x = opt.value();
}
int y = opt.value_or(0);

문제 2: variant에 get으로 잘못된 타입 요청

증상: std::bad_variant_access 예외

// ❌ 잘못된 사용
std::variant<int, double> v = 42;
double d = std::get<double>(v);  // 예외!
// ✅ 해결: get_if 또는 holds_alternative 먼저 확인
if (auto ptr = std::get_if<double>(&v)) {
    double d = *ptr;
}
if (std::holds_alternative<int>(v)) {
    int i = std::get<int>(v);
}

문제 3: optional 중첩

증상: std::optional<std::optional<T>>로 불필요한 중첩

// ❌ 혼란스러운 반환
std::optional<std::optional<int>> weird() {
    return std::optional<int>(42);
}
// ✅ 해결: 단일 optional
std::optional<int> clean() {
    return 42;
}

문제 4: variant에 void 타입 포함

증상: 컴파일 에러 — variant는 void를 담을 수 없음

// ❌ 잘못된 사용
std::variant<int, void> v;  // 컴파일 에러!
// ✅ 해결: std::monostate로 "빈" 상태 표현
std::variant<std::monostate, int> v;
v = std::monostate{};

문제 5: visit에서 모든 타입 처리 누락

증상: variant에 새 타입을 추가했는데 visit의 람다에 해당 케이스를 안 넣으면 컴파일 에러(overloaded 사용 시) 또는 런타임에 처리되지 않음

// ✅ overloaded 사용 시 — 모든 타입에 대한 람다 필수
using V = std::variant<int, double, std::string>;
std::visit(overloaded{
     { /* ....*/ },
     { /* ....*/ },
     { /* ....*/ }  // 세 타입 모두 처리
}, v);

문제 6: optional의 참조 타입

증상: std::optional<T&>는 C++17에서 불가능 (C++20에서도 제한적)

// ❌ C++17에서 불가
std::optional<int&> opt;  // 컴파일 에러
// ✅ 해결: optional<std::reference_wrapper<T>> 또는 포인터
#include <functional>
std::optional<std::reference_wrapper<int>> opt;

5. 베스트 프랙티스

optional 사용 시

  1. value() 호출 전 반드시 has_value() 또는 if (opt) 확인
  2. 기본값이 있으면 value_or() 사용 — 예외 없이 안전
  3. 포인터 반환 대신 optional 반환 — 소유권과 null 의미가 명확
  4. optional을 반환하는 함수에 [[nodiscard]] 고려 — 반환값 무시 방지
[[nodiscard]] std::optional<User> findUser(int id);

variant 사용 시

  1. get 대신 get_if 또는 std::visit — 예외 방지
  2. 타입 집합이 5~7개 이하일 때 유리 — 너무 많으면 visit가 비대해짐
  3. overloaded 패턴으로 visit 가독성 확보
  4. 새 타입 추가 시 모든 visit 호출부 수정 — exhaustive 처리 유지

optional vs variant 선택

상황권장
값 있음/없음만optional
성공/에러 (에러 정보 포함)variant
여러 타입 중 하나 (고정)variant
optional + variant 조합variant<T, Error>, optional<ConfigValue> 등

6. 성능 비교

메모리 레이아웃

flowchart TB
    subgraph optional[optionalT]
        O1["bool: 값 유무"] --> O2["T: 실제 값"]
    end
    subgraph variant[variantA,B,C]
        V1["union: max size"] --> V2[index]
    end

벤치마크 요약 (참고용)

연산optionalvariant
생성~1 cycle~1 cycle
복사T 크기에 비례max(T…) 크기
접근인라인 가능switch/인덱스
메모리sizeof(T) + 1max(sizeof…) + 정렬

성능 팁

  1. optional: std::optional<std::string>보다 std::optional<std::string_view>가 작은 문자열에 유리할 수 있음
  2. variant: std::visit는 컴파일 타임에 모든 타입을 처리하므로 인라인·최적화가 잘 됨
  3. 핫 루프: optional과 variant 모두 스택 할당으로 캐시에 유리

7. 프로덕션 패턴

패턴 1: API 응답 래퍼

#include <optional>
#include <string>
template <typename T>
struct ApiResponse {
    std::optional<T> data;
    std::optional<std::string> error;
    static ApiResponse success(T value) {
        return {std::move(value), std::nullopt};
    }
    static ApiResponse failure(std::string msg) {
        return {std::nullopt, std::move(msg)};
    }
    bool ok() const { return data.has_value(); }
};

패턴 2: 설정 검증 (variant + visit)

#include <variant>
#include <string>
template <class....Ts>
struct overloaded : Ts....{
    using Ts::operator()...;
};
template <class....Ts>
overloaded(Ts...) -> overloaded<Ts...>;
using ConfigValue = std::variant<int, double, std::string>;
bool validate(const ConfigValue& v) {
    return std::visit(overloaded{
         { return i >= 0 && i <= 65535; },
         { return d >= 0.0 && d <= 1.0; },
         { return !s.empty() && s.size() <= 256; }
    }, v);
}

패턴 3: 안전한 파싱

#include <optional>
#include <string>
#include <iostream>
std::optional<int> parseInt(const std::string& str) {
    try {
        return std::stoi(str);
    } catch (...) {
        return std::nullopt;
    }
}
int main() {
    auto num = parseInt("123");
    if (num.has_value()) {
        std::cout << "Parsed: " << num.value() << "\n";
    }
    int value = parseInt("abc").value_or(0);  // 기본값
    return 0;
}

패턴 4: 데이터베이스 NULL 처리

#include <optional>
#include <string>
struct UserRow {
    int id;
    std::optional<std::string> name;   // NULL 허용
    std::optional<int> age;            // NULL 허용
};

패턴 5: Result 타입 (variant)

#include <variant>
#include <string>
template <typename T, typename E = std::string>
using Result = std::variant<T, E>;
template <typename T>
Result<T> ok(T value) {
    return value;
}
template <typename E>
auto err(E error) {
    return std::variant<std::monostate, E>(std::move(error));
}

프로덕션 체크리스트

  • optional: value() 호출 전 has_value() 또는 if (opt) 확인
  • variant: get<T> 대신 get_if<T> 또는 std::visit 사용
  • 예외: bad_optional_access, bad_variant_access 처리
  • 로깅: 값 없음/타입 불일치 시 명확한 에러 메시지
  • [[nodiscard]]: optional 반환 함수에 적용 검토

8. 정리

타입용도핵심 API장점
optional값 유무has_value, value_or, value타입 안전, nullptr 대체
variant다중 타입 중 하나std::get, std::get_if, std::holds_alternative, std::visit타입 안전 union
핵심 원칙:
  1. 값 유무는 optional — has_value, value_or 활용
  2. 고정 타입 집합은 variant — std::visit로 exhaustive 처리
  3. 포인터 대신 optional
  4. union 대신 variant
  5. get 대신 get_if 또는 visit

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

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

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

C++ optional variant, std::optional, std::variant, has_value value_or, std::visit std::get std::holds_alternative, 타입 안전 등으로 검색하시면 이 글이 도움이 됩니다.

자주 묻는 질문 (FAQ)

Q. optional과 variant를 같이 쓸 수 있나요?

A. 네. std::optional<std::variant<A, B>>처럼 “값이 없을 수 있고, 있으면 A 또는 B”를 표현할 수 있습니다. 설정 조회 등에서 유용합니다.

Q. C++20/23에서 바뀐 점이 있나요?

A. C++23에서 optional에 and_then, or_else, transform 등 모나딕 연산이 추가됩니다. variant는 C++17과 동일하게 사용 가능합니다.

Q. 성능은 포인터보다 어떤가요?

A. optional과 variant는 스택에 할당되며 힙 할당이 없어, 포인터+힙 할당보다 일반적으로 빠릅니다. 캐시 지역성도 좋습니다.

실전 체크리스트

실무에서 이 개념을 적용할 때 확인해야 할 사항입니다.

코드 작성 전

  • 이 기법이 현재 문제를 해결하는 최선의 방법인가?
  • 팀원들이 이 코드를 이해하고 유지보수할 수 있는가?
  • 성능 요구사항을 만족하는가?

코드 작성 중

  • 컴파일러 경고를 모두 해결했는가?
  • 엣지 케이스를 고려했는가?
  • 에러 처리가 적절한가?

코드 리뷰 시

  • 코드의 의도가 명확한가?
  • 테스트 케이스가 충분한가?
  • 문서화가 되어 있는가? 이 체크리스트를 활용하여 실수를 줄이고 코드 품질을 높이세요.

한 줄 요약: optional로 “값 없음”을, variant로 “여러 타입 중 하나”를 타입 안전하게 다룰 수 있습니다. 이전 글: C++ 실전 가이드 #12-3: optional·variant·any 다음 글: C++ 실전 가이드 #38-2: 현대적 다형성 — 합성과 std::variant

관련 글

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

이 부록은 앞선 본문에서 다룬 주제(「C++ std::optional·std::variant 완벽 가이드 | nullptr 대신 타입 안전하게」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(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::optional·std::variant 완벽 가이드 | nullptr 대신 타입 안전하게」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

  1. 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
  2. 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
  3. 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
  4. 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
  5. 부하 후 검증: 피크 대비 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 스냅샷 비교
빌드·배포만 실패환경 변수, 권한, 플랫폼 차이, lockfileCI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치프로필·시크릿·기본값, 리전스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치비멱등 재시도, 부분 쓰기, 캐시 무효화 누락멱등 키·아웃박스·트랜잭션 경계 재검토

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

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