pkglog
EN

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

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

이 글의 핵심

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

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

C++에서 “값이 없음”을 표현하는 방법은 여러 가지입니다. 포인터의 nullptr과 std::optional이 대표적입니다.

비유로 말씀드리면, optional은 “오늘 도시락 있음/없음”을 도시락 통 자체에 스티커로 표시하는 것이며, 포인터는 “저기 탁자를 가리키는 손가락”입니다. 손가락은 다형성·비소유 참조에는 좋지만, 잘못 쓰면 댕글링이 납니다.

언제 std::optional을, 언제 포인터를 쓰나요?

관점std::optional포인터(또는 스마트 포인터)
성능보통 스택, 힙 없이 값 부재 표현간접 참조·캐시 미스 비용
사용성값 없음이 타입에 드러남nullptr 체크 관례에 의존
적용 시나리오반환값·로컬에서 “없을 수 있음”다형성, 비소유 참조, 배열·연속 메모리
// 포인터 방식
const int* findValue(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> findValue(const std::vector<int>& vec, int target) {
    for (auto val : vec) {
        if (val == target) {
            return val;  // ✅ 값 복사
        }
    }
    return std::nullopt;  // 값 없음
}

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

이 글에서 다루는 것:

  • std::optional vs 포인터 차이
  • 타입 안전성과 성능
  • 사용 시나리오
  • 실전 패턴

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

항목별 비교표

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

표의 “타입 안전성”은 과장하면 안 됩니다. 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: has_value 확인을 강제하는 인터페이스

// ✅ optional: 안전한 접근
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';
    }
}

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

// ❌ 포인터: 불안전한 접근
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';  // Segmentation fault
    
    // ✅ nullptr 체크 (수동)
    if (result != nullptr) {
        std::cout << *result << '\n';
    }
}

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

메모리 레이아웃

// optional: 스택에 저장
struct Data {
    int x, y, z;
};

std::optional<Data> opt;
// 메모리: sizeof(Data) + 1 = 13바이트 (패딩 포함 16바이트)

// 포인터: 힙에 저장 (동적 할당 시)
Data* ptr = new Data{1, 2, 3};
// 메모리: 포인터 8바이트 + 힙 12바이트 = 20바이트

벤치마크

#include <benchmark/benchmark.h>

// 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: 캐시 친화적
std::vector<std::optional<int>> vec(1000);
// 연속 메모리 (캐시 효율 높음)

// ❌ 포인터: 캐시 미스
std::vector<int*> vec(1000);
// 포인터들은 연속이지만, 실제 데이터는 흩어짐

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

없을 수 있는 반환값: optional

// ✅ optional: 값이 없을 수 있는 반환값
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

// ✅ optional: 선택적 매개변수
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 std::optional<T>&보다 차라리 const T*(없으면 nullptr)가 복사 없이 같은 의미를 전달하기도 합니다.

초기화 지연: optional

// ✅ optional: 초기화 지연
class Database {
    std::optional<Connection> conn_;
    
public:
    void connect(const std::string& host) {
        conn_ = Connection(host);  // 필요할 때 초기화
    }
    
    void query(const std::string& sql) {
        if (!conn_) {
            throw std::runtime_error("연결 안 됨");
        }
        conn_->execute(sql);
    }
};

초기화 지연에서 conn_ = Connection(host);는 임시 객체를 만든 뒤 이동 대입합니다. Connection이 이동 불가능한 타입(뮤텍스나 소켓 핸들을 직접 들고 있는 경우)이면 컴파일되지 않으므로, 그때는 conn_.emplace(host);로 optional 안에서 바로 생성해야 합니다. emplace는 이미 값이 있으면 기존 객체를 먼저 파괴하고 새로 만든다는 점도 기억해 두세요.

다형성: 포인터

// ✅ 포인터: 다형성
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) {  // 포인터 필요
    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을 넣으면 파생 부분이 잘리는 객체 슬라이싱이 일어나고, 추상 클래스라면 아예 컴파일되지 않기 때문입니다.

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

// ✅ 포인터: 큰 객체 참조
struct BigData {
    int data[1000000];
};

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

int main() {
    BigData data;
    process(&data);
}

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

설정 클래스의 선택 필드

// ✅ optional: 설정값
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()까지 확인하면 “전체가 정확히 정수인지”를 엄격하게 검사할 수 있어 설정 파싱에 더 잘 맞습니다.

찾지 못할 수 있는 검색 함수

// ✅ optional: 검색 결과
template <typename T>
std::optional<T> find(const std::vector<T>& vec, 
                      std::function<bool(const T&)> 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 = find(numbers, [](int x) { return x > 3; });
    
    if (result) {
        std::cout << "찾음: " << *result << '\n';  // 4
    } else {
        std::cout << "못 찾음\n";
    }
}

캐시 조회 결과

// ✅ optional: 캐시 조회
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';
}

데이터베이스 단건 조회

// ✅ 실무 예시: DB 조회
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() {
        // 항상 벡터 반환 (빈 벡터 가능)
        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 응답 본문

// ✅ 실무 예시: 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");

설정 파일 파서의 키 조회

// ✅ 실무 예시: 설정 파싱
class ConfigParser {
public:
    std::optional<int> getInt(const std::string& key) {
        auto value = getValue(key);
        if (!value) {
            return std::nullopt;
        }
        
        try {
            return std::stoi(*value);
        } catch (...) {
            return std::nullopt;
        }
    }
    
    std::optional<bool> getBool(const std::string& key) {
        auto value = getValue(key);
        if (!value) {
            return std::nullopt;
        }
        
        if (*value == "true" || *value == "1") {
            return true;
        } else if (*value == "false" || *value == "0") {
            return false;
        }
        return std::nullopt;
    }
    
private:
    std::optional<std::string> getValue(const std::string& key);
};

// 사용
ConfigParser config;
int port = config.getInt("server.port").value_or(8080);
bool debug = config.getBool("debug").value_or(false);

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

함수 반환값

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

// ✅ 포인터: 외부 객체 참조
User* getCurrentUser();

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

함수 파라미터

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

// ✅ 포인터: nullable 파라미터
void process(const Data* data);  // nullptr 가능

// ✅ 참조: 반드시 필요
void process(const Data& data);  // nullptr 불가

멤버 변수

class Widget {
    // ✅ optional: 지연 초기화
    std::optional<Connection> conn_;
    
    // ✅ 포인터: 다형성
    std::unique_ptr<Renderer> renderer_;
    
    // ✅ 값: 항상 존재
    std::string name_;
};

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

optional<T&>는 만들 수 없다

// ❌ 실수: optional<T&>는 없음
std::optional<int&> opt;  // 컴파일 에러

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

// ✅ 또는 reference_wrapper
std::optional<std::reference_wrapper<int>> opt;

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();  // ❌ 예외 던짐!

// ✅ has_value() 체크
if (opt.has_value()) {
    int x = opt.value();
}

// ✅ value_or() 사용
int x = 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 getId() {
    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';
    }
}

해결: and_then() 사용 (C++23)

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에 넘기는 함수는 일반 값을 반환합니다(항상 성공하는 변환). std::optional<void>는 표준에서 허용되지 않는 타입이라 “부수 효과만 있는 마지막 단계”를 체인에 넣을 수는 없으므로, 체인으로 값을 만든 뒤 마지막에 if로 한 번 꺼내 쓰는 형태가 가장 읽기 쉽습니다.

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

증상: 큰 객체를 optional로 반환 시 복사 오버헤드

해결:

// ❌ 큰 객체 복사
std::optional<BigData> getData() {
    BigData data;  // int[1000000] → 약 4MB (스택에 만들면 스택 오버플로 위험)
    // ...
    return data;  // optional로 이동 생성되지만, 배열 멤버의 이동은 결국 전체 복사
}

// ✅ unique_ptr 사용
std::unique_ptr<BigData> getData() {
    auto data = std::make_unique<BigData>();
    // ...
    return data;  // 이동
}

// ✅ 또는 out 파라미터
bool getData(BigData& out) {
    // ...
    return true;  // 성공 여부
}

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

C++23 and_then·transform·or_else

// C++23: and_then, or_else, transform
std::optional<int> getValue();

auto result = getValue()
    .and_then([](int x) { return std::optional<int>(x * 2); })
    .or_else([] { return std::optional<int>(0); })
    .transform([](int x) { return x + 1; });

optional과 포인터 선택 요약

상황별 선택표

상황사용
값이 없을 수 있는 반환값optional
선택적 매개변수optional
초기화 지연optional
다형성포인터
큰 객체 참조포인터
소유권 공유shared_ptr
배열포인터

네 가지 규칙

  1. 값 타입 → optional
  2. 참조 타입 → 포인터
  3. 타입 안전성 우선 → optional
  4. 다형성 필요 → 포인터

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

같이 보면 좋은 글

자주 묻는 질문 (FAQ)

Q. std::optional<int&>처럼 참조를 optional로 감쌀 수 있나요?

A. C++23까지의 표준 std::optional은 참조 타입을 담을 수 없어서 optional<int&>는 컴파일 에러가 납니다. 없을 수도 있는 참조를 표현하려면 널이 될 수 있는 포인터(int*)를 쓰거나 std::optional<std::reference_wrapper>로 감싸야 합니다. 어느 쪽이든 가리키는 원본 객체의 수명을 optional이 관리하지 않으므로, 원본보다 오래 들고 있지 않도록 주의해야 합니다.