C++ 23 标准库新特性：std::optional 的正确使用姿势

引言：告别空指针时代

在 C++ 的漫长历史中，空指针一直是开发者最头疼的问题之一。`nullptr`、`NULL`、异常处理、错误码……各种方案层出不穷。

2017 年，C++17 带来了 `std::optional`，终于为我们提供了一个类型安全的空值表示方式。而到了 2023 年，C++23 进一步增强了这个工具。

今天这篇教程将带你彻底掌握 `std::optional` 的使用方法，让你的 C++ 代码更加安全、优雅。

第一章：std::optional 是什么？

1.1 基本概念

“`cpp
// std::optional 表示：一个 T 类型的值，或者没有值
#include

std::optional number; // 没有值（nullopt）
std::optional value(42); // 有值 42

// 可以显式检查
if (number.has_value()) {
// 有值
}

// 或者使用 if 简写
if (number) {
// 有值
}

核心思想： 将"空值"变成类型系统的一部分，而不是隐式的指针空值。

1.2 为什么需要 optional？


  

    
方案
    
优点
    
缺点
  
  

    
空指针
    
简洁
    
类型不安全，需要额外检查
  
  

    
异常
    
类型安全
    
性能开销大，可能意外抛出
  
  

    
错误码
    
明确
    
容易忘记检查
  
  

    
std::optional
    
类型安全、明确、零开销
    
需要 C++17+
  


第二章：std::optional 基础用法

2.1 创建与初始化

cpp
#include
#include

int main() {
// 1. 默认构造：空值
std::optional opt1;

// 2. 显式 nullopt
std::optional opt2 = std::nullopt;

// 3. 直接初始化值
std::optional opt3(42);
std::optional opt4{99};

// 4. 从另一个 optional 构造
std::optional opt5 = opt3;

// 5. 从值构造
std::optional opt6(100);

std::cout << "opt1 has_value: " << opt1.has_value() << "\n"; std::cout << "opt3 value: " << opt3.value() << "\n"; return 0; }

2.2 访问值

cpp
std::optional findName(int id) {
if (id == 1) return std::string(“Alice”);
return std::nullopt;
}

void accessValue() {
auto name = findName(1);

// 方法 1：has_value() + value()
if (name.has_value()) {
std::cout << name.value() << "\n"; } // 方法 2：直接使用 if 检查 if (name) { std::cout << name.value() << "\n"; } // 方法 3：value_or - 提供默认值 std::string displayName = name.value_or("Unknown"); std::cout << displayName << "\n"; // 方法 4：value() - 抛出异常如果为空 try { std::string safeName = name.value(); std::cout << safeName << "\n"; } catch (const std::bad_optional_access& e) { std::cout << "Value not set!\n"; } }

2.3 修改值

cpp
void modifyValue() {
std::optional opt;

// 赋值
opt = 42;
opt = std::nullopt;

// emplace – 原地构造
opt.emplace(100);

// 重置为 nullopt
opt.reset();

// 交换
std::optional opt2(50);
std::swap(opt, opt2);
}

第三章：C++23 新增特性

3.1 consteval operator[]

C++23 为 `std::optional` 添加了 `consteval operator[]`，允许在常量表达式中访问 optional 的值：

cpp
#include
#include

constexpr int getValue(std::optional opt) {
return *opt; // C++23 允许
}

int main() {
constexpr std::optional opt(42);

// C++23 允许在编译期计算
constexpr int value = getValue(opt);

std::cout << "Value: " << value << "\n"; // 注意：访问空 optional 在编译期未定义行为 // constexpr std::optional empty;
// constexpr int emptyValue = *empty; // 错误！
}

3.2 隐式转换限制

C++23 加强了 `std::optional` 的隐式转换限制，避免意外的类型转换：

cpp
// C++17 允许：std::optional 到 bool 的隐式转换
void printBool(bool b) {
std::cout << b << "\n"; } // 以下在 C++17 可以编译 // printBool(opt); // 隐式转换为 bool // C++23 需要显式转换 printBool(static_cast(opt));

// 或者
printBool(opt.has_value());

3.3 更好的与范围配合

C++23 改进了 `std::optional` 与 C++20 范围的配合：

cpp
#include
#include
#include
#include

std::optional parseNumber(const std::string& str) {
try {
return std::stoi(str);
} catch (…) {
return std::nullopt;
}
}

void processWithRanges() {
std::vector strings = {“1”, “2”, “three”, “4”};

// C++23：可以过滤掉 nullopt 结果
auto numbers = strings |
std::views::transform(parseNumber) |
std::views::filter([](const auto& opt) {
return opt.has_value();
}) |
std::views::transform([](auto& opt) {
return *opt;
});

for (int num : numbers) {
std::cout << num << " "; } // 输出：1 2 4 }

第四章：实际应用场景

4.1 安全返回值

cpp
// 查找元素，如果没有则返回 nullopt
std::optional findUserById(int id,
const std::vector& users) {
for (const auto& user : users) {
if (user.id == id) {
return user.name;
}
}
return std::nullopt;
}

// 对比传统方式：
// – 异常：性能开销大
// – 错误码：容易忘记检查
// – 指针：需要额外检查空值

4.2 可选参数

cpp
class Config {
public:
void setValue(const std::optional& value) {
if (value.has_value()) {
configValue = value.value();
hasValue = true;
}
}

private:
int configValue;
bool hasValue = false;
};

// 使用
Config config;
config.setValue(42); // 设置值
config.setValue(std::nullopt); // 清除值

4.3 链式计算

cpp
std::optional compute() {
// 多个步骤都可能失败
auto step1 = validateInput();
if (!step1) return std::nullopt;

auto step2 = processValue(*step1);
if (!step2) return std::nullopt;

auto step3 = finalizeResult(*step2);
if (!step3) return std::nullopt;

return step3;
}

// C++23：使用 if 绑定简化
std::optional computeWithBind() {
auto [step1] = validateInput();
if (!step1) return std::nullopt;

auto [step2] = processValue(*step1);
if (!step2) return std::nullopt;

return finalizeResult(*step2);
}

第五章：最佳实践

5.1 何时使用 optional

✅ 推荐使用：

函数可能没有返回值
参数是可选的
从缓存或数据库获取数据
需要表示"未设置"的状态


❌ 不推荐使用：

值永远不应该为空
简单的布尔状态
性能极度敏感的场景


5.2 返回值约定

cpp
// ✅ 好的返回值设计
std::optional findUser(int id);
std::optional getConfigValue(const std::string& key);

// ❌ 糟糕的设计
User* findUser(int id); // 空指针？
User& findUser(int id); // 引用空对象？

5.3 访问模式

cpp
// ✅ 推荐模式
void processValue(std::optional opt) {
if (auto value = opt) {
std::cout << *value << "\n"; } } // ✅ 使用 value_or 提供默认值 int safeValue = opt.value_or(0); // ❌ 避免频繁使用 value() int value = opt.value(); // 可能抛出异常

5.4 与 std::variant 结合

cpp
#include
#include

// optional 表示”有值或无值”
std::optional maybeValue;

// variant 表示”多种可能类型之一”
std::variant value;

// 组合使用：返回多种可能类型或无值
using Result = std::variant;

Result process(int input) {
if (input < 0) return std::nullopt; if (input % 2 == 0) return input * 2; return std::to_string(input); } // 使用 Result result = process(10); if (std::holds_alternative(result)) {
std::cout << "No value\n"; } else if (std::holds_alternative(result)) {
std::cout << "Result: " << std::get(result) << "\n"; }

第六章：性能对比

6.1 空间开销

cpp
#include
#include

int main() {
std::cout << "sizeof(std::optional): ”
<< sizeof(std::optional) << "\n"; // 通常：sizeof(int) + 1 (可能对齐到 4 或 8) std::cout << "sizeof(int): " << sizeof(int) << "\n"; // 空 optional 的空间开销很小 // 通常只增加 1 字节的标记位 }

6.2 时间性能

cpp
#include
#include
#include

int main() {
std::optional opt(42);

// 方法 1：has_value() + value()
auto start1 = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 10000000; i++) { if (opt.has_value()) { int val = opt.value(); } } auto end1 = std::chrono::high_resolution_clock::now(); // 方法 2：直接使用 if auto start2 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < 10000000; i++) { if (opt) { int val = opt.value(); } } auto end2 = std::chrono::high_resolution_clock::now(); std::cout << "has_value + value: " << std::chrono::duration_cast(
end1 – start1).count() << " ms\n"; std::cout << "if + value: " << std::chrono::duration_cast(
end2 – start2).count() << " ms\n"; // 性能差异极小，主要取决于编译器优化 }

第七章：C++17 vs C++23 对比

7.1 常量表达式支持

cpp
// C++17：constexpr optional
constexpr std::optional opt(42);
constexpr bool hasValue = opt.has_value();
// ❌ 不能解引用：*opt 在 constexpr 上下文

// C++23：更好的 constexpr 支持
constexpr int value = *opt; // ✅ 允许

7.2 隐式转换

cpp
// C++17
std::optional opt(true);
bool b = opt; // ✅ 隐式转换为 bool

// C++23
bool b2 = opt; // ❌ 需要显式转换
bool b3 = static_cast(opt); // ✅ 正确

7.3 与范围算法配合

cpp
// C++17：需要手动过滤
std::vector> options = {1, 2, std::nullopt, 3};
std::vector values;
for (const auto& opt : options) {
if (opt) values.push_back(*opt);
}

// C++23：更好的范围配合
auto values = options |
std::views::filter([](const auto& opt) { return opt.has_value(); }) |
std::views::transform([](const auto& opt) { return *opt; });

7.4 错误处理

cpp
// C++17：value() 抛出 bad_optional_access
int getValue(std::optional opt) {
return opt.value(); // 可能抛出异常
}

// C++23：更明确的 API
int getValue(std::optional opt) {
if (auto value = opt) {
return *value;
}
throw std::runtime_error(“No value”);
}

第八章：实战案例

8.1 文件读取

cpp
#include
#include
#include

std::optional readFile(const std::string& path) {
std::ifstream file(path);
if (!file.is_open()) {
return std::nullopt;
}

std::string content((std::istreambuf_iterator(file)),
std::istreambuf_iterator());
return content;
}

// 使用
auto content = readFile(“config.txt”);
if (content) {
processContent(*content);
} else {
handleFileError();
}

8.2 配置解析

cpp
#include
#include
#include

class Config {
public:
std::optional getPort() const {
auto it = values.find(“port”);
if (it != values.end()) {
return std::stoi(it->second);
}
return std::nullopt;
}

std::optional getDebugMode() const {
auto it = values.find(“debug”);
if (it != values.end()) {
return it->second == “true”;
}
return std::nullopt;
}

private:
std::unordered_map values;
};

8.3 数据库查询

cpp
#include
#include

struct User {
int id;
std::string name;
std::string email;
};

std::optional findUserById(int id) {
// 数据库查询
auto result = queryDatabase(“SELECT * FROM users WHERE id = ?”, id);

if (result.empty()) {
return std::nullopt;
}

return User{
id,
result[0][“name”],
result[0][“email”]
};
}

// 使用
auto user = findUserById(1);
if (user) {
std::cout << "Found: " << user->name << "\n"; }

第九章：常见问题与陷阱

9.1 不要存储裸指针

cpp
// ❌ 错误：optional 不应该包含裸指针
class Cache {
std::optional cache; // 所有权不清晰
};

// ✅ 正确：使用 unique_ptr 或 value
class Cache {
std::optional cache; // 值语义
// 或者
std::optional> cache;
};

9.2 避免嵌套 optional

cpp
// ❌ 过于复杂
std::optional> getValue();

// ✅ 简化
std::optional getValue(); // nullopt 已经表示”无值”

9.3 不要滥用 value()

cpp
// ❌ 可能抛出异常
int value = opt.value();

// ✅ 检查后访问
if (opt) {
int value = *opt;
}

// ✅ 使用 value_or
int value = opt.value_or(defaultValue);
“`

总结：正确使用 optional

`std::optional` 是 C++17/23 最实用的特性之一，它让我们能够：

1. 类型安全地表示空值：避免空指针陷阱
2. 明确表达语义：函数返回值明确表示可能为空
3. 零性能开销：使用 optional 不牺牲性能
4. 简洁的语法：if 绑定、value_or 等便捷 API

最佳实践总结：

• ✅ 返回值可能为空时使用
• ✅ 参数可选时使用
• ✅ 避免嵌套 optional
• ✅ 谨慎使用 value()
• ✅ 利用 C++23 新特性

掌握 `std::optional`，让你的 C++ 代码更加安全、清晰、现代化！🚀

—

参考资源：

• [C++17 std::optional](https://en.cppreference.com/w/cpp/utility/optional)
• [C++23 optional improvements](https://isocpp.org/blog/2022/12/n4950)
• [cppreference – optional](https://en.cppreference.com/w/cpp/utility/optional)
• [Effective Modern C++](https://www.oreilly.com/library/view/effective-modern-c/9781491950101/)
打赏赞微海报分享