C++如何使用std::optional管理可选值

std::optional通过类型安全的方式明确表达值的可选性，避免空指针或魔术数字的歧义，提升代码清晰度与安全性。它支持存在性检查、安全访问（如value_or提供默认值）、C++17结构化绑定及C++23链式操作（transform、and_then等），适用于查找失败等预期场景，优于异常或输出参数设计，契合现代C++的RAII与值语义理念。

C++中，

std::optional

std::optional

std::optional 的基本用法和实践

使用

std::optional

<optional>

#include <iostream>
#include <optional>
#include <string>

// 示例函数：尝试从字符串中解析一个整数
std::optional<int> parse_int(const std::string& s) {
    try {
        size_t pos;
        int value = std::stoi(s, &pos);
        if (pos == s.length()) { // 确保整个字符串都被解析
            return value;
        }
    } catch (const std::invalid_argument& e) {
        // 字符串不是有效的数字
    } catch (const std::out_of_range& e) {
        // 数字超出int范围
    }
    return std::nullopt; // 表示没有值
}

int main() {
    // 创建一个包含值的 optional
    std::optional<std::string> name = "Alice";
    std::optional<int> age = 30;

    // 创建一个不包含值的 optional
    std::optional<double> temperature; // 默认构造为 std::nullopt
    std::optional<bool> is_active = std::nullopt; // 显式指定为空

    // 检查是否存在值
    if (name.has_value()) {
        std::cout << "Name: " << *name << std::endl; // 使用 * 或 .value() 访问
    }

    // 更简洁的 if 语句检查
    if (age) { // std::optional 可以隐式转换为 bool
        std::cout << "Age: " << age.value() << std::endl; // 使用 .value() 访问
    }

    // 处理没有值的情况，提供默认值
    double current_temp = temperature.value_or(25.0);
    std::cout << "Current temperature: " << current_temp << std::endl;

    // 结合示例函数
    std::optional<int> num1 = parse_int("123");
    if (num1) {
        std::cout << "Parsed num1: " << *num1 << std::endl;
    } else {
        std::cout << "Failed to parse num1." << std::endl;
    }

    std::optional<int> num2 = parse_int("abc");
    if (num2) {
        std::cout << "Parsed num2: " << *num2 << std::endl;
    } else {
        std::cout << "Failed to parse num2." << std::endl;
    }

    // C++23 引入的 monadic operations (and_then, or_else, transform) 使得链式操作更流畅
    // 假设我们有一个函数，如果解析成功，就将其加倍
    auto doubled_num = parse_int("42")
                       .transform([](int val) { return val * 2; })
                       .value_or(0);
    std::cout << "Doubled num (or 0 if failed): " << doubled_num << std::endl;

    return 0;
}

可以看到，

std::optional

has_value()

*

value()

value()

std::bad_optional_access

value_or()

立即学习“C++免费学习笔记（深入）”；

std::optional与裸指针或特殊值（如-1）相比有哪些优势？

从我个人的开发经验来看，

std::optional

首先，类型安全是它最大的亮点。当你返回一个

int*

int

-1

int*

nullptr

std::optional<int>

int

int

-1

-1

std::optional

其次，它提供了清晰的意图。当一个函数返回

std::optional<T>

T

T*

nullptr

T

bool

再者，资源管理也变得更简单。

std::optional

std::optional

最后，它与现代C++的哲学更契合。现代C++推崇RAII（Resource Acquisition Is Initialization）和值语义，

std::optional

在实际项目中，何时选择使用std::optional而不是抛出异常或返回布尔值？

选择

std::optional

我会倾向于使用

std::optional

易森网络企业版

如果您是新用户，请直接将本程序的所有文件上传在任一文件夹下，Rewrite 目录下放置了伪静态规则和筛选器，可将规则添加进IIS，即可正常使用，不用进行任何设置；(可修改图片等)默认的管理员用户名、密码和验证码都是：yeesen系统默认关闭，请上传后登陆后台点击“核心管理”里操作如下:进入“配置管理”中的&ld

0

查看详情

1. “没有值”是一种预期情况，而非异常。 比如，在一个查找操作中，查找不到某个元素是完全正常的，不是程序错误。一个

   find_user_by_id(id)

   登录后复制
   函数，如果用户不存在，返回

   std::nullopt

   登录后复制
   就比抛出

   UserNotFoundException

   登录后复制
   更自然。异常通常用于表示程序无法继续执行的、不应该发生的错误状态。如果你的函数经常性地、预期性地会“找不到”或“无法计算”，那么

   std::optional

   登录后复制
   是更合适的选择。抛出异常的成本也相对较高，如果这种情况频繁发生，性能可能会受影响。

2. API设计需要清晰地表达“可选性”。 如果一个函数的返回值在某些条件下可能不存在，

   std::optional

   登录后复制
   直接在类型签名中就表达了这种可能性。这使得API的使用者无需查看文档就能理解其行为。这比返回一个

   bool

   登录后复制
   并在一个引用参数中填充结果（例如

   bool try_parse(const std::string& s, int& out_value)

   登录后复制
   ）要更简洁、更不易出错。后者容易忘记检查返回值，直接使用

   out_value

   登录后复制
   。

3. 避免不必要的控制流中断。 异常会打断正常的程序控制流，这在某些情况下是必要的，但在“没有值”是预期结果时，它会使代码的逻辑变得复杂。

   std::optional

   登录后复制
   允许你在不中断控制流的情况下，以一种函数式的方式处理值的存在与否。特别是C++23引入的

   and_then

   登录后复制
   、

   transform

   登录后复制
   等 monadic 操作，使得链式处理可选值变得异常流畅和优雅。

然而，如果遇到的是真正意义上的异常条件，例如文件IO错误、内存分配失败、传入了完全非法的参数（而非“找不到”），那么抛出异常仍然是正确的选择。异常是用来处理程序中非预期、无法恢复的错误，它强制你处理这些问题，否则程序就会终止。

至于返回布尔值和输出参数，它在C风格的API中很常见，但在现代C++中，

std::optional

如何安全地解包std::optional中的值并处理其空状态？

安全地从

std::optional

optional

1. 使用

   has_value()

   登录后复制
   或隐式布尔转换进行检查： 这是最基础也是最直接的方式。在尝试访问值之前，先确认它是否存在。

   std::optional<std::string> maybe_name = get_user_name(); // 假设 get_user_name 返回 optional
   
   if (maybe_name.has_value()) {
       std::cout << "User name: " << *maybe_name << std::endl;
   } else {
       std::cout << "User name not found." << std::endl;
   }
   
   // 隐式布尔转换更简洁
   if (maybe_name) {
       std::cout << "User name (via bool conversion): " << maybe_name.value() << std::endl;
   }

   登录后复制

   在这里，

   *maybe_name

   登录后复制
   和

   maybe_name.value()

   登录后复制
   都可以用来获取值。注意

   value()

   登录后复制
   在

   optional

   登录后复制
   为空时会抛出

   std::bad_optional_access

   登录后复制
   异常，而

   *

   登录后复制
   运算符则会导致未定义行为。因此，务必先检查再访问。

2. 使用

   value_or(default_value)

   登录后复制
   提供默认值： 当

   optional

   登录后复制
   为空时，你可能希望提供一个备用值，而不是处理空状态。

   value_or()

   登录后复制
   就是为此设计的。

   std::optional<int> maybe_score = get_score();
   int actual_score = maybe_score.value_or(0); // 如果没有分数，则默认为0
   std::cout << "Score: " << actual_score << std::endl;
   
   std::optional<std::string> maybe_title;
   std::string title = maybe_title.value_or("Untitled"); // 如果没有标题，则默认为"Untitled"
   std::cout << "Title: " << title << std::endl;

   登录后复制

   这是一个非常实用的方法，它将检查和提供默认值这两个操作合并成一步，代码更简洁。

3. C++17 结构化绑定（Structured Bindings）结合

   if

   登录后复制
   语句： 从C++17开始，你可以将

   std::optional

   登录后复制
   与

   if (auto var = optional_expr)

   登录后复制
   语法结合，使得代码更加紧凑和易读。

   if (std::optional<int> parsed_value = parse_int("456")) {
       std::cout << "Successfully parsed: " << *parsed_value << std::endl;
       // 在这个 if 作用域内，parsed_value 保证有值
   } else {
       std::cout << "Failed to parse." << std::endl;
   }

   登录后复制

   这种模式我个人非常喜欢，它清晰地表达了“如果解析成功，那么在作用域内使用这个值”。

4. C++23 的 monadic 操作 (

   and_then

   登录后复制
   ,

   transform

   登录后复制
   ,

   or_else

   登录后复制
   )： 这些操作允许你以一种链式、函数式的方式处理

   optional

   登录后复制
   。它们在

   optional

   登录后复制
   有值时应用一个函数，或者在没有值时提供一个备用

   optional

   登录后复制
   。

   // 假设我们有一个函数，将字符串转换为大写
   std::optional<std::string> to_uppercase(const std::string& s) {
       std::string upper_s = s;
       for (char& c : upper_s) {
           c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
       }
       return upper_s;
   }
   
   std::optional<std::string> user_input = "hello world";
   std::optional<std::string> processed_input = user_input
       .and_then([](const std::string& s) {
           // 如果 user_input 有值，则尝试解析成 int
           return parse_int(s);
       })
       .transform([](int val) {
           // 如果解析成功，则将 int 转换为字符串并加倍
           return std::to_string(val * 2);
       })
       .or_else([]() {
           // 如果之前的操作链中任何一个 optional 为空，则提供一个备用 optional
           return std::optional<std::string>("Fallback string");
       });
   
   std::cout << "Processed input: " << processed_input.value_or("Nothing processed") << std::endl;
   
   // 另一个例子：如果 user_input 是 "123"，parse_int 返回 123
   // transform 将 123 变为 "246"
   // or_else 不会执行
   // 最终输出 "Processed input: 246"
   
   // 如果 user_input 是 "abc"，parse_int 返回 std::nullopt
   // transform 不会执行
   // or_else 返回 "Fallback string"
   // 最终输出 "Processed input: Fallback string"

   登录后复制

   这些函数式操作在处理复杂逻辑流时，能显著减少

   if/else

   登录后复制
   嵌套，使代码更具可读性和表现力。虽然它们是C++23的特性，但很多现代代码库已经通过自定义工具或使用类似Boost.Optional的库提供了类似的功能。

选择哪种解包方式，取决于你的具体需求：是需要强制处理空状态（

value()

value_or()

optional

以上就是C++如何使用std::optional管理可选值的详细内容，更多请关注php中文网其它相关文章！