029 《Folly String.h 权威指南：深度解析、实战应用与高级技巧》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 走近 folly::String (Getting Started with folly::String)
▮▮▮▮▮▮▮ 1.1 字符串的基石：C++ 字符串类型概览 (The Foundation of Strings: An Overview of C++ String Types)
▮▮▮▮▮▮▮▮▮▮▮ 1.1.1 C 风格字符串 (C-style Strings)
▮▮▮▮▮▮▮▮▮▮▮ 1.1.2 std::string：标准库的强大工具 (std::string: The Powerful Tool in Standard Library)
▮▮▮▮▮▮▮▮▮▮▮ 1.1.3 folly::fbstring 与写时复制 (Copy-on-Write) 机制 (folly::fbstring and Copy-on-Write Mechanism)
▮▮▮▮▮▮▮ 1.2 folly::StringPiece：高效的字符串视图 (Efficient String Views with folly::StringPiece)
▮▮▮▮▮▮▮▮▮▮▮ 1.2.1 StringPiece 的设计理念与优势 (Design Philosophy and Advantages of StringPiece)
▮▮▮▮▮▮▮▮▮▮▮ 1.2.2 StringPiece 的构造、赋值与基本操作 (Construction, Assignment, and Basic Operations of StringPiece)
▮▮▮▮▮▮▮▮▮▮▮ 1.2.3 StringPiece 的使用场景与最佳实践 (Use Cases and Best Practices for StringPiece)
▮▮▮▮▮▮▮ 1.3 folly::fbstring 详解：高性能字符串的秘密 (folly::fbstring in Detail: The Secret of High-Performance Strings)
▮▮▮▮▮▮▮▮▮▮▮ 1.3.1 fbstring 的内存管理策略 (Memory Management Strategies of fbstring)
▮▮▮▮▮▮▮▮▮▮▮ 1.3.2 fbstring 的构造、赋值与常用方法 (Construction, Assignment, and Common Methods of fbstring)
▮▮▮▮▮▮▮▮▮▮▮ 1.3.3 fbstring 与 std::string 的对比分析 (Comparative Analysis of fbstring and std::string)
▮▮▮▮▮▮▮ 1.4.1 Folly 库的安装与编译 (Installation and Compilation of Folly Library)
▮▮▮▮▮▮▮ 1.4.2 第一个 folly::String.h 程序 (Your First folly::String.h Program)
▮▮▮▮▮▮▮ 1.4.3 常见编译错误与解决方法 (Common Compilation Errors and Solutions)
▮▮▮▮ 2. chapter 2： folly::StringPiece 实战指南 (Practical Guide to folly::StringPiece)
▮▮▮▮▮▮▮ 2.1 字符串查找与匹配 (String Searching and Matching)
▮▮▮▮▮▮▮▮▮▮▮ 2.1.1 使用 StringPiece::find 进行精确查找 (Exact Search with StringPiece::find)
▮▮▮▮▮▮▮▮▮▮▮ 2.1.2 使用 StringPiece::startsWith 和 StringPiece::endsWith 进行前后缀判断 (Prefix and Suffix Judgments with StringPiece::startsWith and StringPiece::endsWith)
▮▮▮▮▮▮▮▮▮▮▮ 2.1.3 使用正则表达式与 StringPiece 结合进行复杂匹配 (Complex Matching with Regular Expressions and StringPiece)
▮▮▮▮▮▮▮ 2.2 字符串分割与子串操作 (String Splitting and Substring Operations)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.1 使用 StringPiece::split 进行字符串分割 (String Splitting with StringPiece::split)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.2 使用 StringPiece::substr 获取子串 (Getting Substrings with StringPiece::substr)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.3 高效处理分隔符与空字符串 (Efficiently Handling Delimiters and Empty Strings)
▮▮▮▮▮▮▮ 2.3 字符串比较与排序 (String Comparison and Sorting)
▮▮▮▮▮▮▮▮▮▮▮ 2.3.1 StringPiece 的字典序比较 (Lexicographical Comparison of StringPiece)
▮▮▮▮▮▮▮▮▮▮▮ 2.3.2 自定义比较函数与排序规则 (Custom Comparison Functions and Sorting Rules)
▮▮▮▮▮▮▮▮▮▮▮ 2.3.3 性能考量：比较操作的效率分析 (Performance Considerations: Efficiency Analysis of Comparison Operations)
▮▮▮▮▮▮▮ 2.4.1 使用 StringPiece 解析日志文件 (Parsing Log Files with StringPiece)
▮▮▮▮▮▮▮ 2.4.2 从日志字符串中提取关键信息 (Extracting Key Information from Log Strings)
▮▮▮▮▮▮▮ 2.4.3 性能优化技巧在日志解析中的应用 (Application of Performance Optimization Techniques in Log Parsing)
▮▮▮▮ 3. chapter 3： folly::fbstring 高级应用与性能优化 (Advanced Applications and Performance Optimization of folly::fbstring)
▮▮▮▮▮▮▮ 3.1 深入 fbstring 的内存管理 (Deep Dive into fbstring's Memory Management)
▮▮▮▮▮▮▮▮▮▮▮ 3.1.1 小字符串优化 (SSO, Small String Optimization) 原理与应用 (Principle and Application of Small String Optimization (SSO))
▮▮▮▮▮▮▮▮▮▮▮ 3.1.2 写时复制 (COW, Copy-on-Write) 的优势与局限性 (Advantages and Limitations of Copy-on-Write (COW))
▮▮▮▮▮▮▮▮▮▮▮ 3.1.3 自定义内存分配器 (Custom Memory Allocators) 与 fbstring 的结合 (Integration of Custom Memory Allocators with fbstring)
▮▮▮▮▮▮▮ 3.2 fbstring 的线程安全性与并发编程 (Thread Safety and Concurrent Programming with fbstring)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.1 fbstring 在多线程环境下的行为 (Behavior of fbstring in Multi-threaded Environments)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.2 使用 fbstring 构建线程安全的数据结构 (Building Thread-Safe Data Structures with fbstring)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.3 避免 fbstring 的线程安全陷阱 (Avoiding Thread Safety Pitfalls of fbstring)
▮▮▮▮▮▮▮ 3.3 fbstring 与 IO 操作的结合 (Integration of fbstring with IO Operations)
▮▮▮▮▮▮▮▮▮▮▮ 3.3.1 高效读取文件内容到 fbstring (Efficiently Reading File Content into fbstring)
▮▮▮▮▮▮▮▮▮▮▮ 3.3.2 使用 fbstring 进行网络数据传输 (Using fbstring for Network Data Transmission)
▮▮▮▮▮▮▮▮▮▮▮ 3.3.3 fbstring 在高性能 IO 场景下的应用 (Application of fbstring in High-Performance IO Scenarios)
▮▮▮▮▮▮▮ 3.4.1 fbstring 性能测试工具与方法 (Performance Testing Tools and Methods for fbstring)
▮▮▮▮▮▮▮ 3.4.2 fbstring 与 std::string 的性能对比基准 (Performance Comparison Benchmarks between fbstring and std::string)
▮▮▮▮▮▮▮ 3.4.3 性能瓶颈分析与优化策略 (Performance Bottleneck Analysis and Optimization Strategies)
▮▮▮▮ 4. chapter 4： folly::String API 全面解析 (Comprehensive API Analysis of folly::String)
▮▮▮▮▮▮▮ 4.1 folly::StringPiece API 详解 (Detailed API Explanation of folly::StringPiece)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.1 构造函数与赋值运算符 (Constructors and Assignment Operators)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.2 容量与长度相关方法 (Capacity and Length Related Methods)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.3 查找与匹配方法 (Search and Match Methods)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.4 子串操作方法 (Substring Operation Methods)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.5 比较运算符 (Comparison Operators)
▮▮▮▮▮▮▮ 4.2 folly::fbstring API 详解 (Detailed API Explanation of folly::fbstring)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.1 构造函数与赋值运算符 (Constructors and Assignment Operators)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.2 容量与长度相关方法 (Capacity and Length Related Methods)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.3 修改字符串内容的方法 (Methods for Modifying String Content)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.4 查找与匹配方法 (Search and Match Methods)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.5 子串操作方法 (Substring Operation Methods)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.6 与其他类型的转换方法 (Conversion Methods to Other Types)
▮▮▮▮▮▮▮ 4.3 folly::stringPrintf 与格式化输出 (Formatted Output with folly::stringPrintf)
▮▮▮▮▮▮▮▮▮▮▮ 4.3.1 stringPrintf 的用法与示例 (Usage and Examples of stringPrintf)
▮▮▮▮▮▮▮▮▮▮▮ 4.3.2 stringPrintf 的格式化控制符 (Format Specifiers of stringPrintf)
▮▮▮▮▮▮▮▮▮▮▮ 4.3.3 stringPrintf 的性能考量 (Performance Considerations of stringPrintf)
▮▮▮▮▮▮▮ 4.4.1 字符串转换函数 (String Conversion Functions)
▮▮▮▮▮▮▮▮▮▮▮ 4.4.1.1 to<T>() 模板函数 (The to<T>() Template Function)
▮▮▮▮▮▮▮▮▮▮▮ 4.4.1.2 字符串与数字类型之间的转换 (Conversions Between String and Numeric Types)
▮▮▮▮▮▮▮ 4.4.2 字符串 Hash 函数 (String Hash Functions)
▮▮▮▮▮▮▮▮▮▮▮ 4.4.2.1 hash_value() 函数 (The hash_value() Function)
▮▮▮▮▮▮▮▮▮▮▮ 4.4.2.2 自定义 Hash 函数的应用 (Application of Custom Hash Functions)
▮▮▮▮ 5. chapter 5： 高级主题与扩展 (Advanced Topics and Extensions)
▮▮▮▮▮▮▮ 5.1 folly::String 与 Unicode 支持 (Unicode Support in folly::String)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.1 Unicode 编码基础 (Basics of Unicode Encoding)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.2 folly::String 对 UTF-8 等 Unicode 编码的支持 (Support for UTF-8 and Other Unicode Encodings in folly::String)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.3 处理 Unicode 字符串的最佳实践 (Best Practices for Handling Unicode Strings)
▮▮▮▮▮▮▮ 5.2 自定义字符串类与 folly::String 的集成 (Integrating Custom String Classes with folly::String)
▮▮▮▮▮▮▮▮▮▮▮ 5.2.1 设计自定义字符串类的考量 (Considerations for Designing Custom String Classes)
▮▮▮▮▮▮▮▮▮▮▮ 5.2.2 与 folly::StringPiece 兼容 (Compatibility with folly::StringPiece)
▮▮▮▮▮▮▮▮▮▮▮ 5.2.3 扩展 folly::fbstring 的功能 (Extending the Functionality of folly::fbstring)
▮▮▮▮▮▮▮ 5.3 folly::String 在大型项目中的应用案例 (Application Cases of folly::String in Large-Scale Projects)
▮▮▮▮▮▮▮▮▮▮▮ 5.3.1 Facebook 内部如何使用 folly::String (How Facebook Uses folly::String Internally)
▮▮▮▮▮▮▮▮▮▮▮ 5.3.2 开源项目中使用 folly::String 的案例分析 (Case Studies of Using folly::String in Open Source Projects)
▮▮▮▮▮▮▮▮▮▮▮ 5.3.3 folly::String 的未来发展趋势 (Future Development Trends of folly::String)
1. chapter 1： 走近 folly::String (Getting Started with folly::String)
1.1 字符串的基石：C++ 字符串类型概览 (The Foundation of Strings: An Overview of C++ String Types)
在深入 folly::String 的世界之前，我们首先需要回顾 C++ 中处理文本字符串的几种基本方法。理解这些基础概念，将有助于我们更好地欣赏 folly::String 提供的工具和优势。本节将概览 C 风格字符串、标准库中的 std::string 以及 folly::fbstring，为后续的学习打下坚实的基础。
1.1.1 C 风格字符串 (C-style Strings)
C 风格字符串，也常被称为字符数组，是 C 语言中表示文本字符串的传统方式，在 C++ 中仍然被广泛使用。
① 定义与表示: C 风格字符串本质上是以空字符 \0 结尾的字符数组。例如：
1
char c_str[] = "Hello, C-style string!";
这里 c_str 就是一个 C 风格字符串。编译器会自动在字符串字面量的末尾添加空字符 \0。
② 优点:
⚝ 简单直接: C 风格字符串的概念非常简单，直接操作字符数组，易于理解底层机制。
⚝ 高效: 在某些底层操作或与 C 语言库交互时，C 风格字符串具有较高的效率。
③ 缺点:
⚝ 安全性问题: C 风格字符串最大的问题是安全性。由于其本质是字符数组，没有边界检查，容易发生缓冲区溢出（buffer overflow）等安全漏洞。例如，使用 strcpy 等函数时，若目标缓冲区空间不足，就可能导致内存越界。
⚝ 手动内存管理: C 风格字符串的内存管理需要手动进行，容易出错。例如，动态分配的 C 风格字符串需要手动使用 delete[] 释放内存，稍有不慎就会造成内存泄漏（memory leak）。
⚝ 功能有限: C 风格字符串的功能相对有限，缺乏丰富的字符串操作方法，例如查找、替换、分割等，通常需要借助 C 标准库函数如 strlen、strcpy、strcmp 等，使用起来较为繁琐。
④ 适用场景:
⚝ 与 C 语言库的互操作: 当需要与 C 语言编写的库或 API 交互时，C 风格字符串是不可避免的选择。
⚝ 底层系统编程: 在某些对性能要求极致，且需要直接操作内存的底层系统编程场景中，C 风格字符串仍然有一定的应用。
⑤ 示例代码:
1
#include <iostream>
2
#include <cstring> // 引入 cstring 头文件以使用 C 风格字符串函数
3
4
int main() {
5
char c_str1[] = "Hello";
6
char c_str2[10]; // 分配 10 字节的字符数组
7
8
// 复制字符串，注意安全性问题
9
strcpy(c_str2, c_str1);
10
11
std::cout << "C-style string 1: " << c_str1 << std::endl;
12
std::cout << "C-style string 2: " << c_str2 << std::endl;
13
std::cout << "Length of c_str1: " << strlen(c_str1) << std::endl; // 计算字符串长度
14
15
return 0;
16
}
总结: C 风格字符串是 C++ 字符串处理的基础，但由于其安全性和易用性方面的缺陷，在现代 C++ 开发中，通常更推荐使用更安全、功能更强大的 std::string。
1.1.2 std::string：标准库的强大工具 (std::string: The Powerful Tool in Standard Library)
std::string 是 C++ 标准库提供的字符串类，它极大地简化了字符串操作，并提供了更高的安全性和更丰富的功能，是现代 C++ 开发中最常用的字符串类型。
① 定义与特性: std::string 是一个类，封装了字符串数据以及一系列操作字符串的方法。它具有以下关键特性：
⚝ 动态内存管理: std::string 内部自动管理内存，可以根据字符串长度动态分配和释放内存，无需手动管理，避免了内存泄漏和缓冲区溢出等问题。
⚝ 丰富的成员函数: std::string 提供了大量的成员函数，用于字符串的查找、替换、拼接、比较、子串操作等，极大地提高了字符串处理的效率和便利性。
⚝ 安全性: std::string 进行了边界检查，避免了缓冲区溢出等安全问题。例如，使用 operator[] 访问字符时，如果索引越界，会抛出异常（虽然默认不检查，但可以使用 at() 方法进行安全访问）。
⚝ 易用性: std::string 的接口设计简洁直观，易于学习和使用。
② 常用操作: std::string 提供了非常丰富的操作，包括：
⚝ 构造与赋值: 可以使用字符串字面量、C 风格字符串、其他 std::string 对象等多种方式构造和赋值 std::string 对象。
⚝ 长度与容量: size() 或 length() 方法获取字符串长度， capacity() 方法获取字符串容量。
⚝ 访问字符: 可以使用 operator[] 或 at() 方法访问字符串中的字符。
⚝ 拼接: 可以使用 + 运算符或 append() 方法进行字符串拼接。
⚝ 查找: find()、rfind()、find_first_of()、find_last_of() 等方法用于字符串查找。
⚝ 子串: substr() 方法用于获取子字符串。
⚝ 比较: 可以使用 ==、!=、<、> 等运算符进行字符串比较。
③ 示例代码:
1
#include <iostream>
2
#include <string> // 引入 string 头文件
3
4
int main() {
5
std::string str1 = "Hello, ";
6
std::string str2 = "std::string!";
7
8
// 拼接字符串
9
std::string str3 = str1 + str2;
10
std::cout << "str3: " << str3 << std::endl;
11
12
// 获取长度
13
std::cout << "Length of str3: " << str3.length() << std::endl;
14
15
// 查找子串
16
size_t pos = str3.find("string");
17
if (pos != std::string::npos) {
18
std::cout << "'string' found at position: " << pos << std::endl;
19
}
20
21
// 获取子串
22
std::string sub_str = str3.substr(7, 6); // 从位置 7 开始，截取 6 个字符
23
std::cout << "Substring: " << sub_str << std::endl;
24
25
return 0;
26
}
④ std::string 的内存管理: std::string 通常使用动态内存分配来存储字符串数据。早期的 std::string 实现中，很多采用了写时复制（Copy-on-Write, COW）技术来优化性能，但由于 COW 在多线程环境下的复杂性和潜在的性能问题，现代 C++ 标准库的 std::string 实现，例如 GCC libstdc++ 和 LLVM libc++，已经不再使用 COW。 现代 std::string 通常采用更直接的内存管理策略，例如小字符串优化（Small String Optimization, SSO），以提高性能。
⑤ 适用场景: std::string 几乎适用于所有需要处理文本字符串的 C++ 应用场景。无论是日常的字符串操作、文件读写、网络编程、还是更复杂的算法实现，std::string 都是首选的字符串类型。
总结: std::string 是 C++ 标准库提供的强大且易用的字符串类，它提供了动态内存管理、丰富的操作方法和较高的安全性，是现代 C++ 开发中处理字符串的首选工具。
1.1.3 folly::fbstring 与写时复制 (Copy-on-Write) 机制 (folly::fbstring and Copy-on-Write Mechanism)
folly::fbstring 是 Facebook 开源的 Folly 库中提供的字符串类。它旨在提供高性能的字符串操作，并在某些方面对 std::string 进行了优化。其中一个关键的优化策略就是 写时复制 (Copy-on-Write, COW) 机制。
① 写时复制 (COW) 机制: 写时复制是一种资源管理优化技术。其核心思想是，在多个对象共享同一份资源（例如字符串数据）时，并不立即进行物理复制。只有当某个对象需要修改资源时，才真正进行复制操作，从而避免不必要的复制开销，提高性能。
② folly::fbstring 与 COW: folly::fbstring 的早期版本以及一些其他字符串库（例如 Qt 的 QString）使用了写时复制技术。当多个 fbstring 对象通过拷贝构造或赋值操作共享同一个字符串缓冲区时，它们实际上指向同一块内存。只有当其中一个 fbstring 对象尝试修改字符串内容时，才会触发真正的内存复制，创建一个新的缓冲区，并将修改操作应用到新的缓冲区上。
③ COW 的优势:
⚝ 减少复制开销: 在字符串频繁拷贝但修改较少的场景下，COW 可以显著减少内存复制的次数，提高性能。例如，函数参数传递、返回值返回等场景，如果使用传值方式传递或返回字符串，COW 可以避免深拷贝的开销。
⚝ 节省内存: 多个对象共享同一份数据，可以节省内存空间。
④ COW 的局限性与问题:
⚝ 线程安全问题: COW 在多线程环境下容易引发线程安全问题。为了保证线程安全，需要引入额外的同步机制（例如互斥锁），这会增加开销，甚至可能导致性能下降。
⚝ 现代硬件与编译器的优化: 现代硬件（例如多核处理器、高速缓存）和编译器优化技术（例如移动语义、返回值优化 RVO）在一定程度上降低了深拷贝的开销。在某些情况下，COW 的优势不再明显，甚至可能成为性能瓶颈。
⚝ 复杂性: COW 的实现较为复杂，容易引入 bug，并且调试和维护也相对困难。
⑤ folly::fbstring 的现状: 尽管 COW 曾经被认为是提高字符串性能的有效手段，但由于上述局限性，特别是线程安全问题，现代 folly::fbstring 的实现已经 不再使用写时复制。 folly::fbstring 仍然是一个高性能的字符串类，但其性能优势更多来自于其他方面的优化，例如自定义内存分配器、小字符串优化（SSO）等，这些将在后续章节详细介绍。
⑥ 示例代码 (概念性，早期 COW fbstring 的行为): 以下代码 仅为概念性示例，展示了早期 COW fbstring 的可能行为，现代 folly::fbstring 已经不再是 COW 字符串。
1
#include <iostream>
2
#include <folly/FBString.h>
3
4
int main() {
5
folly::fbstring str1 = "Initial string";
6
folly::fbstring str2 = str1; // 拷贝构造，str1 和 str2 共享数据
7
8
std::cout << "str1: " << str1 << std::endl;
9
std::cout << "str2: " << str2 << std::endl;
10
11
// 此时 str1 和 str2 仍然共享同一块内存
12
13
str2 += " - modified"; // 修改 str2，触发写时复制
14
15
// 修改后，str2 拥有了自己的独立内存，str1 不受影响
16
std::cout << "str1 after str2 modification: " << str1 << std::endl;
17
std::cout << "str2 after modification: " << str2 << std::endl;
18
19
return 0;
20
}
总结: folly::fbstring 曾经使用写时复制技术来优化性能，但现代实现已经放弃了 COW。理解 COW 机制有助于我们理解字符串优化的历史和一些设计权衡。 尽管不再使用 COW，folly::fbstring 仍然是一个值得学习和使用的高性能字符串类，它在内存管理、性能优化等方面有很多值得借鉴的经验，我们将在后续章节深入探讨。
1.2 folly::StringPiece：高效的字符串视图 (Efficient String Views with folly::StringPiece)
folly::StringPiece 是 Folly 库中另一个非常重要的字符串工具。它并非一个字符串类，而是一个 字符串视图 (string view)。理解 StringPiece 的设计理念和使用场景，对于编写高效的 C++ 代码至关重要，尤其是在处理字符串时。
1.2.1 StringPiece 的设计理念与优势 (Design Philosophy and Advantages of StringPiece)
StringPiece 的核心设计理念是 零拷贝 (zero-copy) 和 高效只读访问 (efficient read-only access)。它提供了一种轻量级的方式来引用已存在的字符串数据，而无需进行任何内存复制。
① 设计理念:
⚝ 非拥有 (Non-owning): StringPiece 不拥有 它所指向的字符串数据。它只是一个指向现有字符串的指针和长度的组合。这意味着 StringPiece 对象本身并不负责字符串数据的内存管理。
⚝ 只读 (Read-only): StringPiece 提供的接口主要是用于 只读 访问字符串数据。它不提供修改字符串内容的方法。
⚝ 高效 (Efficient): 由于 StringPiece 不进行内存复制，因此构造、拷贝和赋值操作都非常快速，开销极小。
② 优势:
⚝ 避免不必要的拷贝: 在很多场景下，我们只需要读取字符串的内容，而不需要修改它。使用 StringPiece 可以避免 std::string 或 fbstring 等字符串类在拷贝时可能发生的内存复制，从而提高性能。
⚝ 与多种字符串类型兼容: StringPiece 可以方便地与 C 风格字符串、std::string、fbstring 等多种字符串类型进行交互，因为它只需要知道字符串的起始地址和长度。
⚝ 函数接口的通用性: 使用 StringPiece 作为函数参数类型，可以使函数接受多种字符串类型的输入，提高代码的通用性和灵活性。
⚝ 减少内存分配: 由于避免了字符串拷贝，也间接减少了动态内存分配的次数，有助于提高性能和降低内存碎片。
③ 适用场景:
⚝ 字符串只读操作: 当只需要读取字符串内容，例如字符串查找、解析、比较等操作时，StringPiece 是理想的选择。
⚝ 函数参数传递: 当函数只需要读取字符串参数，而不需要修改时，使用 StringPiece 作为参数类型可以提高效率，并使函数更通用。
⚝ 解析和处理大型文本数据: 在处理大型文本数据（例如日志文件、配置文件）时，使用 StringPiece 可以避免大量不必要的字符串拷贝，显著提高解析和处理速度。
④ 与 std::string_view 的关系: C++17 标准引入了 std::string_view，其设计理念和功能与 folly::StringPiece 非常相似。std::string_view 也是一个字符串视图，提供了高效的只读字符串访问。在支持 C++17 及以上标准的项目中，std::string_view 通常是 folly::StringPiece 的替代选择。 folly::StringPiece 可以看作是 std::string_view 的一个早期实现和实践。
总结: folly::StringPiece 是一种高效、轻量级的字符串视图，它通过零拷贝和只读访问的设计理念，避免了不必要的内存复制，提高了字符串处理的性能。理解和善用 StringPiece，可以编写出更高效、更通用的 C++ 代码。
1.2.2 StringPiece 的构造、赋值与基本操作 (Construction, Assignment, and Basic Operations of StringPiece)
folly::StringPiece 的使用非常简单直接。由于它是一个字符串视图，其构造、赋值和基本操作都围绕着如何引用已存在的字符串数据展开。
① 构造函数: StringPiece 提供了多种构造函数，可以从不同类型的字符串数据构造 StringPiece 对象：
⚝ 默认构造函数: 创建一个空的 StringPiece 对象，不指向任何字符串数据。
1
folly::StringPiece sp1; // 空 StringPiece
⚝ C 风格字符串构造: 从 C 风格字符串构造 StringPiece。
1
const char* c_str = "Hello StringPiece";
2
folly::StringPiece sp2(c_str); // 从 C 风格字符串构造
⚝ C 风格字符串和长度构造: 从 C 风格字符串和长度构造 StringPiece。当 C 风格字符串不是以空字符结尾，或者只想使用 C 风格字符串的一部分时，可以使用这种构造方式。
1
const char* data = "StringPiece data with extra";
2
folly::StringPiece sp3(data, 14); // 从 data 的前 14 个字符构造，即 "StringPiece dat"
⚝ std::string 构造: 从 std::string 对象构造 StringPiece。
1
std::string std_str = "String from std::string";
2
folly::StringPiece sp4(std_str); // 从 std::string 构造
⚝ fbstring 构造: 从 folly::fbstring 对象构造 StringPiece。
1
folly::fbstring fb_str = "String from fbstring";
2
folly::StringPiece sp5(fb_str); // 从 fbstring 构造
② 赋值操作: StringPiece 提供了赋值运算符，可以将其他 StringPiece 对象或兼容的字符串类型赋值给 StringPiece 对象。赋值操作仍然是零拷贝的，只是修改 StringPiece 对象内部的指针和长度。
1
folly::StringPiece sp6 = sp2; // 拷贝赋值
2
folly::StringPiece sp7;
3
sp7 = std_str; // 从 std::string 赋值
③ 基本操作: StringPiece 提供了丰富的成员函数，用于访问和操作字符串视图，但都是 只读 操作。
⚝ 长度和判空: length() 或 size() 方法获取字符串视图的长度， empty() 方法判断字符串视图是否为空。
1
std::cout << "Length of sp2: " << sp2.length() << std::endl;
2
std::cout << "Is sp1 empty? " << sp1.empty() << std::endl;
⚝ 字符访问: operator[] 允许通过索引访问字符串视图中的字符，但不进行边界检查。 at() 方法也提供字符访问，但会进行边界检查，越界时抛出异常。
1
std::cout << "First char of sp2: " << sp2[0] << std::endl;
2
// std::cout << sp2.at(100); // 可能会抛出异常，如果越界
⚝ 比较操作: StringPiece 支持各种比较运算符，例如 ==、!=、<、> 等，用于比较两个 StringPiece 对象或 StringPiece 对象与其他字符串类型。比较操作是基于字典序的。
1
folly::StringPiece sp8 = "apple";
2
folly::StringPiece sp9 = "banana";
3
std::cout << "sp8 == sp9? " << (sp8 == sp9) << std::endl; // 比较
4
std::cout << "sp8 < sp9? " << (sp8 < sp9) << std::endl; // 字典序比较
⚝ 查找操作: StringPiece 提供了 find()、rfind()、startsWith()、endsWith() 等方法用于字符串查找和匹配。这些方法返回位置索引或布尔值。
1
folly::StringPiece sp10 = "This is a StringPiece example";
2
size_t pos = sp10.find("StringPiece");
3
if (pos != folly::StringPiece::npos) {
4
std::cout << "'StringPiece' found at: " << pos << std::endl;
5
}
6
std::cout << "Starts with 'This'? " << sp10.startsWith("This") << std::endl;
⚝ 子串操作: substr() 方法用于获取字符串视图的子串，返回一个新的 StringPiece 对象，仍然是零拷贝的。
1
folly::StringPiece sp11 = sp10.substr(10, 11); // 从位置 10 开始，截取 11 个字符
2
std::cout << "Substring: " << sp11 << std::endl; // 输出 "StringPiece"
注意: 由于 StringPiece 是非拥有型的，使用 StringPiece 时需要特别注意其生命周期。必须确保 StringPiece 对象所引用的原始字符串数据在其生命周期内保持有效。如果原始字符串数据被释放或销毁，StringPiece 对象就会变成悬空指针，访问它会导致未定义行为。
总结: folly::StringPiece 的构造、赋值和基本操作都非常高效且易于使用。掌握这些基本操作，可以帮助我们充分利用 StringPiece 的优势，编写出更高效的字符串处理代码。
1.2.3 StringPiece 的使用场景与最佳实践 (Use Cases and Best Practices for StringPiece)
folly::StringPiece 在很多场景下都能发挥其高效的优势。了解其最佳使用场景和实践方法，可以帮助我们更好地应用 StringPiece，提升代码性能和可维护性。
① 使用场景:
⚝ 函数参数: 当函数需要接受字符串参数，并且在函数内部只需要读取字符串内容，而不需要修改时，应该优先考虑使用 StringPiece 作为参数类型。这可以避免不必要的字符串拷贝，提高函数调用的效率。
1
void processString(folly::StringPiece str) {
2
// 函数内部只读访问 str
3
std::cout << "Processing string: " << str << std::endl;
4
// ... 其他只读操作 ...
5
}
6
7
int main() {
8
std::string data = "Large string data";
9
processString(data); // 传递 std::string，零拷贝
10
const char* c_str_data = "C-style string data";
11
processString(c_str_data); // 传递 C 风格字符串，零拷贝
12
folly::fbstring fb_data = "fbstring data";
13
processString(fb_data); // 传递 fbstring，零拷贝
14
return 0;
15
}
⚝ 字符串解析: 在解析文本数据，例如日志文件、配置文件、网络协议数据包等时，StringPiece 非常有用。可以利用 StringPiece 快速分割、查找和提取关键信息，而无需进行大量的字符串拷贝。
1
void parseLogLine(folly::StringPiece logLine) {
2
size_t timestamp_end = logLine.find(' ');
3
if (timestamp_end != folly::StringPiece::npos) {
4
folly::StringPiece timestamp = logLine.substr(0, timestamp_end);
5
folly::StringPiece message = logLine.substr(timestamp_end + 1);
6
std::cout << "Timestamp: " << timestamp << std::endl;
7
std::cout << "Message: " << message << std::endl;
8
// ... 进一步解析 message ...
9
}
10
}
11
12
int main() {
13
std::string log = "2024-01-01 10:00:00 [INFO] System started";
14
parseLogLine(log);
15
return 0;
16
}
⚝ 避免临时字符串拷贝: 在某些需要临时创建字符串的场景下，如果只是为了传递给某个函数进行只读操作，可以考虑使用 StringPiece 来避免临时字符串的拷贝。
1
void printFirstWord(folly::StringPiece str) {
2
size_t space_pos = str.find(' ');
3
folly::StringPiece firstWord = (space_pos == folly::StringPiece::npos) ? str : str.substr(0, space_pos);
4
std::cout << "First word: " << firstWord << std::endl;
5
}
6
7
int main() {
8
std::string line = "This is a line of text";
9
printFirstWord(line);
10
return 0;
11
}
② 最佳实践:
⚝ 生命周期管理: 务必注意 StringPiece 的生命周期。确保 StringPiece 引用的原始字符串数据在 StringPiece 对象使用期间保持有效。避免 StringPiece 引用局部变量或临时对象，因为这些对象可能会在 StringPiece 仍然存在时被销毁。
⚝ 只读操作: StringPiece 主要用于只读操作。如果需要修改字符串内容，应该使用 std::string 或 fbstring 等字符串类。
⚝ 与 std::string_view 的选择: 如果项目已经使用 C++17 或更高版本，并且标准库支持完善，优先考虑使用 std::string_view，它与 folly::StringPiece 功能类似，但属于标准库，具有更好的通用性和可移植性。 如果项目环境较老，或者需要使用 Folly 库的其他功能，则 folly::StringPiece 仍然是一个很好的选择。
⚝ 性能考量: 虽然 StringPiece 通常能提高性能，但在某些极端情况下，过度使用 StringPiece 也可能导致性能下降。例如，如果频繁地从 StringPiece 转换为 std::string 或 fbstring，反而会增加拷贝开销。 因此，在性能敏感的场景下，需要进行实际的性能测试和分析，选择最合适的字符串处理方式。
总结: folly::StringPiece 在字符串只读操作、函数参数传递和字符串解析等场景下具有显著的优势。遵循最佳实践，注意生命周期管理，并根据实际情况选择合适的字符串类型，可以充分发挥 StringPiece 的作用，提高代码的效率和质量。
1.3 folly::fbstring 详解：高性能字符串的秘密 (folly::fbstring in Detail: The Secret of High-Performance Strings)
folly::fbstring 是 Folly 库中用于替代 std::string 的高性能字符串类。虽然现代 fbstring 已经不再使用写时复制 (COW) 机制，但它仍然通过其他多种优化策略，在特定场景下提供优于 std::string 的性能。本节将深入探讨 fbstring 的内存管理策略、常用方法以及与 std::string 的对比分析，揭示其高性能的秘密。
1.3.1 fbstring 的内存管理策略 (Memory Management Strategies of fbstring)
folly::fbstring 的内存管理是其高性能的关键所在。它主要采用了以下几种策略来优化内存使用和性能：
① 小字符串优化 (SSO, Small String Optimization): 小字符串优化是一种常见的字符串优化技术，旨在提高短字符串操作的性能。fbstring 也采用了 SSO。
⚝ 原理: SSO 的核心思想是，对于长度较短的字符串，直接将字符串数据存储在 fbstring 对象自身的内存空间中，而不是动态分配堆内存。只有当字符串长度超过一定阈值时，才会在堆上分配内存。
⚝ 优势:
▮▮▮▮⚝ 减少堆内存分配: 对于短字符串，避免了堆内存分配和释放的开销，提高了性能。
▮▮▮▮⚝ 提高缓存局部性: 短字符串数据与 fbstring 对象本身存储在一起，提高了数据访问的局部性，有利于 CPU 缓存命中，进一步提高性能。
⚝ 实现细节: fbstring 通常会在对象内部预留一块固定大小的缓冲区（例如 15 或 22 字节）。当字符串长度小于等于缓冲区大小时，字符串数据直接存储在这个缓冲区中。当字符串长度超过缓冲区大小时，才会在堆上动态分配内存。
② 自定义内存分配器 (Custom Memory Allocator): fbstring 可以使用自定义的内存分配器来管理堆内存。Folly 库提供了多种内存分配器，例如 fb::Arena、fb::Pool 等，这些分配器针对特定场景进行了优化，可以提高内存分配和释放的效率。
⚝ 优势:
▮▮▮▮⚝ 更高效的内存分配: 自定义内存分配器可以根据 fbstring 的使用模式进行优化，例如预先分配大块内存、减少内存碎片等，从而提高内存分配效率。
▮▮▮▮⚝ 更好的内存控制: 自定义内存分配器可以提供更精细的内存控制，例如限制内存使用量、监控内存分配情况等。
⚝ 应用场景: 在高性能服务器程序、内存受限的环境等场景下，使用自定义内存分配器可以显著提高 fbstring 的性能和资源利用率。
③ 对齐优化 (Alignment Optimization): fbstring 在内存布局上可能进行对齐优化，以提高内存访问效率。例如，确保字符串数据在内存中按照一定的字节数对齐，可以提高 CPU 访问内存的速度。
④ 延迟收缩 (Lazy Shrinking): 当 fbstring 的字符串长度缩小时，例如使用 resize() 或 clear() 方法，fbstring 可能不会立即释放多余的内存空间，而是延迟到后续的内存分配操作时再进行收缩。
⚝ 优势: 避免频繁的内存分配和释放操作，特别是在字符串长度频繁变化的场景下，可以提高性能。
⚝ 权衡: 延迟收缩可能会导致 fbstring 占用稍多的内存空间，但通常情况下，性能的提升更为重要。
⑤ 无 COW (No Copy-on-Write): 如前所述，现代 fbstring 已经放弃了写时复制 (COW) 机制，避免了 COW 带来的线程安全问题和潜在的性能瓶颈。 fbstring 采用更直接的内存管理策略，例如移动语义、返回值优化 (RVO) 等，来减少不必要的内存拷贝。
总结: folly::fbstring 通过小字符串优化 (SSO)、自定义内存分配器、对齐优化、延迟收缩以及放弃 COW 等多种内存管理策略，实现了高性能的字符串操作。这些策略共同作用，使得 fbstring 在特定场景下能够提供优于 std::string 的性能。
1.3.2 fbstring 的构造、赋值与常用方法 (Construction, Assignment, and Common Methods of fbstring)
folly::fbstring 的接口设计与 std::string 非常相似，易于学习和使用。它提供了丰富的构造函数、赋值运算符和成员函数，用于字符串的创建、操作和管理。
① 构造函数: fbstring 提供了多种构造函数，与 std::string 类似，可以从不同类型的字符串数据构造 fbstring 对象：
⚝ 默认构造函数: 创建一个空的 fbstring 对象。
1
folly::fbstring fb_str1; // 空 fbstring
⚝ C 风格字符串构造: 从 C 风格字符串构造 fbstring。
1
const char* c_str = "Hello fbstring";
2
folly::fbstring fb_str2(c_str); // 从 C 风格字符串构造
⚝ std::string 构造: 从 std::string 对象构造 fbstring。
1
std::string std_str = "String from std::string";
2
folly::fbstring fb_str3(std_str); // 从 std::string 构造
⚝ StringPiece 构造: 从 folly::StringPiece 对象构造 fbstring。
1
folly::StringPiece sp = "StringPiece source";
2
folly::fbstring fb_str4(sp); // 从 StringPiece 构造
⚝ 指定长度和字符构造: 构造指定长度并用特定字符填充的 fbstring。
1
folly::fbstring fb_str5(10, 'x'); // 构造长度为 10，内容为 "xxxxxxxxxx" 的 fbstring
② 赋值运算符: fbstring 提供了赋值运算符，可以将其他 fbstring 对象、std::string 对象、C 风格字符串等赋值给 fbstring 对象。
1
folly::fbstring fb_str6 = fb_str2; // 拷贝赋值
2
folly::fbstring fb_str7;
3
fb_str7 = std_str; // 从 std::string 赋值
4
fb_str7 = "New string value"; // 从 C 风格字符串赋值
③ 常用方法: fbstring 提供了与 std::string 类似的常用方法，用于字符串操作和管理。
⚝ 长度和容量: length() 或 size() 方法获取字符串长度， capacity() 方法获取字符串容量， empty() 方法判断字符串是否为空。
⚝ 字符访问: operator[] 和 at() 方法用于访问字符串中的字符，与 std::string 类似。
⚝ 拼接: += 运算符和 append() 方法用于字符串拼接。
⚝ 查找: find()、rfind()、find_first_of()、find_last_of() 等方法用于字符串查找。
⚝ 子串: substr() 方法用于获取子字符串。
⚝ 比较: ==、!=、<、> 等运算符用于字符串比较。
⚝ 修改字符串内容: push_back()、pop_back()、insert()、erase()、replace()、clear()、resize() 等方法用于修改字符串内容。
⚝ 与其他类型的转换: to<T>() 模板函数可以将 fbstring 转换为其他类型，例如数字类型。 stringPrintf() 函数用于格式化输出到 fbstring。
④ 示例代码:
1
#include <iostream>
2
#include <folly/FBString.h>
3
4
int main() {
5
folly::fbstring fb_str = "Example fbstring";
6
7
std::cout << "fb_str: " << fb_str << std::endl;
8
std::cout << "Length: " << fb_str.length() << std::endl;
9
10
fb_str += " - appended"; // 拼接
11
std::cout << "After append: " << fb_str << std::endl;
12
13
size_t pos = fb_str.find("fbstring"); // 查找
14
if (pos != folly::fbstring::npos) {
15
std::cout << "'fbstring' found at: " << pos << std::endl;
16
}
17
18
folly::fbstring sub_str = fb_str.substr(8, 8); // 子串
19
std::cout << "Substring: " << sub_str << std::endl;
20
21
return 0;
22
}
总结: folly::fbstring 提供了与 std::string 相似且功能丰富的接口，易于学习和使用。 开发者可以像使用 std::string 一样使用 fbstring，同时在特定场景下获得潜在的性能提升。
1.3.3 fbstring 与 std::string 的对比分析 (Comparative Analysis of fbstring and std::string)
folly::fbstring 和 std::string 都是 C++ 中常用的字符串类，但它们在设计理念、内存管理和性能特点上存在一些差异。理解这些差异，可以帮助我们根据实际需求选择合适的字符串类型。
① 设计理念:
⚝ std::string: std::string 是 C++ 标准库的一部分，其设计目标是 通用性、易用性和安全性。 std::string 力求在各种应用场景下都能提供稳定可靠的字符串操作，并尽可能避免安全漏洞。
⚝ fbstring: fbstring 是 Folly 库提供的，其设计目标更侧重于 高性能。 fbstring 通过各种优化策略，例如 SSO、自定义内存分配器等，力求在特定场景下提供优于 std::string 的性能。
② 内存管理:
⚝ std::string: std::string 的内存管理策略由标准库实现决定，不同的标准库实现可能有所不同。 现代 std::string 通常采用 SSO 和直接内存管理，不再使用 COW。
⚝ fbstring: fbstring 采用了更激进的内存管理策略，包括 SSO、自定义内存分配器、对齐优化、延迟收缩等。 fbstring 的内存管理更加灵活和可定制，可以根据具体应用场景进行调整。
③ 性能特点:
⚝ std::string: std::string 在通用场景下性能良好，但对于某些性能敏感的应用，可能存在一定的优化空间。
⚝ fbstring: fbstring 在特定场景下，例如短字符串操作频繁、内存分配开销敏感、需要自定义内存管理等场景，通常能提供优于 std::string 的性能。 尤其是在 Facebook 内部的大规模、高性能系统中，fbstring 的性能优势更为明显。
④ 兼容性与依赖:
⚝ std::string: std::string 是 C++ 标准库的一部分，具有最佳的兼容性和可移植性。 几乎所有的 C++ 编译器和平台都支持 std::string。
⚝ fbstring: fbstring 依赖于 Folly 库。 使用 fbstring 需要引入 Folly 库的依赖，并进行编译和链接。 虽然 Folly 库本身是开源且跨平台的，但相比于标准库，其依赖性更强。
⑤ 线程安全:
⚝ std::string: std::string 在多线程环境下通常是安全的，但具体的线程安全级别取决于标准库实现。 一般来说，多个线程同时读取同一个 std::string 对象是安全的，但多个线程同时修改同一个 std::string 对象则需要进行同步保护。
⚝ fbstring: fbstring 的线程安全特性与 std::string 类似。 多个线程同时读取同一个 fbstring 对象是安全的，但并发修改需要同步保护。 由于 fbstring 不再使用 COW，避免了 COW 带来的线程安全问题。
⑥ 选择建议:
⚝ 通用场景: 在大多数通用应用场景下，std::string 已经足够满足需求。 std::string 易用、通用、兼容性好，是首选的字符串类型。
⚝ 性能敏感场景: 在性能敏感的应用场景下，例如高性能服务器、大规模数据处理、游戏开发等，可以考虑使用 fbstring。 fbstring 在特定场景下可能提供更好的性能。 但需要进行实际的性能测试和评估，确定 fbstring 是否能带来明显的性能提升。
⚝ 需要 Folly 库其他功能: 如果项目已经使用了 Folly 库的其他功能，或者需要使用 Folly 库提供的其他工具和组件，那么使用 fbstring 可以更好地与 Folly 库集成。
⚝ 考虑依赖性: 使用 fbstring 需要引入 Folly 库的依赖。 需要权衡引入额外依赖的成本和收益。 如果项目对依赖性有严格要求，或者希望尽量减少外部依赖，则 std::string 可能是更合适的选择。
总结: folly::fbstring 和 std::string 各有优缺点。 std::string 通用性强、易用性好，适合大多数场景。 fbstring 性能更优，但在特定场景下才能体现其优势，并且有额外的依赖性。 选择哪种字符串类型，需要根据具体的应用场景、性能需求、依赖性要求等因素进行权衡。
1.4.1 Folly 库的安装与编译 (Installation and Compilation of Folly Library)
要开始使用 folly::String，首先需要安装和编译 Folly 库。 Folly 是一个大型的 C++ 库，依赖较多，编译过程相对复杂。 本节将介绍 Folly 库的安装和编译步骤，帮助读者搭建开发环境。
① 环境准备: 在开始安装和编译 Folly 之前，需要确保系统满足以下基本环境要求：
⚝ 操作系统: Linux (推荐), macOS。 Windows 平台的支持相对较弱，编译过程可能更复杂。
⚝ C++ 编译器: GCC 5.0 或更高版本，Clang 3.8 或更高版本。 推荐使用较新版本的编译器，以获得更好的 C++14/C++17 支持。
⚝ CMake: 3.5 或更高版本。 CMake 是 Folly 库的构建工具。
⚝ Python: 2.7 或 3.x 版本。 CMake 构建过程可能需要 Python。
⚝ 其他依赖库: Folly 依赖于许多第三方库，例如 Boost, OpenSSL, zlib, libevent, glog, gflags 等。 具体的依赖库列表和版本要求，请参考 Folly 官方文档。
② 获取 Folly 源代码: Folly 库的源代码托管在 GitHub 上。 可以使用 Git 工具克隆 Folly 仓库：
1
git clone https://github.com/facebook/folly.git
2
cd folly
③ 安装依赖库: Folly 依赖的第三方库需要手动安装。 具体的安装方法取决于操作系统和包管理器。 以下是一些常用操作系统和包管理器的安装示例：
⚝ Ubuntu/Debian: 使用 apt-get 包管理器安装常用依赖库。
1
sudo apt-get update
2
sudo apt-get install -y cmake g++ libboost-all-dev libevent-dev libgflags-dev libglog-dev libssl-dev libtool libleveldb-dev liblz4-dev libsnappy-dev zlib1g-dev python pkg-config autoconf automake
⚝ CentOS/RHEL: 使用 yum 包管理器安装常用依赖库。
1
sudo yum update
2
sudo yum install -y cmake gcc-c++ boost-devel libevent-devel gflags-devel glog-devel openssl-devel libtool leveldb-devel lz4-devel snappy-devel zlib-devel python pkgconfig autoconf automake
⚝ macOS (使用 Homebrew): 使用 Homebrew 包管理器安装常用依赖库。
1
brew update
2
brew install cmake boost libevent gflags glog openssl leveldb lz4 snappy zlib python
注意: Folly 的依赖库版本要求可能会随着 Folly 版本的更新而变化。 请务必参考 Folly 官方文档或 CMake 配置文件 (CMakeLists.txt) 中的依赖库版本要求，安装正确的版本。 某些依赖库可能需要手动编译安装，例如 jemalloc。
④ 使用 CMake 构建 Folly: Folly 使用 CMake 作为构建工具。 在 Folly 源代码根目录下，创建构建目录，并使用 CMake 配置和生成构建文件。
1
mkdir build
2
cd build
3
cmake ..
CMake 配置过程会自动检测系统环境、编译器、依赖库等，并生成 Makefile 或其他构建系统所需的文件。 如果 CMake 配置失败，通常是由于缺少依赖库或依赖库版本不正确。 需要根据 CMake 的错误提示，检查和安装缺少的依赖库。
⑤ 编译 Folly: 在 CMake 配置成功后，使用 make 命令进行编译。
1
make -j$(nproc) # 使用多线程编译，加快编译速度
-j$(nproc) 参数表示使用多线程编译，$(nproc) 获取当前系统的 CPU 核心数。 编译过程可能需要一段时间，取决于机器性能和代码规模。
⑥ 安装 Folly (可选): 编译成功后，可以使用 make install 命令将 Folly 库安装到系统目录 (例如 /usr/local)。 通常情况下，不需要安装 Folly 到系统目录，直接在构建目录中使用编译好的库文件即可。
1
sudo make install # 可选步骤，需要 root 权限
⑦ 验证安装: 编译和安装完成后，可以编写一个简单的程序，包含 folly/FBString.h 头文件，并链接 Folly 库，验证 Folly 库是否安装成功。 在后续的 1.4.2 节中，我们将编写第一个 folly::String.h 程序，并演示如何编译和运行。
总结: Folly 库的安装和编译过程相对复杂，需要仔细阅读 Folly 官方文档，并根据系统环境安装正确的依赖库。 按照上述步骤，通常可以成功编译 Folly 库，为后续的 folly::String 开发做好准备。
1.4.2 第一个 folly::String.h 程序 (Your First folly::String.h Program)
在成功安装和编译 Folly 库之后，我们来编写第一个使用 folly::String.h 的 C++ 程序，体验 folly::fbstring 的基本用法。
① 创建源文件: 创建一个名为 hello_fbstring.cpp 的源文件，并输入以下代码：
1
#include <iostream>
2
#include <folly/FBString.h>
3
4
int main() {
5
folly::fbstring message = "Hello, folly::fbstring!";
6
std::cout << message << std::endl;
7
return 0;
8
}
这段代码非常简单：
⚝ #include <folly/FBString.h>: 包含 folly::FBString.h 头文件，引入 folly::fbstring 类。
⚝ folly::fbstring message = "Hello, folly::fbstring!";: 创建一个 folly::fbstring 对象 message，并用字符串字面量初始化。
⚝ std::cout << message << std::endl;: 使用 std::cout 输出 message 的内容。
② 编译程序: 使用 g++ 或 clang++ 编译器编译 hello_fbstring.cpp。 编译时需要指定 Folly 库的头文件路径和库文件路径，并链接 Folly 库。 假设 Folly 库的构建目录为 folly/build，则编译命令可能如下所示 (根据实际情况调整路径)：
1
g++ -std=c++17 -I folly/ -I folly/build/folly hello_fbstring.cpp -o hello_fbstring -L folly/build/folly -lfolly -lfollybenchmark -lfolly_test_util -lboost_context -lboost_filesystem -lboost_regex -lboost_system -lboost_thread -ldouble-conversion -lglog -lgflags -lz -llz4 -lsnappy -lssl -lcrypto -levent -ldl
编译选项说明:
⚝ -std=c++17: 指定 C++ 标准为 C++17 (或 C++14，根据 Folly 版本和编译器支持情况选择)。
⚝ -I folly/: 指定 Folly 源代码根目录为头文件搜索路径。
⚝ -I folly/build/folly: 指定 Folly 构建目录下的 folly 子目录为头文件搜索路径 (某些情况下可能需要)。
⚝ hello_fbstring.cpp: 源文件名。
⚝ -o hello_fbstring: 指定可执行文件名为 hello_fbstring。
⚝ -L folly/build/folly: 指定 Folly 构建目录下的 folly 子目录为库文件搜索路径。
⚝ -lfolly: 链接 libfolly.so (或 libfolly.a) 库。
⚝ -lfollybenchmark -lfolly_test_util -lboost_context ... -ldl: 链接 Folly 依赖的其他库。 具体的依赖库列表可能因 Folly 版本和编译选项而异。 CMake 生成的构建文件中通常会包含完整的链接命令。 可以参考 CMake 生成的链接命令，或者使用 pkg-config 工具获取 Folly 的链接信息。
使用 pkg-config 获取链接信息 (如果 Folly 安装了 pkg-config 文件):
1
g++ -std=c++17 -I folly/ hello_fbstring.cpp -o hello_fbstring `pkg-config --cflags --libs folly`
pkg-config --cflags --libs folly 命令会输出 Folly 库的编译选项 (头文件路径) 和链接选项 (库文件路径和依赖库列表)。 使用反引号 ` 将命令输出嵌入到 g++ 编译命令中。
③ 运行程序: 编译成功后，运行生成的可执行文件 hello_fbstring。
1
./hello_fbstring
如果一切正常，程序将输出：
1
Hello, folly::fbstring!
这表明你已经成功编译并运行了第一个使用 folly::String.h 的程序。
总结: 编写第一个 folly::String.h 程序，并成功编译运行，是开始 folly::String 开发的第一步。 通过这个简单的示例，读者可以初步了解如何包含 folly::String.h 头文件，以及如何使用 folly::fbstring 类。 后续章节将深入介绍 folly::StringPiece 和 folly::fbstring 的更多高级用法和特性。
1.4.3 常见编译错误与解决方法 (Common Compilation Errors and Solutions)
在编译使用 folly::String.h 的程序时，可能会遇到各种编译错误。 本节总结了一些常见的编译错误及其解决方法，帮助读者快速排除编译问题。
① 头文件找不到错误: 编译时出现类似 fatal error: folly/FBString.h: No such file or directory 的错误，表示编译器找不到 folly/FBString.h 头文件。
⚝ 解决方法:
▮▮▮▮⚝ 检查头文件路径: 确认 -I 选项指定的头文件搜索路径是否正确，是否包含了 Folly 源代码根目录或安装目录下的 include 目录。
▮▮▮▮⚝ 确认 Folly 库已正确安装: 检查 Folly 库是否已成功编译和安装。 如果 Folly 库是手动编译的，需要确保头文件已复制到正确的目录，或者 -I 选项指向了正确的头文件目录。
② 库文件找不到错误: 编译时出现类似 error: cannot find -lfolly 或 ld: library not found for -lfolly 的错误，表示链接器找不到 libfolly.so (或 libfolly.a) 库文件。
⚝ 解决方法:
▮▮▮▮⚝ 检查库文件路径: 确认 -L 选项指定的库文件搜索路径是否正确，是否包含了 Folly 构建目录下的 folly 子目录或安装目录下的 lib 目录。
▮▮▮▮⚝ 确认 Folly 库已正确编译: 检查 Folly 库是否已成功编译。 如果 Folly 编译失败，需要重新编译 Folly 库。
▮▮▮▮⚝ 检查库文件名: 确认 -l 选项指定的库文件名是否正确，例如 -lfolly 对应 libfolly.so 或 libfolly.a 文件。 不同的 Folly 版本或编译选项，库文件名可能略有不同。
③ 依赖库缺失错误: 编译或链接时出现类似 error: undefined reference to '...' 或 ld: ...: undefined symbols: 的错误，表示缺少 Folly 依赖的第三方库。
⚝ 解决方法:
▮▮▮▮⚝ 安装缺失的依赖库: 根据错误提示，安装缺少的依赖库。 例如，如果提示缺少 libboost_system.so，则需要安装 Boost 库。 可以使用操作系统的包管理器安装依赖库，例如 apt-get install libboost-system-dev (Ubuntu/Debian) 或 brew install boost (macOS)。
▮▮▮▮⚝ 检查依赖库版本: 某些依赖库可能需要特定版本。 参考 Folly 官方文档或 CMake 配置文件，安装正确的依赖库版本。
▮▮▮▮⚝ 链接所有依赖库: 确保链接了 Folly 库及其所有依赖库。 CMake 生成的链接命令通常会包含完整的依赖库列表。 可以使用 pkg-config --libs folly 命令获取 Folly 的链接选项，并将其添加到编译命令中。
④ C++ 标准版本错误: 编译时出现与 C++ 标准版本相关的错误，例如使用了 C++11 特性，但编译器默认使用 C++98 标准。
⚝ 解决方法:
▮▮▮▮⚝ 指定 C++ 标准版本: 在编译命令中添加 -std=c++17 或 -std=c++14 选项，指定 C++ 标准版本。 Folly 库通常需要 C++14 或更高版本的标准支持。
⑤ 其他编译错误: 除了上述常见错误，还可能遇到其他各种编译错误，例如语法错误、类型错误、模板错误等。
⚝ 解决方法:
▮▮▮▮⚝ 仔细阅读错误信息: 编译器通常会提供详细的错误信息，包括错误类型、错误位置、错误原因等。 仔细阅读错误信息，有助于定位问题。
▮▮▮▮⚝ 检查代码语法: 检查代码是否存在语法错误，例如拼写错误、标点符号错误、括号不匹配等。
▮▮▮▮⚝ 检查类型匹配: 检查代码中是否存在类型不匹配的问题，例如函数参数类型不匹配、赋值类型不匹配等。
▮▮▮▮⚝ 查阅文档和资料: 如果遇到不熟悉的错误，可以查阅 C++ 语言规范、编译器文档、Folly 官方文档、Stack Overflow 等资料，寻求帮助。
▮▮▮▮⚝ 简化代码: 尝试将代码简化，逐步排除错误。 例如，将复杂的代码分解成 छोटे 模块，逐个模块进行编译和测试。
总结: 编译错误是开发过程中常见的问题。 遇到编译错误时，不要慌张，仔细阅读错误信息，根据错误类型和提示，逐步排查问题。 善用搜索引擎和在线资源，可以更快地找到解决方法。 积累经验，可以提高解决编译错误的能力。
END_OF_CHAPTER
2. chapter 2： folly::StringPiece 实战指南 (Practical Guide to folly::StringPiece)
2.1 字符串查找与匹配 (String Searching and Matching)
2.1.1 使用 StringPiece::find 进行精确查找 (Exact Search with StringPiece::find)
folly::StringPiece 提供了高效的字符串查找功能，其中 find 方法是最基础且常用的精确查找工具。与 std::string 的 find 类似，StringPiece::find 用于在一个 StringPiece 对象中查找另一个 StringPiece 或字符（char）首次出现的位置。但由于 StringPiece 本身不拥有字符串的所有权，find 操作也避免了不必要的内存拷贝，从而提高了效率。
StringPiece::find 方法有多种重载形式，可以灵活地适应不同的查找需求：
① 查找子字符串: size_type find(StringPiece str, size_type pos = 0) const noexcept;
从指定位置 pos 开始，查找子字符串 str 在当前 StringPiece 中首次出现的位置。如果找到，返回首次出现的索引；否则，返回 StringPiece::npos。
② 查找字符: size_type find(char c, size_type pos = 0) const noexcept;
从指定位置 pos 开始，查找字符 c 在当前 StringPiece 中首次出现的位置。如果找到，返回首次出现的索引；否则，返回 StringPiece::npos。
实战代码示例
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece text = "Hello, StringPiece! Welcome to Folly String.";
6
folly::StringPiece target = "StringPiece";
7
char charTarget = 'F';
8
9
// 查找子字符串 "StringPiece"
10
folly::StringPiece::size_type pos1 = text.find(target);
11
if (pos1 != folly::StringPiece::npos) {
12
std::cout << "找到子字符串 '" << target << "' 在位置: " << pos1 << std::endl;
13
} else {
14
std::cout << "未找到子字符串 '" << target << "'" << std::endl;
15
}
16
17
// 从指定位置开始查找子字符串 "StringPiece"
18
folly::StringPiece::size_type pos2 = text.find(target, pos1 + 1); // 从第一次出现的位置之后开始查找
19
if (pos2 != folly::StringPiece::npos) {
20
std::cout << "再次找到子字符串 '" << target << "' 在位置: " << pos2 << std::endl;
21
} else {
22
std::cout << "在位置 " << pos1 + 1 << " 之后未找到子字符串 '" << target << "'" << std::endl;
23
}
24
25
26
// 查找字符 'F'
27
folly::StringPiece::size_type pos3 = text.find(charTarget);
28
if (pos3 != folly::StringPiece::npos) {
29
std::cout << "找到字符 '" << charTarget << "' 在位置: " << pos3 << std::endl;
30
} else {
31
std::cout << "未找到字符 '" << charTarget << "'" << std::endl;
32
}
33
34
return 0;
35
}
代码解析
⚝ 首先，我们包含了必要的头文件 <folly/StringPiece.h> 和 <iostream>。
⚝ 创建了一个 folly::StringPiece 对象 text，作为被查找的字符串。
⚝ 创建了另一个 folly::StringPiece 对象 target，作为要查找的子字符串，以及一个字符 charTarget。
⚝ 使用 text.find(target) 查找子字符串 "StringPiece" 首次出现的位置，并将结果存储在 pos1 中。如果找到，则输出位置信息。
⚝ 使用 text.find(target, pos1 + 1) 从 pos1 + 1 的位置开始再次查找子字符串 "StringPiece"，并将结果存储在 pos2 中。这演示了 find 方法的起始位置参数的用法。
⚝ 使用 text.find(charTarget) 查找字符 'F' 首次出现的位置，并将结果存储在 pos3 中。
⚝ 通过检查返回值是否为 StringPiece::npos 来判断是否找到目标字符串或字符。StringPiece::npos 是一个静态成员常量，表示未找到。
使用场景与优势
⚝ 高效查找: StringPiece::find 操作非常高效，因为它直接在已有的字符串数据上进行查找，避免了额外的内存分配和拷贝。这在处理大型字符串或需要频繁进行查找操作的场景中尤其重要。
⚝ 灵活性: find 方法支持查找子字符串和单个字符，并允许指定查找的起始位置，提供了灵活的查找方式。
⚝ 与 StringPiece 的设计理念一致: find 方法的设计与 StringPiece 的轻量级、高效的设计理念一致，充分利用了 StringPiece 的优势。
2.1.2 使用 StringPiece::startsWith 和 StringPiece::endsWith 进行前后缀判断 (Prefix and Suffix Judgments with StringPiece::startsWith and StringPiece::endsWith)
在字符串处理中，经常需要判断一个字符串是否以特定的前缀或后缀开始或结束。folly::StringPiece 提供了 startsWith 和 endsWith 方法，用于高效地进行前后缀判断。这两个方法都非常轻量级，避免了不必要的内存操作，性能出色。
① startsWith: bool startsWith(StringPiece prefix) const noexcept;
判断当前 StringPiece 对象是否以指定的 prefix (前缀) 开始。返回 true 如果是，否则返回 false。
② endsWith: bool endsWith(StringPiece suffix) const noexcept;
判断当前 StringPiece 对象是否以指定的 suffix (后缀) 结束。返回 true 如果是，否则返回 false。
实战代码示例
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece text = "Folly is a great library.";
6
folly::StringPiece prefix1 = "Folly";
7
folly::StringPiece prefix2 = "folly"; // 注意大小写
8
folly::StringPiece suffix1 = "library.";
9
folly::StringPiece suffix2 = "Library."; // 注意大小写
10
11
// 判断前缀
12
if (text.startsWith(prefix1)) {
13
std::cout << "字符串以 '" << prefix1 << "' 开始" << std::endl;
14
} else {
15
std::cout << "字符串不以 '" << prefix1 << "' 开始" << std::endl;
16
}
17
18
if (text.startsWith(prefix2)) {
19
std::cout << "字符串以 '" << prefix2 << "' 开始" << std::endl;
20
} else {
21
std::cout << "字符串不以 '" << prefix2 << "' 开始" << std::endl;
22
}
23
24
// 判断后缀
25
if (text.endsWith(suffix1)) {
26
std::cout << "字符串以 '" << suffix1 << "' 结束" << std::endl;
27
} else {
28
std::cout << "字符串不以 '" << suffix1 << "' 结束" << std::endl;
29
}
30
31
if (text.endsWith(suffix2)) {
32
std::cout << "字符串以 '" << suffix2 << "' 结束" << std::endl;
33
} else {
34
std::cout << "字符串不以 '" << suffix2 << "' 结束" << std::endl;
35
}
36
37
return 0;
38
}
代码解析
⚝ 创建了一个 folly::StringPiece 对象 text，用于进行前后缀判断。
⚝ 定义了几个 folly::StringPiece 对象，分别作为前缀 (prefix1, prefix2) 和后缀 (suffix1, suffix2) 进行测试。
⚝ 使用 text.startsWith(prefix1) 和 text.startsWith(prefix2) 判断 text 是否以 prefix1 和 prefix2 开始。注意，字符串比较是大小写敏感的，因此 "Folly" 和 "folly" 被视为不同的前缀。
⚝ 使用 text.endsWith(suffix1) 和 text.endsWith(suffix2) 判断 text 是否以 suffix1 和 suffix2 结束。同样，字符串比较是大小写敏感的。
⚝ 根据 startsWith 和 endsWith 的返回值，输出相应的判断结果。
使用场景与优势
⚝ 高效前/后缀判断: startsWith 和 endsWith 方法实现非常高效，它们只进行必要的字符比较，避免了额外的内存分配和拷贝。
⚝ 代码简洁: 使用 startsWith 和 endsWith 可以使代码更简洁易读，直接表达了前/后缀判断的意图。
⚝ 广泛应用: 前后缀判断在文件类型识别、协议解析、日志分析等场景中非常常见，StringPiece::startsWith 和 StringPiece::endsWith 在这些场景中都非常实用。
⚝ 性能优势: 相比于可能需要创建子字符串再进行比较的方法（例如使用 substr），startsWith 和 endsWith 避免了子字符串的创建，性能更高。
2.1.3 使用正则表达式与 StringPiece 结合进行复杂匹配 (Complex Matching with Regular Expressions and StringPiece)
虽然 folly::StringPiece 本身不直接支持正则表达式，但它可以与正则表达式库（如 std::regex 或 Boost.Regex）结合使用，实现强大的复杂字符串匹配功能。StringPiece 提供高效的字符串视图，避免了正则表达式引擎在匹配过程中不必要的字符串拷贝，从而提升性能。
使用 std::regex 示例
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
#include <regex>
4
5
int main() {
6
folly::StringPiece text = "Log entry: 2023-10-27 10:30:45 [INFO] Server started.";
7
std::regex pattern(R"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})"); // 匹配日期时间格式
8
9
std::smatch match;
10
if (std::regex_search(text.begin(), text.end(), match, pattern)) {
11
std::cout << "找到匹配的日期时间: " << match[0] << std::endl;
12
} else {
13
std::cout << "未找到匹配的日期时间" << std::endl;
14
}
15
16
return 0;
17
}
代码解析
⚝ 包含了必要的头文件 <folly/StringPiece.h>、<iostream> 和 <regex>。
⚝ 创建了一个 folly::StringPiece 对象 text，包含一段日志文本。
⚝ 定义了一个 std::regex 对象 pattern，用于匹配日期时间格式 YYYY-MM-DD HH:MM:SS。使用了原始字符串字面量 R"(...)" 来定义正则表达式，避免了反斜杠转义的麻烦。
⚝ 使用 std::regex_search 函数在 text 中搜索匹配 pattern 的子字符串。text.begin() 和 text.end() 返回迭代器，可以与 std::regex_search 协同工作。
⚝ 如果找到匹配，std::regex_search 将匹配结果存储在 std::smatch 对象 match 中。match[0] 存储整个匹配的字符串。
⚝ 输出匹配到的日期时间，或者提示未找到匹配。
使用 Boost.Regex 示例
如果项目中使用 Boost 库，可以使用 Boost.Regex，其接口与 std::regex 类似。
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
#include <boost/regex.hpp>
4
5
int main() {
6
folly::StringPiece text = "User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3";
7
boost::regex pattern("Chrome/(\\d+\\.\\d+)"); // 匹配 Chrome 浏览器版本号
8
9
boost::smatch match;
10
if (boost::regex_search(text.begin(), text.end(), match, pattern)) {
11
std::cout << "Chrome 版本号: " << match[1] << std::endl; // match[1] 是第一个捕获组
12
} else {
13
std::cout << "未找到 Chrome 版本号" << std::endl;
14
}
15
16
return 0;
17
}
代码解析
⚝ 将 <regex> 头文件替换为 <boost/regex.hpp>，并将 std::regex 和 std::smatch 替换为 boost::regex 和 boost::smatch。
⚝ 正则表达式 pattern 匹配 "Chrome/" 后面的版本号，并使用括号 () 捕获版本号部分。
⚝ match[1] 访问第一个捕获组的内容，即括号中匹配到的版本号。
使用场景与优势
⚝ 复杂模式匹配: 正则表达式提供了强大的模式匹配能力，可以处理各种复杂的字符串匹配需求，例如数据验证、协议解析、文本分析等。
⚝ 性能提升: StringPiece 与正则表达式结合使用，避免了不必要的字符串拷贝，提高了正则表达式匹配的性能。尤其是在处理大量文本数据时，性能提升更加明显。
⚝ 灵活性: 可以使用 std::regex 或 Boost.Regex 等成熟的正则表达式库，根据项目需求选择合适的库。
⚝ 代码可读性: 正则表达式本身具有一定的学习曲线，但对于复杂的匹配任务，使用正则表达式可以使代码更简洁、更易于维护。
2.2 字符串分割与子串操作 (String Splitting and Substring Operations)
2.2.1 使用 StringPiece::split 进行字符串分割 (String Splitting with StringPiece::split)
字符串分割是将一个字符串按照指定的分隔符拆分成多个子字符串的过程。folly::StringPiece 提供了 split 方法，可以方便高效地进行字符串分割。StringPiece::split 返回一个 std::vector<folly::StringPiece>，包含了分割后的子字符串，每个子字符串都是 StringPiece 类型，避免了额外的内存拷贝。
StringPiece::split 方法有两种主要形式：
① 基于单个字符分隔符:
std::vector<StringPiece> split(char delimiter, size_type limit = npos) const;
使用单个字符 delimiter 作为分隔符，将当前 StringPiece 对象分割成多个子字符串。limit 参数可选，用于限制分割的次数，默认为 npos，表示分割所有可能的子字符串。
② 基于 folly::StringPiece 分隔符:
std::vector<StringPiece> split(StringPiece delimiter, size_type limit = npos) const;
使用 StringPiece 对象 delimiter 作为分隔符，进行字符串分割。同样，limit 参数用于限制分割次数。
实战代码示例
1
#include <folly/StringPiece.h>
2
#include <vector>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece text = "apple,banana,orange,grape";
7
8
// 使用字符 ',' 分割
9
std::vector<folly::StringPiece> fruits = text.split(',');
10
std::cout << "使用 ',' 分割的结果:" << std::endl;
11
for (const auto& fruit : fruits) {
12
std::cout << fruit << std::endl;
13
}
14
15
// 使用字符 ',' 分割，并限制分割次数为 2
16
std::vector<folly::StringPiece> fruitsLimited = text.split(',', 2);
17
std::cout << "\n使用 ',' 分割，限制次数为 2 的结果:" << std::endl;
18
for (const auto& fruit : fruitsLimited) {
19
std::cout << fruit << std::endl;
20
}
21
22
folly::StringPiece text2 = "/path/to/resource";
23
folly::StringPiece delimiter = "/";
24
25
// 使用 StringPiece "/" 分割
26
std::vector<folly::StringPiece> paths = text2.split(delimiter);
27
std::cout << "\n使用 '/' 分割的结果:" << std::endl;
28
for (const auto& path : paths) {
29
std::cout << path << std::endl;
30
}
31
32
33
return 0;
34
}
代码解析
⚝ 创建了一个 folly::StringPiece 对象 text，包含逗号分隔的水果名称。
⚝ 使用 text.split(',') 以字符 ',' 为分隔符分割 text，并将结果存储在 std::vector<folly::StringPiece> fruits 中。遍历 fruits 向量并输出每个子字符串。
⚝ 使用 text.split(',', 2) 限制分割次数为 2，并将结果存储在 fruitsLimited 中。这会得到最多 3 个子字符串（原始字符串 + 2 次分割）。
⚝ 创建了另一个 folly::StringPiece 对象 text2，包含一个文件路径。
⚝ 使用 text2.split(delimiter) 以 StringPiece 对象 "/" 为分隔符分割 text2，并将结果存储在 paths 中。
使用场景与优势
⚝ 高效字符串分割: StringPiece::split 方法高效地将字符串分割成多个 StringPiece 对象，避免了不必要的内存拷贝。
⚝ 灵活的分隔符: 支持字符和 StringPiece 两种分隔符类型，可以处理各种分割需求。
⚝ 限制分割次数: limit 参数可以控制分割的次数，适用于只需要分割字符串前部分的场景，提高了效率。
⚝ 返回 StringPiece 向量: 返回的子字符串是 StringPiece 类型，可以继续使用 StringPiece 的各种方法进行操作，无需转换为 std::string。
⚝ 广泛应用: 字符串分割在 CSV 文件解析、URL 解析、命令行参数解析等场景中非常常见，StringPiece::split 在这些场景中都非常实用。
2.2.2 使用 StringPiece::substr 获取子串 (Getting Substrings with StringPiece::substr)
获取子字符串（substring）是字符串处理中常见的操作。folly::StringPiece 提供了 substr 方法，用于高效地获取当前 StringPiece 对象的子串。StringPiece::substr 返回一个新的 StringPiece 对象，指向原始字符串的子区间，而不会发生内存拷贝。
StringPiece::substr 方法有两种重载形式：
① 指定起始位置和长度:
StringPiece substr(size_type pos = 0, size_type n = npos) const;
从位置 pos 开始，提取长度为 n 的子字符串。如果省略 n 或 n 为 npos，则提取从 pos 到字符串末尾的所有字符。
② 指定长度 (从起始位置 0 开始):
StringPiece substr(size_type n) const;
从起始位置 0 开始，提取长度为 n 的子字符串。等价于 substr(0, n)。
实战代码示例
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece text = "Hello, StringPiece!";
6
7
// 从位置 7 开始提取到末尾
8
folly::StringPiece sub1 = text.substr(7);
9
std::cout << "从位置 7 开始的子串: '" << sub1 << "'" << std::endl;
10
11
// 从位置 0 开始提取长度为 5 的子串
12
folly::StringPiece sub2 = text.substr(0, 5);
13
std::cout << "从位置 0 开始长度为 5 的子串: '" << sub2 << "'" << std::endl;
14
15
// 提取前 5 个字符 (等价于 substr(0, 5))
16
folly::StringPiece sub3 = text.substr(5);
17
std::cout << "前 5 个字符之后的子串: '" << sub3 << "'" << std::endl;
18
19
return 0;
20
}
代码解析
⚝ 创建了一个 folly::StringPiece 对象 text。
⚝ 使用 text.substr(7) 从位置 7 开始提取子字符串到末尾，并将结果存储在 sub1 中。
⚝ 使用 text.substr(0, 5) 从位置 0 开始提取长度为 5 的子字符串，并将结果存储在 sub2 中。
⚝ 使用 text.substr(5) 从位置 5 开始提取子字符串到末尾，并将结果存储在 sub3 中。
⚝ 输出提取的子字符串。
使用场景与优势
⚝ 高效子串获取: StringPiece::substr 方法非常高效，它只创建新的 StringPiece 对象，指向原始字符串的子区间，避免了内存拷贝。
⚝ 灵活的参数: 支持指定起始位置和长度，或者只指定长度（从起始位置 0 开始），满足不同的子串提取需求。
⚝ 零拷贝: 由于 StringPiece 的设计特性，substr 操作是零拷贝的，性能非常高。
⚝ 链式操作: substr 返回的仍然是 StringPiece 对象，可以方便地进行链式操作，例如 text.substr(7).startsWith("String")。
⚝ 广泛应用: 子串操作在字符串解析、数据提取、文本处理等场景中非常常见，StringPiece::substr 在这些场景中都非常实用。
2.2.3 高效处理分隔符与空字符串 (Efficiently Handling Delimiters and Empty Strings)
在字符串分割过程中，高效处理分隔符和空字符串至关重要。folly::StringPiece::split 方法在设计时就考虑了这些因素，提供了灵活的选项来满足不同的需求。
分隔符处理
⚝ 单个字符分隔符: split(char delimiter, ...) 可以处理单个字符作为分隔符的情况，例如逗号、空格、制表符等。
⚝ 多字符分隔符: split(StringPiece delimiter, ...) 可以处理多字符字符串作为分隔符的情况，例如 ", "、"\r\n" 等。
⚝ 连续分隔符: 默认情况下，split 方法会将连续的分隔符视作单个分隔符。例如，对于字符串 "a,,b,c"，使用逗号 , 分割，会得到 {"a", "", "b", "c"}。如果需要忽略连续分隔符之间的空字符串，可以在分割后进行过滤。
空字符串处理
⚝ 保留空字符串: 默认情况下，split 方法会保留分割结果中的空字符串。例如，对于字符串 "a,,b,c"，分割结果包含一个空字符串 ""。
⚝ 忽略空字符串: 如果需要忽略分割结果中的空字符串，可以在分割后手动过滤掉空字符串。可以使用循环遍历分割结果，并判断每个 StringPiece 的长度是否为 0，如果为 0 则忽略。
实战代码示例：处理连续分隔符和空字符串
1
#include <folly/StringPiece.h>
2
#include <vector>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece text = "a,,b,,,c,d";
7
8
// 使用逗号 ',' 分割，默认保留空字符串
9
std::vector<folly::StringPiece> parts1 = text.split(',');
10
std::cout << "默认分割结果 (保留空字符串):" << std::endl;
11
for (const auto& part : parts1) {
12
std::cout << "'" << part << "'" << std::endl;
13
}
14
15
// 使用逗号 ',' 分割，并过滤空字符串
16
std::vector<folly::StringPiece> parts2 = text.split(',');
17
std::vector<folly::StringPiece> filteredParts;
18
for (const auto& part : parts2) {
19
if (!part.empty()) { // 使用 StringPiece::empty() 判断是否为空字符串
20
filteredParts.push_back(part);
21
}
22
}
23
std::cout << "\n过滤空字符串后的结果:" << std::endl;
24
for (const auto& part : filteredParts) {
25
std::cout << "'" << part << "'" << std::endl;
26
}
27
28
return 0;
29
}
代码解析
⚝ 创建了一个 folly::StringPiece 对象 text，包含连续的逗号分隔符。
⚝ 使用 text.split(',') 进行分割，默认情况下会保留空字符串，并将结果存储在 parts1 中。输出 parts1 的内容，可以看到其中包含空字符串 ""。
⚝ 再次使用 text.split(',') 分割，并将结果存储在 parts2 中。然后，创建一个新的 std::vector<folly::StringPiece> filteredParts 用于存储过滤后的结果。
⚝ 遍历 parts2，使用 part.empty() 判断每个 StringPiece 是否为空字符串。StringPiece::empty() 方法用于判断 StringPiece 是否为空，非常高效。
⚝ 如果 part 不为空，则将其添加到 filteredParts 中。
⚝ 输出 filteredParts 的内容，可以看到空字符串已经被过滤掉。
最佳实践
⚝ 根据需求选择是否保留空字符串: 根据具体的应用场景，决定是否需要保留分割结果中的空字符串。如果空字符串有意义，则保留；如果空字符串是噪音，则过滤掉。
⚝ 使用 StringPiece::empty() 高效判断空字符串: 使用 StringPiece::empty() 方法可以高效地判断 StringPiece 是否为空字符串，避免不必要的长度计算。
⚝ 考虑性能: 在处理大量字符串分割操作时，考虑性能因素。folly::StringPiece::split 已经非常高效，但合理的分割策略和空字符串处理方式也能进一步提升性能。
2.3 字符串比较与排序 (String Comparison and Sorting)
2.3.1 StringPiece 的字典序比较 (Lexicographical Comparison of StringPiece)
folly::StringPiece 支持字典序比较，可以方便地对 StringPiece 对象进行排序和比较操作。字典序比较，也称为词典序或字母序，是指按照字符串中字符的 Unicode 值逐个比较，直到比较出结果或所有字符都比较完毕。
StringPiece 重载了标准的比较运算符，可以直接使用这些运算符进行字典序比较：
⚝ ==: 等于
⚝ !=: 不等于
⚝ <: 小于
⚝ <=: 小于等于
⚝ >: 大于
⚝ >=: 大于等于
这些比较运算符都进行了重载，可以高效地比较两个 StringPiece 对象，而无需进行字符串拷贝。
实战代码示例
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
#include <algorithm> // std::sort
4
#include <vector>
5
6
int main() {
7
folly::StringPiece str1 = "apple";
8
folly::StringPiece str2 = "banana";
9
folly::StringPiece str3 = "apple";
10
folly::StringPiece str4 = "Apple"; // 注意大小写
11
12
// 比较运算符
13
std::cout << "'" << str1 << "' == '" << str2 << "': " << (str1 == str2) << std::endl;
14
std::cout << "'" << str1 << "' == '" << str3 << "': " << (str1 == str3) << std::endl;
15
std::cout << "'" << str1 << "' != '" << str2 << "': " << (str1 != str2) << std::endl;
16
std::cout << "'" << str1 << "' < '" << str2 << "': " << (str1 < str2) << std::endl;
17
std::cout << "'" << str1 << "' > '" << str2 << "': " << (str1 > str2) << std::endl;
18
std::cout << "'" << str1 << "' < '" << str4 << "': " << (str1 < str4) << std::endl; // 'a' > 'A' (ASCII 值)
19
20
21
// 使用 std::sort 对 StringPiece 向量进行排序
22
std::vector<folly::StringPiece> fruits = {"orange", "apple", "grape", "banana"};
23
std::sort(fruits.begin(), fruits.end()); // 默认使用字典序比较
24
25
std::cout << "\n排序后的水果:" << std::endl;
26
for (const auto& fruit : fruits) {
27
std::cout << fruit << std::endl;
28
}
29
30
return 0;
31
}
代码解析
⚝ 创建了几个 folly::StringPiece 对象，用于比较操作。
⚝ 使用 ==、!=、<、> 等比较运算符比较不同的 StringPiece 对象，并输出比较结果。注意，字典序比较是大小写敏感的，"apple" 和 "Apple" 被视为不同的字符串。
⚝ 创建了一个 std::vector<folly::StringPiece> fruits，包含一些水果名称。
⚝ 使用 std::sort 函数对 fruits 向量进行排序。由于 folly::StringPiece 重载了 < 运算符，std::sort 默认使用字典序进行排序。
⚝ 输出排序后的水果名称。
使用场景与优势
⚝ 高效字典序比较: StringPiece 的比较运算符实现高效，避免了字符串拷贝，性能高。
⚝ 直接使用标准比较运算符: 可以直接使用标准的比较运算符 (==, !=, <, <=, >, >=) 进行 StringPiece 对象的比较，代码简洁易读。
⚝ 与标准库算法兼容: StringPiece 的比较运算符与标准库算法（如 std::sort, std::lower_bound, std::upper_bound 等）兼容，可以直接用于排序和查找操作。
⚝ 广泛应用: 字典序比较在字符串排序、数据索引、文本处理等场景中非常常见，StringPiece 的字典序比较功能在这些场景中都非常实用。
2.3.2 自定义比较函数与排序规则 (Custom Comparison Functions and Sorting Rules)
虽然 folly::StringPiece 默认支持字典序比较，但在某些场景下，可能需要自定义比较函数或排序规则。例如，忽略大小写比较、按照字符串长度排序、按照特定规则排序等。folly::StringPiece 可以与自定义比较函数结合使用，实现灵活的排序和比较。
自定义比较函数示例：忽略大小写比较
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
#include <algorithm> // std::sort, std::tolower
4
#include <vector>
5
#include <cctype> // std::tolower
6
7
// 自定义比较函数，忽略大小写
8
bool caseInsensitiveCompare(folly::StringPiece a, folly::StringPiece b) {
9
auto toLowerStringPiece = [](folly::StringPiece sp) {
10
std::string lowerStr;
11
for (char c : sp) {
12
lowerStr += std::tolower(c);
13
}
14
return lowerStr;
15
};
16
return toLowerStringPiece(a) < toLowerStringPiece(b);
17
}
18
19
int main() {
20
std::vector<folly::StringPiece> words = {"Apple", "banana", "Ant", "Ball"};
21
22
// 使用自定义比较函数进行排序
23
std::sort(words.begin(), words.end(), caseInsensitiveCompare);
24
25
std::cout << "忽略大小写排序后的单词:" << std::endl;
26
for (const auto& word : words) {
27
std::cout << word << std::endl;
28
}
29
30
return 0;
31
}
代码解析
⚝ 包含了必要的头文件 <folly/StringPiece.h>、<iostream>、<algorithm> 和 <cctype>。
⚝ 定义了一个自定义比较函数 caseInsensitiveCompare，接受两个 folly::StringPiece 对象 a 和 b 作为参数。
⚝ 在 caseInsensitiveCompare 函数中，定义了一个 lambda 函数 toLowerStringPiece，用于将 StringPiece 转换为小写字符串。这里为了演示方便，先将 StringPiece 转换为 std::string 再进行小写转换。更高效的做法是直接在 StringPiece 上进行忽略大小写的字符比较，避免字符串转换。
⚝ 使用 std::tolower 将字符串中的字符转换为小写。
⚝ 比较两个小写字符串的字典序，并返回比较结果。
⚝ 在 main 函数中，创建了一个 std::vector<folly::StringPiece> words。
⚝ 使用 std::sort 函数对 words 向量进行排序，并将 caseInsensitiveCompare 作为第三个参数传递给 std::sort，指定使用自定义的比较函数。
⚝ 输出排序后的单词，可以看到排序结果是忽略大小写的。
更高效的忽略大小写比较函数
1
bool caseInsensitiveCompareEfficient(folly::StringPiece a, folly::StringPiece b) {
2
auto pair = std::mismatch(a.begin(), a.end(), b.begin(), b.end(), [](char c1, char c2) {
3
return std::tolower(c1) == std::tolower(c2);
4
});
5
if (pair.first == a.end()) {
6
return pair.second != b.end();
7
}
8
if (pair.second == b.end()) {
9
return false;
10
}
11
return std::tolower(*pair.first) < std::tolower(*pair.second);
12
}
这个更高效的版本直接在 StringPiece 上进行字符比较，避免了创建临时的 std::string 对象，性能更高。
使用场景与优势
⚝ 灵活的排序规则: 自定义比较函数可以实现各种复杂的排序规则，例如忽略大小写、按照字符串长度、按照特定业务逻辑排序等。
⚝ 与标准库算法结合: 自定义比较函数可以与 std::sort 等标准库算法无缝结合，方便地进行排序操作。
⚝ 代码可复用: 自定义比较函数可以封装排序逻辑，提高代码的可复用性和可维护性。
⚝ 性能优化: 可以根据具体需求，编写高效的自定义比较函数，例如避免不必要的字符串拷贝和转换。
2.3.3 性能考量：比较操作的效率分析 (Performance Considerations: Efficiency Analysis of Comparison Operations)
folly::StringPiece 的比较操作在设计时就非常注重性能。由于 StringPiece 本身不拥有字符串数据，比较操作避免了内存拷贝，直接在原始数据上进行比较，因此效率很高。
性能优势
⚝ 零拷贝: StringPiece 的比较操作（包括字典序比较和自定义比较）都是零拷贝的，不会创建新的字符串对象，避免了内存分配和拷贝的开销。
⚝ 直接比较: 比较操作直接在原始字符串数据上进行字符比较，无需额外的处理步骤。
⚝ 高效实现: StringPiece 的比较运算符和相关方法都经过精心优化，具有很高的执行效率。
性能对比：StringPiece vs. std::string
与 std::string 相比，StringPiece 在比较操作方面通常具有更高的性能，尤其是在以下场景：
⚝ 频繁比较: 如果需要频繁进行字符串比较操作，例如在排序、查找、去重等场景中，StringPiece 的性能优势更加明显。
⚝ 大型字符串: 对于大型字符串的比较，StringPiece 避免了 std::string 可能发生的内存拷贝，性能提升更加显著。
⚝ 只读操作: 如果字符串数据是只读的，并且只需要进行比较操作，使用 StringPiece 可以避免 std::string 的所有权管理开销。
性能测试建议
⚝ 基准测试: 使用基准测试工具（如 Google Benchmark）对 StringPiece 和 std::string 的比较操作进行性能测试，比较在不同场景下的性能差异。
⚝ 实际场景测试: 在实际应用场景中进行性能测试，例如在日志解析、数据处理等场景中，评估 StringPiece 的性能提升效果。
⚝ 关注 CPU 消耗: 使用性能分析工具（如 perf, VTune）分析比较操作的 CPU 消耗，找出性能瓶颈，并进行优化。
优化建议
⚝ 优先使用 StringPiece: 在只需要字符串视图，并且需要进行频繁比较操作的场景中，优先使用 folly::StringPiece，可以获得更好的性能。
⚝ 避免不必要的字符串拷贝: 在比较操作中，尽量避免不必要的字符串拷贝，例如使用 StringPiece 代替 std::string 传递字符串参数。
⚝ 选择合适的比较算法: 根据具体需求，选择合适的比较算法，例如字典序比较、忽略大小写比较、自定义比较等。
⚝ 优化自定义比较函数: 如果使用自定义比较函数，尽量编写高效的比较函数，避免不必要的计算和内存操作。
2.4.1 使用 StringPiece 解析日志文件 (Parsing Log Files with StringPiece)
日志文件解析是 StringPiece 的一个典型应用场景。日志文件通常包含大量的文本数据，并且需要频繁地进行字符串处理操作，例如查找、分割、提取关键信息等。使用 StringPiece 可以高效地解析日志文件，避免不必要的内存拷贝，提升解析性能。
日志文件解析流程
- 读取日志文件: 将日志文件内容读取到内存中。可以使用
std::ifstream或folly::File等文件读取方式。 - 逐行处理: 将日志文件内容按行分割，可以使用
folly::split或其他行分割方法。 - 解析每行日志: 对于每一行日志，使用
StringPiece进行解析，提取关键信息。例如，使用find查找关键字，使用split分割字段，使用substr提取子串等。 - 存储解析结果: 将解析结果存储到数据结构中，例如
std::vector,std::map等。
实战代码示例：解析简单的日志文件
假设有一个简单的日志文件 example.log，内容如下：
1
[2023-10-27 10:00:00] [INFO] User login: Alice
2
[2023-10-27 10:00:30] [WARNING] Invalid password attempt: Bob
3
[2023-10-27 10:01:00] [ERROR] Database connection failed
以下代码使用 StringPiece 解析该日志文件，提取时间戳、日志级别和日志消息：
1
#include <folly/StringPiece.h>
2
#include <folly/File.h>
3
#include <folly/io/Cursor.h>
4
#include <vector>
5
#include <iostream>
6
#include <fstream>
7
#include <sstream>
8
9
int main() {
10
std::ifstream logFile("example.log");
11
if (!logFile.is_open()) {
12
std::cerr << "无法打开日志文件 example.log" << std::endl;
13
return 1;
14
}
15
16
std::string line;
17
while (std::getline(logFile, line)) {
18
folly::StringPiece logLine(line);
19
20
// 提取时间戳 (假设时间戳在方括号 [])
21
folly::StringPiece::size_type startPos = logLine.find('[');
22
folly::StringPiece::size_type endPos = logLine.find(']', startPos + 1);
23
folly::StringPiece timestamp;
24
if (startPos != folly::StringPiece::npos && endPos != folly::StringPiece::npos) {
25
timestamp = logLine.substr(startPos + 1, endPos - startPos - 1);
26
}
27
28
// 提取日志级别 (假设日志级别在第二个方括号 [])
29
folly::StringPiece::size_type startPosLevel = logLine.find('[', endPos + 1);
30
folly::StringPiece::size_type endPosLevel = logLine.find(']', startPosLevel + 1);
31
folly::StringPiece logLevel;
32
if (startPosLevel != folly::StringPiece::npos && endPosLevel != folly::StringPiece::npos) {
33
logLevel = logLine.substr(startPosLevel + 1, endPosLevel - startPosLevel - 1);
34
}
35
36
// 提取日志消息 (假设日志消息在日志级别之后)
37
folly::StringPiece logMessage;
38
if (endPosLevel != folly::StringPiece::npos) {
39
logMessage = logLine.substr(endPosLevel + 2); // +2 跳过 '] '
40
}
41
42
std::cout << "时间戳: '" << timestamp << "', 级别: '" << logLevel << "', 消息: '" << logMessage << "'" << std::endl;
43
}
44
45
logFile.close();
46
return 0;
47
}
代码解析
⚝ 包含了必要的头文件 <folly/StringPiece.h>、<folly/File.h>、<folly/io/Cursor.h>、<vector>、<iostream>、<fstream> 和 <sstream>。
⚝ 使用 std::ifstream 打开日志文件 example.log。
⚝ 使用 std::getline 逐行读取日志文件内容到 std::string line 中。
⚝ 将每行日志转换为 folly::StringPiece logLine(line)，以便使用 StringPiece 的方法进行解析。
⚝ 使用 logLine.find('[') 和 logLine.find(']', ...) 查找方括号的位置，提取时间戳和日志级别。
⚝ 使用 logLine.substr(...) 提取时间戳、日志级别和日志消息的子字符串。
⚝ 输出提取的时间戳、日志级别和日志消息。
使用场景与优势
⚝ 高效日志解析: StringPiece 避免了日志解析过程中不必要的字符串拷贝，提高了日志解析的性能。
⚝ 简化代码: StringPiece 提供了丰富的字符串操作方法，简化了日志解析的代码。
⚝ 易于维护: 使用 StringPiece 解析日志文件，代码结构清晰，易于理解和维护.
⚝ 性能提升: 尤其是在处理大型日志文件时，StringPiece 的性能优势更加明显。
2.4.2 从日志字符串中提取关键信息 (Extracting Key Information from Log Strings)
在日志解析中，提取关键信息是核心任务。关键信息可以是时间戳、日志级别、用户 ID、请求 ID、错误码、错误消息等。folly::StringPiece 提供了多种方法来高效地提取这些关键信息。
提取关键信息的方法
⚝ find 和 substr: 使用 find 方法查找关键字或分隔符的位置，然后使用 substr 方法提取关键信息。例如，查找 "User ID:" 关键字，然后提取后面的用户 ID。
⚝ split: 使用 split 方法将日志行分割成多个字段，然后根据字段的位置或内容提取关键信息。例如，使用空格或制表符分割日志行，然后提取特定位置的字段。
⚝ 正则表达式: 结合正则表达式库（如 std::regex 或 Boost.Regex）进行更复杂的模式匹配和信息提取。例如，使用正则表达式匹配特定的日期时间格式或错误码格式。
⚝ 自定义解析函数: 对于复杂的日志格式，可以编写自定义的解析函数，结合 StringPiece 的各种方法，灵活地提取关键信息.
实战代码示例：提取用户 ID 和请求 ID
假设日志消息格式如下：
1
[2023-10-27 10:05:00] [INFO] Request received. User ID: 12345, Request ID: ABC-XYZ-789
以下代码使用 StringPiece 从日志消息中提取用户 ID 和请求 ID：
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece logMessage = "Request received. User ID: 12345, Request ID: ABC-XYZ-789";
6
7
// 提取 User ID
8
folly::StringPiece userIdPrefix = "User ID: ";
9
folly::StringPiece::size_type userIdStartPos = logMessage.find(userIdPrefix);
10
folly::StringPiece userId;
11
if (userIdStartPos != folly::StringPiece::npos) {
12
folly::StringPiece::size_type userIdValueStartPos = userIdStartPos + userIdPrefix.size();
13
folly::StringPiece::size_type userIdEndPos = logMessage.find(',', userIdValueStartPos); // 假设 User ID 后跟逗号
14
if (userIdEndPos == folly::StringPiece::npos) {
15
userId = logMessage.substr(userIdValueStartPos); // 如果没有逗号，提取到末尾
16
} else {
17
userId = logMessage.substr(userIdValueStartPos, userIdEndPos - userIdValueStartPos);
18
}
19
}
20
21
// 提取 Request ID
22
folly::StringPiece requestIdPrefix = "Request ID: ";
23
folly::StringPiece::size_type requestIdStartPos = logMessage.find(requestIdPrefix);
24
folly::StringPiece requestId;
25
if (requestIdStartPos != folly::StringPiece::npos) {
26
folly::StringPiece::size_type requestIdValueStartPos = requestIdStartPos + requestIdPrefix.size();
27
requestId = logMessage.substr(requestIdValueStartPos); // Request ID 之后是行尾
28
}
29
30
std::cout << "用户 ID: '" << userId << "'" << std::endl;
31
std::cout << "请求 ID: '" << requestId << "'" << std::endl;
32
33
return 0;
34
}
代码解析
⚝ 创建了一个 folly::StringPiece 对象 logMessage，包含日志消息。
⚝ 定义了 userIdPrefix 和 requestIdPrefix 作为关键字前缀。
⚝ 使用 logMessage.find(userIdPrefix) 查找 "User ID: " 的位置。
⚝ 如果找到 "User ID: "，则计算用户 ID 值的起始位置 userIdValueStartPos。
⚝ 使用 logMessage.find(',', userIdValueStartPos) 查找用户 ID 值后面的逗号位置，确定用户 ID 值的结束位置 userIdEndPos。
⚝ 使用 logMessage.substr(...) 提取用户 ID 值。
⚝ 类似地，提取请求 ID 值。
⚝ 输出提取的用户 ID 和请求 ID。
最佳实践
⚝ 根据日志格式选择合适的提取方法: 根据日志格式的复杂程度，选择合适的提取方法。简单的格式可以使用 find 和 substr，复杂的格式可以使用 split 或正则表达式。
⚝ 考虑性能: 在提取关键信息时，考虑性能因素。尽量使用高效的 StringPiece 方法，避免不必要的字符串拷贝和计算。
⚝ 错误处理: 在提取关键信息时，要考虑错误处理。例如，如果日志格式不正确，或者关键信息不存在，要进行相应的处理，避免程序崩溃或产生错误的结果.
2.4.3 性能优化技巧在日志解析中的应用 (Application of Performance Optimization Techniques in Log Parsing)
日志解析是性能敏感型任务，尤其是在处理海量日志数据时。folly::StringPiece 本身就具有很高的性能，但在日志解析过程中，还可以应用一些性能优化技巧，进一步提升解析效率。
性能优化技巧
- 减少内存分配: 尽量避免在日志解析过程中进行内存分配操作。
StringPiece的零拷贝特性已经在这方面做了很好的优化。在代码编写时，也要注意避免不必要的字符串拷贝和对象创建。 - 批量处理: 如果可能，将日志数据批量读取到内存中，然后批量进行解析。批量处理可以减少文件 IO 和系统调用的次数，提高整体性能。
- 多线程并行处理: 对于大型日志文件，可以使用多线程并行处理。将日志文件分割成多个部分，每个线程负责解析一部分日志数据。多线程并行处理可以充分利用多核 CPU 的性能，显著提升解析速度。
- 使用高效的算法和数据结构: 在日志解析过程中，选择高效的算法和数据结构。例如，使用
StringPiece::find和StringPiece::split等高效的字符串操作方法，使用std::unordered_map或folly::F14ValueMap等高效的哈希表来存储和查找数据。 - 预编译正则表达式: 如果使用正则表达式进行日志解析，预编译正则表达式可以提高匹配性能。
std::regex和 Boost.Regex 都支持正则表达式预编译。 - 避免重复计算: 在日志解析过程中，避免重复计算。例如，如果需要多次使用同一个子字符串，可以将其提取出来并缓存，避免重复提取。
- 使用
StringPiece的视图: 在函数调用或数据传递过程中，尽量使用StringPiece的视图，避免不必要的字符串拷贝。
实战代码示例：多线程并行日志解析
以下代码演示了如何使用多线程并行解析日志文件：
1
#include <folly/StringPiece.h>
2
#include <folly/File.h>
3
#include <folly/io/Cursor.h>
4
#include <vector>
5
#include <iostream>
6
#include <fstream>
7
#include <sstream>
8
#include <thread>
9
#include <mutex>
10
11
void parseLogLines(const std::vector<std::string>& lines, std::mutex& mutex) {
12
for (const auto& line : lines) {
13
folly::StringPiece logLine(line);
14
// ... (日志解析逻辑，例如提取时间戳、日志级别、消息等) ...
15
std::lock_guard<std::mutex> lock(mutex); // 保护共享资源 (例如输出)
16
std::cout << "Thread ID: " << std::this_thread::get_id() << ", Line: " << logLine << std::endl;
17
}
18
}
19
20
int main() {
21
std::ifstream logFile("example.log");
22
if (!logFile.is_open()) {
23
std::cerr << "无法打开日志文件 example.log" << std::endl;
24
return 1;
25
}
26
27
std::vector<std::string> allLines;
28
std::string line;
29
while (std::getline(logFile, line)) {
30
allLines.push_back(line);
31
}
32
logFile.close();
33
34
size_t numThreads = 4; // 设置线程数
35
size_t linesPerThread = (allLines.size() + numThreads - 1) / numThreads;
36
std::vector<std::thread> threads;
37
std::mutex outputMutex; // 用于保护输出
38
39
for (size_t i = 0; i < numThreads; ++i) {
40
size_t startLine = i * linesPerThread;
41
size_t endLine = std::min(startLine + linesPerThread, allLines.size());
42
std::vector<std::string> threadLines(allLines.begin() + startLine, allLines.begin() + endLine);
43
threads.emplace_back(parseLogLines, threadLines, std::ref(outputMutex));
44
}
45
46
for (auto& thread : threads) {
47
thread.join();
48
}
49
50
return 0;
51
}
代码解析
⚝ 定义了一个 parseLogLines 函数，用于解析日志行。该函数接受一个日志行向量和一个互斥锁作为参数。
⚝ 在 main 函数中，读取整个日志文件内容到 std::vector<std::string> allLines 中。
⚝ 设置线程数 numThreads，并计算每个线程需要处理的行数 linesPerThread。
⚝ 创建一个线程向量 threads 和一个互斥锁 outputMutex 用于保护共享资源（例如标准输出）。
⚝ 循环创建 numThreads 个线程。每个线程负责处理 allLines 的一部分日志行。
⚝ 使用 std::thread::emplace_back 创建线程，并将 parseLogLines 函数、线程需要处理的日志行向量和互斥锁传递给线程函数。
⚝ 使用 thread.join() 等待所有线程完成。
使用场景与优势
⚝ 提升日志解析性能: 多线程并行处理可以显著提升日志解析性能，尤其是在处理大型日志文件时。
⚝ 充分利用多核 CPU: 多线程并行处理可以充分利用多核 CPU 的性能，提高资源利用率。
⚝ 适用于 CPU 密集型任务: 日志解析通常是 CPU 密集型任务，多线程并行处理非常适合这种类型的任务。
⚝ 可扩展性: 可以根据 CPU 核数和日志数据量调整线程数，实现性能的线性扩展。
性能优化注意事项
⚝ 线程安全: 在多线程环境中，要注意线程安全问题。例如，使用互斥锁保护共享资源，避免数据竞争。
⚝ 线程开销: 创建和管理线程有一定的开销。线程数不宜设置过大，过多的线程反而可能降低性能。
⚝ 负载均衡: 要尽量保证每个线程的负载均衡，避免某些线程过载，而其他线程空闲。
⚝ 性能测试: 在进行性能优化后，要进行性能测试，验证优化效果，并根据测试结果进行进一步调整。
END_OF_CHAPTER
3. chapter 3： folly::fbstring 高级应用与性能优化 (Advanced Applications and Performance Optimization of folly::fbstring)
3.1 深入 fbstring 的内存管理 (Deep Dive into fbstring's Memory Management)
3.1.1 小字符串优化 (SSO, Small String Optimization) 原理与应用 (Principle and Application of Small String Optimization (SSO))
小字符串优化（SSO, Small String Optimization）是一种常见的字符串优化技术，旨在提高短字符串操作的性能。folly::fbstring 也采用了 SSO 技术。在深入 fbstring 的 SSO 之前，我们先来理解一下 SSO 的基本原理。
① SSO 的原理：
当字符串的长度较短时，动态内存分配的开销会变得相对显著。频繁地进行内存分配和释放不仅会降低性能，还可能导致内存碎片。SSO 的核心思想是，对于短字符串，直接在字符串对象自身内部的固定大小的缓冲区中存储字符串数据，而无需在堆上分配内存。只有当字符串长度超过这个预设的阈值时，才会在堆上动态分配内存。
② SSO 的优势：
⚝ 减少动态内存分配：对于大量的小字符串操作，SSO 可以显著减少堆内存的分配和释放次数，从而降低内存管理的开销。
⚝ 提高缓存局部性：小字符串数据存储在字符串对象自身内部，更有利于提高缓存的局部性（Cache Locality），加速访问速度。
⚝ 提升性能：综合以上两点，SSO 可以显著提升短字符串操作的性能，尤其是在字符串频繁创建、复制和销毁的场景下。
③ fbstring 的 SSO 实现：
folly::fbstring 内部实现 SSO 的方式通常涉及以下几个关键部分：
⚝ 内部缓冲区：fbstring 对象内部会预留一块固定大小的缓冲区，用于存储短字符串的数据。这个缓冲区的大小是在编译时确定的，例如，可能是 15 或 22 个字节（具体大小取决于实现）。
⚝ 长度字段：fbstring 需要记录字符串的实际长度，以便区分缓冲区中有效数据和未使用的空间。
⚝ 标志位：可能需要一个标志位来指示字符串数据是存储在内部缓冲区中，还是在堆上分配的内存中。
④ SSO 的应用场景：
SSO 特别适用于以下场景：
⚝ 处理大量短字符串：例如，在处理 JSON 数据、URL、日志记录等场景中，经常会遇到大量的短字符串。
⚝ 字符串复制频繁：由于 SSO 避免了堆内存分配，短字符串的复制操作可以变得非常高效，尤其是在写时复制（COW）机制的配合下。
⑤ 代码示例：
为了更直观地理解 SSO 的效果，我们可以通过一个简单的例子来对比 std::string 和 folly::fbstring 在处理短字符串时的性能差异。
1
#include <iostream>
2
#include <string>
3
#include <folly/FBString.h>
4
#include <chrono>
5
6
using namespace std;
7
using namespace folly;
8
9
int main() {
10
int iterations = 1000000;
11
string std_str = "short string";
12
fbstring fb_str = "short string";
13
14
// std::string 性能测试
15
auto start_std = chrono::high_resolution_clock::now();
16
for (int i = 0; i < iterations; ++i) {
17
string temp = std_str; // 复制 std::string
18
}
19
auto end_std = chrono::high_resolution_clock::now();
20
chrono::duration<double> duration_std = end_std - start_std;
21
cout << "std::string 复制 " << iterations << " 次耗时: " << duration_std.count() << " 秒" << endl;
22
23
// folly::fbstring 性能测试
24
auto start_fb = chrono::high_resolution_clock::now();
25
for (int i = 0; i < iterations; ++i) {
26
fbstring temp = fb_str; // 复制 fbstring
27
}
28
auto end_fb = chrono::high_resolution_clock::now();
29
chrono::duration<double> duration_fb = end_fb - start_fb;
30
cout << "folly::fbstring 复制 " << iterations << " 次耗时: " << duration_fb.count() << " 秒" << endl;
31
32
return 0;
33
}
在这个例子中，我们分别对 std::string 和 folly::fbstring 进行了大量的复制操作。由于 "short string" 长度较短，fbstring 可以利用 SSO 避免堆内存分配，理论上性能会优于 std::string。实际运行结果会因编译器、硬件环境等因素有所不同，但通常 fbstring 在短字符串复制方面会表现出更优的性能。
⑥ 总结：
小字符串优化 (SSO) 是 folly::fbstring 为了提升短字符串处理效率而采用的一项关键技术。通过在对象内部缓冲区存储短字符串，SSO 减少了动态内存分配的开销，提高了缓存局部性，从而显著提升了性能。理解 SSO 的原理和应用场景，有助于我们更好地利用 fbstring 在高性能应用中处理字符串。
3.1.2 写时复制 (COW, Copy-on-Write) 的优势与局限性 (Advantages and Limitations of Copy-on-Write (COW))
写时复制（COW, Copy-on-Write）是一种资源优化技术，常用于字符串、容器等数据结构的实现中。folly::fbstring 曾经使用写时复制机制，虽然在某些场景下能带来性能提升，但也存在一些局限性。现代 fbstring 的实现已经移除了 COW，但理解 COW 的原理、优势和局限性，对于深入理解字符串优化的演进历程仍然很有价值。
① COW 的原理：
写时复制的核心思想是延迟复制。当多个对象共享同一份资源（例如，字符串的字符缓冲区）时，并不立即进行深拷贝。只有当某个对象需要修改这份共享资源时，才会真正进行复制操作，创建一份独立的副本供其修改。在修改之前，多个对象仍然共享同一份数据，从而节省了内存和复制开销。
② COW 的优势：
⚝ 减少复制开销：在字符串复制操作频繁，但修改操作相对较少的场景下，COW 可以显著减少不必要的深拷贝，节省时间和内存。例如，在函数参数传递、字符串赋值等操作中，如果只是读取字符串内容，而不需要修改，则多个 fbstring 对象可以共享同一份字符缓冲区。
⚝ 节省内存：多个对象共享同一份数据，可以降低内存占用，尤其是在大量字符串复制的场景下。
③ COW 的局限性与问题：
尽管 COW 在某些场景下有优势，但它也存在一些固有的局限性和问题，这也是现代 fbstring 移除 COW 的主要原因：
⚝ 线程安全问题：COW 最主要的问题是线程安全性。当多个线程同时访问共享的字符串对象，并且其中一个线程尝试修改字符串时，会触发写时复制。这个复制过程需要保证原子性，否则可能导致数据竞争和未定义行为。为了保证线程安全，需要引入额外的同步机制（例如，互斥锁），这会带来额外的性能开销，甚至可能抵消 COW 带来的性能优势。
⚝ 现代硬件和编译器的优化：现代硬件（例如，多核处理器、高速缓存）和编译器优化技术（例如，移动语义、RVO/NRVO）在很大程度上降低了深拷贝的开销。对于 std::string 来说，移动语义已经使得字符串的移动操作变得非常高效，接近于零开销。因此，COW 在现代 C++ 环境下的性能优势不再明显。
⚝ 复杂性增加：COW 的实现增加了字符串类的复杂性，包括内存管理、引用计数、线程同步等方面。这使得代码更难理解、维护和调试。
⚝ 某些场景下性能下降：在某些特定场景下，COW 可能会导致性能下降。例如，如果字符串频繁被修改，那么每次修改都会触发复制操作，反而增加了开销。此外，COW 的延迟复制特性可能会导致缓存失效，降低缓存命中率。
④ fbstring 移除 COW 的原因：
folly::fbstring 最初采用了 COW 机制，但在后续版本中移除了 COW。主要原因包括：
⚝ 线程安全性的挑战：为了解决 COW 的线程安全问题，需要引入复杂的同步机制，这与 folly 追求高性能和简洁的设计理念相悖。
⚝ 现代 C++ 的发展：C++11 引入了移动语义，使得字符串的移动操作变得非常高效。std::string 已经可以通过移动语义来避免不必要的深拷贝。
⚝ 性能测试结果：在实际测试中，移除 COW 后的 fbstring 在大多数场景下并没有明显的性能下降，甚至在某些场景下性能有所提升，尤其是在多线程环境下。
⚝ 简化代码：移除 COW 可以显著简化 fbstring 的实现，降低代码复杂性，提高可维护性。
⑤ 替代方案：
移除 COW 后，fbstring 主要依靠以下技术来保证性能：
⚝ 小字符串优化 (SSO)：对于短字符串，使用 SSO 避免堆内存分配和复制开销。
⚝ 移动语义：利用 C++11 的移动语义，高效地进行字符串的移动操作。
⚝ 定制化的内存分配器：fbstring 可以与定制化的内存分配器结合使用，进一步优化内存管理。
⑥ 总结：
写时复制 (COW) 曾经是一种流行的字符串优化技术，但在现代 C++ 环境下，由于线程安全问题、现代硬件和编译器的优化、以及代码复杂性等原因，其优势不再明显。folly::fbstring 顺应技术发展趋势，移除了 COW，并采用 SSO、移动语义等技术来保证高性能。理解 COW 的原理和局限性，有助于我们更全面地认识字符串优化的技术演进。
3.1.3 自定义内存分配器 (Custom Memory Allocators) 与 fbstring 的结合 (Integration of Custom Memory Allocators with fbstring)
内存分配器（Memory Allocator）负责管理程序的内存分配和释放。默认情况下，C++ 使用标准库提供的全局内存分配器（通常是 malloc 和 free）。然而，在高性能应用中，自定义内存分配器可以根据特定场景进行优化，从而提升性能。folly::fbstring 允许用户自定义内存分配器，并与之灵活结合，以满足不同的性能需求。
① 内存分配器的作用：
内存分配器的主要作用是：
⚝ 分配内存：当程序需要内存时，内存分配器负责从系统中分配一块合适的内存块。
⚝ 释放内存：当程序不再需要某块内存时，内存分配器负责将这块内存归还给系统，以便后续重用。
⚝ 内存管理策略：不同的内存分配器可以采用不同的内存管理策略，例如，堆内存管理、对象池、固定大小块分配等。
② 自定义内存分配器的优势：
在某些特定场景下，自定义内存分配器可以提供以下优势：
⚝ 性能优化：针对特定应用场景，自定义内存分配器可以采用更高效的内存管理策略，例如，减少内存碎片、提高分配和释放速度。
⚝ 内存控制：自定义内存分配器可以更好地控制内存的使用，例如，限制内存使用量、监控内存分配情况。
⚝ 特殊需求：某些应用可能需要特殊的内存分配行为，例如，在嵌入式系统中，可能需要使用特定的内存区域或分配策略。
③ fbstring 与内存分配器的结合：
folly::fbstring 允许用户通过模板参数来指定自定义内存分配器。fbstring 的声明形式如下：
1
template <typename CharT, typename Traits = char_traits<CharT>, typename Allocator = std::allocator<CharT>>
2
class basic_fbstring;
3
4
using fbstring = basic_fbstring<char>;
5
using fbwstring = basic_fbstring<wchar_t>;
6
using fbustring = basic_fbstring<char16_t>;
7
using fblstring = basic_fbstring<char32_t>;
可以看到，basic_fbstring 模板类的第三个参数 Allocator 就是用于指定内存分配器的。默认情况下，Allocator 使用 std::allocator<CharT>，即标准库的默认分配器。用户可以自定义一个符合 Allocator 要求的类，并将其作为模板参数传递给 fbstring。
④ 自定义内存分配器的要求：
要作为 fbstring 的内存分配器，自定义分配器类需要满足 C++ 标准库对 Allocator 的要求，主要包括：
⚝ 类型定义：需要定义一些标准类型，例如 value_type（元素类型）、pointer（指针类型）、size_type（大小类型）等。
⚝ 构造函数和析构函数：需要提供默认构造函数、复制构造函数、移动构造函数、析构函数等。
⚝ allocate() 方法：用于分配指定大小的内存块。
⚝ deallocate() 方法：用于释放之前分配的内存块。
⚝ 其他方法：例如 max_size()、construct()、destroy() 等，具体要求可以参考 C++ 标准库文档。
⑤ 自定义内存分配器的示例：
下面是一个简单的自定义内存分配器的示例，它使用一个简单的对象池来管理内存：
1
#include <iostream>
2
#include <memory>
3
#include <vector>
4
#include <folly/FBString.h>
5
6
using namespace std;
7
using namespace folly;
8
9
// 简单的对象池分配器
10
template <typename T>
11
class SimplePoolAllocator {
12
public:
13
using value_type = T;
14
using pointer = T*;
15
using const_pointer = const T*;
16
using reference = T&;
17
using const_reference = const T&;
18
using size_type = size_t;
19
using difference_type = ptrdiff_t;
20
21
SimplePoolAllocator() noexcept = default;
22
template <typename U> SimplePoolAllocator(const SimplePoolAllocator<U>&) noexcept {}
23
24
pointer allocate(size_type n, const void* hint = 0) {
25
if (n > 1) throw bad_alloc(); // 简单对象池只分配单个对象
26
if (pool_.empty()) {
27
// 对象池为空时，预先分配一批对象
28
for (int i = 0; i < 10; ++i) {
29
pool_.push_back(new T());
30
}
31
}
32
pointer p = pool_.back();
33
pool_.pop_back();
34
return p;
35
}
36
37
void deallocate(pointer p, size_type n) {
38
if (n > 1) throw bad_alloc(); // 简单对象池只分配单个对象
39
pool_.push_back(p); // 归还到对象池
40
}
41
42
private:
43
vector<pointer> pool_;
44
};
45
46
template <typename T, typename U>
47
bool operator==(const SimplePoolAllocator<T>&, const SimplePoolAllocator<U>&) { return true; }
48
template <typename T, typename U>
49
bool operator!=(const SimplePoolAllocator<T>&, const SimplePoolAllocator<U>&) { return false; }
50
51
52
int main() {
53
// 使用自定义对象池分配器的 fbstring
54
using PoolFbString = fbstring::basic_fbstring<char, char_traits<char>, SimplePoolAllocator<char>>;
55
PoolFbString pool_str = "hello";
56
PoolFbString pool_str2 = "world";
57
cout << pool_str << " " << pool_str2 << endl;
58
59
return 0;
60
}
在这个例子中，我们定义了一个简单的 SimplePoolAllocator，它使用一个 vector 来模拟对象池。在 main 函数中，我们使用 SimplePoolAllocator<char> 作为模板参数，创建了 PoolFbString 类型，并使用它创建了字符串对象。
⑥ 实际应用场景：
自定义内存分配器在以下场景中可能有用：
⚝ 高频小对象分配：如果程序中频繁创建和销毁小字符串对象，可以使用对象池分配器来减少内存分配和释放的开销。
⚝ 内存受限环境：在内存资源有限的环境下，可以使用自定义分配器来更精细地控制内存使用。
⚝ 性能敏感应用：在对性能要求极高的应用中，可以通过定制化的内存分配策略来优化性能。
⑦ 注意事项：
⚝ 正确性：自定义内存分配器必须正确实现 Allocator 接口，否则可能导致程序崩溃或内存错误。
⚝ 性能测试：使用自定义内存分配器后，需要进行充分的性能测试，验证其是否真的带来了性能提升。
⚝ 复杂性：自定义内存分配器会增加代码的复杂性，需要权衡其带来的收益和维护成本。
⑧ 总结：
自定义内存分配器是 folly::fbstring 提供的一个高级特性，允许用户根据特定场景优化内存管理。通过与自定义内存分配器结合使用，fbstring 可以更好地满足不同应用场景下的性能需求。然而，自定义内存分配器也具有一定的复杂性，需要谨慎使用，并进行充分的测试和验证。
3.2 fbstring 的线程安全性与并发编程 (Thread Safety and Concurrent Programming with fbstring)
在多线程并发编程环境中，线程安全性（Thread Safety）是一个至关重要的问题。如果一个数据结构不是线程安全的，那么在多线程环境下并发访问和修改它可能会导致数据竞争（Data Race）、未定义行为，甚至程序崩溃。本节将深入探讨 folly::fbstring 的线程安全性，以及如何在并发编程中安全地使用 fbstring。
3.2.1 fbstring 在多线程环境下的行为 (Behavior of fbstring in Multi-threaded Environments)
理解 fbstring 在多线程环境下的行为，是正确使用 fbstring 进行并发编程的基础。我们需要区分不同的操作类型，以及它们在多线程环境下的线程安全性。
① 只读操作的线程安全性：
fbstring 的只读操作，例如 size()、empty()、operator[]（只读访问）、c_str()、data()、find()、substr() 等，通常是线程安全的。这意味着，多个线程可以同时安全地读取同一个 fbstring 对象的内容，而无需额外的同步措施。这是因为只读操作不会修改 fbstring 对象的状态，因此不会发生数据竞争。
② 修改操作的线程安全性：
fbstring 的修改操作，例如 operator=（赋值）、append()、push_back()、insert()、erase()、replace()、clear() 等，通常不是线程安全的。如果多个线程同时对同一个 fbstring 对象进行修改操作，或者一个线程进行修改操作，同时另一个线程进行读或写操作，就可能发生数据竞争，导致未定义行为。
③ 写时复制 (COW) 与线程安全：
早期的 fbstring 版本采用了写时复制 (COW) 机制。COW 本身是为了优化性能，但在多线程环境下，COW 会引入线程安全问题。当多个线程共享同一个 fbstring 对象的字符缓冲区时，如果其中一个线程尝试修改字符串，会触发写时复制。这个复制过程需要保证原子性，否则可能导致数据竞争。为了解决 COW 的线程安全问题，通常需要引入锁机制，但这会带来额外的性能开销。现代 fbstring 已经移除了 COW，因此不再存在 COW 带来的线程安全问题。
④ 现代 fbstring 的线程安全性：
现代 folly::fbstring (移除 COW 之后) 的线程安全性行为可以总结如下：
⚝ 只读操作：线程安全。多个线程可以并发执行只读操作。
⚝ 修改操作：非线程安全。并发执行修改操作，或者读写操作并发执行，都可能导致数据竞争。
⑤ 线程安全示例与非线程安全示例：
线程安全示例 (只读操作)：
1
#include <iostream>
2
#include <thread>
3
#include <folly/FBString.h>
4
5
using namespace std;
6
using namespace folly;
7
8
void read_string(const fbstring& str) {
9
cout << "Thread ID: " << this_thread::get_id() << ", String size: " << str.size() << endl;
10
}
11
12
int main() {
13
fbstring shared_str = "hello world";
14
thread t1(read_string, ref(shared_str));
15
thread t2(read_string, ref(shared_str));
16
17
t1.join();
18
t2.join();
19
20
return 0;
21
}
在这个例子中，两个线程 t1 和 t2 同时读取同一个 fbstring 对象 shared_str 的大小。由于 size() 是只读操作，因此这段代码是线程安全的，不会发生数据竞争。
非线程安全示例 (修改操作)：
1
#include <iostream>
2
#include <thread>
3
#include <folly/FBString.h>
4
5
using namespace std;
6
using namespace folly;
7
8
void append_string(fbstring& str) {
9
for (int i = 0; i < 10000; ++i) {
10
str.append("a"); // 修改操作
11
}
12
}
13
14
int main() {
15
fbstring shared_str = "start";
16
thread t1(append_string, ref(shared_str));
17
thread t2(append_string, ref(shared_str));
18
19
t1.join();
20
t2.join();
21
22
cout << "Final string size: " << shared_str.size() << endl; // 最终大小可能不确定
23
return 0;
24
}
在这个例子中，两个线程 t1 和 t2 同时向同一个 fbstring 对象 shared_str 追加字符串 "a"。由于 append() 是修改操作，这段代码不是线程安全的，会发生数据竞争。最终 shared_str 的大小可能不确定，且程序行为不可预测。
⑥ 总结：
folly::fbstring 的只读操作在多线程环境下是线程安全的，可以并发执行。但是，修改操作不是线程安全的。在多线程环境下，如果需要并发地修改同一个 fbstring 对象，或者同时进行读写操作，必须采取适当的同步措施，例如使用互斥锁、原子操作等，以保证线程安全。
3.2.2 使用 fbstring 构建线程安全的数据结构 (Building Thread-Safe Data Structures with fbstring)
虽然 fbstring 自身不是线程安全的（对于修改操作），但我们可以使用 fbstring 作为组件，构建线程安全的数据结构。关键在于在数据结构的接口层面，通过适当的同步机制来保护内部的 fbstring 对象，从而实现线程安全性。
① 线程安全数据结构的设计原则：
构建线程安全的数据结构，需要遵循以下原则：
⚝ 数据封装：将内部数据（例如，fbstring 对象）封装在类的私有成员中，避免外部直接访问。
⚝ 互斥访问：对于可能发生并发访问的方法（尤其是修改方法），使用互斥锁（Mutex）或其他同步机制来保护临界区（Critical Section），确保同一时刻只有一个线程可以访问和修改共享数据。
⚝ 最小化锁的持有时间：尽量减小锁的粒度，缩短锁的持有时间，以提高并发性能。
⚝ 避免死锁：在涉及多个锁时，注意锁的获取顺序，避免死锁的发生。
② 使用互斥锁保护 fbstring：
最常用的线程安全方法是使用互斥锁（std::mutex）来保护对 fbstring 对象的访问。例如，我们可以创建一个线程安全的字符串类 ThreadSafeFbString，内部包含一个 fbstring 对象和一个互斥锁。
③ ThreadSafeFbString 的实现示例：
1
#include <iostream>
2
#include <string>
3
#include <mutex>
4
#include <folly/FBString.h>
5
6
using namespace std;
7
using namespace folly;
8
9
class ThreadSafeFbString {
10
public:
11
ThreadSafeFbString() = default;
12
ThreadSafeFbString(const fbstring& str) : str_(str) {}
13
14
// 线程安全的 append 操作
15
void append(const fbstring& suffix) {
16
lock_guard<mutex> lock(mutex_); // 获取互斥锁
17
str_.append(suffix); // 在锁的保护下修改 fbstring
18
}
19
20
// 线程安全的 size 获取操作
21
size_t size() const {
22
lock_guard<mutex> lock(mutex_); // 获取互斥锁 (读操作也需要锁保护，保证数据一致性)
23
return str_.size();
24
}
25
26
// 线程安全的 toStdString 转换操作
27
string toStdString() const {
28
lock_guard<mutex> lock(mutex_);
29
return str_.toStdString();
30
}
31
32
private:
33
fbstring str_; // 内部 fbstring 对象
34
mutable mutex mutex_; // 互斥锁，mutable 允许 const 方法修改 mutex
35
};
36
37
void thread_func(ThreadSafeFbString& safe_str) {
38
for (int i = 0; i < 10000; ++i) {
39
safe_str.append("b");
40
}
41
}
42
43
int main() {
44
ThreadSafeFbString safe_str("start");
45
thread t1(thread_func, ref(safe_str));
46
thread t2(thread_func, ref(safe_str));
47
48
t1.join();
49
t2.join();
50
51
cout << "Thread-safe string size: " << safe_str.size() << endl;
52
cout << "Thread-safe string content (first 20 chars): " << safe_str.toStdString().substr(0, 20) << "..." << endl;
53
54
return 0;
55
}
在这个例子中，ThreadSafeFbString 类内部包含一个 fbstring 对象 str_ 和一个互斥锁 mutex_。append() 和 size() 方法都使用 lock_guard<mutex> 来自动管理锁的获取和释放，确保在临界区内对 str_ 的访问是互斥的，从而实现了线程安全。
④ 更细粒度的锁：
在某些情况下，可以使用更细粒度的锁来提高并发性能。例如，如果字符串的修改操作主要集中在字符串的不同部分，可以考虑使用读写锁（std::shared_mutex，C++17 引入）或者分段锁（Segmented Lock）等更高级的同步机制。但细粒度锁的实现通常更复杂，需要仔细权衡性能和复杂性。
⑤ 原子操作：
对于一些简单的操作，例如原子地更新字符串的长度计数器，可以使用原子操作（std::atomic）。但原子操作通常只适用于基本类型，对于复杂的字符串操作，互斥锁仍然是更常用的选择。
⑥ 无锁数据结构：
在某些高性能场景下，可以考虑使用无锁（Lock-Free）数据结构。无锁数据结构使用原子操作和内存排序等技术，避免了锁的开销，可以实现更高的并发性能。但无锁数据结构的实现非常复杂，容易出错，并且通常只适用于特定的应用场景。
⑦ 总结：
虽然 folly::fbstring 自身不是线程安全的（对于修改操作），但我们可以使用 fbstring 作为组件，通过互斥锁等同步机制，构建线程安全的数据结构，例如 ThreadSafeFbString。在设计线程安全的数据结构时，需要遵循数据封装、互斥访问、最小化锁持有时间等原则，并根据具体的应用场景选择合适的同步机制，以实现线程安全和高性能的平衡。
3.2.3 避免 fbstring 的线程安全陷阱 (Avoiding Thread Safety Pitfalls of fbstring)
在使用 folly::fbstring 进行并发编程时，需要注意一些常见的线程安全陷阱，避免因疏忽而导致数据竞争和程序错误。
① 隐式共享与写时复制 (COW) 的遗留问题：
虽然现代 fbstring 已经移除了 COW，但在早期的版本中，COW 曾经是线程安全问题的根源之一。即使现在没有 COW 了，我们仍然需要警惕隐式共享可能带来的问题。例如，如果多个线程通过非线程安全的方式共享同一个 fbstring 对象，仍然可能发生数据竞争。
② 迭代器失效：
当多个线程同时访问同一个 fbstring 对象，并且其中一个线程修改了字符串内容（例如，插入、删除字符），可能会导致其他线程正在使用的迭代器失效。迭代器失效会导致程序崩溃或未定义行为。因此，在多线程环境下，需要谨慎使用迭代器，避免在迭代过程中修改字符串内容，或者采取适当的同步措施。
③ 引用失效：
类似于迭代器失效，当一个线程修改了 fbstring 对象，可能会导致其他线程持有的指向字符串内部数据的引用（例如，通过 operator[] 获取的引用）失效。引用失效同样可能导致程序错误。
④ 忘记加锁：
最常见的线程安全陷阱是忘记在临界区加锁。例如，在需要修改 fbstring 对象之前，忘记获取互斥锁，或者在访问共享数据时，没有进行任何同步。这会导致数据竞争，程序行为不可预测。
⑤ 锁的粒度过大或过小：
锁的粒度（Lock Granularity）是指锁保护的临界区的大小。如果锁的粒度过大，例如，一个锁保护了整个数据结构的所有操作，会导致并发度降低，性能下降。如果锁的粒度过小，例如，只保护了部分操作，可能会遗漏某些临界区，仍然存在线程安全问题。因此，需要根据具体的应用场景，选择合适的锁粒度。
⑥ 死锁：
当程序中使用多个互斥锁时，如果锁的获取顺序不当，可能会导致死锁（Deadlock）。例如，线程 A 持有锁 L1，等待锁 L2；同时，线程 B 持有锁 L2，等待锁 L1。这时，线程 A 和线程 B 互相等待对方释放锁，导致程序永久阻塞。为了避免死锁，需要遵循一定的锁获取顺序，例如，总是按照固定的顺序获取锁。
⑦ 性能瓶颈：
即使代码是线程安全的，但如果同步机制使用不当，仍然可能成为性能瓶颈。例如，过度使用全局锁，或者锁的竞争过于激烈，都会降低程序的并发性能。因此，在保证线程安全的前提下，还需要关注性能优化，尽量减少锁的开销，提高并发度。
⑧ 避免陷阱的最佳实践：
⚝ 明确 fbstring 的线程安全特性：清楚地了解 fbstring 的哪些操作是线程安全的，哪些不是。
⚝ 使用线程安全的数据结构封装 fbstring：如果需要在多线程环境下共享和修改字符串数据，建议使用线程安全的数据结构（例如，ThreadSafeFbString）来封装 fbstring 对象，通过互斥锁等同步机制来保护内部的 fbstring。
⚝ 仔细审查并发代码：在编写并发代码时，要仔细审查每一处对共享 fbstring 对象的访问，确保所有临界区都得到了适当的保护。
⚝ 进行充分的测试：编写并发测试用例，模拟多线程并发访问的场景，检测是否存在数据竞争和死锁等问题。
⚝ 使用性能分析工具：使用性能分析工具（例如，ThreadSanitizer, Valgrind）检测并发代码中的线程安全问题，并分析性能瓶颈。
⑨ 总结：
避免 fbstring 的线程安全陷阱，需要深入理解 fbstring 的线程安全特性，采用合适的同步机制，并遵循并发编程的最佳实践。通过仔细的设计、编码、测试和性能分析，可以有效地避免线程安全问题，构建高效、稳定的并发程序。
3.3 fbstring 与 IO 操作的结合 (Integration of fbstring with IO Operations)
字符串在 IO 操作中扮演着重要的角色，无论是文件读写还是网络数据传输，都离不开字符串的处理。folly::fbstring 作为高性能的字符串类型，在 IO 密集型应用中具有广泛的应用价值。本节将探讨 fbstring 如何与 IO 操作高效结合，提升 IO 性能。
3.3.1 高效读取文件内容到 fbstring (Efficiently Reading File Content into fbstring)
将文件内容读取到字符串是常见的 IO 操作。传统的方式可能使用 std::string，但 folly::fbstring 在某些场景下可以提供更高的效率。
① 传统方式：使用 std::string 读取文件：
使用 std::string 读取文件内容，通常的做法是先确定文件大小，然后分配足够大的 std::string 缓冲区，再使用文件流读取数据。
1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
#include <sstream>
5
6
using namespace std;
7
8
string read_file_std_string(const string& filename) {
9
ifstream ifs(filename, ios::in | ios::binary | ios::ate); // 打开文件，定位到文件末尾
10
if (!ifs.is_open()) {
11
throw runtime_error("Failed to open file: " + filename);
12
}
13
14
ifstream::pos_type file_size = ifs.tellg(); // 获取文件大小
15
ifs.seekg(0, ios::beg); // 定位到文件开头
16
17
string content;
18
content.resize(file_size); // 预先分配缓冲区
19
ifs.read(&content[0], file_size); // 读取文件内容
20
21
return content;
22
}
23
24
int main() {
25
try {
26
string content = read_file_std_string("example.txt");
27
cout << "File content (first 50 chars): " << content.substr(0, 50) << "..." << endl;
28
} catch (const exception& e) {
29
cerr << "Error: " << e.what() << endl;
30
}
31
return 0;
32
}
这种方式的优点是代码简洁，易于理解。但缺点是可能存在一些性能优化的空间。例如，std::string::resize() 可能会进行内存的重新分配和拷贝。
② 使用 fbstring 读取文件：
使用 folly::fbstring 读取文件内容，可以利用 fbstring 的一些特性来提高效率。例如，fbstring 的 reserve() 方法可以预先分配足够的内存空间，避免后续的重新分配。
1
#include <iostream>
2
#include <fstream>
3
#include <folly/FBString.h>
4
5
using namespace std;
6
using namespace folly;
7
8
fbstring read_file_fbstring(const string& filename) {
9
ifstream ifs(filename, ios::in | ios::binary | ios::ate);
10
if (!ifs.is_open()) {
11
throw runtime_error("Failed to open file: " + filename);
12
}
13
14
ifstream::pos_type file_size = ifs.tellg();
15
ifs.seekg(0, ios::beg);
16
17
fbstring content;
18
content.reserve(file_size); // 预先分配缓冲区
19
content.resize(file_size); // 设置大小，但不初始化内容
20
ifs.read(content.data(), file_size); // 使用 data() 获取可写缓冲区
21
22
return content;
23
}
24
25
int main() {
26
try {
27
fbstring content = read_file_fbstring("example.txt");
28
cout << "File content (first 50 chars): " << content.substr(0, 50) << "..." << endl;
29
} catch (const exception& e) {
30
cerr << "Error: " << e.what() << endl;
31
}
32
return 0;
33
}
在这个例子中，我们使用了 fbstring::reserve() 方法预先分配了文件大小的内存空间，然后使用 fbstring::data() 方法获取可写的字符指针，传递给 ifs.read() 进行读取。fbstring::data() 返回的是指向内部缓冲区的指针，可以直接用于写入数据。
③ 零拷贝 (Zero-Copy) 读取：
在某些高级场景下，可以尝试使用零拷贝技术来进一步提高文件读取效率。零拷贝是指在数据传输过程中，尽量减少 CPU 的数据拷贝操作，直接在内核空间和用户空间之间传输数据，或者在内核空间内部完成数据传输。例如，可以使用 mmap() 系统调用将文件映射到内存，然后直接通过内存访问来读取文件内容。但零拷贝技术的实现通常比较复杂，需要深入了解操作系统和文件系统的底层机制。
④ 分块读取与流式处理：
对于大文件，一次性将整个文件内容读取到内存可能不可行。这时，可以采用分块读取（Chunked Reading）或流式处理（Streaming Processing）的方式。每次只读取文件的一部分内容到 fbstring 缓冲区，处理完这部分数据后，再读取下一部分。这样可以降低内存占用，并支持处理任意大小的文件。
⑤ 性能对比与选择：
在实际应用中，需要根据文件大小、读取频率、性能要求等因素，选择合适的读取方式。对于小文件，使用 std::string 或 fbstring 的简单读取方式通常已经足够高效。对于大文件，可以考虑使用 fbstring 的 reserve() 和 data() 方法进行优化，或者采用分块读取、流式处理等方式。在性能敏感的场景下，可以进行性能测试，对比不同读取方式的效率，选择最优方案。
⑥ 总结：
folly::fbstring 可以用于高效读取文件内容。通过预先分配内存、使用 data() 方法获取可写缓冲区等技巧，可以提高文件读取的效率。对于大文件，可以采用分块读取或流式处理的方式。在性能敏感的应用中，需要进行性能测试，选择最优的文件读取方案。
3.3.2 使用 fbstring 进行网络数据传输 (Using fbstring for Network Data Transmission)
在网络编程中，字符串常用于表示网络数据包的内容。folly::fbstring 可以作为高效的网络数据缓冲区，用于网络数据的接收、发送和处理。
① 网络数据接收缓冲区：
在网络编程中，通常需要一个缓冲区来接收网络数据。fbstring 可以作为接收缓冲区，用于存储接收到的数据。由于 fbstring 具有高效的内存管理和操作能力，可以提高网络数据接收的性能。
1
#include <iostream>
2
#include <sys/socket.h>
3
#include <netinet/in.h>
4
#include <unistd.h>
5
#include <folly/FBString.h>
6
7
using namespace std;
8
using namespace folly;
9
10
int main() {
11
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
12
if (sockfd == -1) {
13
perror("socket");
14
return 1;
15
}
16
17
sockaddr_in server_addr;
18
server_addr.sin_family = AF_INET;
19
server_addr.sin_port = htons(8080);
20
server_addr.sin_addr.s_addr = INADDR_ANY;
21
22
if (bind(sockfd, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
23
perror("bind");
24
close(sockfd);
25
return 1;
26
}
27
28
if (listen(sockfd, 5) == -1) {
29
perror("listen");
30
close(sockfd);
31
return 1;
32
}
33
34
sockaddr_in client_addr;
35
socklen_t client_addr_len = sizeof(client_addr);
36
int client_sockfd = accept(sockfd, (sockaddr*)&client_addr, &client_addr_len);
37
if (client_sockfd == -1) {
38
perror("accept");
39
close(sockfd);
40
return 1;
41
}
42
43
fbstring recv_buffer;
44
recv_buffer.resize(4096); // 预先分配接收缓冲区
45
46
ssize_t bytes_received = recv(client_sockfd, recv_buffer.data(), recv_buffer.size(), 0);
47
if (bytes_received > 0) {
48
recv_buffer.resize(bytes_received); // 调整实际接收到的数据大小
49
cout << "Received data: " << recv_buffer.toStdString() << endl;
50
} else if (bytes_received == 0) {
51
cout << "Connection closed by client." << endl;
52
} else {
53
perror("recv");
54
}
55
56
close(client_sockfd);
57
close(sockfd);
58
return 0;
59
}
在这个例子中，我们创建了一个简单的 TCP 服务器，使用 fbstring 作为接收缓冲区。recv_buffer.resize(4096) 预先分配了 4KB 的缓冲区，recv(client_sockfd, recv_buffer.data(), recv_buffer.size(), 0) 使用 recv() 系统调用接收数据，并将数据写入到 recv_buffer 的缓冲区中。接收完成后，recv_buffer.resize(bytes_received) 调整 fbstring 的大小，使其只包含实际接收到的数据。
② 网络数据发送缓冲区：
类似于接收缓冲区，fbstring 也可以作为发送缓冲区，用于存储待发送的网络数据。
1
#include <iostream>
2
#include <sys/socket.h>
3
#include <netinet/in.h>
4
#include <unistd.h>
5
#include <folly/FBString.h>
6
7
using namespace std;
8
using namespace folly;
9
10
int main() {
11
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
12
if (sockfd == -1) {
13
perror("socket");
14
return 1;
15
}
16
17
sockaddr_in server_addr;
18
server_addr.sin_family = AF_INET;
19
server_addr.sin_port = htons(8080);
20
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 连接到本地服务器
21
22
if (connect(sockfd, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
23
perror("connect");
24
close(sockfd);
25
return 1;
26
}
27
28
fbstring send_buffer = "Hello from client!";
29
ssize_t bytes_sent = send(sockfd, send_buffer.c_str(), send_buffer.size(), 0);
30
if (bytes_sent == -1) {
31
perror("send");
32
} else {
33
cout << "Sent " << bytes_sent << " bytes: " << send_buffer.toStdString() << endl;
34
}
35
36
close(sockfd);
37
return 0;
38
}
在这个例子中，我们创建了一个简单的 TCP 客户端，使用 fbstring send_buffer = "Hello from client!" 初始化发送缓冲区，然后使用 send(sockfd, send_buffer.c_str(), send_buffer.size(), 0) 发送数据。send_buffer.c_str() 返回指向字符串内容的只读指针，send_buffer.size() 返回字符串长度。
③ 零拷贝 (Zero-Copy) 发送：
类似于文件读取，网络数据发送也可以使用零拷贝技术来提高效率。例如，可以使用 sendfile() 系统调用，将文件内容直接从内核空间发送到网络套接字，避免用户空间和内核空间之间的数据拷贝。或者，在支持 Scatter-Gather IO 的网络接口卡（NIC）上，可以使用 Scatter-Gather IO 技术，将多个不连续的内存块（例如，fbstring 的不同部分）组合成一个数据包发送，减少数据拷贝和系统调用次数。
④ 内存池与缓冲区复用：
在高并发网络应用中，频繁地创建和销毁网络数据缓冲区会带来较大的性能开销。可以使用内存池（Memory Pool）技术，预先分配一批 fbstring 缓冲区，并进行复用。当需要发送或接收数据时，从内存池中获取一个空闲缓冲区，使用完后，再将缓冲区归还给内存池，以便下次重用。这样可以减少内存分配和释放的次数，提高性能。
⑤ 性能优化与协议解析：
fbstring 在网络编程中不仅可以作为数据缓冲区，还可以用于高效地进行协议解析。例如，在 HTTP 服务器中，可以使用 fbstring 存储 HTTP 请求和响应报文，并使用 fbstring 的查找、分割、子串操作等方法，快速解析 HTTP 头部和内容。结合 folly::StringPiece，可以进一步提高协议解析的效率，避免不必要的数据拷贝。
⑥ 总结：
folly::fbstring 可以高效地应用于网络数据传输，作为网络数据接收和发送缓冲区。通过预先分配缓冲区、使用零拷贝技术、内存池和缓冲区复用等方法，可以进一步提高网络 IO 的性能。fbstring 还可以用于高效地进行网络协议解析，提升网络应用的整体性能。
3.3.3 fbstring 在高性能 IO 场景下的应用 (Application of fbstring in High-Performance IO Scenarios)
folly::fbstring 由于其高性能特性，在各种高性能 IO 场景下都有广泛的应用价值。本节将探讨 fbstring 在一些典型的高性能 IO 场景中的应用。
① 高性能 Web 服务器：
在高性能 Web 服务器（例如，基于 Nginx、Apache、或者自研的 Web 服务器）中，fbstring 可以用于：
⚝ HTTP 请求和响应报文处理：存储和解析 HTTP 请求行、头部、消息体。
⚝ 静态文件服务：读取静态文件内容到 fbstring 缓冲区，并发送给客户端。
⚝ 日志记录：格式化和存储 Web 服务器的访问日志、错误日志等。
⚝ 连接管理：存储客户端连接的相关信息，例如，客户端 IP 地址、请求 URI 等。
② 高性能缓存系统：
在高性能缓存系统（例如，Memcached, Redis, 或者自研的缓存系统）中，fbstring 可以用于：
⚝ 键值存储：存储缓存的键和值。
⚝ 数据序列化和反序列化：将缓存对象序列化为 fbstring 格式存储，或者从 fbstring 反序列化为对象。
⚝ 网络通信：作为网络数据缓冲区，用于客户端和服务器之间的通信。
③ 高性能消息队列：
在高性能消息队列系统（例如，Kafka, RabbitMQ, 或者自研的消息队列）中，fbstring 可以用于：
⚝ 消息存储：存储消息的内容。
⚝ 消息序列化和反序列化：将消息对象序列化为 fbstring 格式存储，或者从 fbstring 反序列化为消息对象。
⚝ 网络传输：作为网络数据缓冲区，用于消息生产者、消息队列服务器和消息消费者之间的通信。
④ 高性能日志处理系统：
在高性能日志处理系统（例如，Fluentd, Elasticsearch, 或者自研的日志系统）中，fbstring 可以用于：
⚝ 日志收集：接收和存储来自不同来源的日志数据。
⚝ 日志解析：解析日志数据，提取关键字段。
⚝ 日志格式化：将日志数据格式化为特定的输出格式。
⚝ 日志传输：将日志数据传输到存储系统或分析系统。
⑤ 高性能数据库系统：
在高性能数据库系统（例如，MySQL, PostgreSQL, 或者 NoSQL 数据库）中，fbstring 可以用于：
⚝ SQL 语句处理：存储和解析 SQL 查询语句。
⚝ 数据存储：存储数据库表中的字符串类型数据。
⚝ 网络通信：作为客户端和服务器之间通信的数据缓冲区。
⑥ 其他高性能 IO 场景：
除了以上场景，fbstring 还可以应用于其他各种高性能 IO 场景，例如：
⚝ 高性能 RPC 框架：作为 RPC 请求和响应的数据缓冲区。
⚝ 高性能数据分析系统：处理和分析大量的文本数据。
⚝ 高性能游戏服务器：处理游戏客户端和服务器之间的通信数据。
⚝ 高性能音视频处理系统：处理音视频数据流中的文本元数据。
⑦ fbstring 的优势总结：
fbstring 在高性能 IO 场景下的应用优势主要体现在：
⚝ 高性能：fbstring 具有高效的内存管理、字符串操作和 IO 性能，可以满足高性能 IO 应用的需求。
⚝ 灵活性：fbstring 提供了丰富的 API，支持各种字符串操作，可以灵活地应用于不同的 IO 场景。
⚝ 可定制性：fbstring 支持自定义内存分配器，可以根据特定场景进行优化。
⚝ 与 Folly 库的集成：fbstring 是 Folly 库的一部分，可以方便地与其他 Folly 组件（例如，folly::StringPiece, folly::IOBuf）集成使用，构建更强大的高性能 IO 系统。
⑧ 总结：
folly::fbstring 在高性能 IO 场景下具有广泛的应用价值，例如，高性能 Web 服务器、缓存系统、消息队列、日志处理系统、数据库系统等。fbstring 的高性能、灵活性和可定制性，使其成为构建高性能 IO 应用的理想选择。
3.4 fbstring 性能测试与优化 (Performance Testing and Optimization of fbstring)
性能测试（Performance Testing）和优化（Optimization）是评估和提升 fbstring 性能的关键环节。本节将介绍 fbstring 的性能测试工具、方法，以及性能瓶颈分析和优化策略。
3.4.1 fbstring 性能测试工具与方法 (Performance Testing Tools and Methods for fbstring)
进行 fbstring 性能测试，需要选择合适的工具和方法，以获得准确、可靠的性能数据。
① 基准测试 (Benchmark)：
基准测试（Benchmark）是一种常用的性能测试方法，通过模拟实际应用场景，对目标代码进行性能评估。常用的基准测试工具包括：
⚝ Google Benchmark：Google Benchmark 是一个 C++ 微基准测试框架，可以方便地编写和运行基准测试用例，并生成详细的性能报告。Folly 库自身也使用 Google Benchmark 进行性能测试。
⚝ Criterion：Criterion 是另一个流行的 C++ 基准测试框架，具有易用性、可扩展性等特点。
⚝ 手动计时：对于简单的性能测试，可以使用 C++ 标准库提供的计时工具（例如，std::chrono）手动测量代码的执行时间。
② 性能剖析 (Profiling)：
性能剖析（Profiling）是一种更深入的性能分析方法，可以帮助我们找出程序中的性能瓶颈。常用的性能剖析工具包括：
⚝ perf (Linux)：perf 是 Linux 系统自带的性能分析工具，可以收集 CPU 指令周期、缓存命中率、系统调用等性能数据，帮助我们定位性能瓶颈。
⚝ Valgrind (Callgrind)：Valgrind 的 Callgrind 工具可以进行函数级别的性能剖析，分析程序的函数调用关系和执行时间，找出热点函数。
⚝ 火焰图 (Flame Graph)：火焰图是一种可视化性能剖析结果的工具，可以将函数调用栈以火焰的形式展示，直观地显示程序的性能瓶颈。
③ 内存分析工具：
内存分配和释放是字符串操作的重要组成部分。使用内存分析工具可以帮助我们评估 fbstring 的内存使用情况，找出内存泄漏、内存碎片等问题。常用的内存分析工具包括：
⚝ Valgrind (Memcheck)：Valgrind 的 Memcheck 工具可以检测内存泄漏、非法内存访问等内存错误。
⚝ AddressSanitizer (ASan)：AddressSanitizer 是一种快速的内存错误检测工具，可以检测内存越界、使用释放后内存等错误。
⚝ Memory Profiler：一些 IDE 和操作系统也提供了内存剖析工具，例如，Xcode Instruments (macOS), Visual Studio Profiler (Windows)。
④ 测试用例设计：
设计合理的测试用例是性能测试的关键。测试用例应该尽可能地模拟实际应用场景，覆盖各种常见的 fbstring 操作，例如：
⚝ 构造和析构：测试 fbstring 对象的创建和销毁开销。
⚝ 复制和赋值：测试 fbstring 对象的复制和赋值操作性能。
⚝ 字符串拼接：测试字符串拼接操作（例如，append(), operator+=）的性能。
⚝ 查找和匹配：测试字符串查找和匹配操作（例如，find(), startsWith(), endsWith()）的性能。
⚝ 子串操作：测试子串操作（例如，substr()）的性能。
⚝ 与其他类型的转换：测试 fbstring 与其他类型（例如，数字类型、std::string）之间的转换性能。
⚝ IO 操作：测试 fbstring 在文件读写、网络数据传输等 IO 场景下的性能。
⑤ 性能指标：
性能测试需要关注以下性能指标：
⚝ 执行时间 (Execution Time)：代码执行完成所需的时间，通常以秒、毫秒或纳秒为单位。
⚝ 吞吐量 (Throughput)：单位时间内完成的操作数量，例如，每秒处理的字符串数量、每秒传输的数据量。
⚝ 延迟 (Latency)：完成单个操作所需的时间，例如，字符串查找的延迟、网络数据包的传输延迟。
⚝ 内存占用 (Memory Usage)：程序运行过程中使用的内存量，包括堆内存、栈内存等。
⚝ CPU 使用率 (CPU Utilization)：程序运行过程中 CPU 的使用率。
⑥ 测试环境：
性能测试结果受测试环境的影响很大。为了获得可比的性能数据，需要控制测试环境的变量，例如：
⚝ 硬件配置：CPU 型号、内存大小、磁盘类型、网络带宽等。
⚝ 操作系统：操作系统类型、版本、内核参数等。
⚝ 编译器：编译器类型、版本、编译选项（例如，优化级别）。
⚝ 库版本：Folly 库版本、标准库版本等。
⑦ 统计分析：
性能测试通常需要多次运行，并对测试结果进行统计分析，例如，计算平均值、中位数、标准差、置信区间等。可以使用统计分析工具（例如，R, Python, Excel）对性能数据进行处理和可视化。
⑧ 总结：
进行 fbstring 性能测试，需要选择合适的工具和方法，设计合理的测试用例，关注关键性能指标，控制测试环境，并进行统计分析。通过全面的性能测试，可以深入了解 fbstring 的性能特点，为性能优化提供依据。
3.4.2 fbstring 与 std::string 的性能对比基准 (Performance Comparison Benchmarks between fbstring and std::string)
folly::fbstring 和 std::string 都是常用的 C++ 字符串类型，但在性能方面存在一些差异。进行 fbstring 和 std::string 的性能对比基准测试，可以帮助我们了解它们各自的优缺点，并根据实际应用场景选择合适的字符串类型。
① 测试场景选择：
性能对比基准测试需要选择具有代表性的测试场景，以反映 fbstring 和 std::string 在不同操作下的性能差异。常见的测试场景包括：
⚝ 构造与析构：测试字符串对象的创建和销毁开销。
⚝ 复制与赋值：测试字符串对象的复制和赋值操作性能。
⚝ 字符串拼接：测试字符串拼接操作（例如，append(), operator+=）的性能。
⚝ 查找与匹配：测试字符串查找和匹配操作（例如，find(), startsWith(), endsWith()）的性能。
⚝ 子串操作：测试子串操作（例如，substr()）的性能。
⚝ 迭代：测试字符串的迭代访问性能。
⚝ IO 操作：测试字符串在文件读写、网络数据传输等 IO 场景下的性能。
② 基准测试框架：
可以使用 Google Benchmark 等基准测试框架，编写性能对比测试用例。例如，可以使用 Google Benchmark 定义不同的 benchmark 函数，分别测试 fbstring 和 std::string 在不同场景下的性能。
③ 测试用例示例 (使用 Google Benchmark)：
下面是一个使用 Google Benchmark 进行字符串拼接性能对比的示例：
1
#include <benchmark/benchmark.h>
2
#include <string>
3
#include <folly/FBString.h>
4
5
using namespace std;
6
using namespace folly;
7
8
static void BM_StdStringAppend(benchmark::State& state) {
9
string str = "hello";
10
for (auto _ : state) {
11
string temp = str;
12
for (int i = 0; i < 100; ++i) {
13
temp += "world";
14
}
15
benchmark::DoNotOptimize(temp); // 防止编译器优化掉无用代码
16
}
17
}
18
BENCHMARK(BM_StdStringAppend);
19
20
static void BM_FBStringAppend(benchmark::State& state) {
21
fbstring str = "hello";
22
for (auto _ : state) {
23
fbstring temp = str;
24
for (int i = 0; i < 100; ++i) {
25
temp += "world";
26
}
27
benchmark::DoNotOptimize(temp);
28
}
29
}
30
BENCHMARK(BM_FBStringAppend);
31
32
BENCHMARK_MAIN();
在这个例子中，我们定义了两个 benchmark 函数 BM_StdStringAppend 和 BM_FBStringAppend，分别测试 std::string 和 fbstring 的字符串拼接性能。BENCHMARK_MAIN() 宏用于生成 main 函数，运行 benchmark 测试。
④ 性能对比结果分析：
运行基准测试用例后，可以得到 fbstring 和 std::string 在不同场景下的性能数据。通常，性能对比结果会显示：
⚝ 短字符串操作：fbstring 由于 SSO 优化，在短字符串的构造、复制、赋值等操作上，通常比 std::string 更高效。
⚝ 字符串拼接：fbstring 在字符串拼接操作方面，可能与 std::string 性能相当，或者略有优势，具体取决于实现和测试场景。
⚝ 查找和匹配：fbstring 和 std::string 在查找和匹配操作方面，性能差异可能不大。
⚝ 内存占用：fbstring 的内存占用可能略高于 std::string，因为 fbstring 为了实现 SSO 和其他优化，可能需要额外的内部数据结构。
⚝ IO 操作：fbstring 在 IO 操作方面，由于其高效的内存管理，可能比 std::string 略有优势。
⑤ 性能差异的原因：
fbstring 和 std::string 性能差异的原因主要在于：
⚝ 小字符串优化 (SSO)：fbstring 采用了 SSO 技术，对于短字符串操作进行了优化。
⚝ 写时复制 (COW)：早期的 fbstring 版本使用了 COW 机制，虽然现代 fbstring 已经移除了 COW，但 COW 的设计思想仍然影响着 fbstring 的实现。
⚝ 内存分配策略：fbstring 可能采用了定制化的内存分配策略，以提高内存管理效率。
⚝ 实现细节：fbstring 和 std::string 在内部实现细节上存在差异，例如，内存布局、算法选择等，这些差异也会影响性能。
⑥ 选择建议：
根据性能对比基准测试结果，以及实际应用场景的需求，可以选择合适的字符串类型：
⚝ 高性能场景：在对性能要求极高的场景下，例如，高性能服务器、缓存系统、消息队列等，folly::fbstring 可能是更好的选择，尤其是在处理大量短字符串的场景下。
⚝ 通用场景：在通用场景下，std::string 已经足够高效，并且具有更好的兼容性和可移植性。如果对性能没有特别苛刻的要求，std::string 仍然是一个不错的选择。
⚝ 混合场景：在某些场景下，可以根据字符串的长度和操作类型，混合使用 fbstring 和 std::string。例如，对于短字符串和频繁操作的字符串，使用 fbstring；对于长字符串和不频繁操作的字符串，使用 std::string。
⑦ 总结：
进行 fbstring 和 std::string 的性能对比基准测试，可以帮助我们了解它们各自的性能特点和适用场景。fbstring 在短字符串操作和高性能 IO 场景下可能具有优势，而 std::string 在通用场景下也足够高效。在实际应用中，需要根据性能测试结果和具体需求，选择合适的字符串类型。
3.4.3 性能瓶颈分析与优化策略 (Performance Bottleneck Analysis and Optimization Strategies)
性能瓶颈（Performance Bottleneck）是指程序中限制性能提升的关键因素。进行性能瓶颈分析，找出程序中的性能瓶颈，并采取相应的优化策略，是提升 fbstring 应用性能的关键步骤。
① 性能瓶颈的常见类型：
在 fbstring 应用中，常见的性能瓶颈类型包括：
⚝ CPU 密集型瓶颈：程序的主要性能瓶颈在于 CPU 计算，例如，复杂的字符串算法、正则表达式匹配、哈希计算等。
⚝ 内存密集型瓶颈：程序的主要性能瓶颈在于内存访问，例如，频繁的内存分配和释放、内存拷贝、缓存失效等。
⚝ IO 密集型瓶颈：程序的主要性能瓶颈在于 IO 操作，例如，文件读写、网络数据传输、数据库访问等。
⚝ 锁竞争瓶颈：在多线程程序中，如果锁的竞争过于激烈，会导致线程阻塞，降低并发性能。
② 性能瓶颈分析方法：
进行性能瓶颈分析，可以使用以下方法：
⚝ 性能剖析 (Profiling)：使用性能剖析工具（例如，perf, Valgrind, 火焰图）分析程序的性能数据，找出热点函数、CPU 使用率、内存访问模式、IO 等待时间等信息，定位性能瓶颈。
⚝ 基准测试 (Benchmark)：针对不同的代码模块或操作，编写基准测试用例，测量其性能数据，找出性能瓶颈所在。
⚝ 代码审查 (Code Review)：仔细审查代码，分析代码的算法复杂度、内存使用模式、IO 操作、锁使用情况等，找出潜在的性能瓶颈。
⚝ 假设验证 (Hypothesis Testing)：根据对代码的理解和性能数据分析，提出性能瓶颈的假设，并通过实验验证假设是否成立。
③ 常见的 fbstring 性能优化策略：
针对不同类型的性能瓶颈，可以采取相应的优化策略：
⚝ 算法优化：对于 CPU 密集型瓶颈，可以优化字符串算法，例如，使用更高效的查找、匹配、排序算法，减少不必要的计算。
⚝ 内存优化：
⚝ 减少内存分配：尽量重用 fbstring 对象，避免频繁的创建和销毁。使用 reserve() 方法预先分配足够的内存空间，避免动态扩容。
⚝ 使用 SSO：利用 fbstring 的 SSO 优化，对于短字符串操作，可以获得更高的性能。
⚝ 定制内存分配器：根据应用场景，使用自定义内存分配器，优化内存管理。
⚝ 零拷贝：在 IO 操作中，尽量使用零拷贝技术，减少数据拷贝开销。
⚝ IO 优化：对于 IO 密集型瓶颈，可以采用异步 IO、批量 IO、缓存等技术，减少 IO 等待时间，提高 IO 吞吐量。
⚝ 并发优化：对于锁竞争瓶颈，可以采用以下策略：
⚝ 减少锁的粒度：将锁的粒度从全局锁缩小到细粒度锁，提高并发度。
⚝ 使用无锁数据结构：在某些场景下，可以考虑使用无锁数据结构，避免锁的开销。
⚝ 优化锁的竞争：例如，使用读写锁代替互斥锁，减少读操作之间的互斥。
⚝ 编译器优化：使用编译器优化选项（例如，-O3, -march=native），开启编译器优化，提高代码执行效率。
⚝ 硬件优化：升级硬件配置，例如，使用更快的 CPU、更大的内存、更快的磁盘、更高带宽的网络，提升整体性能。
④ 优化步骤：
性能优化通常是一个迭代的过程，可以按照以下步骤进行：
⚝ 性能测试：首先进行性能测试，评估程序的当前性能水平。
⚝ 性能剖析：使用性能剖析工具分析性能数据，找出性能瓶颈。
⚝ 瓶颈分析：分析性能瓶颈的原因，确定优化方向。
⚝ 策略选择：选择合适的优化策略。
⚝ 代码修改：根据优化策略，修改代码。
⚝ 重新测试：修改代码后，重新进行性能测试，评估优化效果。
⚝ 迭代优化：如果性能提升不明显，或者出现新的性能瓶颈，重复以上步骤，进行迭代优化。
⑤ 注意事项：
⚝ 优化目标：在进行性能优化之前，需要明确优化目标，例如，将执行时间缩短多少，将吞吐量提高多少。
⚝ 适度优化：性能优化需要权衡收益和成本。过度优化可能会增加代码复杂性，降低可维护性。
⚝ 测试驱动优化：性能优化应该以性能测试为驱动，通过测试数据验证优化效果。
⚝ 持续优化：性能优化是一个持续的过程，需要不断地进行性能测试、分析和优化，以适应不断变化的应用需求和硬件环境。
⑥ 总结：
性能瓶颈分析和优化策略是提升 fbstring 应用性能的关键环节。通过性能剖析、基准测试、代码审查等方法，找出性能瓶颈，并采取相应的优化策略，例如，算法优化、内存优化、IO 优化、并发优化等，可以有效地提升 fbstring 应用的性能。性能优化是一个迭代的过程，需要持续进行测试、分析和优化。
END_OF_CHAPTER
4. chapter 4： folly::String API 全面解析 (Comprehensive API Analysis of folly::String)
4.1 folly::StringPiece API 详解 (Detailed API Explanation of folly::StringPiece)
4.1.1 构造函数与赋值运算符 (Constructors and Assignment Operators)
folly::StringPiece 是一个非拥有式（non-owning）的字符串视图类，它提供了对字符序列的只读访问能力，而无需进行内存分配和复制。因此，其构造函数和赋值运算符的设计重点在于高效和避免不必要的资源开销。
① 默认构造函数 (Default Constructor)
1
folly::StringPiece();
⚝ 默认构造函数创建一个空的 StringPiece 对象，它不指向任何字符数据。其 data() 方法返回 nullptr，size() 方法返回 0。
② C 风格字符串构造函数 (C-style String Constructor)
1
folly::StringPiece(const char* str);
⚝ 接受一个 C 风格字符串 str 作为参数。
⚝ 如果 str 为 nullptr，则构造一个空的 StringPiece。
⚝ 否则，StringPiece 将指向 str 指向的以空字符结尾的字符串，其大小由 strlen(str) 确定。
③ 带长度的 C 风格字符串构造函数 (C-style String with Length Constructor)
1
folly::StringPiece(const char* str, size_t len);
⚝ 接受一个 C 风格字符串 str 和长度 len 作为参数。
⚝ 允许指定字符串的长度，即使 str 不是以空字符结尾的。
⚝ 如果 str 为 nullptr 且 len 为非零值，行为是未定义的。通常应避免这种情况。
④ std::string 构造函数 (std::string Constructor)
1
folly::StringPiece(const std::string& str);
⚝ 接受一个 std::string 对象的引用 str 作为参数。
⚝ StringPiece 将视图指向 std::string 对象内部的字符数据。
⑤ 字符指针和长度构造函数 (Character Pointer and Length Constructor)
1
folly::StringPiece(const char* data, size_t length);
⚝ 这是最通用的构造函数，接受一个字符指针 data 和长度 length。
⚝ StringPiece 将视图指向从 data 开始的 length 个字符。
⚝ data 可以指向任何字符数组，不一定是空字符结尾的字符串。
⑥ 拷贝构造函数与拷贝赋值运算符 (Copy Constructor and Copy Assignment Operator)
1
folly::StringPiece(const StringPiece& other);
2
StringPiece& operator=(const StringPiece& other);
⚝ 拷贝构造函数和拷贝赋值运算符执行浅拷贝（shallow copy），即它们只是复制指针和长度，而不是字符数据本身。
⚝ 这意味着多个 StringPiece 对象可以共享同一个字符序列，而无需额外的内存分配。
示例代码 (Code Example)
1
#include <folly/StringPiece.h>
2
#include <string>
3
#include <iostream>
4
5
int main() {
6
const char* c_str = "hello";
7
std::string std_str = "world";
8
9
folly::StringPiece sp1; // 默认构造函数
10
folly::StringPiece sp2(c_str); // C 风格字符串构造函数
11
folly::StringPiece sp3(c_str, 3); // 带长度的 C 风格字符串构造函数
12
folly::StringPiece sp4(std_str); // std::string 构造函数
13
folly::StringPiece sp5("literal string"); // 隐式转换
14
folly::StringPiece sp6 = sp2; // 拷贝构造函数
15
folly::StringPiece sp7;
16
sp7 = sp4; // 拷贝赋值运算符
17
18
std::cout << "sp1: data=" << (sp1.data() == nullptr ? "nullptr" : sp1.data()) << ", size=" << sp1.size() << std::endl;
19
std::cout << "sp2: data=" << sp2.data() << ", size=" << sp2.size() << std::endl;
20
std::cout << "sp3: data=" << sp3.data() << ", size=" << sp3.size() << std::endl;
21
std::cout << "sp4: data=" << sp4.data() << ", size=" << sp4.size() << std::endl;
22
std::cout << "sp5: data=" << sp5.data() << ", size=" << sp5.size() << std::endl;
23
std::cout << "sp6: data=" << sp6.data() << ", size=" << sp6.size() << std::endl;
24
std::cout << "sp7: data=" << sp7.data() << ", size=" << sp7.size() << std::endl;
25
26
return 0;
27
}
总结 (Summary)
folly::StringPiece 的构造函数和赋值运算符都旨在提供最大的灵活性和效率，避免不必要的内存拷贝。理解这些构造函数的工作方式对于正确和高效地使用 StringPiece 至关重要。尤其需要注意的是 StringPiece 是非拥有式的，其生命周期不应超过其指向的原始数据。
4.1.2 容量与长度相关方法 (Capacity and Length Related Methods)
由于 folly::StringPiece 是一个字符串视图，它并不拥有字符串的存储空间，因此，与容量（capacity）相关的概念在 StringPiece 中并不适用。StringPiece 主要关注的是它所“看到”的字符串的长度和数据指针。以下是 StringPiece 中与长度相关的主要方法：
① size() 或 length()
1
size_t size() const;
2
size_t length() const;
⚝ 这两个方法完全等价，都返回 StringPiece 对象所表示的字符串的长度（即字符的数量）。
⚝ 长度不包括空字符结尾符。
⚝ 对于空的 StringPiece 对象，返回值为 0。
② empty()
1
bool empty() const;
⚝ 返回一个布尔值，指示 StringPiece 对象是否为空。
⚝ 如果 size() 为 0，则返回 true，否则返回 false。
⚝ 这是一个方便的方法，用于快速检查 StringPiece 是否包含任何字符。
③ data()
1
const char* data() const;
⚝ 返回一个指向 StringPiece 对象所表示的字符序列的首字符的指针。
⚝ 如果 StringPiece 对象为空，则返回 nullptr。
⚝ 返回的指针类型是 const char*，强调了 StringPiece 的只读性质。
④ remove_prefix(size_t n)
1
void remove_prefix(size_t n);
⚝ 从 StringPiece 的开头移除 n 个字符。
⚝ 实际上，它通过增加内部数据指针并减小长度来实现，而不会实际修改原始字符串数据。
⚝ 如果 n 大于或等于当前 size()，则 StringPiece 将变为空。
⑤ remove_suffix(size_t n)
1
void remove_suffix(size_t n);
⚝ 从 StringPiece 的末尾移除 n 个字符。
⚝ 通过减小内部长度来实现，同样不会修改原始字符串数据。
⚝ 如果 n 大于或等于当前 size()，则 StringPiece 将变为空。
示例代码 (Code Example)
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece sp("Hello, StringPiece!");
6
7
std::cout << "String: " << sp.data() << std::endl;
8
std::cout << "Size: " << sp.size() << std::endl;
9
std::cout << "Length: " << sp.length() << std::endl;
10
std::cout << "Empty: " << std::boolalpha << sp.empty() << std::endl;
11
12
sp.remove_prefix(7);
13
std::cout << "\nAfter remove_prefix(7):" << std::endl;
14
std::cout << "String: " << sp.data() << std::endl;
15
std::cout << "Size: " << sp.size() << std::endl;
16
17
sp.remove_suffix(2);
18
std::cout << "\nAfter remove_suffix(2):" << std::endl;
19
std::cout << "String: " << sp.data() << std::endl;
20
std::cout << "Size: " << sp.size() << std::endl;
21
22
return 0;
23
}
总结 (Summary)
folly::StringPiece 提供了简洁而高效的方法来获取字符串视图的长度和数据指针，以及修改视图的起始和结束位置。这些方法都是非修改性的，不会改变原始字符串数据，并且操作效率很高，因为它们主要涉及指针和长度的运算，而避免了内存分配和复制。理解这些方法是使用 StringPiece 进行高效字符串处理的基础。
4.1.3 查找与匹配方法 (Search and Match Methods)
folly::StringPiece 提供了丰富的查找和匹配方法，这些方法允许在字符串视图中高效地定位字符或子字符串。由于 StringPiece 是只读的，这些查找操作不会修改原始字符串。
① find(CharT ch, size_type pos = 0) const
1
size_t find(char ch, size_t pos = 0) const;
⚝ 从位置 pos 开始，查找第一个出现的字符 ch。
⚝ 如果找到，返回字符的索引位置（从 0 开始）。
⚝ 如果未找到，返回 folly::StringPiece::npos (通常是 size_t 的最大值)。
② rfind(CharT ch, size_type pos = npos) const
1
size_t rfind(char ch, size_t pos = npos) const;
⚝ 从位置 pos 开始向前（反向）查找最后一个出现的字符 ch。
⚝ 如果找到，返回字符的索引位置。
⚝ 如果未找到，返回 folly::StringPiece::npos。
⚝ 默认情况下，pos 为 npos，表示从字符串的末尾开始向前查找。
③ find(StringPiece str, size_type pos = 0) const
1
size_t find(StringPiece str, size_t pos = 0) const;
⚝ 从位置 pos 开始，查找第一个出现的子字符串 str。
⚝ 如果找到，返回子字符串起始位置的索引。
⚝ 如果未找到，返回 folly::StringPiece::npos。
④ rfind(StringPiece str, size_type pos = npos) const
1
size_t rfind(StringPiece str, size_type pos = npos) const;
⚝ 从位置 pos 开始向前（反向）查找最后一个出现的子字符串 str。
⚝ 如果找到，返回子字符串起始位置的索引。
⚝ 如果未找到，返回 folly::StringPiece::npos。
⑤ find_first_of(StringPiece chars, size_type pos = 0) const
1
size_t find_first_of(StringPiece chars, size_t pos = 0) const;
⚝ 从位置 pos 开始，查找第一个出现在 chars 中的字符。
⚝ 返回找到的字符在 StringPiece 中的索引。
⚝ 如果未找到，返回 folly::StringPiece::npos。
⑥ find_first_not_of(StringPiece chars, size_type pos = 0) const
1
size_t find_first_not_of(StringPiece chars, size_type pos = 0) const;
⚝ 从位置 pos 开始，查找第一个不出现在 chars 中的字符。
⚝ 返回找到的字符在 StringPiece 中的索引。
⚝ 如果未找到，返回 folly::StringPiece::npos。
⑦ find_last_of(StringPiece chars, size_type pos = npos) const
1
size_t find_last_of(StringPiece chars, size_type pos = npos) const;
⚝ 从位置 pos 开始向前（反向）查找最后一个出现在 chars 中的字符。
⚝ 返回找到的字符在 StringPiece 中的索引。
⚝ 如果未找到，返回 folly::StringPiece::npos。
⑧ find_last_not_of(StringPiece chars, size_type pos = npos) const
1
size_t find_last_not_of(StringPiece chars, size_type pos = npos) const;
⚝ 从位置 pos 开始向前（反向）查找最后一个不出现在 chars 中的字符。
⚝ 返回找到的字符在 StringPiece 中的索引。
⚝ 如果未找到，返回 folly::StringPiece::npos。
⑨ startsWith(StringPiece prefix) const
1
bool startsWith(StringPiece prefix) const;
⚝ 检查 StringPiece 是否以指定的前缀 prefix 开始。
⚝ 返回 true 如果是，否则返回 false。
⑩ endsWith(StringPiece suffix) const
1
bool endsWith(StringPiece suffix) const;
⚝ 检查 StringPiece 是否以指定的后缀 suffix 结尾。
⚝ 返回 true 如果是，否则返回 false。
示例代码 (Code Example)
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece sp = "Hello, World! Hello, Folly!";
6
7
// find
8
size_t pos1 = sp.find('o');
9
std::cout << "find('o'): " << pos1 << std::endl; // 输出 4
10
size_t pos2 = sp.find("World");
11
std::cout << "find(\"World\"): " << pos2 << std::endl; // 输出 7
12
13
// rfind
14
size_t pos3 = sp.rfind('o');
15
std::cout << "rfind('o'): " << pos3 << std::endl; // 输出 19
16
size_t pos4 = sp.rfind("Hello");
17
std::cout << "rfind(\"Hello\"): " << pos4 << std::endl; // 输出 14
18
19
// find_first_of
20
size_t pos5 = sp.find_first_of("eo");
21
std::cout << "find_first_of(\"eo\"): " << pos5 << std::endl; // 输出 1 ('e')
22
23
// find_first_not_of
24
size_t pos6 = sp.find_first_not_of("Hel");
25
std::cout << "find_first_not_of(\"Hel\"): " << pos6 << std::endl; // 输出 3 (',')
26
27
// startsWith & endsWith
28
std::cout << "startsWith(\"Hello\"): " << std::boolalpha << sp.startsWith("Hello") << std::endl; // true
29
std::cout << "endsWith(\"Folly!\"): " << std::boolalpha << sp.endsWith("Folly!") << std::endl; // true
30
31
return 0;
32
}
总结 (Summary)
folly::StringPiece 提供的查找和匹配方法覆盖了常见的字符串搜索需求，包括字符和子字符串的查找，正向和反向查找，以及基于字符集合的查找。这些方法都设计为高效操作，利用 StringPiece 的轻量级特性，避免不必要的内存操作。掌握这些方法可以有效地在字符串视图中定位和提取所需的信息。
4.1.4 子串操作方法 (Substring Operation Methods)
folly::StringPiece 提供了方便的子串操作方法，允许从现有的 StringPiece 对象创建新的 StringPiece 对象，指向原始字符串的子集。这些操作同样是非拥有式的，不会发生内存拷贝，非常高效。
① substr(size_type pos = 0, size_type n = npos) const
1
StringPiece substr(size_t pos = 0, size_t n = npos) const;
⚝ 返回一个新的 StringPiece 对象，它表示当前 StringPiece 对象从位置 pos 开始，长度为 n 的子字符串。
⚝ 如果 pos 超出当前字符串的范围，则行为未定义。
⚝ 如果 n 为 folly::StringPiece::npos，则子字符串将延续到原字符串的末尾。
⚝ 如果请求的子字符串超出原始字符串的边界，返回的子字符串将只包含到原始字符串末尾的部分。
② split(CharT delimiter, std::vector<StringPiece>& result) const
1
void split(char delimiter, std::vector<StringPiece>& result) const;
⚝ 使用单个字符 delimiter 作为分隔符，将当前 StringPiece 对象分割成多个子字符串，并将结果存储在 std::vector<StringPiece>& result 中。
⚝ 分割后的子字符串将作为新的 StringPiece 对象添加到 result 向量中。
⚝ 默认情况下，连续的分隔符会被视为空字符串之间的分隔符，即会产生空字符串。如果需要不同的行为，可能需要结合其他方法进行处理。
③ split(StringPiece delimiters, std::vector<StringPiece>& result) const
1
void split(StringPiece delimiters, std::vector<StringPiece>& result) const;
⚝ 使用 delimiters 中包含的任何字符作为分隔符，将当前 StringPiece 对象分割成多个子字符串，并将结果存储在 std::vector<StringPiece>& result 中。
⚝ 这允许使用多个可能的字符作为分隔符。
示例代码 (Code Example)
1
#include <folly/StringPiece.h>
2
#include <vector>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece sp = "apple,banana,orange,grape";
7
8
// substr
9
folly::StringPiece sub_sp1 = sp.substr(7); // 从索引 7 开始到末尾
10
std::cout << "substr(7): \"" << sub_sp1 << "\"" << std::endl; // 输出 "banana,orange,grape"
11
folly::StringPiece sub_sp2 = sp.substr(0, 5); // 从索引 0 开始，长度为 5
12
std::cout << "substr(0, 5): \"" << sub_sp2 << "\"" << std::endl; // 输出 "apple"
13
14
// split with char delimiter
15
std::vector<folly::StringPiece> parts1;
16
sp.split(',', parts1);
17
std::cout << "\nsplit(',') results:" << std::endl;
18
for (const auto& part : parts1) {
19
std::cout << "\"" << part << "\" ";
20
}
21
std::cout << std::endl; // 输出 "apple" "banana" "orange" "grape"
22
23
// split with StringPiece delimiters
24
folly::StringPiece sp2 = " leading and trailing spaces ";
25
std::vector<folly::StringPiece> parts2;
26
sp2.split(" ", parts2); // 使用空格作为分隔符
27
std::cout << "\nsplit(\" \") results:" << std::endl;
28
for (const auto& part : parts2) {
29
std::cout << "\"" << part << "\" ";
30
}
31
std::cout << std::endl; // 输出 "" "" "leading" "and" "trailing" "spaces" ""
32
33
return 0;
34
}
总结 (Summary)
folly::StringPiece 的子串操作方法提供了强大的字符串处理能力，允许用户高效地提取和分割字符串视图。substr 方法用于获取子字符串，而 split 方法则用于根据分隔符将字符串分割成多个部分。这些方法都非常高效，因为它们创建的是新的视图而不是复制字符串数据，这使得 StringPiece 非常适合于高性能的字符串处理任务。
4.1.5 比较运算符 (Comparison Operators)
folly::StringPiece 重载了标准的比较运算符，允许直接比较 StringPiece 对象。这些比较是基于字典序（lexicographical order）进行的，并且是逐字符比较，直到确定顺序或比较完所有字符。
① 相等运算符 (Equality Operators)
1
bool operator==(StringPiece other) const;
2
bool operator!=(StringPiece other) const;
⚝ operator== 比较两个 StringPiece 对象是否相等。只有当两个 StringPiece 对象表示的字符串内容完全相同时，才返回 true。
⚝ operator!= 检查两个 StringPiece 对象是否不相等，是 operator== 的逻辑非。
② 关系运算符 (Relational Operators)
1
bool operator<(StringPiece other) const;
2
bool operator>(StringPiece other) const;
3
bool operator<=(StringPiece other) const;
4
bool operator>=(StringPiece other) const;
⚝ 这些运算符用于比较两个 StringPiece 对象的字典序关系。
⚝ operator<：如果当前 StringPiece 对象在字典序上小于 other，则返回 true。
⚝ operator>：如果当前 StringPiece 对象在字典序上大于 other，则返回 true。
⚝ operator<=：如果当前 StringPiece 对象在字典序上小于等于 other，则返回 true。
⚝ operator>=：如果当前 StringPiece 对象在字典序上大于等于 other，则返回 true。
字典序比较规则 (Lexicographical Comparison Rules)
字典序比较类似于字典中单词的排序方式。比较过程如下：
1. 从两个字符串的第一个字符开始逐个比较。
2. 如果两个字符不同，则根据字符的 ASCII 值（或其他字符编码顺序）确定字符串的顺序。
3. 如果所有字符都相同，但一个字符串比另一个字符串短，则较短的字符串在字典序上被认为是较小的。
4. 如果两个字符串完全相同（包括长度和内容），则它们在字典序上相等。
示例代码 (Code Example)
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece sp1 = "apple";
6
folly::StringPiece sp2 = "banana";
7
folly::StringPiece sp3 = "apple";
8
folly::StringPiece sp4 = "apples";
9
10
// 相等性比较
11
std::cout << std::boolalpha << (sp1 == sp3) << std::endl; // true
12
std::cout << std::boolalpha << (sp1 != sp2) << std::endl; // true
13
std::cout << std::boolalpha << (sp1 == sp2) << std::endl; // false
14
15
// 关系比较
16
std::cout << std::boolalpha << (sp1 < sp2) << std::endl; // true ("apple" < "banana")
17
std::cout << std::boolalpha << (sp2 > sp1) << std::endl; // true ("banana" > "apple")
18
std::cout << std::boolalpha << (sp1 <= sp3) << std::endl; // true ("apple" <= "apple")
19
std::cout << std::boolalpha << (sp1 <= sp4) << std::endl; // true ("apple" < "apples")
20
std::cout << std::boolalpha << (sp4 >= sp1) << std::endl; // true ("apples" > "apple")
21
22
return 0;
23
}
总结 (Summary)
folly::StringPiece 提供的比较运算符使得字符串视图的比较变得简单直观。这些运算符基于字典序进行比较，并且高效，因为它们直接操作字符数据而无需创建新的字符串对象。这对于需要频繁比较字符串的算法和数据结构非常有用，例如排序、搜索和数据验证等。
4.2 folly::fbstring API 详解 (Detailed API Explanation of folly::fbstring)
folly::fbstring 是 Folly 库提供的一个高性能字符串类，旨在替代 std::string 在某些场景下的不足。它在内存管理、写时复制（Copy-on-Write, COW）等方面进行了优化，以提高性能。本节将详细解析 fbstring 的 API。
4.2.1 构造函数与赋值运算符 (Constructors and Assignment Operators)
folly::fbstring 提供了多种构造函数和赋值运算符，以灵活地创建和初始化字符串对象。
① 默认构造函数 (Default Constructor)
1
fbstring();
⚝ 创建一个空的 fbstring 对象，不包含任何字符。
② C 风格字符串构造函数 (C-style String Constructor)
1
fbstring(const char* str);
⚝ 接受一个 C 风格字符串 str 作为参数。
⚝ 如果 str 为 nullptr，则行为未定义（通常会导致程序崩溃，应避免）。
⚝ 否则，fbstring 将初始化为 str 指向的以空字符结尾的字符串的副本。
③ 带长度的 C 风格字符串构造函数 (C-style String with Length Constructor)
1
fbstring(const char* str, size_t len);
⚝ 接受一个 C 风格字符串 str 和长度 len 作为参数。
⚝ 允许指定字符串的长度，即使 str 不是以空字符结尾的。
⚝ 如果 str 为 nullptr 且 len 为非零值，行为是未定义的。
④ std::string 构造函数 (std::string Constructor)
1
fbstring(const std::string& str);
⚝ 接受一个 std::string 对象的引用 str 作为参数。
⚝ fbstring 将初始化为 std::string 对象 str 的副本。
⑤ StringPiece 构造函数 (StringPiece Constructor)
1
fbstring(StringPiece sp);
⚝ 接受一个 folly::StringPiece 对象 sp 作为参数。
⚝ fbstring 将初始化为 StringPiece 对象 sp 所表示的字符串的副本。
⑥ 拷贝构造函数与拷贝赋值运算符 (Copy Constructor and Copy Assignment Operator)
1
fbstring(const fbstring& other);
2
fbstring& operator=(const fbstring& other);
⚝ 拷贝构造函数和拷贝赋值运算符都实现了写时复制（COW）机制。
⚝ 当进行拷贝构造或赋值时，如果原始 fbstring 对象不是唯一拥有其数据，则新的 fbstring 对象会共享原始对象的数据。只有当其中一个副本尝试修改字符串内容时，才会发生实际的内存复制。
⑦ 移动构造函数与移动赋值运算符 (Move Constructor and Move Assignment Operator)
1
fbstring(fbstring&& other) noexcept;
2
fbstring& operator=(fbstring&& other) noexcept;
⚝ 移动构造函数和移动赋值运算符允许高效地转移资源所有权，避免深拷贝。
⚝ 移动操作会将 other 对象的状态转移到新的 fbstring 对象，并将 other 对象置于有效但未指定的状态。
⑧ 范围构造函数 (Range Constructor)
1
template <class InputIterator>
2
fbstring(InputIterator begin, InputIterator end);
⚝ 允许从迭代器范围 [begin, end) 构造 fbstring 对象。
⑨ 填充构造函数 (Fill Constructor)
1
fbstring(size_t n, char c);
⚝ 创建一个包含 n 个字符 c 的 fbstring 对象。
示例代码 (Code Example)
1
#include <folly/FBString.h>
2
#include <string>
3
#include <iostream>
4
5
int main() {
6
const char* c_str = "hello";
7
std::string std_str = "world";
8
folly::StringPiece sp("StringPiece view");
9
10
folly::fbstring fb_str1; // 默认构造函数
11
folly::fbstring fb_str2(c_str); // C 风格字符串构造函数
12
folly::fbstring fb_str3(c_str, 3); // 带长度的 C 风格字符串构造函数
13
folly::fbstring fb_str4(std_str); // std::string 构造函数
14
folly::fbstring fb_str5(sp); // StringPiece 构造函数
15
folly::fbstring fb_str6 = fb_str2; // 拷贝构造函数
16
folly::fbstring fb_str7;
17
fb_str7 = fb_str4; // 拷贝赋值运算符
18
folly::fbstring fb_str8 = std::move(fb_str6); // 移动构造函数
19
folly::fbstring fb_str9;
20
fb_str9 = std::move(fb_str7); // 移动赋值运算符
21
folly::fbstring fb_str10(10, 'x'); // 填充构造函数
22
23
std::cout << "fb_str1: \"" << fb_str1 << "\"" << std::endl;
24
std::cout << "fb_str2: \"" << fb_str2 << "\"" << std::endl;
25
std::cout << "fb_str3: \"" << fb_str3 << "\"" << std::endl;
26
std::cout << "fb_str4: \"" << fb_str4 << "\"" << std::endl;
27
std::cout << "fb_str5: \"" << fb_str5 << "\"" << std::endl;
28
std::cout << "fb_str6 (moved from): \"" << fb_str6 << "\"" << std::endl; // 可能为空或有效但不确定
29
std::cout << "fb_str8: \"" << fb_str8 << "\"" << std::endl;
30
std::cout << "fb_str10: \"" << fb_str10 << "\"" << std::endl;
31
32
return 0;
33
}
总结 (Summary)
folly::fbstring 提供了全面的构造函数和赋值运算符，支持从各种字符串类型和数据源创建 fbstring 对象。写时复制和移动语义的实现使得 fbstring 在拷贝和移动操作时更加高效，尤其是在字符串频繁复制的场景下。理解这些构造函数和赋值运算符对于有效地使用 fbstring 至关重要。
4.2.2 容量与长度相关方法 (Capacity and Length Related Methods)
folly::fbstring 提供了与容量和长度相关的方法，类似于 std::string，但内部实现可能有所不同，尤其是在内存管理和写时复制方面。
① size() 或 length()
1
size_t size() const noexcept;
2
size_t length() const noexcept;
⚝ 这两个方法等价，返回 fbstring 对象中字符的数量。
⚝ 不包括空字符结尾符。
② empty()
1
bool empty() const noexcept;
⚝ 返回 true 如果 fbstring 对象为空（即 size() 为 0），否则返回 false。
③ capacity()
1
size_t capacity() const noexcept;
⚝ 返回当前 fbstring 对象已分配的存储空间大小，以字符为单位。
⚝ capacity() 通常大于或等于 size()，表示在不重新分配内存的情况下，fbstring 可以容纳的最大字符数。
⚝ 由于写时复制的特性，多个 fbstring 对象可能共享相同的存储空间，因此 capacity() 的值可能反映共享存储的容量。
④ reserve(size_t n)
1
void reserve(size_t n);
⚝ 预分配至少能容纳 n 个字符的存储空间。
⚝ 如果 n 大于当前的 capacity()，则会重新分配内存。
⚝ reserve() 可以用于避免在多次追加字符时频繁的内存重新分配，从而提高性能。
⚝ 由于写时复制，reserve() 可能会触发数据的复制，如果多个 fbstring 对象共享同一份数据。
⑤ shrink_to_fit()
1
void shrink_to_fit();
⚝ 尝试释放不再需要的额外容量，将 capacity() 减小到与 size() 相同的大小。
⚝ 这可以用于减少内存占用，尤其是在字符串大小大幅缩减后。
⚝ 同样，由于写时复制，shrink_to_fit() 也可能触发数据复制。
⑥ max_size()
1
size_t max_size() const noexcept;
⚝ 返回 fbstring 对象可以容纳的最大字符数，受系统和库实现的限制。
⚝ 这是一个理论上的上限，实际可用的最大大小可能更小，取决于可用内存等因素。
示例代码 (Code Example)
1
#include <folly/FBString.h>
2
#include <iostream>
3
4
int main() {
5
folly::fbstring fb_str = "Hello";
6
7
std::cout << "Initial fb_str: \"" << fb_str << "\"" << std::endl;
8
std::cout << "Size: " << fb_str.size() << std::endl;
9
std::cout << "Capacity: " << fb_str.capacity() << std::endl;
10
std::cout << "Empty: " << std::boolalpha << fb_str.empty() << std::endl;
11
12
fb_str.reserve(100);
13
std::cout << "\nAfter reserve(100):" << std::endl;
14
std::cout << "Capacity: " << fb_str.capacity() << std::endl;
15
16
fb_str += ", World!";
17
std::cout << "\nAfter appending \", World!\":" << std::endl;
18
std::cout << "fb_str: \"" << fb_str << "\"" << std::endl;
19
std::cout << "Size: " << fb_str.size() << std::endl;
20
std::cout << "Capacity: " << fb_str.capacity() << std::endl;
21
22
fb_str.shrink_to_fit();
23
std::cout << "\nAfter shrink_to_fit():" << std::endl;
24
std::cout << "Capacity: " << fb_str.capacity() << std::endl;
25
26
return 0;
27
}
总结 (Summary)
folly::fbstring 提供的容量和长度相关方法与 std::string 类似，但需要考虑到 fbstring 的写时复制特性。capacity(), reserve(), 和 shrink_to_fit() 等方法允许用户管理 fbstring 的内存使用，以优化性能和内存占用。合理使用这些方法可以在性能关键的应用中发挥重要作用。
4.2.3 修改字符串内容的方法 (Methods for Modifying String Content)
folly::fbstring 提供了多种方法来修改字符串的内容，包括追加、插入、删除、替换等操作。由于 fbstring 采用了写时复制（COW）机制，修改操作可能会触发数据复制，尤其是在多个 fbstring 对象共享同一份数据时。
① operator+= (Append Operators)
1
fbstring& operator+=(const fbstring& str);
2
fbstring& operator+=(StringPiece sp);
3
fbstring& operator+=(const std::string& str);
4
fbstring& operator+=(const char* str);
5
fbstring& operator+=(char c);
⚝ 提供多种重载形式，用于将字符串、StringPiece、std::string、C 风格字符串或单个字符追加到 fbstring 对象的末尾。
⚝ 这些操作可能会导致内存重新分配，如果当前容量不足以容纳追加的内容。
⚝ 如果发生写时复制，修改操作会先复制数据，然后再进行追加。
② append()
1
fbstring& append(const fbstring& str);
2
fbstring& append(StringPiece sp);
3
fbstring& append(const std::string& str);
4
fbstring& append(const char* str);
5
fbstring& append(const char* str, size_t len);
6
fbstring& append(size_t n, char c);
7
template <class InputIterator>
8
fbstring& append(InputIterator first, InputIterator last);
⚝ append() 方法提供了更丰富的追加功能，包括追加 fbstring、StringPiece、std::string、C 风格字符串、指定长度的 C 风格字符串、重复字符以及迭代器范围的内容。
⚝ 功能与 operator+= 类似，但更灵活。
③ push_back(char c)
1
void push_back(char c);
⚝ 将单个字符 c 追加到 fbstring 的末尾。
④ insert()
1
fbstring& insert(size_t pos, const fbstring& str);
2
fbstring& insert(size_t pos, StringPiece sp);
3
fbstring& insert(size_t pos, const std::string& str);
4
fbstring& insert(size_t pos, const char* str);
5
fbstring& insert(size_t pos, const char* str, size_t len);
6
fbstring& insert(size_t pos, size_t n, char c);
7
template <class InputIterator>
8
fbstring& insert(size_t pos, InputIterator first, InputIterator last);
⚝ 在指定位置 pos 插入字符串、StringPiece、std::string、C 风格字符串、指定长度的 C 风格字符串、重复字符或迭代器范围的内容。
⚝ 插入操作通常比追加操作开销更大，因为它可能需要移动插入位置之后的所有字符。
⑤ erase()
1
fbstring& erase(size_t pos = 0, size_t n = npos);
⚝ 从指定位置 pos 开始删除最多 n 个字符。
⚝ 如果 n 为 folly::fbstring::npos，则删除从 pos 开始到字符串末尾的所有字符。
⑥ clear()
1
void clear() noexcept;
⚝ 清空 fbstring 对象的内容，使其变为空字符串。
⚝ capacity() 可能保持不变，但 size() 将变为 0。
⑦ replace()
1
fbstring& replace(size_t pos, size_t len, const fbstring& str);
2
fbstring& replace(size_t pos, size_t len, StringPiece sp);
3
fbstring& replace(size_t pos, size_t len, const std::string& str);
4
fbstring& replace(size_t pos, size_t len, const char* str);
5
fbstring& replace(size_t pos, size_t len, const char* str, size_t replacement_len);
6
fbstring& replace(size_t pos, size_t len, size_t n, char c);
⚝ 将从位置 pos 开始，长度为 len 的子字符串替换为新的字符串、StringPiece、std::string、C 风格字符串、指定长度的 C 风格字符串或重复字符。
⚝ 替换操作是修改字符串内容的强大工具。
示例代码 (Code Example)
1
#include <folly/FBString.h>
2
#include <iostream>
3
4
int main() {
5
folly::fbstring fb_str = "Hello";
6
7
// append
8
fb_str += ", World!";
9
std::cout << "After operator+=: \"" << fb_str << "\"" << std::endl; // "Hello, World!"
10
fb_str.append(" Folly");
11
std::cout << "After append(\" Folly\"): \"" << fb_str << "\"" << std::endl; // "Hello, World! Folly"
12
13
// push_back
14
fb_str.push_back('!');
15
std::cout << "After push_back('!'): \"" << fb_str << "\"" << std::endl; // "Hello, World! Folly!!"
16
17
// insert
18
fb_str.insert(5, "---");
19
std::cout << "After insert(5, \"---\"): \"" << fb_str << "\"" << std::endl; // "Hello---, World! Folly!!"
20
21
// erase
22
fb_str.erase(5, 3);
23
std::cout << "After erase(5, 3): \"" << fb_str << "\"" << std::endl; // "Hello, World! Folly!!"
24
25
// replace
26
fb_str.replace(7, 5, "Universe");
27
std::cout << "After replace(7, 5, \"Universe\"): \"" << fb_str << "\"" << std::endl; // "Hello, Universe! Folly!!"
28
29
// clear
30
fb_str.clear();
31
std::cout << "After clear(): \"" << fb_str << "\"" << std::endl; // ""
32
std::cout << "Size after clear(): " << fb_str.size() << std::endl; // 0
33
34
return 0;
35
}
总结 (Summary)
folly::fbstring 提供了丰富的修改字符串内容的方法，涵盖了常见的字符串操作需求。由于写时复制机制，修改操作的性能特性需要特别注意。在性能敏感的场景中，应尽量减少不必要的字符串复制，例如，可以通过预先 reserve() 足够的容量来减少内存重新分配的次数。
4.2.4 查找与匹配方法 (Search and Match Methods)
folly::fbstring 提供了与 folly::StringPiece 类似的查找和匹配方法，用于在 fbstring 对象中搜索字符或子字符串。这些方法与 StringPiece 的对应方法功能相似，但操作对象是可修改的 fbstring。
fbstring 提供的查找与匹配方法包括（与 StringPiece 类似，功能和用法也基本一致）：
① find(CharT ch, size_type pos = 0) const
② rfind(CharT ch, size_type pos = npos) const
③ find(StringPiece str, size_type pos = 0) const
④ rfind(StringPiece str, size_type pos = npos) const
⑤ find_first_of(StringPiece chars, size_type pos = 0) const
⑥ find_first_not_of(StringPiece chars, size_type pos = 0) const
⑦ find_last_of(StringPiece chars, size_type pos = npos) const
⑧ find_last_not_of(StringPiece chars, size_type pos = npos) const
⑨ startsWith(StringPiece prefix) const
⑩ endsWith(StringPiece suffix) const
这些方法的具体用法和返回值与 folly::StringPiece 中描述的完全一致，此处不再重复详细解释。可以参考 4.1.3 节 folly::StringPiece 的查找与匹配方法部分。
示例代码 (Code Example)
1
#include <folly/FBString.h>
2
#include <iostream>
3
4
int main() {
5
folly::fbstring fb_str = "Hello, World! Hello, Folly!";
6
7
// find
8
size_t pos1 = fb_str.find('o');
9
std::cout << "find('o'): " << pos1 << std::endl;
10
size_t pos2 = fb_str.find("World");
11
std::cout << "find(\"World\"): " << pos2 << std::endl;
12
13
// startsWith & endsWith
14
std::cout << "startsWith(\"Hello\"): " << std::boolalpha << fb_str.startsWith("Hello") << std::endl;
15
std::cout << "endsWith(\"Folly!\"): " << std::boolalpha << fb_str.endsWith("Folly!") << std::endl;
16
17
return 0;
18
}
总结 (Summary)
folly::fbstring 提供的查找与匹配方法与 folly::StringPiece 类似，使得在 fbstring 对象中进行字符串搜索变得方便高效。这些方法允许开发者执行各种字符串查找操作，而无需转换为其他字符串类型。
4.2.5 子串操作方法 (Substring Operation Methods)
folly::fbstring 提供了子串操作方法，用于获取 fbstring 对象的子字符串。与 folly::StringPiece 的子串操作类似，但 fbstring 的 substr 方法返回的是一个新的 fbstring 对象，而不是 StringPiece。
① substr(size_type pos = 0, size_type n = npos) const
1
fbstring substr(size_t pos = 0, size_t n = npos) const;
⚝ 返回一个新的 fbstring 对象，它是当前 fbstring 对象从位置 pos 开始，长度为 n 的子字符串的副本。
⚝ 与 StringPiece::substr 不同，fbstring::substr 返回的是一个拥有所有权的 fbstring 对象，这意味着会发生字符串的复制。
⚝ 如果 pos 超出范围或 n 过大，行为与 std::string::substr 类似。
② split(CharT delimiter, std::vector<fbstring>& result) const
1
void split(char delimiter, std::vector<fbstring>& result) const;
⚝ 使用单个字符 delimiter 作为分隔符，将当前 fbstring 对象分割成多个子字符串，并将结果存储在 std::vector<fbstring>& result 中。
⚝ 分割后的子字符串将作为新的 fbstring 对象添加到 result 向量中。
⚝ 与 StringPiece::split 类似，但结果是 fbstring 对象。
③ split(StringPiece delimiters, std::vector<fbstring>& result) const
1
void split(StringPiece delimiters, std::vector<fbstring>& result) const;
⚝ 使用 delimiters 中包含的任何字符作为分隔符进行分割，结果同样是 fbstring 对象的向量。
示例代码 (Code Example)
1
#include <folly/FBString.h>
2
#include <vector>
3
#include <iostream>
4
5
int main() {
6
folly::fbstring fb_str = "apple,banana,orange,grape";
7
8
// substr
9
folly::fbstring sub_fb_str1 = fb_str.substr(7);
10
std::cout << "substr(7): \"" << sub_fb_str1 << "\"" << std::endl;
11
folly::fbstring sub_fb_str2 = fb_str.substr(0, 5);
12
std::cout << "substr(0, 5): \"" << sub_fb_str2 << "\"" << std::endl;
13
14
// split with char delimiter
15
std::vector<folly::fbstring> parts1;
16
fb_str.split(',', parts1);
17
std::cout << "\nsplit(',') results:" << std::endl;
18
for (const auto& part : parts1) {
19
std::cout << "\"" << part << "\" ";
20
}
21
std::cout << std::endl;
22
23
return 0;
24
}
总结 (Summary)
folly::fbstring 的子串操作方法提供了方便的方式来提取和分割 fbstring 对象的内容。与 StringPiece 的主要区别在于，fbstring 的子串操作返回的是拥有所有权的 fbstring 对象，这意味着在性能敏感的场景下，需要考虑潜在的字符串复制开销。
4.2.6 与其他类型的转换方法 (Conversion Methods to Other Types)
folly::fbstring 提供了一些方法用于与其他类型进行转换，例如转换为 C 风格字符串或 std::string。
① c_str()
1
const char* c_str() const;
⚝ 返回一个指向以空字符结尾的 C 风格字符串的指针。
⚝ 返回的指针指向 fbstring 对象内部存储的字符数据，并且保证以空字符结尾。
⚝ 返回的指针的生命周期与 fbstring 对象相同，如果 fbstring 对象被销毁或内容被修改，指针可能会失效。
② toStdString()
1
std::string toStdString() const;
⚝ 返回一个与当前 fbstring 对象内容相同的 std::string 对象。
⚝ 这会创建一个新的 std::string 对象，并将 fbstring 的内容复制到新的 std::string 对象中。
示例代码 (Code Example)
1
#include <folly/FBString.h>
2
#include <string>
3
#include <iostream>
4
5
int main() {
6
folly::fbstring fb_str = "Convert me";
7
8
// c_str()
9
const char* c_str = fb_str.c_str();
10
std::cout << "c_str(): \"" << c_str << "\"" << std::endl;
11
12
// toStdString()
13
std::string std_str = fb_str.toStdString();
14
std::cout << "toStdString(): \"" << std_str << "\"" << std::endl;
15
16
return 0;
17
}
总结 (Summary)
folly::fbstring 提供了转换为 C 风格字符串和 std::string 的方法，方便与其他库或 API 进行交互。c_str() 方法提供了高效的零拷贝转换到 C 风格字符串的方式，而 toStdString() 方法则提供了到 std::string 的完整拷贝转换。选择使用哪种方法取决于具体的应用场景和性能需求。
4.3 folly::stringPrintf 与格式化输出 (Formatted Output with folly::stringPrintf)
folly::stringPrintf 是 Folly 库提供的一个用于格式化字符串输出的函数，类似于 sprintf，但返回的是 folly::fbstring 对象，而不是写入到字符数组。这使得格式化字符串操作更加安全和方便，避免了缓冲区溢出的风险。
4.3.1 stringPrintf 的用法与示例 (Usage and Examples of stringPrintf)
folly::stringPrintf 的基本用法是接受一个格式化字符串和可变数量的参数，根据格式化字符串生成一个 folly::fbstring 对象。
函数签名 (Function Signature)
1
folly::fbstring stringPrintf(const char* format, ...);
⚝ format：格式化字符串，与 printf 的格式化字符串语法兼容。
⚝ ...：可变参数列表，根据格式化字符串中的格式控制符进行替换。
⚝ 返回值：一个包含格式化结果的 folly::fbstring 对象。
基本示例 (Basic Examples)
1
#include <folly/FBString.h>
2
#include <iostream>
3
4
int main() {
5
int age = 30;
6
std::string name = "Alice";
7
8
// 格式化字符串和整数
9
folly::fbstring str1 = folly::stringPrintf("Age is %d", age);
10
std::cout << str1 << std::endl; // 输出 "Age is 30"
11
12
// 格式化字符串和字符串
13
folly::fbstring str2 = folly::stringPrintf("Name is %s", name.c_str());
14
std::cout << str2 << std::endl; // 输出 "Name is Alice"
15
16
// 格式化多个参数
17
folly::fbstring str3 = folly::stringPrintf("Name: %s, Age: %d", name.c_str(), age);
18
std::cout << str3 << std::endl; // 输出 "Name: Alice, Age: 30"
19
20
// 格式化浮点数
21
double pi = 3.1415926;
22
folly::fbstring str4 = folly::stringPrintf("Pi is approximately %.2f", pi);
23
std::cout << str4 << std::endl; // 输出 "Pi is approximately 3.14"
24
25
return 0;
26
}
使用 StringPiece 参数 (Using StringPiece Arguments)
folly::stringPrintf 也可以很好地与 folly::StringPiece 协同工作，可以直接使用 StringPiece 对象作为 %s 格式控制符的参数。
1
#include <folly/FBString.h>
2
#include <folly/StringPiece.h>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece sp = "StringPiece";
7
folly::fbstring str = folly::stringPrintf("This is a %s example", sp);
8
std::cout << str << std::endl; // 输出 "This is a StringPiece example"
9
return 0;
10
}
总结 (Summary)
folly::stringPrintf 提供了一种类型安全且方便的方式来格式化字符串，它返回 folly::fbstring 对象，避免了传统 sprintf 的缓冲区溢出问题。其用法与 printf 类似，但更加现代化和安全。
4.3.2 stringPrintf 的格式化控制符 (Format Specifiers of stringPrintf)
folly::stringPrintf 支持大部分与标准 printf 兼容的格式化控制符，用于指定如何格式化输出不同类型的参数。
常用格式控制符 (Common Format Specifiers)
⚝ %d 或 %i: 格式化为有符号十进制整数 (int)。
⚝ %u: 格式化为无符号十进制整数 (unsigned int)。
⚝ %x 或 %X: 格式化为十六进制整数 (unsigned int)，%x 使用小写字母，%X 使用大写字母。
⚝ %o: 格式化为八进制整数 (unsigned int)。
⚝ %f: 格式化为浮点数 (double)，标准十进制形式。
⚝ %e 或 %E: 格式化为浮点数 (double)，科学计数法，%e 使用小写 'e'，%E 使用大写 'E'。
⚝ %g 或 %G: 格式化为浮点数 (double)，自动选择 %f 或 %e (%E) 格式中较短的一种。
⚝ %c: 格式化为字符 (char)。
⚝ %s: 格式化为 C 风格字符串 (const char*)。也可以接受 folly::StringPiece。
⚝ %p: 格式化为指针 (void*)，通常以十六进制形式显示内存地址。
⚝ %%: 输出百分号 % 本身。
修饰符 (Modifiers)
可以在格式控制符中添加修饰符来进一步控制格式化输出：
⚝ 宽度修饰符: 在 % 和格式控制符之间可以指定一个数字，表示输出的最小宽度。如果输出内容宽度不足，则会用空格填充（默认右对齐）。例如，%5d 表示输出宽度至少为 5 的十进制整数。
⚝ 精度修饰符: 对于浮点数，可以使用 . 后跟一个数字来指定小数点后的精度。例如，%.2f 表示保留两位小数的浮点数。
⚝ 标志修饰符:
▮▮▮▮⚝ -：左对齐输出（默认右对齐）。例如，%-5d。
▮▮▮▮⚝ +：在正数前面显示加号 +。例如，%+d。
▮▮▮▮⚝ 空格：在正数前面显示一个空格。例如，% d。
▮▮▮▮⚝ #：对于 %o、%x、%X，分别在输出前面添加 0、0x、0X 前缀；对于 %f、%e、%E、%g、%G，强制输出小数点。例如，%#x，%#f。
▮▮▮▮⚝ 0：用零填充空白位置（宽度修饰符指定宽度时）。例如，%05d。
示例代码 (Code Example)
1
#include <folly/FBString.h>
2
#include <iostream>
3
4
int main() {
5
int num = 123;
6
double pi = 3.1415926;
7
std::string str = "example";
8
9
folly::fbstring formatted_str = folly::stringPrintf(
10
"Integer: %d, Hex: %x, Float: %.2f, String: %10s, Padded Integer: %05d",
11
num, num, pi, str.c_str(), num);
12
std::cout << formatted_str << std::endl;
13
// 输出 "Integer: 123, Hex: 7b, Float: 3.14, String: example, Padded Integer: 00123"
14
15
return 0;
16
}
总结 (Summary)
folly::stringPrintf 支持丰富的格式化控制符和修饰符，与 printf 语法基本兼容，提供了强大的字符串格式化能力。开发者可以灵活地控制输出的格式，以满足各种需求。
4.3.3 stringPrintf 的性能考量 (Performance Considerations of stringPrintf)
folly::stringPrintf 在性能方面通常表现良好，但作为格式化输出函数，其性能开销相对比简单的字符串拼接要高。理解其性能特性有助于在性能敏感的应用中合理使用。
性能特点 (Performance Characteristics)
- 格式化解析开销:
stringPrintf需要解析格式化字符串，并根据格式控制符处理参数。这部分解析和处理过程会带来一定的性能开销，尤其是在格式化字符串复杂或格式化操作频繁时。 - 动态内存分配:
stringPrintf返回folly::fbstring对象，这意味着在格式化过程中可能涉及动态内存分配。虽然fbstring内部有优化，例如小字符串优化（SSO），但对于非常大的格式化结果，仍然可能发生堆内存分配，这会影响性能。 - 写时复制 (COW) 的影响: 如果格式化后的
fbstring对象被频繁复制，写时复制机制可以减少实际的内存复制次数。但在某些情况下，例如多线程环境下的并发修改，COW 可能会带来额外的同步开销。
性能优化建议 (Performance Optimization Tips)
- 避免在循环中频繁使用: 如果在循环中频繁调用
stringPrintf，并且格式化字符串和参数变化不大，可以考虑将格式化操作移出循环，或者预先计算好格式化字符串，以减少重复的解析开销。 - 使用简单的格式化字符串: 复杂的格式化字符串解析起来更耗时。如果格式化需求简单，尽量使用简单的格式控制符，避免不必要的复杂性。
- 考虑使用字符串拼接: 对于简单的字符串拼接场景，例如只是将几个字符串或数字连接起来，直接使用
fbstring的operator+=或append()方法可能比stringPrintf更高效，因为避免了格式化解析的开销。 - 预分配容量: 如果预知格式化后字符串的大概长度，可以使用
fbstring::reserve()预先分配足够的容量，以减少动态内存分配的次数。 - 性能测试: 在性能关键的应用中，应该进行实际的性能测试，比较
stringPrintf和其他字符串操作方法的性能差异，选择最适合具体场景的方法。
与其他格式化方法的比较 (Comparison with Other Formatting Methods)
⚝ std::sprintf: std::sprintf 的性能可能略优于 stringPrintf，因为它直接写入到预分配的字符数组，避免了 fbstring 的一些管理开销。但 sprintf 存在缓冲区溢出风险，且返回的是 C 风格字符串，使用不如 fbstring 方便。
⚝ std::ostringstream: std::ostringstream 是 C++ 标准库提供的流式格式化方法，类型安全，但通常性能比 stringPrintf 差，尤其是在格式化简单字符串时。
⚝ fmt::format (或 std::format C++20): fmt::format 库（以及 C++20 标准库的 std::format）提供了现代化的格式化方法，类型安全，性能通常与 stringPrintf 相当或更优，且语法更简洁。如果项目允许使用 C++20 或引入 fmt 库，可以考虑使用 fmt::format 或 std::format。
总结 (Summary)
folly::stringPrintf 在提供安全和方便的字符串格式化功能的同时，也需要考虑其性能开销。在性能敏感的应用中，应根据具体场景选择合适的字符串格式化方法，并进行必要的性能测试和优化。对于简单的格式化需求，可以考虑使用更轻量级的字符串拼接方法；对于复杂的格式化需求，stringPrintf 仍然是一个强大且实用的工具。
4.4.1 字符串转换函数 (String Conversion Functions)
Folly 库提供了一组方便的字符串转换函数，用于在字符串和数值类型之间进行转换。其中，folly::to<T>() 模板函数是核心，它提供了一种类型安全且简洁的方式进行字符串转换。
4.4.1.1 to<T>() 模板函数 (The to<T>() Template Function)
folly::to<T>() 是一个模板函数，可以将字符串转换为指定的类型 T。它支持多种数值类型和字符串类型之间的转换，并且在转换失败时会抛出异常，从而保证了类型安全。
函数签名 (Function Signature)
1
template <typename T, typename StringType>
2
T to(const StringType& str);
⚝ T：目标类型，即要将字符串转换成的类型。可以是数值类型（如 int, double, long long 等）、std::string、folly::fbstring 等。
⚝ StringType：源字符串类型，可以是 folly::StringPiece、std::string、folly::fbstring 或 C 风格字符串。
⚝ 返回值：类型为 T 的转换结果。
⚝ 异常：如果转换失败（例如，字符串无法解析为指定的数值类型），则抛出异常（通常是 std::invalid_argument 或 std::out_of_range）。
基本用法 (Basic Usage)
1
#include <folly/FBString.h>
2
#include <folly/Conv.h>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece str_int = "123";
7
folly::StringPiece str_double = "3.14";
8
folly::StringPiece str_bool_true = "true";
9
folly::StringPiece str_bool_false = "false";
10
11
// 转换为 int
12
int int_val = folly::to<int>(str_int);
13
std::cout << "String to int: " << int_val << std::endl; // 输出 123
14
15
// 转换为 double
16
double double_val = folly::to<double>(str_double);
17
std::cout << "String to double: " << double_val << std::endl; // 输出 3.14
18
19
// 转换为 bool
20
bool bool_val_true = folly::to<bool>(str_bool_true);
21
bool bool_val_false = folly::to<bool>(str_bool_false);
22
std::cout << "String \"true\" to bool: " << std::boolalpha << bool_val_true << std::endl; // 输出 true
23
std::cout << "String \"false\" to bool: " << std::boolalpha << bool_val_false << std::endl; // 输出 false
24
25
// 转换为 fbstring
26
folly::fbstring fb_str_val = folly::to<folly::fbstring>(str_int);
27
std::cout << "String to fbstring: \"" << fb_str_val << "\"" << std::endl; // 输出 "123"
28
29
return 0;
30
}
异常处理 (Exception Handling)
folly::to<T>() 在转换失败时会抛出异常，因此在使用时应该进行异常处理，以保证程序的健壮性。
1
#include <folly/FBString.h>
2
#include <folly/Conv.h>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece invalid_str_int = "abc";
7
8
try {
9
int invalid_int_val = folly::to<int>(invalid_str_int);
10
std::cout << "String to int: " << invalid_int_val << std::endl; // 不会执行到这里
11
} catch (const std::invalid_argument& e) {
12
std::cerr << "Conversion failed: " << e.what() << std::endl; // 输出 "Conversion failed: folly::to<int>: invalid argument"
13
}
14
15
return 0;
16
}
支持的类型 (Supported Types)
folly::to<T>() 支持转换为多种类型，包括：
⚝ 数值类型: int, long, long long, unsigned int, unsigned long, unsigned long long, float, double, long double 等。
⚝ 布尔类型: bool (接受 "true", "false", "1", "0", "yes", "no", 忽略大小写)。
⚝ 字符串类型: std::string, folly::fbstring。
总结 (Summary)
folly::to<T>() 模板函数提供了一种类型安全、方便且通用的字符串转换方式。它支持多种目标类型和源字符串类型，并且通过异常处理机制保证了转换的安全性。在需要将字符串转换为数值或其他类型时，folly::to<T>() 是一个非常有用的工具。
4.4.1.2 字符串与数字类型之间的转换 (Conversions Between String and Numeric Types)
folly::to<T>() 模板函数特别擅长于字符串与数字类型之间的转换。它能够处理各种格式的数字字符串，并将其转换为对应的数值类型。
字符串转数值类型 (String to Numeric Types)
folly::to<T>() 可以将表示整数、浮点数或布尔值的字符串转换为相应的数值类型。
1
#include <folly/FBString.h>
2
#include <folly/Conv.h>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece str_int_decimal = "12345";
7
folly::StringPiece str_int_hex = "0x7b"; // 十六进制
8
folly::StringPiece str_double_decimal = "123.45";
9
folly::StringPiece str_double_scientific = "1.2345e2"; // 科学计数法
10
11
int int_decimal = folly::to<int>(str_int_decimal);
12
int int_hex = folly::to<int>(str_int_hex);
13
double double_decimal = folly::to<double>(str_double_decimal);
14
double double_scientific = folly::to<double>(str_double_scientific);
15
16
std::cout << "Decimal integer string to int: " << int_decimal << std::endl; // 12345
17
std::cout << "Hexadecimal integer string to int: " << int_hex << std::endl; // 123 (0x7b)
18
std::cout << "Decimal double string to double: " << double_decimal << std::endl; // 123.45
19
std::cout << "Scientific double string to double: " << double_scientific << std::endl; // 123.45
20
21
return 0;
22
}
数值类型转字符串 (Numeric Types to String)
虽然 folly::to<T>() 主要用于字符串到其他类型的转换，但结合 folly::stringPrintf 或其他字符串格式化方法，可以实现数值类型到字符串的转换。
1
#include <folly/FBString.h>
2
#include <folly/Conv.h>
3
#include <iostream>
4
5
int main() {
6
int int_val = 12345;
7
double double_val = 3.14159;
8
9
// 使用 stringPrintf 将 int 转换为字符串
10
folly::fbstring str_int = folly::stringPrintf("%d", int_val);
11
std::cout << "Int to string: \"" << str_int << "\"" << std::endl; // "12345"
12
13
// 使用 stringPrintf 将 double 转换为字符串，并控制精度
14
folly::fbstring str_double = folly::stringPrintf("%.2f", double_val);
15
std::cout << "Double to string (2 decimal places): \"" << str_double << "\"" << std::endl; // "3.14"
16
17
return 0;
18
}
总结 (Summary)
folly::to<T>() 提供了强大的字符串到数值类型的转换能力，支持多种数值格式和类型。结合 folly::stringPrintf 等格式化输出函数，可以实现数值类型到字符串的转换，从而在 folly::String 库中构建完整的字符串与数值类型之间的转换方案。
4.4.2 字符串 Hash 函数 (String Hash Functions)
Folly 库为字符串类型提供了 Hash 函数，用于计算字符串的哈希值。这对于在哈希表、哈希集合等数据结构中使用字符串作为键非常有用。
4.4.2.1 hash_value() 函数 (The hash_value() Function)
Folly 库为 folly::StringPiece 和 folly::fbstring 提供了 hash_value() 函数，用于计算字符串的哈希值。这些函数通常使用高效的哈希算法，例如 FNV-1a 或 CityHash，以提供良好的哈希分布和性能。
函数签名 (Function Signature)
1
size_t hash_value(folly::StringPiece sp);
2
size_t hash_value(const folly::fbstring& str);
⚝ 接受一个 folly::StringPiece 或 folly::fbstring 对象作为参数。
⚝ 返回值：size_t 类型的哈希值。
基本用法 (Basic Usage)
1
#include <folly/StringPiece.h>
2
#include <folly/FBString.h>
3
#include <folly/Hash.h>
4
#include <iostream>
5
6
int main() {
7
folly::StringPiece sp = "hello";
8
folly::fbstring fb_str = "world";
9
10
// 计算 StringPiece 的哈希值
11
size_t hash1 = folly::hash_value(sp);
12
std::cout << "Hash value of StringPiece \"hello\": " << hash1 << std::endl;
13
14
// 计算 fbstring 的哈希值
15
size_t hash2 = folly::hash_value(fb_str);
16
std::cout << "Hash value of fbstring \"world\": " << hash2 << std::endl;
17
18
// 相同字符串的哈希值应该相同
19
folly::StringPiece sp2 = "hello";
20
size_t hash3 = folly::hash_value(sp2);
21
std::cout << "Hash value of StringPiece \"hello\" (again): " << hash3 << std::endl;
22
std::cout << "hash1 == hash3: " << std::boolalpha << (hash1 == hash3) << std::endl; // true
23
24
return 0;
25
}
哈希算法 (Hashing Algorithm)
folly::hash_value() 函数的具体哈希算法可能会在 Folly 库的不同版本中有所变化，但通常会选择高效且冲突率低的算法。常见的选择包括：
⚝ FNV-1a (Fowler–Noll–Vo): 一种快速且广泛使用的非加密哈希算法。
⚝ CityHash: Google 开发的一种高性能哈希算法，尤其在处理长字符串时表现优秀。
开发者通常不需要关心具体的哈希算法，只需要使用 folly::hash_value() 函数即可获得可靠的哈希值。
应用场景 (Application Scenarios)
字符串哈希值在很多场景中都非常有用，例如：
⚝ 哈希表 (Hash Tables) 和哈希集合 (Hash Sets): 将字符串作为键存储在哈希表或哈希集合中，需要计算字符串的哈希值来确定其存储位置。
⚝ 数据索引和查找: 使用哈希值可以加速字符串的查找和索引过程。
⚝ 数据校验: 哈希值可以用于快速校验数据是否发生变化。
总结 (Summary)
folly::hash_value() 函数为 folly::StringPiece 和 folly::fbstring 提供了高效的字符串哈希功能。这使得在 Folly 库中使用字符串作为哈希键变得非常方便，并且可以应用于各种需要字符串哈希的场景。
4.4.2.2 自定义 Hash 函数的应用 (Application of Custom Hash Functions)
虽然 folly::hash_value() 提供了默认的字符串哈希函数，但在某些特殊场景下，可能需要使用自定义的哈希函数。Folly 库允许用户自定义哈希函数，并在需要时使用它们。
自定义哈希函数的需求 (Need for Custom Hash Functions)
- 特定哈希算法: 在某些应用中，可能需要使用特定的哈希算法，例如出于兼容性或性能优化的考虑。
- 哈希冲突控制: 对于特定的数据集，默认的哈希函数可能容易产生哈希冲突。自定义哈希函数可以根据数据特性进行优化，以减少冲突。
- 加密哈希: 在安全相关的应用中，可能需要使用加密哈希函数，例如 SHA-256 或 MD5，而不是非加密哈希函数。
自定义哈希函数的方法 (Methods for Custom Hash Functions)
Folly 库的哈希框架允许用户注册和使用自定义的哈希函数。具体的自定义方法可能涉及到 Folly 库更底层的哈希接口，超出本书 folly::String.h 的范围。但通常情况下，使用默认的 folly::hash_value() 函数已经足够满足大多数需求。
使用自定义哈希函数的示例 (Example of Using Custom Hash Functions - Conceptual)
以下是一个概念性的示例，说明如何使用自定义哈希函数（实际实现可能更复杂，需要查阅 Folly 库的哈希文档）：
1
#include <folly/StringPiece.h>
2
#include <folly/FBString.h>
3
#include <folly/Hash.h>
4
#include <iostream>
5
6
// 假设的自定义哈希函数 (Conceptual - may not be actual Folly API)
7
size_t customHashFunction(folly::StringPiece sp) {
8
// 实现自定义的哈希算法
9
size_t hash = 0;
10
for (char c : sp) {
11
hash = hash * 31 + c; // 简单的示例哈希算法
12
}
13
return hash;
14
}
15
16
int main() {
17
folly::StringPiece sp = "custom hash";
18
19
// 使用默认的 hash_value
20
size_t defaultHash = folly::hash_value(sp);
21
std::cout << "Default hash value: " << defaultHash << std::endl;
22
23
// 使用自定义哈希函数 (Conceptual - may not be actual Folly API)
24
size_t customHash = customHashFunction(sp);
25
std::cout << "Custom hash value: " << customHash << std::endl;
26
27
return 0;
28
}
总结 (Summary)
虽然 folly::hash_value() 提供了方便且高效的默认字符串哈希函数，Folly 库也为需要更高级哈希功能的开发者提供了自定义哈希函数的可能性。自定义哈希函数可以用于实现特定的哈希算法、优化哈希冲突控制或满足安全需求。在大多数情况下，默认的 folly::hash_value() 函数已经足够使用。
END_OF_CHAPTER
5. chapter 5： 高级主题与扩展 (Advanced Topics and Extensions)
5.1 folly::String 与 Unicode 支持 (Unicode Support in folly::String)
Unicode 是一种通用的字符编码标准，旨在支持世界上所有书写系统中的字符。随着全球化的发展，处理多语言文本已成为现代软件开发中不可或缺的一部分。folly::String 库虽然核心关注性能和效率，但也充分考虑了 Unicode 的支持，尤其是在处理 UTF-8 编码方面。本节将深入探讨 Unicode 编码的基础知识，folly::String 对 Unicode 的支持情况，以及处理 Unicode 字符串的最佳实践。
5.1.1 Unicode 编码基础 (Basics of Unicode Encoding)
Unicode 编码是为了解决传统字符编码方案的局限性而诞生的。传统的字符编码，如 ASCII 和 ISO-8859-1，只能表示有限的字符集，无法覆盖全球范围内的所有语言字符。Unicode 的目标是为世界上每一个字符分配一个唯一的数字标识，称为码点（Code Point）。
① 码点、字符集与编码方案
⚝ 字符集（Character Set）：是一个抽象的概念，指的是所有字符的集合。Unicode 字符集包含了世界上几乎所有的字符，包括各种语言的字母、符号、标点、表情符号等等。
⚝ 码点（Code Point）：是 Unicode 字符集中每个字符的唯一数字标识。码点通常以 U+ 开头，后跟十六进制数字表示，例如，字母 'A' 的码点是 U+0041，汉字 '中' 的码点是 U+4E2D，表情符号 '😀' 的码点是 U+1F600。Unicode 的码点空间被划分为 17 个平面（Plane），每个平面包含 \(2^{16}\) 个码点，总共可以表示超过一百万个字符。
⚝ 编码方案（Encoding Scheme）：是如何将 Unicode 码点表示为计算机可以存储和传输的字节序列的方法。常见的 Unicode 编码方案包括 UTF-8、UTF-16 和 UTF-32。
② 常见的 Unicode 编码方案
⚝ UTF-8 (8-bit Unicode Transformation Format)：是一种变长编码方案，使用 1 到 4 个字节表示一个码点。UTF-8 的主要优点是兼容 ASCII 编码，ASCII 字符在 UTF-8 中使用单字节表示，这使得 UTF-8 在处理英文文本时非常高效。同时，UTF-8 也能够表示 Unicode 字符集中的所有字符。UTF-8 是互联网上最常用的 Unicode 编码方案。
⚝ UTF-16 (16-bit Unicode Transformation Format)：也是一种变长编码方案，使用 2 或 4 个字节表示一个码点。UTF-16 主要用于 Windows 操作系统和 Java、JavaScript 等编程语言的内部字符表示。UTF-16 可以直接表示 BMP（基本多文种平面，Basic Multilingual Plane）中的字符，对于 BMP 之外的字符，则需要使用代理对（Surrogate Pair）进行编码，使用两个 16-bit 码元表示。
⚝ UTF-32 (32-bit Unicode Transformation Format)：是一种定长编码方案，每个码点都使用 4 个字节表示。UTF-32 的优点是编码简单，可以直接通过码点值访问字符，缺点是存储空间占用较大，尤其是在处理主要由 ASCII 字符组成的文本时，会浪费大量的存储空间。
③ 字节序 (Endianness)
对于 UTF-16 和 UTF-32 等多字节编码方案，还需要考虑字节序的问题，即多字节数据在内存中的存储顺序。字节序分为大端序（Big-Endian）和小端序（Little-Endian）。
⚝ 大端序（Big-Endian）：高位字节存储在低地址，低位字节存储在高地址，符合人类的阅读习惯。
⚝ 小端序（Little-Endian）：低位字节存储在低地址，高位字节存储在高地址，符合计算机的存储习惯。
UTF-8 由于是单字节编码，不存在字节序的问题。UTF-16 和 UTF-32 通常会使用 BOM（Byte Order Mark，字节顺序标记）来指示字节序。BOM 是一个特殊的 Unicode 字符 U+FEFF，在 UTF-16 和 UTF-32 编码中，BOM 会被编码为特定的字节序列，接收方可以通过 BOM 来判断字节序。
理解 Unicode 编码的基础知识对于正确处理多语言文本至关重要。在后续的章节中，我们将看到 folly::String 如何处理 Unicode 编码，以及在实际应用中需要注意的事项。
5.1.2 folly::String 对 UTF-8 等 Unicode 编码的支持 (Support for UTF-8 and Other Unicode Encodings in folly::String)
folly::String 库的核心设计目标是高性能和效率，它主要关注字节序列的处理，而不是字符语义。这意味着 folly::String 本身并不直接感知 Unicode 编码，它将字符串视为简单的字节序列进行处理。然而，由于 UTF-8 编码在互联网和现代软件系统中占据主导地位，folly::String 在设计和使用时，实际上可以很好地支持 UTF-8 编码。
① folly::String 的字节序列处理方式
folly::StringPiece 和 folly::fbstring 都是基于字节序列进行操作的。例如，StringPiece::length() 返回的是字节长度，StringPiece::substr() 返回的是字节子串，StringPiece::find() 查找的是字节序列。这种字节序列处理方式使得 folly::String 非常高效，因为它避免了复杂的字符编码解析和转换操作。
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece sp = "你好world"; // UTF-8 编码
6
std::cout << "Length in bytes: " << sp.length() << std::endl; // 输出字节长度，UTF-8 中汉字通常占 3 个字节，英文字符占 1 个字节
7
folly::StringPiece sub_sp = sp.substr(0, 5); // 截取前 5 个字节
8
std::cout << "Substring (bytes): " << sub_sp << std::endl; // 可能截断 UTF-8 字符
9
return 0;
10
}
在上面的例子中，StringPiece sp = "你好world" 存储的是 UTF-8 编码的字符串。sp.length() 返回的是字节长度，而不是字符个数。sp.substr(0, 5) 截取的是前 5 个字节，如果截断的位置正好在一个 UTF-8 字符的中间，就会导致截断的子串不是一个有效的 UTF-8 字符串。
② UTF-8 编码的兼容性
尽管 folly::String 是字节序列处理的，但由于 UTF-8 编码的特性，folly::String 在处理 UTF-8 字符串时仍然非常有用。UTF-8 的一个重要特性是，对于 ASCII 字符（码点 U+0000 到 U+007F），UTF-8 编码与 ASCII 编码完全相同，都是单字节表示。这意味着，对于主要由 ASCII 字符组成的文本，folly::String 的字节操作可以直接对应到字符操作。
此外，UTF-8 编码具有自同步性（Self-synchronization）。UTF-8 编码的每个字节都包含了足够的信息来判断它是否是一个多字节字符的起始字节、中间字节或结束字节。这使得在处理 UTF-8 字节流时，即使从中间位置开始解析，也能够快速找到字符的边界，并恢复到正确的解析状态。
③ folly::String 与 UTF-8 的结合使用
在实际应用中，如果你的字符串数据主要是 UTF-8 编码的，你可以直接使用 folly::StringPiece 和 folly::fbstring 进行处理。对于一些基本的字符串操作，如查找 ASCII 字符、分割 ASCII 分隔符、比较 ASCII 字符串等，folly::String 的字节操作通常能够满足需求，并且效率很高。
然而，当需要进行字符级别的操作，例如，获取字符串的字符个数、按字符截取子串、字符级别的查找和替换、大小写转换、Unicode 规范化等操作时，folly::String 的字节操作就可能无法正确处理 UTF-8 字符串。在这种情况下，你需要借助专门的 Unicode 处理库，例如 ICU (International Components for Unicode) 等。
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
#include <unicode/unistr.h> // ICU UnicodeString
4
5
int main() {
6
folly::StringPiece sp = "你好world😀"; // UTF-8 编码
7
icu::UnicodeString ustr = icu::UnicodeString::fromUTF8(icu::StringPiece(sp.data(), sp.length())); // StringPiece to ICU UnicodeString
8
std::cout << "Character length (ICU): " << ustr.length() << std::endl; // 使用 ICU 获取字符长度
9
icu::UnicodeString sub_ustr = ustr.tempSubString(0, 3); // 使用 ICU 按字符截取子串
10
std::string sub_utf8;
11
sub_ustr.toUTF8String(sub_utf8); // UnicodeString to UTF-8 string
12
std::cout << "Substring (characters, ICU): " << sub_utf8 << std::endl;
13
return 0;
14
}
上面的例子展示了如何结合 ICU 库和 folly::String 来处理 UTF-8 字符串。首先，将 folly::StringPiece 转换为 ICU 的 UnicodeString 对象，然后使用 ICU 提供的 Unicode 字符处理功能，例如 ustr.length() 获取字符长度，ustr.tempSubString(0, 3) 按字符截取子串。最后，将处理后的 UnicodeString 对象转换回 UTF-8 字符串。
总结来说，folly::String 本身是字节序列处理的，但可以很好地支持 UTF-8 编码。在处理 UTF-8 字符串时，如果只需要字节级别的操作，可以直接使用 folly::String。如果需要字符级别的操作，则需要结合专门的 Unicode 处理库，例如 ICU。
5.1.3 处理 Unicode 字符串的最佳实践 (Best Practices for Handling Unicode Strings)
处理 Unicode 字符串需要特别注意字符编码和字符语义，以避免出现乱码、截断字符等问题。以下是一些处理 Unicode 字符串的最佳实践，尤其是在使用 folly::String 的场景下。
① 明确字符串的编码方式
在处理字符串之前，首先要明确字符串的编码方式。最常见的 Unicode 编码方式是 UTF-8。如果你的程序需要处理多语言文本，强烈建议统一使用 UTF-8 编码。在程序中，应该明确指定字符串的编码方式，避免隐式编码转换带来的问题。
② 使用合适的库进行 Unicode 处理
当需要进行字符级别的 Unicode 操作时，不要尝试自己编写代码来解析和处理 UTF-8 编码，而应该使用成熟的 Unicode 处理库，例如 ICU。ICU 提供了丰富的 Unicode 功能，包括字符编码转换、字符属性查询、文本 Collation（排序规则）、格式化、正则表达式等等。使用 ICU 可以大大简化 Unicode 处理的复杂性，并提高程序的可靠性和性能。
③ 区分字节操作和字符操作
folly::String 提供的主要是字节操作。在处理 UTF-8 字符串时，需要区分字节操作和字符操作。
⚝ 字节操作：例如，length() 返回字节长度，substr() 截取字节子串，find() 查找字节序列。字节操作通常效率较高，适用于处理 ASCII 字符为主的文本，或者只需要字节级别的处理，例如，网络协议解析、文件格式解析等。
⚝ 字符操作：例如，获取字符个数、按字符截取子串、字符级别的查找和替换、大小写转换、Unicode 规范化等。字符操作需要进行 UTF-8 解码，并根据 Unicode 字符的语义进行处理。字符操作通常需要使用 Unicode 处理库，例如 ICU。
④ 注意字符串的边界问题
在进行字符串分割、截取子串等操作时，需要特别注意字符边界问题。对于 UTF-8 编码，一个字符可能由 1 到 4 个字节组成。如果按字节截取子串，可能会截断一个 UTF-8 字符，导致乱码或解析错误。因此，在处理 UTF-8 字符串时，应该尽量使用字符级别的操作，或者在字节操作之后进行 UTF-8 验证，确保截取的子串是有效的 UTF-8 字符串。
⑤ 考虑性能和效率
Unicode 处理通常比 ASCII 处理更复杂，性能开销也更大。在性能敏感的场景下，需要仔细考虑 Unicode 处理的性能影响。可以采取一些优化策略，例如：
⚝ 延迟解码：只在需要字符级别操作时才进行 UTF-8 解码。
⚝ 批量处理：尽量批量处理字符串，减少 Unicode 处理库的调用次数。
⚝ 使用高效的 Unicode 库：选择性能优秀的 Unicode 处理库，例如 ICU。
⚝ 避免不必要的字符操作：如果只需要字节级别的操作，尽量避免使用字符操作。
⑥ 测试和验证
处理 Unicode 字符串时，务必进行充分的测试和验证，确保程序能够正确处理各种 Unicode 字符和编码情况。可以使用各种 Unicode 测试用例，包括不同语言的文本、特殊字符、表情符号、组合字符、控制字符等等，来测试程序的 Unicode 处理能力。
遵循以上最佳实践，可以帮助你更好地处理 Unicode 字符串，避免常见的 Unicode 相关问题，并提高程序的国际化和本地化能力。在使用 folly::String 处理 Unicode 字符串时，要根据实际需求选择合适的处理方式，平衡性能和正确性。
5.2 自定义字符串类与 folly::String 的集成 (Integrating Custom String Classes with folly::String)
folly::String 库提供了高效的字符串表示和操作，但在某些特定场景下，你可能需要自定义字符串类，以满足特定的需求。例如，你可能需要一个具有特定内存管理策略的字符串类，或者需要集成到已有的代码库中，而该代码库使用了自定义的字符串类。本节将探讨如何将自定义字符串类与 folly::String 库进行集成，特别是如何与 folly::StringPiece 兼容，以及如何扩展 folly::fbstring 的功能。
5.2.1 设计自定义字符串类的考量 (Considerations for Designing Custom String Classes)
在设计自定义字符串类时，需要考虑以下几个关键方面：
① 内存管理 (Memory Management)
内存管理是自定义字符串类设计中最重要的考虑因素之一。不同的内存管理策略会直接影响字符串的性能和资源消耗。
⚝ 栈上分配 (Stack Allocation)：对于长度较小的字符串，可以考虑在栈上分配内存。栈上分配的优点是速度快，无需手动管理内存，缺点是栈空间有限，不适合存储大字符串。小字符串优化 (SSO, Small String Optimization) 技术通常会结合栈上分配和堆上分配，对于小字符串使用栈上空间，对于大字符串使用堆上空间。
⚝ 堆上分配 (Heap Allocation)：对于长度不确定的字符串，或者可能很大的字符串，通常需要在堆上分配内存。堆上分配的优点是可以动态调整内存大小，适合存储各种长度的字符串，缺点是内存分配和释放的开销较大，需要手动或自动管理内存。
⚝ 自定义分配器 (Custom Allocator)：为了更精细地控制内存分配，可以使用自定义内存分配器。自定义分配器可以实现各种内存管理策略，例如，内存池、arena 分配器等，以优化特定场景下的内存分配性能。folly::fbstring 就支持自定义分配器。
⚝ 写时复制 (COW, Copy-on-Write)：写时复制是一种延迟复制的优化技术。当多个字符串对象共享同一份字符串数据时，只有在需要修改字符串内容时，才会真正进行数据复制。写时复制可以减少不必要的内存复制，提高性能，但实现较为复杂，且在多线程环境下需要考虑线程安全问题。folly::fbstring 早期版本使用了写时复制，但后来为了简化实现和提高多线程性能，移除了写时复制。
② 字符编码 (Character Encoding)
自定义字符串类需要明确支持的字符编码。常见的选择包括：
⚝ ASCII：只支持 ASCII 字符，简单高效，但不支持非 ASCII 字符。
⚝ UTF-8：支持 Unicode 字符集，兼容 ASCII，是互联网上最常用的编码方式。
⚝ UTF-16：支持 Unicode 字符集，主要用于 Windows 和 Java 等平台。
⚝ UTF-32：支持 Unicode 字符集，定长编码，实现简单，但存储空间占用较大。
⚝ 其他编码：例如，GBK、Latin-1 等，根据具体应用场景选择。
如果需要支持多语言文本，强烈建议选择 UTF-8 编码。自定义字符串类需要明确指定字符编码，并提供相应的字符操作接口。
③ API 设计 (API Design)
自定义字符串类的 API 设计应该考虑到易用性、效率和功能性。可以参考 std::string 和 folly::fbstring 的 API 设计，提供常用的字符串操作方法，例如：
⚝ 构造函数和赋值运算符：支持从 C 风格字符串、std::string、folly::StringPiece 等类型构造和赋值。
⚝ 容量和长度相关方法：length()、size()、capacity()、empty()、reserve()、shrink_to_fit() 等。
⚝ 元素访问：operator[]、at()、data()、c_str() 等。
⚝ 修改字符串内容的方法：append()、push_back()、insert()、erase()、replace()、clear() 等。
⚝ 查找和匹配方法：find()、rfind()、find_first_of()、find_first_not_of()、find_last_of()、find_last_not_of()、startsWith()、endsWith() 等。
⚝ 子串操作方法：substr()。
⚝ 比较运算符：operator==、operator!=、operator<、operator<=、operator>、operator>=。
⚝ 与其他类型的转换方法：to_string()、to_int()、to_double() 等。
④ 性能 (Performance)
性能是 folly::String 库的核心优势。在设计自定义字符串类时，也应该关注性能。可以从以下几个方面优化性能：
⚝ 减少内存分配和释放：使用内存池、arena 分配器、SSO 等技术，减少内存分配和释放的次数和开销。
⚝ 避免不必要的内存复制：使用写时复制、移动语义、引用计数等技术，减少内存复制的次数和开销。
⚝ 优化常用操作：针对常用的字符串操作，例如，查找、比较、拼接等，进行算法和数据结构的优化。
⚝ 利用 SIMD 指令：对于一些字符串操作，例如，查找、比较等，可以利用 SIMD (Single Instruction, Multiple Data) 指令进行并行处理，提高性能。
⑤ 线程安全 (Thread Safety)
如果自定义字符串类需要在多线程环境下使用，需要考虑线程安全问题。常见的线程安全策略包括：
⚝ 互斥锁 (Mutex)：使用互斥锁保护共享数据，保证同一时间只有一个线程可以访问共享数据。互斥锁的优点是实现简单，缺点是性能开销较大，可能导致线程阻塞。
⚝ 原子操作 (Atomic Operations)：使用原子操作对共享数据进行原子性操作，避免数据竞争。原子操作的优点是性能较高，缺点是只适用于简单的操作，例如，计数器、标志位等。
⚝ 无锁数据结构 (Lock-Free Data Structures)：使用无锁数据结构，例如，无锁队列、无锁哈希表等，避免使用锁，提高并发性能。无锁数据结构的实现较为复杂，需要仔细考虑 ABA 问题等。
⚝ 线程局部存储 (Thread-Local Storage)：为每个线程分配独立的存储空间，避免线程之间共享数据，从而避免线程安全问题。线程局部存储的优点是线程安全，性能较高，缺点是内存消耗较大。
在设计自定义字符串类时，需要根据具体的应用场景和需求，综合考虑以上各个方面，做出合理的权衡和选择。
5.2.2 与 folly::StringPiece 兼容 (Compatibility with folly::StringPiece)
folly::StringPiece 是 folly::String 库中非常重要的一个组件，它提供了高效的字符串视图，避免了不必要的内存复制。为了更好地与 folly::String 库集成，自定义字符串类应该尽可能地与 folly::StringPiece 兼容。
① 提供到 StringPiece 的隐式转换
最简单的方式是为自定义字符串类提供到 folly::StringPiece 的隐式转换。这样，自定义字符串类的对象就可以直接传递给接受 folly::StringPiece 参数的函数，无需显式转换。
1
#include <folly/StringPiece.h>
2
#include <string>
3
4
class MyString {
5
public:
6
MyString(const std::string& str) : str_(str) {}
7
// ... 其他成员函数 ...
8
9
// 提供到 folly::StringPiece 的隐式转换
10
operator folly::StringPiece() const {
11
return folly::StringPiece(str_);
12
}
13
14
private:
15
std::string str_;
16
};
17
18
void processString(folly::StringPiece sp) {
19
// ... 使用 StringPiece 处理字符串 ...
20
std::cout << "StringPiece length: " << sp.length() << std::endl;
21
}
22
23
int main() {
24
MyString my_str("Hello, MyString!");
25
processString(my_str); // 隐式转换为 StringPiece
26
return 0;
27
}
在上面的例子中，MyString 类提供了 operator folly::StringPiece() const 隐式转换运算符。这样，MyString 对象 my_str 就可以直接作为 processString 函数的参数，隐式转换为 folly::StringPiece 类型。
② 实现 StringPiece 的接口
更进一步，自定义字符串类可以实现 folly::StringPiece 的常用接口，例如，length()、data()、substr()、find() 等。这样，自定义字符串类就可以像 folly::StringPiece 一样使用，可以更方便地与 folly::String 库的其他组件进行交互。
1
#include <folly/StringPiece.h>
2
#include <string>
3
4
class MyString {
5
public:
6
MyString(const std::string& str) : str_(str) {}
7
// ... 其他成员函数 ...
8
9
// 实现 StringPiece 的接口
10
size_t length() const { return str_.length(); }
11
const char* data() const { return str_.data(); }
12
folly::StringPiece substr(size_t pos, size_t count = folly::StringPiece::npos) const {
13
return folly::StringPiece(str_).substr(pos, count);
14
}
15
size_t find(folly::StringPiece needle, size_t pos = 0) const {
16
return folly::StringPiece(str_).find(needle, pos);
17
}
18
// ... 其他 StringPiece 接口 ...
19
20
private:
21
std::string str_;
22
};
23
24
void processStringPieceLike(folly::StringPiece sp) {
25
std::cout << "StringPiece-like length: " << sp.length() << std::endl;
26
}
27
28
int main() {
29
MyString my_str("Hello, MyString-like!");
30
processStringPieceLike(my_str); // 可以像 StringPiece 一样使用
31
std::cout << "Substring: " << my_str.substr(7, 10) << std::endl; // 调用 substr() 接口
32
return 0;
33
}
在上面的例子中，MyString 类实现了 StringPiece 的部分接口，例如，length()、data()、substr()、find()。这样，MyString 对象 my_str 就可以像 folly::StringPiece 一样使用，可以调用 substr() 等方法。
③ 使用 StringPiece 作为成员
另一种方式是在自定义字符串类内部使用 folly::StringPiece 作为成员，用于表示字符串的视图。这种方式可以更好地利用 folly::StringPiece 的高效性，并简化自定义字符串类的实现。
1
#include <folly/StringPiece.h>
2
#include <string>
3
4
class MyStringWrapper {
5
public:
6
MyStringWrapper(const std::string& str) : sp_(str) {}
7
// ... 其他成员函数 ...
8
9
folly::StringPiece getStringPiece() const { return sp_; }
10
11
private:
12
folly::StringPiece sp_; // 使用 StringPiece 作为成员
13
};
14
15
void processStringPieceWrapper(const MyStringWrapper& wrapper) {
16
folly::StringPiece sp = wrapper.getStringPiece();
17
std::cout << "StringPiece wrapper length: " << sp.length() << std::endl;
18
}
19
20
int main() {
21
MyStringWrapper my_wrapper("Hello, StringPiece Wrapper!");
22
processStringPieceWrapper(my_wrapper);
23
return 0;
24
}
在上面的例子中，MyStringWrapper 类内部使用 folly::StringPiece sp_ 作为成员，用于表示字符串的视图。getStringPiece() 方法返回内部的 StringPiece 对象。这种方式将字符串数据的存储和视图分离，可以更灵活地处理字符串。
通过以上几种方式，自定义字符串类可以很好地与 folly::StringPiece 兼容，从而更好地融入 folly::String 库的生态系统，并利用 folly::StringPiece 带来的性能优势。
5.2.3 扩展 folly::fbstring 的功能 (Extending the Functionality of folly::fbstring)
folly::fbstring 已经是一个功能强大且高性能的字符串类。然而，在某些特定场景下，你可能需要扩展 fbstring 的功能，以满足更特殊的需求。folly::fbstring 的设计考虑了可扩展性，你可以通过以下几种方式扩展其功能：
① 继承 fbstring 并添加新方法
最直接的方式是继承 folly::fbstring 类，并添加新的成员函数，以扩展其功能。例如，你可以添加一些自定义的字符串操作方法，或者集成一些第三方库的功能。
1
#include <folly/FBString.h>
2
#include <iostream>
3
4
class MyFBString : public folly::fbstring {
5
public:
6
using folly::fbstring::fbstring; // 继承构造函数
7
8
// 添加自定义方法：反转字符串
9
MyFBString reverse() const {
10
MyFBString reversed_str = *this;
11
std::reverse(reversed_str.begin(), reversed_str.end());
12
return reversed_str;
13
}
14
15
// 添加自定义方法：转换为大写
16
MyFBString toUpper() const {
17
MyFBString upper_str = *this;
18
std::transform(upper_str.begin(), upper_str.end(), upper_str.begin(), ::toupper);
19
return upper_str;
20
}
21
};
22
23
int main() {
24
MyFBString my_fbstr("hello, fbstring extension!");
25
MyFBString reversed_str = my_fbstr.reverse();
26
MyFBString upper_str = my_fbstr.toUpper();
27
28
std::cout << "Original: " << my_fbstr << std::endl;
29
std::cout << "Reversed: " << reversed_str << std::endl;
30
std::cout << "Upper: " << upper_str << std::endl;
31
32
return 0;
33
}
在上面的例子中，MyFBString 类继承了 folly::fbstring，并添加了 reverse() 和 toUpper() 两个自定义方法，分别用于反转字符串和转换为大写。通过继承，MyFBString 类可以直接使用 fbstring 的所有功能，并在此基础上进行扩展。
② 使用非成员函数进行扩展
另一种扩展 fbstring 功能的方式是使用非成员函数。你可以编写一些独立的函数，接受 folly::fbstring 对象作为参数，实现额外的字符串操作。这种方式更加灵活，不会修改 fbstring 类的定义，也更容易进行模块化和复用。
1
#include <folly/FBString.h>
2
#include <iostream>
3
#include <algorithm>
4
#include <cctype>
5
6
// 非成员函数：反转 fbstring
7
folly::fbstring reverseFBString(const folly::fbstring& str) {
8
folly::fbstring reversed_str = str;
9
std::reverse(reversed_str.begin(), reversed_str.end());
10
return reversed_str;
11
}
12
13
// 非成员函数：转换为大写 fbstring
14
folly::fbstring toUpperFBString(const folly::fbstring& str) {
15
folly::fbstring upper_str = str;
16
std::transform(upper_str.begin(), upper_str.end(), upper_str.begin(), ::toupper);
17
return upper_str;
18
}
19
20
int main() {
21
folly::fbstring my_fbstr("hello, fbstring non-member extension!");
22
folly::fbstring reversed_str = reverseFBString(my_fbstr);
23
folly::fbstring upper_str = toUpperFBString(my_fbstr);
24
25
std::cout << "Original: " << my_fbstr << std::endl;
26
std::cout << "Reversed: " << reversed_str << std::endl;
27
std::cout << "Upper: " << upper_str << std::endl;
28
29
return 0;
30
}
在上面的例子中，reverseFBString() 和 toUpperFBString() 是两个非成员函数，分别用于反转和转换为大写 folly::fbstring 对象。这种方式不会修改 fbstring 类的定义，更加灵活和模块化。
③ 使用扩展库或工具函数
还可以通过创建扩展库或工具函数的方式来扩展 fbstring 的功能。例如，你可以创建一个专门处理 Unicode 字符串的库，其中包含各种 Unicode 相关的字符串操作函数，这些函数可以接受 folly::fbstring 或 folly::StringPiece 对象作为参数。或者，你可以编写一些通用的字符串工具函数，例如，字符串格式化、字符串解析、字符串验证等，这些工具函数可以与 folly::String 库配合使用。
通过以上几种方式，你可以灵活地扩展 folly::fbstring 的功能，以满足各种不同的需求。在扩展 fbstring 功能时，要尽量保持代码的简洁、高效和可维护性，并充分利用 folly::String 库已有的功能和优势。
5.3 folly::String 在大型项目中的应用案例 (Application Cases of folly::String in Large-Scale Projects)
folly::String 库因其高性能和效率，在大型项目中得到了广泛应用。尤其是在 Facebook 内部，folly::String 是核心的基础组件之一，被用于各种关键的系统和服务中。本节将探讨 folly::String 在大型项目中的应用案例，包括 Facebook 内部的使用情况，开源项目中的应用案例，以及 folly::String 的未来发展趋势。
5.3.1 Facebook 内部如何使用 folly::String (How Facebook Uses folly::String Internally)
Facebook 作为一个超大型的互联网公司，其内部系统和服务对性能和效率有着极高的要求。folly::String 库作为 Facebook 开源的 C++ 库 Folly 的一部分，在 Facebook 内部得到了广泛的应用，几乎所有的 C++ 项目都会直接或间接地使用 folly::String。
① 高性能服务器开发
Facebook 的许多核心服务器都是使用 C++ 开发的，例如，Web 服务器、消息队列服务器、数据库服务器、缓存服务器等。这些服务器需要处理海量的请求和数据，对字符串操作的性能要求非常高。folly::String 库，特别是 folly::fbstring 和 folly::StringPiece，因其高效的内存管理和字符串操作，成为 Facebook 服务器开发的首选字符串库。
⚝ Web 服务器：Facebook 的 Web 服务器需要处理大量的 HTTP 请求和响应，其中包含了大量的字符串数据，例如，URL、Header、Cookie、Body 等。folly::StringPiece 被广泛用于解析和处理 HTTP 请求和响应，避免不必要的字符串复制。folly::fbstring 则用于构建和存储 HTTP 响应，以及在服务器内部进行字符串操作。
⚝ 消息队列服务器：Facebook 的消息队列服务器需要处理大量的消息数据，消息内容通常是字符串形式。folly::fbstring 被用于高效地存储和传输消息数据。folly::StringPiece 则用于解析消息协议和消息内容。
⚝ 数据库服务器：Facebook 的数据库服务器需要处理大量的 SQL 查询和数据存储，SQL 语句和数据记录中都包含大量的字符串。folly::fbstring 被用于存储和操作数据库中的字符串数据。folly::StringPiece 则用于解析 SQL 语句和查询结果。
⚝ 缓存服务器：Facebook 的缓存服务器需要存储大量的键值对数据，键和值通常都是字符串形式。folly::fbstring 被用于高效地存储缓存数据。folly::StringPiece 则用于解析缓存协议和键值数据。
② 日志处理与分析
Facebook 的系统和服务会产生大量的日志数据，日志数据通常是文本形式的字符串。folly::String 库被广泛用于日志处理和分析系统中。
⚝ 日志收集：日志收集系统需要高效地读取和传输日志数据。folly::fbstring 被用于读取和缓存日志文件内容。folly::StringPiece 则用于解析日志格式和提取关键信息。
⚝ 日志解析：日志解析系统需要解析各种格式的日志数据，提取有用的信息，例如，时间戳、请求 ID、用户 ID、错误信息等。folly::StringPiece 提供了丰富的字符串查找和分割方法，方便进行日志解析。
⚝ 日志分析：日志分析系统需要对海量的日志数据进行分析，例如，统计指标、异常检测、趋势分析等。folly::String 库的高效性能可以加速日志分析过程。
③ 配置管理
Facebook 的系统和服务通常需要读取和解析大量的配置文件，配置文件通常是文本形式的字符串。folly::String 库被用于配置管理系统中。
⚝ 配置文件读取：配置管理系统需要读取各种格式的配置文件，例如，JSON、YAML、XML、INI 等。folly::fbstring 被用于读取配置文件内容。
⚝ 配置解析：配置管理系统需要解析配置文件内容，提取配置项和配置值。folly::StringPiece 提供了方便的字符串查找和分割方法，用于解析配置文件。
⚝ 配置验证：配置管理系统需要验证配置项和配置值的合法性。folly::String 库可以用于字符串的格式验证和内容检查。
④ 通用工具库
folly::String 库本身也是一个通用的字符串工具库，提供了许多实用的字符串操作函数，例如，folly::stringPrintf、folly::to<T>()、folly::hash_value() 等。这些工具函数在 Facebook 内部的各种项目中都得到了广泛的应用，提高了开发效率和代码质量。
总而言之，folly::String 库在 Facebook 内部的应用非常广泛，几乎渗透到各个技术领域。其高性能、高效率、易用性等优点，使得 folly::String 成为 Facebook 内部 C++ 开发的基础设施之一。
5.3.2 开源项目中使用 folly::String 的案例分析 (Case Studies of Using folly::String in Open Source Projects)
除了 Facebook 内部，folly::String 库也在许多开源项目中得到了应用。这些开源项目涵盖了不同的领域，例如，数据库、消息队列、网络库、游戏引擎等。以下是一些开源项目中使用 folly::String 的案例分析：
① RocksDB
RocksDB 是一个由 Facebook 开发的高性能嵌入式键值存储引擎，被广泛应用于各种需要高性能数据存储的场景。RocksDB 内部大量使用了 folly::String 库，特别是 folly::StringPiece 和 folly::fbstring。
⚝ 键值存储：RocksDB 的核心功能是键值存储，键和值都是字节序列。RocksDB 使用 folly::StringPiece 来表示键和值的视图，避免不必要的内存复制。folly::fbstring 则用于存储键和值的数据。
⚝ 日志和 WAL (Write-Ahead Logging)：RocksDB 使用日志和 WAL 来保证数据持久性和事务性。日志和 WAL 文件中包含了大量的字符串数据。RocksDB 使用 folly::fbstring 来高效地写入和读取日志和 WAL 文件。
⚝ 配置管理：RocksDB 允许用户通过配置文件来调整引擎的各种参数。RocksDB 使用 folly::StringPiece 来解析配置文件内容。
② Proxygen
Proxygen 是 Facebook 开发的高性能 HTTP 框架，用于构建高性能 HTTP 服务器和客户端。Proxygen 内部也大量使用了 folly::String 库。
⚝ HTTP 解析：Proxygen 需要解析 HTTP 请求和响应，包括 URL、Header、Body 等。Proxygen 使用 folly::StringPiece 来高效地解析 HTTP 协议。
⚝ HTTP 生成：Proxygen 需要生成 HTTP 响应，包括 Header、Body 等。Proxygen 使用 folly::fbstring 来构建 HTTP 响应。
⚝ 连接管理：Proxygen 需要管理大量的 HTTP 连接，包括连接的建立、关闭、复用等。Proxygen 使用 folly::String 库来处理连接相关的字符串数据。
③ Wangle
Wangle 是 Facebook 开发的网络应用框架，用于构建高性能、高可靠性的网络服务。Wangle 内部也使用了 folly::String 库。
⚝ 协议解析：Wangle 支持多种网络协议，例如，TCP、UDP、HTTP、Thrift 等。Wangle 使用 folly::StringPiece 来解析各种网络协议。
⚝ 数据序列化：Wangle 需要对网络数据进行序列化和反序列化。Wangle 使用 folly::fbstring 来存储和操作序列化后的数据。
⚝ 中间件：Wangle 提供了丰富的中间件机制，用于处理网络请求和响应。中间件通常需要处理字符串形式的请求和响应数据。Wangle 使用 folly::String 库来支持中间件的开发。
④ 其他开源项目
除了以上几个案例，还有许多其他开源项目也使用了 folly::String 库，例如：
⚝ folly itself：Folly 库自身就大量使用了 folly::String 库，这是理所当然的。
⚝ Fizz：Facebook 开发的 TLS 库 Fizz 也使用了 folly::String 库。
⚝ mvfst：Facebook 开发的 QUIC 协议库 mvfst 也使用了 folly::String 库。
⚝ 一些游戏引擎：一些 C++ 游戏引擎也开始使用 folly::String 库，以提高字符串处理的性能。
这些开源项目使用 folly::String 库，主要是看中了其高性能和效率，以及与 Folly 库其他组件的良好集成性。folly::String 库在这些项目中发挥了重要的作用，提高了项目的性能和可靠性。
5.3.3 folly::String 的未来发展趋势 (Future Development Trends of folly::String)
folly::String 库作为一个活跃的开源项目，其未来发展趋势主要集中在以下几个方面：
① 持续性能优化
性能一直是 folly::String 库的核心目标。未来，folly::String 库将继续进行性能优化，包括：
⚝ 更高效的内存管理：探索更先进的内存管理策略，例如，更精细的内存池、更智能的内存分配算法等，以进一步减少内存分配和释放的开销。
⚝ SIMD 和向量化优化：充分利用现代 CPU 的 SIMD 指令集，对常用的字符串操作进行向量化优化，提高并行处理能力。
⚝ 算法优化：继续优化字符串操作的算法，例如，查找算法、比较算法、拼接算法等，提高算法效率。
⚝ 编译期优化：利用 C++ 的编译期计算能力，将一些字符串操作在编译期完成，减少运行期开销。
② 增强 Unicode 支持
随着全球化的深入，Unicode 支持越来越重要。未来，folly::String 库可能会增强对 Unicode 的支持，例如：
⚝ 内置 UTF-8 支持：考虑在 folly::fbstring 中内置 UTF-8 支持，提供更方便的 Unicode 字符操作接口。
⚝ Unicode 工具函数：增加更多 Unicode 相关的工具函数，例如，Unicode 规范化、字符属性查询、文本 Collation 等。
⚝ 与 ICU 等 Unicode 库的更好集成：进一步加强与 ICU 等 Unicode 库的集成，提供更全面的 Unicode 支持。
③ 扩展功能和 API
folly::String 库可能会继续扩展功能和 API，以满足更多应用场景的需求，例如：
⚝ 正则表达式支持：考虑在 folly::StringPiece 或 folly::fbstring 中增加正则表达式支持，方便进行复杂的字符串匹配和查找。
⚝ 字符串格式化增强：增强 folly::stringPrintf 的功能，提供更灵活的格式化选项和性能优化。
⚝ 与其他 Folly 组件的更好集成：进一步加强与 Folly 库其他组件的集成，例如，folly::IOBuf、folly::Format 等，提供更完善的 Folly 生态系统。
④ 社区合作与发展
folly::String 库是一个开源项目，其发展离不开社区的贡献和合作。未来，folly::String 库将继续加强社区合作，吸引更多的开发者参与到项目中来，共同推动 folly::String 库的发展。
⚝ 接受社区贡献：积极接受社区的代码贡献、Bug 报告、功能建议等，共同完善 folly::String 库。
⚝ 参与社区讨论：积极参与社区的讨论，了解用户需求，解决用户问题，共同推动 folly::String 库的发展方向。
⚝ 与其他开源项目合作：加强与其他开源项目的合作，例如，与其他 C++ 库、Unicode 库、网络库等进行集成，共同构建更强大的开源生态系统。
总而言之，folly::String 库的未来发展趋势是持续优化性能、增强 Unicode 支持、扩展功能和 API、加强社区合作与发展。folly::String 库将继续朝着高性能、高效率、易用性、通用性的方向发展，为 C++ 开发者提供更强大、更可靠的字符串处理工具。
END_OF_CHAPTER