007 《Folly Dynamic.h 权威指南：C++ 动态类型实战》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 走进 Dynamic.h (Introduction to Dynamic.h)
▮▮▮▮▮▮▮ 1.1 什么是动态类型 (What is Dynamic Typing)
▮▮▮▮▮▮▮ 1.2 为什么选择 folly::dynamic (Why Choose folly::dynamic)
▮▮▮▮▮▮▮ 1.3 folly::dynamic 的应用场景 (Use Cases of folly::dynamic)
▮▮▮▮▮▮▮ 1.4 环境搭建与快速上手 (Environment Setup and Quick Start)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 Folly 库的安装与配置 (Installation and Configuration of Folly Library)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 第一个 folly::dynamic 程序 (Your First folly::dynamic Program)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 dynamic 的基本数据类型 (Basic Data Types of dynamic)
▮▮▮▮ 2. chapter 2： dynamic 的核心概念与操作 (Core Concepts and Operations of dynamic)
▮▮▮▮▮▮▮ 2.1 dynamic 对象的创建与初始化 (Creation and Initialization of dynamic Objects)
▮▮▮▮▮▮▮ 2.2 dynamic 的类型系统 (Type System of dynamic)
▮▮▮▮▮▮▮ 2.3 访问 dynamic 对象的值 (Accessing Values of dynamic Objects)
▮▮▮▮▮▮▮ 2.4 修改 dynamic 对象的值 (Modifying Values of dynamic Objects)
▮▮▮▮▮▮▮ 2.5 dynamic 对象的类型判断与转换 (Type Checking and Conversion of dynamic Objects)
▮▮▮▮▮▮▮ 2.6 dynamic 与容器的结合 (dynamic and Containers)
▮▮▮▮ 3. chapter 3： dynamic 与 JSON (dynamic and JSON)
▮▮▮▮▮▮▮ 3.1 JSON 格式简介 (Introduction to JSON Format)
▮▮▮▮▮▮▮ 3.2 使用 dynamic 解析 JSON (Parsing JSON with dynamic)
▮▮▮▮▮▮▮ 3.3 使用 dynamic 生成 JSON (Generating JSON with dynamic)
▮▮▮▮▮▮▮ 3.4 处理复杂的 JSON 数据结构 (Handling Complex JSON Data Structures)
▮▮▮▮▮▮▮ 3.5 JSON 解析与生成性能优化 (Performance Optimization for JSON Parsing and Generation)
▮▮▮▮ 4. chapter 4： dynamic 高级应用 (Advanced Applications of dynamic)
▮▮▮▮▮▮▮ 4.1 dynamic 在配置文件处理中的应用 (dynamic in Configuration File Processing)
▮▮▮▮▮▮▮ 4.2 dynamic 在数据交换中的应用 (dynamic in Data Exchange)
▮▮▮▮▮▮▮ 4.3 dynamic 与反射 (dynamic and Reflection)
▮▮▮▮▮▮▮ 4.4 自定义 dynamic 对象的行为 (Customizing the Behavior of dynamic Objects)
▮▮▮▮▮▮▮ 4.5 dynamic 的线程安全性 (Thread Safety of dynamic)
▮▮▮▮ 5. chapter 5： dynamic API 全面解析 (Comprehensive API Analysis of dynamic)
▮▮▮▮▮▮▮ 5.1 dynamic 类详解 (Detailed Explanation of dynamic Class)
▮▮▮▮▮▮▮ 5.2 dynamic 的操作符重载 (Operator Overloading of dynamic)
▮▮▮▮▮▮▮ 5.3 dynamic 的辅助函数 (Helper Functions of dynamic)
▮▮▮▮▮▮▮ 5.4 dynamic 的异常处理 (Exception Handling of dynamic)
▮▮▮▮ 6. chapter 6： dynamic 实战案例分析 (Practical Case Study Analysis of dynamic)
▮▮▮▮▮▮▮ 6.1 案例一：构建灵活的 API 接口 (Case Study 1: Building Flexible API Interfaces)
▮▮▮▮▮▮▮ 6.2 案例二：实现动态配置管理系统 (Case Study 2: Implementing Dynamic Configuration Management System)
▮▮▮▮▮▮▮ 6.3 案例三：开发轻量级脚本语言 (Case Study 3: Developing Lightweight Scripting Language)
▮▮▮▮ 7. chapter 7： dynamic 性能与优化 (Performance and Optimization of dynamic)
▮▮▮▮▮▮▮ 7.1 dynamic 的性能特点分析 (Performance Characteristics Analysis of dynamic)
▮▮▮▮▮▮▮ 7.2 减少 dynamic 的性能开销 (Reducing Performance Overhead of dynamic)
▮▮▮▮▮▮▮ 7.3 内存管理与自定义分配器 (Memory Management and Custom Allocators)
▮▮▮▮ 8. chapter 8： dynamic 源码剖析 (Source Code Analysis of dynamic)
▮▮▮▮▮▮▮ 8.1 dynamic 的内部结构 (Internal Structure of dynamic)
▮▮▮▮▮▮▮ 8.2 dynamic 的类型存储与管理 (Type Storage and Management of dynamic)
▮▮▮▮▮▮▮ 8.3 dynamic 的内存分配策略 (Memory Allocation Strategy of dynamic)
▮▮▮▮ 9. chapter 9： dynamic 与其他动态类型方案的比较 (Comparison of dynamic with Other Dynamic Typing Solutions)
▮▮▮▮▮▮▮ 9.1 dynamic vs. std::variant (dynamic vs. std::variant)
▮▮▮▮▮▮▮ 9.2 dynamic vs. RapidJSON::Value (dynamic vs. RapidJSON::Value)
▮▮▮▮▮▮▮ 9.3 dynamic vs. 其他动态类型库 (dynamic vs. Other Dynamic Typing Libraries)
▮▮▮▮ 10. chapter 10： dynamic 的最佳实践与未来展望 (Best Practices and Future Prospects of dynamic)
▮▮▮▮▮▮▮ 10.1 dynamic 使用的最佳实践 (Best Practices for Using dynamic)
▮▮▮▮▮▮▮ 10.2 dynamic 的局限性与改进方向 (Limitations and Improvement Directions of dynamic)
▮▮▮▮▮▮▮ 10.3 dynamic 的未来发展趋势 (Future Development Trends of dynamic)
1. chapter 1： 走进 Dynamic.h (Introduction to Dynamic.h)
1.1 什么是动态类型 (What is Dynamic Typing)
在编程世界中，类型系统是构建可靠软件的基石。类型系统决定了程序中数据的种类和操作，以及编译器如何在编译时或运行时检查和处理这些数据。其中，动态类型（Dynamic Typing） 是一种类型系统的方法，它与 静态类型（Static Typing） 形成鲜明对比。要理解 folly::dynamic 的强大之处，我们首先需要深入了解动态类型的概念。
简单来说，动态类型 意味着变量的类型在运行时才被确定和检查，而不是在编译时。这意味着，在动态类型语言中，你声明一个变量时，不需要显式指定它的类型。变量的类型会根据赋给它的值而自动变化。
与之相对，静态类型 要求在编译时就明确变量的类型。例如，在 C++ 中，当你声明一个 int x; 时，你就明确指定了 x 必须存储整数值。编译器会在编译阶段检查类型错误，例如，如果你试图将一个字符串赋值给 x，编译器会报错。
为了更清晰地理解两者的区别，我们通过一个简单的例子来说明。假设我们要实现一个函数，该函数接受一个参数并返回其平方。
在 静态类型语言 (如 C++) 中，我们可能需要为不同类型的输入参数编写多个函数，或者使用模板来实现泛型：
1
// 静态类型语言 (C++) 示例
2
3
// 为整数类型
4
int square(int x) {
5
return x * x;
6
}
7
8
// 为浮点数类型
9
double square(double x) {
10
return x * x;
11
}
12
13
// 使用模板实现泛型 (更灵活的方式)
14
template <typename T>
15
T square_template(T x) {
16
return x * x;
17
}
18
19
int main() {
20
int int_val = 5;
21
double double_val = 3.14;
22
23
std::cout << "Integer square: " << square(int_val) << std::endl;
24
std::cout << "Double square: " << square(double_val) << std::endl;
25
std::cout << "Template square (int): " << square_template(int_val) << std::endl;
26
std::cout << "Template square (double): " << square_template(double_val) << std::endl;
27
28
return 0;
29
}
在 动态类型语言 (如 Python) 中，我们可以编写一个更简洁的函数，无需关心参数的具体类型：
1
# 动态类型语言 (Python) 示例
2
3
def square(x):
4
return x * x
5
6
int_val = 5
7
double_val = 3.14
8
9
print(f"Integer square: {square(int_val)}")
10
print(f"Double square: {square(double_val)}")
可以看到，Python 的代码更加简洁和灵活。这是动态类型的典型优势之一。
动态类型的优点：
① 灵活性和简洁性（Flexibility and Simplicity）： 动态类型允许更简洁的代码，无需显式声明类型，减少了代码的冗余。特别是在处理数据结构较为复杂或类型不确定的数据时，动态类型能提供更高的灵活性。例如，在处理 JSON 数据时，数据的结构和类型可能在运行时才能确定，动态类型可以更自然地处理这种情况。
② 快速原型开发（Rapid Prototyping）： 由于无需关注类型声明，开发者可以更快速地编写和测试代码，加速原型开发过程。这对于快速验证想法和构建概念验证模型非常有利。
③ 更好的代码可读性（Improved Code Readability）： 在某些情况下，动态类型的代码可以更易读，因为它减少了类型声明的干扰，使代码更专注于逻辑本身。
动态类型的缺点：
① 运行时错误（Runtime Errors）： 类型检查延迟到运行时，这意味着类型错误可能在程序运行时才被发现，增加了调试的难度。在大型项目中，潜在的类型错误可能隐藏得更深，更难追踪。
② 性能开销（Performance Overhead）： 动态类型需要在运行时进行类型检查和类型推断，这会带来一定的性能开销。相比之下，静态类型在编译时完成类型检查，运行时性能更高。
③ 代码维护性降低（Reduced Code Maintainability）： 缺乏显式的类型信息，可能会降低代码的可读性和维护性，尤其是在大型项目中，代码的意图可能不够清晰，给后续的维护和修改带来困难。
总结：
动态类型和静态类型各有优缺点，选择哪种类型系统取决于具体的应用场景和需求。动态类型以其灵活性和简洁性，在快速开发、处理不确定类型数据等场景中表现出色。而静态类型以其类型安全性和性能优势，在需要高可靠性和性能的系统中更受欢迎。
folly::dynamic 正是 Facebook 开源的 Folly 库提供的一个 C++ 库，它为 C++ 引入了动态类型的特性，旨在弥合 C++ 静态类型的严格性和动态类型语言的灵活性之间的差距。在接下来的章节中，我们将深入探讨 folly::dynamic 的特性、应用和使用方法。
1.2 为什么选择 folly::dynamic (Why Choose folly::dynamic)
既然 C++ 是一门静态类型语言，为什么我们需要 folly::dynamic 这样的库来引入动态类型特性呢？ 答案在于 平衡。folly::dynamic 并非要取代 C++ 的静态类型系统，而是作为一种补充，在特定的应用场景下，为 C++ 开发者提供更大的灵活性和便利性。
C++ 的静态类型优势毋庸置疑：编译时类型检查可以尽早发现错误，提高代码的可靠性和性能。然而，在某些场景下，静态类型也会显得过于 rigid，限制了开发的效率和灵活性。
folly::dynamic 的出现正是为了解决以下痛点：
① 处理外部数据格式的灵活性（Flexibility in Handling External Data Formats）： 现代应用程序经常需要与外部系统交换数据，例如 JSON、YAML 等。这些数据格式通常是 自描述的（self-describing），即数据本身包含了类型信息。在 C++ 中，如果使用静态类型来解析和处理这些数据，通常需要预先定义复杂的结构体或类，并且在解析过程中进行大量的类型转换和检查，代码繁琐且容易出错。
folly::dynamic 可以将外部数据格式（如 JSON）直接解析为动态类型对象，无需预先定义类型，使得数据解析和处理过程更加简洁自然。例如，解析 JSON 数据时，你可以像操作动态类型语言一样，直接访问 JSON 对象中的字段，而无需关心其具体的 C++ 类型。
② 简化配置管理（Simplified Configuration Management）： 应用程序的配置信息通常存储在外部配置文件中（如 JSON、YAML、XML 等）。配置文件的结构和内容可能比较复杂，并且可能经常变化。使用 folly::dynamic 可以方便地读取和操作配置文件，无需为配置文件定义复杂的 C++ 结构体，简化了配置管理的流程。你可以将配置文件解析为 dynamic 对象，然后使用类似字典或对象的方式访问配置项，非常直观和方便。
③ 实现更灵活的 API 接口（Implementing More Flexible API Interfaces）： 在设计库或框架时，有时需要提供更灵活的 API 接口，允许用户传递不同类型的数据。使用 folly::dynamic 可以实现接受动态类型参数的函数，从而提高 API 的通用性和易用性。例如，你可以设计一个函数，接受 dynamic 类型的参数，根据参数的实际类型执行不同的操作，实现类似多态的效果，但更加灵活。
④ 快速原型开发和实验性编程（Rapid Prototyping and Experimental Programming）： 在原型开发或实验性编程阶段，我们可能需要快速验证想法，而不需要花费大量时间在类型定义和类型转换上。folly::dynamic 允许我们以更接近动态类型语言的方式进行编程，提高开发效率，快速验证概念。
⑤ 与动态类型语言互操作（Interoperability with Dynamic Languages）： 在某些场景下，C++ 程序可能需要与动态类型语言（如 Python、JavaScript）进行互操作。folly::dynamic 可以作为 C++ 和动态类型语言之间的桥梁，方便数据交换和类型转换。例如，你可以使用 folly::dynamic 将 C++ 数据转换为 JSON 格式，然后传递给 JavaScript 代码进行处理。
folly::dynamic 的优势总结：
⚝ 易用性（Ease of Use）： folly::dynamic 提供了简洁直观的 API，使得动态类型编程在 C++ 中变得更加容易。你可以像操作 JSON 对象或 Python 字典一样操作 dynamic 对象。
⚝ 高性能（Performance）： folly::dynamic 底层实现经过了精心的优化，虽然动态类型本身会有一定的性能开销，但 folly::dynamic 在性能方面表现出色，尽可能地减少了性能损失，使其在性能敏感的应用中也能使用。
⚝ 与 Folly 库的良好集成（Good Integration with Folly Library）： folly::dynamic 是 Folly 库的一部分，可以与 Folly 库的其他组件（如 folly::json, folly::Optional, folly::Expected 等）无缝集成，共同构建更强大、更高效的 C++ 应用。
⚝ 类型安全（Type Safety）： 虽然 folly::dynamic 引入了动态类型，但它仍然在一定程度上保持了类型安全。folly::dynamic 会在运行时进行类型检查，避免一些常见的类型错误。同时，它也提供了类型转换和类型判断的机制，帮助开发者更好地管理动态类型数据。
与其他动态类型方案的比较：
在 C++ 中，还有一些其他的动态类型方案，例如 std::variant, boost::variant, RapidJSON::Value 等。folly::dynamic 与它们相比，在设计理念、使用场景和性能特点上有所不同。我们将在后续章节中详细比较 folly::dynamic 与这些方案的差异，帮助读者根据实际需求选择最合适的动态类型方案。
总而言之，folly::dynamic 为 C++ 开发者提供了一种在静态类型和动态类型之间取得平衡的方案。它在需要灵活性和处理外部动态数据的场景下，能够显著提高开发效率和代码简洁性，同时保持 C++ 的高性能和可靠性。选择 folly::dynamic，意味着选择了一种更现代、更高效的 C++ 编程方式。
1.3 folly::dynamic 的应用场景 (Use Cases of folly::dynamic)
folly::dynamic 的灵活性和易用性使其在众多应用场景中都能发挥重要作用。理解 folly::dynamic 的应用场景，可以帮助我们更好地判断何时以及如何使用它来解决实际问题。以下列举了一些 folly::dynamic 常见的应用场景：
① JSON 数据处理 (JSON Data Processing) ⚝
这是 folly::dynamic 最典型的应用场景之一。JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，广泛应用于 Web API、配置文件、数据存储等领域。JSON 数据的结构灵活多变，可能包含嵌套的对象、数组以及各种基本数据类型。
folly::dynamic 可以完美地表示 JSON 数据结构。你可以将 JSON 字符串解析为 dynamic 对象，然后像操作 JavaScript 对象一样，使用点号 . 或方括号 [] 访问 JSON 对象中的字段和元素，无需预先定义 C++ 结构体。
示例： 解析 JSON 字符串并访问数据
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
5
int main() {
6
std::string json_str = R"({"name": "Alice", "age": 30, "city": "New York"})";
7
folly::dynamic dyn = folly::parseJson(json_str);
8
9
std::cout << "Name: " << dyn["name"].asString() << std::endl;
10
std::cout << "Age: " << dyn["age"].asInt() << std::endl;
11
std::cout << "City: " << dyn["city"].asString() << std::endl;
12
13
return 0;
14
}
在这个例子中，folly::parseJson 函数将 JSON 字符串解析为 folly::dynamic 对象 dyn。然后，我们可以使用 dyn["name"], dyn["age"], dyn["city"] 访问 JSON 对象中的字段，并使用 asString() 和 asInt() 等方法将 dynamic 对象转换为具体的 C++ 类型。
② 配置文件处理 (Configuration File Processing) ⚝
应用程序的配置信息通常存储在配置文件中，例如 JSON、YAML、XML 等格式。配置文件的结构可能比较复杂，并且可能需要经常修改。folly::dynamic 可以简化配置文件的读取和操作。
你可以将配置文件解析为 dynamic 对象，然后使用类似字典的方式访问配置项，无需为配置文件定义复杂的 C++ 结构体。这使得配置文件的管理更加灵活和方便。
示例： 读取 JSON 配置文件
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <fstream>
4
#include <iostream>
5
6
int main() {
7
std::ifstream config_file("config.json");
8
std::string config_str((std::istreambuf_iterator<char>(config_file)),
9
std::istreambuf_iterator<char>());
10
11
folly::dynamic config = folly::parseJson(config_str);
12
13
std::string server_host = config["server"]["host"].asString();
14
int server_port = config["server"]["port"].asInt();
15
16
std::cout << "Server Host: " << server_host << std::endl;
17
std::cout << "Server Port: " << server_port << std::endl;
18
19
return 0;
20
}
假设 config.json 文件内容如下：
1
{
2
"server": {
3
"host": "localhost",
4
"port": 8080
5
},
6
"database": {
7
"name": "mydb",
8
"user": "admin"
9
}
10
}
这段代码读取 config.json 文件，并使用 folly::dynamic 解析配置文件，然后访问 server.host 和 server.port 配置项。
③ 数据交换 (Data Exchange) ⚝
在分布式系统、微服务架构中，不同组件之间经常需要交换数据。folly::dynamic 可以作为一种通用的数据交换格式，方便不同语言和平台之间的数据传递。
你可以将 C++ 对象转换为 dynamic 对象，然后将其序列化为 JSON 字符串，发送给其他系统。接收方可以将 JSON 字符串反序列化为 dynamic 对象，然后进行处理。
示例： 使用 dynamic 进行数据交换
1
// 发送方 (C++)
2
#include <folly/dynamic.h>
3
#include <folly/json.h>
4
#include <iostream>
5
#include <string>
6
7
int main() {
8
folly::dynamic data = folly::dynamic::object
9
("message", "Hello from C++")
10
("value", 123);
11
12
std::string json_str = folly::toJson(data);
13
std::cout << "JSON data to send: " << json_str << std::endl;
14
15
// ... 发送 json_str ...
16
17
return 0;
18
}
19
20
21
// 接收方 (Python)
22
import json
23
24
json_str = '{"message": "Hello from C++", "value": 123}'
25
data = json.loads(json_str)
26
27
print(f"Received message: {data['message']}")
28
print(f"Received value: {data['value']}")
这个例子展示了如何使用 folly::dynamic 在 C++ 和 Python 之间交换数据。C++ 代码将数据封装为 dynamic 对象并转换为 JSON 字符串，Python 代码接收 JSON 字符串并解析为 Python 字典。
④ 构建灵活的 API 接口 (Building Flexible API Interfaces) ⚝
在设计库或框架时，有时需要提供更灵活的 API 接口，允许用户传递不同类型的数据。folly::dynamic 可以用于构建接受动态类型参数的函数，提高 API 的通用性和易用性。
示例： 接受动态类型参数的函数
1
#include <folly/dynamic.h>
2
#include <iostream>
3
#include <string>
4
5
void process_data(const folly::dynamic& data) {
6
if (data.isString()) {
7
std::cout << "Received string data: " << data.asString() << std::endl;
8
} else if (data.isInt()) {
9
std::cout << "Received integer data: " << data.asInt() << std::endl;
10
} else if (data.isObject()) {
11
std::cout << "Received object data: " << folly::toJson(data) << std::endl;
12
} else {
13
std::cout << "Received unknown data type." << std::endl;
14
}
15
}
16
17
int main() {
18
process_data("Hello");
19
process_data(123);
20
process_data(folly::dynamic::object("key", "value"));
21
22
return 0;
23
}
process_data 函数接受 folly::dynamic 类型的参数，并根据参数的实际类型执行不同的操作。这种方式使得 API 更加灵活，可以处理多种类型的数据输入。
⑤ 脚本语言和解释器 (Scripting Languages and Interpreters) ⚝
folly::dynamic 可以作为构建轻量级脚本语言或解释器的基础数据类型。动态类型非常适合脚本语言，因为脚本语言通常需要更高的灵活性和更少的类型约束。
你可以使用 folly::dynamic 表示脚本语言中的变量、表达式和数据结构，并实现脚本的解析、执行和求值过程。
总结：
folly::dynamic 的应用场景非常广泛，涵盖了数据处理、配置管理、API 设计、脚本语言等多个领域。在这些场景中，folly::dynamic 能够提供更高的灵活性、简洁性和开发效率，帮助开发者更好地应对复杂的数据处理和动态类型需求。在后续的章节中，我们将通过更多的实战案例，深入探讨 folly::dynamic 在不同场景下的应用。
1.4 环境搭建与快速上手 (Environment Setup and Quick Start)
要开始使用 folly::dynamic，首先需要搭建开发环境并进行简单的上手操作。本节将指导你完成 Folly 库的安装与配置，并编写你的第一个 folly::dynamic 程序。
1.4.1 Folly 库的安装与配置 (Installation and Configuration of Folly Library)
folly::dynamic 是 Facebook 开源的 Folly (Facebook Open Source Library) 库的一部分。Folly 库是一个大型的 C++ 库，包含了许多实用的组件和工具。要使用 folly::dynamic，你需要先安装 Folly 库。
Folly 库的安装相对复杂，因为它依赖于许多其他的库和工具。以下介绍几种常见的 Folly 库安装方法：
① 使用包管理器安装 (Installing with Package Managers)
对于某些 Linux 发行版和 macOS，可以使用包管理器（如 apt, yum, brew）来安装 Folly 库及其依赖项。这种方法最简单快捷，但可能无法安装最新版本的 Folly，并且不同发行版提供的 Folly 版本可能有所差异。
⚝ Debian/Ubuntu:
1
sudo apt-get update
2
sudo apt-get install libfolly-dev
⚝ CentOS/Fedora:
1
sudo yum install folly-devel
⚝ macOS (使用 Homebrew):
1
brew install folly
1
使用包管理器安装后，通常 Folly 库的头文件会被安装到 `/usr/include/folly` 或 `/usr/local/include/folly` 目录下，库文件会被安装到 `/usr/lib` 或 `/usr/local/lib` 目录下。
② 从源码编译安装 (Building from Source)
从源码编译安装 Folly 库可以获取最新版本，并且可以更灵活地配置编译选项。但这种方法相对复杂，需要较长的编译时间，并且需要处理各种依赖项。
源码编译安装步骤：
- 克隆 Folly 仓库:
1
git clone https://github.com/facebook/folly.git
2
cd folly
安装依赖项:
Folly 依赖于许多其他的库，包括 Boost, Double-conversion, Glog, Gflags, Libevent, OpenSSL, Zlib, LZ4, Snappy, jemalloc (可选), libsodium (可选) 等。你需要根据你的系统环境安装这些依赖项。
在 Ubuntu 系统上，可以使用以下命令安装常用的依赖项：
1
sudo apt-get update
2
sudo apt-get install autoconf automake build-essential cmake libboost-dev libboost-system-dev libboost-thread-dev libdouble-conversion-dev libgflags-dev libglog-dev libjemalloc-dev liblz4-dev libopenssl-dev libsnappy-dev zlib1g-dev libevent-dev libsodium-dev python3 python3-dev pkg-config
1
其他系统请参考 Folly 仓库的文档 ( `README.md` )，根据你的系统环境安装相应的依赖项。
- 使用 CMake 构建:
1
mkdir build
2
cd build
3
cmake ..
4
make -j$(nproc) # 使用多核并行编译，加快编译速度
5
sudo make install
1
CMake 会自动检测你的系统环境和依赖项，并生成 Makefile。`make` 命令会编译 Folly 库，`sudo make install` 命令会将编译好的库文件和头文件安装到系统目录 (通常是 `/usr/local` 目录下)。
③ 使用 Docker (Using Docker)
如果你希望快速体验 folly::dynamic，或者避免本地环境配置的麻烦，可以使用 Docker。Folly 仓库提供了一个 Dockerfile，可以方便地构建包含 Folly 开发环境的 Docker 镜像。
构建 Docker 镜像:
在 Folly 仓库根目录下，执行以下命令构建 Docker 镜像：
1
docker build -t folly-dev .
- 运行 Docker 容器:
1
docker run -it --rm -v $(pwd):/mnt/folly folly-dev /bin/bash
1
这条命令会启动一个交互式的 Docker 容器，并将当前目录挂载到容器的 `/mnt/folly` 目录下。你可以在容器内部进行 Folly 代码的编译和测试。
配置编译环境:
安装 Folly 库后，你需要配置你的 C++ 编译环境，以便能够找到 Folly 的头文件和库文件。
⚝ CMake 工程: 如果你的项目使用 CMake 构建，可以在 CMakeLists.txt 文件中添加以下配置：
1
cmake_minimum_required(VERSION 3.15)
2
project(my_folly_project)
3
4
find_package(Folly REQUIRED)
5
6
add_executable(my_program main.cpp)
7
target_link_libraries(my_program PRIVATE Folly::folly) # 链接 folly 库
8
target_include_directories(my_program PUBLIC ${Folly_INCLUDE_DIRS}) # 添加头文件搜索路径
⚝ Makefile 工程: 如果你的项目使用 Makefile 构建，需要在编译命令和链接命令中指定 Folly 的头文件路径和库文件路径。假设 Folly 安装在 /usr/local 目录下，编译命令和链接命令可能如下所示：
1
CXX = g++
2
CXXFLAGS = -std=c++17 -I/usr/local/include # 指定头文件路径
3
LDFLAGS = -L/usr/local/lib -lfolly # 指定库文件路径和库名称
4
5
my_program: main.o
6
$(CXX) $(LDFLAGS) -o my_program main.o -lfolly
7
8
main.o: main.cpp
9
$(CXX) $(CXXFLAGS) -c main.cpp
1
请根据你的实际安装路径和项目构建方式进行相应的配置。
1.4.2 第一个 folly::dynamic 程序 (Your First folly::dynamic Program)
环境配置完成后，让我们编写你的第一个 folly::dynamic 程序，体验 folly::dynamic 的基本用法。
创建一个名为 hello_dynamic.cpp 的文件，并输入以下代码：
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
5
int main() {
6
// 创建一个 dynamic 对象
7
folly::dynamic my_dynamic = folly::dynamic::object
8
("name", "Dynamic World")
9
("version", 1.0)
10
("features", folly::dynamic::array("flexibility", "simplicity", "performance"));
11
12
// 打印 dynamic 对象
13
std::cout << "My Dynamic Object: " << folly::toJson(my_dynamic) << std::endl;
14
15
// 访问 dynamic 对象的字段
16
std::string name = my_dynamic["name"].asString();
17
double version = my_dynamic["version"].asDouble();
18
19
std::cout << "Name: " << name << std::endl;
20
std::cout << "Version: " << version << std::endl;
21
22
// 访问 dynamic 数组的元素
23
std::string first_feature = my_dynamic["features"][0].asString();
24
std::cout << "First Feature: " << first_feature << std::endl;
25
26
return 0;
27
}
代码解释：
⚝ #include <folly/dynamic.h>: 引入 folly::dynamic 头文件。
⚝ #include <folly/json.h>: 引入 folly::json.h 头文件，用于将 dynamic 对象转换为 JSON 字符串输出。
⚝ folly::dynamic my_dynamic = folly::dynamic::object(...): 使用 folly::dynamic::object 创建一个 dynamic 对象，它类似于 JSON 对象或 Python 字典。我们向对象中添加了三个字段：name, version, features。
▮▮▮▮⚝ "name", "Dynamic World": 添加一个字符串类型的字段 name，值为 "Dynamic World"。
▮▮▮▮⚝ "version", 1.0: 添加一个浮点数类型的字段 version，值为 1.0。
▮▮▮▮⚝ "features", folly::dynamic::array("flexibility", "simplicity", "performance"): 添加一个数组类型的字段 features，值为包含三个字符串元素的数组。folly::dynamic::array 用于创建 dynamic 数组。
⚝ std::cout << "My Dynamic Object: " << folly::toJson(my_dynamic) << std::endl;: 使用 folly::toJson 函数将 dynamic 对象转换为 JSON 字符串，并打印输出。
⚝ std::string name = my_dynamic["name"].asString();: 使用 my_dynamic["name"] 访问 name 字段，并使用 asString() 方法将 dynamic 对象转换为 std::string 类型。
⚝ double version = my_dynamic["version"].asDouble();: 使用 my_dynamic["version"] 访问 version 字段，并使用 asDouble() 方法将 dynamic 对象转换为 double 类型。
⚝ std::string first_feature = my_dynamic["features"][0].asString();: 使用 my_dynamic["features"][0] 访问 features 数组的第一个元素，并使用 asString() 方法将其转换为 std::string 类型。
编译和运行：
使用你配置好的编译环境编译 hello_dynamic.cpp 文件，并运行生成的可执行文件。例如，如果使用 g++ 和 Makefile，可以执行以下命令：
1
g++ -std=c++17 -I/usr/local/include -L/usr/local/lib -o hello_dynamic hello_dynamic.cpp -lfolly
2
./hello_dynamic
如果一切顺利，你将看到如下输出：
1
My Dynamic Object: {"name":"Dynamic World","version":1,"features":["flexibility","simplicity","performance"]}
2
Name: Dynamic World
3
Version: 1
4
First Feature: flexibility
恭喜你，你已经成功运行了你的第一个 folly::dynamic 程序！
1.4.3 dynamic 的基本数据类型 (Basic Data Types of dynamic)
folly::dynamic 可以表示多种基本数据类型，类似于 JSON 支持的数据类型。理解 dynamic 支持的基本数据类型是使用 folly::dynamic 的基础。
folly::dynamic 支持以下基本数据类型：
① null: 表示空值或不存在的值。可以使用 folly::dynamic::null() 创建 null 类型的 dynamic 对象。
1
folly::dynamic null_dyn = folly::dynamic::null();
2
std::cout << "Null dynamic: " << folly::toJson(null_dyn) << std::endl; // 输出: null
3
std::cout << "Is null? " << null_dyn.isNull() << std::endl; // 输出: 1 (true)
② bool: 表示布尔值，true 或 false。可以使用 folly::dynamic(true) 或 folly::dynamic(false) 创建布尔类型的 dynamic 对象。
1
folly::dynamic bool_true_dyn = folly::dynamic(true);
2
folly::dynamic bool_false_dyn = folly::dynamic(false);
3
std::cout << "True dynamic: " << folly::toJson(bool_true_dyn) << std::endl; // 输出: true
4
std::cout << "False dynamic: " << folly::toJson(bool_false_dyn) << std::endl; // 输出: false
5
std::cout << "Is bool? " << bool_true_dyn.isBool() << std::endl; // 输出: 1 (true)
③ int64_t: 表示 64 位有符号整数。可以使用整数值直接创建整数类型的 dynamic 对象。
1
folly::dynamic int_dyn = folly::dynamic(12345);
2
std::cout << "Integer dynamic: " << folly::toJson(int_dyn) << std::endl; // 输出: 12345
3
std::cout << "Is integer? " << int_dyn.isInt() << std::endl; // 输出: 1 (true)
4
std::cout << "As integer: " << int_dyn.asInt() << std::endl; // 输出: 12345
④ double: 表示双精度浮点数。可以使用浮点数值直接创建浮点数类型的 dynamic 对象。
1
folly::dynamic double_dyn = folly::dynamic(3.14159);
2
std::cout << "Double dynamic: " << folly::toJson(double_dyn) << std::endl; // 输出: 3.14159
3
std::cout << "Is double? " << double_dyn.isDouble() << std::endl; // 输出: 1 (true)
4
std::cout << "As double: " << double_dyn.asDouble() << std::endl; // 输出: 3.14159
⑤ std::string: 表示字符串。可以使用字符串字面量或 std::string 对象创建字符串类型的 dynamic 对象。
1
folly::dynamic string_dyn = folly::dynamic("Hello Dynamic");
2
std::cout << "String dynamic: " << folly::toJson(string_dyn) << std::endl; // 输出: "Hello Dynamic"
3
std::cout << "Is string? " << string_dyn.isString() << std::endl; // 输出: 1 (true)
4
std::cout << "As string: " << string_dyn.asString() << std::endl; // 输出: Hello Dynamic
⑥ array: 表示动态数组，可以存储多个 dynamic 对象。可以使用 folly::dynamic::array(...) 创建数组类型的 dynamic 对象。
1
folly::dynamic array_dyn = folly::dynamic::array(1, "two", 3.0, folly::dynamic::null());
2
std::cout << "Array dynamic: " << folly::toJson(array_dyn) << std::endl; // 输出: [1,"two",3,null]
3
std::cout << "Is array? " << array_dyn.isArray() << std::endl; // 输出: 1 (true)
4
std::cout << "Array size: " << array_dyn.size() << std::endl; // 输出: 4
5
std::cout << "First element: " << array_dyn[0].asInt() << std::endl; // 输出: 1
⑦ object: 表示动态对象（类似于 JSON 对象或 Python 字典），可以存储键值对，键是字符串，值是 dynamic 对象。可以使用 folly::dynamic::object(...) 创建对象类型的 dynamic 对象。
1
folly::dynamic object_dyn = folly::dynamic::object
2
("key1", "value1")
3
("key2", 123)
4
("key3", folly::dynamic::array(true, false));
5
std::cout << "Object dynamic: " << folly::toJson(object_dyn) << std::endl;
6
// 输出: {"key1":"value1","key2":123,"key3":[true,false]}
7
std::cout << "Is object? " << object_dyn.isObject() << std::endl; // 输出: 1 (true)
8
std::cout << "Object size: " << object_dyn.size() << std::endl; // 输出: 3
9
std::cout << "Value of key1: " << object_dyn["key1"].asString() << std::endl; // 输出: value1
类型判断和转换：
folly::dynamic 提供了多种方法用于类型判断和类型转换，例如：
⚝ isNull(): 判断是否为 null 类型。
⚝ isBool(): 判断是否为布尔类型。
⚝ isInt(): 判断是否为整数类型。
⚝ isDouble(): 判断是否为浮点数类型。
⚝ isString(): 判断是否为字符串类型。
⚝ isArray(): 判断是否为数组类型。
⚝ isObject(): 判断是否为对象类型。
以及 as<Type>() 系列方法用于类型转换，例如 asBool(), asInt(), asDouble(), asString(), asArray(), asObject() 等。
注意： 在使用 as<Type>() 方法进行类型转换时，需要确保 dynamic 对象的实际类型与目标类型兼容，否则会抛出异常。例如，如果 dynamic 对象存储的是字符串，而你尝试使用 asInt() 转换为整数，就会抛出异常。因此，在进行类型转换之前，最好先使用类型判断方法 (is<Type>()) 检查对象的类型。
掌握了 folly::dynamic 的基本数据类型和类型操作，你就可以开始使用 folly::dynamic 处理各种动态类型数据了。在接下来的章节中，我们将深入学习 folly::dynamic 的核心概念、高级应用和 API 详解。
END_OF_CHAPTER
2. chapter 2： dynamic 的核心概念与操作 (Core Concepts and Operations of dynamic)
2.1 dynamic 对象的创建与初始化 (Creation and Initialization of dynamic Objects)
folly::dynamic 是一个非常灵活的类型，它能够持有多种不同的数据类型，类似于 JavaScript 中的 var 或者 Python 中的动态类型变量。理解 dynamic 对象的创建和初始化是掌握 folly::dynamic 的基础。
创建 dynamic 对象
创建 dynamic 对象非常简单，可以直接声明一个 dynamic 类型的变量，无需显式指定其初始类型。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic var; // 创建一个未初始化的 dynamic 对象
6
return 0;
7
}
上述代码创建了一个名为 var 的 dynamic 对象，此时它处于未初始化状态，可以被赋予任何支持的类型的值。
初始化 dynamic 对象
dynamic 对象可以使用多种方式进行初始化，它可以被赋予基本数据类型、容器甚至其他 dynamic 对象。
① 使用字面量初始化
dynamic 可以直接使用字面量进行初始化，例如数字、字符串、布尔值、以及 nullptr。
1
folly::dynamic intVar = 10; // 初始化为整数
2
folly::dynamic doubleVar = 3.14; // 初始化为浮点数
3
folly::dynamic stringVar = "hello"; // 初始化为字符串
4
folly::dynamic boolVar = true; // 初始化为布尔值
5
folly::dynamic nullVar = nullptr; // 初始化为 null
② 使用 C++ 变量初始化
dynamic 可以使用 C++ 中的变量进行初始化，这使得 dynamic 可以方便地与现有的 C++ 代码集成。
1
int cppInt = 100;
2
std::string cppString = "world";
3
folly::dynamic dynamicIntVar = cppInt; // 使用 int 变量初始化
4
folly::dynamic dynamicStringVar = cppString; // 使用 std::string 变量初始化
③ 使用容器初始化
dynamic 可以初始化为数组（array）或对象（object），这两种类型在处理结构化数据时非常有用，尤其是在与 JSON 数据交互时。
⚝ 初始化为数组 (array)
使用 folly::dynamic::array() 可以创建一个 dynamic 数组，并可以链式调用 .push_back() 方法添加元素。
1
folly::dynamic dynamicArray = folly::dynamic::array(); // 创建一个空的 dynamic 数组
2
dynamicArray.push_back(1);
3
dynamicArray.push_back("two");
4
dynamicArray.push_back(3.0);
5
6
// 或者在初始化时直接赋值
7
folly::dynamic dynamicArray2 = folly::dynamic::array(1, "two", 3.0);
⚝ 初始化为对象 (object)
使用 folly::dynamic::object() 可以创建一个 dynamic 对象，它类似于一个键值对的容器，键必须是字符串，值可以是任何 dynamic 类型。可以使用 [] 运算符或者 .insert() 方法添加键值对。
1
folly::dynamic dynamicObject = folly::dynamic::object(); // 创建一个空的 dynamic 对象
2
dynamicObject["name"] = "Alice";
3
dynamicObject["age"] = 30;
4
dynamicObject["city"] = "New York";
5
6
// 或者在初始化时直接赋值
7
folly::dynamic dynamicObject2 = folly::dynamic::object("name", "Bob", "age", 25);
④ 使用其他 dynamic 对象初始化
dynamic 对象可以互相赋值和初始化，这在处理嵌套的动态数据结构时非常方便。
1
folly::dynamic dynamicVar1 = 123;
2
folly::dynamic dynamicVar2 = dynamicVar1; // 使用 dynamicVar1 初始化 dynamicVar2
默认初始化
如果声明 dynamic 对象时没有进行显式初始化，它将持有一个未定义的（undefined）值。虽然可以对其赋值，但建议始终显式初始化 dynamic 对象，以避免潜在的未定义行为。
1
folly::dynamic defaultDynamic; // 默认初始化，值为 undefined
2
defaultDynamic = "initialized later"; // 后续赋值
总结
folly::dynamic 提供了多种灵活的初始化方式，可以方便地创建和赋值各种类型的动态对象。理解这些初始化方法是使用 folly::dynamic 的第一步，为后续的核心概念和操作打下基础。在实际应用中，可以根据具体场景选择最合适的初始化方式，以提高代码的可读性和效率。
2.2 dynamic 的类型系统 (Type System of dynamic)
folly::dynamic 的核心特性之一是其动态类型系统。与 C++ 的静态类型系统不同，dynamic 对象的类型并非在编译时确定，而是在运行时根据其存储的值动态变化。理解 dynamic 的类型系统对于正确使用和调试基于 folly::dynamic 的代码至关重要。
dynamic 的内部类型
folly::dynamic 能够表示以下几种基本类型：
① Null (空值)：对应 C++ 中的 nullptr，表示空值或缺失值。
② Boolean (布尔值)：对应 C++ 中的 bool，表示真或假。
③ Integer (整数)：对应 C++ 中的有符号整数类型，如 int64_t。
④ Double (双精度浮点数)：对应 C++ 中的 double，表示浮点数值。
⑤ String (字符串)：对应 C++ 中的 std::string，表示文本字符串。
⑥ Array (数组)：表示一个有序的 dynamic 元素集合，类似于 std::vector<folly::dynamic>。
⑦ Object (对象)：表示一个键值对集合，键是字符串，值是 dynamic 类型，类似于 std::map<std::string, folly::dynamic>。
⑧ Undefined (未定义)：表示 dynamic 对象尚未被赋值或初始化。
类型识别
folly::dynamic 提供了多种方法来检查一个 dynamic 对象当前存储的类型。这些方法通常以 is<Type>() 的形式出现，返回布尔值，指示 dynamic 对象是否为指定的类型。
⚝ isNull(): 检查是否为 Null 类型。
⚝ isBool(): 检查是否为 Boolean 类型。
⚝ isInt(): 检查是否为 Integer 类型。
⚝ isDouble(): 检查是否为 Double 类型。
⚝ isString(): 检查是否为 String 类型。
⚝ isArray(): 检查是否为 Array 类型。
⚝ isObject(): 检查是否为 Object 类型。
⚝ isUndefined(): 检查是否为 Undefined 类型。
⚝ isNumber(): 检查是否为数字类型 (Integer 或 Double)。
⚝ isSimple(): 检查是否为简单类型 (Null, Boolean, Integer, Double, String)。
⚝ isContainer(): 检查是否为容器类型 (Array 或 Object)。
1
folly::dynamic var;
2
3
var = nullptr;
4
std::cout << "var is Null: " << var.isNull() << std::endl; // 输出 true
5
6
var = 123;
7
std::cout << "var is Integer: " << var.isInt() << std::endl; // 输出 true
8
std::cout << "var is Number: " << var.isNumber() << std::endl; // 输出 true
9
10
var = "text";
11
std::cout << "var is String: " << var.isString() << std::endl; // 输出 true
12
13
var = folly::dynamic::array(1, 2, 3);
14
std::cout << "var is Array: " << var.isArray() << std::endl; // 输出 true
15
std::cout << "var is Container: " << var.isContainer() << std::endl; // 输出 true
类型转换
folly::dynamic 允许在不同类型之间进行转换，但需要注意类型安全。尝试将 dynamic 对象转换为不兼容的类型可能会导致运行时错误或抛出异常。
⚝ 显式类型转换
可以使用 as<Type>() 方法尝试将 dynamic 对象转换为指定的 C++ 类型。如果类型不兼容，会抛出 std::bad_cast 异常。
1
folly::dynamic dynamicInt = 100;
2
int intValue = dynamicInt.asInt(); // 显式转换为 int
3
4
folly::dynamic dynamicString = "42";
5
try {
6
int convertedInt = dynamicString.asInt(); // 尝试将字符串转换为 int，会抛出异常
7
} catch (const std::bad_cast& e) {
8
std::cerr << "类型转换失败: " << e.what() << std::endl;
9
}
⚝ 隐式类型转换
在某些情况下，dynamic 对象可以隐式转换为 C++ 类型，例如在输出流操作中。
1
folly::dynamic dynamicValue = 123;
2
std::cout << "Value: " << dynamicValue << std::endl; // 隐式转换为字符串输出
类型系统的动态性
dynamic 对象的类型是动态的，这意味着同一个 dynamic 变量可以在不同的时间点持有不同类型的值。
1
folly::dynamic flexibleVar;
2
3
flexibleVar = 10;
4
std::cout << "Type: Integer" << std::endl;
5
std::cout << "Value: " << flexibleVar.asInt() << std::endl;
6
7
flexibleVar = "hello";
8
std::cout << "Type: String" << std::endl;
9
std::cout << "Value: " << flexibleVar.asString() << std::endl;
10
11
flexibleVar = folly::dynamic::array(true, false);
12
std::cout << "Type: Array" << std::endl;
13
std::cout << "Value: " << flexibleVar.toJson() << std::endl; // 使用 toJson() 方法输出 JSON 格式
总结
folly::dynamic 的动态类型系统提供了极大的灵活性，允许在运行时处理不同类型的数据。理解 dynamic 支持的类型、类型识别方法以及类型转换机制，是编写健壮且灵活的 folly::dynamic 代码的关键。在实际应用中，应谨慎处理类型转换，并充分利用类型检查方法来避免运行时错误。
2.3 访问 dynamic 对象的值 (Accessing Values of dynamic Objects)
访问 dynamic 对象的值是使用 folly::dynamic 的核心操作之一。由于 dynamic 可以持有多种类型的值，因此访问其值需要根据其当前类型采取不同的方法。folly::dynamic 提供了多种方式来安全且方便地访问其内部存储的值。
使用 as<Type>() 方法
as<Type>() 方法是最直接的访问 dynamic 对象值的方式。它尝试将 dynamic 对象转换为指定的 C++ 类型，并返回该类型的值。如果 dynamic 对象的实际类型与 as<Type>() 指定的类型不匹配，则会抛出 std::bad_cast 异常。因此，在使用 as<Type>() 之前，通常需要先使用类型检查方法（如 isInt(), isString() 等）来确保类型匹配。
1
folly::dynamic dynamicInt = 123;
2
if (dynamicInt.isInt()) {
3
int value = dynamicInt.asInt(); // 安全访问 Integer 类型的值
4
std::cout << "Integer Value: " << value << std::endl;
5
}
6
7
folly::dynamic dynamicString = "hello";
8
if (dynamicString.isString()) {
9
std::string strValue = dynamicString.asString(); // 安全访问 String 类型的值
10
std::cout << "String Value: " << strValue << std::endl;
11
}
访问 Array 元素
对于 dynamic 数组，可以使用 [] 运算符或者 .at() 方法来访问指定索引位置的元素。[] 运算符不会进行边界检查，而 .at() 方法会在索引越界时抛出 std::out_of_range 异常。访问数组元素返回的是 dynamic 类型的值，可以继续使用类型检查和 as<Type>() 方法来获取具体的值。
1
folly::dynamic dynamicArray = folly::dynamic::array(10, "twenty", 30.0);
2
3
if (dynamicArray.isArray() && dynamicArray.size() > 1) {
4
folly::dynamic element1 = dynamicArray[0]; // 使用 [] 运算符访问
5
folly::dynamic element2 = dynamicArray.at(1); // 使用 .at() 方法访问
6
7
if (element1.isInt()) {
8
std::cout << "Array Element 1 (Integer): " << element1.asInt() << std::endl;
9
}
10
if (element2.isString()) {
11
std::cout << "Array Element 2 (String): " << element2.asString() << std::endl;
12
}
13
}
访问 Object 成员
对于 dynamic 对象，可以使用 [] 运算符或者 .at() 方法，并以键名（字符串）作为索引来访问对象成员。类似于数组，[] 运算符在键名不存在时会默认创建新的键值对（并返回默认构造的 dynamic 对象），而 .at() 方法在键名不存在时会抛出 std::out_of_range 异常。访问对象成员返回的也是 dynamic 类型的值。
1
folly::dynamic dynamicObject = folly::dynamic::object("name", "Alice", "age", 28);
2
3
if (dynamicObject.isObject()) {
4
folly::dynamic nameValue = dynamicObject["name"]; // 使用 [] 运算符访问
5
folly::dynamic ageValue = dynamicObject.at("age"); // 使用 .at() 方法访问
6
7
if (nameValue.isString()) {
8
std::cout << "Object Member 'name': " << nameValue.asString() << std::endl;
9
}
10
if (ageValue.isInt()) {
11
std::cout << "Object Member 'age': " << ageValue.asInt() << std::endl;
12
}
13
14
// 访问不存在的键名，使用 [] 运算符不会抛出异常，但返回 undefined
15
folly::dynamic cityValue = dynamicObject["city"];
16
if (cityValue.isUndefined()) {
17
std::cout << "Object Member 'city' is undefined." << std::endl;
18
}
19
20
// 访问不存在的键名，使用 .at() 方法会抛出异常
21
try {
22
folly::dynamic countryValue = dynamicObject.at("country");
23
} catch (const std::out_of_range& e) {
24
std::cerr << "Error accessing object member: " << e.what() << std::endl;
25
}
26
}
使用迭代器访问 Array 和 Object
对于 dynamic 数组和对象，还可以使用迭代器进行遍历访问。dynamic 提供了 .items() 方法，返回一个迭代器范围，可以用于循环遍历数组元素或对象键值对。
⚝ 遍历 Array
1
folly::dynamic dynamicArray = folly::dynamic::array(1, 2, 3, 4, 5);
2
if (dynamicArray.isArray()) {
3
for (const auto& item : dynamicArray.items()) {
4
if (item.isInt()) {
5
std::cout << "Array Item: " << item.asInt() << std::endl;
6
}
7
}
8
}
⚝ 遍历 Object
1
folly::dynamic dynamicObject = folly::dynamic::object("a", 1, "b", "two", "c", 3.0);
2
if (dynamicObject.isObject()) {
3
for (const auto& pair : dynamicObject.items()) {
4
std::string key = pair.first.asString(); // 键是字符串类型的 dynamic
5
folly::dynamic value = pair.second; // 值是 dynamic 类型
6
std::cout << "Object Key: " << key << ", Value: ";
7
if (value.isInt()) {
8
std::cout << value.asInt() << std::endl;
9
} else if (value.isString()) {
10
std::cout << value.asString() << std::endl;
11
} else if (value.isDouble()) {
12
std::cout << value.asDouble() << std::endl;
13
} else {
14
std::cout << "Unknown Type" << std::endl;
15
}
16
}
17
}
总结
folly::dynamic 提供了多种灵活的方式来访问其存储的值，包括使用 as<Type>() 进行类型转换访问，使用 [] 和 .at() 访问数组元素和对象成员，以及使用迭代器遍历容器类型。在实际应用中，应根据具体场景选择合适的访问方式，并结合类型检查来确保类型安全，避免运行时错误。理解这些访问方法是有效使用 folly::dynamic 的关键。
2.4 修改 dynamic 对象的值 (Modifying Values of dynamic Objects)
folly::dynamic 的一个重要特性是其值的可修改性。可以修改 dynamic 对象本身的值，也可以修改 dynamic 数组和对象中包含的元素或成员的值。理解如何修改 dynamic 对象的值对于动态数据处理至关重要。
修改 dynamic 对象本身的值
可以直接对 dynamic 对象进行赋值操作，以修改其存储的值和类型。这与初始化 dynamic 对象的方式类似。
1
folly::dynamic var = 10;
2
std::cout << "Initial Value: " << var.asInt() << std::endl; // 输出 10
3
4
var = "new value"; // 修改为字符串类型
5
std::cout << "Modified Value: " << var.asString() << std::endl; // 输出 "new value"
6
7
var = folly::dynamic::array(1, 2, 3); // 修改为数组类型
8
std::cout << "Modified Value (JSON): " << var.toJson() << std::endl; // 输出 "[1,2,3]"
修改 Array 元素
可以使用 [] 运算符或 .at() 方法来修改 dynamic 数组中指定索引位置的元素。与访问元素类似，[] 运算符不会进行边界检查，而 .at() 方法会在索引越界时抛出异常。
1
folly::dynamic dynamicArray = folly::dynamic::array(1, "two", 3.0);
2
std::cout << "Initial Array: " << dynamicArray.toJson() << std::endl; // 输出 "[1,\"two\",3]"
3
4
dynamicArray[0] = 100; // 修改索引 0 的元素
5
dynamicArray.at(1) = "modified two"; // 修改索引 1 的元素
6
// dynamicArray[3] = 4; // 越界访问，使用 [] 运算符不会报错，但行为未定义
7
// dynamicArray.at(3) = 4; // 越界访问，使用 .at() 方法会抛出 std::out_of_range 异常
8
9
std::cout << "Modified Array: " << dynamicArray.toJson() << std::endl; // 输出 "[100,\"modified two\",3]"
修改 Object 成员
可以使用 [] 运算符或 .insert() 方法来修改 dynamic 对象中指定键名的成员的值。如果键名已存在，则会修改其对应的值；如果键名不存在，则会添加新的键值对。
1
folly::dynamic dynamicObject = folly::dynamic::object("name", "Alice", "age", 28);
2
std::cout << "Initial Object: " << dynamicObject.toJson() << std::endl; // 输出 "{\"name\":\"Alice\",\"age\":28}"
3
4
dynamicObject["age"] = 30; // 修改已存在的键 "age" 的值
5
dynamicObject["city"] = "New York"; // 添加新的键值对 "city": "New York"
6
// dynamicObject.insert("country", "USA"); // 也可以使用 insert 方法添加键值对
7
8
std::cout << "Modified Object: " << dynamicObject.toJson() << std::endl; // 输出 "{\"name\":\"Alice\",\"age\":30,\"city\":\"New York\"}"
使用引用修改
当需要直接修改 dynamic 数组或对象中的元素或成员时，可以使用引用来避免不必要的拷贝。通过使用引用，可以直接在原始 dynamic 对象上进行修改。
1
folly::dynamic dynamicArray = folly::dynamic::array(1, 2, 3);
2
if (dynamicArray.isArray() && dynamicArray.size() > 1) {
3
folly::dynamic& elementRef = dynamicArray[1]; // 获取索引 1 元素的引用
4
elementRef = "modified"; // 通过引用修改元素值
5
}
6
std::cout << "Modified Array (by ref): " << dynamicArray.toJson() << std::endl; // 输出 "[1,\"modified\",3]"
7
8
folly::dynamic dynamicObject = folly::dynamic::object("key", "value");
9
if (dynamicObject.isObject()) {
10
folly::dynamic& memberRef = dynamicObject["key"]; // 获取键 "key" 成员的引用
11
memberRef = 123; // 通过引用修改成员值
12
}
13
std::cout << "Modified Object (by ref): " << dynamicObject.toJson() << std::endl; // 输出 "{\"key\":123}"
注意事项
⚝ 类型安全: 修改 dynamic 对象的值时，需要注意类型安全。虽然 dynamic 类型灵活，但在后续访问和操作时，仍然需要确保类型的一致性，避免类型错误。
⚝ 容器边界: 修改 dynamic 数组元素时，需要注意数组边界，避免越界访问。.at() 方法提供了边界检查，可以用于更安全的修改操作。
⚝ 对象键名: 修改 dynamic 对象成员时，键名必须是字符串类型。
总结
folly::dynamic 提供了多种灵活的方式来修改其值，包括直接赋值、修改数组元素、修改对象成员以及使用引用修改。理解这些修改操作是使用 folly::dynamic 进行动态数据处理的关键。在实际应用中，应根据具体场景选择合适的修改方式，并注意类型安全和容器边界，以确保代码的正确性和健壮性。
2.5 dynamic 对象的类型判断与转换 (Type Checking and Conversion of dynamic Objects)
在处理 folly::dynamic 对象时，由于其动态类型的特性，经常需要在运行时判断对象的实际类型，并根据需要进行类型转换。类型判断和转换是确保代码健壮性和避免运行时错误的关键步骤。folly::dynamic 提供了一系列方法用于类型判断和转换。
类型判断
如 2.2 节所述，folly::dynamic 提供了 is<Type>() 系列方法用于类型判断。这些方法返回布尔值，指示 dynamic 对象是否为指定的类型。常用的类型判断方法包括：
⚝ isNull()
⚝ isBool()
⚝ isInt()
⚝ isDouble()
⚝ isString()
⚝ isArray()
⚝ isObject()
⚝ isUndefined()
⚝ isNumber()
⚝ isSimple()
⚝ isContainer()
这些方法可以用于在访问或转换 dynamic 对象的值之前，先进行类型检查，从而避免类型不匹配导致的错误。
1
folly::dynamic var;
2
3
var = 123;
4
if (var.isInt()) {
5
std::cout << "var is Integer" << std::endl;
6
} else {
7
std::cout << "var is not Integer" << std::endl;
8
}
9
10
var = "hello";
11
if (var.isString()) {
12
std::cout << "var is String" << std::endl;
13
} else {
14
std::cout << "var is not String" << std::endl;
15
}
16
17
var = folly::dynamic::array();
18
if (var.isArray()) {
19
std::cout << "var is Array" << std::endl;
20
} else {
21
std::cout << "var is not Array" << std::endl;
22
}
类型转换
folly::dynamic 提供了 as<Type>() 系列方法用于显式类型转换。这些方法尝试将 dynamic 对象转换为指定的 C++ 类型，并返回转换后的值。如果类型不兼容，会抛出 std::bad_cast 异常。常用的类型转换方法包括：
⚝ asNull()
⚝ asBool()
⚝ asInt()
⚝ asDouble()
⚝ asString()
⚝ asArray()
⚝ asObject()
在使用 as<Type>() 方法进行类型转换时，务必先进行类型判断，以确保类型兼容，避免异常。
1
folly::dynamic dynamicVar = 123;
2
3
if (dynamicVar.isInt()) {
4
int intValue = dynamicVar.asInt(); // 安全转换为 int
5
std::cout << "Integer Value: " << intValue << std::endl;
6
}
7
8
folly::dynamic dynamicStr = "true";
9
// 注意：字符串 "true" 或 "false" 不能直接转换为 bool 类型
10
// 需要手动解析字符串
11
if (dynamicStr.isString()) {
12
std::string strValue = dynamicStr.asString();
13
bool boolValue;
14
if (strValue == "true") {
15
boolValue = true;
16
} else if (strValue == "false") {
17
boolValue = false;
18
} else {
19
// 字符串不是 "true" 或 "false"，处理错误情况
20
std::cerr << "Error: Cannot convert string to bool" << std::endl;
21
boolValue = false; // 默认值
22
}
23
std::cout << "Bool Value (from string): " << boolValue << std::endl;
24
}
25
26
folly::dynamic dynamicDouble = 3.14;
27
if (dynamicDouble.isDouble()) {
28
double doubleValue = dynamicDouble.asDouble(); // 安全转换为 double
29
std::cout << "Double Value: " << doubleValue << std::endl;
30
}
toJson() 方法
toJson() 方法可以将 dynamic 对象转换为 JSON 格式的字符串。这在需要序列化 dynamic 对象或者输出其内容时非常有用。toJson() 方法会递归地将 dynamic 对象及其包含的数组和对象转换为 JSON 格式。
1
folly::dynamic dynamicData = folly::dynamic::object(
2
"name", "Alice",
3
"age", 30,
4
"address", folly::dynamic::object(
5
"city", "New York",
6
"zip", "10001"
7
),
8
"hobbies", folly::dynamic::array("reading", "hiking")
9
);
10
11
std::string jsonString = dynamicData.toJson();
12
std::cout << "JSON String: " << jsonString << std::endl;
13
// 输出 JSON String: {"name":"Alice","age":30,"address":{"city":"New York","zip":"10001"},"hobbies":["reading","hiking"]}
类型转换的安全性
类型转换操作需要谨慎处理，特别是从 dynamic 类型转换为静态 C++ 类型时。不正确的类型转换可能导致运行时异常或未定义行为。因此，最佳实践是在进行类型转换之前，始终使用类型判断方法进行检查，确保类型兼容。
总结
folly::dynamic 提供了完善的类型判断和转换机制，使得在运行时处理动态类型数据成为可能。通过结合使用 is<Type>() 和 as<Type>() 方法，可以安全地访问和操作 dynamic 对象的值。toJson() 方法则提供了将 dynamic 对象序列化为 JSON 字符串的便捷方式。在实际应用中，合理使用类型判断和转换，可以编写出既灵活又健壮的 folly::dynamic 代码。
2.6 dynamic 与容器的结合 (dynamic and Containers)
folly::dynamic 不仅自身可以作为动态类型的容器（Array 和 Object），还可以与 C++ 标准库中的容器（如 std::vector, std::map, std::list 等）以及 Folly 库中的其他容器灵活结合使用。这种结合使得在 C++ 中处理动态数据结构变得更加方便和高效。
dynamic 数组作为容器
dynamic 数组本身就是一个动态容器，可以存储任意类型的 dynamic 元素。可以像操作 std::vector 一样操作 dynamic 数组，例如添加元素、访问元素、遍历等。
1
folly::dynamic dynamicArray = folly::dynamic::array();
2
dynamicArray.push_back(1);
3
dynamicArray.push_back("hello");
4
dynamicArray.push_back(folly::dynamic::object("key", "value"));
5
6
for (const auto& item : dynamicArray.items()) {
7
std::cout << "Array Item (JSON): " << item.toJson() << std::endl;
8
}
dynamic 对象作为关联容器
dynamic 对象类似于关联容器，可以存储键值对，其中键是字符串，值是 dynamic 类型。可以像操作 std::map 一样操作 dynamic 对象，例如插入、访问、删除键值对，遍历等。
1
folly::dynamic dynamicObject = folly::dynamic::object();
2
dynamicObject["name"] = "Alice";
3
dynamicObject["age"] = 30;
4
dynamicObject["hobbies"] = folly::dynamic::array("reading", "hiking");
5
6
for (const auto& pair : dynamicObject.items()) {
7
std::cout << "Object Key: " << pair.first.asString() << ", Value (JSON): " << pair.second.toJson() << std::endl;
8
}
在标准库容器中使用 dynamic
可以将 folly::dynamic 作为元素类型，存储在 C++ 标准库容器中，例如 std::vector<folly::dynamic>, std::list<folly::dynamic>, std::map<std::string, folly::dynamic> 等。这使得可以使用标准库容器的强大功能来管理和操作动态数据。
⚝ std::vector<folly::dynamic>
1
std::vector<folly::dynamic> dynamicVector;
2
dynamicVector.push_back(1);
3
dynamicVector.push_back("string");
4
dynamicVector.push_back(folly::dynamic::object("key", "value"));
5
6
for (const auto& item : dynamicVector) {
7
std::cout << "Vector Item (JSON): " << item.toJson() << std::endl;
8
}
⚝ std::map<std::string, folly::dynamic>
1
std::map<std::string, folly::dynamic> dynamicMap;
2
dynamicMap["key1"] = 100;
3
dynamicMap["key2"] = "text";
4
dynamicMap["key3"] = folly::dynamic::array(1, 2, 3);
5
6
for (const auto& pair : dynamicMap) {
7
std::cout << "Map Key: " << pair.first << ", Value (JSON): " << pair.second.toJson() << std::endl;
8
}
嵌套容器与 dynamic
可以将 dynamic 容器和标准库容器进行嵌套组合，构建复杂的数据结构。例如，可以使用 std::vector<folly::dynamic::object> 表示一个对象数组，或者使用 folly::dynamic::object 存储 std::vector<int> 等静态类型容器。
1
// 对象数组：std::vector<folly::dynamic::object>
2
std::vector<folly::dynamic::object> objectArray;
3
objectArray.push_back(folly::dynamic::object("name", "Person1", "age", 25));
4
objectArray.push_back(folly::dynamic::object("name", "Person2", "age", 30));
5
6
for (const auto& obj : objectArray) {
7
std::cout << "Object in Array (JSON): " << obj.toJson() << std::endl;
8
}
9
10
// dynamic 对象存储静态类型容器：folly::dynamic::object 存储 std::vector<int>
11
folly::dynamic dynamicContainerObject = folly::dynamic::object();
12
std::vector<int> intVector = {1, 2, 3, 4, 5};
13
// 需要将 std::vector<int> 转换为 folly::dynamic 才能存储
14
// 这里假设有一个函数 convertToDynamic 可以完成转换 (实际应用中需要手动实现或使用其他库)
15
// dynamicContainerObject["int_vector"] = convertToDynamic(intVector); // 假设的转换函数
16
17
// std::cout << "Dynamic Object with Vector (JSON): " << dynamicContainerObject.toJson() << std::endl; // 输出 JSON
优势与应用场景
⚝ 灵活性: dynamic 与容器的结合提供了极大的灵活性，可以处理各种复杂和动态的数据结构，尤其是在处理 JSON 数据、配置文件、动态 API 接口等场景下非常有用。
⚝ 互操作性: 可以方便地将 dynamic 数据与现有的 C++ 代码和标准库容器集成，实现平滑的数据交换和处理。
⚝ 简化代码: 使用 dynamic 可以简化动态数据处理的代码，避免手动管理多种类型的数据，提高开发效率。
注意事项
⚝ 性能: 动态类型有一定的性能开销，在性能敏感的场景下需要注意评估。
⚝ 类型安全: 虽然 dynamic 提供了灵活性，但也牺牲了一部分编译时类型安全。需要通过运行时类型检查来保证代码的健壮性。
总结
folly::dynamic 与容器的结合是其强大功能的重要体现。无论是作为动态容器本身，还是与标准库容器结合使用，dynamic 都为 C++ 动态数据处理提供了便捷而强大的工具。理解 dynamic 与容器的结合使用，可以更好地利用 folly::dynamic 解决实际问题，构建灵活、可扩展的应用程序。
END_OF_CHAPTER
3. chapter 3： dynamic 与 JSON (dynamic and JSON)
3.1 JSON 格式简介 (Introduction to JSON Format)
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，以其易于人阅读和编写，同时也易于机器解析和生成而著称。自其诞生以来，JSON 已成为 Web 应用中数据交换的事实标准，并广泛应用于配置文件、数据存储等多个领域。理解 JSON 格式对于掌握 folly::dynamic 的应用至关重要，因为 dynamic 类型经常被用于处理和操作 JSON 数据。
JSON 格式的核心特点包括：
① 轻量级 (Lightweight)：JSON 采用简洁的文本格式，相比 XML 等其他数据交换格式，其语法更加精简，数据量更小，传输效率更高。
② 易于人阅读和编写 (Human-readable and writable)：JSON 的语法结构清晰，采用键值对（key-value pairs）和数组（arrays）等结构，易于理解和编写。
③ 易于机器解析和生成 (Machine-parsable and generatable)：JSON 的语法规则简单明确，各种编程语言都提供了方便的库来解析和生成 JSON 数据。
④ 语言无关性 (Language-independent)：JSON 格式不依赖于任何特定的编程语言，可以跨平台、跨语言进行数据交换，具有良好的通用性。
⑤ 文本格式 (Text-based)：JSON 数据以纯文本形式存在，可以使用任何文本编辑器进行查看和编辑。
JSON 的数据类型主要包括以下几种：
⚝ 字符串（String）：由双引号 " 包围的 Unicode 字符序列。例如："hello"。
⚝ 数字（Number）：可以是整数或浮点数，支持十进制和指数形式。例如：123，-45.6，1.2e+5。
⚝ 布尔值（Boolean）：只有两个值 true 或 false，注意都是小写。
⚝ 空值（Null）：用 null 表示，同样是小写。
⚝ 对象（Object）：由花括号 {} 包围，包含一组无序的键值对（key-value pairs）。键（key）必须是字符串，值（value）可以是任意 JSON 数据类型。键值对之间用逗号 , 分隔，键和值之间用冒号 : 分隔。例如：{"name": "Alice", "age": 30}。
⚝ 数组（Array）：由方括号 [] 包围，包含一组有序的值（values）。值可以是任意 JSON 数据类型，值之间用逗号 , 分隔。例如：[1, 2, "three", true]。
一个典型的 JSON 文档示例：
1
{
2
"name": "示例数据",
3
"version": "1.0",
4
"author": {
5
"name": "John Doe",
6
"email": "john.doe@example.com"
7
},
8
"features": [
9
"轻量级",
10
"易读易写",
11
"跨平台"
12
],
13
"isActive": true,
14
"config": null
15
}
在这个例子中，我们看到了 JSON 的对象和数组的嵌套使用，以及各种基本数据类型。理解这些基本概念是使用 folly::dynamic 处理 JSON 的基础。在接下来的章节中，我们将学习如何使用 folly::dynamic 来解析和生成 JSON 数据，以及如何处理更复杂的 JSON 结构。
3.2 使用 dynamic 解析 JSON (Parsing JSON with dynamic)
folly::dynamic 库提供了一种非常方便的方式来解析 JSON 字符串。通过 folly::parseJson 函数，我们可以将 JSON 字符串转换为 dynamic 对象，从而可以像操作动态类型数据一样操作 JSON 数据。
folly::parseJson 函数的基本用法非常简单。它接受一个字符串参数，该字符串应为合法的 JSON 格式，函数会返回一个 dynamic 对象，该对象表示解析后的 JSON 数据。如果输入的字符串不是合法的 JSON 格式，folly::parseJson 函数会抛出异常。
以下代码示例展示了如何使用 folly::parseJson 解析一个简单的 JSON 字符串：
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
6
int main() {
7
std::string json_string = R"({"name": "Alice", "age": 30})";
8
9
try {
10
folly::dynamic parsed_json = folly::parseJson(json_string);
11
12
// 访问解析后的 JSON 数据
13
std::cout << "Name: " << parsed_json["name"].asString() << std::endl;
14
std::cout << "Age: " << parsed_json["age"].asInt() << std::endl;
15
16
} catch (const std::exception& e) {
17
std::cerr << "JSON 解析错误: " << e.what() << std::endl;
18
return 1;
19
}
20
21
return 0;
22
}
代码解析：
① 包含头文件：首先，我们需要包含 <folly/dynamic.h> 和 <folly/json.h> 头文件，以便使用 folly::dynamic 和 folly::parseJson 函数。同时包含 <iostream> 和 <string> 用于输入输出和字符串操作。
② JSON 字符串：我们定义了一个 JSON 字符串 json_string，使用了原始字符串字面量 R"(...)"，这样可以方便地在字符串中包含双引号，而无需转义。
③ try-catch 块：由于 folly::parseJson 在解析失败时会抛出异常，我们使用 try-catch 块来捕获可能发生的异常，并进行错误处理。
④ 解析 JSON：folly::parseJson(json_string) 函数将 JSON 字符串解析为 folly::dynamic 对象，并将结果赋值给 parsed_json 变量。
⑤ 访问 JSON 数据：通过 parsed_json["name"] 和 parsed_json["age"] 可以访问 JSON 对象中的键值。asString() 和 asInt() 方法用于将 dynamic 对象转换为相应的 C++ 类型。需要注意的是，如果类型不匹配，例如尝试将字符串类型的 "name" 转换为整数，将会抛出异常。
⑥ 异常处理：如果 JSON 解析过程中发生错误，catch 块会捕获异常，并打印错误信息到标准错误输出。
错误处理
JSON 解析过程中可能出现多种错误，例如 JSON 格式不正确、JSON 字符串为空等。为了保证程序的健壮性，必须进行适当的错误处理。如上述代码所示，使用 try-catch 块可以有效地捕获 folly::parseJson 抛出的异常。在 catch 块中，可以根据具体的异常类型进行不同的处理，例如打印错误信息、记录日志、或者进行重试等操作。
访问解析后的 JSON 数据
解析 JSON 字符串后，我们得到的是一个 folly::dynamic 对象。访问 dynamic 对象中的值，可以使用以下方法：
⚝ 下标运算符 []：对于 JSON 对象和数组，可以使用下标运算符 [] 通过键（对于对象）或索引（对于数组）来访问值。例如，parsed_json["name"] 访问 JSON 对象中键为 "name" 的值，parsed_json[0] 访问 JSON 数组中的第一个元素。
⚝ 类型转换方法 as*()：dynamic 对象提供了 asBool()、asInt()、asDouble()、asString()、asArray()、asObject() 等方法，用于将 dynamic 对象转换为相应的 C++ 类型。使用这些方法时需要确保 dynamic 对象实际存储的类型与目标类型兼容，否则会抛出异常。
⚝ is*() 方法：可以使用 isBool()、isInt()、isDouble()、isString()、isArray()、isObject()、isNull() 等方法来判断 dynamic 对象当前存储的类型。这在进行类型转换之前进行类型检查非常有用，可以避免类型转换错误。
通过结合下标运算符和类型转换方法，我们可以灵活地访问和操作解析后的 JSON 数据。在实际应用中，通常需要根据 JSON 数据的结构，选择合适的访问方式。
3.3 使用 dynamic 生成 JSON (Generating JSON with dynamic)
folly::dynamic 不仅可以用于解析 JSON，还可以用于生成 JSON 字符串。通过构建 folly::dynamic 对象，并使用 folly::toJson 函数，我们可以将 dynamic 对象转换为 JSON 格式的字符串。
folly::toJson 函数接受一个 folly::dynamic 对象作为参数，返回一个 std::string 对象，该字符串是 dynamic 对象对应的 JSON 格式表示。
以下代码示例展示了如何使用 folly::dynamic 生成 JSON 字符串：
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
#include <vector>
6
7
int main() {
8
folly::dynamic data = folly::dynamic::object; // 创建一个 JSON 对象
9
10
data["name"] = "Bob"; // 添加字符串类型的键值对
11
data["age"] = 25; // 添加整数类型的键值对
12
data["isStudent"] = true; // 添加布尔类型的键值对
13
data["courses"] = folly::dynamic::array("Math", "Physics", "Computer Science"); // 添加数组类型的键值对
14
15
std::string json_string = folly::toJson(data); // 将 dynamic 对象转换为 JSON 字符串
16
17
std::cout << "Generated JSON: " << json_string << std::endl;
18
19
return 0;
20
}
代码解析：
① 创建 dynamic 对象：首先，我们使用 folly::dynamic::object 创建一个表示 JSON 对象的 dynamic 对象 data。folly::dynamic::array() 可以用于创建 JSON 数组。
② 构建 JSON 数据：通过类似字典的操作，我们可以向 data 对象中添加键值对。例如，data["name"] = "Bob"; 添加了一个键为 "name"，值为字符串 "Bob" 的键值对。对于数组类型的值，我们使用 folly::dynamic::array() 创建一个 dynamic 数组对象，并将其赋值给 data["courses"]。
③ 生成 JSON 字符串：folly::toJson(data) 函数将 dynamic 对象 data 转换为 JSON 格式的字符串，并将结果赋值给 json_string 变量。
④ 输出 JSON 字符串：最后，我们将生成的 JSON 字符串打印到标准输出。
构建复杂的 JSON 结构
通过 folly::dynamic，我们可以构建任意复杂的 JSON 结构，包括嵌套的对象和数组。例如，要创建一个包含嵌套对象的 JSON，可以这样做：
1
folly::dynamic address = folly::dynamic::object;
2
address["street"] = "Main Street";
3
address["city"] = "Anytown";
4
address["zipCode"] = "12345";
5
6
folly::dynamic person = folly::dynamic::object;
7
person["name"] = "Charlie";
8
person["age"] = 35;
9
person["address"] = address; // 嵌套对象
10
11
std::string json_string = folly::toJson(person);
12
std::cout << "Generated JSON with nested object: " << json_string << std::endl;
同样，可以创建嵌套数组，或者对象和数组的混合嵌套结构。folly::dynamic 提供了灵活的方式来构建各种 JSON 数据结构。
JSON 格式化输出
默认情况下，folly::toJson 生成的 JSON 字符串是紧凑格式的，不包含额外的空格和换行符。为了提高 JSON 字符串的可读性，可以使用 folly::json::serialization_opts 来控制 JSON 的序列化格式。例如，可以使用 folly::json::serialization_opts::PRETTY_PRINT 选项生成格式化输出的 JSON 字符串。
1
folly::json::serialization_opts opts;
2
opts.pretty_print = true; // 启用格式化输出
3
std::string formatted_json_string = folly::toJson(data, opts);
4
std::cout << "Formatted JSON: \n" << formatted_json_string << std::endl;
通过设置 opts.pretty_print = true;，生成的 JSON 字符串将包含缩进和换行符，使其更易于阅读。folly::json::serialization_opts 还提供了其他选项，例如控制是否转义非 ASCII 字符等，可以根据需要进行配置。
3.4 处理复杂的 JSON 数据结构 (Handling Complex JSON Data Structures)
在实际应用中，我们经常需要处理复杂的 JSON 数据结构，例如嵌套的对象和数组。folly::dynamic 提供了强大的工具来处理这些复杂结构，使得我们可以方便地访问、修改和操作 JSON 数据。
访问嵌套对象和数组
对于嵌套的 JSON 对象和数组，我们可以通过链式调用下标运算符 [] 来访问深层嵌套的值。例如，假设我们有以下 JSON 数据：
1
{
2
"company": {
3
"name": "TechCorp",
4
"employees": [
5
{
6
"name": "David",
7
"department": "Engineering"
8
},
9
{
10
"name": "Eve",
11
"department": "Marketing"
12
}
13
]
14
}
15
}
要访问第一个员工的名字 "David"，可以使用以下代码：
1
std::string json_string = R"({"company": {"name": "TechCorp", "employees": [{"name": "David", "department": "Engineering"}, {"name": "Eve", "department": "Marketing"}]}})";
2
folly::dynamic parsed_json = folly::parseJson(json_string);
3
4
std::string employee_name = parsed_json["company"]["employees"][0]["name"].asString();
5
std::cout << "First employee name: " << employee_name << std::endl;
代码解析：
① parsed_json["company"]：首先，通过键 "company" 访问顶层 JSON 对象中的 "company" 对象。
② ["employees"]：然后，在 "company" 对象的基础上，通过键 "employees" 访问 "employees" 数组。
③ [0]：接着，访问 "employees" 数组的第一个元素，即第一个员工对象。
④ ["name"]：最后，在第一个员工对象的基础上，通过键 "name" 访问员工的名字。
⑤ .asString()：将最终得到的 dynamic 对象转换为字符串类型。
通过这种链式调用的方式，我们可以方便地访问任意深度的嵌套 JSON 数据。
迭代 JSON 数组和对象
当需要遍历 JSON 数组或对象中的所有元素时，可以使用 dynamic 对象的迭代器。dynamic 对象提供了 items() 方法，用于返回一个可以迭代对象或数组的迭代器范围。
迭代 JSON 数组
对于 JSON 数组，可以使用 items() 方法结合循环来遍历数组中的所有元素。
1
folly::dynamic array_data = folly::dynamic::array(10, 20, 30, 40, 50);
2
3
std::cout << "Iterating through array: ";
4
for (auto const& item : array_data.items()) {
5
std::cout << item.second.asInt() << " "; // item.second 是数组元素的值
6
}
7
std::cout << std::endl;
迭代 JSON 对象
对于 JSON 对象，items() 方法返回的迭代器会遍历对象中的所有键值对。迭代器的 first 成员是键，second 成员是值。
1
folly::dynamic object_data = folly::dynamic::object("key1", "value1", "key2", "value2", "key3", "value3");
2
3
std::cout << "Iterating through object: " << std::endl;
4
for (auto const& item : object_data.items()) {
5
std::cout << "Key: " << item.first.asString() << ", Value: " << item.second.asString() << std::endl;
6
}
修改复杂的 JSON 结构
folly::dynamic 不仅可以访问复杂的 JSON 结构，还可以修改它们。通过下标运算符 [] 和赋值操作，我们可以修改 JSON 对象和数组中的值。
1
std::string json_string = R"({"settings": {"debug": false, "logLevel": "INFO"}})";
2
folly::dynamic parsed_json = folly::parseJson(json_string);
3
4
// 修改 debug 值为 true
5
parsed_json["settings"]["debug"] = true;
6
7
// 修改 logLevel 值为 "DEBUG"
8
parsed_json["settings"]["logLevel"] = "DEBUG";
9
10
std::cout << "Modified JSON: " << folly::toJson(parsed_json) << std::endl;
在这个例子中，我们通过 parsed_json["settings"]["debug"] = true; 将嵌套对象 "settings" 中的 "debug" 键的值修改为 true。同样，parsed_json["settings"]["logLevel"] = "DEBUG"; 修改了 "logLevel" 键的值。修改后的 dynamic 对象可以通过 folly::toJson 重新转换为 JSON 字符串。
3.5 JSON 解析与生成性能优化 (Performance Optimization for JSON Parsing and Generation)
虽然 folly::dynamic 提供了方便的 JSON 处理方式，但在性能敏感的应用中，JSON 解析和生成的性能仍然需要关注。尤其是在处理大量 JSON 数据或者高并发场景下，性能优化显得尤为重要。
性能特点分析
folly::dynamic 和 folly::json 库在设计时已经考虑了性能。folly::parseJson 使用高效的 JSON 解析算法，folly::toJson 也经过了优化。然而，动态类型本身相比静态类型会有一定的性能开销。在 JSON 处理过程中，主要的性能瓶颈可能出现在以下几个方面：
① 解析开销：JSON 解析需要扫描和分析 JSON 字符串，并将其转换为 dynamic 对象。这个过程涉及到字符串处理、内存分配等操作，会消耗一定的 CPU 时间。
② 生成开销：JSON 生成需要将 dynamic 对象转换为 JSON 字符串。这个过程与解析类似，也涉及到数据结构遍历、字符串拼接等操作。
③ 动态类型开销：dynamic 类型在运行时需要进行类型检查和动态分发，这会带来一定的运行时开销，相比直接操作静态类型数据，性能会有所下降。
④ 内存分配：JSON 解析和生成过程中，可能会涉及到大量的内存分配和释放操作，频繁的内存操作也会影响性能。
优化策略
为了提高 JSON 解析和生成的性能，可以考虑以下优化策略：
① 减少不必要的解析和生成：在应用设计时，应尽量避免不必要的 JSON 解析和生成操作。例如，如果只需要访问 JSON 数据中的少量字段，可以考虑使用流式 JSON 解析器，只解析需要的字段，而不是将整个 JSON 文档解析到 dynamic 对象中。虽然 folly::dynamic 本身不直接提供流式解析 API，但在某些场景下，可以考虑与其他 JSON 库结合使用，或者自行实现流式解析逻辑。
② 重用 dynamic 对象：如果需要频繁地解析或生成结构相似的 JSON 数据，可以考虑重用 dynamic 对象，避免重复创建和销毁 dynamic 对象。例如，可以将解析后的 dynamic 对象缓存起来，下次需要相同结构的数据时直接使用缓存。
③ 选择合适的 JSON 库：folly::json 已经是一个高性能的 JSON 库，但在某些极端性能要求的场景下，可以考虑对比其他 JSON 库的性能，选择最适合的库。例如，RapidJSON、simdjson 等库在某些方面可能具有更高的性能。然而，切换到其他库可能需要修改代码，并失去 folly::dynamic 带来的便利性。
④ 优化内存管理：folly::dynamic 内部使用了高效的内存管理策略。在自定义内存分配器方面，folly 提供了相关的接口，可以根据具体应用场景进行定制化的内存管理优化。例如，可以使用 jemalloc 或 tcmalloc 等高性能内存分配器，或者针对 JSON 数据的特点，设计更高效的内存分配策略。
⑤ 编译优化：确保代码在编译时启用了优化选项（例如 -O2 或 -O3），编译器优化可以显著提高代码的执行效率。
⑥ 性能测试和分析：在进行性能优化时，务必进行充分的性能测试和分析。使用性能分析工具（例如 perf、gprof 等）找出性能瓶颈，然后针对瓶颈进行优化。避免盲目优化，要基于实际的性能数据进行优化。
性能测试示例
可以使用 benchmark 工具来测试 folly::parseJson 和 folly::toJson 的性能。以下是一个简单的 benchmark 示例，使用 Google Benchmark 框架测试 JSON 解析性能：
1
#include <benchmark/benchmark.h>
2
#include <folly/dynamic.h>
3
#include <folly/json.h>
4
#include <string>
5
6
static void BM_ParseJson(benchmark::State& state) {
7
std::string json_string = R"({"name": "Benchmark Test", "value": 12345, "array": [1, 2, 3, 4, 5]})";
8
for (auto _ : state) {
9
folly::dynamic parsed_json = folly::parseJson(json_string);
10
benchmark::DoNotOptimize(parsed_json); // 防止编译器优化掉解析操作
11
}
12
}
13
BENCHMARK(BM_ParseJson);
14
15
// ... 可以添加 toJson 的 benchmark ...
16
17
BENCHMARK_MAIN();
通过运行 benchmark，可以得到 folly::parseJson 的性能数据，例如每秒解析 JSON 字符串的次数。可以根据 benchmark 结果评估性能，并验证优化策略的效果。
总结
JSON 解析和生成性能优化是一个复杂的主题，需要根据具体的应用场景和性能需求进行权衡和选择。folly::dynamic 和 folly::json 库本身已经具有良好的性能，但在高负载场景下，仍然需要关注性能优化。通过合理的优化策略，可以进一步提升 JSON 处理的效率，满足高性能应用的需求。
END_OF_CHAPTER
4. chapter 4： dynamic 高级应用 (Advanced Applications of dynamic)
4.1 dynamic 在配置文件处理中的应用 (dynamic in Configuration File Processing)
在软件开发中，配置文件扮演着至关重要的角色。它们允许我们在不重新编译代码的情况下修改程序的行为，极大地提升了软件的灵活性和可维护性。传统上，C++ 开发者可能会选择使用硬编码的配置、简单的文本文件，或者更复杂的 XML 或 INI 格式。然而，这些方法各有其局限性。硬编码缺乏灵活性，文本文件解析繁琐且容易出错，而 XML 和 INI 虽然结构化，但在处理复杂配置时显得冗余且不易扩展。
folly::dynamic 类型为配置文件处理提供了一种优雅且强大的解决方案。其动态类型特性使其能够灵活地表示各种配置数据结构，而无需预先定义严格的类型。这对于处理结构多变、schema 不固定的配置文件尤其有利。
dynamic 在配置文件处理中的优势：
① 灵活性 (Flexibility)：dynamic 可以容纳各种数据类型，包括基本类型（如整数、浮点数、字符串、布尔值）以及复杂的嵌套结构（如对象和数组）。这使得它能够轻松表示各种格式的配置文件，例如 JSON、YAML 甚至自定义格式。
② 易于解析 (Easy Parsing)：dynamic 与 JSON 格式天然契合。Folly 库本身提供了便捷的 JSON 解析工具，可以将 JSON 数据直接解析为 dynamic 对象，无需繁琐的手动解析过程。这大大简化了配置文件的读取和处理流程。
③ 类型安全 (Type Safety)：虽然 dynamic 是动态类型，但它仍然提供了运行时的类型检查。这意味着在访问 dynamic 对象的值时，可以进行类型判断，避免因类型错误导致的程序崩溃。同时，Folly 提供了丰富的 API 来进行类型转换和检查，保证了类型操作的安全性。
④ 可扩展性 (Extensibility)：当配置需求发生变化时，例如需要添加新的配置项或修改配置结构，使用 dynamic 可以轻松应对。无需修改数据结构定义，只需在配置文件中添加或修改相应的字段即可。这降低了维护成本，并提高了软件的适应性。
应用场景示例：JSON 配置文件
假设我们有一个应用程序，需要从 JSON 配置文件 config.json 中读取配置信息。配置文件内容如下：
1
{
2
"appName": "MyApp",
3
"version": "1.0.0",
4
"server": {
5
"host": "127.0.0.1",
6
"port": 8080,
7
"timeout": 30
8
},
9
"features": [
10
"featureA",
11
"featureB",
12
"featureC"
13
]
14
}
使用 folly::dynamic 解析和访问配置信息的 C++ 代码示例如下：
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <fstream>
4
#include <iostream>
5
6
int main() {
7
std::ifstream configFile("config.json");
8
if (!configFile.is_open()) {
9
std::cerr << "Failed to open config.json" << std::endl;
10
return 1;
11
}
12
13
std::string configStr((std::istreambuf_iterator<char>(configFile)),
14
std::istreambuf_iterator<char>());
15
16
folly::dynamic config = folly::parseJson(configStr);
17
18
std::string appName = config["appName"].asString();
19
std::string version = config["version"].asString();
20
std::string host = config["server"]["host"].asString();
21
int port = config["server"]["port"].asInt();
22
int timeout = config["server"]["timeout"].asInt();
23
std::vector<std::string> features;
24
for (const auto& feature : config["features"]) {
25
features.push_back(feature.asString());
26
}
27
28
std::cout << "App Name: " << appName << std::endl;
29
std::cout << "Version: " << version << std::endl;
30
std::cout << "Server Host: " << host << std::endl;
31
std::cout << "Server Port: " << port << std::endl;
32
std::cout << "Server Timeout: " << timeout << std::endl;
33
std::cout << "Features: ";
34
for (const auto& feature : features) {
35
std::cout << feature << " ";
36
}
37
std::cout << std::endl;
38
39
return 0;
40
}
代码解析：
- 读取配置文件：使用
std::ifstream读取config.json文件的内容到字符串configStr中。 - 解析 JSON：使用
folly::parseJson(configStr)将 JSON 字符串解析为folly::dynamic对象config。 - 访问配置项：通过键名（例如
"appName","server","features"）访问config对象中的配置项。可以使用链式访问来获取深层嵌套的配置值，例如config["server"]["host"]。 - 类型转换：使用
asString(),asInt()等方法将dynamic对象转换为所需的具体类型。需要注意的是，如果类型转换失败（例如，尝试将字符串转换为整数），会抛出异常。因此，在实际应用中，应该进行适当的异常处理或类型检查。 - 遍历数组：对于数组类型的配置项（例如
"features"），可以使用范围 for 循环遍历数组中的元素。
总结：
folly::dynamic 在配置文件处理中展现出强大的优势，尤其是在处理 JSON 等半结构化配置文件时。它简化了配置文件的解析和访问过程，提高了代码的灵活性和可维护性。通过结合 Folly 库提供的 JSON 解析工具，开发者可以轻松构建健壮且易于扩展的配置管理系统。
4.2 dynamic 在数据交换中的应用 (dynamic in Data Exchange)
在分布式系统和微服务架构中，数据交换是核心环节。服务之间需要通过网络传输数据进行通信和协作。常见的数据交换格式包括 JSON、XML、Protocol Buffers 等。folly::dynamic 在数据交换场景中同样具有独特的优势，尤其是在处理需要灵活数据结构和动态 schema 的情况。
dynamic 在数据交换中的优势：
① Schema 灵活性 (Schema Flexibility)：在数据交换过程中，数据结构可能会随着业务发展而演变。使用 dynamic 可以轻松应对 schema 的变化，无需预先定义严格的数据结构。发送端和接收端可以根据需要添加或修改数据字段，而不会影响彼此的兼容性。这对于快速迭代和敏捷开发至关重要。
② 易于序列化和反序列化 (Easy Serialization and Deserialization)：dynamic 对象可以方便地转换为 JSON 字符串，并从 JSON 字符串反序列化为 dynamic 对象。Folly 库提供了 folly::toJson() 和 folly::parseJson() 等函数，简化了序列化和反序列化过程。JSON 格式具有良好的跨语言和跨平台兼容性，使得 dynamic 成为构建异构系统数据交换的理想选择。
③ 动态数据处理 (Dynamic Data Processing)：在接收到 dynamic 数据后，可以根据需要动态地访问和处理数据字段。无需预先知道数据的具体结构，可以在运行时根据键名或索引访问数据。这为构建通用的数据处理逻辑提供了便利。
④ 减少代码耦合 (Reduced Code Coupling)：使用 dynamic 可以降低发送端和接收端代码之间的耦合度。发送端无需关心接收端如何解析数据，接收端也无需严格依赖发送端的数据结构定义。这种松耦合的设计提高了系统的可维护性和可扩展性。
应用场景示例：API 接口数据交换
假设我们构建一个 RESTful API 服务，需要处理客户端发送的 JSON 请求，并将 JSON 响应返回给客户端。使用 folly::dynamic 可以简化 API 接口的数据处理逻辑。
请求处理 (Request Handling)：
当 API 服务接收到客户端发送的 JSON 请求时，可以使用 folly::parseJson() 将 JSON 请求体解析为 dynamic 对象。然后，可以根据请求的 API 路径和请求参数，动态地访问 dynamic 对象中的数据，并执行相应的业务逻辑。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
6
// 模拟接收到的 JSON 请求字符串
7
std::string jsonRequest = R"({
8
"action": "getUserInfo",
9
"params": {
10
"userId": 12345,
11
"fields": ["name", "email", "phone"]
12
}
13
})";
14
15
int main() {
16
folly::dynamic request = folly::parseJson(jsonRequest);
17
18
std::string action = request["action"].asString();
19
folly::dynamic params = request["params"];
20
21
if (action == "getUserInfo") {
22
int userId = params["userId"].asInt();
23
std::vector<std::string> fields;
24
for (const auto& field : params["fields"]) {
25
fields.push_back(field.asString());
26
}
27
28
std::cout << "Action: " << action << std::endl;
29
std::cout << "User ID: " << userId << std::endl;
30
std::cout << "Fields: ";
31
for (const auto& field : fields) {
32
std::cout << field << " ";
33
}
34
std::cout << std::endl;
35
36
// ... 执行获取用户信息业务逻辑 ...
37
} else {
38
std::cerr << "Unknown action: " << action << std::endl;
39
}
40
41
return 0;
42
}
响应生成 (Response Generation)：
在 API 服务处理完请求后，可以使用 dynamic 对象构建 JSON 响应。可以动态地构建响应数据结构，并将业务逻辑处理结果填充到 dynamic 对象中。最后，使用 folly::toJson() 将 dynamic 对象转换为 JSON 字符串，并返回给客户端。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
6
int main() {
7
folly::dynamic response = folly::dynamic::object(); // 创建一个 dynamic 对象，类型为 object
8
response["status"] = "success";
9
response["code"] = 200;
10
response["data"] = folly::dynamic::object(); // data 字段也是一个 object
11
response["data"]["userName"] = "John Doe";
12
response["data"]["email"] = "john.doe@example.com";
13
14
std::string jsonResponse = folly::toJson(response);
15
16
std::cout << "JSON Response: " << jsonResponse << std::endl;
17
18
return 0;
19
}
代码解析：
⚝ 请求处理：接收 JSON 请求，使用 folly::parseJson() 解析为 dynamic 对象，根据请求内容动态访问和处理数据。
⚝ 响应生成：创建 dynamic::object() 对象作为 JSON 响应的根对象，动态构建响应数据结构，并使用 folly::toJson() 将 dynamic 对象转换为 JSON 字符串。
总结：
folly::dynamic 在数据交换中，尤其是在构建 API 接口时，提供了极大的灵活性和便利性。它简化了 JSON 数据的序列化和反序列化过程，降低了代码耦合度，并提高了系统的可维护性和可扩展性。对于需要处理动态 schema 和快速迭代的数据交换场景，dynamic 是一个非常有价值的选择。
4.3 dynamic 与反射 (dynamic and Reflection)
反射（Reflection）是一种程序在运行时检查自身结构的能力。它允许程序在运行时获取类型信息、类成员、方法等元数据，并可以动态地调用方法、访问属性等。反射在很多场景下都非常有用，例如：
⚝ 序列化和反序列化：根据对象的结构动态地将对象转换为字节流或从字节流恢复对象。
⚝ 依赖注入：在运行时根据配置动态地创建和组装对象。
⚝ 单元测试：动态地访问对象的内部状态进行测试。
⚝ 通用代码：编写可以处理不同类型对象的通用代码，例如通用的数据处理框架。
C++ 是一门静态类型语言，本身并不原生支持反射。传统的 C++ 反射实现通常依赖于宏、模板元编程或外部工具，实现复杂且效率较低。folly::dynamic 虽然不是真正的反射机制，但它提供了一种在一定程度上模拟反射行为的方式，尤其是在处理动态数据和 JSON 数据时。
dynamic 模拟反射的原理：
dynamic 对象本质上是一个可以容纳多种类型的容器。它可以存储基本类型、对象和数组。当我们将一个 C++ 对象转换为 dynamic 对象时，我们可以将对象的成员变量和方法以键值对的形式存储在 dynamic 对象中。然后，我们可以通过键名动态地访问这些成员，类似于反射中的属性访问。
使用 dynamic 模拟反射的示例：
假设我们有一个简单的 C++ 类 Person：
1
#include <iostream>
2
#include <string>
3
4
class Person {
5
public:
6
Person(std::string name, int age) : name_(name), age_(age) {}
7
8
std::string getName() const { return name_; }
9
int getAge() const { return age_; }
10
void printInfo() const {
11
std::cout << "Name: " << name_ << ", Age: " << age_ << std::endl;
12
}
13
14
private:
15
std::string name_;
16
int age_;
17
};
我们可以将 Person 对象转换为 dynamic 对象，并动态地访问其成员：
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
6
class Person { // ... (Person 类的定义同上) ... };
7
8
int main() {
9
Person person("Alice", 30);
10
11
// 将 Person 对象的信息转换为 dynamic 对象
12
folly::dynamic personDynamic = folly::dynamic::object();
13
personDynamic["name"] = person.getName();
14
personDynamic["age"] = person.getAge();
15
16
// 动态访问 dynamic 对象中的成员
17
std::string name = personDynamic["name"].asString();
18
int age = personDynamic["age"].asInt();
19
20
std::cout << "Name (from dynamic): " << name << std::endl;
21
std::cout << "Age (from dynamic): " << age << std::endl;
22
23
// 模拟方法调用 (需要手动实现)
24
if (personDynamic.count("printInfo")) { // 假设我们有一个 "printInfo" 键，但实际上 dynamic 无法直接存储方法
25
// ... 模拟调用 printInfo 方法的逻辑 ... (此处仅为演示概念，实际无法直接通过 dynamic 调用方法)
26
person.printInfo(); // 实际调用 Person 对象的方法
27
}
28
29
return 0;
30
}
代码解析：
- 转换为 dynamic 对象：手动创建一个
dynamic::object()对象personDynamic，并将Person对象的name_和age_成员的值分别赋值给personDynamic对象的"name"和"age"键。 - 动态访问成员：通过键名
"name"和"age"动态地访问personDynamic对象中的成员值，并使用asString()和asInt()进行类型转换。 - 模拟方法调用：通过检查
dynamic对象是否包含"printInfo"键来模拟方法调用。注意：dynamic实际上无法直接存储和调用 C++ 对象的方法。此处仅为演示反射的概念。要实现真正的反射方法调用，需要更复杂的机制，例如函数指针或std::function的存储和调用。 在这个例子中，我们实际上仍然直接调用了原始Person对象的printInfo()方法。
dynamic 模拟反射的局限性：
⚝ 非真正的反射：dynamic 提供的只是对数据结构的动态访问，而不是真正的 C++ 反射。它无法获取类的元数据信息（例如，类名、成员类型、方法签名等），也无法动态地创建对象或调用方法。
⚝ 需要手动转换：将 C++ 对象转换为 dynamic 对象需要手动编写转换代码，将对象的成员逐个赋值给 dynamic 对象。反之亦然。
⚝ 性能开销：动态类型操作通常比静态类型操作具有一定的性能开销。
总结：
folly::dynamic 虽然不能完全替代 C++ 反射，但它提供了一种在一定程度上模拟反射行为的方式，尤其是在处理动态数据和 JSON 数据时。它可以简化对未知数据结构的访问和操作，提高代码的灵活性。在需要一定程度的动态性，但又不需要完整的反射功能的场景下，dynamic 是一个轻量级且实用的选择。对于真正的 C++ 反射需求，可能需要考虑使用更专业的反射库或技术。
4.4 自定义 dynamic 对象的行为 (Customizing the Behavior of dynamic Objects)
folly::dynamic 默认行为已经非常灵活和强大，但在某些高级应用场景中，我们可能需要进一步自定义 dynamic 对象的行为，以满足特定的需求。虽然 dynamic 本身的设计目标并非高度可定制化，但 Folly 库提供了一些机制，允许我们在一定程度上扩展和修改 dynamic 的行为。
自定义 dynamic 行为的方式：
① 操作符重载 (Operator Overloading)：dynamic 类重载了许多操作符，例如 [] (索引访问), = (赋值), +, -, ==, != 等。虽然我们不能直接为 dynamic 类添加新的操作符重载，但我们可以通过继承或组合的方式，创建自定义的 dynamic 派生类或包装类，并在这些类中重载操作符，从而扩展 dynamic 的行为。需要注意的是，直接继承 folly::dynamic 可能比较复杂，因为它是一个 final 类，并且其内部实现细节可能不适合直接继承。更常见的方法是使用组合，即将 dynamic 对象作为成员变量，并在包装类中提供自定义的操作符重载。
② 自定义访问器和修改器 (Custom Accessors and Mutators)：我们可以通过自定义函数或方法，封装对 dynamic 对象的访问和修改操作。在这些自定义的访问器和修改器中，我们可以添加额外的逻辑，例如类型检查、数据验证、默认值处理、数据转换等。这可以提高代码的健壮性和可读性。
③ 与自定义类型结合 (Integration with Custom Types)：dynamic 可以存储各种基本类型和容器类型。我们可以将自定义类型转换为 dynamic 对象，或者从 dynamic 对象转换为自定义类型。通过自定义转换逻辑，我们可以实现 dynamic 与自定义类型的无缝集成。
自定义行为示例：带默认值的 dynamic 访问
在某些情况下，我们希望在访问 dynamic 对象时，如果键不存在，则返回一个默认值，而不是抛出异常。我们可以通过自定义访问器函数来实现这个功能。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
6
// 自定义带默认值的 dynamic 访问函数
7
folly::dynamic getOrDefault(const folly::dynamic& obj, const std::string& key, const folly::dynamic& defaultValue) {
8
if (obj.count(key)) {
9
return obj[key];
10
} else {
11
return defaultValue;
12
}
13
}
14
15
int main() {
16
folly::dynamic config = folly::dynamic::object();
17
config["appName"] = "MyApp";
18
config["server"] = folly::dynamic::object();
19
config["server"]["host"] = "127.0.0.1";
20
21
// 使用自定义访问函数获取配置项，如果不存在则返回默认值
22
std::string appName = getOrDefault(config, "appName", "DefaultApp").asString();
23
int port = getOrDefault(config["server"], "port", 80).asInt(); // "port" 键不存在，返回默认值 80
24
std::string logDir = getOrDefault(config, "logDir", "/tmp/logs").asString(); // "logDir" 键不存在，返回默认值 "/tmp/logs"
25
26
std::cout << "App Name: " << appName << std::endl;
27
std::cout << "Port: " << port << std::endl;
28
std::cout << "Log Dir: " << logDir << std::endl;
29
30
return 0;
31
}
代码解析：
⚝ getOrDefault 函数：定义了一个名为 getOrDefault 的自定义访问函数，它接受一个 dynamic 对象 obj，一个键名 key，和一个默认值 defaultValue 作为参数。
⚝ 键存在性检查：在 getOrDefault 函数中，首先使用 obj.count(key) 检查键 key 是否存在于 dynamic 对象 obj 中。
⚝ 返回默认值：如果键存在，则返回 obj[key] 的值；如果键不存在，则返回 defaultValue。
⚝ 使用自定义访问函数：在 main 函数中，使用 getOrDefault 函数访问配置项 "appName", "server.port", "logDir"。对于不存在的键，getOrDefault 函数返回预定义的默认值，避免了异常抛出。
高级自定义行为：动态类型转换
我们可以通过自定义类型转换函数，实现 dynamic 对象与自定义类型之间的灵活转换。例如，我们可以定义一个函数，将 dynamic 对象转换为 Person 对象，或者将 Person 对象转换为 dynamic 对象。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
6
class Person { // ... (Person 类的定义同上) ... };
7
8
// 将 dynamic 对象转换为 Person 对象
9
Person dynamicToPerson(const folly::dynamic& personDynamic) {
10
std::string name = personDynamic["name"].asString();
11
int age = personDynamic["age"].asInt();
12
return Person(name, age);
13
}
14
15
// 将 Person 对象转换为 dynamic 对象
16
folly::dynamic personToDynamic(const Person& person) {
17
folly::dynamic personDynamic = folly::dynamic::object();
18
personDynamic["name"] = person.getName();
19
personDynamic["age"] = person.getAge();
20
return personDynamic;
21
}
22
23
int main() {
24
folly::dynamic personDynamicObj = folly::dynamic::object();
25
personDynamicObj["name"] = "Bob";
26
personDynamicObj["age"] = 25;
27
28
// dynamic 转换为 Person
29
Person bob = dynamicToPerson(personDynamicObj);
30
bob.printInfo();
31
32
// Person 转换为 dynamic
33
folly::dynamic bobDynamic = personToDynamic(bob);
34
std::cout << folly::toJson(bobDynamic) << std::endl;
35
36
return 0;
37
}
代码解析：
⚝ dynamicToPerson 函数：将 dynamic 对象 personDynamic 转换为 Person 对象。从 dynamic 对象中提取 "name" 和 "age" 字段，并创建 Person 对象。
⚝ personToDynamic 函数：将 Person 对象 person 转换为 dynamic 对象。创建一个 dynamic::object() 对象，并将 Person 对象的 name_ 和 age_ 成员赋值给 dynamic 对象的 "name" 和 "age" 字段。
总结：
虽然 folly::dynamic 的自定义能力有限，但通过操作符重载（间接方式）、自定义访问器和修改器，以及与自定义类型结合，我们仍然可以在一定程度上扩展和修改 dynamic 对象的行为，以满足更复杂和特定的应用需求。这些自定义技巧可以帮助我们更好地利用 dynamic 的灵活性，构建更健壮、更易于维护的应用程序。
4.5 dynamic 的线程安全性 (Thread Safety of dynamic)
在多线程编程环境中，线程安全性是一个至关重要的问题。如果一个数据结构不是线程安全的，多个线程同时访问和修改它可能会导致数据竞争、程序崩溃或其他不可预测的行为。理解 folly::dynamic 的线程安全性对于在多线程应用中正确使用 dynamic 至关重要。
dynamic 的线程安全级别：
folly::dynamic 本身不是完全线程安全的。这意味着在没有适当同步机制的情况下，多个线程同时访问和修改同一个 dynamic 对象可能会导致数据竞争。
线程安全的操作：
⚝ 只读操作 (Read-only Operations)：多个线程可以同时安全地读取同一个 dynamic 对象的值，而不会发生数据竞争。例如，多个线程可以同时调用 asString(), asInt(), isObject(), isArray() 等只读方法。
⚝ 独立对象的访问 (Accessing Independent Objects)：如果多个线程访问的是不同的 dynamic 对象，即使这些对象之间存在关联（例如，它们是同一个父对象的子对象），通常也是线程安全的。因为每个线程操作的是独立的内存区域。
线程不安全的操作：
⚝ 修改操作 (Modification Operations)：多个线程同时修改同一个 dynamic 对象的值是线程不安全的。例如，多个线程同时调用 operator[]= (赋值), insert(), erase(), clear() 等修改方法可能会导致数据竞争。
⚝ 非原子操作 (Non-atomic Operations)：即使是看似简单的操作，例如 dynamic 对象的自增操作 (dynamic += 1)，在多线程环境下也可能不是原子操作，需要额外的同步机制来保证线程安全。
线程安全的使用方法：
为了在多线程环境中使用 folly::dynamic，我们需要采取适当的同步机制来保护对 dynamic 对象的并发访问。常见的同步机制包括：
① 互斥锁 (Mutex)：使用互斥锁（例如 std::mutex 或 folly::SharedMutex）来保护对 dynamic 对象的独占访问。在修改 dynamic 对象之前，线程需要先获取互斥锁；在完成修改后，释放互斥锁。这可以保证在同一时刻只有一个线程可以修改 dynamic 对象。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <thread>
5
#include <mutex>
6
7
folly::dynamic sharedDynamic = folly::dynamic::object();
8
std::mutex dynamicMutex;
9
10
void threadFunc(int threadId) {
11
for (int i = 0; i < 1000; ++i) {
12
std::lock_guard<std::mutex> lock(dynamicMutex); // 获取互斥锁
13
sharedDynamic[folly::to<std::string>("count")] = sharedDynamic["count"].asInt() + 1; // 线程安全地修改 dynamic 对象
14
std::cout << "Thread " << threadId << ": Count = " << sharedDynamic["count"].asInt() << std::endl;
15
}
16
}
17
18
int main() {
19
sharedDynamic["count"] = 0;
20
std::thread t1(threadFunc, 1);
21
std::thread t2(threadFunc, 2);
22
23
t1.join();
24
t2.join();
25
26
std::cout << "Final Count: " << sharedDynamic["count"].asInt() << std::endl; // 最终计数结果应为 2000
27
28
return 0;
29
}
代码解析：
⚝ 互斥锁 dynamicMutex：声明一个 std::mutex 对象 dynamicMutex，用于保护对 sharedDynamic 对象的并发访问。
⚝ std::lock_guard：在 threadFunc 函数中，使用 std::lock_guard<std::mutex> lock(dynamicMutex) 获取互斥锁。std::lock_guard 是一种 RAII 风格的互斥锁管理类，在构造时自动获取锁，在析构时自动释放锁，确保了互斥锁的正确使用，即使在发生异常的情况下也能正确释放锁。
⚝ 线程安全修改：在互斥锁的保护下，多个线程可以安全地修改 sharedDynamic 对象。
② 读写锁 (Read-Write Lock)：如果读操作远多于写操作，可以使用读写锁（例如 folly::SharedMutex）来提高并发性能。读写锁允许多个线程同时进行读操作，但只允许一个线程进行写操作。
③ 原子操作 (Atomic Operations)：对于简单的原子操作，例如计数器自增，可以使用原子变量（例如 std::atomic<int>）来代替 dynamic 对象。原子操作本身是线程安全的，无需额外的同步机制。但 dynamic 本身不支持原子操作，原子操作通常用于基本数据类型，而不是复杂的动态类型。
④ 线程局部存储 (Thread-Local Storage)：如果每个线程只需要访问和修改自己的 dynamic 对象副本，可以使用线程局部存储（例如 thread_local 关键字）为每个线程创建独立的 dynamic 对象。这样可以避免线程之间的竞争，提高并发性能。
总结：
folly::dynamic 本身不是完全线程安全的，但只读操作通常是线程安全的。在多线程环境中修改 dynamic 对象时，需要使用适当的同步机制（例如互斥锁、读写锁）来保护并发访问，避免数据竞争。选择合适的同步机制取决于具体的应用场景和并发访问模式。在设计多线程应用时，务必仔细考虑 dynamic 对象的线程安全性，并采取相应的措施来保证程序的正确性和性能。
END_OF_CHAPTER
5. chapter 5： dynamic API 全面解析 (Comprehensive API Analysis of dynamic)
5.1 dynamic 类详解 (Detailed Explanation of dynamic Class)
folly::dynamic 是 Folly 库中用于表示动态类型的核心类。它类似于 JavaScript 中的 var 或 Python 中的动态类型变量，能够在运行时存储和操作不同类型的数据，而无需在编译时指定具体类型。这为 C++ 带来了极大的灵活性，尤其是在处理 JSON 数据、配置文件、或者需要与动态语言交互的场景中。
核心特性：
① 动态类型存储：dynamic 对象可以存储多种基本数据类型，包括 null、bool、int64_t、double、std::string 以及 dynamic 数组和对象。
② 运行时类型检查：类型检查在运行时进行，允许在程序执行过程中根据数据的实际类型进行操作。
③ 隐式类型转换：在某些情况下，dynamic 对象可以隐式转换为其存储的实际类型，简化了代码编写。
④ JSON 兼容性：dynamic 与 JSON 数据格式天然兼容，可以方便地进行 JSON 数据的解析和生成。
⑤ 易用性：dynamic 提供了简洁直观的 API，使得动态类型操作在 C++ 中变得简单易用。
dynamic 类的主要组成部分：
⚝ 构造函数 (Constructors)：
dynamic 提供了多种构造函数，允许从不同类型的值创建 dynamic 对象。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
#include <string>
4
#include <vector>
5
6
int main() {
7
// 默认构造函数，创建一个 null 类型的 dynamic 对象
8
folly::dynamic d1;
9
std::cout << "d1 type: " << d1.typeName() << std::endl; // 输出: d1 type: null
10
11
// 从 int 类型构造
12
folly::dynamic d2 = 123;
13
std::cout << "d2 type: " << d2.typeName() << ", value: " << d2.asInt() << std::endl; // 输出: d2 type: int64, value: 123
14
15
// 从 double 类型构造
16
folly::dynamic d3 = 3.14;
17
std::cout << "d3 type: " << d3.typeName() << ", value: " << d3.asDouble() << std::endl; // 输出: d3 type: double, value: 3.14
18
19
// 从 bool 类型构造
20
folly::dynamic d4 = true;
21
std::cout << "d4 type: " << d4.typeName() << ", value: " << d4.asBool() << std::endl; // 输出: d4 type: bool, value: 1
22
23
// 从 string 类型构造
24
folly::dynamic d5 = "hello";
25
std::cout << "d5 type: " << d5.typeName() << ", value: " << d5.asString() << std::endl; // 输出: d5 type: string, value: hello
26
27
// 从 C 风格字符串构造
28
folly::dynamic d6 = "world";
29
std::cout << "d6 type: " << d6.typeName() << ", value: " << d6.asString() << std::endl; // 输出: d6 type: string, value: world
30
31
// 从 std::vector<dynamic> 构造，创建 dynamic 数组
32
std::vector<folly::dynamic> vec = {1, "two", 3.0};
33
folly::dynamic d7 = vec;
34
std::cout << "d7 type: " << d7.typeName() << ", value: " << folly::toJson(d7) << std::endl; // 输出: d7 type: array, value: [1,"two",3]
35
36
// 从 std::map<std::string, dynamic> 构造，创建 dynamic 对象
37
std::map<std::string, folly::dynamic> map = {{"key1", "value1"}, {"key2", 2}};
38
folly::dynamic d8 = map;
39
std::cout << "d8 type: " << d8.typeName() << ", value: " << folly::toJson(d8) << std::endl; // 输出: d8 type: object, value: {"key1":"value1","key2":2}
40
41
return 0;
42
}
⚝ 析构函数 (Destructor)：
dynamic 对象的析构函数负责释放对象占用的资源，包括动态分配的内存。由于 dynamic 可以存储不同类型的数据，析构函数需要正确处理各种类型的资源清理。
⚝ 类型查询方法 (Type Query Methods)：
dynamic 提供了多种方法来查询其存储的类型。
1
| 方法 | 描述 | 返回值类型 |
2
| ------------------------- | ---------------------------------------- | -------- |
3
| `isNull()` | 检查是否为 null 类型 | `bool` |
4
| `isBool()` | 检查是否为 bool 类型 | `bool` |
5
| `isInt()` | 检查是否为 int64_t 类型 | `bool` |
6
| `isDouble()` | 检查是否为 double 类型 | `bool` |
7
| `isString()` | 检查是否为 std::string 类型 | `bool` |
8
| `isArray()` | 检查是否为 dynamic 数组类型 | `bool` |
9
| `isObject()` | 检查是否为 dynamic 对象类型 | `bool` |
10
| `isNumber()` | 检查是否为数值类型 (int64_t 或 double) | `bool` |
11
| `isConvertibleToInt()` | 检查是否可以转换为 int 类型 | `bool` |
12
| `isConvertibleToDouble()` | 检查是否可以转换为 double 类型 | `bool` |
13
| `typeName()` | 返回类型的字符串表示，例如 "null", "int64", "string" 等 | `const char*` |
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d = 123;
6
7
std::cout << "Is null? " << d.isNull() << std::endl; // 输出: Is null? 0
8
std::cout << "Is int? " << d.isInt() << std::endl; // 输出: Is int? 1
9
std::cout << "Is double? " << d.isDouble() << std::endl; // 输出: Is double? 0
10
std::cout << "Is number? " << d.isNumber() << std::endl; // 输出: Is number? 1
11
std::cout << "Type name: " << d.typeName() << std::endl; // 输出: Type name: int64
12
13
folly::dynamic d_str = "test";
14
std::cout << "Is string? " << d_str.isString() << std::endl; // 输出: Is string? 1
15
16
return 0;
17
}
⚝ 值访问方法 (Value Access Methods)：
这些方法用于获取 dynamic 对象存储的值。需要注意的是，必须先使用类型查询方法确认类型，再使用对应的值访问方法，否则可能会抛出异常。
1
| 方法 | 描述 | 返回值类型 | 异常情况 |
2
| --------------------- | ---------------------------------------- | -------------------- | -------------------------------------- |
3
| `asNull()` | 将 dynamic 对象转换为 null 类型 | `folly::Unit` | 如果不是 null 类型，抛出 `bad_dynamic_cast` |
4
| `asBool()` | 将 dynamic 对象转换为 bool 类型 | `bool` | 如果不是 bool 类型，抛出 `bad_dynamic_cast` |
5
| `asInt()` | 将 dynamic 对象转换为 int64_t 类型 | `int64_t` | 如果不是 int 类型或无法转换为 int，抛出 `bad_dynamic_cast` |
6
| `asDouble()` | 将 dynamic 对象转换为 double 类型 | `double` | 如果不是 double 类型或无法转换为 double，抛出 `bad_dynamic_cast` |
7
| `asString()` | 将 dynamic 对象转换为 std::string 类型 | `std::string` | 如果不是 string 类型，抛出 `bad_dynamic_cast` |
8
| `asStringPiece()` | 以 `folly::StringPiece` 形式访问字符串值 | `folly::StringPiece` | 如果不是 string 类型，抛出 `bad_dynamic_cast` |
9
| `asArray()` | 将 dynamic 对象转换为 dynamic 数组引用 | `dynamic::array_type&` | 如果不是 array 类型，抛出 `bad_dynamic_cast` |
10
| `asObject()` | 将 dynamic 对象转换为 dynamic 对象引用 | `dynamic::object_type&`| 如果不是 object 类型，抛出 `bad_dynamic_cast` |
11
| `get_ptr()` | 获取指向内部存储值的指针 | `const void*` | |
12
| `value()` | 返回内部存储值的 `detail::Value` 对象 | `detail::Value` | |
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d_int = 123;
6
if (d_int.isInt()) {
7
int val = d_int.asInt();
8
std::cout << "Integer value: " << val << std::endl; // 输出: Integer value: 123
9
}
10
11
folly::dynamic d_str = "test string";
12
if (d_str.isString()) {
13
std::string str_val = d_str.asString();
14
std::cout << "String value: " << str_val << std::endl; // 输出: String value: test string
15
}
16
17
folly::dynamic d_array = folly::dynamic::array(1, 2, 3);
18
if (d_array.isArray()) {
19
folly::dynamic::array_type& arr = d_array.asArray();
20
std::cout << "Array size: " << arr.size() << std::endl; // 输出: Array size: 3
21
std::cout << "First element: " << arr[0].asInt() << std::endl; // 输出: First element: 1
22
}
23
24
folly::dynamic d_obj = folly::dynamic::object("key", "value");
25
if (d_obj.isObject()) {
26
folly::dynamic::object_type& obj = d_obj.asObject();
27
std::cout << "Object size: " << obj.size() << std::endl; // 输出: Object size: 1
28
std::cout << "Value of key: " << obj["key"].asString() << std::endl; // 输出: Value of key: value
29
}
30
31
return 0;
32
}
⚝ 修改值的方法 (Value Modification Methods)：
dynamic 对象的值可以通过赋值操作符或数组/对象的元素访问方式进行修改。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d = 123;
6
std::cout << "Initial value: " << d.asInt() << std::endl; // 输出: Initial value: 123
7
8
d = "new string value"; // 修改为 string 类型
9
std::cout << "Modified value (string): " << d.asString() << std::endl; // 输出: Modified value (string): new string value
10
11
d = folly::dynamic::array(); // 修改为 array 类型
12
d[0] = 10;
13
d[1] = "element";
14
std::cout << "Modified value (array): " << folly::toJson(d) << std::endl; // 输出: Modified value (array): [10,"element"]
15
16
folly::dynamic obj = folly::dynamic::object(); // 修改为 object 类型
17
obj["key1"] = true;
18
obj["key2"] = 100.5;
19
std::cout << "Modified value (object): " << folly::toJson(obj) << std::endl; // 输出: Modified value (object): {"key1":true,"key2":100.5}
20
21
return 0;
22
}
⚝ 数组和对象操作方法 (Array and Object Manipulation Methods)：
当 dynamic 对象存储的是数组或对象时，可以使用以下方法进行操作：
1
**数组 (Array) 的方法**：
2
3
| 方法 | 描述 |
4
| ----------- | ---------------------------------------- |
5
| `size()` | 返回数组元素的数量 |
6
| `empty()` | 检查数组是否为空 |
7
| `clear()` | 清空数组 |
8
| `push_back(const dynamic& val)` | 在数组末尾添加元素 |
9
| `pop_back()` | 移除数组末尾的元素 |
10
| `erase(size_t index)` | 移除指定索引位置的元素 |
11
| `insert(size_t index, const dynamic& val)` | 在指定索引位置插入元素 |
12
13
**对象 (Object) 的方法**：
14
15
| 方法 | 描述 |
16
| ------------------------------------- | ---------------------------------------- |
17
| `size()` | 返回对象键值对的数量 |
18
| `empty()` | 检查对象是否为空 |
19
| `clear()` | 清空对象 |
20
| `insert(const std::string& key, const dynamic& val)` | 插入或更新键值对 |
21
| `erase(const std::string& key)` | 移除指定键的键值对 |
22
| `count(const std::string& key)` | 检查对象是否包含指定键 |
23
| `find(const std::string& key)` | 查找指定键的迭代器 |
24
| `items()` | 返回包含所有键值对的范围 |
25
| `keys()` | 返回包含所有键的范围 |
26
| `values()` | 返回包含所有值的范围 |
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
// 数组操作
6
folly::dynamic arr = folly::dynamic::array(1, 2, 3);
7
std::cout << "Array size: " << arr.size() << std::endl; // 输出: Array size: 3
8
arr.push_back(4);
9
std::cout << "Array after push_back: " << folly::toJson(arr) << std::endl; // 输出: Array after push_back: [1,2,3,4]
10
arr.erase(1);
11
std::cout << "Array after erase: " << folly::toJson(arr) << std::endl; // 输出: Array after erase: [1,3,4]
12
13
// 对象操作
14
folly::dynamic obj = folly::dynamic::object("key1", "value1", "key2", "value2");
15
std::cout << "Object size: " << obj.size() << std::endl; // 输出: Object size: 2
16
obj["key3"] = "value3";
17
std::cout << "Object after insert: " << folly::toJson(obj) << std::endl; // 输出: Object after insert: {"key1":"value1","key2":"value2","key3":"value3"}
18
obj.erase("key2");
19
std::cout << "Object after erase: " << folly::toJson(obj) << std::endl; // 输出: Object after erase: {"key1":"value1","key3":"value3"}
20
std::cout << "Has key1? " << obj.count("key1") << std::endl; // 输出: Has key1? 1
21
22
return 0;
23
}
5.2 dynamic 的操作符重载 (Operator Overloading of dynamic)
folly::dynamic 为了提供更便捷的操作体验，重载了多种操作符，使得 dynamic 对象可以像原生类型一样进行运算和比较。
⚝ 赋值操作符 (Assignment Operators)：
dynamic 重载了赋值操作符 =，允许将不同类型的值赋给 dynamic 对象。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d;
6
7
d = 10; // 赋值 int
8
std::cout << "d = int: " << d.asInt() << std::endl; // 输出: d = int: 10
9
10
d = "string"; // 赋值 string
11
std::cout << "d = string: " << d.asString() << std::endl; // 输出: d = string: string
12
13
d = folly::dynamic::array(1, 2); // 赋值 array
14
std::cout << "d = array: " << folly::toJson(d) << std::endl; // 输出: d = array: [1,2]
15
16
return 0;
17
}
⚝ 比较操作符 (Comparison Operators)：
dynamic 重载了比较操作符 == 和 !=，用于比较两个 dynamic 对象的值是否相等。比较操作符会考虑 dynamic 对象内部存储的实际值进行比较。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d1 = 10;
6
folly::dynamic d2 = 10;
7
folly::dynamic d3 = 20;
8
folly::dynamic d4 = "10";
9
10
std::cout << "(d1 == d2): " << (d1 == d2) << std::endl; // 输出: (d1 == d2): 1
11
std::cout << "(d1 == d3): " << (d1 == d3) << std::endl; // 输出: (d1 == d3): 0
12
std::cout << "(d1 != d3): " << (d1 != d3) << std::endl; // 输出: (d1 != d3): 1
13
std::cout << "(d1 == d4): " << (d1 == d4) << std::endl; // 输出: (d1 == d4): 0，类型不同，值不相等
14
15
return 0;
16
}
⚝ 逻辑操作符 (Logical Operators)：
dynamic 重载了逻辑非操作符 !，用于判断 dynamic 对象的值是否为 "falsey"。对于 dynamic 而言，null、false、0、0.0、空字符串、空数组、空对象都被认为是 "falsey"，其他值被认为是 "truthy"。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d_null;
6
folly::dynamic d_false = false;
7
folly::dynamic d_zero_int = 0;
8
folly::dynamic d_zero_double = 0.0;
9
folly::dynamic d_empty_str = "";
10
folly::dynamic d_empty_array = folly::dynamic::array();
11
folly::dynamic d_empty_obj = folly::dynamic::object();
12
folly::dynamic d_true = true;
13
folly::dynamic d_one = 1;
14
folly::dynamic d_non_empty_str = "hello";
15
folly::dynamic d_non_empty_array = folly::dynamic::array(1);
16
folly::dynamic d_non_empty_obj = folly::dynamic::object("key", "value");
17
18
std::cout << "!d_null: " << !d_null << std::endl; // 输出: !d_null: 1
19
std::cout << "!d_false: " << !d_false << std::endl; // 输出: !d_false: 1
20
std::cout << "!d_zero_int: " << !d_zero_int << std::endl; // 输出: !d_zero_int: 1
21
std::cout << "!d_zero_double: " << !d_zero_double << std::endl; // 输出: !d_zero_double: 1
22
std::cout << "!d_empty_str: " << !d_empty_str << std::endl; // 输出: !d_empty_str: 1
23
std::cout << "!d_empty_array: " << !d_empty_array << std::endl; // 输出: !d_empty_array: 1
24
std::cout << "!d_empty_obj: " << !d_empty_obj << std::endl; // 输出: !d_empty_obj: 1
25
26
std::cout << "!d_true: " << !d_true << std::endl; // 输出: !d_true: 0
27
std::cout << "!d_one: " << !d_one << std::endl; // 输出: !d_one: 0
28
std::cout << "!d_non_empty_str: " << !d_non_empty_str << std::endl; // 输出: !d_non_empty_str: 0
29
std::cout << "!d_non_empty_array: " << !d_non_empty_array << std::endl; // 输出: !d_non_empty_array: 0
30
std::cout << "!d_non_empty_obj: " << !d_non_empty_obj << std::endl; // 输出: !d_non_empty_obj: 0
31
32
return 0;
33
}
⚝ 数组和对象元素访问操作符 (Array and Object Element Access Operators)：
dynamic 重载了下标操作符 []，用于访问 dynamic 数组的元素或 dynamic 对象的键值对。
1
对于 **数组**，下标操作符接受整数索引，返回对应位置的 `dynamic` 元素的引用。如果索引越界，会抛出异常。
2
3
对于 **对象**，下标操作符接受字符串键，返回对应键的值的 `dynamic` 引用。如果键不存在，则会在对象中**创建**一个新的键值对，并返回新创建的值的引用。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
// 数组访问
6
folly::dynamic arr = folly::dynamic::array(10, 20, 30);
7
std::cout << "arr[0]: " << arr[0].asInt() << std::endl; // 输出: arr[0]: 10
8
arr[1] = 25; // 修改数组元素
9
std::cout << "arr after modification: " << folly::toJson(arr) << std::endl; // 输出: arr after modification: [10,25,30]
10
11
// 对象访问
12
folly::dynamic obj = folly::dynamic::object("key1", "value1");
13
std::cout << "obj[\"key1\"]: " << obj["key1"].asString() << std::endl; // 输出: obj["key1"]: value1
14
obj["key2"] = "value2"; // 添加新的键值对
15
std::cout << "obj after insertion: " << folly::toJson(obj) << std::endl; // 输出: obj after insertion: {"key1":"value1","key2":"value2"}
16
obj["key1"] = "new_value1"; // 修改已存在的键值对
17
std::cout << "obj after modification: " << folly::toJson(obj) << std::endl; // 输出: obj after modification: {"key1":"new_value1","key2":"value2"}
18
19
return 0;
20
}
⚝ 加法操作符 (Addition Operator)：
dynamic 重载了加法操作符 +，用于执行以下操作：
① 数值相加：如果两个 dynamic 对象都是数值类型（int64_t 或 double），则执行数值加法。如果其中一个是 double，结果为 double 类型，否则为 int64_t 类型。
② 字符串拼接：如果其中一个 dynamic 对象是字符串类型，则将另一个对象转换为字符串并进行拼接。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
// 数值相加
6
folly::dynamic d1 = 10;
7
folly::dynamic d2 = 20;
8
folly::dynamic d3 = d1 + d2;
9
std::cout << "d1 + d2 = " << d3.asInt() << std::endl; // 输出: d1 + d2 = 30
10
11
folly::dynamic d4 = 3.5;
12
folly::dynamic d5 = d1 + d4;
13
std::cout << "d1 + d4 = " << d5.asDouble() << std::endl; // 输出: d1 + d4 = 13.5
14
15
// 字符串拼接
16
folly::dynamic d6 = "hello";
17
folly::dynamic d7 = d6 + " world";
18
std::cout << "d6 + \" world\" = " << d7.asString() << std::endl; // 输出: d6 + " world" = hello world
19
20
folly::dynamic d8 = d6 + 123;
21
std::cout << "d6 + 123 = " << d8.asString() << std::endl; // 输出: d6 + 123 = hello123
22
23
return 0;
24
}
⚝ 复合赋值操作符 (Compound Assignment Operators)：
dynamic 也重载了复合赋值操作符，如 +=，其行为与对应的二元操作符类似，并直接修改左操作数的值。例如，+= 可以用于数值累加或字符串拼接。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
// 数值累加
6
folly::dynamic d1 = 10;
7
d1 += 5;
8
std::cout << "d1 += 5: " << d1.asInt() << std::endl; // 输出: d1 += 5: 15
9
10
// 字符串拼接
11
folly::dynamic d2 = "hello";
12
d2 += " world";
13
std::cout << "d2 += \" world\": " << d2.asString() << std::endl; // 输出: d2 += " world": hello world
14
15
return 0;
16
}
注意事项：
① 类型安全：虽然操作符重载提供了便利，但仍然需要注意类型安全。例如，对非数值类型的 dynamic 对象进行数值运算可能会导致运行时错误或抛出异常。
② 隐式转换：dynamic 的操作符重载涉及到隐式类型转换，需要理解其转换规则，避免出现意料之外的结果。
③ 性能影响：动态类型操作和操作符重载相比静态类型操作会有一定的性能开销，在性能敏感的场景需要考虑其影响。
5.3 dynamic 的辅助函数 (Helper Functions of dynamic)
folly::dynamic 提供了一系列辅助函数，用于更方便地创建、操作和转换 dynamic 对象。这些辅助函数增强了 dynamic 的功能，使其在各种应用场景中更加实用。
⚝ 创建 dynamic 对象：
▮▮▮▮⚝ folly::dynamic::null(): 创建一个 null 类型的 dynamic 对象。
▮▮▮▮⚝ folly::dynamic::boolValue(bool value): 创建一个 bool 类型的 dynamic 对象。
▮▮▮▮⚝ folly::dynamic::int64(int64_t value): 创建一个 int64_t 类型的 dynamic 对象。
▮▮▮▮⚝ folly::dynamic::doubleValue(double value): 创建一个 double 类型的 dynamic 对象。
▮▮▮▮⚝ folly::dynamic::string(folly::StringPiece value): 创建一个 string 类型的 dynamic 对象。
▮▮▮▮⚝ folly::dynamic::array(std::initializer_list<dynamic> values): 创建一个 array 类型的 dynamic 对象，可以使用初始化列表方便地添加元素。
▮▮▮▮⚝ folly::dynamic::object(std::initializer_list<std::pair<const char*, dynamic>> values): 创建一个 object 类型的 dynamic 对象，可以使用初始化列表方便地添加键值对。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d_null = folly::dynamic::null();
6
folly::dynamic d_bool = folly::dynamic::boolValue(true);
7
folly::dynamic d_int = folly::dynamic::int64(100);
8
folly::dynamic d_double = folly::dynamic::doubleValue(2.718);
9
folly::dynamic d_string = folly::dynamic::string("example");
10
folly::dynamic d_array = folly::dynamic::array(1, "two", 3.0);
11
folly::dynamic d_object = folly::dynamic::object("key1", "val1", "key2", 2);
12
13
std::cout << "d_null: " << d_null.typeName() << std::endl; // 输出: d_null: null
14
std::cout << "d_bool: " << d_bool.asBool() << std::endl; // 输出: d_bool: 1
15
std::cout << "d_int: " << d_int.asInt() << std::endl; // 输出: d_int: 100
16
std::cout << "d_double: " << d_double.asDouble() << std::endl; // 输出: d_double: 2.718
17
std::cout << "d_string: " << d_string.asString() << std::endl; // 输出: d_string: example
18
std::cout << "d_array: " << folly::toJson(d_array) << std::endl; // 输出: d_array: [1,"two",3]
19
std::cout << "d_object: " << folly::toJson(d_object) << std::endl; // 输出: d_object: {"key1":"val1","key2":2}
20
21
return 0;
22
}
⚝ JSON 转换函数：
▮▮▮▮⚝ folly::toJson(const dynamic& d): 将 dynamic 对象转换为 JSON 格式的字符串。
▮▮▮▮⚝ folly::parseJson(folly::StringPiece json): 将 JSON 格式的字符串解析为 dynamic 对象。
1
这两个函数是 `dynamic` 与 JSON 数据交互的核心，使得 `dynamic` 非常适合处理 JSON 数据。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
5
int main() {
6
// dynamic to JSON
7
folly::dynamic obj = folly::dynamic::object("name", "Alice", "age", 30);
8
std::string json_str = folly::toJson(obj);
9
std::cout << "JSON string: " << json_str << std::endl; // 输出: JSON string: {"name":"Alice","age":30}
10
11
// JSON to dynamic
12
folly::StringPiece json_piece = "{\"city\":\"New York\", \"zip\":10001}";
13
folly::dynamic parsed_dynamic = folly::parseJson(json_piece);
14
std::cout << "Parsed dynamic object: " << folly::toJson(parsed_dynamic) << std::endl; // 输出: Parsed dynamic object: {"city":"New York","zip":10001}
15
std::cout << "City: " << parsed_dynamic["city"].asString() << std::endl; // 输出: City: New York
16
17
return 0;
18
}
⚝ 类型转换辅助函数：
▮▮▮▮⚝ folly::convertTo<T>(const dynamic& d): 尝试将 dynamic 对象转换为类型 T。这是一个模板函数，可以转换为多种类型，例如 int, double, std::string, std::vector<dynamic>, std::map<std::string, dynamic> 等。如果转换失败，会抛出异常。
1
#include <folly/dynamic.h>
2
#include <folly/Conv.h> // 引入 folly/Conv.h
3
#include <iostream>
4
#include <string>
5
#include <vector>
6
#include <map>
7
8
int main() {
9
folly::dynamic d_int = 123;
10
int int_val = folly::convertTo<int>(d_int);
11
std::cout << "Converted int: " << int_val << std::endl; // 输出: Converted int: 123
12
13
folly::dynamic d_str = "convert me";
14
std::string str_val = folly::convertTo<std::string>(d_str);
15
std::cout << "Converted string: " << str_val << std::endl; // 输出: Converted string: convert me
16
17
folly::dynamic d_array = folly::dynamic::array(1, 2, 3);
18
std::vector<folly::dynamic> vec_val = folly::convertTo<std::vector<folly::dynamic>>(d_array);
19
std::cout << "Converted vector size: " << vec_val.size() << std::endl; // 输出: Converted vector size: 3
20
21
folly::dynamic d_obj = folly::dynamic::object("key", "value");
22
std::map<std::string, folly::dynamic> map_val = folly::convertTo<std::map<std::string, folly::dynamic>>(d_obj);
23
std::cout << "Converted map size: " << map_val.size() << std::endl; // 输出: Converted map size: 1
24
std::cout << "Map value for key: " << map_val["key"].asString() << std::endl; // 输出: Map value for key: value
25
26
// 错误示例：尝试将 string 转换为 int，会抛出异常
27
folly::dynamic d_str_num = "456";
28
try {
29
int invalid_int_val = folly::convertTo<int>(d_str_num); // 字符串 "456" 可以转换为 int
30
std::cout << "Converted invalid int: " << invalid_int_val << std::endl;
31
} catch (const std::exception& e) {
32
std::cerr << "Conversion exception: " << e.what() << std::endl; // 输出转换异常信息
33
}
34
35
36
folly::dynamic d_invalid_str = "not a number";
37
try {
38
int invalid_int_val = folly::convertTo<int>(d_invalid_str); // 字符串 "not a number" 无法转换为 int，抛出异常
39
std::cout << "Converted invalid int: " << invalid_int_val << std::endl;
40
} catch (const std::exception& e) {
41
std::cerr << "Conversion exception: " << e.what() << std::endl; // 输出转换异常信息
42
}
43
44
return 0;
45
}
⚝ 其他辅助函数：
▮▮▮▮⚝ folly::dynamic::copy(const dynamic& other): 创建一个 dynamic 对象的深拷贝。
▮▮▮▮⚝ folly::dynamic::move(dynamic&& other): 创建一个 dynamic 对象的移动拷贝。
▮▮▮▮⚝ folly::dynamic::merge_patch(dynamic& target, const dynamic& patch): 根据 RFC 7396 标准，将 patch 对象合并到 target 对象中。常用于 JSON Patch 操作。
▮▮▮▮⚝ folly::dynamic::get_default(const dynamic& obj, folly::StringPiece key, const dynamic& default_value): 安全地获取对象中指定键的值，如果键不存在则返回默认值。避免了直接使用 obj[key] 在键不存在时创建新键值对的行为。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
// copy 和 move
6
folly::dynamic original_array = folly::dynamic::array(1, 2, 3);
7
folly::dynamic copied_array = folly::dynamic::copy(original_array);
8
folly::dynamic moved_array = folly::dynamic::move(folly::dynamic::array(4, 5, 6));
9
10
std::cout << "Copied array: " << folly::toJson(copied_array) << std::endl; // 输出: Copied array: [1,2,3]
11
std::cout << "Moved array: " << folly::toJson(moved_array) << std::endl; // 输出: Moved array: [4,5,6]
12
13
// merge_patch
14
folly::dynamic target_obj = folly::dynamic::object("name", "Old Name", "age", 25);
15
folly::dynamic patch_obj = folly::dynamic::object("age", 30, "city", "New City");
16
folly::dynamic::merge_patch(target_obj, patch_obj);
17
std::cout << "Merged object: " << folly::toJson(target_obj) << std::endl; // 输出: Merged object: {"name":"Old Name","age":30,"city":"New City"}
18
19
// get_default
20
folly::dynamic config_obj = folly::dynamic::object("timeout", 1000);
21
folly::dynamic timeout_value = folly::dynamic::get_default(config_obj, "timeout", 500);
22
folly::dynamic retry_count = folly::dynamic::get_default(config_obj, "retry", 3);
23
24
std::cout << "Timeout value: " << timeout_value.asInt() << std::endl; // 输出: Timeout value: 1000
25
std::cout << "Retry count: " << retry_count.asInt() << std::endl; // 输出: Retry count: 3
26
27
return 0;
28
}
5.4 dynamic 的异常处理 (Exception Handling of dynamic)
在使用 folly::dynamic 时，了解其异常处理机制至关重要，可以帮助编写更健壮和可靠的代码。dynamic 主要在类型转换和访问时可能抛出异常。
⚝ folly::bad_dynamic_cast 异常：
这是最常见的异常类型，当尝试使用 asType() 方法将 dynamic 对象转换为不兼容的类型时抛出。例如，尝试将一个字符串类型的 dynamic 对象转换为 int 类型，或者当 dynamic 对象不是数组却调用 asArray() 时。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d_str = "not a number";
6
7
try {
8
int val = d_str.asInt(); // 尝试将 string 转换为 int，会抛出 bad_dynamic_cast
9
std::cout << "Value: " << val << std::endl; // 不会执行到这里
10
} catch (const folly::bad_dynamic_cast& e) {
11
std::cerr << "Caught bad_dynamic_cast: " << e.what() << std::endl; // 输出异常信息
12
}
13
14
folly::dynamic d_int_array = folly::dynamic::array(1, 2, 3);
15
try {
16
std::string str_val = d_int_array.asString(); // 尝试将 array 转换为 string，会抛出 bad_dynamic_cast
17
std::cout << "Value: " << str_val << std::endl; // 不会执行到这里
18
} catch (const folly::bad_dynamic_cast& e) {
19
std::cerr << "Caught bad_dynamic_cast (array to string): " << e.what() << std::endl; // 输出异常信息
20
}
21
22
return 0;
23
}
1
**避免 `bad_dynamic_cast` 的最佳实践**：
① 类型检查先行：在使用 asType() 方法之前，始终使用类型检查方法（如 isInt(), isString(), isArray() 等）确认 dynamic 对象的实际类型。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d = 123;
6
7
if (d.isInt()) {
8
int val = d.asInt();
9
std::cout << "Integer value: " << val << std::endl; // 安全访问
10
} else {
11
std::cerr << "Not an integer type." << std::endl;
12
}
13
14
return 0;
15
}
② 使用 get_default 获取对象值：当访问 dynamic 对象（object 类型）的键值时，如果不能确定键是否存在，可以使用 folly::dynamic::get_default 函数，提供一个默认值，避免因键不存在而抛出异常（虽然对象的 [] 操作符在键不存在时不会抛出异常，但会创建新的键值对，这在某些情况下可能不是期望的行为）。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic config = folly::dynamic::object("timeout", 1000);
6
7
folly::dynamic timeout = folly::dynamic::get_default(config, "timeout", 500);
8
folly::dynamic retry = folly::dynamic::get_default(config, "retry", 3); // "retry" 键不存在，返回默认值 3
9
10
std::cout << "Timeout: " << timeout.asInt() << std::endl; // 输出: Timeout: 1000
11
std::cout << "Retry: " << retry.asInt() << std::endl; // 输出: Retry: 3
12
13
return 0;
14
}
⚝ 其他异常情况：
① 数组索引越界：当使用 dynamic 数组的 [] 操作符访问越界索引时，会抛出异常（具体异常类型可能取决于 Folly 版本，通常是 std::out_of_range 或类似的异常）。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
#include <stdexcept>
4
5
int main() {
6
folly::dynamic arr = folly::dynamic::array(1, 2, 3);
7
8
try {
9
folly::dynamic val = arr[5]; // 索引越界
10
std::cout << "Value: " << val.asInt() << std::endl; // 不会执行到这里
11
} catch (const std::out_of_range& e) {
12
std::cerr << "Caught out_of_range: " << e.what() << std::endl; // 输出索引越界异常信息
13
} catch (const std::exception& e) {
14
std::cerr << "Caught exception: " << e.what() << std::endl; // 捕获其他标准异常
15
}
16
17
return 0;
18
}
② 内存分配失败：在极少数情况下，如果系统内存不足，dynamic 对象在分配内存时可能会抛出 std::bad_alloc 异常。
③ JSON 解析错误：folly::parseJson 函数在解析无效的 JSON 字符串时，会抛出 folly::json_parse_error 异常。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece invalid_json = "{invalid: json}";
7
8
try {
9
folly::dynamic parsed = folly::parseJson(invalid_json); // 解析无效 JSON，抛出 json_parse_error
10
std::cout << "Parsed JSON: " << folly::toJson(parsed) << std::endl; // 不会执行到这里
11
} catch (const folly::json_parse_error& e) {
12
std::cerr << "Caught json_parse_error: " << e.what() << std::endl; // 输出 JSON 解析错误信息
13
}
14
15
return 0;
16
}
总结：
⚝ 了解 dynamic 可能抛出的异常类型，特别是 folly::bad_dynamic_cast。
⚝ 始终进行类型检查，避免类型转换错误。
⚝ 使用 folly::dynamic::get_default 安全地访问对象键值。
⚝ 适当处理数组索引越界和 JSON 解析错误等异常。
⚝ 使用 try-catch 块捕获和处理异常，增强程序的健壮性。
通过合理的异常处理，可以有效地提高使用 folly::dynamic 的 C++ 程序的稳定性和可靠性。
END_OF_CHAPTER
6. chapter 6： dynamic 实战案例分析 (Practical Case Study Analysis of dynamic)
6.1 案例一：构建灵活的 API 接口 (Case Study 1: Building Flexible API Interfaces)
在现代软件开发中，API（应用程序编程接口，Application Programming Interface）扮演着至关重要的角色，它们是不同系统和服务之间沟通的桥梁。然而，传统的强类型 API 在面对快速变化的需求和数据结构时，往往显得不够灵活。例如，当我们需要向 API 响应中添加新的字段，或者修改现有字段的数据类型时，传统的 API 可能需要进行版本迭代，这会给客户端带来兼容性问题和升级成本。folly::dynamic 类型为构建更加灵活和易于演进的 API 接口提供了强大的支持。
问题背景
假设我们正在开发一个电商平台的商品信息 API。最初，API 只需要返回商品的名称（name）、价格（price）和描述（description）等基本信息。随着业务的发展，我们可能需要添加商品图片（images）、库存量（stock）、促销信息（promotion）等更多字段。如果使用强类型语言如 C++ 传统的结构体或类来定义 API 响应，那么每次字段变更都可能需要修改接口定义，并通知所有客户端进行适配。这种紧耦合的设计不利于 API 的长期维护和演进。
解决方案：使用 folly::dynamic 构建灵活 API
folly::dynamic 允许我们在 API 接口中使用动态类型来表示请求和响应数据，从而实现更大的灵活性。我们可以将 API 响应定义为 folly::dynamic 类型，并在其中存储 JSON 格式的数据。这样，即使数据结构发生变化，只要客户端能够处理 JSON 数据，API 就能保持兼容性。
代码示例
以下代码示例展示了如何使用 folly::dynamic 构建一个简单的商品信息 API 接口。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <string>
5
6
using namespace folly;
7
8
// 模拟商品信息服务
9
dynamic fetchProductInfo(int productId) {
10
dynamic productInfo = dynamic::object;
11
12
if (productId == 123) {
13
productInfo["id"] = 123;
14
productInfo["name"] = "Example Product";
15
productInfo["price"] = 99.99;
16
productInfo["description"] = "This is a sample product for demonstration.";
17
productInfo["images"] = dynamic::array("image1.jpg", "image2.jpg"); // 新增图片字段
18
} else {
19
productInfo["error"] = "Product not found";
20
}
21
22
return productInfo;
23
}
24
25
int main() {
26
int productId = 123;
27
dynamic response = fetchProductInfo(productId);
28
29
// 将 dynamic 对象转换为 JSON 字符串并输出
30
std::string jsonString = toJson(response);
31
std::cout << jsonString << std::endl;
32
33
// 客户端可以灵活地解析 JSON 数据并获取所需字段
34
if (response.isObject() && response.count("name")) {
35
std::cout << "Product Name: " << response["name"].asString() << std::endl;
36
}
37
if (response.isObject() && response.count("images")) {
38
std::cout << "Images: " << toJson(response["images"]) << std::endl; // 输出图片列表
39
}
40
41
42
return 0;
43
}
代码解析
① fetchProductInfo 函数模拟了一个商品信息服务，它接受商品 ID 作为参数，并返回一个 folly::dynamic 对象作为响应。
② 在 fetchProductInfo 函数内部，我们使用 dynamic::object 创建一个动态对象，并使用键值对的方式填充商品信息。
③ 示例中，我们新增了 images 字段，这是一个动态数组，包含了商品的图片链接。
④ toJson(response) 函数将 folly::dynamic 对象转换为 JSON 字符串，方便 API 接口返回数据。
⑤ 在 main 函数中，客户端接收到 JSON 响应后，可以根据需要解析 JSON 数据，并使用 response["name"].asString() 等方法访问特定字段的值。客户端可以根据自身需求选择性地处理响应中的字段，即使 API 响应新增了字段，客户端只要不依赖于新字段，就可以保持兼容。
优势分析
⚝ 灵活性和可扩展性：使用 folly::dynamic 可以轻松地添加、删除或修改 API 响应中的字段，而无需强制客户端进行同步更新。API 可以根据业务发展需要自由演进。
⚝ 松耦合：API 提供方和客户端之间解耦，客户端不再强依赖于固定的数据结构，降低了维护成本。
⚝ 兼容性：即使 API 接口发生变化，只要客户端能够处理 JSON 数据，就能保持基本的兼容性。对于新增字段，客户端可以选择忽略，从而实现向后兼容。
⚝ 易于处理复杂数据结构：folly::dynamic 天然支持嵌套的对象和数组，可以方便地表示复杂的 JSON 数据结构，例如示例中的 images 字段。
总结
通过使用 folly::dynamic，我们可以构建更加灵活、可扩展和易于维护的 API 接口。这种方法特别适用于需要快速迭代和频繁变更的 API 服务，能够有效地降低 API 的维护成本，并提升系统的整体健壮性。对于初学者和中级工程师而言，理解和掌握 folly::dynamic 在 API 开发中的应用，能够帮助他们设计出更具弹性的系统架构。对于高级工程师和专家而言，folly::dynamic 提供了一种强大的工具，用于应对复杂和动态的 API 需求，并构建面向未来的服务。
6.2 案例二：实现动态配置管理系统 (Case Study 2: Implementing Dynamic Configuration Management System)
配置管理是任何软件系统中不可或缺的一部分。传统的配置管理方法通常使用静态配置文件，例如 XML 或 Properties 文件。然而，在云原生和微服务架构盛行的今天，应用配置需要更加动态和灵活。例如，我们可能需要根据不同的环境（开发、测试、生产）加载不同的配置，或者在运行时动态更新配置而无需重启应用。folly::dynamic 类型可以帮助我们构建一个高效、灵活的动态配置管理系统。
问题背景
假设我们正在开发一个分布式系统，该系统包含多个服务组件，每个组件都需要读取和管理自身的配置信息。如果使用静态配置文件，每次修改配置都需要重新部署服务，这会影响系统的可用性和运维效率。此外，不同的环境可能需要不同的配置参数，手动维护多套配置文件容易出错且效率低下。我们需要一个动态配置管理系统，能够支持配置的动态加载、更新和管理，并能够适应不同的运行环境。
解决方案：使用 folly::dynamic 构建动态配置管理系统
我们可以使用 folly::dynamic 来表示配置数据，并将配置信息存储在 JSON 格式的文件或配置中心中。当应用启动时，从配置源加载 JSON 配置数据到 folly::dynamic 对象，并在运行时动态地读取和更新配置。
代码示例
以下代码示例展示了如何使用 folly::dynamic 构建一个简单的动态配置管理系统，该系统从 JSON 文件加载配置，并支持动态更新配置。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <fstream>
4
#include <iostream>
5
#include <stdexcept>
6
#include <string>
7
8
using namespace folly;
9
10
class ConfigManager {
11
public:
12
ConfigManager(const std::string& configFilePath) : configFilePath_(configFilePath) {
13
loadConfig();
14
}
15
16
void loadConfig() {
17
std::ifstream configFile(configFilePath_);
18
if (!configFile.is_open()) {
19
throw std::runtime_error("Failed to open config file: " + configFilePath_);
20
}
21
std::string configStr((std::istreambuf_iterator<char>(configFile)),
22
std::istreambuf_iterator<char>());
23
config_ = parseJson(configStr);
24
}
25
26
dynamic getConfig() const {
27
return config_;
28
}
29
30
// 动态更新配置项
31
void updateConfig(const std::string& key, const dynamic& value) {
32
config_[key] = value;
33
saveConfig(); // 可选：将配置写回文件或配置中心
34
}
35
36
private:
37
void saveConfig() {
38
// 可选：将 config_ 写入到配置文件或配置中心
39
// 这里为了简化示例，暂不实现写回功能
40
std::ofstream configFile(configFilePath_);
41
if (configFile.is_open()) {
42
configFile << toJson(config_);
43
} else {
44
std::cerr << "Warning: Failed to save config to file: " << configFilePath_ << std::endl;
45
}
46
}
47
48
private:
49
std::string configFilePath_;
50
dynamic config_;
51
};
52
53
int main() {
54
ConfigManager configManager("config.json"); // 假设配置文件为 config.json
55
56
// 获取初始配置
57
dynamic config = configManager.getConfig();
58
std::cout << "Initial Config: " << toJson(config) << std::endl;
59
60
// 读取配置项
61
std::string serverHost = config["server"]["host"].asString();
62
int serverPort = config["server"]["port"].asInt();
63
std::cout << "Server Host: " << serverHost << ", Port: " << serverPort << std::endl;
64
65
// 动态更新配置项
66
configManager.updateConfig("server.port", 8081);
67
std::cout << "Config after update: " << toJson(configManager.getConfig()) << std::endl;
68
69
70
// 再次读取更新后的配置项
71
int updatedPort = configManager.getConfig()["server"]["port"].asInt();
72
std::cout << "Updated Server Port: " << updatedPort << std::endl;
73
74
75
return 0;
76
}
config.json 示例
1
{
2
"server": {
3
"host": "localhost",
4
"port": 8080
5
},
6
"database": {
7
"url": "jdbc://localhost:5432/mydb",
8
"username": "admin",
9
"password": "password"
10
},
11
"features": {
12
"featureA": true,
13
"featureB": false
14
}
15
}
代码解析
① ConfigManager 类封装了配置管理的功能。构造函数接受配置文件路径作为参数，并在初始化时加载配置。
② loadConfig 函数从 JSON 文件读取配置内容，并使用 parseJson 函数将其解析为 folly::dynamic 对象。
③ getConfig 函数返回当前的配置 folly::dynamic 对象。
④ updateConfig 函数允许动态更新配置项。它接受配置项的键（key）和新的值（value）作为参数，更新 config_ 对象，并可选地将配置写回配置文件或配置中心（示例中实现了写回文件功能）。
⑤ 在 main 函数中，我们创建 ConfigManager 对象，加载 config.json 配置文件。
⑥ 通过 config["server"]["host"].asString() 和 config["server"]["port"].asInt() 等方式，可以方便地访问配置项的值。
⑦ configManager.updateConfig("server.port", 8081) 演示了如何动态更新配置项。更新后，再次读取 server.port 配置项，可以看到值已经变为 8081。
优势分析
⚝ 动态更新：使用 folly::dynamic 可以实现配置的动态加载和更新，无需重启应用即可应用新的配置，提高了系统的可用性和灵活性。
⚝ 结构化配置：JSON 格式的配置文件易于阅读和编写，folly::dynamic 能够很好地表示 JSON 数据结构，方便配置的组织和管理。
⚝ 多环境支持：可以根据不同的环境加载不同的配置文件，例如使用 config-dev.json、config-test.json、config-prod.json 等，轻松实现多环境配置管理。
⚝ 易于扩展：可以方便地添加新的配置项，或者修改现有配置项的结构，folly::dynamic 的动态类型特性使得配置结构的变化更加容易处理。
⚝ 集成配置中心：可以将配置源替换为配置中心（如 Consul, etcd, ZooKeeper 等），实现更高级的配置管理功能，例如配置的版本控制、权限管理、灰度发布等。
总结
folly::dynamic 为构建动态配置管理系统提供了强大的支持。通过使用 folly::dynamic，我们可以实现配置的动态加载、更新和管理，提高系统的灵活性和可维护性。这种方法特别适用于微服务和云原生应用，能够有效地提升配置管理的效率和可靠性。对于初学者和中级工程师而言，理解和掌握 folly::dynamic 在配置管理中的应用，能够帮助他们构建更加现代化和云友好的应用系统。对于高级工程师和专家而言，folly::dynamic 提供了一种轻量级且高效的工具，用于构建复杂的动态配置管理解决方案，并满足各种高级配置管理需求。
6.3 案例三：开发轻量级脚本语言 (Case Study 3: Developing Lightweight Scripting Language)
脚本语言在软件开发中扮演着重要的角色，它们通常用于自动化任务、扩展应用功能、快速原型开发等场景。开发一个完整的脚本语言通常需要大量的工程工作，但如果只需要一个轻量级的、嵌入式的脚本语言，folly::dynamic 可以大大简化开发过程。folly::dynamic 类型可以作为脚本语言的运行时数据表示，用于存储变量、表达式和数据结构，从而快速构建一个简单的脚本解释器。
问题背景
假设我们需要为一个 C++ 应用添加脚本扩展功能，允许用户编写简单的脚本来控制应用的某些行为，例如自动化一些任务、自定义业务逻辑等。我们不希望引入复杂的脚本语言运行时环境（如 Lua, Python），而是希望开发一个轻量级的、易于集成的脚本语言。
解决方案：使用 folly::dynamic 构建轻量级脚本语言
我们可以使用 folly::dynamic 作为脚本语言的运行时数据类型，定义一套简单的脚本语法，并实现一个简单的解释器来解析和执行脚本。脚本中的变量和数据结构可以使用 folly::dynamic 对象来表示。
代码示例
以下代码示例展示了如何使用 folly::dynamic 构建一个非常简单的脚本语言解释器，该解释器支持变量赋值、基本算术运算和打印语句。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
#include <sstream>
5
#include <stdexcept>
6
#include <string>
7
#include <unordered_map>
8
9
using namespace folly;
10
11
class SimpleScriptInterpreter {
12
public:
13
SimpleScriptInterpreter() {}
14
15
dynamic execute(const std::string& script) {
16
std::stringstream ss(script);
17
std::string line;
18
dynamic result;
19
20
while (std::getline(ss, line)) {
21
line = trim(line); // 移除行首尾空格
22
if (line.empty() || line[0] == '#') continue; // 忽略空行和注释
23
24
result = executeLine(line);
25
}
26
return result;
27
}
28
29
private:
30
dynamic executeLine(const std::string& line) {
31
std::stringstream lineStream(line);
32
std::string command;
33
lineStream >> command;
34
35
if (command == "let") {
36
return executeLetCommand(lineStream);
37
} else if (command == "print") {
38
return executePrintCommand(lineStream);
39
} else {
40
throw std::runtime_error("Unknown command: " + command);
41
}
42
}
43
44
dynamic executeLetCommand(std::stringstream& lineStream) {
45
std::string varName;
46
std::string assignment;
47
std::string valueStr;
48
49
lineStream >> varName >> assignment; // 读取变量名和赋值符号 "="
50
51
std::getline(lineStream >> std::ws, valueStr); // 读取等号后面的所有内容作为值
52
53
if (assignment != "=") {
54
throw std::runtime_error("Invalid assignment operator: " + assignment);
55
}
56
57
dynamic value = evaluateExpression(valueStr);
58
variables_[varName] = value;
59
return value; // 返回赋值的值，方便调试
60
}
61
62
dynamic executePrintCommand(std::stringstream& lineStream) {
63
std::string expressionStr;
64
std::getline(lineStream >> std::ws, expressionStr); // 读取 print 后的表达式
65
66
dynamic value = evaluateExpression(expressionStr);
67
std::cout << toJson(value) << std::endl; // 打印 JSON 格式的值
68
return value; // 返回打印的值，方便调试
69
}
70
71
72
dynamic evaluateExpression(const std::string& expressionStr) {
73
std::stringstream exprStream(expressionStr);
74
dynamic leftOperand;
75
std::string op;
76
dynamic rightOperand;
77
78
exprStream >> leftOperand; // 尝试直接解析为 dynamic，可能是变量名或字面量
79
80
if (variables_.count(expressionStr)) { // 如果是变量名
81
leftOperand = variables_[expressionStr];
82
return leftOperand;
83
} else {
84
try {
85
leftOperand = parseJson(expressionStr); // 尝试解析为 JSON 字面量
86
} catch (const std::exception& /*e*/) {
87
// 如果解析 JSON 失败，则尝试作为变量名处理
88
if (variables_.count(expressionStr)) {
89
leftOperand = variables_[expressionStr];
90
} else {
91
throw std::runtime_error("Invalid expression: " + expressionStr);
92
}
93
}
94
}
95
96
97
if (!(exprStream >> op)) { // 如果没有运算符，则表达式就是单个值
98
return leftOperand;
99
}
100
101
exprStream >> rightOperand; // 读取右操作数
102
103
if (op == "+") {
104
return leftOperand + rightOperand;
105
} else if (op == "-") {
106
return leftOperand - rightOperand;
107
} else if (op == "*") {
108
return leftOperand * rightOperand;
109
} else if (op == "/") {
110
return leftOperand / rightOperand;
111
} else {
112
throw std::runtime_error("Unsupported operator: " + op);
113
}
114
}
115
116
117
private:
118
std::unordered_map<std::string, dynamic> variables_; // 存储脚本变量
119
std::string trim(const std::string& str) { // 移除字符串首尾空格
120
size_t first = str.find_first_not_of(' ');
121
if (std::string::npos == first) {
122
return str;
123
}
124
size_t last = str.find_last_not_of(' ');
125
return str.substr(first, (last - first + 1));
126
}
127
};
128
129
int main() {
130
SimpleScriptInterpreter interpreter;
131
std::string script = R"(
132
# 这是一个简单的脚本示例
133
let x = 10
134
let y = 20
135
let result = x + y
136
print result # 输出结果
137
print "Hello, Script!" # 打印字符串
138
let message = "Dynamic Scripting"
139
print message
140
let obj = {"name": "script", "version": 1.0}
141
print obj
142
)";
143
144
dynamic scriptResult = interpreter.execute(script);
145
std::cout << "Script execution finished." << std::endl;
146
147
return 0;
148
}
代码解析
① SimpleScriptInterpreter 类实现了一个简单的脚本解释器。
② execute 函数接受脚本字符串作为输入，逐行解析和执行脚本。
③ executeLine 函数解析每一行脚本，根据命令类型（let, print）调用不同的处理函数。
④ executeLetCommand 函数处理变量赋值语句，将变量名和值存储在 variables_ 成员变量中，这是一个 std::unordered_map<std::string, dynamic>，用于存储脚本变量。
⑤ executePrintCommand 函数处理打印语句，计算表达式的值，并将其打印到控制台。
⑥ evaluateExpression 函数负责解析和计算表达式。目前只实现了简单的加减乘除运算，以及变量和 JSON 字面量的解析。
⑦ variables_ 成员变量使用 std::unordered_map 存储脚本变量，键是变量名（字符串），值是 folly::dynamic 对象。
⑧ 在 main 函数中，我们创建 SimpleScriptInterpreter 对象，并执行一段简单的脚本。脚本中定义了变量、进行了算术运算、打印了结果和字符串，以及定义和打印了 JSON 对象。
优势分析
⚝ 快速原型：使用 folly::dynamic 可以快速搭建脚本语言的原型，无需从零开始实现复杂的运行时环境和数据类型系统。
⚝ 易于集成：脚本解释器可以很容易地嵌入到 C++ 应用中，通过 folly::dynamic 实现 C++ 代码和脚本之间的互操作。
⚝ 动态类型：folly::dynamic 的动态类型特性非常适合脚本语言，脚本语言通常也是动态类型的，可以灵活地处理各种数据类型。
⚝ JSON 支持：folly::dynamic 天然支持 JSON 数据格式，使得脚本语言可以方便地处理 JSON 数据，例如配置文件、API 响应等。
⚝ 可扩展性：可以根据需要扩展脚本语言的功能，例如添加更多的命令、运算符、数据类型、控制结构等。
总结
folly::dynamic 为开发轻量级脚本语言提供了一种快速且有效的方法。通过使用 folly::dynamic 作为脚本语言的运行时数据表示，我们可以大大简化脚本解释器的开发工作，并快速构建出满足特定需求的脚本扩展功能。这种方法特别适用于需要嵌入式脚本功能的 C++ 应用，能够有效地提升应用的灵活性和可扩展性。对于初学者和中级工程师而言，理解和掌握 folly::dynamic 在脚本语言开发中的应用，能够帮助他们快速入门脚本语言开发，并为更复杂的脚本语言设计打下基础。对于高级工程师和专家而言，folly::dynamic 提供了一种轻量级且高效的工具，用于构建定制化的脚本解决方案，并满足各种特定的脚本需求。
END_OF_CHAPTER
7. chapter 7： dynamic 性能与优化 (Performance and Optimization of dynamic)
7.1 dynamic 的性能特点分析 (Performance Characteristics Analysis of dynamic)
动态类型 dynamic 提供了极大的灵活性，允许我们在运行时处理不同类型的数据，而无需在编译时确定其具体类型。这种灵活性是以一定的性能开销为代价的。理解 dynamic 的性能特点对于有效地使用它至关重要，尤其是在性能敏感的应用场景中。本节将深入分析 dynamic 的性能特点，帮助读者权衡其灵活性与性能开销。
7.1.1 动态类型带来的性能开销 (Performance Overhead of Dynamic Typing)
动态类型与静态类型相比，主要的性能开销来自于以下几个方面：
① 类型检查开销 (Type Checking Overhead)：
静态类型语言在编译时进行类型检查，确保类型安全。而动态类型语言的类型检查则延迟到运行时。每次对 dynamic 对象进行操作时，都需要进行类型检查，以确保操作的有效性。例如，当我们尝试访问 dynamic 对象中的某个成员时，系统需要在运行时判断该对象是否真的包含该成员，以及成员的类型是否符合预期。这种运行时的类型检查会带来额外的计算开销。
② 内存分配开销 (Memory Allocation Overhead)：
dynamic 需要能够存储不同类型的数据，这通常意味着它需要在堆上分配内存来存储数据。与栈上分配的静态类型变量相比，堆内存分配和释放的开销更大。此外，dynamic 对象可能需要存储类型信息，这也增加了内存开销。
③ 间接访问开销 (Indirection Overhead)：
访问 dynamic 对象的值通常需要通过指针或引用进行间接访问。这种间接访问会增加指令执行的延迟，尤其是在频繁访问 dynamic 对象的情况下。
④ 虚函数调用开销 (Virtual Function Call Overhead)：
folly::dynamic 的实现可能使用了虚函数来实现多态性。虚函数调用相比于普通函数调用，会增加额外的查找虚函数表的开销。虽然现代编译器的优化技术可以在一定程度上缓解这种开销，但在某些情况下仍然可能成为性能瓶颈。
⚝ 示例代码：性能开销对比
为了更直观地理解动态类型带来的性能开销，我们可以通过一个简单的示例代码进行对比。假设我们需要对一个数值进行加法运算，分别使用 int 类型和 dynamic 类型进行操作，并测量它们的执行时间。
1
#include <folly/dynamic.h>
2
#include <chrono>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace std::chrono;
7
8
int main() {
9
// 使用 int 类型
10
int int_val = 10;
11
auto start_int = high_resolution_clock::now();
12
for (int i = 0; i < 1000000; ++i) {
13
int_val += 1;
14
}
15
auto end_int = high_resolution_clock::now();
16
auto duration_int = duration_cast<microseconds>(end_int - start_int);
17
18
// 使用 dynamic 类型
19
dynamic dynamic_val = 10;
20
auto start_dynamic = high_resolution_clock::now();
21
for (int i = 0; i < 1000000; ++i) {
22
dynamic_val = dynamic_val.asInt() + 1; // 需要显式类型转换
23
}
24
auto end_dynamic = high_resolution_clock::now();
25
auto duration_dynamic = duration_cast<microseconds>(end_dynamic - start_dynamic);
26
27
std::cout << "Int Duration: " << duration_int.count() << " microseconds" << std::endl;
28
std::cout << "Dynamic Duration: " << duration_dynamic.count() << " microseconds" << std::endl;
29
30
return 0;
31
}
运行上述代码，我们可以观察到 dynamic 版本的执行时间通常会比 int 版本更长。这主要是因为 dynamic 版本在每次循环中都需要进行类型检查和可能的类型转换，而 int 版本则没有这些开销。
7.1.2 folly::dynamic 的性能优势 (Performance Advantages of folly::dynamic)
尽管动态类型本身存在性能开销，folly::dynamic 在设计和实现上仍然做了很多优化，以尽可能地提高性能。folly::dynamic 的性能优势主要体现在以下几个方面：
① 高效的类型表示 (Efficient Type Representation)：
folly::dynamic 内部使用高效的数据结构来表示不同的类型，例如使用 enum 和 union 的组合，以及使用 small-object optimization (小对象优化) 技术来减少小对象的内存分配开销。这使得 dynamic 对象在存储和访问类型信息时更加高效。
② 优化的内存管理 (Optimized Memory Management)：
folly::dynamic 使用自定义的内存分配器，可以根据实际使用场景进行优化。例如，可以使用 arena allocator (竞技场分配器) 来批量分配内存，减少内存碎片，并提高内存分配和释放的效率。
③ 延迟解析 (Lazy Parsing)：
在处理 JSON 等数据格式时，folly::dynamic 可以采用延迟解析的策略。这意味着只有在真正需要访问 JSON 数据时，才进行解析，而不是一次性解析整个 JSON 文档。这可以显著提高解析性能，尤其是在处理大型 JSON 文档时。
④ 内联和编译时优化 (Inlining and Compile-time Optimization)：
folly::dynamic 的实现充分利用了 C++ 的内联和编译时优化特性。例如，对于一些常见的操作，例如类型判断和类型转换，folly::dynamic 可以通过内联函数来减少函数调用开销。编译器也可以对 dynamic 的代码进行优化，例如消除冗余的类型检查。
⑤ 针对特定场景的优化 (Scenario-Specific Optimizations)：
folly::dynamic 在设计时考虑了常见的应用场景，例如 JSON 处理和配置管理。针对这些场景，folly::dynamic 进行了专门的优化。例如，在 JSON 处理方面，folly::dynamic 提供了高效的 JSON 解析和生成 API。
7.1.3 常见操作的性能基准 (Performance Benchmarks for Common Operations)
为了更具体地了解 folly::dynamic 的性能，我们可以进行一些常见的操作的性能基准测试。以下是一些常见的操作以及它们的性能特点：
① 创建和销毁 (Creation and Destruction)：
dynamic 对象的创建和销毁开销相对较小，尤其是在使用小对象优化的情况下。但是，频繁地创建和销毁 dynamic 对象仍然会带来一定的性能开销。
② 类型判断 (Type Checking)：
dynamic 的类型判断操作，例如 isBool(), isInt(), isString() 等，通常非常快速，因为类型信息是直接存储在 dynamic 对象内部的。
③ 值访问 (Value Access)：
访问 dynamic 对象的值，例如 asBool(), asInt(), asString() 等，会涉及到类型转换和可能的内存拷贝。这些操作的开销取决于具体的类型和数据大小。访问基本类型（如 bool, int, double）的值通常比较快，而访问字符串或数组等复杂类型的值则可能开销较大。
④ 修改值 (Value Modification)：
修改 dynamic 对象的值，例如赋值操作，会涉及到内存分配和数据拷贝。如果新的值类型与旧的值类型不同，还可能需要进行类型转换和内存重新分配。修改操作的开销取决于新的值的大小和类型。
⑤ JSON 解析和生成 (JSON Parsing and Generation)：
folly::dynamic 提供了高效的 JSON 解析和生成 API。JSON 解析的性能取决于 JSON 文档的大小和复杂度。folly::dynamic 的 JSON 解析器通常比其他一些 JSON 库更快，尤其是在处理大型 JSON 文档时。JSON 生成的性能也比较高，但仍然会受到数据结构复杂度的影响。
⚝ 性能测试工具 (Performance Testing Tools)
为了进行更精确的性能测试，可以使用专业的性能测试工具，例如 Google Benchmark。Google Benchmark 可以帮助我们测量代码的执行时间、CPU 周期数、内存分配等性能指标，并生成详细的性能报告。
⚝ 性能优化建议 (Performance Optimization Suggestions)
在实际应用中，为了提高 dynamic 的性能，可以考虑以下优化建议：
⚝ 避免不必要的 dynamic 使用：如果类型在编译时可以确定，尽量使用静态类型，而不是 dynamic。
⚝ 减少 dynamic 对象的拷贝：尽量使用引用或指针传递 dynamic 对象，避免不必要的拷贝。
⚝ 优化 JSON 处理：使用 folly::dynamic 提供的 JSON API 进行高效的 JSON 解析和生成。
⚝ 使用自定义内存分配器：在性能敏感的场景中，可以考虑使用自定义内存分配器，例如 arena allocator，来优化内存管理。
7.2 减少 dynamic 的性能开销 (Reducing Performance Overhead of dynamic)
虽然 folly::dynamic 已经做了很多性能优化，但在某些性能敏感的应用场景中，我们仍然需要进一步减少 dynamic 的性能开销。本节将介绍一些减少 dynamic 性能开销的实用技巧和方法。
7.2.1 避免不必要的类型转换 (Avoiding Unnecessary Type Conversions)
类型转换是 dynamic 操作中常见的性能开销来源之一。每次调用 asBool(), asInt(), asString() 等方法时，dynamic 都会进行类型检查和类型转换。如果类型转换是不必要的，或者可以提前确定类型，那么就可以避免这些开销。
① 显式类型判断 (Explicit Type Checking)：
在进行类型转换之前，可以使用 isBool(), isInt(), isString() 等方法显式地判断 dynamic 对象的类型。只有在类型匹配时才进行类型转换，避免不必要的类型转换尝试。
1
dynamic value = 123;
2
if (value.isInt()) {
3
int int_val = value.asInt(); // 只有在确定是 int 类型时才转换
4
// ... 使用 int_val
5
} else {
6
// ... 处理其他类型
7
}
② 缓存类型转换结果 (Caching Type Conversion Results)：
如果需要多次访问 dynamic 对象的同一个值，可以将类型转换的结果缓存起来，避免重复进行类型转换。
1
dynamic value = "hello";
2
if (value.isString()) {
3
std::string str_val = value.asString(); // 第一次转换
4
for (int i = 0; i < 100; ++i) {
5
// ... 使用 str_val，避免重复转换
6
std::cout << str_val << std::endl;
7
}
8
}
③ 使用 get_ptr() 避免拷贝 (Using get_ptr() to Avoid Copies)：
对于字符串和数组等复杂类型，asString() 和 asArray() 等方法会返回值的拷贝。如果只需要读取值，而不需要修改，可以使用 getString() 和 getArray() 方法，或者 get_ptr<std::string>() 和 get_ptr<dynamic::array>() 方法来获取指向内部数据的指针或引用，避免不必要的拷贝开销。
1
dynamic value = "large string";
2
if (value.isString()) {
3
const std::string* str_ptr = value.getString(); // 获取指向内部字符串的指针，避免拷贝
4
if (str_ptr) {
5
// ... 使用 *str_ptr
6
std::cout << *str_ptr << std::endl;
7
}
8
}
7.2.2 减少 dynamic 对象的拷贝 (Reducing Copies of dynamic Objects)
dynamic 对象的拷贝可能会带来较大的性能开销，尤其是在 dynamic 对象存储了大量数据时。为了减少拷贝开销，可以采取以下措施：
① 使用引用或指针传递 (Passing by Reference or Pointer)：
在函数调用或对象传递时，尽量使用引用 (dynamic&) 或指针 (dynamic*) 传递 dynamic 对象，而不是值传递 (dynamic)。引用和指针传递避免了对象的拷贝，只传递了对象的地址。
1
void process_dynamic_ref(const dynamic& d) { // 使用引用传递
2
// ... 使用 d
3
std::cout << d.isInt() << std::endl;
4
}
5
6
void process_dynamic_ptr(const dynamic* d) { // 使用指针传递
7
if (d) {
8
// ... 使用 *d
9
std::cout << d->isString() << std::endl;
10
}
11
}
12
13
int main() {
14
dynamic large_dynamic_object = /* ... */;
15
process_dynamic_ref(large_dynamic_object); // 避免拷贝
16
process_dynamic_ptr(&large_dynamic_object); // 避免拷贝
17
return 0;
18
}
② 使用 std::move() 移动语义 (Using std::move() Move Semantics)：
在某些情况下，可以使用 std::move() 将 dynamic 对象的所有权转移给另一个对象，而不是进行深拷贝。移动语义可以避免不必要的数据拷贝，提高性能。
1
dynamic create_dynamic_object() {
2
dynamic obj = /* ... */;
3
return obj; // 返回时会发生移动
4
}
5
6
int main() {
7
dynamic obj1 = create_dynamic_object(); // 移动构造
8
dynamic obj2 = std::move(obj1); // 移动赋值
9
return 0;
10
}
③ 就地修改 (In-place Modification)：
尽量就地修改 dynamic 对象的值，而不是创建新的 dynamic 对象。例如，可以使用 dynamic::operator[] 和 dynamic::insert() 等方法直接修改 dynamic 对象内部的数据，避免创建新的 dynamic 对象。
7.2.3 使用就地修改 (Using In-place Modification)
就地修改是指直接修改 dynamic 对象内部的数据，而不是创建新的 dynamic 对象。就地修改可以减少内存分配和数据拷贝的开销，提高性能。
① 使用 dynamic::operator[] 修改数组和对象元素 (Using dynamic::operator[] to Modify Array and Object Elements)：
dynamic::operator[] 可以用于访问和修改 dynamic 数组和对象的元素。通过 operator[] 修改元素是就地修改，不会创建新的 dynamic 对象。
1
dynamic arr = dynamic::array(1, 2, 3);
2
arr[0] = 10; // 就地修改数组元素
3
dynamic obj = dynamic::object("key", "value");
4
obj["key"] = "new value"; // 就地修改对象元素
② 使用 dynamic::insert() 修改对象元素 (Using dynamic::insert() to Modify Object Elements)：
dynamic::insert() 方法可以用于向 dynamic 对象中插入新的键值对，或者修改已有的键值对。insert() 方法也是就地修改，不会创建新的 dynamic 对象。
1
dynamic obj = dynamic::object();
2
obj.insert("key1", "value1"); // 就地插入新的键值对
3
obj.insert("key1", "new value1"); // 就地修改已有的键值对
③ 使用 dynamic::emplace_back() 修改数组元素 (Using dynamic::emplace_back() to Modify Array Elements)：
dynamic::emplace_back() 方法可以用于在 dynamic 数组的末尾添加新的元素。emplace_back() 方法是就地构造元素，避免了元素的拷贝或移动开销。
1
dynamic arr = dynamic::array();
2
arr.emplace_back(1); // 就地构造并添加到数组末尾
3
arr.emplace_back("hello");
7.2.4 优化 JSON 处理 (Optimizing JSON Processing)
JSON 处理是 dynamic 的一个重要应用场景。优化 JSON 处理可以显著提高 dynamic 的性能。
① 延迟解析 (Lazy Parsing)：
folly::dynamic 默认采用延迟解析策略。这意味着只有在真正需要访问 JSON 数据时，才进行解析。在处理大型 JSON 文档时，延迟解析可以显著提高性能，因为可以避免解析不必要的数据。
② 流式解析 (Streaming Parsing)：
对于非常大的 JSON 文档，可以使用流式解析 API，例如 folly::json::parse(folly::io::Cursor& cursor)。流式解析可以逐块解析 JSON 数据，而不是一次性加载整个文档到内存中。这可以减少内存消耗，并提高解析性能。
③ 预先分配内存 (Pre-allocating Memory)：
在生成 JSON 字符串时，如果可以预先估计 JSON 字符串的大小，可以预先分配足够的内存空间，避免动态内存分配和重新分配的开销。可以使用 folly::io::Appender 来高效地构建 JSON 字符串。
④ 避免不必要的 JSON 序列化和反序列化 (Avoiding Unnecessary JSON Serialization and Deserialization)：
如果只需要在程序内部处理 JSON 数据，而不需要将其转换为字符串或从字符串解析，可以直接使用 dynamic 对象进行操作，避免不必要的 JSON 序列化和反序列化过程。
7.3 内存管理与自定义分配器 (Memory Management and Custom Allocators)
folly::dynamic 的内存管理对于其性能至关重要。默认情况下，dynamic 使用标准的 malloc 和 free 进行内存分配和释放。在某些高性能场景中，自定义内存分配器可以提供更好的性能。本节将介绍 dynamic 的内存管理机制，以及如何使用自定义内存分配器来优化性能。
7.3.1 folly::dynamic 的默认内存分配器 (Default Memory Allocator of folly::dynamic)
folly::dynamic 默认使用 std::allocator<void> 作为其内存分配器。std::allocator<void> 内部通常使用 malloc 和 free 进行内存分配和释放。malloc 和 free 是通用的内存分配器，适用于大多数场景。但在高并发、频繁分配和释放小对象等特定场景下，malloc 和 free 的性能可能成为瓶颈。
folly::dynamic 的内存分配器可以通过模板参数进行自定义。dynamic 类的定义如下：
1
template <typename Allocator = std::allocator<void>>
2
class dynamic {
3
// ...
4
};
默认情况下，Allocator 模板参数为 std::allocator<void>。我们可以通过指定不同的分配器类型来改变 dynamic 的内存管理行为。
7.3.2 自定义内存分配器的优势 (Advantages of Custom Memory Allocators)
自定义内存分配器可以针对特定的应用场景进行优化，从而提高内存分配和释放的效率，并减少内存碎片。自定义内存分配器的优势主要体现在以下几个方面：
① 提高内存分配和释放速度 (Improving Memory Allocation and Release Speed)：
自定义内存分配器可以采用更高效的内存分配算法，例如 arena allocator, pool allocator 等。这些分配器可以批量分配内存，并重用已释放的内存，从而减少内存分配和释放的开销。
② 减少内存碎片 (Reducing Memory Fragmentation)：
malloc 和 free 在频繁分配和释放不同大小的内存块时，容易产生内存碎片。内存碎片会导致内存利用率降低，并可能影响程序的性能。自定义内存分配器可以采用更精细的内存管理策略，例如使用 arena allocator 来分配固定大小的内存块，从而减少内存碎片。
③ 提高缓存局部性 (Improving Cache Locality)：
自定义内存分配器可以将相关的数据对象分配到连续的内存区域，从而提高缓存局部性。缓存局部性可以减少 CPU 访问内存的次数，提高程序的执行速度。
④ 定制化内存管理策略 (Customized Memory Management Strategies)：
自定义内存分配器可以根据具体的应用场景定制内存管理策略。例如，在多线程环境中，可以使用线程安全的内存分配器来避免锁竞争。在内存受限的环境中，可以使用内存池来限制内存使用量。
7.3.3 如何实现自定义内存分配器 (How to Implement Custom Memory Allocators)
要实现自定义内存分配器，需要创建一个符合 Allocator 要求的类。Allocator 类需要提供以下方法：
⚝ pointer allocate(size_type n, pointer hint = 0)：分配 n 个大小为 sizeof(void) 字节的内存块。
⚝ void deallocate(pointer p, size_type n)：释放之前分配的 n 个大小为 sizeof(void) 字节的内存块。
⚝ size_type max_size() const throw()：返回可以分配的最大内存块大小。
⚝ 示例代码：自定义 Arena 分配器
以下是一个简单的 Arena 分配器的示例代码：
1
#include <memory>
2
#include <vector>
3
#include <stdexcept>
4
5
class ArenaAllocator {
6
public:
7
using pointer = void*;
8
using size_type = std::size_t;
9
using is_always_equal = std::true_type; // C++17 required
10
11
ArenaAllocator(size_type chunkSize = 4096) : chunkSize_(chunkSize), currentChunkSize_(0), currentChunk_(nullptr) {}
12
13
pointer allocate(size_type n, pointer hint = nullptr) {
14
if (n > chunkSize_) {
15
throw std::bad_alloc(); // Allocation too large for arena
16
}
17
if (currentChunk_ == nullptr || currentChunkSize_ + n > chunkSize_) {
18
// Allocate a new chunk
19
currentChunk_ = static_cast<char*>(std::malloc(chunkSize_));
20
if (currentChunk_ == nullptr) {
21
throw std::bad_alloc();
22
}
23
chunks_.push_back(currentChunk_);
24
currentChunkSize_ = 0;
25
}
26
pointer p = currentChunk_ + currentChunkSize_;
27
currentChunkSize_ += n;
28
return p;
29
}
30
31
void deallocate(pointer p, size_type n) {
32
// Arena allocator does not deallocate individual blocks, only whole arena at once.
33
// In debug mode, we can check if the pointer belongs to the arena for error detection.
34
#ifdef DEBUG
35
bool belongsToArena = false;
36
for (char* chunk : chunks_) {
37
if (p >= chunk && p < chunk + chunkSize_) {
38
belongsToArena = true;
39
break;
40
}
41
}
42
if (!belongsToArena) {
43
throw std::runtime_error("Deallocating memory not from arena");
44
}
45
#endif
46
// No actual deallocation here. Memory is freed when the arena is destroyed.
47
}
48
49
~ArenaAllocator() {
50
for (char* chunk : chunks_) {
51
std::free(chunk);
52
}
53
}
54
55
private:
56
size_type chunkSize_;
57
size_type currentChunkSize_;
58
char* currentChunk_;
59
std::vector<char*> chunks_;
60
};
7.3.4 使用 Arena 分配器优化内存分配 (Optimizing Memory Allocation with Arena Allocators)
Arena 分配器是一种高效的内存分配策略，特别适用于生命周期较短的对象。Arena 分配器预先分配一大块连续的内存区域（Arena），然后从 Arena 中分配小块内存。当 Arena 不再使用时，一次性释放整个 Arena。Arena 分配器的优点是分配速度快，内存碎片少，但缺点是不能单独释放 Arena 中分配的内存块，只能一次性释放整个 Arena。
⚝ 使用 Arena 分配器与 folly::dynamic
要将 Arena 分配器与 folly::dynamic 结合使用，只需要在创建 dynamic 对象时，指定 Arena 分配器作为模板参数即可。
1
#include <folly/dynamic.h>
2
#include "arena_allocator.h" // 假设 ArenaAllocator 定义在 arena_allocator.h 中
3
4
int main() {
5
using ArenaDynamic = folly::dynamic<ArenaAllocator>; // 使用 ArenaAllocator 的 dynamic 类型别名
6
ArenaAllocator arena;
7
ArenaDynamic dynamic_obj{arena}; // 创建使用 ArenaAllocator 的 dynamic 对象
8
9
dynamic_obj = dynamic::object("key", 123); // 在 Arena 中分配内存
10
// ... 使用 dynamic_obj
11
12
return 0; // arena 在 dynamic_obj 销毁后被销毁，释放 Arena 中的所有内存
13
}
通过使用 Arena 分配器，可以显著提高 folly::dynamic 在某些场景下的性能，尤其是在需要频繁创建和销毁 dynamic 对象，且对象生命周期较短的情况下。在选择自定义内存分配器时，需要根据具体的应用场景和性能需求进行权衡和选择。
END_OF_CHAPTER
8. chapter 8： dynamic 源码剖析 (Source Code Analysis of dynamic)
8.1 dynamic 的内部结构 (Internal Structure of dynamic)
folly::dynamic 是 Folly 库中用于表示动态类型的核心组件。为了理解其强大功能和性能特性，深入剖析其内部结构至关重要。dynamic 的设计目标是提供一种灵活且高效的方式来处理类型不确定的数据，尤其是在需要与外部数据格式（如 JSON）交互或构建动态系统时。
dynamic 的核心是一个能够容纳多种不同类型值的容器。从概念上讲，你可以将其视为一个“类型安全的 union”加上一些额外的元数据和管理机制。 它允许你在运行时存储和操作不同类型的数据，而无需在编译时确定具体类型。
让我们从宏观层面审视 dynamic 的内部结构，然后再深入到细节：
① 类型标签 (Type Tag)：dynamic 对象内部首先需要记录它当前存储的数据类型。这通过一个枚举或类似的机制来实现，我们称之为类型标签（Type Tag）。类型标签明确地指出了 dynamic 对象当前持有的是整数、浮点数、字符串、布尔值、数组、对象还是空值（null）。
② 数据存储区 (Data Storage)：根据类型标签，dynamic 需要一块内存区域来实际存储数据。由于 dynamic 可以存储多种类型，因此这块存储区的设计需要能够适应不同大小和类型的数据。常见的实现方式是使用 union 或 variant 类似的结构，或者使用 void* 指针指向堆上分配的内存。为了优化性能和内存使用，dynamic 通常会采用小对象优化（Small Object Optimization, SSO）技术，对于较小的数据类型（如整数、布尔值），直接在 dynamic 对象自身内部存储，避免额外的堆分配。对于较大的数据类型（如字符串、数组、对象），则可能在堆上分配内存，并使用指针在 dynamic 对象内部引用堆内存。
③ 引用计数 (Reference Counting)：当 dynamic 对象存储复杂类型（如字符串、数组、对象）时，通常会涉及到动态内存分配。为了有效地管理这些内存，并避免内存泄漏，dynamic 常常会采用引用计数（Reference Counting）机制。这意味着多个 dynamic 对象可以共享同一份堆内存数据，只有当最后一个引用消失时，才会释放内存。这对于拷贝 dynamic 对象以及在不同作用域之间传递 dynamic 对象非常重要。
④ 分配器 (Allocator)：dynamic 的内存分配行为可以通过自定义分配器（Allocator）进行控制。这允许用户根据具体的应用场景，选择合适的内存分配策略，例如使用内存池来提高性能或减少内存碎片。
为了更具体地理解 dynamic 的内部结构，我们可以设想一个简化的模型，尽管实际的 folly::dynamic 实现可能更复杂和优化：
1
enum class DynamicType {
2
kNull,
3
kBool,
4
kInt,
5
kDouble,
6
kString,
7
kArray,
8
kObject,
9
};
10
11
struct DynamicInternal {
12
DynamicType type_;
13
union {
14
bool bool_val;
15
int64_t int_val;
16
double double_val;
17
// 小字符串优化，例如使用 folly::small_vector<char, N>
18
folly::fbstring string_val;
19
// 指向堆上分配的数组或对象
20
void* ptr_val;
21
};
22
// 引用计数 (如果 ptr_val 指向堆内存)
23
std::atomic<uint32_t>* ref_count_;
24
};
25
26
class dynamic {
27
public:
28
// ... dynamic 的公共接口 ...
29
30
private:
31
DynamicInternal internal_;
32
};
图示：dynamic 的简化内部结构
1
+---------------------+
2
| dynamic |
3
+---------------------+
4
| - internal_ | ----> +---------------------+
5
| | | DynamicInternal |
6
| | +---------------------+
7
| | | | type_ (DynamicType)|
8
| | | +---------------------+
9
| | | | union { |
10
| | | | bool bool_val; |
11
| | | | int64_t int_val; |
12
| | | | double double_val; |
13
| | | | fbstring string_val;|
14
| | | | void* ptr_val; |
15
| | | | } |
16
| | | +---------------------+
17
| | | | ref_count_* | ----> (Reference Count - only for heap allocated data)
18
| | | +---------------------+
19
+---------------------+
关键点总结：
⚝ dynamic 内部维护一个类型标签，用于标识当前存储的数据类型。
⚝ 使用 union 或类似机制来存储不同类型的值，并可能采用小对象优化。
⚝ 对于复杂类型，使用引用计数进行内存管理。
⚝ 可能支持自定义分配器以控制内存分配行为。
理解 dynamic 的内部结构有助于我们更好地理解其性能特点和使用限制，并在实际应用中做出更明智的选择。在接下来的章节中，我们将更深入地探讨类型存储与管理以及内存分配策略。
8.2 dynamic 的类型存储与管理 (Type Storage and Management of dynamic)
folly::dynamic 的核心功能之一是能够存储和管理多种不同的数据类型。为了实现这一目标，dynamic 必须有效地跟踪当前存储值的类型，并在运行时根据类型执行相应的操作。本节将深入探讨 dynamic 的类型存储与管理机制。
类型枚举 (Type Enumeration)
dynamic 首先需要定义一套完整的类型枚举，用于标识其可以存储的所有数据类型。在 folly::dynamic 中，这些类型包括：
⚝ null：空值。
⚝ bool：布尔值（true 或 false）。
⚝ int64：64位有符号整数。
⚝ double：双精度浮点数。
⚝ string：字符串。
⚝ array：数组（有序的值集合）。
⚝ object：对象（键值对的集合，类似于字典或哈希表）。
这些类型被映射到内部的类型标签（Type Tag），通常是一个枚举类型。例如，在 folly::dynamic 的实现中，可能会有类似以下的枚举定义：
1
namespace folly {
2
namespace dynamic_detail {
3
4
enum class Type : uint8_t {
5
NULL_T,
6
BOOL,
7
INT64,
8
DOUBLE,
9
STRING,
10
ARRAY,
11
OBJECT,
12
// ... 内部类型 ...
13
};
14
15
} // namespace dynamic_detail
16
} // namespace folly
这个枚举 Type 定义了 dynamic 可以表示的所有外部可见类型，以及可能存在的内部类型（例如，用于优化的内部表示）。
类型存储 (Type Storage)
类型标签本身需要被存储在 dynamic 对象内部。正如我们在上一节讨论的内部结构，dynamic 通常会在其内部结构 DynamicInternal 中包含一个成员变量来存储类型标签，例如 type_，其类型为 dynamic_detail::Type。
类型判断 (Type Checking)
有了类型标签，dynamic 就可以在运行时进行类型判断。folly::dynamic 提供了多种方法来检查 dynamic 对象当前的类型，例如：
⚝ isNull()：判断是否为 null 类型。
⚝ isBool()：判断是否为布尔类型。
⚝ isInt()：判断是否为整数类型。
⚝ isDouble()：判断是否为浮点数类型。
⚝ isString()：判断是否为字符串类型。
⚝ isArray()：判断是否为数组类型。
⚝ isObject()：判断是否为对象类型。
这些方法通常会直接检查内部存储的类型标签 type_，并返回相应的布尔值。例如，isNull() 的实现可能类似于：
1
bool dynamic::isNull() const {
2
return internal_.type_ == dynamic_detail::Type::NULL_T;
3
}
类型转换 (Type Conversion)
dynamic 还支持类型转换，允许将 dynamic 对象转换为其存储的实际类型。folly::dynamic 提供了 asXXX() 系列方法来进行类型转换，例如：
⚝ asNull()：转换为 nullptr_t (仅当类型为 null 时有效)。
⚝ asBool()：转换为 bool (仅当类型为 bool 时有效)。
⚝ asInt()：转换为 int64_t (仅当类型为 int 时有效)。
⚝ asDouble()：转换为 double (仅当类型为 double 时有效)。
⚝ asString()：转换为 std::string (仅当类型为 string 时有效)。
⚝ asArray()：转换为 dynamic::array (仅当类型为 array 时有效)。
⚝ asObject()：转换为 dynamic::object (仅当类型为 object 时有效)。
这些 asXXX() 方法在类型不匹配时会抛出异常，以确保类型安全。例如，asInt() 的实现会先检查类型是否为 int64，如果不是则抛出异常，否则返回存储的整数值。
1
int64_t dynamic::asInt() const {
2
if (internal_.type_ != dynamic_detail::Type::INT64) {
3
throw std::runtime_error("dynamic: type is not int64");
4
}
5
return internal_.internal_.int_val;
6
}
类型安全 (Type Safety)
folly::dynamic 提供了运行时的类型安全。虽然它允许存储不同类型的值，但在尝试访问或操作值时，会进行类型检查。如果类型不匹配，会抛出异常，防止类型错误导致程序崩溃或数据损坏。这种运行时类型安全是 dynamic 的关键特性，使其在处理外部数据或构建动态系统时更加可靠。
总结：
⚝ dynamic 使用类型枚举来标识其支持的数据类型。
⚝ 类型标签存储在 dynamic 对象内部。
⚝ 提供 isXXX() 方法进行类型判断。
⚝ 提供 asXXX() 方法进行类型转换，并在类型不匹配时抛出异常，保证运行时类型安全。
通过这些机制，folly::dynamic 实现了对动态类型的有效存储和管理，为用户提供了灵活且安全的方式来处理类型不确定的数据。接下来，我们将探讨 dynamic 的内存分配策略，进一步了解其性能和资源管理。
8.3 dynamic 的内存分配策略 (Memory Allocation Strategy of dynamic)
folly::dynamic 的内存分配策略对其性能和资源消耗有着重要影响。由于 dynamic 需要存储不同大小和类型的数据，并且可能涉及到动态增长的数组和对象，因此高效的内存管理至关重要。本节将深入分析 dynamic 的内存分配策略。
小对象优化 (Small Object Optimization, SSO)
对于较小的数据类型，例如布尔值、整数、浮点数，以及短字符串，folly::dynamic 采用了小对象优化（SSO）技术。这意味着对于这些类型的值，dynamic 会直接在其自身内部的存储空间中进行存储，而无需额外的堆内存分配。
例如，对于一个存储整数的 dynamic 对象，其整数值会直接存储在 DynamicInternal 结构体的 union 中的 int_val 成员中。这避免了堆分配的开销，提高了性能，并减少了内存碎片。
对于短字符串，folly::dynamic 可能会使用 folly::small_vector 或类似的固定大小的缓冲区，直接在 dynamic 对象内部存储字符串数据，只要字符串长度不超过缓冲区大小。
堆内存分配 (Heap Allocation)
对于较大的数据类型，例如长字符串、数组和对象，以及超过 SSO 优化阈值的数据，folly::dynamic 会在堆上分配内存来存储数据。
⚝ 字符串 (String)：当字符串长度超过 SSO 优化的阈值时，dynamic 会在堆上分配一块内存来存储字符串数据，并将指向该内存的指针存储在 dynamic 对象内部。folly::fbstring 通常被用于高效的字符串管理，它本身也可能采用 SSO 和引用计数等优化策略。
⚝ 数组 (Array)：dynamic 的数组类型实际上是一个 std::vector<dynamic>。当创建一个 dynamic 数组时，std::vector 会在堆上分配内存来存储数组元素。随着数组元素的增加，std::vector 可能会进行动态扩容，重新分配更大的内存块。
⚝ 对象 (Object)：dynamic 的对象类型是一个 std::map<dynamic, dynamic>。类似于数组，当创建一个 dynamic 对象时，std::map 会在堆上分配内存来存储键值对。随着键值对的增加，std::map 的内部数据结构（通常是红黑树）也会动态调整和分配内存。
引用计数 (Reference Counting)
对于堆上分配的字符串、数组和对象数据，folly::dynamic 采用了引用计数机制进行内存管理。当多个 dynamic 对象共享同一份堆内存数据时，它们会共享同一个引用计数器。当一个 dynamic 对象被销毁或赋值为其他值时，其引用的堆内存的引用计数会减 1。当引用计数降为 0 时，表示没有任何 dynamic 对象再引用这块堆内存，此时堆内存会被释放。
引用计数有效地避免了内存泄漏，并允许多个 dynamic 对象共享数据，减少了内存拷贝和分配的开销。
自定义分配器 (Custom Allocator)
folly::dynamic 允许用户通过自定义分配器来控制其内存分配行为。用户可以提供自定义的 std::allocator 对象，用于 dynamic 内部的内存分配。这使得用户可以根据具体的应用场景，选择合适的内存分配策略，例如：
⚝ 内存池 (Memory Pool)：使用内存池可以预先分配一块大的内存区域，然后从中分配和释放小块内存，减少内存分配和释放的开销，并提高性能。
⚝ 统计和监控 (Statistics and Monitoring)：自定义分配器可以用于跟踪 dynamic 的内存使用情况，进行内存泄漏检测和性能分析。
通过自定义分配器，用户可以更精细地控制 dynamic 的内存管理，以满足特定的性能和资源需求。
内存分配策略总结：
⚝ 小对象优化 (SSO)：对于小数据类型，直接在 dynamic 对象内部存储，避免堆分配。
⚝ 堆内存分配：对于大数据类型（长字符串、数组、对象），在堆上分配内存。
⚝ 引用计数：对于堆上分配的数据，使用引用计数进行内存管理，避免内存泄漏和减少拷贝。
⚝ 自定义分配器：允许用户自定义内存分配策略，以满足特定需求。
理解 dynamic 的内存分配策略有助于我们更好地评估其性能特点，并在性能敏感的应用场景中合理使用 dynamic。例如，在需要频繁创建和销毁 dynamic 对象，且存储的数据主要是小数据类型时，SSO 优化可以带来显著的性能提升。而在处理大量大数据或复杂数据结构时，引用计数和自定义分配器则可以帮助我们更好地管理内存，避免资源浪费。
END_OF_CHAPTER
9. chapter 9： dynamic 与其他动态类型方案的比较 (Comparison of dynamic with Other Dynamic Typing Solutions)
9.1 dynamic vs. std::variant (dynamic vs. std::variant)
folly::dynamic 和 std::variant 都是 C++ 中用于处理多种数据类型的工具，但它们的设计哲学和应用场景存在显著差异。std::variant 是 C++17 标准库引入的类型安全的联合体（union），而 folly::dynamic 是 Facebook Folly 库提供的动态类型。理解它们之间的区别有助于在合适的场景下选择最合适的工具。
① 类型安全性 (Type Safety)：
std::variant 的核心优势在于其类型安全。在编译时，std::variant 明确知道它可以存储哪些类型，并且在访问时会进行类型检查。如果尝试以错误的类型访问 std::variant，编译器会报错或者在运行时抛出异常（如果使用 std::get_if 等方法）。这种类型安全性有助于在编译阶段发现潜在的类型错误，提高代码的健壮性。
1
#include <variant>
2
#include <string>
3
#include <iostream>
4
5
int main() {
6
std::variant<int, std::string> v = 123;
7
std::cout << std::get<int>(v) << std::endl; // 正确：访问 int 类型
8
// std::cout << std::get<double>(v) << std::endl; // 编译错误：double 不是 variant 的可能类型
9
return 0;
10
}
相反，folly::dynamic 是动态类型，类型检查发生在运行时。dynamic 对象可以存储任何基本数据类型、对象或数组，并且其类型可以在运行时改变。虽然这提供了极大的灵活性，但也牺牲了一部分编译时的类型安全性。类型错误可能会延迟到运行时才被发现。
1
#include <folly/dynamic.h>
2
#include <iostream>
3
4
int main() {
5
folly::dynamic d = 123;
6
std::cout << d.asInt() << std::endl; // 正确：访问 int 类型
7
// std::cout << d.asDouble() << std::endl; // 运行时错误（如果 d 不是 double 类型）：抛出异常或返回默认值
8
return 0;
9
}
② 使用场景 (Use Cases)：
std::variant 适用于类型集合在编译时已知且相对固定的场景。例如，表示一个可以返回整数或字符串的函数返回值，或者处理一组预定义的事件类型。std::variant 的类型安全性使其在需要严格类型控制的场合非常有用，例如在状态机、协议解析等领域。
1
std::variant<int, std::string> process_data(bool condition) {
2
if (condition) {
3
return 42;
4
} else {
5
return "error";
6
}
7
}
folly::dynamic 更适合处理类型不确定或在运行时动态变化的场景，尤其是在处理外部数据（如 JSON、配置文件）或构建灵活的 API 时。dynamic 能够方便地表示和操作结构化的、半结构化的数据，而无需预先定义所有可能的类型。这使得 dynamic 在脚本语言、数据交换、动态配置等领域非常强大。
1
folly::dynamic config = folly::dynamic::object
2
("server", "localhost")
3
("port", 8080)
4
("debug", true);
5
6
std::string server_address = config["server"].asString();
7
int port = config["port"].asInt();
8
bool debug_mode = config["debug"].asBool();
③ 性能 (Performance)：
std::variant 通常具有更好的性能，尤其是在访问速度和内存占用方面。由于 std::variant 在编译时已知所有可能的类型，编译器可以进行更多的优化，例如直接访问存储的数据，而无需额外的类型检查和转换开销。std::variant 的内存占用也相对固定，取决于其存储的最大类型的大小。
folly::dynamic 由于需要在运行时进行类型检查和动态内存管理，通常会有一定的性能开销。每次访问 dynamic 对象的值时，都需要进行类型判断和可能的类型转换。此外，dynamic 在存储复杂数据结构（如对象和数组）时，可能需要动态分配内存，这也会带来额外的开销。然而，对于许多应用场景，folly::dynamic 的性能开销是可以接受的，尤其是在灵活性和开发效率方面的优势超过性能损失时。
④ 易用性 (Ease of Use)：
std::variant 的使用相对简洁，但需要预先明确所有可能的类型。访问 std::variant 的值通常需要使用 std::get、std::get_if 或 std::visit 等方法，这在一定程度上增加了代码的复杂性，尤其是在处理多种可能类型时。
1
std::variant<int, std::string> result = process_data(true);
2
if (std::holds_alternative<int>(result)) {
3
int value = std::get<int>(result);
4
std::cout << "Result is int: " << value << std::endl;
5
} else if (std::holds_alternative<std::string>(result)) {
6
std::string error = std::get<std::string>(result);
7
std::cout << "Result is string: " << error << std::endl;
8
}
folly::dynamic 的 API 设计更加友好和直观，特别是对于处理 JSON 等结构化数据。dynamic 对象可以直接使用类似字典和列表的访问方式，例如 dynamic["key"] 和 dynamic[index]，使得代码更加简洁易懂。dynamic 提供了丰富的类型转换方法（如 asInt()、asString()、asBool() 等），方便进行类型转换和访问。
1
folly::dynamic json_data = folly::parseJson(R"({"name": "Alice", "age": 30})");
2
std::string name = json_data["name"].asString();
3
int age = json_data["age"].asInt();
⑤ 总结 (Summary)：
| 特性 (Feature) | std::variant | folly::dynamic |
|---|---|---|
| 类型安全性 (Type Safety) | 编译时类型安全 (Compile-time type safety) | 运行时类型检查 (Runtime type checking) |
| 使用场景 (Use Cases) | 类型集合固定、类型安全要求高的场景 (Fixed type set, type-safety critical scenarios) | 类型不确定、动态数据、灵活 API (Uncertain types, dynamic data, flexible APIs) |
| 性能 (Performance) | 通常更高 (Generally better) | 运行时开销，但可接受 (Runtime overhead, but acceptable) |
| 易用性 (Ease of Use) | 相对复杂，需显式类型处理 (Relatively complex, explicit type handling) | 更直观，API 友好 (More intuitive, user-friendly API) |
选择 std::variant 还是 folly::dynamic 取决于具体的应用场景和需求。如果强调类型安全和性能，且类型集合在编译时已知，std::variant 是更好的选择。如果需要处理动态数据、构建灵活的系统，并且更看重开发效率和易用性，folly::dynamic 则更合适。在某些情况下，也可以将两者结合使用，例如使用 std::variant 来表示 dynamic 对象内部的特定类型，以兼顾类型安全和灵活性。
9.2 dynamic vs. RapidJSON::Value (dynamic vs. RapidJSON::Value)
folly::dynamic 和 RapidJSON::Value 都是用于处理动态数据的工具，尤其是在 JSON 数据处理方面。然而，它们的设计目标和侧重点有所不同。RapidJSON::Value 是 RapidJSON 库中专门用于表示 JSON 值的类，而 folly::dynamic 是一个更通用的动态类型，可以用于表示更广泛的数据类型和结构。
① 设计目标 (Design Goals)：
RapidJSON::Value 的主要设计目标是高效地解析、生成和操作 JSON 数据。RapidJSON 库本身就是一个专注于高性能 JSON 处理的库，Value 类自然也继承了这一目标。RapidJSON::Value 提供了丰富的 API，用于处理 JSON 的各种数据类型（null, boolean, number, string, object, array）和操作，例如查询、修改、序列化等。
folly::dynamic 的设计目标是提供一个通用的动态类型，用于在 C++ 中方便地处理动态类型的数据。虽然 dynamic 也非常擅长处理 JSON 数据，但它的应用范围更广。dynamic 可以用于表示配置文件、数据交换格式、脚本语言中的动态对象等。dynamic 的设计更侧重于灵活性和易用性，而不仅仅是 JSON 处理。
② JSON 处理能力 (JSON Processing Capabilities)：
RapidJSON::Value 在 JSON 处理方面提供了更专业和全面的功能。RapidJSON 库提供了高性能的 JSON 解析器和生成器，Value 类可以直接与这些解析器和生成器配合使用，实现高效的 JSON 数据处理。RapidJSON::Value 提供了丰富的 API，用于精确控制 JSON 数据的各个方面，例如控制数字的精度、字符串的编码、JSON 格式的输出等。
1
#include <rapidjson/document.h>
2
#include <rapidjson/writer.h>
3
#include <rapidjson/stringbuffer.h>
4
#include <iostream>
5
6
int main() {
7
rapidjson::Document document;
8
document.Parse(R"({"name": "Alice", "age": 30})");
9
rapidjson::Value& name = document["name"];
10
std::cout << name.GetString() << std::endl;
11
12
rapidjson::StringBuffer buffer;
13
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
14
document.Accept(writer);
15
std::cout << buffer.GetString() << std::endl;
16
return 0;
17
}
folly::dynamic 也提供了方便的 JSON 解析和生成功能，通过 folly::parseJson 和 folly::toJson 函数，可以轻松地在 dynamic 对象和 JSON 字符串之间进行转换。dynamic 在处理简单的 JSON 数据时非常方便，但对于需要精细控制 JSON 处理过程的场景，可能不如 RapidJSON::Value 灵活。
1
#include <folly/dynamic.h>
2
#include <folly/json.h>
3
#include <iostream>
4
5
int main() {
6
folly::dynamic json_data = folly::parseJson(R"({"name": "Alice", "age": 30})");
7
std::cout << json_data["name"].asString() << std::endl;
8
std::string json_string = folly::toJson(json_data);
9
std::cout << json_string << std::endl;
10
return 0;
11
}
③ 性能 (Performance)：
RapidJSON::Value 和 folly::dynamic 在 JSON 处理方面都具有较高的性能，但 RapidJSON 通常被认为在 JSON 解析和生成方面具有更高的效率。RapidJSON 库的设计目标之一就是高性能，它采用了多种优化技术，例如快速解析算法、内存池管理等。RapidJSON::Value 作为 RapidJSON 库的核心组件，自然也受益于这些优化。
folly::dynamic 的性能在大多数应用场景下也是可以接受的，尤其是在使用 Folly 库的其他组件时，dynamic 的集成性和便利性可能更重要。然而，如果极致的 JSON 处理性能是首要考虑因素，RapidJSON::Value 可能是更好的选择。
④ API 设计 (API Design)：
RapidJSON::Value 的 API 设计更贴近 JSON 数据模型，提供了丰富的接口用于操作 JSON 的各种类型和结构。RapidJSON::Value 提供了 IsObject(), IsArray(), IsString(), GetInt(), GetString() 等方法，用于检查类型和获取值。对于对象和数组，RapidJSON::Value 提供了迭代器和索引访问方式。
folly::dynamic 的 API 设计更加简洁和通用，更符合动态类型的编程风格。dynamic 对象可以直接使用类似字典和列表的访问方式，例如 dynamic["key"] 和 dynamic[index]。dynamic 提供了 asInt(), asString(), asBool() 等类型转换方法，使得代码更加简洁易懂。folly::dynamic 的 API 更注重易用性和开发效率。
⑤ 依赖性 (Dependencies)：
RapidJSON::Value 是 RapidJSON 库的一部分，使用 RapidJSON::Value 需要依赖 RapidJSON 库。RapidJSON 是一个独立的 C++ 库，相对轻量级，易于集成。
folly::dynamic 是 Facebook Folly 库的一部分，使用 folly::dynamic 需要依赖 Folly 库。Folly 库是一个大型的 C++ 库，包含许多实用的组件，但也意味着更大的依赖和编译开销。如果项目已经使用了 Folly 库，或者需要使用 Folly 库的其他功能，那么使用 folly::dynamic 是很自然的选择。如果项目只需要 JSON 处理功能，并且希望减少依赖，RapidJSON 可能是更轻量级的选择。
⑥ 总结 (Summary)：
| 特性 (Feature) | RapidJSON::Value | folly::dynamic |
|---|---|---|
| 设计目标 (Design Goals) | 高性能 JSON 处理 (High-performance JSON processing) | 通用动态类型，JSON 处理能力强 (General dynamic type, strong JSON processing) |
| JSON 处理能力 (JSON Processing) | 专业、全面、精细控制 (Professional, comprehensive, fine-grained control) | 方便、易用，满足日常 JSON 处理 (Convenient, easy-to-use, sufficient for daily JSON) |
| 性能 (Performance) | JSON 处理性能通常更高 (Generally higher JSON performance) | JSON 处理性能良好，通用性强 (Good JSON performance, general-purpose) |
| API 设计 (API Design) | 更贴近 JSON 数据模型 (Closer to JSON data model) | 更简洁、通用、易用 (More concise, general-purpose, easy-to-use) |
| 依赖性 (Dependencies) | 依赖 RapidJSON 库 (Depends on RapidJSON library) | 依赖 Folly 库 (Depends on Folly library) |
选择 RapidJSON::Value 还是 folly::dynamic 取决于项目的具体需求。如果主要关注高性能 JSON 处理，并且需要精细控制 JSON 操作，RapidJSON::Value 是更专业的选择。如果项目需要一个通用的动态类型，并且已经使用了 Folly 库，或者更看重易用性和开发效率，folly::dynamic 则更合适。在某些场景下，也可以将两者结合使用，例如使用 RapidJSON 解析 JSON 数据，然后将部分数据转换为 folly::dynamic 对象进行后续处理。
9.3 dynamic vs. 其他动态类型库 (dynamic vs. Other Dynamic Typing Libraries)
除了 std::variant 和 RapidJSON::Value，C++ 生态系统中还存在其他一些动态类型方案，以及其他语言中动态类型的概念。将 folly::dynamic 与这些方案进行比较，可以更全面地理解 dynamic 的特点和适用场景。
① Boost.Any (Boost.Any)：
Boost.Any 是 Boost 库提供的一个通用的动态类型，类似于 folly::dynamic，可以存储任意类型的值。Boost.Any 的设计目标是提供一种类型擦除（type erasure）的机制，允许在不知道具体类型的情况下存储和传递值。
相似之处：
⚝ 都是通用的动态类型，可以存储任意类型的值。
⚝ 都需要在运行时进行类型检查。
⚝ 都提供了类型转换的方法（boost::any_cast，dynamic::as*）。
不同之处：
⚝ API 设计：Boost.Any 的 API 相对简单，主要提供 any_cast 用于类型转换。folly::dynamic 的 API 更丰富，特别是对于处理结构化数据（对象和数组）更加方便。
⚝ JSON 支持：folly::dynamic 内置了对 JSON 的良好支持，可以方便地解析和生成 JSON 数据。Boost.Any 本身不直接支持 JSON，需要结合其他 JSON 库使用。
⚝ 性能：folly::dynamic 在某些场景下可能比 Boost.Any 具有更好的性能，尤其是在处理复杂数据结构时。Folly 库在性能优化方面做了很多工作。
⚝ 依赖性：Boost.Any 依赖 Boost 库，folly::dynamic 依赖 Folly 库。Boost 库相对更加通用和广泛使用，而 Folly 库则更专注于 Facebook 的内部需求。
适用场景：
⚝ Boost.Any 适用于需要简单动态类型的场景，例如存储未知类型的配置值、实现泛型数据容器等。
⚝ folly::dynamic 更适合处理结构化动态数据，例如 JSON、配置文件、动态 API 等，尤其是在项目已经使用了 Folly 库的情况下。
② Qt 的 QVariant (Qt's QVariant)：
QVariant 是 Qt 框架提供的一个动态类型，用于在 Qt 的元对象系统（meta-object system）中存储和传递各种数据类型。QVariant 可以存储 Qt 支持的各种基本类型、Qt 对象、以及自定义类型（需要注册到元对象系统）。
相似之处：
⚝ 都是动态类型，可以存储多种数据类型。
⚝ 都提供了类型检查和类型转换的功能。
⚝ 都广泛应用于各自的生态系统（Qt 框架，Facebook 基础设施）。
不同之处：
⚝ 生态系统：QVariant 是 Qt 框架的一部分，与 Qt 的信号槽机制、元对象系统紧密集成。folly::dynamic 是 Folly 库的一部分，更侧重于通用 C++ 开发和 Facebook 的内部需求。
⚝ 类型系统：QVariant 的类型系统主要面向 Qt 的数据类型和对象。folly::dynamic 的类型系统更通用，可以表示更广泛的 C++ 类型和结构。
⚝ JSON 支持：folly::dynamic 对 JSON 有原生支持。QVariant 可以通过 Qt 的 JSON 相关类（如 QJsonDocument, QJsonObject, QJsonArray）来处理 JSON 数据，但 QVariant 本身不是专门为 JSON 设计的。
⚝ 性能：folly::dynamic 在某些场景下可能比 QVariant 具有更好的性能，尤其是在非 Qt 环境下。QVariant 的性能受到 Qt 元对象系统的一些限制。
适用场景：
⚝ QVariant 适用于 Qt 应用程序开发，特别是在需要与 Qt 的信号槽、属性系统、模型/视图框架等组件交互时。
⚝ folly::dynamic 更适合 非 Qt 环境下的通用 C++ 开发，尤其是在需要处理 JSON 数据、构建动态系统时。
③ 脚本语言中的动态类型 (Dynamic Types in Scripting Languages)：
许多脚本语言（如 Python, JavaScript, Lua）都原生支持动态类型。这些语言中的变量可以存储任何类型的值，并且类型可以在运行时动态改变。folly::dynamic 在某种程度上借鉴了脚本语言的动态类型概念，旨在为 C++ 提供类似的灵活性。
相似之处：
⚝ 都是动态类型，提供极大的灵活性。
⚝ 类型检查和类型转换都在运行时进行。
⚝ 都可以方便地表示和操作结构化数据（如对象、字典、数组）。
不同之处：
⚝ 语言特性：脚本语言的动态类型是语言的核心特性，而 folly::dynamic 是 C++ 库提供的动态类型。C++ 本身是静态类型语言，folly::dynamic 是在 C++ 中模拟动态类型的机制。
⚝ 性能：脚本语言的动态类型通常会有较大的运行时开销，因为所有类型检查、内存管理等都在运行时进行。folly::dynamic 作为 C++ 库，在性能方面做了很多优化，力求在灵活性和性能之间取得平衡。
⚝ 类型安全：脚本语言的动态类型牺牲了编译时的类型安全，类型错误只能在运行时发现。folly::dynamic 虽然是动态类型，但在 API 设计上仍然尽量提供一些类型安全保障，例如使用 asInt(), asString() 等类型转换方法，而不是完全无类型的访问。
适用场景：
⚝ 脚本语言的动态类型适用于 快速开发、原型设计、以及需要高度灵活性的应用。
⚝ folly::dynamic 适用于 需要在 C++ 中实现类似脚本语言动态特性的场景，例如构建动态配置系统、数据交换格式处理、轻量级脚本语言解释器等，同时又希望保持 C++ 的性能和类型安全优势。
④ 其他动态类型库 (Other Dynamic Typing Libraries)：
除了上述方案，C++ 生态系统中还存在一些其他的动态类型库，例如：
⚝ Poco::Dynamic::Var (Poco C++ Libraries)：Poco 库提供的动态类型，类似于 folly::dynamic 和 Boost.Any。
⚝ cereal 库的 polymorphic 机制 (cereal library's polymorphic mechanism)：cereal 库是一个序列化库，其 polymorphic 机制可以用于实现一定程度的动态类型。
这些库各有特点，但在核心思想上都与 folly::dynamic 类似，都是为了在 C++ 中提供动态类型的能力。选择哪个库取决于具体的项目需求、依赖库、以及个人偏好。
⑤ 总结 (Summary)：
| 特性 (Feature) | folly::dynamic | Boost.Any | QVariant | 脚本语言动态类型 (Scripting Language Dynamic Types) |
|---|---|---|---|---|
| 类型系统 (Type System) | 通用 C++ 类型，JSON 支持 (General C++ types, JSON support) | 通用 C++ 类型 (General C++ types) | Qt 类型系统 (Qt type system) | 语言原生动态类型 (Language-native dynamic types) |
| API 设计 (API Design) | 丰富、易用，结构化数据友好 (Rich, easy-to-use, structured data friendly) | 简洁 (Simple) | Qt 集成，面向 Qt 开发 (Qt integrated, Qt-oriented) | 灵活、动态 (Flexible, dynamic) |
| 性能 (Performance) | 优化过的 C++ 性能 (Optimized C++ performance) | C++ 性能 (C++ performance) | Qt 环境下性能 (Qt environment performance) | 运行时开销较大 (Higher runtime overhead) |
| 适用场景 (Use Cases) | 结构化动态数据、JSON、Folly 生态 (Structured dynamic data, JSON, Folly ecosystem) | 简单动态类型、泛型编程 (Simple dynamic types, generic programming) | Qt 应用开发 (Qt application development) | 快速开发、原型设计 (Rapid development, prototyping) |
| 依赖性 (Dependencies) | Folly 库 (Folly library) | Boost 库 (Boost library) | Qt 框架 (Qt framework) | 语言本身 (Language itself) |
folly::dynamic 在众多动态类型方案中，以其强大的 JSON 处理能力、丰富易用的 API、以及 Folly 库的性能优化而著称。选择 folly::dynamic 还是其他动态类型方案，需要综合考虑项目的具体需求、技术栈、以及对性能、易用性、依赖性的权衡。在很多现代 C++ 项目中，特别是涉及到数据交换、配置管理、动态 API 等场景，folly::dynamic 都是一个非常有竞争力的选择。
END_OF_CHAPTER
10. chapter 10： dynamic 的最佳实践与未来展望 (Best Practices and Future Prospects of dynamic)
10.1 dynamic 使用的最佳实践 (Best Practices for Using dynamic)
folly::dynamic 作为一个强大的动态类型工具，在 C++ 开发中为我们提供了极大的灵活性。然而，正如任何工具一样，合理和恰当的使用才能发挥其最大价值。本节将深入探讨 dynamic 的最佳实践，帮助读者在项目中更有效地运用 dynamic，避免潜在的陷阱，并提升代码的质量和可维护性。
10.1.1 何时使用 dynamic (When to Use dynamic)
dynamic 最适合应用于以下场景：
① 处理外部数据接口 (Handling External Data Interfaces)：例如，当与外部系统（如 Web API、数据库等）交互，接收和处理 JSON、YAML 等半结构化数据时，dynamic 可以无需预先定义数据结构即可灵活地解析和访问数据。这在处理 schema 不固定或经常变化的外部数据时尤其有用。
② 动态配置 (Dynamic Configuration)：在需要灵活配置的应用中，例如读取配置文件，dynamic 可以方便地表示各种配置项，而无需为每种配置项定义具体的类型。这使得配置文件的结构更加灵活，易于扩展和修改。
③ 脚本语言集成 (Scripting Language Integration)：当需要将 C++ 代码与脚本语言（如 Lua、Python 等）集成时，dynamic 可以作为 C++ 和脚本语言之间数据交换的桥梁，方便地传递和操作各种类型的数据。
④ 实现泛型算法和数据结构 (Implementing Generic Algorithms and Data Structures)：在某些情况下，为了实现高度泛型的算法或数据结构，可能需要在运行时处理多种类型的数据。dynamic 可以作为一种类型擦除的手段，使得算法或数据结构能够处理不同类型的数据，而无需在编译时确定具体类型。
⑤ 原型开发和快速迭代 (Prototype Development and Rapid Iteration)：在项目初期或快速迭代阶段，当数据结构和接口尚未完全确定时，使用 dynamic 可以减少类型定义的繁琐，加快开发速度。
10.1.2 避免过度使用 dynamic (Avoiding Overuse of dynamic)
虽然 dynamic 提供了灵活性，但过度使用也会带来一些问题：
① 性能开销 (Performance Overhead)：与静态类型相比，dynamic 的类型检查和内存管理都会带来额外的运行时开销。在性能敏感的场景中，应谨慎使用 dynamic，并考虑使用更高效的静态类型方案。
② 类型安全隐患 (Type Safety Risks)：dynamic 牺牲了编译时的类型检查，将类型错误推迟到运行时。这可能导致程序在运行时出现类型相关的错误，增加了调试难度。因此，在使用 dynamic 时，需要加强运行时类型检查和错误处理。
③ 代码可读性和维护性降低 (Reduced Code Readability and Maintainability)：过度使用 dynamic 会使代码的类型信息变得模糊，降低代码的可读性和可维护性。特别是在大型项目中，类型信息的缺失会增加代码理解和维护的难度。
因此，在使用 dynamic 时，应权衡其带来的灵活性和潜在的风险，避免在不必要的场景中使用。对于类型结构相对固定和性能要求较高的场景，应优先考虑使用静态类型。
10.1.3 类型安全与运行时检查 (Type Safety and Runtime Checks)
由于 dynamic 放弃了编译时的类型检查，因此在使用 dynamic 时，必须加强运行时的类型检查，以确保程序的健壮性。
① 显式类型检查 (Explicit Type Checking)：在使用 dynamic 对象之前，应使用 is<T>() 方法显式地检查其类型，确保操作的类型与预期一致。例如：
1
dynamic data = parseJsonData();
2
if (data.isString()) {
3
std::string str = data.asString();
4
// ... 处理字符串
5
} else if (data.isInt()) {
6
int num = data.asInt();
7
// ... 处理整数
8
} else {
9
// ... 错误处理或默认情况
10
}
② 断言 (Assertions)：在开发和调试阶段，可以使用断言来检查 dynamic 对象的类型和值，尽早发现潜在的类型错误。例如：
1
dynamic config = loadConfig();
2
assert(config.isObject());
3
assert(config.count("port"));
4
assert(config["port"].isInt());
5
int port = config["port"].asInt();
③ 异常处理 (Exception Handling)：当类型转换失败时（例如，尝试将一个字符串 dynamic 对象转换为整数），as<T>() 方法会抛出异常。应合理地使用 try-catch 块来捕获和处理这些异常，避免程序崩溃。
1
dynamic value = getDynamicValue();
2
try {
3
int num = value.asInt();
4
// ... 使用整数
5
} catch (const std::runtime_error& e) {
6
std::cerr << "类型转换错误: " << e.what() << std::endl;
7
// ... 错误处理
8
}
10.1.4 性能考量 (Performance Considerations)
dynamic 的动态类型特性不可避免地会带来一定的性能开销。为了减少性能损失，可以考虑以下几点：
① 避免频繁的类型转换 (Avoid Frequent Type Conversions)：类型转换操作（如 as<T>()）会涉及类型检查和数据转换，应尽量减少不必要的类型转换。如果需要多次访问 dynamic 对象的同一类型的值，可以先将其转换为静态类型，再进行后续操作。
② 选择合适的存储类型 (Choose Appropriate Storage Type)：dynamic 内部使用 Variant 来存储不同类型的值。在创建 dynamic 对象时，如果能预先知道其可能存储的类型范围，可以考虑使用更轻量级的 Variant 或其他静态类型方案，以减少内存占用和类型检查开销。
③ 优化 JSON 解析和生成 (Optimize JSON Parsing and Generation)：如果 dynamic 主要用于 JSON 处理，可以关注 JSON 解析和生成库的性能优化。例如，选择高效的 JSON 库，使用流式解析，避免不必要的数据拷贝等。
④ 使用自定义分配器 (Use Custom Allocators)：dynamic 的内存分配也可能成为性能瓶颈。在性能敏感的场景中，可以考虑使用自定义内存分配器，例如 folly::fbvector 的分配器，来优化内存分配和释放的效率。
10.1.5 代码可读性与维护性 (Code Readability and Maintainability)
为了提高使用 dynamic 的代码的可读性和维护性，应遵循以下原则：
① 清晰的命名 (Clear Naming)：为 dynamic 对象选择具有描述性的名称，使其用途和含义清晰明了。例如，jsonData、configParams 等。
② 注释和文档 (Comments and Documentation)：对于使用 dynamic 的代码段，应添加必要的注释和文档，说明 dynamic 对象的预期类型、用途和可能的取值范围，帮助其他开发者理解代码逻辑。
③ 模块化和封装 (Modularization and Encapsulation)：将使用 dynamic 的代码模块化，并进行适当的封装，隐藏底层的动态类型细节，对外提供清晰的接口。这可以降低代码的复杂性，提高可维护性。
④ 单元测试 (Unit Testing)：针对使用 dynamic 的代码编写充分的单元测试，覆盖各种可能的类型和取值情况，确保代码的正确性和健壮性。
10.2 dynamic 的局限性与改进方向 (Limitations and Improvement Directions of dynamic)
尽管 folly::dynamic 功能强大且灵活，但它也存在一些局限性。理解这些局限性有助于我们更好地使用 dynamic，并期待未来的改进。
10.2.1 性能开销 (Performance Overhead)
相较于静态类型，dynamic 的主要局限性在于性能开销。动态类型检查、类型存储和管理、以及可能的内存分配和释放，都会引入额外的运行时成本。在对性能要求极高的场景中，dynamic 可能不是最佳选择。
改进方向：
① 更高效的类型表示 (More Efficient Type Representation)：探索更紧凑、更高效的类型表示方法，减少类型存储的内存占用和类型检查的时间开销。
② 即时编译 (Just-In-Time Compilation, JIT)：考虑引入 JIT 技术，针对热点代码路径，动态地生成针对特定类型的优化代码，提升性能。
③ 编译时优化 (Compile-Time Optimization)：在编译时尽可能地推断 dynamic 对象的类型信息，进行部分静态化优化，减少运行时开销。
10.2.2 缺乏编译时类型检查 (Lack of Compile-Time Type Checking)
dynamic 的动态类型特性意味着类型错误只能在运行时被发现。这增加了调试难度，并可能导致程序在生产环境中出现意外错误。
改进方向：
① 静态分析工具 (Static Analysis Tools)：开发更强大的静态分析工具，能够更有效地分析使用 dynamic 的代码，尽早发现潜在的类型错误。
② 类型注解 (Type Annotations)：引入可选的类型注解机制，允许开发者为 dynamic 对象添加类型提示，辅助静态分析工具进行类型检查，并在一定程度上提高代码的可读性。
③ 与静态类型系统的融合 (Integration with Static Type System)：探索将 dynamic 与 C++ 的静态类型系统更紧密地结合，例如，允许在某些场景下将 dynamic 对象转换为静态类型对象，以便进行编译时类型检查。
10.2.3 错误处理 (Error Handling)
dynamic 的错误处理主要依赖于异常。当类型转换失败或访问不存在的成员时，会抛出异常。虽然异常处理是 C++ 中常用的错误处理机制，但在某些场景下，异常的开销可能较高。
改进方向：
① 更细粒度的错误码 (More Granular Error Codes)：除了异常，可以考虑提供基于错误码的错误处理机制，允许开发者根据不同的错误情况选择合适的处理方式。
② 编译时错误提示 (Compile-Time Error Hints)：对于一些明显的类型错误，例如，在编译时就能确定某个 dynamic 对象不可能具有某个成员，可以考虑在编译时给出警告或错误提示，而不是完全推迟到运行时。
③ 改进错误信息 (Improved Error Messages)：改进异常的错误信息，使其更清晰、更易于理解，帮助开发者更快地定位和解决问题。
10.2.4 API 扩展性 (API Extensibility)
dynamic 的 API 相对固定，对于一些特定的应用场景，可能需要扩展其功能。例如，支持自定义类型的序列化和反序列化，或者提供更丰富的操作符重载。
改进方向：
① 插件式扩展机制 (Plugin-Based Extension Mechanism)：引入插件式扩展机制，允许开发者自定义 dynamic 对象的行为，例如，添加新的类型支持、自定义操作符、扩展序列化功能等。
② 更灵活的类型系统 (More Flexible Type System)：扩展 dynamic 的类型系统，支持更复杂的类型，例如，联合类型、交叉类型等，以满足更广泛的应用需求。
③ 开放 API (Open API)：更开放 dynamic 的内部 API，允许开发者更深入地定制和扩展 dynamic 的功能。
10.3 dynamic 的未来发展趋势 (Future Development Trends of dynamic)
folly::dynamic 作为 C++ 动态类型方案的代表，其未来发展趋势将受到 C++ 语言发展、应用场景变化以及社区贡献等多种因素的影响。
10.3.1 与 C++ 标准的融合 (Integration with C++ Standards)
C++ 标准委员会也在积极探索动态类型和反射等特性。未来，dynamic 有可能与 C++ 标准中的相关特性进行融合，例如：
① 反射 (Reflection)：C++ 反射提案正在不断演进。如果 C++ 标准最终引入反射机制，dynamic 可以利用反射来实现更强大的动态特性，例如，动态地访问和修改对象的成员，动态地调用函数等。
② 变体类型 (Variant Types)：std::variant 已经成为 C++17 标准的一部分。dynamic 可以考虑基于 std::variant 进行实现，或者与 std::variant 进行更紧密的集成，例如，提供 dynamic 到 std::variant 的便捷转换。
③ 概念 (Concepts)：C++20 引入了 Concepts 特性。dynamic 可以利用 Concepts 来约束 dynamic 对象的类型，提供更强的类型安全性和编译时检查能力。
10.3.2 应用场景的拓展 (Expansion of Application Scenarios)
随着云计算、大数据、人工智能等技术的快速发展，dynamic 的应用场景将进一步拓展：
① Serverless 计算 (Serverless Computing)：在 Serverless 环境中，应用的动态性和灵活性变得尤为重要。dynamic 可以帮助开发者更快速地构建和部署 Serverless 应用。
② 数据分析与处理 (Data Analysis and Processing)：在大数据分析和处理领域，数据格式的多样性和不确定性是常态。dynamic 可以方便地处理各种半结构化数据，简化数据处理流程。
③ 人工智能 (Artificial Intelligence)：在人工智能领域，特别是深度学习和自然语言处理，模型的结构和数据类型可能非常复杂且动态变化。dynamic 可以为构建灵活的 AI 系统提供支持。
10.3.3 社区驱动的演进 (Community-Driven Evolution)
folly::dynamic 是一个开源项目，其发展离不开社区的贡献。未来，dynamic 的演进将更加依赖社区的力量：
① 社区贡献 (Community Contributions)：期待更多开发者参与到 dynamic 的开发中，贡献代码、提出建议、报告 bug，共同推动 dynamic 的发展。
② 用户反馈 (User Feedback)：重视用户反馈，了解用户在使用 dynamic 过程中遇到的问题和需求，根据用户反馈改进 dynamic 的功能和性能。
③ 与其他库的集成 (Integration with Other Libraries)：加强 dynamic 与其他常用 C++ 库的集成，例如，网络库、数据库库、序列化库等，构建更完善的 C++ 生态系统。
总而言之，folly::dynamic 在 C++ 动态类型领域扮演着重要的角色。通过不断地改进和演进，并与 C++ 标准和社区发展紧密结合，dynamic 将在未来的 C++ 开发中发挥更大的作用，为开发者提供更强大、更灵活的工具。
END_OF_CHAPTER