010 《Folly Try.h 权威指南：C++ 异常处理的现代实践》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 走进 Folly Try.h (走进 Folly Try.h)
▮▮▮▮▮▮▮ 1.1 什么是 Folly Try.h (什么是 Folly Try.h)
▮▮▮▮▮▮▮ 1.2 Try.h 的设计哲学与优势 (Try.h 的设计哲学与优势)
▮▮▮▮▮▮▮ 1.3 Try.h 与传统 C++ 异常处理的对比 (Try.h 与传统 C++ 异常处理的对比)
▮▮▮▮▮▮▮ 1.4 Try.h 的适用场景与局限性 (Try.h 的适用场景与局限性)
▮▮▮▮ 2. chapter 2： Folly Try.h 基础入门 (Folly Try.h 基础入门)
▮▮▮▮▮▮▮ 2.1 Try 对象的创建与初始化 (Try 对象的创建与初始化)
▮▮▮▮▮▮▮ 2.2 判断 Try 对象的状态：成功与失败 (判断 Try 对象的状态：成功与失败)
▮▮▮▮▮▮▮ 2.3 获取 Try 对象的值或异常 (获取 Try 对象的值或异常)
▮▮▮▮▮▮▮ 2.4 Try 的基本操作：map, flatMap, or, orElse (Try 的基本操作：map, flatMap, or, orElse)
▮▮▮▮▮▮▮▮▮▮▮ 2.4.1 map：转换 Try 成功的值 (map：转换 Try 成功的值)
▮▮▮▮▮▮▮▮▮▮▮ 2.4.2 flatMap：链式操作与 Try 的组合 (flatMap：链式操作与 Try 的组合)
▮▮▮▮▮▮▮▮▮▮▮ 2.4.3 or 与 orElse：提供备选值 (or 与 orElse：提供备选值)
▮▮▮▮▮▮▮ 2.5 Try 与函数式编程 (Try 与函数式编程)
▮▮▮▮ 3. chapter 3： Folly Try.h 实战应用 (Folly Try.h 实战应用)
▮▮▮▮▮▮▮ 3.1 使用 Try 处理可能失败的函数 (使用 Try 处理可能失败的函数)
▮▮▮▮▮▮▮ 3.2 Try 在资源管理中的应用 (Try 在资源管理中的应用)
▮▮▮▮▮▮▮ 3.3 Try 与异步编程 (Try 与异步编程)
▮▮▮▮▮▮▮ 3.4 Try 在错误传播与聚合中的应用 (Try 在错误传播与聚合中的应用)
▮▮▮▮▮▮▮ 3.5 案例分析：使用 Try 构建健壮的应用程序 (案例分析：使用 Try 构建健壮的应用程序)
▮▮▮▮ 4. chapter 4： Folly Try.h 高级进阶 (Folly Try.h 高级进阶)
▮▮▮▮▮▮▮ 4.1 自定义异常类型与 Try (自定义异常类型与 Try)
▮▮▮▮▮▮▮ 4.2 Try 的性能考量与优化 (Try 的性能考量与优化)
▮▮▮▮▮▮▮ 4.3 Try 与其他 Folly 组件的集成 (Try 与其他 Folly 组件的集成)
▮▮▮▮▮▮▮ 4.4 Try 的高级错误处理模式 (Try 的高级错误处理模式)
▮▮▮▮▮▮▮ 4.5 深入源码：Try 的实现原理分析 (深入源码：Try 的实现原理分析)
▮▮▮▮ 5. chapter 5： Folly Try.h API 全面解析 (Folly Try.h API 全面解析)
▮▮▮▮▮▮▮ 5.1 folly::Try 类详解 (folly::Try 类详解)
▮▮▮▮▮▮▮ 5.2 Try 的工厂函数与辅助函数 (Try 的工厂函数与辅助函数)
▮▮▮▮▮▮▮ 5.3 Try 的操作符重载 (Try 的操作符重载)
▮▮▮▮▮▮▮ 5.4 Try 的相关类型与定义 (Try 的相关类型与定义)
▮▮▮▮ 6. chapter 6： 最佳实践与常见问题 (最佳实践与常见问题)
▮▮▮▮▮▮▮ 6.1 Try 的编码规范与最佳实践 (Try 的编码规范与最佳实践)
▮▮▮▮▮▮▮ 6.2 常见错误与陷阱 (常见错误与陷阱)
▮▮▮▮▮▮▮ 6.3 Try 的调试技巧 (Try 的调试技巧)
▮▮▮▮▮▮▮ 6.4 Try 在大型项目中的应用经验 (Try 在大型项目中的应用经验)
▮▮▮▮ 7. chapter 7： 总结与展望 (总结与展望)
▮▮▮▮▮▮▮ 7.1 Folly Try.h 的价值回顾 (Folly Try.h 的价值回顾)
▮▮▮▮▮▮▮ 7.2 Try.h 的未来发展趋势 (Try.h 的未来发展趋势)
▮▮▮▮▮▮▮ 7.3 持续学习 Folly 与 C++ 现代编程 (持续学习 Folly 与 C++ 现代编程)
1. chapter 1： 走进 Folly Try.h (走进 Folly Try.h)
1.1 什么是 Folly Try.h (什么是 Folly Try.h)
在现代 C++ 开发中，处理错误和异常情况是构建健壮、可靠软件的关键环节。传统上，C++ 依赖于异常处理机制（Exception Handling）来管理运行时错误。然而，随着函数式编程范式的兴起以及对代码可预测性和清晰度的更高要求，出现了一些新的错误处理模式。Folly Try.h 正是 Facebook Folly 库提供的一种替代性错误处理方案，它旨在以更加显式和可控的方式来处理可能失败的操作。
Folly 是 "Facebook Open Source Library" 的缩写，它是一个由 Facebook 开发和维护的、高度模块化的 C++ 库集合。Try.h 作为 Folly 库中的一个组件，提供了一个名为 folly::Try 的类模板。这个类模板代表了一个可能成功也可能失败的计算结果。
简单来说，folly::Try<T> 可以被看作是一个容器，它可能包含以下两种状态之一：
⚝ 成功状态（Success）： 容器内含有一个类型为 T 的值，表示操作成功完成并返回了预期的结果。
⚝ 失败状态（Failure）： 容器内含有一个异常对象，表示操作失败，并且包含了描述失败原因的异常信息。
与传统的 C++ 异常处理不同，Try.h 不依赖于隐式的异常抛出和捕获机制。相反，它将错误处理显式地融入到函数的返回类型中。当一个函数可能失败时，它不再直接抛出异常，而是返回一个 Try<T> 对象。调用者可以通过检查 Try 对象的状态来显式地处理成功或失败的情况。
Try.h 的核心目标是：
⚝ 显式错误处理（Explicit Error Handling）： 通过 Try<T> 返回类型，明确地告知调用者该函数可能失败，并迫使调用者考虑和处理失败情况。
⚝ 函数式错误处理（Functional Error Handling）： 提供 map、flatMap、or、orElse 等函数式操作，使得错误处理可以像处理数据一样进行链式组合和转换，从而编写出更加简洁和易于理解的代码。
⚝ 避免异常的隐式控制流（Avoid Implicit Control Flow of Exceptions）： 减少对异常的过度依赖，避免异常穿透调用栈带来的性能开销和代码可读性问题，使得错误处理的控制流更加局部化和可预测。
总而言之，Folly Try.h 提供了一种更加可控、显式和函数式的错误处理方式，它鼓励开发者在设计程序时，将错误处理作为正常逻辑的一部分来考虑，从而提高代码的健壮性和可维护性。对于追求代码清晰度、性能敏感以及函数式编程风格的 C++ 项目来说，Try.h 是一个非常有价值的工具。
1.2 Try.h 的设计哲学与优势 (Try.h 的设计哲学与优势)
Folly Try.h 的设计哲学根植于对传统 C++ 异常处理机制的反思以及对函数式编程范式的借鉴。其核心理念可以概括为“显式、可控、函数式”。 这种设计哲学带来了诸多优势，使得 Try.h 在错误处理方面表现出色。
设计哲学：
⚝ 显式性（Explicitness）： Try.h 强调错误处理的显式性。传统的 C++ 异常处理是隐式的，异常的抛出和捕获可能发生在代码执行路径上的任何地方，这使得代码的控制流变得复杂和难以预测。Try.h 通过将错误处理纳入函数返回类型，迫使开发者显式地考虑和处理错误情况。Try<T> 的返回类型本身就明确地表明了函数可能失败，这是一种类型级别的显式。
⚝ 可控性（Controllability）： Try.h 提供了更精细的错误处理控制。开发者可以根据具体需求，选择合适的 Try 操作（如 map, flatMap, or, orElse 等）来处理成功或失败的情况。这种控制是局部的、可组合的，避免了异常处理中常见的“一刀切”式的全局捕获。开发者可以精确地控制错误处理的范围和方式，使得错误处理逻辑更加清晰和可维护。
⚝ 函数式（Functional）： Try.h 借鉴了函数式编程中 Result 或 Either 类型的概念。它将计算结果和错误信息统一封装在 Try<T> 对象中，并提供了一系列函数式操作，如 map, flatMap 等。这些操作允许开发者以链式调用的方式处理 Try 对象，将错误处理逻辑与业务逻辑流畅地结合起来。函数式编程强调纯函数和不可变性，Try.h 的设计也鼓励编写更加纯粹和可测试的代码。
优势：
⚝ 提升代码可读性和可维护性（Improved Code Readability and Maintainability）： 显式的错误处理使得代码的意图更加清晰。通过查看函数签名，开发者可以立即知道该函数是否可能失败，以及需要如何处理失败情况。函数式的链式操作使得错误处理逻辑更加紧凑和易于理解。相比于散落在代码各处的 try-catch 块，使用 Try.h 可以显著提升代码的可读性和可维护性。
⚝ 增强错误处理的健壮性（Enhanced Robustness of Error Handling）： Try.h 鼓励开发者在设计阶段就充分考虑错误处理。通过显式地处理 Try 对象，可以避免忽略错误或者错误处理不当的情况。Try.h 提供的 or, orElse 等操作可以方便地提供备选值或默认行为，增强程序的容错能力。
⚝ 更精细的错误控制和传播（Finer-grained Error Control and Propagation）： Try.h 允许开发者在不同的层级和模块之间灵活地控制错误的传播。可以使用 map 或 flatMap 将错误转换为不同的类型，或者使用 or 或 orElse 恢复错误。这种精细的控制使得错误处理更加灵活和适应复杂的应用场景。
⚝ 与函数式编程范式更好地融合（Better Integration with Functional Programming Paradigm）： Try.h 与函数式编程的思想高度契合。它提供的函数式操作使得开发者可以更容易地编写函数式风格的 C++ 代码。在函数式编程中，错误处理通常被视为函数组合的一部分，Try.h 正好提供了这种能力。
⚝ 潜在的性能优势（Potential Performance Benefits）： 在某些情况下，使用 Try.h 可以带来性能优势。传统的 C++ 异常处理在抛出和捕获异常时，会产生一定的性能开销，尤其是在异常不常发生的情况下，这种开销显得不必要。Try.h 避免了隐式的异常抛出和捕获，只在需要时才创建异常对象，这可以减少不必要的性能损耗。当然，性能的提升与具体的应用场景和代码实现有关，需要具体分析。
总而言之，Folly Try.h 的设计哲学和优势使其成为现代 C++ 错误处理的一个有力选择。它通过显式性、可控性和函数式特性，提升了代码的可读性、健壮性和可维护性，并与函数式编程范式更好地融合。
1.3 Try.h 与传统 C++ 异常处理的对比 (Try.h 与传统 C++ 异常处理的对比)
Folly Try.h 和传统的 C++ 异常处理机制都是用于处理程序运行时错误的方法，但它们在设计理念、使用方式和适用场景上存在显著差异。理解这些差异有助于开发者根据具体情况选择合适的错误处理策略。
| 特性/方面 | 传统 C++ 异常处理 (Exception Handling) | Folly Try.h |
|---|---|---|
| 错误表示方式 | 隐式：通过抛出和捕获异常对象 | 显式：通过 folly::Try<T> 返回类型封装结果和异常 |
| 控制流 | 隐式：异常抛出导致控制流跳转到最近的 catch 块 | 显式：控制流由开发者通过 Try 对象的操作显式控制 |
| 错误处理时机 | 运行时：在异常抛出时处理 | 编译时和运行时：函数签名明确错误可能性，运行时显式处理 Try 对象 |
| 函数签名 | 函数签名不直接表明是否可能抛出异常 | 函数签名通过 Try<T> 返回类型明确表明可能失败 |
| 代码可读性 | try-catch 块可能分散在代码中，控制流复杂 | 错误处理逻辑集中，函数式操作链式调用，代码更清晰 |
| 性能开销 | 异常抛出和捕获可能带来性能开销，即使在正常情况下 | 避免了隐式异常处理的开销，性能更可预测 |
| 函数式编程 | 与函数式编程范式结合不够紧密 | 与函数式编程范式高度契合，提供 map, flatMap 等操作 |
| 适用场景 | 适用于处理异常情况，例如不可恢复的错误、资源耗尽等 | 适用于处理可预期的失败，例如业务逻辑错误、输入验证失败等 |
| 错误类型 | 可以抛出任何类型的异常对象 | 异常类型受限，通常使用 std::exception 或自定义异常类型 |
| 错误传播 | 异常可以跨越函数调用栈传播 | 错误传播更加局部化，通过 Try 对象显式传递 |
| 调试难度 | 异常的隐式控制流可能增加调试难度 | 显式的错误处理流程，更易于调试和追踪错误 |
更详细的对比说明：
⚝ 显式 vs. 隐式错误表示： 传统异常处理是隐式的，函数签名无法直接告知调用者是否会抛出异常。开发者需要阅读函数文档或代码才能了解潜在的异常。而 Try.h 是显式的，Try<T> 返回类型明确地表明函数可能失败，这是一种类型系统级别的显式。
⚝ 控制流的差异： 传统异常处理通过 throw 关键字抛出异常，控制流会立即跳转到最近的 catch 块，这是一种非局部跳转。这种隐式的控制流跳转可能使得代码的执行路径变得难以追踪。Try.h 则完全避免了这种隐式控制流。错误处理的控制流完全由开发者通过 Try 对象的操作来显式控制，例如使用 match、map、flatMap 等方法来处理成功或失败的情况。
⚝ 错误处理时机的不同： 传统异常处理主要在运行时处理错误，只有当异常被抛出时，才会触发错误处理逻辑。Try.h 则在编译时和运行时都发挥作用。编译时，Try<T> 返回类型作为函数签名的一部分，提醒开发者注意错误可能性。运行时，开发者需要显式地处理 Try 对象，检查其状态并采取相应的措施。
⚝ 代码可读性和维护性： 过度使用异常处理可能导致代码中散布着大量的 try-catch 块，使得代码结构复杂，控制流混乱。Try.h 通过函数式操作和链式调用，可以将错误处理逻辑集中起来，使得代码更加简洁和易于理解。
⚝ 性能考量： 异常处理在某些情况下可能带来性能开销。即使在没有异常抛出的情况下，编译器也需要生成额外的代码来支持异常处理机制。当异常被抛出时，堆栈展开（Stack Unwinding）等操作会消耗更多资源。Try.h 避免了隐式的异常处理开销，只在需要时才创建异常对象，这在性能敏感的应用中可能具有优势。
⚝ 函数式编程的契合度： Try.h 与函数式编程范式更加契合。函数式编程强调纯函数、不可变性和函数组合。Try.h 提供的 map, flatMap 等操作正是函数式编程中常用的工具，可以方便地进行函数组合和错误处理。
总结：
| 对比维度 | 传统 C++ 异常处理 | Folly Try.h | 推荐使用场景 ⚝ Try.h 是一种用于处理可能失败操作的显式错误处理机制，它与传统的 C++ 异常处理机制形成对比，提供了更可控、更函数式的错误处理方式。
⚝ 传统 C++ 异常处理 依赖于隐式的异常抛出和捕获，控制流可能跳转到远处的 catch 块，有时会使代码的控制流变得复杂和难以预测。
⚝ Try.h 通过 folly::Try<T> 类型显式地表示操作可能成功或失败，并将错误处理纳入函数返回类型，迫使开发者显式地处理错误情况。
⚝ 选择建议：
▮▮▮▮⚝ 对于异常情况（例如，程序逻辑错误、资源耗尽等非预期的、不可恢复的错误），传统的 C++ 异常处理仍然是合适的选择。
▮▮▮▮⚝ 对于可预期的失败（例如，输入验证失败、文件不存在、网络请求超时等预期的、可处理的错误），Try.h 提供了更优雅、更可控的解决方案。在这些场景下，使用 Try.h 可以提高代码的可读性、健壮性和可维护性。
1.4 Try.h 的适用场景与局限性 (Try.h 的适用场景与局限性)
Folly Try.h 作为一个强大的错误处理工具，在很多场景下都能发挥其优势。然而，如同任何技术一样，Try.h 也有其适用范围和局限性。了解这些适用场景和局限性，可以帮助开发者更好地判断何时以及如何使用 Try.h。
适用场景：
⚝ 函数可能返回失败的情况： Try.h 最直接的应用场景就是处理那些可能失败的函数。例如，文件读取、网络请求、数据库查询、数据解析等操作都可能因为各种原因失败。使用 Try<T> 作为这些函数的返回类型，可以显式地表示函数可能失败，并迫使调用者处理失败情况。
1
#include <folly/Try.h>
2
#include <fstream>
3
#include <string>
4
5
folly::Try<std::string> readFile(const std::string& filename) {
6
std::ifstream file(filename);
7
if (!file.is_open()) {
8
return folly::make_exception_ptr<std::runtime_error>("Failed to open file: " + filename);
9
}
10
std::string content;
11
std::getline(file, content);
12
return content;
13
}
14
15
void processFile() {
16
folly::Try<std::string> contentTry = readFile("example.txt");
17
if (contentTry.isSuccess()) {
18
std::string content = contentTry.value();
19
// 处理文件内容
20
std::cout << "File content: " << content << std::endl;
21
} else {
22
std::exception_ptr exPtr = contentTry.exception();
23
try {
24
std::rethrow_exception(exPtr);
25
} catch (const std::exception& e) {
26
std::cerr << "Error reading file: " << e.what() << std::endl;
27
}
28
}
29
}
⚝ 需要链式操作和函数组合的场景： Try.h 提供的 map, flatMap 等函数式操作非常适合链式调用和函数组合。当需要对可能失败的操作进行一系列处理时，使用 Try.h 可以将错误处理逻辑融入到链式调用中，使得代码更加简洁和流畅。
1
#include <folly/Try.h>
2
#include <string>
3
4
folly::Try<int> stringToInt(const std::string& str) {
5
try {
6
return std::stoi(str);
7
} catch (const std::invalid_argument& e) {
8
return folly::make_exception_ptr<std::invalid_argument>("Invalid argument: " + str);
9
} catch (const std::out_of_range& e) {
10
return folly::make_exception_ptr<std::out_of_range>("Out of range: " + str);
11
}
12
}
13
14
folly::Try<int> processString(const std::string& input) {
15
return stringToInt(input)
16
.map([](int value) { return value * 2; }) // 成功时将值乘以 2
17
.map([](int value) { return value + 10; }); // 再次成功时将值加 10
18
}
19
20
void testProcessString() {
21
folly::Try<int> result1 = processString("10");
22
if (result1.isSuccess()) {
23
std::cout << "Result 1: " << result1.value() << std::endl; // 输出 30
24
} else {
25
// 处理错误
26
}
27
28
folly::Try<int> result2 = processString("abc");
29
if (result2.isSuccess()) {
30
// 不会执行到这里
31
} else {
32
std::exception_ptr exPtr = result2.exception();
33
try {
34
std::rethrow_exception(exPtr);
35
} catch (const std::exception& e) {
36
std::cerr << "Error processing string: " << e.what() << std::endl; // 输出 "Invalid argument: abc"
37
}
38
}
39
}
⚝ 需要显式控制错误传播和恢复的场景： Try.h 提供了 or, orElse 等操作，可以方便地提供备选值或默认行为，或者将错误转换为其他值。这在需要精细控制错误传播和恢复的场景下非常有用。
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <string>
4
5
folly::Try<int> mayFail() {
6
// 模拟可能失败的操作
7
if (rand() % 2 == 0) {
8
return 42; // 成功
9
} else {
10
return folly::make_exception_ptr<std::runtime_error>("Operation failed!"); // 失败
11
}
12
}
13
14
void testErrorRecovery() {
15
folly::Try<int> result = mayFail();
16
17
int value = result.orElse(100); // 如果失败，则使用备选值 100
18
std::cout << "Value: " << value << std::endl;
19
20
folly::Try<int> recoveredResult = mayFail().orTry([]{ return folly::Try<int>(123); }); // 如果失败，尝试另一个可能成功的操作
21
if (recoveredResult.isSuccess()) {
22
std::cout << "Recovered result: " << recoveredResult.value() << std::endl;
23
} else {
24
// 仍然失败，处理最终错误
25
std::cerr << "Operation still failed after recovery." << std::endl;
26
}
27
}
⚝ 函数式编程风格的代码： 如果项目或团队倾向于函数式编程风格，Try.h 可以很好地融入到这种风格中。它提供的函数式操作和显式错误处理方式与函数式编程的理念相符。
局限性：
⚝ 学习曲线： 对于习惯了传统 C++ 异常处理的开发者来说，理解和掌握 Try.h 需要一定的学习成本。需要理解 Try 对象的概念、各种操作的含义和用法，以及如何在实际项目中有效地应用 Try.h。
⚝ 代码侵入性： 使用 Try.h 需要修改函数的返回类型，将原先可能返回 T 的函数改为返回 Try<T>。这可能会对现有的代码造成一定的侵入性，尤其是在大型项目中。如果项目中已经大量使用了传统的异常处理，迁移到 Try.h 可能需要较大的工作量。
⚝ 与现有代码的兼容性： Try.h 是一种相对较新的错误处理方式，可能与一些旧的 C++ 代码或库的兼容性不够好。如果项目需要与大量遗留代码或第三方库集成，可能需要仔细考虑 Try.h 的兼容性问题。
⚝ 过度使用： 虽然 Try.h 在很多场景下都很有用，但也不应该过度使用。对于一些绝对不可能失败的操作，或者错误处理逻辑非常简单的情况，使用 Try.h 可能会增加代码的复杂性，反而降低了代码的可读性。应该根据具体的场景和需求，权衡使用 Try.h 的利弊。
⚝ 性能开销 (在某些极端情况下)： 虽然通常 Try.h 可以避免传统异常处理的性能开销，但在某些极端情况下，例如在非常频繁地创建和销毁 Try 对象，或者进行复杂的 Try 操作时，也可能会引入一定的性能开销。需要根据具体的性能需求进行评估和优化。
总结：
| 适用场景 | 局限性 |
|---|---|
| 函数可能返回失败的操作 | 学习曲线 |
| 需要链式操作和函数组合的场景 | 代码侵入性 |
| 需要显式控制错误传播和恢复的场景 | 与现有代码的兼容性 |
| 函数式编程风格的代码 | 过度使用可能降低代码可读性 |
| 某些极端情况下可能存在性能开销 | |
| 推荐使用场景： | 需要谨慎使用场景： |
| ⚝ 处理可预期的失败，例如 I/O 操作、网络请求、数据解析等。 | ⚝ 绝对不可能失败的操作。 |
| ⚝ 需要函数式错误处理和链式调用的场景。 | ⚝ 错误处理逻辑非常简单的场景。 |
| ⚝ 追求代码可读性、健壮性和可维护性的项目。 | ⚝ 需要与大量遗留代码或第三方库集成的项目，需要考虑兼容性。 |
⚝ 性能敏感的应用，但需要具体评估 Try.h 的性能影响。 | ⚝ 团队对 Try.h 不熟悉，或者缺乏函数式编程经验，需要充分学习和培训。 |
总而言之，Folly Try.h 是一种强大的错误处理工具，尤其适用于处理可预期的失败、需要函数式错误处理和链式操作的场景。然而，开发者也需要了解其局限性，并根据具体的项目需求和团队情况，权衡使用 Try.h 的利弊，合理选择错误处理策略。
END_OF_CHAPTER
2. chapter 2： Folly Try.h 基础入门 (Folly Try.h Basic Introduction)
2.1 Try 对象的创建与初始化 (Try Object Creation and Initialization)
folly::Try 是 Folly 库中用于处理可能抛出异常的操作结果的工具。它类似于 std::optional，但专门用于封装可能成功或失败的操作结果，并显式地处理异常情况。理解 Try 对象的创建和初始化是使用 Try.h 的基础。
创建成功的 Try 对象
当一个操作成功完成并返回一个值时，我们可以使用 folly::Try<T> 来封装这个成功的结果。有几种方式可以创建成功的 Try 对象：
① 直接构造: 可以直接使用 folly::Try<T> 的构造函数，传入一个值来创建一个成功的 Try 对象。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
int main() {
5
folly::Try<int> successfulTry(42);
6
if (successfulTry.isSuccess()) {
7
std::cout << "Try is successful, value: " << successfulTry.value() << std::endl;
8
}
9
return 0;
10
}
② 使用 folly::Try<T>::succeed() 静态方法: succeed() 方法提供了一种更语义化的方式来创建成功的 Try 对象。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
int main() {
5
folly::Try<std::string> successfulTry = folly::Try<std::string>::succeed("Hello, Try!");
6
if (successfulTry.isSuccess()) {
7
std::cout << "Try is successful, value: " << successfulTry.value() << std::endl;
8
}
9
return 0;
10
}
创建失败的 Try 对象
当一个操作失败并抛出异常时，我们需要创建一个失败的 Try 对象来封装这个异常。同样，也有几种方式：
① 捕获异常并构造: 可以使用 try-catch 块捕获异常，并使用捕获的异常对象来构造 folly::Try<T>。
1
#include <folly/Try.h>
2
#include <stdexcept>
3
#include <iostream>
4
5
int main() {
6
folly::Try<int> failedTry;
7
try {
8
throw std::runtime_error("Operation failed!");
9
} catch (const std::exception& e) {
10
failedTry = folly::Try<int>(folly::exception_wrapper(std::current_exception()));
11
}
12
13
if (failedTry.isFailure()) {
14
std::cout << "Try is failed, exception: " << failedTry.exception()->what() << std::endl;
15
}
16
return 0;
17
}
在这个例子中，folly::exception_wrapper(std::current_exception()) 用于包装当前捕获的异常，以便 folly::Try 可以安全地存储和管理它。
② 使用 folly::Try<T>::fail() 静态方法: fail() 方法提供了一种更直接的方式来创建失败的 Try 对象，接受一个 folly::exception_wrapper 对象。
1
#include <folly/Try.h>
2
#include <stdexcept>
3
#include <iostream>
4
5
int main() {
6
folly::Try<int> failedTry = folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Operation failed using fail()!")));
7
8
if (failedTry.isFailure()) {
9
std::cout << "Try is failed, exception: " << failedTry.exception()->what() << std::endl;
10
}
11
return 0;
12
}
使用 folly::makeTry() 辅助函数
folly::makeTry() 是一个非常有用的辅助函数，可以简化 Try 对象的创建。它可以接受一个 lambda 函数，并自动捕获 lambda 函数执行过程中抛出的任何异常，并返回一个 Try 对象。
1
#include <folly/Try.h>
2
#include <stdexcept>
3
#include <iostream>
4
5
int main() {
6
auto successfulTry = folly::makeTry([]() { return 100; });
7
if (successfulTry.isSuccess()) {
8
std::cout << "makeTry successful, value: " << successfulTry.value() << std::endl;
9
}
10
11
auto failedTry = folly::makeTry([]() { throw std::runtime_error("makeTry operation failed!"); });
12
if (failedTry.isFailure()) {
13
std::cout << "makeTry failed, exception: " << failedTry.exception()->what() << std::endl;
14
}
15
return 0;
16
}
folly::makeTry() 的优势在于它简洁且异常安全。它隐藏了 try-catch 块的细节，使得代码更加清晰易读。
总结
创建和初始化 folly::Try 对象是使用 Try.h 的第一步。无论是处理可能成功的操作还是可能失败的操作，Try 都提供了灵活且安全的方式来封装结果。通过直接构造、使用静态方法 succeed() 和 fail()，以及辅助函数 makeTry()，开发者可以根据不同的场景选择最合适的方式来创建 Try 对象，为后续的错误处理和链式操作打下基础。
2.2 判断 Try 对象的状态：成功与失败 (Judging Try Object Status: Success and Failure)
在创建 folly::Try 对象后，我们需要能够判断其状态，即操作是成功还是失败。folly::Try 提供了几种方法来检查对象的状态，这对于后续根据不同状态执行不同的逻辑至关重要。
isSuccess() 方法
isSuccess() 方法返回一个布尔值，true 表示 Try 对象封装的是一个成功的结果（即操作没有抛出异常），false 表示封装的是一个失败的结果（即操作抛出了异常）。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
int main() {
5
folly::Try<int> successfulTry = folly::Try<int>::succeed(123);
6
folly::Try<int> failedTry = folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Error!")));
7
8
if (successfulTry.isSuccess()) {
9
std::cout << "successfulTry is successful!" << std::endl; // 输出
10
} else {
11
std::cout << "successfulTry is failed!" << std::endl;
12
}
13
14
if (failedTry.isSuccess()) {
15
std::cout << "failedTry is successful!" << std::endl;
16
} else {
17
std::cout << "failedTry is failed!" << std::endl; // 输出
18
}
19
return 0;
20
}
isFailure() 方法
isFailure() 方法与 isSuccess() 方法相反。它也返回一个布尔值，true 表示 Try 对象封装的是一个失败的结果，false 表示封装的是一个成功的结果。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
int main() {
5
folly::Try<int> successfulTry = folly::Try<int>::succeed(123);
6
folly::Try<int> failedTry = folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Error!")));
7
8
if (successfulTry.isFailure()) {
9
std::cout << "successfulTry is failed!" << std::endl;
10
} else {
11
std::cout << "successfulTry is successful!" << std::endl; // 输出
12
}
13
14
if (failedTry.isFailure()) {
15
std::cout << "failedTry is failed!" << std::endl; // 输出
16
} else {
17
std::cout << "failedTry is successful!" << std::endl;
18
}
19
return 0;
20
}
使用断言 (Assertions) 进行状态检查
在测试或调试阶段，可以使用断言来检查 Try 对象的状态，确保程序在预期的状态下运行。
1
#include <folly/Try.h>
2
#include <cassert>
3
4
int main() {
5
folly::Try<int> successfulTry = folly::Try<int>::succeed(123);
6
folly::Try<int> failedTry = folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Error!")));
7
8
assert(successfulTry.isSuccess());
9
assert(!successfulTry.isFailure());
10
assert(failedTry.isFailure());
11
assert(!failedTry.isSuccess());
12
13
return 0;
14
}
如果断言失败，程序会立即终止，这有助于在开发早期发现状态错误。
状态判断的应用场景
状态判断在 Try 的使用中非常常见。例如，在处理网络请求时，我们可能需要检查请求是否成功，然后根据结果执行不同的操作：
1
#include <folly/Try.h>
2
#include <iostream>
3
4
folly::Try<std::string> fetchDataFromNetwork() {
5
// 模拟网络请求，可能成功也可能失败
6
bool success = (rand() % 2 == 0);
7
if (success) {
8
return folly::Try<std::string>::succeed("Data from network!");
9
} else {
10
return folly::Try<std::string>::fail(folly::exception_wrapper(std::runtime_error("Network request failed!")));
11
}
12
}
13
14
int main() {
15
auto resultTry = fetchDataFromNetwork();
16
if (resultTry.isSuccess()) {
17
std::cout << "Data received: " << resultTry.value() << std::endl; // 处理成功数据
18
} else {
19
std::cerr << "Failed to fetch data: " << resultTry.exception()->what() << std::endl; // 处理失败情况
20
}
21
return 0;
22
}
在这个例子中，我们首先使用 isSuccess() 检查 fetchDataFromNetwork() 函数返回的 Try 对象是否成功。如果是成功的，我们获取并处理数据；如果是失败的，我们处理错误情况。
总结
isSuccess() 和 isFailure() 方法是判断 folly::Try 对象状态的关键。通过这些方法，我们可以清晰地了解操作的结果，并根据成功或失败的状态执行相应的逻辑。这使得错误处理更加明确和可控，提高了代码的健壮性和可读性。
2.3 获取 Try 对象的值或异常 (Getting the Value or Exception of a Try Object)
一旦我们判断了 folly::Try 对象的状态，接下来就需要获取其内部封装的值（如果成功）或异常（如果失败）。folly::Try 提供了 value() 和 exception() 方法来实现这一目的。
value() 方法
value() 方法用于获取 Try 对象中封装的成功值。重要提示： 只能在 Try 对象状态为成功 (isSuccess() 返回 true) 时调用 value()。如果在失败的 Try 对象上调用 value()，程序会抛出 folly::TryAccessWithException 类型的异常。
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <stdexcept>
4
5
int main() {
6
folly::Try<int> successfulTry = folly::Try<int>::succeed(50);
7
8
if (successfulTry.isSuccess()) {
9
int value = successfulTry.value();
10
std::cout << "Successful value: " << value << std::endl; // 输出
11
}
12
13
folly::Try<int> failedTry = folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Value access error!")));
14
15
if (failedTry.isFailure()) {
16
// 安全：在失败的 Try 上调用 value() 会抛出异常，这里我们不调用
17
std::cout << "failedTry is failed, cannot access value() safely here." << std::endl;
18
}
19
20
// 不安全示例 (取消注释会抛出异常)
21
// try {
22
// int value = failedTry.value(); // 错误：在失败的 Try 上调用 value()
23
// } catch (const folly::TryAccessWithException& e) {
24
// std::cerr << "Caught exception when accessing value on failed Try: " << e.what() << std::endl;
25
// }
26
27
return 0;
28
}
在上面的例子中，我们展示了在成功的 Try 对象上安全调用 value() 的方法。同时，注释部分展示了在失败的 Try 对象上调用 value() 会导致异常的情况，并提供了捕获这种异常的示例（尽管最佳实践是避免在失败的 Try 上调用 value()）。
exception() 方法
exception() 方法用于获取 Try 对象中封装的异常对象。重要提示： 只能在 Try 对象状态为失败 (isFailure() 返回 true) 时调用 exception()。如果在成功的 Try 对象上调用 exception()，行为是未定义的，通常会返回空指针或者导致程序崩溃。
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <stdexcept>
4
5
int main() {
6
folly::Try<int> failedTry = folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Operation failed!")));
7
8
if (failedTry.isFailure()) {
9
const std::exception* exceptionPtr = failedTry.exception().get();
10
if (exceptionPtr) {
11
std::cerr << "Exception details: " << exceptionPtr->what() << std::endl; // 输出异常信息
12
}
13
}
14
15
folly::Try<int> successfulTry = folly::Try<int>::succeed(100);
16
17
if (successfulTry.isSuccess()) {
18
// 安全：在成功的 Try 上调用 exception() 是不安全的，这里我们不调用
19
std::cout << "successfulTry is successful, cannot access exception() safely here." << std::endl;
20
}
21
22
// 不安全示例 (取消注释可能会导致未定义行为或崩溃)
23
// const std::exception* exceptionPtr = successfulTry.exception().get(); // 错误：在成功的 Try 上调用 exception()
24
25
return 0;
26
}
在上面的例子中，我们展示了在失败的 Try 对象上安全调用 exception() 的方法，并获取了异常对象的指针。我们强调了避免在成功的 Try 对象上调用 exception()，因为这会导致未定义行为。
安全地获取值或异常的最佳实践
为了安全地获取 Try 对象的值或异常，最佳实践是始终先检查 Try 对象的状态 (isSuccess() 或 isFailure())，然后再根据状态调用 value() 或 exception()。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
folly::Try<int> mayFailOperation(int input) {
5
if (input >= 0) {
6
return folly::Try<int>::succeed(input * 2);
7
} else {
8
return folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Input must be non-negative!")));
9
}
10
}
11
12
int main() {
13
int input1 = 5;
14
auto result1Try = mayFailOperation(input1);
15
if (result1Try.isSuccess()) {
16
std::cout << "Operation with input " << input1 << " succeeded, result: " << result1Try.value() << std::endl;
17
} else {
18
std::cerr << "Operation with input " << input1 << " failed, reason: " << result1Try.exception()->what() << std::endl;
19
}
20
21
int input2 = -2;
22
auto result2Try = mayFailOperation(input2);
23
if (result2Try.isSuccess()) {
24
std::cout << "Operation with input " << input2 << " succeeded, result: " << result2Try.value() << std::endl;
25
} else {
26
std::cerr << "Operation with input " << input2 << " failed, reason: " << result2Try.exception()->what() << std::endl;
27
}
28
29
return 0;
30
}
在这个例子中，我们定义了一个可能失败的操作 mayFailOperation()。在 main() 函数中，我们先检查 Try 对象的状态，然后才安全地获取值或异常，避免了潜在的运行时错误。
总结
value() 和 exception() 方法提供了访问 folly::Try 对象内部数据的途径。但务必记住，安全使用这两个方法的关键在于先进行状态检查。只有在 isSuccess() 为 true 时才能调用 value()，只有在 isFailure() 为 true 时才能调用 exception()。遵循这个原则可以避免程序崩溃和未定义行为，确保代码的健壮性。
2.4 Try 的基本操作：map, flatMap, or, orElse (Basic Try Operations: map, flatMap, or, orElse)
folly::Try 不仅仅是一个简单的结果容器，它还提供了一系列强大的操作，使得可以以函数式的方式链式处理可能失败的操作。这些操作包括 map, flatMap, or, 和 orElse，它们是构建复杂、健壮的错误处理逻辑的基础。
2.4.1 map：转换 Try 成功的值 (map: Transforming the Successful Value of Try)
map 操作允许你对一个成功的 Try 对象内部的值进行转换，并返回一个新的 Try 对象。如果原始 Try 对象是失败的，map 操作会直接返回一个新的失败的 Try 对象，而不会应用转换函数。
函数签名
1
template <typename F>
2
auto map(F&& f) &&;
map 接受一个函数 f 作为参数，这个函数 f 接受原始 Try 对象成功的值作为输入，并返回一个新的值。map 返回一个新的 Try 对象，其内部封装的值是函数 f 的返回值（如果原始 Try 成功），或者与原始 Try 相同的异常（如果原始 Try 失败）。
示例
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <string>
4
5
folly::Try<int> getIntValue() {
6
return folly::Try<int>::succeed(10);
7
}
8
9
folly::Try<int> getFailedTry() {
10
return folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Failed to get value!")));
11
}
12
13
int main() {
14
auto successfulTry = getIntValue();
15
auto mappedSuccessfulTry = successfulTry.map([](int value) {
16
return std::to_string(value * 2); // 将 int 转换为 string
17
});
18
19
if (mappedSuccessfulTry.isSuccess()) {
20
std::cout << "Mapped successful Try value: " << mappedSuccessfulTry.value() << std::endl; // 输出 "Mapped successful Try value: 20"
21
}
22
23
auto failedTry = getFailedTry();
24
auto mappedFailedTry = failedTry.map([](int value) {
25
return std::to_string(value * 2); // 即使原始 Try 失败，map 的 lambda 仍然会被定义，但不会被执行
26
});
27
28
if (mappedFailedTry.isFailure()) {
29
std::cout << "Mapped failed Try is still failed: " << mappedFailedTry.exception()->what() << std::endl; // 输出 "Mapped failed Try is still failed: Failed to get value!"
30
}
31
32
return 0;
33
}
在上面的例子中，我们首先对一个成功的 Try<int> 对象应用 map 操作，将其内部的 int 值转换为 std::string 类型。结果是一个 Try<std::string> 对象。对于失败的 Try<int> 对象，map 操作没有改变其失败状态，新的 Try 对象仍然是失败的，并且异常信息保持不变。
map 的应用场景
map 操作非常适合在链式操作中对成功的结果进行转换，例如：
① 类型转换: 将 Try<int> 转换为 Try<std::string>，如上面的例子所示。
② 数据处理: 对成功获取的数据进行进一步处理，例如计算、格式化等。
③ 提取部分数据: 从复杂的成功结果中提取需要的部分。
map 保持了 Try 的链式操作能力，同时允许对成功路径上的数据进行灵活的转换。
2.4.2 flatMap：链式操作与 Try 的组合 (flatMap: Chained Operations and Combination of Try)
flatMap 操作与 map 类似，也用于转换 Try 对象的值。但 flatMap 期望你提供的转换函数返回的也是一个 Try 对象。这使得 flatMap 非常适合用于链式操作，特别是当链条中的每个操作都可能失败并返回 Try 时。
函数签名
1
template <typename F>
2
auto flatMap(F&& f) &&;
flatMap 接受一个函数 f，这个函数接受原始 Try 对象成功的值作为输入，并返回一个 Try 对象。flatMap 的返回值是函数 f 返回的 Try 对象（如果原始 Try 成功），或者与原始 Try 相同的异常（如果原始 Try 失败）。
示例
1
#include <folly/Try.h>
2
#include <iostream>
3
4
folly::Try<int> getPositiveIntTry() {
5
return folly::Try<int>::succeed(5);
6
}
7
8
folly::Try<int> multiplyByTwoTry(int value) {
9
if (value >= 0) {
10
return folly::Try<int>::succeed(value * 2);
11
} else {
12
return folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Value must be non-negative!")));
13
}
14
}
15
16
folly::Try<int> getNegativeIntTry() {
17
return folly::Try<int>::succeed(-2);
18
}
19
20
21
int main() {
22
auto initialTry = getPositiveIntTry();
23
auto flatMappedTry = initialTry.flatMap(multiplyByTwoTry); // 链式操作，multiplyByTwoTry 返回 Try<int>
24
25
if (flatMappedTry.isSuccess()) {
26
std::cout << "flatMap successful, value: " << flatMappedTry.value() << std::endl; // 输出 "flatMap successful, value: 10"
27
}
28
29
auto negativeInitialTry = getNegativeIntTry();
30
auto flatMappedNegativeTry = negativeInitialTry.flatMap(multiplyByTwoTry); // multiplyByTwoTry 会返回失败的 Try
31
32
if (flatMappedNegativeTry.isFailure()) {
33
std::cout << "flatMap with negative input failed: " << flatMappedNegativeTry.exception()->what() << std::endl; // 输出 "flatMap with negative input failed: Value must be non-negative!"
34
}
35
36
auto failedInitialTry = folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Initial operation failed!")));
37
auto flatMappedFailedTry = failedInitialTry.flatMap(multiplyByTwoTry); // 原始 Try 失败，flatMap 不会执行转换函数
38
39
if (flatMappedFailedTry.isFailure()) {
40
std::cout << "flatMap after initial failure: " << flatMappedFailedTry.exception()->what() << std::endl; // 输出 "flatMap after initial failure: Initial operation failed!"
41
}
42
43
return 0;
44
}
在上面的例子中，flatMap 被用来链式调用 multiplyByTwoTry 函数。如果初始的 Try 对象是成功的，flatMap 会将成功的值传递给 multiplyByTwoTry，并返回 multiplyByTwoTry 返回的 Try 对象。如果初始的 Try 对象是失败的，flatMap 会直接返回失败的 Try 对象，而不会调用转换函数。
flatMap 的应用场景
flatMap 是构建复杂操作链的关键，特别是在以下场景中：
① 依赖性操作: 一个操作的成功依赖于前一个操作的成功，并且后续操作也可能失败。例如，从配置文件读取数据，然后根据读取的数据连接数据库，这两个操作都可能失败。
② 异步操作链: 在异步编程中，flatMap 可以用于链式调用返回 folly::Future<folly::Try<T>> 的异步操作，实现异步流程的编排。
③ 错误传播: flatMap 可以自然地传播错误。如果链条中的任何一个环节失败，整个链条的结果都会是失败的，并且保留第一个失败环节的异常信息。
flatMap 提供了强大的链式操作能力，使得可以以清晰、简洁的方式处理复杂的、可能失败的操作序列。
2.4.3 or 与 orElse：提供备选值 (or and orElse: Providing Alternative Values)
or 和 orElse 操作用于在 Try 对象失败时提供备选方案。它们允许你指定一个备选的 Try 对象 (or) 或一个备选的值 (orElse)，在原始 Try 对象失败的情况下使用。
or 操作
or 操作接受另一个 Try 对象作为参数。如果原始 Try 对象是成功的，or 操作会返回原始 Try 对象。如果原始 Try 对象是失败的，or 操作会返回作为参数传入的备选 Try 对象。
函数签名
1
template <typename E = folly::exception_wrapper>
2
auto or_(Try<T, E>&& other) &&;
示例
1
#include <folly/Try.h>
2
#include <iostream>
3
4
folly::Try<int> operationMayFail() {
5
bool shouldFail = (rand() % 2 == 0);
6
if (shouldFail) {
7
return folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Primary operation failed!")));
8
} else {
9
return folly::Try<int>::succeed(100);
10
}
11
}
12
13
folly::Try<int> fallbackOperation() {
14
return folly::Try<int>::succeed(50); // 备选操作总是成功
15
}
16
17
int main() {
18
auto primaryTry = operationMayFail();
19
auto orTry = primaryTry.or_(fallbackOperation()); // 如果 primaryTry 失败，则使用 fallbackOperation() 的结果
20
21
if (orTry.isSuccess()) {
22
std::cout << "or operation successful, value: " << orTry.value() << std::endl; // 可能输出 100 或 50
23
} else {
24
std::cerr << "or operation failed: " << orTry.exception()->what() << std::endl; // 只有当 primaryTry 和 fallbackOperation() 都失败时才会输出
25
}
26
27
return 0;
28
}
在上面的例子中，如果 operationMayFail() 返回失败的 Try 对象，or_ 操作会返回 fallbackOperation() 返回的 Try 对象（在本例中总是成功的）。如果 operationMayFail() 返回成功的 Try 对象，or_ 操作会直接返回 operationMayFail() 的结果。
orElse 操作
orElse 操作接受一个函数作为参数，这个函数在原始 Try 对象失败时被调用，并返回一个备选值。如果原始 Try 对象是成功的，orElse 操作会返回原始 Try 对象。如果原始 Try 对象是失败的，orElse 操作会调用提供的函数，并将函数的返回值封装在一个成功的 Try 对象中返回。
函数签名
1
template <typename F>
2
auto orElse(F&& f) &&;
示例
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <string>
4
5
folly::Try<int> operationMayFailAgain() {
6
bool shouldFail = (rand() % 2 == 0);
7
if (shouldFail) {
8
return folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Another operation failed!")));
9
} else {
10
return folly::Try<int>::succeed(200);
11
}
12
}
13
14
int getDefaultValue() {
15
return 0; // 默认值
16
}
17
18
int main() {
19
auto primaryTry = operationMayFailAgain();
20
auto orElseTry = primaryTry.orElse([]() {
21
return getDefaultValue(); // 如果 primaryTry 失败，则使用默认值
22
});
23
24
if (orElseTry.isSuccess()) {
25
std::cout << "orElse operation successful, value: " << orElseTry.value() << std::endl; // 可能输出 200 或 0
26
} else {
27
std::cerr << "orElse operation failed: " << orElseTry.exception()->what() << std::endl; // 永远不会输出，因为 orElse 总是返回成功的 Try
28
}
29
30
return 0;
31
}
在上面的例子中，如果 operationMayFailAgain() 返回失败的 Try 对象，orElse 操作会调用 lambda 函数 [](){ return getDefaultValue(); }，并将 getDefaultValue() 的返回值（0）封装在一个成功的 Try 对象中返回。如果 operationMayFailAgain() 返回成功的 Try 对象，orElse 操作会直接返回 operationMayFailAgain() 的结果。
or 和 orElse 的应用场景
or 和 orElse 操作非常适合在需要提供默认值或备选方案的场景中：
① 默认值: 当主操作失败时，提供一个合理的默认值，例如从缓存读取数据失败时，返回一个预设的默认配置。orElse 更适合这种情况。
② 备选操作: 当主操作失败时，尝试执行另一个备选操作。例如，尝试从主服务器获取数据失败时，尝试从备用服务器获取数据。or 更适合这种情况。
③ 错误恢复: 在某些情况下，即使主操作失败，也可以通过备选方案恢复，保证程序的继续运行。
or 和 orElse 提供了灵活的错误处理策略，使得可以在 Try 链中优雅地处理失败情况，并提供备选方案，增强程序的容错能力。
2.5 Try 与函数式编程 (Try and Functional Programming)
folly::Try 的设计深受函数式编程思想的影响，它与函数式编程的许多核心概念高度契合。理解 Try 与函数式编程的关系，可以更深入地理解 Try 的设计哲学，并更好地利用 Try 构建更清晰、更健壮的代码。
不可变性 (Immutability)
函数式编程强调数据的不可变性。folly::Try 对象本身是不可变的。一旦创建，Try 对象的状态（成功或失败）以及内部封装的值或异常都不能被修改。map, flatMap, or, orElse 等操作都不会修改原始的 Try 对象，而是返回新的 Try 对象。这种不可变性简化了程序的推理和调试，避免了副作用，提高了代码的可靠性。
纯函数 (Pure Functions)
函数式编程鼓励使用纯函数，即函数的输出只由输入决定，并且没有副作用。Try 的操作，如 map 和 flatMap，可以与纯函数很好地结合使用。例如，传递给 map 或 flatMap 的 lambda 函数应该是纯函数，它们只负责转换输入值并返回结果，而不应该有任何副作用。
函数组合 (Function Composition)
函数式编程提倡通过组合小的、可复用的函数来构建复杂的逻辑。Try 的链式操作 (map, flatMap) 正是函数组合的一种体现。通过 map 和 flatMap，可以将多个可能失败的操作组合成一个操作链，每个环节都通过函数进行转换，最终得到一个表示整个操作链结果的 Try 对象。这种组合方式使得代码更加模块化、易于理解和维护。
错误处理作为值 (Error Handling as Values)
在传统的 C++ 异常处理中，异常是一种控制流机制，它会中断正常的程序执行流程。而在函数式编程中，错误被视为一种值，可以像普通数据一样被处理和传递。folly::Try 将错误（异常）封装在 Try 对象中，使得错误可以作为值被显式地处理。Try 对象可以是成功状态，也可以是失败状态，这两种状态都是普通的值，可以被函数操作和组合。or 和 orElse 操作更是显式地处理失败情况，提供了备选值或备选操作，使得错误处理更加可控和灵活。
避免副作用 (Avoiding Side Effects)
函数式编程强调避免副作用，即函数不应该修改外部状态或产生其他不可预测的影响。folly::Try 的设计鼓励编写无副作用的代码。例如，在使用 map 或 flatMap 时，转换函数应该只关注输入值的转换，而不应该修改外部变量或执行 I/O 操作等副作用操作。
与 Lambda 表达式的结合
folly::Try 与 C++ 的 lambda 表达式结合使用非常自然和强大。lambda 表达式可以方便地定义传递给 map, flatMap, or, orElse 等操作的转换函数或备选操作。lambda 表达式的简洁性和灵活性使得可以以更函数式的方式编写代码。
示例：函数式风格的 Try 链
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <string>
4
5
folly::Try<int> stringToIntTry(const std::string& str) {
6
try {
7
return folly::Try<int>::succeed(std::stoi(str));
8
} catch (const std::exception& e) {
9
return folly::Try<int>::fail(folly::exception_wrapper(e));
10
}
11
}
12
13
folly::Try<int> divideByTry(int numerator, int denominator) {
14
if (denominator == 0) {
15
return folly::Try<int>::fail(folly::exception_wrapper(std::runtime_error("Division by zero!")));
16
}
17
return folly::Try<int>::succeed(numerator / denominator);
18
}
19
20
int main() {
21
std::string inputStr = "120";
22
23
auto resultTry = stringToIntTry(inputStr)
24
.flatMap([](int num) { return divideByTry(num, 10); })
25
.map([](int result) { return "Result is: " + std::to_string(result); })
26
.orElse([]() { return "Operation failed!"; });
27
28
if (resultTry.isSuccess()) {
29
std::cout << resultTry.value() << std::endl; // 输出 "Result is: 12"
30
} else {
31
std::cerr << resultTry.exception()->what() << std::endl;
32
}
33
34
return 0;
35
}
在这个例子中，我们使用 Try 和 lambda 表达式构建了一个函数式风格的操作链。stringToIntTry, flatMap, map, orElse 等操作被链式调用，每个操作都通过 lambda 表达式定义了转换逻辑。整个代码风格简洁、清晰，易于理解和维护，体现了函数式编程的优势。
总结
folly::Try 深刻地体现了函数式编程的思想。通过不可变性、纯函数、函数组合、错误处理作为值以及避免副作用等原则，Try 使得 C++ 开发者可以以更函数式的方式处理错误，构建更健壮、更易于维护的代码。理解 Try 与函数式编程的关系，有助于更好地掌握 Try 的使用，并在实际项目中发挥其强大的功能。
END_OF_CHAPTER
3. chapter 3： Folly Try.h 实战应用 (Folly Try.h Practical Applications)
3.1 使用 Try 处理可能失败的函数 (Using Try to Handle Potentially Failing Functions)
在软件开发中，处理可能失败的操作是至关重要的。传统的 C++ 异常处理机制虽然强大，但在某些场景下显得笨重，尤其是在需要更轻量级、更函数式错误处理方式时。folly::Try 提供了一种优雅的替代方案，用于封装可能成功或失败的操作，并允许开发者以更加可控和清晰的方式处理结果。
3.1.1 封装可能失败的函数
folly::Try 的核心价值在于它可以将一个可能抛出异常的函数调用，转化为一个返回 Try 对象的表达式。这个 Try 对象会明确地表示操作的结果：成功或失败。
考虑一个简单的例子，一个函数尝试将字符串转换为整数。这个操作可能会因为字符串格式不正确而失败。
1
#include <folly/Try.h>
2
#include <stdexcept>
3
#include <string>
4
#include <iostream>
5
6
folly::Try<int> stringToInt(const std::string& str) {
7
try {
8
return std::stoi(str);
9
} catch (const std::invalid_argument& e) {
10
return folly::make_exception_ptr<std::invalid_argument>(e);
11
} catch (const std::out_of_range& e) {
12
return folly::make_exception_ptr<std::out_of_range>(e);
13
}
14
}
15
16
int main() {
17
auto result1 = stringToInt("123");
18
auto result2 = stringToInt("abc");
19
20
if (result1.isSuccess()) {
21
std::cout << "成功转换: " << result1.value() << std::endl;
22
} else {
23
std::cout << "转换失败: " << result1.exception().what() << std::endl;
24
}
25
26
if (result2.isSuccess()) {
27
std::cout << "成功转换: " << result2.value() << std::endl;
28
} else {
29
std::cout << "转换失败: " << result2.exception().what() << std::endl;
30
}
31
32
return 0;
33
}
在这个例子中，stringToInt 函数使用 folly::Try<int> 作为返回类型。在函数内部，我们使用 try-catch 块来捕获 std::stoi 可能抛出的异常。如果转换成功，我们使用 std::stoi(str) 的返回值隐式地构造一个成功的 Try 对象。如果捕获到异常，我们使用 folly::make_exception_ptr 将捕获的异常转换为 std::exception_ptr，并用它来构造一个失败的 Try 对象。
在 main 函数中，我们调用 stringToInt 并检查返回的 Try 对象的状态。isSuccess() 方法用于判断操作是否成功。如果成功，我们可以使用 value() 方法获取结果值。如果失败，我们可以使用 exception() 方法获取封装的异常。
3.1.2 Try 与传统异常处理的对比
传统的 C++ 异常处理依赖于 try-catch 块和异常的抛出与捕获。虽然这是一种强大的机制，但在某些情况下，它可能导致代码结构分散，控制流不清晰。
① 显式错误处理: Try 迫使开发者显式地处理可能失败的情况。通过返回 Try 对象，函数签名明确地表明该操作可能失败，调用者必须检查 Try 的状态才能安全地访问结果。这与传统的异常处理形成对比，后者可能在调用栈深处抛出异常，使得错误处理逻辑分散在不同的 catch 块中。
② 函数式风格: Try 鼓励函数式编程风格的错误处理。map、flatMap、or、orElse 等操作符允许开发者以链式的方式处理 Try 对象，避免了命令式错误处理中常见的嵌套 if-else 或 try-catch 结构。
③ 轻量级: 在某些性能敏感的场景中，传统的异常处理可能会引入额外的开销，即使没有异常抛出。Try 提供了一种更轻量级的错误处理机制，因为它避免了异常的抛出和捕获的开销，而是通过状态标志和 std::exception_ptr 来表示错误。
3.1.3 适用场景
使用 Try 处理可能失败的函数在以下场景中尤其适用：
① 函数式编程: 当你希望采用函数式编程风格，并希望以表达式的方式处理错误时，Try 是一个理想的选择。
② 需要显式错误处理的 API: 当你设计的 API 需要明确告知调用者操作可能失败，并希望调用者显式处理错误时，返回 Try 对象可以提高 API 的清晰度和易用性。
③ 轻量级错误处理: 在性能敏感的场景中，或者当错误被认为是预期情况而不是异常情况时，Try 可以提供比传统异常处理更高效的错误处理机制。
④ 资源管理: 如后续章节所述，Try 可以与 RAII 结合，实现更安全、更简洁的资源管理。
总而言之，folly::Try 提供了一种现代、灵活且高效的方式来处理可能失败的函数，特别是在需要函数式编程风格、显式错误处理和轻量级错误处理的场景中。
3.2 Try 在资源管理中的应用 (Try in Resource Management)
资源管理是软件开发中的一个核心问题。在 C++ 中，资源通常通过 RAII (Resource Acquisition Is Initialization，资源获取即初始化) 原则进行管理。RAII 依赖于对象的生命周期来自动管理资源，例如，在对象构造时获取资源，在对象析构时释放资源。然而，当资源获取过程本身可能失败时，传统的 RAII 机制可能需要结合异常处理来确保资源的正确释放。folly::Try 可以与 RAII 结合，提供一种更优雅的方式来处理资源管理，尤其是在资源获取可能失败的情况下。
3.2.1 RAII 与 Try 的结合
考虑一个需要打开文件并读取内容的场景。文件打开操作可能会失败，例如文件不存在或权限不足。使用传统的 RAII 和异常处理，代码可能如下所示：
1
#include <fstream>
2
#include <iostream>
3
#include <stdexcept>
4
#include <string>
5
6
class FileReader {
7
public:
8
FileReader(const std::string& filename) : file_(filename) {
9
if (!file_.is_open()) {
10
throw std::runtime_error("无法打开文件: " + filename);
11
}
12
}
13
~FileReader() {
14
if (file_.is_open()) {
15
file_.close();
16
}
17
}
18
19
std::string readLine() {
20
std::string line;
21
if (!std::getline(file_, line)) {
22
throw std::runtime_error("读取文件行失败");
23
}
24
return line;
25
}
26
27
private:
28
std::ifstream file_;
29
};
30
31
int main() {
32
try {
33
FileReader reader("example.txt");
34
std::string line = reader.readLine();
35
std::cout << "读取到行: " << line << std::endl;
36
} catch (const std::exception& e) {
37
std::cerr << "发生错误: " << e.what() << std::endl;
38
}
39
return 0;
40
}
在这个例子中，FileReader 类使用 RAII 来管理文件资源。构造函数尝试打开文件，如果失败则抛出异常。析构函数负责关闭文件。readLine 方法也可能抛出异常。main 函数使用 try-catch 块来捕获可能发生的异常。
使用 folly::Try，我们可以将资源获取操作封装在 Try 对象中，并在后续操作中使用 Try 的链式操作。
1
#include <folly/Try.h>
2
#include <fstream>
3
#include <iostream>
4
#include <stdexcept>
5
#include <string>
6
7
class FileReader {
8
public:
9
FileReader(folly::Try<std::ifstream> fileTry) : fileTry_(std::move(fileTry)) {}
10
11
folly::Try<std::string> readLine() {
12
if (fileTry_.isFailure()) {
13
return fileTry_.asTry<std::string>(); // Propagate the original failure
14
}
15
std::string line;
16
if (!std::getline(fileTry_.value(), line)) {
17
return folly::make_exception_ptr<std::runtime_error>("读取文件行失败");
18
}
19
return line;
20
}
21
22
private:
23
folly::Try<std::ifstream> fileTry_;
24
};
25
26
folly::Try<FileReader> makeFileReader(const std::string& filename) {
27
folly::Try<std::ifstream> fileTry = folly::Try<std::ifstream>([&]() {
28
std::ifstream file(filename);
29
if (!file.is_open()) {
30
throw std::runtime_error("无法打开文件: " + filename);
31
}
32
return file;
33
}()); // Immediately invoked lambda to capture potential exception
34
35
if (fileTry.isFailure()) {
36
return fileTry.asTry<FileReader>(); // Propagate file opening failure
37
} else {
38
return FileReader(std::move(fileTry));
39
}
40
}
41
42
43
int main() {
44
auto readerTry = makeFileReader("example.txt");
45
46
if (readerTry.isSuccess()) {
47
auto lineTry = readerTry.value().readLine();
48
if (lineTry.isSuccess()) {
49
std::cout << "读取到行: " << lineTry.value() << std::endl;
50
} else {
51
std::cerr << "读取行失败: " << lineTry.exception().what() << std::endl;
52
}
53
} else {
54
std::cerr << "创建 FileReader 失败: " << readerTry.exception().what() << std::endl;
55
}
56
57
return 0;
58
}
在这个改进的例子中，FileReader 的构造函数接受一个 folly::Try<std::ifstream> 对象。makeFileReader 函数负责创建 Try<std::ifstream> 对象，并在文件打开失败时返回一个失败的 Try。FileReader 内部的 readLine 方法也返回 folly::Try<std::string>，以便传播读取行可能发生的错误。
3.2.2 Try 在资源管理中的优势
① 显式错误处理: 使用 Try 可以显式地处理资源获取失败的情况，避免了构造函数抛出异常可能导致的复杂性。
② 链式操作: Try 的链式操作 (如 map, flatMap) 可以方便地组合资源操作，并传播错误。
③ 资源安全: 即使资源获取失败，Try 也能确保程序不会崩溃，而是返回一个失败状态，允许调用者优雅地处理错误。
④ 代码清晰: 使用 Try 可以使资源管理代码更加清晰和易于理解，尤其是在复杂的资源依赖关系中。
3.2.3 适用场景
Try 在资源管理中特别适用于以下场景：
① 资源获取可能失败: 当资源获取操作 (如文件打开、网络连接、内存分配) 可能失败时，使用 Try 可以更好地处理这些失败情况。
② 复杂的资源依赖: 当资源之间存在复杂的依赖关系，需要按顺序获取和释放时，Try 可以帮助管理这些依赖关系，并确保在任何阶段发生错误时都能正确处理。
③ 需要函数式资源管理: 当你希望以函数式风格管理资源，并避免传统的 try-catch 块时，Try 是一个不错的选择。
总而言之，folly::Try 为 C++ 中的资源管理提供了一种更现代、更安全、更灵活的方法，尤其是在资源获取可能失败的场景中。通过与 RAII 原则结合，Try 可以帮助开发者构建更健壮、更易于维护的应用程序。
3.3 Try 与异步编程 (Try and Asynchronous Programming)
异步编程在现代软件开发中变得越来越重要，尤其是在需要处理 I/O 密集型操作或需要高并发的场景中。folly::Try 可以很好地与异步编程模型结合，例如 folly::Future 和 folly::Promise，用于处理异步操作的结果，包括成功和失败的情况。
3.3.1 Try 与 Future/Promise
folly::Future 代表一个异步操作的最终结果，而 folly::Promise 用于设置 Future 的结果。Future 可以持有三种状态：未完成 (Unresolved)、已完成 (Resolved) 和已拒绝 (Rejected)。当异步操作成功完成时，Promise 可以将 Future 设置为已完成，并携带结果值。当异步操作失败时，Promise 可以将 Future 设置为已拒绝，并携带异常。
folly::Try 可以作为 Future 的结果类型，用于显式地表示异步操作可能成功或失败。folly::Future<folly::Try<T>> 表示一个异步操作，其最终结果是一个 Try<T> 对象，其中 T 是操作成功时的值类型。
考虑一个异步读取文件的例子。我们可以使用 folly::Future 和 folly::Promise 以及 folly::Try 来实现异步文件读取，并处理可能的文件读取错误。
1
#include <folly/Future.h>
2
#include <folly/Promise.h>
3
#include <folly/Try.h>
4
#include <fstream>
5
#include <iostream>
6
#include <stdexcept>
7
#include <string>
8
#include <thread>
9
10
using namespace folly;
11
12
Future<Try<std::string>> asyncReadFile(const std::string& filename) {
13
Promise<Try<std::string>> promise;
14
Future<Try<std::string>> future = promise.getFuture();
15
16
std::thread([promise = std::move(promise), filename]() mutable {
17
std::ifstream file(filename);
18
if (!file.is_open()) {
19
promise.setValue(makeTry<std::string>(make_exception_ptr<std::runtime_error>("无法打开文件: " + filename)));
20
return;
21
}
22
std::string content;
23
std::string line;
24
while (std::getline(file, line)) {
25
content += line + "\n";
26
}
27
promise.setValue(makeTry<std::string>(content));
28
}).detach();
29
30
return future;
31
}
32
33
int main() {
34
Future<Try<std::string>> fileContentFuture = asyncReadFile("example.txt");
35
36
fileContentFuture.then([](Try<std::string> contentTry) {
37
if (contentTry.isSuccess()) {
38
std::cout << "文件内容:\n" << contentTry.value() << std::endl;
39
} else {
40
std::cerr << "读取文件失败: " << contentTry.exception().what() << std::endl;
41
}
42
});
43
44
// 等待异步操作完成 (在实际应用中，通常会有更复杂的异步流程管理)
45
std::this_thread::sleep_for(std::chrono::seconds(1));
46
47
return 0;
48
}
在这个例子中，asyncReadFile 函数返回一个 Future<Try<std::string>>。它在后台线程中异步读取文件内容，并将结果 (成功或失败) 设置到 Promise 中。main 函数使用 then 方法注册一个回调函数，当 Future 完成时，回调函数会被调用，并接收一个 Try<std::string> 对象作为参数。回调函数检查 Try 的状态，并相应地处理成功或失败的情况。
3.3.2 Try 在异步编程中的优势
① 显式错误处理: Future<Try<T>> 明确地表示异步操作可能失败，并要求开发者显式地处理错误情况。
② 链式异步操作: Future 提供了丰富的链式操作 (如 then, map, flatMap, rescue)，可以与 Try 结合使用，构建复杂的异步流程，并优雅地处理错误。
③ 错误传播: Try 可以方便地在异步操作链中传播错误。如果链中的任何一个环节返回失败的 Try，整个链条的结果都会是失败的。
④ 统一的错误处理模型: 无论操作是同步的还是异步的，Try 都提供了一种统一的错误处理模型，简化了代码的复杂性。
3.3.3 适用场景
Try 在异步编程中特别适用于以下场景：
① 异步操作可能失败: 当异步操作 (如网络请求、数据库查询、文件 I/O) 可能失败时，使用 Try 可以更好地处理这些失败情况。
② 复杂的异步流程: 当需要构建复杂的异步流程，并需要处理流程中各个环节可能发生的错误时，Try 可以帮助管理错误传播和聚合。
③ 需要函数式异步编程: 当你希望采用函数式编程风格进行异步编程，并希望以表达式的方式处理异步操作的结果和错误时，Try 是一个理想的选择。
总而言之，folly::Try 与 folly::Future 和 folly::Promise 等异步编程工具的结合，为 C++ 异步编程提供了强大的错误处理能力。通过使用 Try，开发者可以构建更健壮、更易于维护的异步应用程序。
3.4 Try 在错误传播与聚合中的应用 (Try in Error Propagation and Aggregation)
在复杂的应用程序中，错误处理往往涉及到错误传播 (Error Propagation) 和错误聚合 (Error Aggregation)。错误传播指的是在一个操作链中，如果某个操作失败，错误应该被传递到调用链的更上层，以便统一处理。错误聚合指的是当需要执行多个独立的操作时，需要收集所有操作的错误信息，以便进行综合处理。folly::Try 在这两种场景下都提供了强大的支持。
3.4.1 错误传播
folly::Try 的设计天生就支持错误传播。当你在 Try 对象上进行链式操作 (如 map, flatMap) 时，如果原始的 Try 对象是失败状态，那么链式操作的结果也会是失败状态，并且会传播原始的异常。
考虑一个操作链，其中每个操作都可能失败：
1
#include <folly/Try.h>
2
#include <stdexcept>
3
#include <iostream>
4
5
using namespace folly;
6
7
Try<int> operation1(int input) {
8
if (input < 0) {
9
return make_exception_ptr<std::invalid_argument>("输入不能为负数");
10
}
11
return input + 1;
12
}
13
14
Try<int> operation2(int input) {
15
if (input > 100) {
16
return make_exception_ptr<std::out_of_range>("输入超出范围");
17
}
18
return input * 2;
19
}
20
21
Try<int> operation3(int input) {
22
return input - 5;
23
}
24
25
int main() {
26
auto result1 = Try<int>(5)
27
.then(operation1)
28
.then(operation2)
29
.then(operation3);
30
31
if (result1.isSuccess()) {
32
std::cout << "操作链成功，结果: " << result1.value() << std::endl;
33
} else {
34
std::cerr << "操作链失败: " << result1.exception().what() << std::endl;
35
}
36
37
auto result2 = Try<int>(-1)
38
.then(operation1)
39
.then(operation2)
40
.then(operation3);
41
42
if (result2.isSuccess()) {
43
std::cout << "操作链成功，结果: " << result2.value() << std::endl;
44
} else {
45
std::cerr << "操作链失败: " << result2.exception().what() << std::endl;
46
}
47
48
auto result3 = Try<int>(50)
49
.then(operation1)
50
.then(operation2)
51
.then(operation3);
52
if (result3.isSuccess()) {
53
std::cout << "操作链成功，结果: " << result3.value() << std::endl;
54
} else {
55
std::cerr << "操作链失败: " << result3.exception().what() << std::endl;
56
}
57
58
auto result4 = Try<int>(101)
59
.then(operation1)
60
.then(operation2)
61
.then(operation3);
62
if (result4.isSuccess()) {
63
std::cout << "操作链成功，结果: " << result4.value() << std::endl;
64
} else {
65
std::cerr << "操作链失败: " << result4.exception().what() << std::endl;
66
}
67
68
69
return 0;
70
}
在这个例子中，operation1, operation2, operation3 组成了一个操作链。我们使用 Try::then 方法将这些操作链接起来。如果链中的任何一个操作返回失败的 Try，后续的操作都不会执行，并且最终的结果 Try 对象会是失败状态，并携带第一个失败操作的异常。
3.4.2 错误聚合
当需要执行多个独立的操作，并需要收集所有操作的错误信息时，可以使用 folly::collectAll 或 folly::collectAny 等函数。这些函数可以接受一个 Try 对象的容器 (例如 std::vector<Try<T>>)，并返回一个新的 Try 对象，用于表示所有操作的结果。
folly::collectAll 函数会等待所有输入的 Try 对象完成。如果所有输入的 Try 对象都成功，collectAll 返回一个成功的 Try<std::vector<T>>，其中包含所有成功的结果。如果任何一个输入的 Try 对象失败，collectAll 返回一个失败的 Try，并携带第一个失败的异常。
folly::collectAny 函数也会等待所有输入的 Try 对象完成。但是，只要有一个输入的 Try 对象成功，collectAny 就会立即返回一个成功的 Try<T>，并携带第一个成功的结果。只有当所有输入的 Try 对象都失败时，collectAny 才会返回一个失败的 Try，并携带所有失败的异常 (通常是聚合的异常)。
1
#include <folly/Try.h>
2
#include <folly/futures/collect.h>
3
#include <vector>
4
#include <stdexcept>
5
#include <iostream>
6
7
using namespace folly;
8
9
Try<int> task(int id) {
10
if (id % 2 == 0) {
11
return id * 2; // 偶数任务成功
12
} else {
13
return make_exception_ptr<std::runtime_error>("任务 " + std::to_string(id) + " 失败"); // 奇数任务失败
14
}
15
}
16
17
int main() {
18
std::vector<Try<int>> tasksResult;
19
for (int i = 0; i < 5; ++i) {
20
tasksResult.push_back(task(i));
21
}
22
23
auto collectedResult = collectAll(tasksResult);
24
25
if (collectedResult.isSuccess()) {
26
std::cout << "所有任务都成功:\n";
27
for (int result : collectedResult.value()) {
28
std::cout << result << " ";
29
}
30
std::cout << std::endl;
31
} else {
32
std::cerr << "至少有一个任务失败: " << collectedResult.exception().what() << std::endl;
33
}
34
35
return 0;
36
}
在这个例子中，task 函数模拟一个可能成功或失败的任务。main 函数创建了一个包含多个 Try<int> 对象的 std::vector，然后使用 collectAll 函数聚合这些 Try 对象的结果。由于任务 1 和任务 3 失败，collectAll 返回一个失败的 Try，并携带第一个失败任务的异常。
3.4.3 错误传播与聚合的优势
① 简化错误处理逻辑: Try 的错误传播和聚合机制可以简化复杂的错误处理逻辑，避免手动编写大量的错误检查和传播代码。
② 提高代码可读性: 使用 Try 的链式操作和聚合函数可以使错误处理代码更加清晰和易于理解。
③ 支持函数式错误处理: Try 的错误传播和聚合机制与函数式编程风格完美契合，可以构建更优雅、更模块化的错误处理系统。
3.4.4 适用场景
Try 在错误传播与聚合方面特别适用于以下场景：
① 操作链: 当需要执行一系列操作，并且任何一个操作失败都会导致整个链条失败时，Try 的错误传播机制非常有用。
② 并行处理: 当需要并行执行多个任务，并需要收集所有任务的结果 (包括错误) 时，Try 的错误聚合机制非常方便。
③ 批量操作: 当需要执行批量操作，并需要记录每个操作的成功或失败状态时，Try 可以帮助管理每个操作的结果，并进行统一的错误报告。
总而言之，folly::Try 提供了强大的错误传播和聚合能力，可以帮助开发者构建更健壮、更易于维护的应用程序，尤其是在需要处理复杂错误场景的应用中。
3.5 案例分析：使用 Try 构建健壮的应用程序 (Case Study: Building Robust Applications with Try)
为了更好地理解 folly::Try 在实际应用中的价值，我们来看一个案例分析，展示如何使用 Try 构建一个健壮的应用程序。假设我们要构建一个简单的配置加载器，该加载器从配置文件中读取配置项，并提供访问配置项的接口。配置加载过程可能涉及文件读取、配置解析等操作，这些操作都可能失败。
3.5.1 需求分析
我们的配置加载器需要满足以下需求：
① 配置文件加载: 从指定的配置文件路径加载配置内容。文件加载可能因为文件不存在、权限不足等原因失败。
② 配置解析: 将加载的配置内容解析为可用的配置项。配置解析可能因为配置格式错误、配置项缺失等原因失败。
③ 配置项访问: 提供接口，允许用户根据配置项名称访问配置值。如果配置项不存在，应该返回错误。
④ 错误处理: 在任何阶段发生错误时，都应该能够优雅地处理错误，并提供详细的错误信息。
3.5.2 设计与实现
我们可以使用 folly::Try 来处理配置加载过程中的可能失败的操作。
首先，我们定义一个 Configuration 类来表示加载的配置：
1
#include <string>
2
#include <unordered_map>
3
#include <stdexcept>
4
5
class Configuration {
6
public:
7
Configuration(std::unordered_map<std::string, std::string> configMap)
8
: configMap_(std::move(configMap)) {}
9
10
std::string getConfig(const std::string& key) const {
11
if (configMap_.find(key) == configMap_.end()) {
12
throw std::runtime_error("配置项不存在: " + key);
13
}
14
return configMap_.at(key);
15
}
16
17
private:
18
std::unordered_map<std::string, std::string> configMap_;
19
};
接下来，我们实现配置加载器 ConfigurationLoader，使用 folly::Try 来封装加载过程：
1
#include <folly/Try.h>
2
#include <fstream>
3
#include <iostream>
4
#include <sstream>
5
#include <stdexcept>
6
#include <string>
7
#include <unordered_map>
8
9
using namespace folly;
10
11
class Configuration { // 假设 Configuration 类的定义如上
12
public:
13
Configuration(std::unordered_map<std::string, std::string> configMap)
14
: configMap_(std::move(configMap)) {}
15
16
std::string getConfig(const std::string& key) const {
17
if (configMap_.find(key) == configMap_.end()) {
18
throw std::runtime_error("配置项不存在: " + key);
19
}
20
return configMap_.at(key);
21
}
22
23
private:
24
std::unordered_map<std::string, std::string> configMap_;
25
};
26
27
28
class ConfigurationLoader {
29
public:
30
static Try<Configuration> loadConfig(const std::string& filePath) {
31
return readFileContent(filePath)
32
.flatMap(ConfigurationLoader::parseConfigContent);
33
}
34
35
private:
36
static Try<std::string> readFileContent(const std::string& filePath) {
37
std::ifstream file(filePath);
38
if (!file.is_open()) {
39
return make_exception_ptr<std::runtime_error>("无法打开配置文件: " + filePath);
40
}
41
std::stringstream buffer;
42
buffer << file.rdbuf();
43
return buffer.str();
44
}
45
46
static Try<Configuration> parseConfigContent(const std::string& content) {
47
std::unordered_map<std::string, std::string> configMap;
48
std::stringstream ss(content);
49
std::string line;
50
while (std::getline(ss, line)) {
51
std::size_t delimiterPos = line.find('=');
52
if (delimiterPos == std::string::npos) {
53
continue; // 忽略格式错误的行
54
}
55
std::string key = line.substr(0, delimiterPos);
56
std::string value = line.substr(delimiterPos + 1);
57
configMap[key] = value;
58
}
59
if (configMap.empty()) {
60
return make_exception_ptr<std::runtime_error>("配置文件内容为空或解析失败");
61
}
62
return Configuration(configMap);
63
}
64
};
65
66
int main() {
67
auto configTry = ConfigurationLoader::loadConfig("config.txt");
68
69
if (configTry.isSuccess()) {
70
Configuration config = configTry.value();
71
try {
72
std::string dbHost = config.getConfig("db.host");
73
std::string dbPort = config.getConfig("db.port");
74
std::cout << "数据库配置: 主机=" << dbHost << ", 端口=" << dbPort << std::endl;
75
} catch (const std::exception& e) {
76
std::cerr << "读取配置项失败: " << e.what() << std::endl;
77
}
78
} else {
79
std::cerr << "加载配置文件失败: " << configTry.exception().what() << std::endl;
80
}
81
82
return 0;
83
}
在这个案例中，ConfigurationLoader::loadConfig 函数使用 Try 的链式操作 flatMap 将 readFileContent 和 parseConfigContent 两个可能失败的操作链接起来。readFileContent 负责读取文件内容，如果文件打开失败，则返回失败的 Try。parseConfigContent 负责解析文件内容，如果解析失败 (例如配置文件为空)，则返回失败的 Try。
main 函数调用 ConfigurationLoader::loadConfig 加载配置，并检查返回的 Try 对象的状态。如果加载成功，则可以从 Configuration 对象中获取配置项。如果加载失败，则输出错误信息。
3.5.3 案例分析总结
通过这个案例分析，我们可以看到 folly::Try 在构建健壮应用程序中的优势：
① 清晰的错误处理流程: 使用 Try 可以清晰地表达配置加载过程中的错误处理流程，从文件读取到配置解析，每一步都可能失败，并使用 Try 显式地处理这些失败情况。
② 链式操作简化代码: Try 的 flatMap 操作符可以将多个可能失败的操作链接起来，避免了传统的嵌套 if-else 或 try-catch 结构，使代码更加简洁易懂。
③ 易于扩展和维护: 使用 Try 构建的配置加载器易于扩展和维护。如果需要添加新的配置加载步骤 (例如从网络加载配置)，只需要在 Try 链中添加新的操作即可。
④ 提高应用程序的健壮性: 通过显式地处理可能失败的操作，并使用 Try 传播错误，可以提高应用程序的健壮性，避免程序在遇到错误时崩溃，而是能够优雅地处理错误并给出有意义的错误提示。
总而言之，folly::Try 在构建健壮的应用程序中扮演着重要的角色。通过使用 Try，开发者可以更好地处理错误，提高代码的可读性和可维护性，并最终构建更可靠的软件系统。
END_OF_CHAPTER
4. chapter 4： Folly Try.h 高级进阶 (Folly Try.h Advanced Topics)
4.1 自定义异常类型与 Try (Custom Exception Types and Try)
在深入探索 folly::Try 的高级应用时，自定义异常类型扮演着至关重要的角色。虽然 Try 可以捕获和处理任何类型的异常，但在实际应用中，使用自定义异常类型 (custom exception types) 能够显著提升代码的可读性、可维护性和错误处理的精确性。本节将详细介绍如何在 Try 中有效地使用自定义异常类型，从而构建更加健壮和易于理解的 C++ 应用程序。
4.1.1 为什么要使用自定义异常类型 (Why Use Custom Exception Types)
使用自定义异常类型，而非仅仅依赖标准库提供的异常类型，具有以下几个关键优势：
① 语义清晰 (Semantic Clarity)：自定义异常类型能够更精确地表达程序中可能发生的特定错误情况。例如，如果你的应用程序需要处理文件操作，你可以定义 FileNotFoundException、FilePermissionException 等自定义异常，而不是笼统地抛出 std::runtime_error。这种更具描述性的异常类型能够让开发者快速理解错误的性质和来源。
② 类型安全 (Type Safety)：自定义异常类型允许在 catch 语句中进行更精确的异常捕获。你可以针对特定的自定义异常类型编写专门的错误处理逻辑，避免捕获到不相关的异常，从而提高程序的健壮性。
③ 信息丰富 (Rich Information)：自定义异常类型可以携带更多的错误信息。除了标准的错误消息之外，你可以在自定义异常类中添加额外的成员变量，例如错误代码、文件名、行号等，以便在错误发生时提供更详细的上下文信息，方便调试和问题定位。
④ 代码组织 (Code Organization)：通过定义一组相关的自定义异常类型，可以更好地组织和管理项目中的错误处理逻辑。你可以将这些自定义异常类型放在专门的头文件中，形成一个清晰的错误处理模块。
4.1.2 如何定义自定义异常类型 (How to Define Custom Exception Types)
在 C++ 中，定义自定义异常类型通常涉及创建一个继承自 std::exception 或其派生类的类。以下是一个简单的自定义异常类型示例：
1
#include <stdexcept>
2
#include <string>
3
4
class FileIOException : public std::runtime_error {
5
public:
6
FileIOException(const std::string& filename, const std::string& message)
7
: filename_(filename), std::runtime_error(message + " in file: " + filename) {}
8
9
const std::string& getFilename() const {
10
return filename_;
11
}
12
13
private:
14
std::string filename_;
15
};
在这个例子中，FileIOException 继承自 std::runtime_error，并添加了一个 filename_ 成员变量来存储文件名。构造函数接受文件名和错误消息，并将它们组合成更详细的错误消息。getFilename() 方法用于获取文件名。
4.1.3 在 Try 中使用自定义异常类型 (Using Custom Exception Types in Try)
在 folly::Try 中使用自定义异常类型非常简单。当你需要表示一个可能失败的操作时，可以使用 Try<T> 来包裹操作的结果，并在操作失败时抛出自定义异常。
1
#include <folly/Try.h>
2
#include <fstream>
3
#include <string>
4
5
folly::Try<std::string> readFileContent(const std::string& filename) {
6
std::ifstream file(filename);
7
if (!file.is_open()) {
8
return folly::make_exception_ptr<FileIOException>(filename, "Failed to open file");
9
}
10
11
std::string content;
12
std::string line;
13
while (std::getline(file, line)) {
14
content += line + "\n";
15
}
16
return content;
17
}
18
19
void processFile(const std::string& filename) {
20
auto contentTry = readFileContent(filename);
21
if (contentTry.hasException()) {
22
try {
23
contentTry.throwIfFailed(); // 抛出异常
24
} catch (const FileIOException& ex) {
25
std::cerr << "File IO Error: " << ex.what() << std::endl;
26
std::cerr << "Filename: " << ex.getFilename() << std::endl;
27
} catch (const std::exception& ex) {
28
std::cerr << "Unexpected error: " << ex.what() << std::endl;
29
}
30
} else {
31
std::cout << "File content:\n" << contentTry.value() << std::endl;
32
}
33
}
在这个例子中，readFileContent 函数尝试读取文件内容。如果文件打开失败，它会使用 folly::make_exception_ptr 创建一个 FileIOException 异常指针，并将其包装在 Try 对象中返回。在 processFile 函数中，我们检查 Try 对象是否包含异常。如果包含异常，我们使用 throwIfFailed() 抛出异常，并使用 catch 语句捕获 FileIOException 和其他标准异常，进行相应的错误处理。
4.1.4 自定义异常类型的最佳实践 (Best Practices for Custom Exception Types)
① 继承自 std::exception 或其派生类：确保你的自定义异常类型继承自 std::exception 或其派生类，以便与标准的异常处理机制兼容。
② 提供清晰的错误消息：在异常类的构造函数中，接受并存储有意义的错误消息，并在 what() 方法中返回，方便错误诊断。
③ 添加额外的上下文信息：根据需要，在自定义异常类中添加额外的成员变量，例如错误代码、资源 ID 等，以提供更丰富的错误上下文。
④ 避免过度使用异常：异常处理应该用于处理真正的异常情况，而不是作为正常的控制流机制。对于可预测的错误情况，可以考虑使用返回值或其他错误指示方法。
⑤ 文档化你的异常类型：清晰地文档化你的自定义异常类型，说明它们表示的错误情况以及何时可能抛出，方便团队成员理解和使用。
通过合理地使用自定义异常类型，并结合 folly::Try 的强大功能，你可以构建出更加健壮、易于维护和错误处理能力更强的 C++ 应用程序。自定义异常类型能够提升代码的表达力，使得错误处理逻辑更加清晰和精确，从而提高软件的整体质量。
4.2 Try 的性能考量与优化 (Performance Considerations and Optimization of Try)
folly::Try 作为一种强大的错误处理机制，在提高代码健壮性和可读性方面具有显著优势。然而，如同任何抽象层一样，理解其潜在的性能考量 (performance considerations) 并掌握优化技巧 (optimization techniques) 至关重要，尤其是在性能敏感的应用场景中。本节将深入探讨 Try 的性能特性，并提供一系列优化建议，帮助开发者在享受 Try 便利性的同时，最大限度地减少性能开销。
4.2.1 Try 的性能开销来源 (Sources of Performance Overhead in Try)
folly::Try 的性能开销主要来源于以下几个方面：
① 异常处理机制 (Exception Handling Mechanism)：当 Try 对象处于失败状态时，它内部会存储一个异常指针 (exception pointer)。异常指针的创建、存储和解引用都可能带来一定的性能开销，尤其是在频繁抛出和捕获异常的情况下。虽然 Try 避免了传统的 try-catch 块的开销，但异常对象本身的构造和析构仍然会消耗资源。
② 额外的间接层 (Extra Indirection)：Try 对象本质上是对可能成功或失败的操作结果的一种封装。访问 Try 对象的值或异常需要额外的间接层，这可能会引入轻微的性能损耗，尤其是在高频访问的场景下。
③ 内存分配 (Memory Allocation)：在某些情况下，例如当 Try 存储异常时，可能需要进行动态内存分配来存储异常对象。频繁的内存分配和释放操作可能会对性能产生负面影响。
④ 函数调用开销 (Function Call Overhead)：Try 提供了一系列操作函数，如 map、flatMap、or 等。这些函数调用本身会带来一定的开销，尤其是在链式调用复杂操作时。
4.2.2 Try 的性能优势 (Performance Advantages of Try)
尽管存在一定的性能开销，folly::Try 在某些方面也具有性能优势，尤其是在与传统的异常处理方式相比时：
① 避免 try-catch 的开销 (Avoiding try-catch Overhead)：传统的 try-catch 块在没有异常抛出时也会引入一定的性能开销，因为编译器需要生成额外的代码来维护调用栈 (call stack) 信息，以便在异常发生时进行栈展开 (stack unwinding)。Try 通过将异常处理延迟到需要时才进行，避免了这种预先的开销。
② 更清晰的控制流 (Clearer Control Flow)：使用 Try 可以使代码的控制流更加清晰，减少了 try-catch 块的嵌套，提高了代码的可读性和可维护性。清晰的代码结构本身也有助于性能优化，因为更容易进行分析和改进。
③ 延迟错误处理 (Deferred Error Handling)：Try 允许将错误处理延迟到合适的时机进行，而不是在错误发生时立即处理。这种延迟处理可以提高程序的响应性，尤其是在异步编程和并发场景中。
4.2.3 Try 的性能优化策略 (Performance Optimization Strategies for Try)
为了最大限度地减少 folly::Try 的性能开销，可以考虑以下优化策略：
① 减少异常抛出的频率 (Reduce Exception Throwing Frequency)：异常处理应该用于处理真正的异常情况，而不是作为正常的控制流。对于可预测的错误情况，例如输入验证失败、资源不可用等，可以考虑使用返回值、错误码或其他更轻量级的错误指示方法。只有在真正发生不可预期的错误时才抛出异常。
② 避免不必要的 Try 对象创建 (Avoid Unnecessary Try Object Creation)：如果某个操作不太可能失败，或者失败的代价很低，可以考虑直接返回结果，而不是使用 Try 包裹。只有在需要显式地处理可能发生的错误，并且错误处理逻辑比较复杂时，才使用 Try。
③ 使用 Try<void> 优化无返回值函数 (Optimize Void-Returning Functions with Try<void>)：对于不返回值的函数，可以使用 folly::Try<void> 来表示操作的成功或失败，避免不必要的返回值构造和拷贝开销。
④ 合理使用 map 和 flatMap (Use map and flatMap Judiciously)：map 和 flatMap 等操作函数提供了强大的链式操作能力，但也可能引入函数调用开销。在性能敏感的代码路径中，需要仔细评估这些操作的必要性，避免过度使用。
⑤ 考虑使用 assumeValue() 或 value() 的性能影响 (Consider Performance Impact of assumeValue() and value())：assumeValue() 和 value() 用于获取 Try 对象的值。assumeValue() 在 Try 对象处于失败状态时会调用 std::terminate()，性能略高，但不安全。value() 会抛出异常，性能略低，但更安全。根据具体场景选择合适的方法。在性能至关重要的代码路径中，如果能确保 Try 对象总是处于成功状态，可以使用 assumeValue()，否则应该使用 value() 并进行适当的异常处理。
⑥ 自定义内存分配器 (Custom Memory Allocator)：如果 Try 的内存分配成为性能瓶颈，可以考虑使用自定义内存分配器来优化内存管理。Folly 库本身提供了多种内存分配器，可以根据具体应用场景选择合适的分配器。
⑦ 编译器优化 (Compiler Optimization)：现代 C++ 编译器具有强大的优化能力。确保使用高优化级别编译代码（例如 -O2 或 -O3），并启用链接时优化 (Link-Time Optimization, LTO)，可以帮助编译器更好地优化 Try 的使用，减少性能开销。
⑧ 性能测试和分析 (Performance Testing and Profiling)：在进行性能优化时，务必进行充分的性能测试和分析。使用性能分析工具（例如 perf、gprof、valgrind 等）来定位性能瓶颈，并针对性地进行优化。不要过早优化，也不要盲目优化，要基于实际的性能数据进行优化。
总而言之，folly::Try 的性能开销通常是可以接受的，尤其是在大多数应用场景下。通过理解其性能特性，并采取适当的优化策略，可以在享受 Try 带来的代码清晰性和健壮性的同时，最大限度地减少性能损失。关键在于权衡代码的可读性、可维护性和性能需求，并根据具体情况做出合理的选择。
4.3 Try 与其他 Folly 组件的集成 (Integration of Try with Other Folly Components)
folly::Try 不仅自身功能强大，还能与其他 Folly 组件无缝集成，共同构建更加强大和高效的 C++ 应用程序。这种集成 (integration) 能力是 Folly 库设计哲学的重要体现，它鼓励开发者将不同的组件组合使用，发挥各自的优势，解决复杂的问题。本节将重点介绍 Try 与 Folly 中几个关键组件的集成应用，包括 Future、Promise 和 FBVector。
4.3.1 Try 与 Future/Promise 的集成 (Integration with Future/Promise)
folly::Future 和 folly::Promise 是 Folly 库中用于异步编程的核心组件。Future 代表一个异步操作的最终结果，而 Promise 用于设置 Future 的结果。Try 与 Future/Promise 的集成，使得异步操作的错误处理更加优雅和安全。
① Future<Try<T>>：异步操作的错误处理 (Error Handling in Asynchronous Operations)
在异步编程中，错误处理往往比同步编程更加复杂。使用 Future<Try<T>> 可以清晰地表示一个异步操作可能成功返回类型为 T 的值，或者失败并返回一个异常。
1
#include <folly/Future.h>
2
#include <folly/Promise.h>
3
#include <folly/Try.h>
4
#include <iostream>
5
6
folly::Future<folly::Try<int>> asyncDivide(int a, int b) {
7
folly::Promise<folly::Try<int>> promise;
8
folly::Future<folly::Try<int>> future = promise.getFuture();
9
10
std::thread([promise = std::move(promise), a, b]() mutable {
11
if (b == 0) {
12
promise.setValue(folly::makeFailure<int>(std::runtime_error("Division by zero")));
13
} else {
14
promise.setValue(folly::Try<int>(a / b));
15
}
16
}).detach();
17
18
return future;
19
}
20
21
int main() {
22
auto futureResult = asyncDivide(10, 2);
23
futureResult.then([](folly::Try<int> resultTry) {
24
if (resultTry.hasException()) {
25
std::cerr << "Async operation failed: " << resultTry.exception().what() << std::endl;
26
} else {
27
std::cout << "Async result: " << resultTry.value() << std::endl;
28
}
29
});
30
31
auto futureError = asyncDivide(10, 0);
32
futureError.then([](folly::Try<int> resultTry) {
33
if (resultTry.hasException()) {
34
std::cerr << "Async operation failed: " << resultTry.exception().what() << std::endl;
35
} else {
36
std::cout << "Async result: " << resultTry.value() << std::endl; // 不会执行到这里
37
}
38
});
39
40
return 0;
41
}
在这个例子中，asyncDivide 函数返回一个 Future<Try<int>>。当除数为零时，Promise 被设置为一个失败的 Try，其中包含一个 std::runtime_error 异常。在 main 函数中，我们使用 then 回调函数处理 Future 的结果。回调函数接收一个 folly::Try<int> 对象，可以检查操作是否成功，并获取结果或异常。
② Future::thenTry()：链式异步操作的错误传播 (Error Propagation in Chained Asynchronous Operations)
folly::Future 提供了 thenTry() 方法，用于在链式异步操作中处理 Try 对象。thenTry() 接收一个返回 Try<U> 的函数，并将前一个 Future 的结果（包装在 Try 中）传递给该函数。这使得在异步操作链中进行错误传播和处理变得非常方便。
1
#include <folly/Future.h>
2
#include <folly/Promise.h>
3
#include <folly/Try.h>
4
#include <iostream>
5
6
folly::Future<folly::Try<int>> asyncOperation1() {
7
folly::Promise<folly::Try<int>> promise;
8
folly::Future<folly::Try<int>> future = promise.getFuture();
9
promise.setValue(folly::Try<int>(10));
10
return future;
11
}
12
13
folly::Try<int> operation2(folly::Try<int> inputTry) {
14
if (inputTry.hasException()) {
15
return inputTry; // 传播之前的异常
16
}
17
int value = inputTry.value();
18
if (value < 0) {
19
return folly::makeFailure<int>(std::runtime_error("Value is negative"));
20
}
21
return folly::Try<int>(value * 2);
22
}
23
24
int main() {
25
auto futureResult = asyncOperation1()
26
.thenTry(operation2)
27
.then([](folly::Try<int> finalResultTry) {
28
if (finalResultTry.hasException()) {
29
std::cerr << "Chained async operation failed: " << finalResultTry.exception().what() << std::endl;
30
} else {
31
std::cout << "Final async result: " << finalResultTry.value() << std::endl;
32
}
33
});
34
return 0;
35
}
在这个例子中，asyncOperation1 返回一个成功的 Try<int> 的 Future。operation2 函数接收一个 Try<int> 对象作为输入，如果输入 Try 包含异常，则直接传播异常；否则，对成功的值进行处理，并返回一个新的 Try<int>。thenTry() 方法将 operation2 应用于 asyncOperation1 的结果，实现了链式异步操作和错误传播。
4.3.2 Try 与 FBVector 的集成 (Integration with FBVector)
folly::FBVector 是 Folly 库提供的高性能动态数组 (high-performance dynamic array) 容器，它在某些场景下比 std::vector 具有更好的性能。Try 可以与 FBVector 结合使用，处理容器操作中可能发生的错误。
① FBVector<Try<T>>：存储可能失败的操作结果 (Storing Results of Potentially Failing Operations)
可以使用 FBVector<Try<T>> 来存储一系列可能失败的操作的结果。例如，批量处理文件时，可以使用 FBVector<Try<FileData>> 来存储每个文件的处理结果，其中 FileData 是文件数据的类型。
1
#include <folly/FBVector.h>
2
#include <folly/Try.h>
3
#include <iostream>
4
#include <string>
5
#include <vector>
6
7
struct FileData {
8
std::string filename;
9
std::string content;
10
};
11
12
folly::Try<FileData> processFile(const std::string& filename) {
13
// 模拟文件处理，可能失败
14
if (filename == "bad_file.txt") {
15
return folly::makeFailure<FileData>(std::runtime_error("Failed to process file: " + filename));
16
}
17
return FileData{filename, "Content of " + filename};
18
}
19
20
int main() {
21
std::vector<std::string> filenames = {"file1.txt", "file2.txt", "bad_file.txt", "file3.txt"};
22
folly::FBVector<folly::Try<FileData>> results;
23
24
for (const auto& filename : filenames) {
25
results.push_back(processFile(filename));
26
}
27
28
for (const auto& resultTry : results) {
29
if (resultTry.hasException()) {
30
std::cerr << "File processing failed: " << resultTry.exception().what() << std::endl;
31
} else {
32
std::cout << "File processed successfully: " << resultTry.value().filename << std::endl;
33
}
34
}
35
36
return 0;
37
}
在这个例子中，processFile 函数模拟文件处理，对于 "bad_file.txt" 会返回一个失败的 Try。main 函数使用 FBVector<Try<FileData>> 存储每个文件的处理结果，并遍历结果向量，处理成功和失败的情况。
② 结合算法和 FBVector<Try<T>> 进行批量操作 (Batch Operations with Algorithms and FBVector<Try<T>>)
可以结合 Folly 提供的算法（例如 folly::algorithms::map、folly::algorithms::filter 等）和 FBVector<Try<T>>，对批量数据进行处理，并优雅地处理每个元素的错误。
1
#include <folly/FBVector.h>
2
#include <folly/Try.h>
3
#include <folly/algorithms/Algorithm.h>
4
#include <iostream>
5
#include <string>
6
#include <vector>
7
8
folly::Try<int> parseInt(const std::string& str) {
9
try {
10
return std::stoi(str);
11
} catch (const std::exception& ex) {
12
return folly::makeFailure<int>(ex);
13
}
14
}
15
16
int main() {
17
std::vector<std::string> strNumbers = {"10", "20", "invalid", "30"};
18
folly::FBVector<folly::Try<int>> tryNumbers;
19
20
folly::algorithms::transform(strNumbers.begin(), strNumbers.end(), std::back_inserter(tryNumbers), parseInt);
21
22
for (const auto& tryNumber : tryNumbers) {
23
if (tryNumber.hasException()) {
24
std::cerr << "Parsing failed: " << tryNumber.exception().what() << std::endl;
25
} else {
26
std::cout << "Parsed number: " << tryNumber.value() << std::endl;
27
}
28
}
29
30
return 0;
31
}
在这个例子中，parseInt 函数尝试将字符串转换为整数，并返回 Try<int>。folly::algorithms::transform 算法将 parseInt 应用于 strNumbers 向量中的每个元素，并将结果存储在 tryNumbers (类型为 FBVector<Try<int>>) 中。最后，遍历 tryNumbers 处理每个解析结果。
通过将 folly::Try 与 Future/Promise 和 FBVector 等 Folly 组件集成，可以构建出更加健壮、高效且易于维护的 C++ 应用程序，尤其是在异步编程和批量数据处理等复杂场景中。这种集成能力充分体现了 Folly 库的模块化和可组合性，为开发者提供了强大的工具箱。
4.4 Try 的高级错误处理模式 (Advanced Error Handling Patterns of Try)
folly::Try 不仅提供了基本的错误处理机制，还支持多种高级错误处理模式 (advanced error handling patterns)，帮助开发者应对更复杂的错误场景，例如错误聚合、错误恢复和重试机制等。这些高级模式能够提升应用程序的韧性 (resilience) 和可靠性 (reliability)，使其在面对错误时能够更加优雅地降级或恢复。本节将深入探讨这些高级错误处理模式，并提供实际应用示例。
4.4.1 错误聚合 (Error Aggregation)
在某些场景下，我们需要处理多个可能失败的操作，并收集所有发生的错误信息，而不是在遇到第一个错误时就立即停止。错误聚合 (error aggregation) 模式允许我们执行多个操作，并将所有失败的错误信息汇总到一个结果中。folly::Try 可以方便地实现错误聚合。
1
#include <folly/FBVector.h>
2
#include <folly/Try.h>
3
#include <iostream>
4
#include <stdexcept>
5
#include <string>
6
#include <vector>
7
8
folly::Try<int> operation(int input) {
9
if (input < 0) {
10
return folly::makeFailure<int>(std::runtime_error("Input is negative: " + std::to_string(input)));
11
}
12
if (input % 2 != 0) {
13
return folly::makeFailure<int>(std::runtime_error("Input is odd: " + std::to_string(input)));
14
}
15
return input * 2;
16
}
17
18
int main() {
19
std::vector<int> inputs = {2, 4, -1, 6, 7, 8};
20
folly::FBVector<folly::Try<int>> results;
21
folly::FBVector<std::exception_ptr> errors;
22
23
for (int input : inputs) {
24
results.push_back(operation(input));
25
}
26
27
for (const auto& resultTry : results) {
28
if (resultTry.hasException()) {
29
errors.push_back(resultTry.exceptionPtr());
30
} else {
31
std::cout << "Operation success: " << resultTry.value() << std::endl;
32
}
33
}
34
35
if (!errors.empty()) {
36
std::cerr << "Aggregated errors:" << std::endl;
37
for (const auto& errorPtr : errors) {
38
try {
39
std::rethrow_exception(errorPtr);
40
} catch (const std::exception& ex) {
41
std::cerr << "- " << ex.what() << std::endl;
42
}
43
}
44
}
45
46
return 0;
47
}
在这个例子中，operation 函数对输入进行一些检查，并可能返回失败的 Try。main 函数遍历一系列输入，执行 operation，并将结果存储在 results 向量中。然后，遍历 results 向量，将所有失败的异常指针收集到 errors 向量中。最后，如果 errors 向量不为空，则打印所有聚合的错误信息。
4.4.2 错误恢复 (Error Recovery)
错误恢复 (error recovery) 模式允许我们在操作失败时尝试进行恢复，而不是立即终止程序或传播错误。folly::Try 的 orElse 和 recover 方法可以用于实现错误恢复。
① orElse：提供备选值 (Providing Alternative Values with orElse)
orElse 方法允许在 Try 对象失败时提供一个备选值。如果 Try 成功，则返回原始值；如果失败，则返回备选值。
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <stdexcept>
4
#include <string>
5
6
folly::Try<int> mayFailOperation(int input) {
7
if (input < 0) {
8
return folly::makeFailure<int>(std::runtime_error("Input is negative: " + std::to_string(input)));
9
}
10
return input * 2;
11
}
12
13
int main() {
14
auto result1 = mayFailOperation(10).orElse(0); // 成功，返回 20
15
auto result2 = mayFailOperation(-5).orElse(0); // 失败，返回备选值 0
16
17
std::cout << "Result 1: " << result1.value() << std::endl;
18
std::cout << "Result 2: " << result2.value() << std::endl;
19
20
return 0;
21
}
在这个例子中，mayFailOperation 函数可能失败。orElse(0) 方法在 Try 失败时返回备选值 0，实现了简单的错误恢复。
② recover：执行恢复操作 (Performing Recovery Operations with recover)
recover 方法允许在 Try 对象失败时执行一个恢复函数。恢复函数接收失败的异常作为输入，并返回一个新的 Try 对象，表示恢复操作的结果。
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <stdexcept>
4
#include <string>
5
6
folly::Try<int> mayFailOperation(int input) {
7
if (input < 0) {
8
return folly::makeFailure<int>(std::runtime_error("Input is negative: " + std::to_string(input)));
9
}
10
return input * 2;
11
}
12
13
folly::Try<int> recoveryOperation(const std::exception_ptr& exPtr) {
14
try {
15
std::rethrow_exception(exPtr);
16
} catch (const std::runtime_error& ex) {
17
std::cerr << "Recovering from error: " << ex.what() << std::endl;
18
return 0; // 返回恢复后的值
19
} catch (...) {
20
return folly::makeFailure<int>(std::current_exception()); // 无法恢复，传播异常
21
}
22
}
23
24
int main() {
25
auto result1 = mayFailOperation(10).recover(recoveryOperation); // 成功，返回 20
26
auto result2 = mayFailOperation(-5).recover(recoveryOperation); // 失败，执行恢复操作，返回 0
27
28
std::cout << "Result 1: " << result1.value() << std::endl;
29
std::cout << "Result 2: " << result2.value() << std::endl;
30
31
return 0;
32
}
在这个例子中，recover(recoveryOperation) 方法在 mayFailOperation 失败时调用 recoveryOperation 函数。recoveryOperation 函数捕获异常，打印错误信息，并返回恢复后的值 0。如果发生其他类型的异常，则传播异常，表示无法恢复。
4.4.3 重试机制 (Retry Mechanism)
重试机制 (retry mechanism) 在网络请求、数据库操作等场景中非常常见。当操作失败时，可以尝试重新执行操作，期望在短暂的瞬时错误后能够成功。folly::Try 可以结合循环和延迟策略实现重试机制。
1
#include <folly/Try.h>
2
#include <chrono>
3
#include <iostream>
4
#include <stdexcept>
5
#include <thread>
6
7
folly::Try<int> flakyOperation() {
8
static int counter = 0;
9
counter++;
10
if (counter < 3) {
11
std::cerr << "Flaky operation failed (attempt " << counter << ")" << std::endl;
12
return folly::makeFailure<int>(std::runtime_error("Flaky operation failed"));
13
}
14
std::cout << "Flaky operation succeeded (attempt " << counter << ")" << std::endl;
15
return 42;
16
}
17
18
int main() {
19
int maxRetries = 3;
20
int retryDelayMs = 100;
21
folly::Try<int> resultTry;
22
23
for (int attempt = 1; attempt <= maxRetries; ++attempt) {
24
resultTry = flakyOperation();
25
if (resultTry.isSuccess()) {
26
break; // 成功，跳出循环
27
}
28
if (attempt < maxRetries) {
29
std::this_thread::sleep_for(std::chrono::milliseconds(retryDelayMs)); // 延迟重试
30
}
31
}
32
33
if (resultTry.hasException()) {
34
std::cerr << "Operation failed after " << maxRetries << " retries: " << resultTry.exception().what() << std::endl;
35
} else {
36
std::cout << "Final result: " << resultTry.value() << std::endl;
37
}
38
39
return 0;
40
}
在这个例子中，flakyOperation 函数模拟一个不稳定的操作，前两次调用会失败，第三次调用会成功。main 函数使用循环和延迟实现了重试机制。它最多重试 maxRetries 次，每次重试之间延迟 retryDelayMs 毫秒。如果最终操作成功，则跳出循环；如果所有重试都失败，则报告错误。
通过灵活运用错误聚合、错误恢复和重试机制等高级错误处理模式，并结合 folly::Try 提供的丰富 API，可以构建出更加健壮、可靠和用户体验更好的 C++ 应用程序。这些模式能够帮助应用程序更好地应对各种错误场景，提高系统的整体稳定性。
4.5 深入源码：Try 的实现原理分析 (In-depth Source Code Analysis of Try's Implementation Principles)
为了更深入地理解 folly::Try 的工作机制，并更好地利用其特性，本节将深入源码 (in-depth source code)，对 Try 的实现原理 (implementation principles) 进行详细分析。我们将重点关注 Try 的核心数据结构、关键成员函数以及异常处理机制，揭示 Try 背后的设计思想和实现细节。
4.5.1 Try 的核心数据结构 (Core Data Structures of Try)
folly::Try 的核心数据结构主要由以下几个部分组成：
① union 存储值或异常 (Union to Store Value or Exception)：Try 使用 union 来存储成功的值或失败的异常。这样做的好处是节省内存空间，因为在任何时候，Try 对象要么存储一个值，要么存储一个异常，两者不会同时存在。union 的定义大致如下：
1
union Storage {
2
T value_; // 存储成功的值
3
std::exception_ptr exception_; // 存储异常指针
4
5
Storage() {} // 默认构造函数
6
~Storage() {} // 默认析构函数，需要注意异常指针的析构
7
Storage(const Storage&) = delete; // 禁用拷贝构造函数
8
Storage& operator=(const Storage&) = delete; // 禁用拷贝赋值运算符
9
};
需要注意的是，由于 union 的特性，需要手动管理存储对象的生命周期，尤其是在存储异常指针时。
② 状态标志 (State Flag)：Try 需要维护一个状态标志，来区分当前对象是处于成功状态还是失败状态。这个状态标志通常是一个 bool 类型的成员变量，例如 hasException_。当 hasException_ 为 true 时，表示 Try 对象存储的是异常；当为 false 时，表示存储的是值。
③ 类型擦除 (Type Erasure)：为了能够存储任意类型的异常，Try 使用 std::exception_ptr 来存储异常。std::exception_ptr 是一种类型擦除 (type erasure) 的机制，它可以指向任何类型的异常对象，而无需在编译时知道异常的具体类型。这使得 Try 能够处理各种类型的异常，包括自定义异常类型。
4.5.2 Try 的关键成员函数 (Key Member Functions of Try)
folly::Try 提供了丰富的成员函数，用于操作和访问 Try 对象。以下是一些关键成员函数的实现原理分析：
① 构造函数 (Constructors)：Try 提供了多种构造函数，用于创建不同状态的 Try 对象。
▮▮▮▮⚝ 默认构造函数 (Default Constructor)：创建一个未初始化的 Try 对象，通常不直接使用。
▮▮▮▮⚝ 值构造函数 (Value Constructor)：Try(T value)：创建一个成功的 Try 对象，存储指定的值。在内部，会将值 value 拷贝到 union Storage 的 value_ 成员中，并将状态标志设置为成功。
▮▮▮▮⚝ 异常指针构造函数 (Exception Pointer Constructor)：Try(exception_ptr exPtr)：创建一个失败的 Try 对象，存储指定的异常指针。在内部，会将异常指针 exPtr 拷贝到 union Storage 的 exception_ 成员中，并将状态标志设置为失败。
▮▮▮▮⚝ 移动构造函数 (Move Constructor) 和 移动赋值运算符 (Move Assignment Operator)：为了提高性能，Try 实现了移动构造和移动赋值，避免不必要的拷贝操作。
② hasException() 和 isSuccess()：这两个方法用于检查 Try 对象的状态。它们通过检查状态标志 hasException_ 的值来判断 Try 对象是处于失败状态还是成功状态。
③ value() 和 throwIfFailed()：这两个方法用于获取 Try 对象的值或抛出异常。
▮▮▮▮⚝ value()：如果 Try 对象处于成功状态，则返回存储的值的拷贝 (copy)。如果处于失败状态，则抛出存储的异常。实现时，首先检查状态标志，如果成功，则返回 value_ 的拷贝；如果失败，则使用 std::rethrow_exception(exception_) 重新抛出异常。
▮▮▮▮⚝ throwIfFailed()：如果 Try 对象处于失败状态，则抛出存储的异常。如果处于成功状态，则不执行任何操作。实现时，只检查状态标志，如果失败，则使用 std::rethrow_exception(exception_) 重新抛出异常。
④ map() 和 flatMap()：这两个方法用于对 Try 对象的值进行转换或链式操作。
▮▮▮▮⚝ map(F f)：如果 Try 对象处于成功状态，则将存储的值传递给函数 f 进行转换，并将转换结果包装在一个新的 Try 对象中返回。如果 Try 对象处于失败状态，则直接返回一个新的失败的 Try 对象，并传播原始异常。
▮▮▮▮⚝ flatMap(F f)：与 map() 类似，但函数 f 需要返回一个 Try<U> 对象。flatMap() 用于实现链式操作，避免 Try<Try<T>> 的嵌套。如果原始 Try 失败，则传播异常；如果成功，则调用 f 并返回其结果。
⑤ or() 和 orElse()：这两个方法用于提供备选值或执行备选操作。
▮▮▮▮⚝ or(Try<T> alternative)：如果原始 Try 对象成功，则返回原始 Try 对象；如果失败，则返回备选的 Try 对象 alternative。
▮▮▮▮⚝ orElse(F f)：如果原始 Try 对象成功，则返回原始 Try 对象；如果失败，则调用函数 f 获取备选的 Try<T> 对象并返回。
4.5.3 Try 的异常处理机制 (Exception Handling Mechanism of Try)
folly::Try 的异常处理机制主要依赖于 C++ 的异常处理 (exception handling) 机制和 std::exception_ptr。
① 捕获异常 (Catching Exceptions)：当使用 folly::makeTry() 或其他工厂函数创建 Try 对象时，如果被包装的函数抛出异常，Try 会捕获该异常，并将其存储为 std::exception_ptr。
② 存储异常指针 (Storing Exception Pointer)：Try 使用 std::exception_ptr 来存储捕获的异常。std::exception_ptr 允许在不同的线程或作用域之间传递异常信息，而不会立即抛出异常。
③ 重新抛出异常 (Rethrowing Exceptions)：当调用 value() 或 throwIfFailed() 等方法时，如果 Try 对象处于失败状态，Try 会使用 std::rethrow_exception(exception_) 重新抛出存储的异常。std::rethrow_exception() 会根据 std::exception_ptr 中存储的异常类型和信息，创建一个新的异常对象并抛出。
④ 异常安全 (Exception Safety)：folly::Try 的实现非常注重异常安全 (exception safety)。在各种操作中，例如拷贝、移动、赋值等，都保证了即使在异常发生的情况下，程序的状态仍然是有效的，不会发生资源泄漏或数据损坏。
通过深入源码分析，我们可以看到 folly::Try 的实现并不复杂，但设计精巧，充分利用了 C++ 的语言特性，例如 union、std::exception_ptr、移动语义等，实现了高效、安全且易于使用的错误处理机制。理解 Try 的实现原理，有助于我们更好地掌握其使用方法，并在实际项目中灵活应用。
END_OF_CHAPTER
5. chapter 5： Folly Try.h API 全面解析 (Folly Try.h API Comprehensive Analysis)
5.1 folly::Try 类详解 (folly::Try Class Detailed Explanation)
folly::Try<T> 是 Folly 库中用于显式处理可能失败操作的核心类。它模仿了函数式编程中 Try Monad 的概念，旨在提供一种比传统 C++ 异常处理机制更安全、更可控的方式来管理错误和异常情况。Try<T> 对象可以处于两种状态之一：成功（Success） 或 失败（Failure）。
核心概念：
⚝ 显式错误处理（Explicit Error Handling）：与隐式的异常抛出和捕获不同，Try 迫使开发者显式地考虑和处理操作可能失败的情况。这提高了代码的可读性和可维护性，并减少了因未捕获异常导致的程序崩溃的风险。
⚝ 值或异常的容器（Container for Value or Exception）：Try<T> 本质上是一个容器，它可以存储类型为 T 的成功值，或者存储一个表示失败原因的异常对象。
⚝ 函数式编程风格（Functional Programming Style）：Try 提供了 map、flatMap、or、orElse 等函数式操作，使得可以以链式调用的方式优雅地处理可能失败的操作序列。
folly::Try<T> 类的结构：
folly::Try<T> 是一个模板类，其中 T 代表操作成功时返回的值的类型。其内部结构大致可以理解为维护了一个状态标志和一个联合体，用于存储成功值或异常对象。
1
namespace folly {
2
3
template <typename T>
4
class Try final {
5
public:
6
// ... 公有成员函数 ...
7
8
private:
9
enum class State : uint8_t {
10
Empty, // 初始状态，未赋值
11
Success, // 成功状态，存储值
12
Failure // 失败状态，存储异常
13
};
14
15
State state_;
16
std::aligned_storage_t<sizeof(T), alignof(T)> valueStorage_;
17
exception_storage exceptionStorage_;
18
// ... 私有成员 ...
19
};
20
21
} // namespace folly
关键成员函数：
⚝ 构造函数（Constructors）：
▮▮▮▮⚝ 默认构造函数：Try()，创建一个空的 Try 对象，状态为 Empty。
▮▮▮▮⚝ 值构造函数：Try(T value)，创建一个成功的 Try 对象，存储值 value。
▮▮▮▮⚝ 异常构造函数：Try(exception_ptr ex)，创建一个失败的 Try 对象，存储异常 ex。通常不直接使用，而是通过工厂函数创建。
▮▮▮▮⚝ 拷贝/移动构造函数和赋值运算符：支持拷贝和移动语义。
⚝ 状态检查（State Inspection）：
▮▮▮▮⚝ bool hasValue() const noexcept;：检查 Try 对象是否处于成功状态（即是否包含值）。
▮▮▮▮⚝ bool hasException() const noexcept;：检查 Try 对象是否处于失败状态（即是否包含异常）。
▮▮▮▮⚝ bool isEmpty() const noexcept;：检查 Try 对象是否处于空状态。
⚝ 值和异常访问（Value and Exception Access）：
▮▮▮▮⚝ const T& value() const&; 和 T&& value() &&;：返回成功状态下的值。如果 Try 对象处于失败状态，则抛出异常。
▮▮▮▮⚝ exception_ptr exception() const noexcept;：返回失败状态下的异常指针。如果 Try 对象处于成功状态，则返回空指针。
▮▮▮▮⚝ T value_or(T defaultValue) const&; 和 T value_or(T defaultValue) &&;：如果 Try 对象处于成功状态，则返回值；否则返回提供的默认值 defaultValue。
▮▮▮▮⚝ template <typename F> auto value_or_else(F&& fallback) const&; 和 template <typename F> auto value_or_else(F&& fallback) &&;：如果 Try 对象处于成功状态，则返回值；否则调用提供的回调函数 fallback 并返回其结果。fallback 可以是一个 lambda 表达式或函数对象，用于动态计算备选值。
⚝ 转换操作（Transformation Operations）：
▮▮▮▮⚝ template <typename F> auto map(F&& f) &&; 和 template <typename F> auto map(F&& f) const&;：如果 Try 对象处于成功状态，则将存储的值传递给函数 f 并返回一个新的 Try 对象，其中包含 f 的返回值。如果 Try 对象处于失败状态，则直接返回一个新的失败的 Try 对象，异常保持不变。
▮▮▮▮⚝ template <typename F> auto flatMap(F&& f) &&; 和 template <typename F> auto flatMap(F&& f) const&;：类似于 map，但要求函数 f 返回一个 Try 对象。flatMap 用于链式操作，避免嵌套的 Try 对象。
▮▮▮▮⚝ template <typename F> auto onFailure(F&& f) &&; 和 template <typename F> auto onFailure(F&& f) const&;：如果 Try 对象处于失败状态，则执行函数 f，并将异常对象传递给 f。返回原始的 Try 对象，允许链式调用。
▮▮▮▮⚝ template <typename F> auto recover(F&& f) &&; 和 template <typename F> auto recover(F&& f) const&;：如果 Try 对象处于失败状态，则将异常对象传递给函数 f，并返回一个新的 Try 对象，其中包含 f 的返回值。recover 用于从失败状态中恢复，例如提供备选值或重试操作。
▮▮▮▮⚝ template <typename F> auto recoverWith(F&& f) &&; 和 template <typename F> auto recoverWith(F&& f) const&;：类似于 recover，但要求函数 f 返回一个 Try 对象。recoverWith 用于从失败状态中恢复，并返回一个新的 Try 对象，通常用于链式错误处理。
▮▮▮▮⚝ Try<void> unit() &&; 和 Try<void> unit() const&;：将 Try<T> 转换为 Try<void>，丢弃成功的值，但保留失败状态和异常。
⚝ 组合操作（Combination Operations）：
▮▮▮▮⚝ Try<T> or_(Try<T> other) &&; 和 Try<T> or_(Try<T> other) const&;：如果当前的 Try 对象处于成功状态，则返回当前对象；否则返回 other 对象。
▮▮▮▮⚝ template <typename F> auto orElse(F&& otherFactory) &&; 和 template <typename F> auto orElse(F&& otherFactory) const&;：类似于 or_，但 otherFactory 是一个函数，只有在当前 Try 对象处于失败状态时才会被调用，用于延迟计算备选的 Try 对象。
代码示例：
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <stdexcept>
4
5
using namespace folly;
6
7
Try<int> divide(int a, int b) {
8
if (b == 0) {
9
return Try<int>(std::make_exception_ptr(std::runtime_error("Division by zero")));
10
}
11
return Try<int>(a / b);
12
}
13
14
int main() {
15
auto result1 = divide(10, 2);
16
if (result1.hasValue()) {
17
std::cout << "Result 1: " << result1.value() << std::endl; // 输出 Result 1: 5
18
}
19
20
auto result2 = divide(10, 0);
21
if (result2.hasException()) {
22
try {
23
std::rethrow_exception(result2.exception());
24
} catch (const std::exception& e) {
25
std::cerr << "Error: " << e.what() << std::endl; // 输出 Error: Division by zero
26
}
27
}
28
29
auto result3 = divide(15, 3)
30
.map([](int x) { return x * 2; })
31
.map([](int x) { return std::to_string(x); });
32
33
if (result3.hasValue()) {
34
std::cout << "Result 3: " << result3.value() << std::endl; // 输出 Result 3: 10
35
}
36
37
return 0;
38
}
总结：
folly::Try<T> 类是 Folly 库中用于处理可能失败操作的核心工具。它提供了类型安全、显式的错误处理机制，并支持函数式编程风格的操作，使得 C++ 代码更加健壮、易读和易维护。理解 Try 类的结构和关键成员函数是掌握 Folly 库错误处理的基础。
5.2 Try 的工厂函数与辅助函数 (Factory Functions and Helper Functions of Try)
除了 folly::Try<T> 类的构造函数，Folly 还提供了一系列工厂函数和辅助函数，用于更方便地创建和操作 Try 对象。这些函数旨在简化常见的使用场景，并提供更具表达力的 API。
工厂函数（Factory Functions）：
⚝ Try<T> makeTry(F&& f)：
▮▮▮▮⚝ 这是创建 Try 对象最常用的工厂函数。它接受一个可调用对象 f（例如 lambda 表达式、函数指针、函数对象）。
▮▮▮▮⚝ makeTry 会执行 f。如果 f 执行成功并返回值，makeTry 会返回一个包含返回值的成功状态的 Try<T> 对象。
▮▮▮▮⚝ 如果 f 执行过程中抛出异常，makeTry 会捕获该异常，并返回一个包含该异常的失败状态的 Try<T> 对象。
▮▮▮▮⚝ makeTry 使得将任何可能抛出异常的函数转换为返回 Try 对象的函数变得非常容易。
1
#include <folly/Try.h>
2
#include <stdexcept>
3
#include <iostream>
4
5
using namespace folly;
6
7
int riskyFunction(int x) {
8
if (x < 0) {
9
throw std::runtime_error("Input cannot be negative");
10
}
11
return x * 2;
12
}
13
14
int main() {
15
auto tryResult1 = makeTry([&] { return riskyFunction(5); });
16
if (tryResult1.hasValue()) {
17
std::cout << "Result 1: " << tryResult1.value() << std::endl; // 输出 Result 1: 10
18
}
19
20
auto tryResult2 = makeTry([&] { return riskyFunction(-1); });
21
if (tryResult2.hasException()) {
22
try {
23
std::rethrow_exception(tryResult2.exception());
24
} catch (const std::exception& e) {
25
std::cerr << "Error: " << e.what() << std::endl; // 输出 Error: Input cannot be negative
26
}
27
}
28
return 0;
29
}
⚝ Try<T> Try<T>::success(T value)：
▮▮▮▮⚝ 静态成员函数，用于显式创建一个成功状态的 Try<T> 对象，并包含指定的值 value。
▮▮▮▮⚝ 适用于在已知操作成功的情况下，直接创建 Try 对象。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
using namespace folly;
5
6
Try<std::string> getGreeting(bool success) {
7
if (success) {
8
return Try<std::string>::success("Hello, world!");
9
} else {
10
return Try<std::string>(std::make_exception_ptr(std::runtime_error("Failed to get greeting")));
11
}
12
}
13
14
int main() {
15
auto tryResult = getGreeting(true);
16
if (tryResult.hasValue()) {
17
std::cout << "Greeting: " << tryResult.value() << std::endl; // 输出 Greeting: Hello, world!
18
}
19
return 0;
20
}
⚝ Try<T> Try<T>::failure(exception_ptr ex)：
▮▮▮▮⚝ 静态成员函数，用于显式创建一个失败状态的 Try<T> 对象，并包含指定的异常指针 ex。
▮▮▮▮⚝ 适用于在已知操作失败，并且已经捕获到异常的情况下，创建 Try 对象。通常与 std::make_exception_ptr 结合使用。
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <stdexcept>
4
5
using namespace folly;
6
7
Try<int> processData(int input) {
8
if (input < 0) {
9
return Try<int>::failure(std::make_exception_ptr(std::invalid_argument("Input must be non-negative")));
10
}
11
return Try<int>(input * 2);
12
}
13
14
int main() {
15
auto tryResult = processData(-5);
16
if (tryResult.hasException()) {
17
try {
18
std::rethrow_exception(tryResult.exception());
19
} catch (const std::exception& e) {
20
std::cerr << "Error: " << e.what() << std::endl; // 输出 Error: Input must be non-negative
21
}
22
}
23
return 0;
24
}
辅助函数（Helper Functions）：
⚝ Expected<T, E> try_cast<T, E>(Try<T>&& t) 和 Expected<T, E> try_cast<T, E>(const Try<T>& t)：
▮▮▮▮⚝ 将 Try<T> 对象转换为 Expected<T, E> 对象。Expected<T, E> 是 Folly 库中另一个用于显式错误处理的类，它使用类型 E 来表示错误，而不是异常。
▮▮▮▮⚝ 如果 Try<T> 对象处于成功状态，try_cast 会返回一个包含值的成功状态的 Expected<T, E> 对象。
▮▮▮▮⚝ 如果 Try<T> 对象处于失败状态，try_cast 会将 Try 中存储的异常转换为类型 E 的错误值，并返回一个包含错误值的失败状态的 Expected<T, E> 对象。转换过程需要提供一个从 exception_ptr 到 E 的转换方式（通常通过 ErrorPolicy 模板参数指定）。
▮▮▮▮⚝ try_cast 用于在 Try 和 Expected 之间进行转换，方便在不同的错误处理策略之间切换。
1
#include <folly/Try.h>
2
#include <folly/Expected.h>
3
#include <iostream>
4
#include <stdexcept>
5
6
using namespace folly;
7
8
enum class MyError {
9
DivisionByZero,
10
InvalidArgument
11
};
12
13
Expected<int, MyError> divideExpected(int a, int b) {
14
if (b == 0) {
15
return makeUnexpected(MyError::DivisionByZero);
16
}
17
return a / b;
18
}
19
20
Try<int> divideTry(int a, int b) {
21
if (b == 0) {
22
return Try<int>(std::make_exception_ptr(std::runtime_error("Division by zero")));
23
}
24
return Try<int>(a / b);
25
}
26
27
MyError exceptionToMyError(exception_ptr ex) {
28
try {
29
std::rethrow_exception(ex);
30
} catch (const std::runtime_error&) {
31
return MyError::DivisionByZero;
32
} catch (const std::invalid_argument&) {
33
return MyError::InvalidArgument;
34
} catch (...) {
35
return MyError::InvalidArgument; // 默认错误
36
}
37
}
38
39
int main() {
40
auto tryResult = divideTry(10, 0);
41
auto expectedResult = try_cast<int, MyError>(tryResult, exceptionToMyError);
42
43
if (expectedResult.hasValue()) {
44
std::cout << "Expected Result Value: " << expectedResult.value() << std::endl;
45
} else {
46
std::cout << "Expected Result Error: " << static_cast<int>(expectedResult.error()) << std::endl; // 输出 Expected Result Error: 0 (MyError::DivisionByZero)
47
}
48
return 0;
49
}
⚝ Try<void> unit(Try<T>&& t) 和 Try<void> unit(const Try<T>& t)：
▮▮▮▮⚝ 将 Try<T> 对象转换为 Try<void> 对象。
▮▮▮▮⚝ 如果输入的 Try<T> 对象处于成功状态，unit 会返回一个成功状态的 Try<void> 对象。
▮▮▮▮⚝ 如果输入的 Try<T> 对象处于失败状态，unit 会返回一个失败状态的 Try<void> 对象，并保留原始的异常信息。
▮▮▮▮⚝ unit 用于在只需要关注操作是否成功，而不需要返回值的情况下，丢弃成功的值，但保留错误信息。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
using namespace folly;
5
6
Try<int> processAndGetValue(int input) {
7
if (input < 0) {
8
return Try<int>(std::make_exception_ptr(std::invalid_argument("Input must be non-negative")));
9
}
10
return Try<int>(input * 2);
11
}
12
13
Try<void> processOnly(int input) {
14
return unit(processAndGetValue(input)); // 丢弃返回值，只关注成功或失败
15
}
16
17
int main() {
18
auto tryResultVoid1 = processOnly(10);
19
if (tryResultVoid1.hasValue()) {
20
std::cout << "Process 1 succeeded." << std::endl; // 输出 Process 1 succeeded.
21
}
22
23
auto tryResultVoid2 = processOnly(-5);
24
if (tryResultVoid2.hasException()) {
25
try {
26
std::rethrow_exception(tryResultVoid2.exception());
27
} catch (const std::exception& e) {
28
std::cerr << "Process 2 failed: " << e.what() << std::endl; // 输出 Process 2 failed: Input must be non-negative
29
}
30
}
31
return 0;
32
}
总结：
Folly 提供的工厂函数和辅助函数极大地简化了 Try 对象的创建和转换。makeTry 使得将普通函数转换为返回 Try 对象的函数变得容易，Try::success 和 Try::failure 提供了显式创建成功和失败 Try 对象的方式，try_cast 实现了 Try 到 Expected 的转换，而 unit 则用于丢弃 Try 对象的值。熟练掌握这些函数可以更高效地使用 folly::Try 进行错误处理。
5.3 Try 的操作符重载 (Operator Overloading of Try)
folly::Try<T> 类为了提供更简洁和直观的使用方式，重载了一些常用的操作符。这些操作符使得 Try 对象可以像普通的值一样参与运算和逻辑判断，同时保持了错误处理的能力。
重载的操作符：
⚝ operator bool() const noexcept (显式转换为 bool)：
▮▮▮▮⚝ 将 Try 对象显式转换为 bool 类型。
▮▮▮▮⚝ 如果 Try 对象处于成功状态（hasValue() == true），则返回 true。
▮▮▮▮⚝ 如果 Try 对象处于失败状态（hasException() == true）或空状态（isEmpty() == true），则返回 false。
▮▮▮▮⚝ 这个操作符使得可以像条件判断语句中直接使用 Try 对象，例如 if (myTry) { ... }。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
using namespace folly;
5
6
Try<int> mayFail(bool succeed) {
7
if (succeed) {
8
return Try<int>(10);
9
} else {
10
return Try<int>(std::make_exception_ptr(std::runtime_error("Operation failed")));
11
}
12
}
13
14
int main() {
15
auto tryResult1 = mayFail(true);
16
if (tryResult1) { // 使用 operator bool()
17
std::cout << "Try 1 succeeded." << std::endl; // 输出 Try 1 succeeded.
18
} else {
19
std::cout << "Try 1 failed." << std::endl;
20
}
21
22
auto tryResult2 = mayFail(false);
23
if (tryResult2) {
24
std::cout << "Try 2 succeeded." << std::endl;
25
} else {
26
std::cout << "Try 2 failed." << std::endl; // 输出 Try 2 failed.
27
}
28
return 0;
29
}
⚝ T const* operator->() const noexcept 和 T* operator->() noexcept (指针解引用操作符)：
▮▮▮▮⚝ 重载指针解引用操作符 ->，使得可以像访问指针一样访问 Try 对象内部的值的成员。
▮▮▮▮⚝ 只有当 Try 对象处于成功状态时，才能使用 operator->()。如果 Try 对象处于失败状态，行为是未定义的（通常会导致程序崩溃，应避免在失败状态下使用）。
▮▮▮▮⚝ 通常与存储指针类型的 Try 对象一起使用，例如 Try<std::unique_ptr<MyClass>>。
1
#include <folly/Try.h>
2
#include <iostream>
3
#include <memory>
4
5
using namespace folly;
6
7
class MyClass {
8
public:
9
void printMessage() const {
10
std::cout << "Hello from MyClass!" << std::endl;
11
}
12
};
13
14
Try<std::unique_ptr<MyClass>> createMyClass(bool succeed) {
15
if (succeed) {
16
return Try<std::unique_ptr<MyClass>>(std::make_unique<MyClass>());
17
} else {
18
return Try<std::unique_ptr<MyClass>>(std::make_exception_ptr(std::runtime_error("Failed to create MyClass")));
19
}
20
}
21
22
int main() {
23
auto tryResult = createMyClass(true);
24
if (tryResult) {
25
tryResult->get()->printMessage(); // 使用 operator->() 访问成员函数，注意需要先 get() 获取指针
26
tryResult.value()->printMessage(); // 或者先 value() 获取指针再访问
27
}
28
29
return 0;
30
}
1
**注意：** 上述代码示例中，为了安全地使用 `operator->()`，仍然需要先检查 `Try` 对象是否成功，并使用 `value()` 获取原始指针，然后再调用 `printMessage()`。直接使用 `tryResult->printMessage()` 是不安全的，因为 `operator->()` 返回的是原始指针，而不是 `Try` 对象本身，无法进行状态检查。更安全和推荐的方式是使用 `map` 或 `flatMap` 等函数式操作来处理 `Try` 对象的值。
⚝ T const& operator*() const& 和 T& operator*() & 和 T&& operator*() && (解引用操作符)：
▮▮▮▮⚝ 重载解引用操作符 *，使得可以像解引用指针一样获取 Try 对象内部的值的引用。
▮▮▮▮⚝ 只有当 Try 对象处于成功状态时，才能使用 operator*()。如果 Try 对象处于失败状态，则行为是未定义的（通常会抛出异常）。
▮▮▮▮⚝ 类似于 operator->()，直接使用 operator*() 也是不安全的，需要先检查 Try 对象的状态。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
using namespace folly;
5
6
Try<int> getIntValue(bool succeed, int value) {
7
if (succeed) {
8
return Try<int>(value);
9
} else {
10
return Try<int>(std::make_exception_ptr(std::runtime_error("Failed to get value")));
11
}
12
}
13
14
int main() {
15
auto tryResult = getIntValue(true, 42);
16
if (tryResult) {
17
int value = *tryResult; // 使用 operator*() 获取值
18
std::cout << "Value: " << value << std::endl; // 输出 Value: 42
19
}
20
return 0;
21
}
1
**注意：** 同样地，直接使用 `operator*()` 前需要确保 `Try` 对象处于成功状态。更安全的方式是使用 `value()` 成员函数或函数式操作。
总结：
folly::Try<T> 重载的操作符主要是为了提供更方便的语法糖，使得在某些场景下可以更简洁地访问和使用 Try 对象。然而，需要特别注意的是，直接使用 operator bool()、operator->() 和 operator*() 时，仍然需要谨慎处理 Try 对象的失败状态，避免在失败状态下进行值访问。更推荐的做法是结合 Try 提供的函数式操作（如 map、flatMap、value_or 等）来安全地处理 Try 对象，而不是过度依赖操作符重载。操作符重载更多的是为了在某些特定场景下提供更符合直觉的语法，但错误处理的核心仍然需要通过显式地检查状态和使用函数式操作来完成。
5.4 Try 的相关类型与定义 (Related Types and Definitions of Try)
folly::Try.h 头文件中除了 folly::Try<T> 类本身，还定义了一些相关的类型和别名，这些类型和别名在与 Try 一起使用时非常有用，可以提高代码的可读性和表达力。
相关类型和定义：
⚝ Try<T>::ValueType：
▮▮▮▮⚝ 类型别名，表示 Try<T> 对象成功时存储的值的类型，即模板参数 T。
▮▮▮▮⚝ 例如，对于 Try<int>，Try<int>::ValueType 就是 int。
⚝ Try<T>::ExceptionType：
▮▮▮▮⚝ 类型别名，表示 Try<T> 对象失败时存储的异常对象的类型，固定为 std::exception_ptr。
▮▮▮▮⚝ Try<T>::ExceptionType 始终是 std::exception_ptr。
⚝ Try<void>：
▮▮▮▮⚝ Try 模板类的一个特化版本，用于表示只关注操作是否成功，而不需要返回值的场景。
▮▮▮▮⚝ Try<void> 对象可以处于成功或失败状态，但成功状态下不存储任何值。
▮▮▮▮⚝ Try<void> 常用于表示副作用操作（side-effect operations）的结果，例如网络请求、文件写入等。
1
#include <folly/Try.h>
2
#include <iostream>
3
4
using namespace folly;
5
6
Try<void> doSomething(bool succeed) {
7
if (succeed) {
8
std::cout << "Operation succeeded." << std::endl;
9
return Try<void>::success(); // 返回成功的 Try<void>
10
} else {
11
std::cerr << "Operation failed." << std::endl;
12
return Try<void>::failure(std::make_exception_ptr(std::runtime_error("Something went wrong"))); // 返回失败的 Try<void>
13
}
14
}
15
16
int main() {
17
auto tryResultVoid1 = doSomething(true);
18
if (tryResultVoid1.hasValue()) {
19
std::cout << "Try<void> 1 succeeded." << std::endl; // 输出 Try<void> 1 succeeded.
20
}
21
22
auto tryResultVoid2 = doSomething(false);
23
if (tryResultVoid2.hasException()) {
24
try {
25
std::rethrow_exception(tryResultVoid2.exception());
26
} catch (const std::exception& e) {
27
std::cerr << "Try<void> 2 failed: " << e.what() << std::endl; // 输出 Try<void> 2 failed: Something went wrong
28
}
29
}
30
return 0;
31
}
⚝ exception_ptr (来自 <exception> 头文件)：
▮▮▮▮⚝ std::exception_ptr 是 C++ 标准库中用于表示异常对象的智能指针。
▮▮▮▮⚝ Try<T> 使用 exception_ptr 来存储失败状态下的异常对象。
▮▮▮▮⚝ exception_ptr 可以安全地在线程之间传递异常，并在稍后重新抛出异常。
▮▮▮▮⚝ 常用的与 exception_ptr 相关的函数包括：
▮▮▮▮▮▮▮▮⚝ std::make_exception_ptr(exception)：创建一个包含给定异常对象的 exception_ptr。
▮▮▮▮▮▮▮▮⚝ std::current_exception()：捕获当前线程正在处理的异常，并返回一个 exception_ptr。
▮▮▮▮▮▮▮▮⚝ std::rethrow_exception(exception_ptr)：重新抛出 exception_ptr 指向的异常。
▮▮▮▮▮▮▮▮⚝ std::exception_ptr::operator bool()：检查 exception_ptr 是否为空（空表示没有异常）。
⚝ exception_storage (Folly 内部类型)：
▮▮▮▮⚝ folly::Try 内部用于存储异常对象的类型。它实际上是对 std::aligned_storage_t<sizeof(std::exception_ptr), alignof(std::exception_ptr)> 的封装，用于在 Try 对象的内存中安全地存储 exception_ptr。
▮▮▮▮⚝ 通常不需要直接使用 exception_storage 类型，它是 Try 内部实现细节。
⚝ TryTraits<T> (Folly 内部 traits 类)：
▮▮▮▮⚝ 一个 traits 类，用于提供关于类型 T 的一些元信息，以便 Try 类能够正确地处理不同类型的 T。
▮▮▮▮⚝ 例如，TryTraits<T> 可以判断类型 T 是否是可平凡析构的（trivially destructible），从而在内部实现中进行优化。
▮▮▮▮⚝ 通常不需要直接使用 TryTraits<T>，它是 Try 内部实现细节。
总结：
folly::Try.h 中定义的相关类型和定义，特别是 Try<T>::ValueType、Try<T>::ExceptionType 和 Try<void>，以及对 std::exception_ptr 的使用，共同构成了 Try 错误处理机制的基础。理解这些类型和定义有助于更深入地理解 Try 的工作原理，并在实际应用中更有效地使用 Try 来处理可能失败的操作。Try<void> 特化版本尤其适用于那些只需要关注操作结果（成功或失败），而不需要具体返回值的场景，例如异步任务的完成通知、资源释放等。
END_OF_CHAPTER
6. chapter 6： 最佳实践与常见问题 (Best Practices and Common Issues)
6.1 Try 的编码规范与最佳实践 (Coding Conventions and Best Practices for Try)
Folly::Try 是一个强大的工具，用于处理可能失败的操作，并提供了一种比传统 C++ 异常处理更具函数式风格的错误处理机制。为了充分发挥 Try 的优势，并在团队协作和代码维护中保持一致性和可读性，遵循一定的编码规范和最佳实践至关重要。本节将深入探讨 Try 的编码规范与最佳实践，帮助读者写出更健壮、更易于理解和维护的代码。
6.1.1 清晰命名：体现 Try 的意图 (Clear Naming: Reflecting the Intent of Try)
① 函数命名： 当函数返回 Try<T> 时，其命名应清晰地表明该函数可能失败。常见的命名约定包括：
⚝ 使用动词 + 名词短语，并暗示可能失败的场景。例如，Try<User> fetchUserFromDatabase(UserID id) 比 User getUser(UserID id) 更能表达函数可能因用户不存在或数据库错误而失败。
⚝ 可以考虑在函数名中加入 Try 或 Attempt 等词汇，显式表明返回的是 Try 对象。例如，Try<int> tryParseInt(const std::string& str)。
⚝ 避免使用可能产生误导的、暗示总是成功的函数名。
② 变量命名： Try 类型的变量名也应具有描述性，反映其可能包含成功值或失败状态。
⚝ 使用 result、attempt、possibleValue 等词汇作为变量名的一部分，可以清晰地表达变量的 Try 类型本质。例如，Try<std::unique_ptr<File>> fileOpenResult = openFile("config.txt");。
⚝ 避免使用过于笼统或容易与普通值混淆的变量名。
6.1.2 Try 与异常：选择合适的错误处理机制 (Try vs. Exceptions: Choosing the Right Error Handling Mechanism)
Try 和异常处理都是 C++ 中处理错误的方式，但它们的设计哲学和适用场景有所不同。选择合适的错误处理机制对于代码的清晰度和效率至关重要。
① 明确 Try 的适用场景： Try 更适合用于可预期的、业务逻辑层面的失败情况。例如：
⚝ 数据验证失败：如用户输入格式错误、数据超出有效范围等。
⚝ 资源获取失败：如文件打开失败、网络连接超时等。
⚝ 业务规则校验失败：如订单库存不足、用户权限不足等。
② 异常的适用场景： 异常更适合用于非预期的、程序运行层面的错误，表示程序遇到了无法正常恢复的严重问题。例如：
⚝ 内存耗尽 (std::bad_alloc)。
⚝ 数组越界 (std::out_of_range)。
⚝ 空指针解引用 (Segmentation Fault)。
③ 混合使用策略： 在某些复杂系统中，可以考虑 Try 和异常混合使用。
⚝ 外层使用 Try 捕获业务逻辑错误，内层函数可以使用异常报告程序级别的错误。 这样可以清晰地划分错误处理的职责，并提高代码的健壮性。
⚝ 避免过度使用异常：异常处理的开销相对较高，频繁抛出和捕获异常可能会影响性能。对于可预期的错误，Try 通常是更高效的选择。
6.1.3 显式处理 Try 的状态：避免忽略错误 (Explicitly Handling Try's State: Avoiding Error Neglect)
使用 Try 的核心优势在于它强制开发者显式地处理操作可能成功或失败两种状态。最糟糕的实践是创建了 Try 对象，但从未检查其状态或处理失败情况。
① 始终检查 isSuccess() 或 isFailure()： 在使用 Try 对象的结果之前，务必使用 isSuccess() 或 isFailure() 方法检查其状态。
1
Try<int> result = calculateValue();
2
if (result.isSuccess()) {
3
int value = result.value(); // 安全访问成功值
4
// ... 使用 value 进行后续操作
5
} else {
6
// 处理失败情况
7
std::exception_ptr exPtr = result.exception();
8
try {
9
std::rethrow_exception(exPtr); // 重新抛出异常以便捕获和处理
10
} catch (const std::exception& e) {
11
std::cerr << "Error: " << e.what() << std::endl;
12
// ... 记录日志、返回错误码或进行其他错误处理
13
}
14
}
② 使用 map, flatMap, or, orElse 等操作符进行链式处理： 这些操作符可以帮助你以更简洁、更函数式的方式处理 Try 对象，并确保在链式操作的每一步都考虑到失败的可能性。
1
Try<std::string> processData(const std::string& input) {
2
return parseInput(input)
3
.flatMap(validateData)
4
.map(transformData)
5
.orElse([] { return Try<std::string>("default value"); });
6
}
③ 避免隐式转换和忽略返回值： Try 对象的设计目的是显式地处理错误，因此要避免任何可能导致错误被忽略的隐式转换或操作。
⚝ 不要将 Try<T> 隐式转换为 T 而不检查成功状态。
⚝ 确保链式操作中每个 Try 返回值都被正确处理，而不是被忽略。
6.1.4 利用 Try 的函数式特性：提升代码可读性和简洁性 (Leveraging Try's Functional Features: Enhancing Code Readability and Conciseness)
Try 的设计深受函数式编程思想的影响，合理利用其提供的 map, flatMap, or, orElse 等操作符，可以显著提升代码的可读性和简洁性。
① 使用 map 进行值转换： 当你只需要对 Try 成功的值进行转换时，map 是一个理想的选择。它避免了显式的状态检查和值提取，使代码更简洁。
1
Try<int> stringLength(const Try<std::string>& strTry) {
2
return strTry.map([](const std::string& str) { return str.length(); });
3
}
② 使用 flatMap 进行链式操作和 Try 的组合： 当你需要根据前一个 Try 的结果执行下一个可能失败的操作时，flatMap 是关键。它可以将多个返回 Try 的操作链接起来，形成一个处理链，并保持错误状态的传播。
1
Try<UserData> fetchAndProcessUserData(UserID id) {
2
return fetchUserDataFromCache(id)
3
.flatMap([&](const UserData& cachedData) -> Try<UserData> {
4
if (isCacheValid(cachedData)) {
5
return Try<UserData>(cachedData); // 缓存有效，直接返回
6
} else {
7
return fetchUserDataFromDatabase(id); // 缓存无效，从数据库获取
8
}
9
});
10
}
③ 使用 or 和 orElse 提供备选值或处理失败情况： or 和 orElse 提供了在 Try 失败时提供备选值或执行备选操作的机制。or 接受另一个 Try 对象作为备选，而 orElse 接受一个返回备选值的 lambda 函数。
1
Try<Config> loadConfig() {
2
return loadConfigFromFile("config.json")
3
.orElse([] { return loadDefaultConfig(); }); // 文件加载失败，加载默认配置
4
}
6.1.5 考虑性能：避免不必要的拷贝和开销 (Performance Considerations: Avoiding Unnecessary Copies and Overhead)
虽然 Try 提供了强大的错误处理能力，但在性能敏感的场景中，也需要注意避免不必要的拷贝和开销。
① 避免在 Try 中存储大型对象： Try 对象本身会存储成功的值或异常，如果存储大型对象，可能会导致额外的拷贝开销。
⚝ 考虑使用智能指针 (std::unique_ptr, std::shared_ptr) 来管理大型对象，并在 Try 中存储智能指针，以减少拷贝开销。
⚝ 如果只需要传递对象的引用，可以考虑返回 Try<T&> 或 Try<T*>. 但需要谨慎管理引用的生命周期。
② 避免不必要的 Try 对象创建： 在某些情况下，如果操作总是成功，或者错误处理逻辑非常简单，可能没有必要使用 Try。
⚝ 权衡使用 Try 带来的代码清晰度和潜在的性能开销。
⚝ 对于非常简单的、不太可能失败的操作，直接返回值可能更高效。
③ 利用移动语义： Try 充分利用了 C++ 的移动语义，在可能的情况下，确保你的代码也支持移动语义，以减少拷贝开销。
⚝ 返回 Try 对象时，尽量使用 std::move。
⚝ 在 lambda 表达式中捕获对象时，考虑使用移动捕获 [value = std::move(value)]。
6.1.6 代码审查与团队协作 (Code Review and Team Collaboration)
在团队开发中，统一的编码规范和最佳实践至关重要。
① 制定团队内部的 Try 编码规范： 基于本节讨论的最佳实践，结合团队的具体项目需求和代码风格，制定团队内部的 Try 编码规范文档。
② 进行代码审查： 在代码审查过程中，重点关注 Try 的使用是否符合规范，错误处理是否完整，以及代码是否清晰易懂。
③ 持续学习和分享： 鼓励团队成员持续学习 Try 的高级用法和最佳实践，并在团队内部进行分享和交流，共同提高 Try 的使用水平。
遵循这些编码规范和最佳实践，可以帮助你更好地利用 Folly::Try，编写出更健壮、更易于维护的 C++ 代码。
6.2 常见错误与陷阱 (Common Errors and Pitfalls)
即使 Folly::Try 提供了强大的错误处理机制，开发者在使用过程中仍然可能遇到一些常见的错误和陷阱。了解这些陷阱并避免它们，可以帮助你更有效地使用 Try，并减少代码中的潜在 bug。
6.2.1 忽略失败状态：未检查 isSuccess() (Ignoring Failure State: Not Checking isSuccess())
最常见的错误也是最严重的错误之一，就是创建了 Try 对象，但从未检查其 isSuccess() 状态，直接尝试访问 value()。 如果 Try 对象处于失败状态，调用 value() 将会抛出异常，导致程序崩溃或行为异常。
1
Try<int> result = mayFail();
2
int value = result.value(); // 💥 如果 result 失败，这里会抛出异常！
3
// ... 后续代码基于错误的 value 继续执行，可能导致更严重的问题
正确做法： 始终在使用 value() 之前检查 isSuccess()。
1
Try<int> result = mayFail();
2
if (result.isSuccess()) {
3
int value = result.value(); // ✅ 安全访问
4
// ... 使用 value
5
} else {
6
// ❌ 错误处理缺失！
7
// ... 应该在这里处理失败情况，例如记录日志、返回错误码等
8
}
更佳实践： 使用 map, flatMap, or, orElse 等操作符进行链式处理，这些操作符会自动处理 Try 的状态，并避免直接访问 value() 可能导致的错误。
6.2.2 错误处理缺失：else 分支为空 (Missing Error Handling: Empty else Branch)
即使检查了 isSuccess()，但如果 else 分支中没有任何错误处理逻辑，仍然会导致问题。仅仅判断了失败状态，但没有采取任何补救措施，相当于忽略了错误。
1
Try<int> result = mayFail();
2
if (result.isSuccess()) {
3
int value = result.value();
4
// ... 使用 value
5
} else {
6
// ❌ else 分支为空，错误被忽略了！
7
}
8
// ... 后续代码可能基于未处理的错误状态继续执行
正确做法： 在 else 分支中提供适当的错误处理逻辑。
1
Try<int> result = mayFail();
2
if (result.isSuccess()) {
3
int value = result.value();
4
// ... 使用 value
5
} else {
6
std::cerr << "Operation failed!" << std::endl; // ✅ 记录日志
7
// 可以选择返回默认值、抛出异常、返回错误码等
8
return Try<int>(0); // 例如，返回默认值
9
}
更佳实践： 使用 orElse 提供备选值，或使用 onFailure 执行失败时的操作。
1
Try<int> result = mayFail().orElse([] {
2
std::cerr << "Operation failed, using default value 0." << std::endl;
3
return Try<int>(0);
4
});
6.2.3 滥用 value() 和 exception()：代码冗余 (Overusing value() and exception(): Code Redundancy)
频繁地使用 isSuccess()、value() 和 exception() 进行状态检查和值/异常提取，会导致代码冗余且不易读。
1
Try<int> result1 = mayFail1();
2
Try<int> result2;
3
if (result1.isSuccess()) {
4
result2 = mayFail2(result1.value());
5
if (result2.isSuccess()) {
6
int finalValue = result2.value();
7
// ... 使用 finalValue
8
} else {
9
std::cerr << "mayFail2 failed: " << result2.exception()->what() << std::endl;
10
}
11
} else {
12
std::cerr << "mayFail1 failed: " << result1.exception()->what() << std::endl;
13
}
更简洁的做法： 使用 flatMap 进行链式操作，避免显式的状态检查和值提取。
1
Try<int> finalResult = mayFail1().flatMap(mayFail2);
2
if (finalResult.isSuccess()) {
3
int finalValue = finalResult.value();
4
// ... 使用 finalValue
5
} else {
6
std::cerr << "Operation failed: " << finalResult.exception()->what() << std::endl;
7
}
6.2.4 在 map 或 flatMap 中抛出异常：破坏 Try 的链式调用 (Throwing Exceptions in map or flatMap: Breaking Try's Chaining)
map 和 flatMap 的设计目的是在成功值上进行转换或链式操作，如果在 map 或 flatMap 的 lambda 函数中抛出异常，会导致 Try 对象进入失败状态，但异常信息会被包装在 Try 内部，原始异常信息可能会丢失或难以追踪。
1
Try<int> result = Try<int>(5).map([](int value) {
2
if (value > 0) {
3
throw std::runtime_error("Value is too large!"); // 💥 在 map 中抛出异常
4
}
5
return value * 2;
6
});
7
8
if (result.isFailure()) {
9
try {
10
std::rethrow_exception(result.exception());
11
} catch (const std::exception& e) {
12
std::cerr << "Caught exception: " << e.what() << std::endl; // 输出 "Caught exception: std::exception" 而不是 "Value is too large!"
13
}
14
}
正确做法： 在 map 或 flatMap 中，如果操作可能失败，应该返回 Try<T> 对象来表示失败，而不是抛出异常。
1
Try<int> result = Try<int>(5).flatMap([](int value) -> Try<int> {
2
if (value > 0) {
3
return Try<int>(std::runtime_error("Value is too large!")); // ✅ 返回失败的 Try
4
}
5
return Try<int>(value * 2);
6
});
7
8
if (result.isFailure()) {
9
try {
10
std::rethrow_exception(result.exception());
11
} catch (const std::exception& e) {
12
std::cerr << "Caught exception: " << e.what() << std::endl; // 输出 "Caught exception: Value is too large!"
13
}
14
}
6.2.5 不恰当的异常类型：信息不足或过于宽泛 (Inappropriate Exception Type: Insufficient Information or Too Broad)
Try 可以存储任何类型的异常，但选择合适的异常类型对于错误诊断和处理至关重要。
① 使用过于宽泛的异常类型 (std::exception)： std::exception 是所有标准异常的基类，但它本身不包含具体的错误信息。使用 std::exception 可能会导致错误信息不足，难以定位问题。
1
Try<int> mayFail() {
2
return Try<int>(std::exception()); // ❌ 使用 std::exception，信息不足
3
}
② 自定义异常类型： 为了提供更丰富的错误信息，应该自定义异常类型，并包含具体的错误描述、错误码等信息。
1
struct DataValidationError : public std::runtime_error {
2
DataValidationError(const std::string& message) : std::runtime_error(message) {}
3
};
4
5
Try<int> validateData(const std::string& data) {
6
if (data.empty()) {
7
return Try<int>(DataValidationError("Input data cannot be empty.")); // ✅ 使用自定义异常类型
8
}
9
// ... 数据验证逻辑
10
return Try<int>(std::stoi(data));
11
}
③ 使用标准库提供的更具体的异常类型： C++ 标准库提供了许多更具体的异常类型，例如 std::invalid_argument, std::out_of_range, std::runtime_error 等。在合适的场景下，优先使用这些标准异常类型，可以提高代码的可读性和可维护性。
6.2.6 性能陷阱：过度拷贝和不必要的 Try 创建 (Performance Pitfalls: Excessive Copying and Unnecessary Try Creation)
虽然 Try 本身的设计考虑了性能，但在某些情况下，不当的使用方式仍然可能导致性能问题。
① 在 Try 中存储大型对象： 如 6.1.5 节所述，在 Try 中直接存储大型对象会导致额外的拷贝开销。
② 不必要的 Try 对象创建： 对于总是成功的操作，或者错误处理非常简单的场景，创建 Try 对象可能会引入不必要的开销。
③ 在循环或性能热点中频繁创建 Try： 如果在循环或性能热点代码中频繁创建 Try 对象，可能会累积性能开销。
优化策略：
⚝ 使用智能指针管理大型对象。
⚝ 避免在性能敏感的代码路径中过度使用 Try。
⚝ 考虑使用 Try<T&> 或 Try<T*> 传递引用或指针（需谨慎管理生命周期）。
⚝ 针对性能瓶颈进行 profiling 和优化。
6.2.7 与传统异常处理混合使用不当：代码混乱 (Improper Mixing with Traditional Exception Handling: Code Clutter)
在同一个代码库中同时使用 Try 和传统异常处理是可以的，但需要谨慎设计，避免代码混乱和逻辑不清晰。
① 混淆错误处理机制： 不清晰地划分 Try 和异常处理的职责，导致代码中既有 try-catch 块，又有 Try 对象的处理逻辑，容易使代码难以理解和维护。
② 异常穿透 Try 的边界： 如果在返回 Try 的函数内部抛出了未捕获的异常，异常会穿透 Try 的边界，导致 Try 对象无法捕获到异常，最终可能导致程序崩溃。
最佳实践：
⚝ 明确 Try 和异常处理的边界： 例如，可以约定 Try 用于处理业务逻辑错误，异常用于处理程序级别的错误。
⚝ 在 Try 的边界处捕获异常： 如果需要在返回 Try 的函数中使用可能抛出异常的传统 C++ 代码，应该使用 folly::makeTry 或 folly::Try::withCatch 等工具将异常转换为 Try 的失败状态。
1
Try<int> mayThrowException() {
2
return folly::makeTry([] {
3
// ... 可能抛出异常的代码
4
return 42;
5
});
6
}
了解并避免这些常见的错误和陷阱，可以帮助你更有效地使用 Folly::Try，编写出更健壮、更可靠的 C++ 代码。
6.3 Try 的调试技巧 (Debugging Techniques for Try)
调试是软件开发过程中不可或缺的一部分。当代码中使用 Folly::Try 时，掌握一些有效的调试技巧可以帮助你快速定位和解决问题。本节将介绍一些 Try 的调试技巧，包括如何检查 Try 对象的状态、如何追踪错误信息、以及如何利用调试工具进行辅助调试。
6.3.1 使用 isSuccess() 和 isFailure() 检查状态 (Using isSuccess() and isFailure() to Check State)
最基本的调试技巧就是使用 Try 提供的 isSuccess() 和 isFailure() 方法来检查对象的状态。这可以帮助你快速判断操作是否成功，并根据状态采取不同的调试策略。
1
Try<int> result = calculateValue();
2
if (result.isSuccess()) {
3
std::cout << "Success! Value: " << result.value() << std::endl;
4
} else {
5
std::cout << "Failure!" << std::endl;
6
// ... 进入失败分支，进行更详细的调试
7
}
6.3.2 打印错误信息：exception()->what() (Printing Error Messages: exception()->what())
当 Try 对象处于失败状态时，可以使用 exception() 方法获取指向异常对象的指针，并调用 what() 方法获取异常的描述信息。这可以帮助你了解失败的原因。
1
Try<int> result = calculateValue();
2
if (result.isFailure()) {
3
std::exception_ptr exPtr = result.exception();
4
try {
5
std::rethrow_exception(exPtr); // 重新抛出异常以便捕获
6
} catch (const std::exception& e) {
7
std::cerr << "Error: " << e.what() << std::endl; // 打印错误信息
8
}
9
}
更简洁的方式： 使用 Try::onFailure 方法，可以更方便地处理失败情况并打印错误信息。
1
Try<int> result = calculateValue();
2
result.onFailure([](const std::exception& e) {
3
std::cerr << "Error: " << e.what() << std::endl;
4
});
6.3.3 条件断点：基于 Try 的状态设置断点 (Conditional Breakpoints: Setting Breakpoints Based on Try's State)
在调试器中，可以设置条件断点，当 Try 对象处于特定状态（成功或失败）时，程序会暂停执行。这可以帮助你更精确地定位问题发生的代码位置。
① 在成功状态时暂停： 在调试器中设置断点，条件为 result.isSuccess(). 当 result 对象变为成功状态时，程序会暂停。
② 在失败状态时暂停： 设置断点，条件为 result.isFailure(). 当 result 对象变为失败状态时，程序会暂停。
③ 基于异常类型暂停： 可以更进一步，根据异常类型设置条件断点。例如，只在抛出特定类型的异常时暂停。这需要更高级的调试器功能，例如在 GDB 中可以使用 catch type 命令。
6.3.4 调试器观察窗口：查看 Try 对象内部状态 (Debugger Watch Window: Inspecting Try Object's Internal State)
大多数现代调试器（如 GDB, LLDB, Visual Studio Debugger）都允许你查看变量的内部状态。在调试器中，将 Try 对象添加到观察窗口，可以查看其内部存储的值或异常信息。
① 查看成功值： 如果 Try 对象处于成功状态，观察窗口会显示其内部存储的值。
② 查看异常对象： 如果 Try 对象处于失败状态，观察窗口会显示其内部存储的异常对象，你可以展开异常对象查看更详细的信息，例如异常类型、错误消息等。
6.3.5 日志记录：记录 Try 的状态和错误信息 (Logging: Recording Try's State and Error Information)
在生产环境中，调试器可能无法使用。日志记录是追踪错误和分析问题的关键手段。在使用 Try 的代码中，合理地添加日志记录可以帮助你更好地理解程序的运行状态。
① 记录 Try 的状态： 在关键的代码路径中，记录 Try 对象的状态（成功或失败）。
1
Try<int> result = calculateValue();
2
if (result.isSuccess()) {
3
LOG(INFO) << "calculateValue succeeded with result: " << result.value();
4
} else {
5
LOG(WARNING) << "calculateValue failed.";
6
}
② 记录详细的错误信息： 当 Try 失败时，记录详细的错误信息，包括异常类型、错误消息、堆栈跟踪等。
1
Try<int> result = calculateValue();
2
if (result.isFailure()) {
3
std::exception_ptr exPtr = result.exception();
4
try {
5
std::rethrow_exception(exPtr);
6
} catch (const std::exception& e) {
7
LOG(ERROR) << "calculateValue failed with exception: " << e.what();
8
// 可以考虑使用 folly::exception_tracer 或其他工具记录堆栈跟踪
9
}
10
}
③ 使用结构化日志： 为了方便日志分析和检索，可以考虑使用结构化日志，将 Try 的状态、错误码、错误消息等信息以结构化的形式记录下来。
6.3.6 单元测试：针对成功和失败场景编写测试用例 (Unit Testing: Writing Test Cases for Success and Failure Scenarios)
单元测试是保证代码质量的重要手段。针对使用 Try 的代码，应该编写充分的单元测试用例，覆盖各种成功和失败场景。
① 测试成功路径： 编写测试用例，验证在正常输入下，代码能够返回成功的 Try 对象，并且结果值符合预期。
② 测试失败路径： 编写测试用例，模拟各种可能导致失败的情况，验证代码能够返回失败的 Try 对象，并且异常类型和错误信息符合预期。
③ 边界条件和异常情况测试： 特别关注边界条件和异常情况的测试，例如空输入、无效输入、资源耗尽等，确保代码在这些情况下能够正确处理错误。
6.3.7 使用 folly::exception_tracer 追踪异常堆栈 (Using folly::exception_tracer to Trace Exception Stack)
folly::exception_tracer 是 Folly 库提供的一个工具，可以帮助你追踪异常的堆栈信息。当 Try 对象存储的异常是由 folly::exception_tracer 包装的异常时，你可以使用 folly::exception_tracer::get_stack_trace() 获取异常的堆栈跟踪信息，这对于定位深层调用栈中的错误非常有帮助。
1
#include <folly/exception_tracer.h>
2
3
Try<int> mayFailDeeply() {
4
try {
5
// ... 深层调用栈中的代码，可能抛出异常
6
throw std::runtime_error("Something went wrong deep inside.");
7
} catch (...) {
8
return Try<int>(folly::exception_tracer::current_exception()); // 包装异常
9
}
10
}
11
12
int main() {
13
Try<int> result = mayFailDeeply();
14
if (result.isFailure()) {
15
std::exception_ptr exPtr = result.exception();
16
try {
17
std::rethrow_exception(exPtr);
18
} catch (const std::exception& e) {
19
std::cerr << "Error: " << e.what() << std::endl;
20
std::cerr << "Stack trace: " << folly::exception_tracer::get_stack_trace(exPtr) << std::endl; // 获取堆栈跟踪
21
}
22
}
23
return 0;
24
}
结合以上调试技巧，可以更有效地调试使用 Folly::Try 的代码，快速定位和解决问题，提高开发效率和代码质量。
6.4 Try 在大型项目中的应用经验 (Application Experience of Try in Large Projects)
在大型项目中应用 Folly::Try，可以显著提升代码的健壮性和可维护性。然而，在实际应用中，也需要考虑一些大型项目特有的挑战和最佳实践。本节将分享 Try 在大型项目中的应用经验，包括如何推广 Try、如何与其他错误处理机制协同工作、以及如何应对大型项目中的性能和维护性挑战。
6.4.1 逐步推广 Try：平滑迁移 (Gradually Adopting Try: Smooth Migration)
在大型项目中，代码库通常非常庞大且复杂，一次性全面替换现有的错误处理机制为 Try 是不现实的，也存在较高的风险。更稳妥的做法是逐步推广 Try，平滑迁移。
① 从新模块开始： 在新开发的模块或子系统中，优先采用 Try 作为错误处理机制。这可以降低引入风险，并为团队积累 Try 的使用经验。
② 逐步改造现有模块： 在维护和迭代现有模块时，逐步将关键的、错误处理逻辑复杂的代码迁移到 Try。可以优先改造那些错误处理逻辑分散、容易出错的模块。
③ 制定迁移计划和优先级： 根据项目的实际情况，制定详细的 Try 迁移计划和优先级，明确哪些模块先迁移，哪些模块后迁移，以及迁移的时间表。
④ 保持代码风格一致性： 在迁移过程中，要保持代码风格的一致性，遵循团队内部的 Try 编码规范，避免新旧代码风格混杂。
6.4.2 Try 与现有错误处理机制的协同 (Collaboration of Try with Existing Error Handling Mechanisms)
大型项目通常已经存在一套成熟的错误处理机制，例如基于异常的错误处理、错误码返回等。在引入 Try 时，需要考虑如何与这些现有机制协同工作，而不是完全取代它们。
① Try 作为业务逻辑错误处理的主力： 可以将 Try 定位为处理业务逻辑错误的主要机制，例如数据验证失败、资源获取失败、业务规则校验失败等。
② 异常处理保留给程序级别错误： 对于程序级别的错误，例如内存耗尽、数组越界、空指针解引用等，仍然可以使用传统的异常处理机制。
③ 错误码返回用于跨模块或跨系统交互： 在跨模块或跨系统交互的场景中，错误码返回仍然是一种常用的错误传递方式。可以将 Try 的失败状态转换为错误码，以便与其他模块或系统进行集成。
④ 统一错误处理接口： 为了提高代码的可维护性和可扩展性，可以考虑定义统一的错误处理接口，将 Try、异常、错误码等不同的错误表示形式统一起来。例如，可以定义一个通用的 Result 类型，可以表示成功、失败（包含异常信息或错误码）等状态。
6.4.3 性能考量：大型项目中的性能敏感性 (Performance Considerations: Performance Sensitivity in Large Projects)
大型项目通常对性能有更高的要求。在使用 Try 时，需要特别关注性能问题，避免引入不必要的性能开销。
① 性能 profiling 和测试： 在大型项目中应用 Try 后，需要进行全面的性能 profiling 和测试，评估 Try 对系统性能的影响。特别关注性能热点代码路径，确保 Try 的使用不会引入明显的性能瓶颈。
② 避免过度使用 Try： 对于性能敏感的代码路径，需要权衡使用 Try 带来的代码清晰度和潜在的性能开销。对于非常简单的、不太可能失败的操作，直接返回值可能更高效。
③ 优化 Try 的使用方式： 遵循 6.1.5 节和 6.2.6 节中提到的性能优化策略，例如避免在 Try 中存储大型对象、避免不必要的 Try 对象创建、利用移动语义等。
④ 定制化的 Try 实现： 在极端的性能敏感场景下，如果 Folly::Try 的默认实现无法满足性能要求，可以考虑根据项目的具体需求，定制化 Try 的实现，例如减少内存分配、优化拷贝操作等。
6.4.4 维护性挑战：代码可读性和团队协作 (Maintainability Challenges: Code Readability and Team Collaboration)
大型项目的代码库通常非常庞大，维护性是一个重要的挑战。在使用 Try 时，需要特别关注代码的可读性和团队协作，确保 Try 的引入不会降低代码的可维护性。
① 统一编码规范和最佳实践： 制定团队内部统一的 Try 编码规范和最佳实践，并严格执行。这可以提高代码的可读性和一致性，降低维护成本。
② 充分的代码注释和文档： 对于使用 Try 的代码，要编写充分的代码注释和文档，解释 Try 的使用目的、错误处理逻辑、以及可能出现的错误情况。
③ 代码审查和知识分享： 通过代码审查，确保团队成员都遵循 Try 的编码规范和最佳实践。定期进行 Try 的知识分享和培训，提高团队整体的 Try 使用水平。
④ 工具支持： 可以开发或引入一些工具，辅助 Try 的使用和维护。例如，可以开发静态代码分析工具，检查代码中 Try 的使用是否符合规范，是否存在潜在的错误。
6.4.5 案例分析：大型项目中使用 Try 的成功案例 (Case Studies: Successful Cases of Using Try in Large Projects)
了解其他大型项目如何成功应用 Try，可以为自己的项目提供宝贵的经验和借鉴。
① Facebook Folly 自身： Folly::Try 本身就诞生于 Facebook 这样的大型项目，并在 Facebook 的许多核心组件中得到广泛应用。Folly 自身的代码库就是一个很好的 Try 应用案例。
② 开源项目： 许多开源项目也开始采用 Try 或类似的错误处理机制。研究这些开源项目的代码，可以了解 Try 在不同场景下的应用方式。
③ 行业最佳实践： 关注行业内的最佳实践，了解其他公司或团队在大型项目中使用 Try 的经验和教训。
通过学习和借鉴这些成功案例，可以更好地理解 Try 在大型项目中的价值和应用方法，并为自己的项目选择合适的 Try 推广策略和最佳实践。
END_OF_CHAPTER
7. chapter 7： 总结与展望 (总结与展望)
7.1 Folly Try.h 的价值回顾 (Folly Try.h Value Review)
在本书的尾声，我们共同回顾了 Folly Try.h 这一强大的工具，并深入探索了其在现代 C++ 开发中的价值。Try.h，作为 Folly 库中的重要组件，不仅仅是一个简单的错误处理机制，它更是一种编程思想（programming paradigm）的体现，一种提升代码健壮性（robustness）、可读性（readability）和可维护性（maintainability）的有效手段。
回顾我们一路走来的学习历程，Try.h 的价值体现在以下几个关键方面：
① 清晰的错误处理语义：Try.h 显式地将可能失败的操作包裹在 folly::Try 对象中，使得错误处理逻辑与正常逻辑分离，代码意图更加清晰。相较于传统的 C++ 异常处理，Try.h 避免了隐式的控制流跳转，降低了代码的复杂性，提升了代码的可读性和可维护性。
② 函数式编程的友好性：Try.h 完美契合函数式编程（functional programming）的思想。map、flatMap、or、orElse 等操作符的引入，使得我们可以像处理数据流一样处理错误，以链式调用的方式优雅地组合可能失败的操作，构建出简洁而强大的错误处理流程。这与现代 C++ 强调的表达式编程（expression-oriented programming）理念不谋而合。
③ 强大的组合能力：Try 对象可以方便地与其他 Try 对象组合，形成复杂的错误处理逻辑。flatMap 操作符尤其强大，它允许我们在处理成功结果的同时，根据结果的类型返回新的 Try 对象，从而实现monadic 的链式操作，有效地避免了“回调地狱（callback hell）”和深层嵌套的条件判断。
④ 资源管理的安全性：虽然 Try.h 本身并非直接用于资源管理，但它可以与 RAII（Resource Acquisition Is Initialization）机制良好配合，确保在可能失败的操作中，资源能够被正确地释放。通过将资源管理操作包裹在 Try 中，我们可以确保即使操作失败，资源析构函数也能被调用，避免资源泄漏。
⑤ 异步编程的助力：在异步编程（asynchronous programming）领域，Try.h 同样发挥着重要作用。它可以与 Folly 的 Future/Promise 等组件无缝集成，使得异步操作的错误处理更加规范和便捷。通过 Try，我们可以清晰地表示异步操作的成功或失败，并以统一的方式处理异步操作的结果和错误。
⑥ 提升代码健壮性：通过显式地处理可能失败的情况，Try.h 迫使开发者更加关注代码的异常路径（exceptional path），而不是仅仅关注正常路径（happy path）。这有助于及早发现和处理潜在的错误，提升应用程序的整体健壮性和可靠性。
⑦ 易于测试：使用 Try.h 可以更容易地进行单元测试（unit testing）。我们可以针对函数的不同返回值（成功或失败的 Try 对象）编写测试用例，全面覆盖函数的各种行为，确保代码的正确性。
总而言之，Folly Try.h 不仅仅是一个库，它代表了一种更加现代、更加函数式的 C++ 错误处理方式。它鼓励开发者以更加严谨和清晰的方式处理错误，从而构建出更健壮、更易维护的应用程序。掌握 Try.h，是提升 C++ 编程技能，迈向现代 C++ 开发（Modern C++ development）的重要一步。
7.2 Try.h 的未来发展趋势 (Future Development Trends of Try.h)
随着 C++ 标准的不断演进和软件开发技术的日新月异，Folly Try.h 作为现代 C++ 错误处理的代表，其未来发展也充满了机遇与挑战。展望未来，Try.h 可能会在以下几个方面持续发展和演进：
① 与 C++ 标准的融合：C++ 标准委员会也在积极探索和改进错误处理机制。例如，std::expected 提案正在逐渐成熟，它与 folly::Try 在设计理念上有着诸多相似之处。未来，Try.h 可能会进一步与 C++ 标准库融合，借鉴 std::expected 的优点，并反过来为 std::expected 的发展提供参考和借鉴。这种融合将有助于提升 Try.h 的通用性和标准化程度，使其更广泛地被 C++ 开发者接受和使用。
② 更强大的异步支持：异步编程在现代软件开发中扮演着越来越重要的角色。未来，Try.h 可能会进一步加强对异步编程的支持，例如，更深入地集成 Folly 的 Future/Promise 组件，提供更便捷的异步错误处理 API，或者与其他异步编程库（如 Boost.Asio、libuv 等）进行更好的互操作。
③ 性能优化与改进：虽然 Try.h 已经具有良好的性能，但在对性能有极致要求的场景下，仍然存在优化的空间。未来，Try.h 可能会在零成本抽象（zero-cost abstraction）方面进行更多的探索和优化，例如，通过编译时计算（compile-time computation）、内联（inlining）等技术，进一步降低 Try.h 的运行时开销，使其在各种场景下都能保持高性能。
④ 更丰富的错误信息：目前的 folly::Try 主要通过异常对象来携带错误信息。未来，Try.h 可能会考虑引入更丰富的错误信息表示方式，例如，支持携带错误码（error code）、错误上下文（error context）等信息，以便更详细地描述错误发生的原因和位置，方便开发者进行错误诊断和调试。
⑤ 与其他 Folly 组件的深度集成：Folly 库是一个庞大而精良的 C++ 库集合，包含了众多实用的组件。未来，Try.h 可能会与其他 Folly 组件进行更深度的集成，例如，与 Folly 的 Logging 组件集成，提供更完善的错误日志记录功能；与 Folly 的 Concurrency 组件集成，提供更强大的并发错误处理能力；与 Folly 的 IO 组件集成，提供更便捷的 IO 错误处理方式等等。
⑥ 更易用易学的 API：虽然 Try.h 的 API 已经相对简洁易用，但对于初学者来说，仍然存在一定的学习曲线。未来，Try.h 可能会在 API 设计上进一步优化，提供更易用、更直观的接口，降低学习门槛，吸引更多的开发者使用。同时，可以提供更丰富的文档和示例，帮助开发者更好地理解和使用 Try.h。
⑦ 社区驱动的演进：Folly 是一个开源项目，其发展离不开社区的贡献。未来，Try.h 的发展将更加依赖社区的力量，吸收社区的反馈和建议，共同推动 Try.h 的演进和完善。开发者可以通过参与 Folly 项目的讨论、提交 issue 和 pull request 等方式，为 Try.h 的发展贡献自己的力量。
总而言之，Folly Try.h 的未来发展前景广阔。它将继续在现代 C++ 错误处理领域发挥重要作用，并随着 C++ 标准和软件开发技术的发展而不断演进和完善，为开发者提供更强大、更便捷、更可靠的错误处理解决方案。
7.3 持续学习 Folly 与 C++ 现代编程 (Continuous Learning of Folly and Modern C++ Programming)
恭喜你完成了本书的学习，相信你已经对 Folly Try.h 有了深入的理解和掌握。然而，学习的脚步永不停歇。C++ 语言和 Folly 库都在不断发展和演进，现代 C++ 编程（Modern C++ programming）的世界充满了无限的可能和挑战。为了更好地应对未来的技术变革，持续学习至关重要。
以下是一些关于持续学习 Folly 和 C++ 现代编程的建议：
① 深入学习 Folly 库的其他组件：Try.h 只是 Folly 库的冰山一角。Folly 库还包含了众多优秀的组件，例如：
⚝ Futures/Promises: 用于异步编程，构建高效的并发程序。
⚝ FBVector/FBString: 高性能的容器和字符串实现，针对特定场景进行了优化。
⚝ Concurrent: 提供丰富的并发编程工具，如并发队列、原子操作等。
⚝ IO: 用于网络编程和 IO 操作，构建高性能的网络应用。
⚝ JSON: 用于 JSON 数据的解析和生成。
⚝ Logging: 高效灵活的日志库。
⚝ Benchmark: 性能测试工具，用于评估代码性能。
深入学习这些组件，可以帮助你更全面地了解 Folly 库的强大之处，并在实际项目中灵活运用。
② 关注 C++ 标准的最新发展：C++ 标准每三年更新一次，不断引入新的语言特性和库组件。例如，C++11、C++14、C++17、C++20 等标准都带来了许多重要的改进和新特性，如 lambda 表达式（lambda expression）、智能指针（smart pointer）、移动语义（move semantics）、概念（concepts）、协程（coroutines）等等。持续关注 C++ 标准的最新发展，学习和掌握新的语言特性，可以让你编写出更现代、更高效、更安全的代码。
③ 阅读优秀的 C++ 代码和开源项目：阅读优秀的 C++ 代码是提升编程技能的有效途径。可以阅读 Folly 库的源码，学习其设计思想和实现技巧。也可以关注其他优秀的 C++ 开源项目，例如 Boost 库、LLVM、Chromium 等，学习不同领域的 C++ 编程实践。通过阅读源码，可以学习到很多书本上学不到的知识和经验。
④ 参与 C++ 社区和技术交流：积极参与 C++ 社区和技术交流，可以让你及时了解 C++ 领域的最新动态，与其他 C++ 开发者交流经验，解决遇到的问题。可以参与 C++ 相关的技术论坛、社区、Meetup、会议等活动，与其他开发者建立联系，共同进步。
⑤ 实践项目，学以致用：学习编程最终目的是为了解决实际问题。将所学的 Folly 和 C++ 知识应用到实际项目中，是巩固知识、提升技能的最佳方式。可以尝试使用 Folly 库构建一些小工具、小项目，或者参与到实际的软件开发项目中，将 Try.h 等工具应用到错误处理、异步编程等场景中，在实践中不断学习和成长。
⑥ 持续学习相关的理论知识：除了学习具体的 C++ 语言和 Folly 库之外，还需要持续学习相关的理论知识，例如函数式编程（functional programming）、并发编程（concurrent programming）、分布式系统（distributed system）、软件架构（software architecture）等等。这些理论知识可以帮助你更深入地理解 C++ 和 Folly 的设计思想，更好地运用它们解决复杂的问题。
学习是一个持续的过程，没有终点。希望本书能够成为你学习 Folly Try.h 和现代 C++ 编程的起点，引领你进入更广阔的技术世界。愿你在 C++ 编程的道路上越走越远，不断取得新的成就！
END_OF_CHAPTER