C++中std::optional的基本使用

在 C++17 中，std::optional 是一个模板类，用于表示一个可能包含值的对象（即值可能存在，也可能不存在）。它提供了一种类型安全的方式处理“可选值”，避免使用特殊标记（如 nullptr 或 -1）或额外的布尔变量来指示值是否存在。以下是 std::optional 的详细使用指南：

1. 基本用法

(1) 头文件

#include <optional>

(2) 声明与初始化

// 声明一个可能包含 int 值的 optional
std::optional<int> opt_int;

// 直接初始化（包含值）
std::optional<int> opt_value = 42;
std::optional<std::string> opt_str = "hello";

// 使用 std::make_optional 创建（自动推导类型）
auto opt_double = std::make_optional(3.14);

(3) 表示“无值”

用 std::nullopt 表示无值：

std::optional<float> opt_float = std::nullopt;
opt_float = std::nullopt;  // 重置为无值

2. 检查与访问值

(1) 检查是否有值

if (opt_int.has_value()) {
    // 值存在
}

// 或者直接判断 bool 上下文
if (opt_str) {
    // 值存在
}

(2) 访问值

value()：返回值的引用，若无值则抛出 std::bad_optional_access。
operator* 和 operator->：直接访问值，但若无值，行为未定义（需先检查）。

std::optional<std::string> opt_name = "Alice";

if (opt_name) {
    std::cout << *opt_name << std::endl;        // 使用 operator*
    std::cout << opt_name->size() << std::endl; // 使用 operator->
    std::cout << opt_name.value() << std::endl; // 使用 value()
}

(3) 安全获取值

使用 value_or(default_value) 提供默认值：

std::optional<int> opt_num;
int num = opt_num.value_or(0); // 若 opt_num 无值，返回 0

3. 重置与修改值

(1) 重置为无值

opt_int.reset();       // 等价于 opt_int = std::nullopt;

(2) 赋值或修改值

opt_int = 100;         // 直接赋值
opt_int.emplace(200);  // 原地构造（避免临时对象）

4. 典型应用场景

(1) 函数返回可能失败的值

// 查找元素，若存在则返回其值，否则返回 std::nullopt
std::optional<int> find_value(const std::vector<int>& vec, int target) {
    auto it = std::find(vec.begin(), vec.end(), target);
    if (it != vec.end()) {
        return *it;
    }
    return std::nullopt;
}

// 调用示例
std::vector<int> data = {1, 2, 3};
if (auto result = find_value(data, 2)) {
    std::cout << "Found: " << *result << std::endl;
}

(2) 避免默认构造函数开销

当对象的构造成本较高时，延迟初始化：

class Resource {
public:
    Resource() { /* 高成本操作 */ }
    // ...
};

std::optional<Resource> res;  // 此时未构造 Resource 对象
res.emplace();                // 显式构造对象

(3) 类成员的可选值

class UserProfile {
private:
    std::optional<std::string> nickname_;  // 昵称可能未设置
public:
    void set_nickname(const std::string& name) { nickname_ = name; }
    std::string get_nickname() const { 
        return nickname_.value_or("(未设置)");
    }
};

5. 注意事项

(1) 性能与内存

std::optional 的大小通常为底层类型大小 + 1 字节（用于标记是否有值）。
对于小对象（如基本类型）几乎无开销；对大对象需权衡是否使用指针。

(2) 未检查访问的风险

直接使用 operator* 或 operator-> 前必须检查是否有值，否则导致未定义行为：

std::optional<int> opt_empty;
// int x = *opt_empty;  // 危险：未定义行为！

(3) 与指针的区别

std::optional 直接存储值，而非指针，不需要手动管理内存。
更适合表示“值可能存在”，而非“对象可能不存在”。

6. 高级用法（C++17 及以上）

(1) 链式操作（C++23）

C++23 引入了 transform 和 and_then，支持链式处理 optional 值：

// 假设 C++23 支持
std::optional<int> opt = 42;
auto result = opt.transform([](int x) { return x * 2; })
                 .and_then([](int x) { return x > 0 ? std::optional{x} : std::nullopt; });

(2) 与 std::variant 结合

处理多种可能类型的值：

std::optional<std::variant<int, std::string>> data;
data = 42;
data = "hello";

完整示例代码

#include <iostream>
#include <optional>
#include <vector>

// 示例：查找元素
std::optional<int> find_value(const std::vector<int>& vec, int target) {
    auto it = std::find(vec.begin(), vec.end(), target);
    if (it != vec.end()) return *it;
    return std::nullopt;
}

int main() {
    // 1. 基本用法
    std::optional<int> opt = 42;
    std::cout << "Value: " << opt.value() << std::endl;

    // 2. 函数返回值
    std::vector<int> data = {1, 3, 5};
    auto result = find_value(data, 3);
    if (result) {
        std::cout << "Found: " << *result << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }

    // 3. 安全获取默认值
    std::optional<std::string> empty_opt;
    std::cout << "Nickname: " << empty_opt.value_or("(未设置)") << std::endl;

    return 0;
}

总结

std::optional 是 C++17 中处理“可能存在值”场景的首选工具，它通过类型安全的方式取代了传统的 nullptr 或特殊标记，提升了代码的可读性和安全性。在函数返回值、延迟初始化、配置参数等场景中广泛应用。