为何std::optional<T*>不强制非空？自定义实现方案咨询

当把nullptr存入任意类型T的std::optional<T*>时，这个std::optional在技术上处于有值状态，但存储的值是nullptr。这相当于浪费了提升空安全性的机会——因为这意味着std::optional无法强制要求开发者对可能为空的参数或返回值做空检查。

比如下面的代码示例：

auto GetObj() -> std::optional<Obj*>;

auto MyFunc() {
    auto result = GetObj();
    if (result.has_value()) {
        UseObj(*(result.value())); // <-- 这里可能触发空指针异常!
    }
}

在这个场景里，即便result.has_value()返回true，解引用依然可能崩溃，因为内部存的是nullptr。

除此之外，如果针对指针类型做特化，还能缩小std::optional的体积。常规的optional结构如下：

template<typename T>
struct optional {
    union {
        DummyType _dummy;
        T _value;
    };
    bool _has_value;
};

而针对指针类型的特化可以简化为：

// 指针类型特化
template<typename T>
struct optional<T*> {
    T* _value;
};

这里直接用指针本身的空状态表示“无值”，不需要额外的_has_value标志位，节省了内存。

1. 标准库为何未采用这种设计？ #

• 语义一致性优先：std::optional的核心语义是「值存在/不存在」，而非「值是否有效」。对于T*类型来说，nullptr是一个合法有效的T*值，就像0是合法的int值一样。如果把nullptr映射为std::nullopt，会混淆「值的有效性」和「值的存在性」，破坏语义一致性，让开发者对optional的行为产生困惑。
• 兼容性与通用性：标准库需要保持接口的通用性，适配所有类型。针对指针类型做特殊处理会增加规则复杂度，还可能破坏依赖optional<T*>原有语义的代码——比如有些场景下，开发者需要明确区分「没有返回指针」和「返回了空指针」两种状态，特化设计会抹杀掉这种区分能力。
• 设计初衷定位：std::optional的目标是封装「可选值」，而非替代指针的空检查。它负责处理「值可能不存在」的场景，而指针的空有效性检查属于指针自身的逻辑范畴，不应由optional接管。

2. 自有代码库中实现该功能的最优方案是什么？ #

方案一：封装自定义的指针可选类型 #

创建专门针对指针的OptionalPtr<T>，构造时自动将nullptr转换为「无值」状态：

#include <stdexcept>

template<typename T>
class OptionalPtr {
public:
    constexpr OptionalPtr(std::nullptr_t) noexcept : _ptr(nullptr) {}
    constexpr explicit OptionalPtr(T* ptr) noexcept : _ptr(ptr) {}

    constexpr bool has_value() const noexcept { return _ptr != nullptr; }

    constexpr T* value() const {
        if (!has_value()) {
            throw std::bad_optional_access();
        }
        return _ptr;
    }

    constexpr T& operator*() const { return *value(); }
    constexpr T* operator->() const { return value(); }

private:
    T* _ptr;
};

这种方案语义清晰，完全匹配需求，且不会与标准库std::optional冲突。

方案二：为std::optional添加构造包装函数 #

如果不想自定义类型，可以写一个包装函数，构造std::optional<T*>时自动将nullptr转为std::nullopt：

#include <optional>

template<typename T>
constexpr std::optional<T*> make_optional_ptr(T* ptr) noexcept {
    return ptr == nullptr ? std::nullopt : std::optional<T*>(ptr);
}

使用时直接调用该函数：

auto GetObj() -> std::optional<Obj*> {
    Obj* obj = GetRawObj();
    return make_optional_ptr(obj);
}

auto MyFunc() {
    auto result = GetObj();
    if (result.has_value()) {
        UseObj(*result.value()); // 此处可安全解引用，has_value()意味着指针非空
    }
}

该方案侵入性小，基于标准库实现，适合快速改造现有代码。

方案三：C++20+ 概念辅助增强安全 #

如果使用C++20及以上版本，可以用概念定义指针类型检查工具，辅助确保空安全：

#include <optional>
#include <type_traits>

template<typename T>
concept PointerType = std::is_pointer_v<T>;

template<PointerType T>
constexpr bool is_valid(const std::optional<T>& opt) noexcept {
    return opt.has_value() && *opt != nullptr;
}

使用时用is_valid()替代has_value()，确保解引用的安全性。不过该方案仅做检查增强，未改变optional原有语义，属于辅助工具类方案。

内容的提问来源于stack exchange，提问作者Walter Svenddal