如何在C++中使用std::optional_C++ std::optional使用场景与方法

尼克

发布时间：2025-09-22 16:33:01

963人浏览过

来源于php中文网

原创

std::optional通过类型安全的方式明确表达值的存在与否，解决了空指针解引用、魔术数字歧义和布尔标志冗余等问题，提升了代码清晰度与安全性。

如何在c++中使用std::optional_c++ std::optional使用场景与方法

std::optional

在 C++ 中提供了一种优雅且类型安全的方式来表达一个值可能存在，也可能不存在的场景。它避免了使用空指针、魔术数字或额外的布尔标志来表示缺失值所带来的各种问题，让代码的意图更加明确，大大减少了因意外解引用或错误处理空值而导致的运行时错误。简单来说，它就像一个可以装东西的盒子，你一眼就能知道里面有没有东西，而不是猜测盒子是不是空的或者里面是不是装了个“特殊石头”来代表空。

解决方案

使用

std::optional

并不复杂，其核心思想是封装一个可能存在或不存在的值。

1. 声明与初始化： 你可以像声明普通变量一样声明一个

std::optional

。

#include 
#include 
#include 

// 声明一个空的 optional
std::optional maybeInt; 
// 声明并初始化一个包含值的 optional
std::optional maybeString = "Hello Optional!"; 
// 使用 std::nullopt 明确表示一个空的 optional
std::optional maybeDouble = std::nullopt; 

// 也可以直接构造
std::optional anotherInt(123);

2. 检查值是否存在： 这是使用

std::optional

最重要的步骤，因为它强制你考虑值可能不存在的情况。

if (maybeInt.has_value()) {
    std::cout << "maybeInt 有值: " << maybeInt.value() << std::endl;
} else {
    std::cout << "maybeInt 没有值。" << std::endl; // 输出此行
}

// 也可以直接用作布尔表达式，这是更常见的写法
if (maybeString) { // 等同于 maybeString.has_value()
    std::cout << "maybeString 有值。" << std::endl; // 输出此行
}

3. 访问值： 在确认值存在后，你可以通过

value()

方法或解引用操作符

来获取它。

if (maybeString) {
    std::cout << "通过 value() 获取: " << maybeString.value() << std::endl;
    std::cout << "通过 * 操作符获取: " << *maybeString << std::endl;
}

// 注意：如果 optional 为空，调用 .value() 会抛出 std::bad_optional_access 异常。
// 解引用空的 optional 是未定义行为。
// 务必先检查 has_value() 或使用 value_or()。

4. 提供默认值：

value_or()

如果你希望在值不存在时提供一个默认值，

value_or()

是一个非常方便的方法。

std::optional emptyInt;
std::optional fullInt = 42;

int val1 = emptyInt.value_or(0); // val1 为 0
int val2 = fullInt.value_or(100); // val2 为 42

std::cout << "emptyInt.value_or(0): " << val1 << std::endl;
std::cout << "fullInt.value_or(100): " << val2 << std::endl;

5. 结构体/类成员访问：

operator->()

如果

std::optional

包含的是一个类或结构体类型，你可以使用

->

操作符直接访问其成员。

struct Point {
    int x, y;
    void print() const { std::cout << "(" << x << ", " << y << ")" << std::endl; }
};

std::optional p = Point{10, 20};
if (p) {
    p->print(); // 输出 (10, 20)
}

std::optional

解决了C++中哪些常见的“空值”问题？

我个人觉得，

std::optional

最核心的价值在于它彻底改变了我们处理“缺失数据”的方式。在它出现之前，C++开发者处理这种情况，说实话，有点像在走钢丝，一不小心就可能掉下去。

最典型的就是空指针（Null Pointer）问题。想象一下，一个函数可能成功返回一个对象，也可能因为某些原因无法找到或创建该对象。传统的做法是返回一个

nullptr

。然后，调用者就必须时刻记住检查这个指针是否为空，否则，一个不经意的解引用操作就会导致程序崩溃，也就是我们常说的“段错误”。这种错误往往在运行时才暴露出来，调试起来很头疼，而且代码中充斥着大量的

if (ptr != nullptr)

检查，显得冗余。

std::optional

强制你通过

has_value()

或

operator bool()

来显式地处理两种情况，它把“值可能不存在”这个信息编码到了类型系统里，编译器就能帮助你规避这类问题。

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

再来是魔术数字（Magic Number）问题。比如，一个函数返回

int

类型，表示某个索引或数量，但如果找不到或不存在，它可能会返回

-1

。这看起来没问题，但如果

-1

在某些业务逻辑中恰好是一个合法的值呢？这就造成了歧义。更糟糕的是，如果返回值是

unsigned int

，那

-1

根本就不是一个选项，你可能得找一个

UINT_MAX

这样的值，但同样，这可能与某个真实存在的最大值冲突。

std::optional

避免了这种数值上的混淆，它明确地表示“没有值”，而不是用一个特殊的数值来“假装”没有值。

还有就是布尔标志（Boolean Flag）和输出参数（Output Parameter）的组合。某些函数为了表示成功与否，会返回一个

bool

，然后通过一个引用参数来传递实际结果。例如

bool try_get_value(int& out_value)

。这使得函数的签名变得不那么直观，而且调用者需要额外声明一个变量来接收结果。

std::optional get_value()

这种形式则简洁明了，一眼就能看出函数的意图和返回值类型。

所以，

std::optional

并非仅仅是一个语法糖，它是一种设计模式的提升，让代码的意图更清晰，安全性更高，也更符合现代 C++ 的类型安全哲学。它让“缺失值”不再是一个潜在的运行时炸弹，而是一个可以被优雅处理的类型特征。

什么时候应该使用

std::optional

而不是指针或引用？

这真的是一个非常值得深思的问题，因为它触及了 C++ 中数据表示和生命周期管理的核心。在我看来，选择

std::optional

还是指针或引用，关键在于你想要表达的“意图”和“所有权”语义。

std::optional

vs. 裸指针（Raw Pointers）： 当一个函数或对象成员不拥有它所指向的数据，并且该数据可能不存在时，

std::optional

是一个极佳的选择。裸指针，尤其是那些返回的裸指针，往往会带来所有权上的困惑：调用者是否需要

delete

这个指针？如果不需要，那谁来管理它的生命周期？

std::optional

明确表示它包含的是一个值，这个值是按值语义存储的（或者至少是按值语义管理的），不涉及复杂的内存管理责任。

例如，一个查找函数：

```
T* find_item(const std::string& key)
```
：如果没找到，返回
```
nullptr
```
。但如果找到了，调用者是否需要关心
```
T
```
的生命周期？这个
```
T
```
是在堆上分配的吗？
```
std::optional find_item(const std::string& key)
```
：如果没找到，返回
```
std::nullopt
```
。如果找到了，返回一个
```
optional
```
包含
```
T
```
的副本（或移动后的
```
T
```
）。调用者只关心
```
T
```
这个值本身，不关心它的内存管理。这在我看来，大大简化了接口设计和使用。

std::optional

vs. 引用（References）： 引用和

std::optional

的区别非常明确：引用必须引用一个已经存在的对象，它不能是空的。如果你试图让一个引用引用空，那将是编译错误或未定义行为。因此，如果你的设计中，某个值可能不存在，那么引用根本就不是一个选项。引用通常用于传递参数，确保参数始终有效，或者用于别名。

std::optional

vs. 智能指针（Smart Pointers，如
std::unique_ptr
/
std::shared_ptr
）：智能指针是关于所有权和生命周期管理的。

std::unique_ptr

表示独占所有权，

std::shared_ptr

表示共享所有权。

如果你有一个可能不存在的、动态分配的对象，并且你希望管理它的生命周期，那么
```
std::unique_ptr
```
或
```
std::shared_ptr
```
仍然是首选。它们在内部处理了
```
nullptr
```
的情况，并且提供了安全的内存释放机制。
```
std::optional
```
关注的是值的存在性，而不是值的内存管理方式。你完全可以拥有一个
```
std::optional>
```
，这表示“可能有一个我独占拥有的
```
MyObject
```
”。但这通常意味着你的设计可能有点复杂，需要仔细斟酌。更多时候，如果
```
MyObject
```
是一个值类型，直接用
```
std::optional
```
就足够了。

总结一下我的看法：

用
std::optional
：当你想表达一个“值”可能存在也可能不存在，且不涉及所有权转移时。它让函数的返回值或类的成员变量的语义更清晰。
用裸指针： 极少使用，通常只在与 C API 交互、或者明确知道其生命周期被外部管理且不会有所有权问题时。
用引用： 当你确信一个值始终存在，并且只是想为它创建一个别名，或者作为函数参数传递时。
用智能指针： 当你需要在堆上管理对象的生命周期，并明确表达所有权语义时。

选择的关键在于，

std::optional

把“缺失”这个概念提升到了类型层面，让编译器帮你做更多检查，而不是把这个责任完全推给程序员。

std::optional

的性能开销和最佳实践是什么？

关于

std::optional

的性能开销，这确实是开发者在引入新特性时会考虑的一个点。不过，我个人的经验是，在绝大多数应用场景下，

std::optional

带来的性能开销是可以忽略不计的，甚至在某些情况下，由于其更好的代码清晰度和减少的错误，反而能间接提升整体性能（减少调试时间，优化代码逻辑）。

燕雀Logo

为用户提供LOGO免费设计在线生成服务

下载

1. 性能开销分析：

内存占用：
```
std::optional
```
通常会占用
```
sizeof(T)
```
加上一个
```
bool
```
类型的空间（用于表示值是否存在），再加上可能的内存对齐填充。所以，它会比
```
T
```
本身稍微大一点。对于
```
T
```
是一个非常小的类型（比如
```
bool
```
或
```
char
```
）时，这个额外的
```
bool
```
可能会显得比例较大。但对于大多数自定义类型或较大的内置类型，这点额外空间影响微乎其微。
- 值得一提的是，C++ 标准允许编译器对
```
std::optional
```
  进行优化。如果
```
T
```
  满足某些条件（例如，
```
T
```
  是一个可以表示“空”状态的类型，比如
```
std::string
```
  可以是空字符串，或者
```
T
```
  是一个指针类型，可以为
```
nullptr
```
  ），那么
```
std::optional
```
  可能会被优化成只占用
```
sizeof(T)
```
  的空间，通过
```
T
```
  自身的某个特殊状态来表示“空”。但这取决于具体的编译器实现和
```
T
```
  的类型。
运行时开销：
- 构造/析构：
```
std::optional
```
  的构造和析构会涉及其内部
```
T
```
  对象的构造和析构，以及
```
bool
```
  标志的设置。如果
```
T
```
  是一个昂贵的类型，那么
```
optional
```
  也会继承这份开销。
- 访问值： 访问
```
std::optional
```
  中的值（例如通过
```
value()
```
  或
```
*
```
  ）通常会涉及一个条件检查（
```
has_value()
```
  ），这可能会导致一次分支预测，但现代 CPU 的分支预测能力很强，通常不会造成显著性能瓶颈。

2. 最佳实践：

作为函数返回值： 这是
```
std::optional
```
最常见且最推荐的用法。当一个函数可能无法产生一个有效结果时，返回
```
std::optional
```
比返回
```
nullptr
```
、魔术数字或使用输出参数要清晰和安全得多。
作为类成员变量： 如果一个类的某个成员变量在其生命周期内可能不会被初始化，或者其状态是“可选的”，那么使用
```
std::optional
```
是一个非常好的选择。例如，一个用户配置文件对象，其“头像 URL”可能不是每个用户都有。
避免作为函数参数（通常情况下）： 除非参数本身就代表一个“可选的输入值”，并且传递
```
std::nullopt
```
是一种明确的意图，否则通常不建议将
```
std::optional
```
作为函数参数。
- 如果参数是可选的，但你只是想避免复制，可以考虑
```
std::optional>
```
  ，但这会增加复杂性。
- 更常见的做法是函数重载，提供有参数和无参数的版本，或者使用默认参数。
避免过度嵌套
```
std::optional
```
：比如
```
std::optional>
```
。这通常意味着设计上可能存在一些冗余或者可以简化的地方。双重
```
optional
```
意味着“可能有一个可选的值”，这听起来有点绕，通常一个
```
optional
```
就足以表达“值可能不存在”了。
明智使用
```
value_or()
```
：
```
value_or()
```
在提供简单默认值时非常方便。但如果默认值需要复杂的计算，或者其语义与“值不存在”有较大区别，那么使用
```
if (opt.has_value()) { /* ... */ } else { /* ... */ }
```
结构会更清晰，避免不必要的计算。

利用 C++23 的 monadic 操作： 如果你的编译器支持 C++23，

std::optional

提供了

and_then

、

or_else

、

transform

等 monadic 操作。这些操作可以让你以更函数式、更链式的方式处理

optional

值，避免嵌套的

if

语句，使代码更简洁、更具表达力。

// 假设 get_user_id 返回 std::optional
// get_user_name 返回 std::optional
// find_profile 返回 std::optional
auto profile = get_user_id()
                .and_then([](int id){ return get_user_name(id); }) // 如果有id，继续获取name
                .and_then([](const std::string& name){ return find_profile(name); }); // 如果有name，继续查找profile

if (profile) {
    profile->display();
}

这是一种非常优雅的处理流程，避免了层层嵌套的