1. 项目概述：为什么我们需要一个现代的C++ JSON库？

在C++项目里处理JSON数据，这事儿搁以前，绝对是个让人头疼的活儿。你得手动解析字符串，处理转义字符，构建复杂的数据结构，一不小心就写出满屏的bug，调试起来能让人怀疑人生。后来虽然有了像jsoncpp这样的老牌库，但用起来总感觉有点“重”，API设计也带着浓浓的C++98时代的烙印，不够直观和优雅。

直到我遇到了nlohmann/json。第一次用它的时候，那种感觉就像是给老旧的C++代码里注入了一股清泉。这个库的作者是 Niels Lohmann ，它完全用现代C++（C++11及以上）写成，最大的特点就是**“像使用原生类型一样使用JSON”**。你不需要去记一堆繁琐的get、set方法，直接用[]操作符或者像访问std::map、std::vector一样去操作JSON对象和数组，代码写出来干净利落，可读性极高。

这个库在GitHub上已经收获了超过40k的星标，成为了C++社区处理JSON事实上的标准。无论是网络通信（HTTP API、WebSocket）、配置文件解析、数据序列化存储，还是作为不同模块间的数据交换格式，nlohmann/json都能轻松胜任。它完美地诠释了现代C++“零开销抽象”的理念，提供了极其便利的接口，同时性能也足够出色。接下来，我就带你从零开始，把它配置到你的项目中，并分享一些我踩过坑才总结出来的高效使用技巧。

2. 核心设计哲学与方案选型

2.1 为什么选择 nlohmann/json？

面对一堆C++ JSON库（如 jsoncpp, RapidJSON, taojson等），选型时我主要考量以下几点，而nlohmann/json几乎在每一项上都拿了高分：

1. 极致的易用性（Usability First）：这是它最核心的竞争力。它的API设计借鉴了STL容器和Python字典，支持直观的初始化、访问和修改。你几乎可以忘记你在操作一个JSON库，感觉就像在使用std::map<std::string, any>和std::vector<any>。
2. 头文件库（Header-only）：整个库就是一个json.hpp头文件。这意味着无需编译、无需链接。你只需要把这个头文件拷贝到你的项目里，或者通过包管理器引入，然后在代码中#include即可。这极大地简化了项目的构建和依赖管理，尤其是在跨平台开发时，避免了编译第三方库的麻烦。
3. 强类型与隐式转换：库内部使用std::variant类似的机制来存储不同类型（null, boolean, number, string, array, object）。它提供了丰富的类型安全访问方法（如get<T>()），同时也支持在安全范围内的隐式转换，比如JSON数字可以自动转到int、double等。
4. 现代C++特性：全面拥抱C++11/14/17，代码风格现代，与标准库无缝集成。支持移动语义、初始化列表、范围for循环等，让你写出更高效、更现代的C++代码。
5. 丰富的功能：除了基础的解析和序列化，还支持JSON Patch、JSON Merge Patch、JSON Pointer（类似路径访问）、自定义类型转换、二进制格式（BSON, CBOR, MessagePack等）的输入输出，功能非常全面。
6. 良好的性能和足够的内存安全：虽然它不是性能最极致的（RapidJSON在纯解析性能上可能略胜一筹），但其性能对于绝大多数应用场景已经完全足够。更重要的是，它通过现代C++的RAII机制管理内存，避免了手动管理内存带来的风险。

注意：头文件库的便利性也带来一个潜在问题：编译时间。因为每次包含json.hpp都会展开大量模板代码，可能导致单个编译单元的编译时间显著增加。对于大型项目，这是一个需要权衡的点。不过，通常的优化手段（如预编译头文件PCH）可以很好地缓解这个问题。

2.2 与其他主流库的快速对比

为了让你有个更直观的认识，这里用一个简单的表格对比一下：

对于90%的C++项目，尤其是需要快速开发、高可读性、易维护性的场景，nlohmann/json都是我的首选。除非你的项目是性能瓶颈就在JSON解析上（例如需要每秒处理数十万条JSON消息的高频交易系统），否则它的便利性带来的开发效率提升，远远超过那一点点性能差异。

3. 多种集成与配置方法详解

“配置使用”听起来简单，但选择合适的方法能让你的项目管理更清爽。这里我详细拆解四种主流方式，并告诉你每种方式的适用场景和我踩过的坑。

3.1 方法一：直接下载单头文件（最快速）

这是上手最快的方法，适合小型项目、快速原型或学习阶段。

1. 获取头文件：直接从项目的 GitHub Release页面 下载最新版本的json.hpp单头文件。我建议下载json.hpp而不是带版本号的文件，方便后续更新。
2. 放入项目：在你的项目源码目录下（例如include/、third_party/或直接放在源码旁），创建一个合适的文件夹，比如nlohmann，然后将json.hpp放进去。
3. 包含头文件：在你的C++源文件中，使用#include “path/to/your/nlohmann/json.hpp”。

// 假设你的项目结构如下： // my_project/ // ├── src/ // │ └── main.cpp // └── include/ // └── nlohmann/ // └── json.hpp // 在 main.cpp 中 #include "../include/nlohmann/json.hpp" // 为了方便，通常会给命名空间起个别名 using json = nlohmann::json; int main() { json j; // 创建一个JSON对象 j["message"] = "Hello, nlohmann/json!"; // ... 后续操作 }

实操心得：

• 路径问题：确保编译命令中的-I或/I参数包含了json.hpp所在目录的父目录。例如，上面例子中，编译时应添加-I./include。
• 版本管理：如果你用Git，建议将json.hpp加入版本管理。虽然它很大（约2MB），但保证了所有开发者环境一致。更优雅的做法是使用Git子模块（见方法三）。

3.2 方法二：使用包管理器（最规范）

对于中型以上项目，使用包管理器是管理依赖的最佳实践，它能自动处理下载、版本和可能的依赖冲突。

• vcpkg (Windows/Linux/macOS):

  # 安装库 vcpkg install nlohmann-json

  然后在你的CMakeLists.txt中：

  find_package(nlohmann_json CONFIG REQUIRED) target_link_libraries(your_target PRIVATE nlohmann_json::nlohmann_json)

  vcpkg会自动设置好包含路径。这是我最推荐的方式，特别是Windows+Visual Studio的开发环境，几乎无缝集成。

• Conan (跨平台):

  # 添加远程仓库（通常已默认配置） conan remote add conancenter https://center.conan.io # 在项目目录下安装依赖 conan install . --build=missing

  你需要一个conanfile.txt或conanfile.py来声明依赖。对于CMake项目，Conan会生成一个conanbuildinfo.cmake文件，你需要在CMakeLists.txt中包含它。

• Linux/macOS 系统包管理器:

  # Ubuntu/Debian sudo apt-get install nlohmann-json3-dev # Fedora sudo dnf install json-devel # macOS (Homebrew) brew install nlohmann-json

  安装后，通常头文件会在/usr/include或/usr/local/include下，直接#include <nlohmann/json.hpp>即可。注意：系统包管理器提供的版本可能不是最新的。

注意事项： 使用包管理器时，务必确认其提供的json.hpp是“头文件模式”还是需要链接库。nlohmann/json官方推荐以头文件形式使用，但一些包（如nlohmann-json-dev）可能也提供了编译好的库，这时要仔细看文档，确保target_link_libraries链接的是接口目标（如nlohmann_json::nlohmann_json），它只传递编译定义，不实际链接库。

3.3 方法三：Git子模块（适合Git项目）

如果你的项目本身就用Git管理，并且希望将第三方库的版本也锁定下来，Git子模块是很好的选择。

# 在你的项目根目录下 git submodule add https://github.com/nlohmann/json.git extern/nlohmann_json git submodule update --init --recursive

这会在你的项目里创建一个extern/nlohmann_json目录，里面是整个仓库。然后，在你的构建系统（如CMake）中，将这个目录添加到头文件搜索路径。

# CMakeLists.txt 示例 add_subdirectory(extern/nlohmann_json) # 或者仅添加包含目录 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/extern/nlohmann_json/include)

踩坑记录： 子模块的版本是固定的（指向某个commit）。更新子模块需要显式地进入子模块目录拉取新提交，然后在主项目提交新的子模块commit hash。这既是优点（版本稳定），也是缺点（更新稍麻烦）。另外，克隆你的项目后，别忘记运行git submodule update --init --recursive来拉取子模块内容。

3.4 方法四：CMake FetchContent（现代CMake推荐）

如果你用CMake并且版本在3.11以上，FetchContent模块可以在配置阶段直接在线获取依赖，无需提前下载。

# CMakeLists.txt include(FetchContent) FetchContent_Declare( json GIT_REPOSITORY https://github.com/nlohmann/json.git GIT_TAG v3.11.3 # 指定一个版本标签，强烈建议！ ) FetchContent_MakeAvailable(json) # 之后，你的目标就可以直接链接了 target_link_libraries(your_target PRIVATE nlohmann_json::nlohmann_json)

这种方式非常干净，它会在构建时下载代码到构建目录（如_deps），不会污染你的源码树。关键点：一定要用GIT_TAG指定一个明确的版本（如v3.11.3），而不是master分支，以保证构建的可重复性。

4. 从入门到精通：核心API实战解析

配置好了，我们来真正用起来。我会按照使用频率，从最基本的操作讲到一些高级特性。

4.1 创建与初始化JSON值

创建JSON对象有多种直观的方式：

#include <nlohmann/json.hpp> using json = nlohmann::json; // 1. 创建空值 json j_null; // null json j_object = json::object(); // 空对象 {} json j_array = json::array(); // 空数组 [] // 2. 使用初始化列表 (最常用、最直观) json j = { {"pi", 3.141}, {"happy", true}, {"name", "Niels"}, {"nothing", nullptr}, {"answer", { {"everything", 42} }}, {"list", {1, 0, 2}}, {"object", { {"currency", "USD"}, {"value", 42.99} }} }; // 结果：一个包含嵌套对象和数组的复杂JSON // 3. 从现有值解析（反序列化） std::string json_str = R"({"key": "value"})"; // C++11原始字符串字面量，避免转义 json j_from_string = json::parse(json_str); // 从文件读取 std::ifstream i("config.json"); json j_from_file; i >> j_from_file; // 使用流操作符直接读取

4.2 访问与修改数据

这是nlohmann/json的精华所在，访问方式非常灵活。

// 接上文的 j // 1. 类STL风格访问（推荐） // 访问对象成员 std::string name = j["name"]; // 返回 "Niels"，自动类型转换 double pi = j["pi"]; // 返回 3.141 // 访问嵌套对象 int answer = j["answer"]["everything"]; // 返回 42 // 访问数组 int first_item = j["list"][0]; // 返回 1 // 2. 安全访问（避免异常） // 使用 at()，键不存在时抛出 std::out_of_range 异常 try { auto value = j.at("nonexistent_key"); } catch (const std::out_of_range& e) { std::cerr << "Key not found: " << e.what() << std::endl; } // 使用 value()，提供默认值 std::string not_found = j.value("nonexistent_key", "default_value"); // 返回 "default_value" // 使用 find() 返回迭代器 auto it = j.find("name"); if (it != j.end()) { std::cout << "Found: " << it.value() << std::endl; } // 3. 修改数据 j["new_key"] = "new_value"; // 添加或修改 j["list"][1] = 999; // 修改数组元素 j["answer"]["everything"] = 100; // 修改嵌套值 // 4. 类型检查与转换 if (j["happy"].is_boolean()) { /* ... */ } if (j["list"].is_array()) { /* ... */ } // 安全转换（类型不匹配会抛出异常） int pi_int = j["pi"].get<int>(); // 抛出异常，因为"pi"是浮点数 double pi_double = j["pi"].get<double>(); // 正确 // 不安全的直接转换（不推荐，除非你非常确定） int maybe_pi = j["pi"]; // 如果j["pi"]是整数，OK；是浮点数，可能被截断。

重要经验：

• operator[]vsat()vsvalue()：operator[]用于访问时，如果键不存在，对于对象会创建一个null值并返回引用（这是为了支持j[“new”] = value的语法）。对于const对象，行为与at()相同，键不存在会抛出异常。at()是强安全检查，value()是安全访问并提供回退。根据你的需求选择。
• 迭代：JSON对象可以像std::map一样迭代。

  for (auto& [key, value] : j.items()) { // C++17 结构化绑定 std::cout << key << " : " << value << std::endl; }

  数组可以像std::vector一样用范围for循环迭代。

4.3 序列化：将JSON对象转为字符串或文件

当你需要将内存中的JSON对象发送出去或保存时，就需要序列化。

json j = {{"name", "Alice"}, {"age", 30}}; // 1. 转为字符串（默认紧凑格式） std::string compact_str = j.dump(); // {"name":"Alice","age":30} // 带缩进的美化格式（常用于调试或配置文件） std::string pretty_str = j.dump(4); // 参数是缩进空格数 // { // "name": "Alice", // "age": 30 // } // 2. 转义控制 // dump() 默认会转义非ASCII字符和特殊字符（如引号、换行符）。 // 如果你需要输出纯UTF-8（不转义），可以： std::string unescaped_str = j.dump(-1, ' ', false, json::error_handler_t::ignore); // 参数含义：缩进(-1表示紧凑)，缩进字符，确保ASCII(false)，错误处理方式 // 3. 写入文件 std::ofstream o(“output.json”); o << std::setw(4) << j << std::endl; // 使用流操作符并设置美化输出

4.4 高级特性实战

掌握了基础，这些高级功能能让你的代码更强大、更安全。

4.4.1 JSON Pointer (RFC 6901)JSON Pointer提供了一种类似文件路径的字符串来定位JSON文档中的特定部分。

json j = { {"foo", {"bar", {"baz", nullptr}}}, {"", 0}, {"a/b", 1}, {"c%d", 2}, {"e^f", 3}, {"g|h", 4}, {"i\\j", 5}, {"k\"l", 6}, {" ", 7}, {"m~n", 8} }; // 使用 json::json_pointer auto ptr = json::json_pointer("/foo/1/baz"); if (j.contains(ptr)) { // 检查路径是否存在 auto& value = j[ptr]; // 获取值引用 std::cout << value << std::endl; // 输出: null } // 直接使用字符串路径（库内部会处理转义） std::cout << j["/foo/1/baz"_json_pointer] << std::endl; // 对于特殊字符键名，路径需要转义：~0 代表 ~， ~1 代表 / std::cout << j["/c%d"_json_pointer] << std::endl; // 输出: 2 std::cout << j["/m~0n"_json_pointer] << std::endl; // 输出: 8 (~ 被转义为 ~0)

这在处理动态生成的、深度嵌套的JSON路径时非常有用。

4.4.2 自定义类型转换你可以让你自定义的类或结构体与JSON无缝互转。这需要为你的类型特化nlohmann::adl_serializer。

struct Person { std::string name; int age; std::vector<std::string> hobbies; }; // 方法一：使用 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE 宏（非侵入式，推荐） // 需要公共成员变量 namespace nlohmann { NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Person, name, age, hobbies) } // 方法二：手动特化序列化器（更灵活，可以处理私有成员） namespace nlohmann { template <> struct adl_serializer<Person> { static void to_json(json& j, const Person& p) { j = json{{"name", p.name}, {"age", p.age}, {"hobbies", p.hobbies}}; } static void from_json(const json& j, Person& p) { j.at("name").get_to(p.name); j.at("age").get_to(p.age); j.at("hobbies").get_to(p.hobbies); } }; } // 使用 Person alice {"Alice", 30, {"reading", "hiking"}}; json j = alice; // 自动调用 to_json std::cout << j.dump(2) << std::endl; Person bob; j.get_to(bob); // 自动调用 from_json，将数据填充到bob assert(bob.name == "Alice");

这个功能极大地简化了业务对象与JSON数据模型之间的转换。

4.4.3 二进制格式支持nlohmann/json除了文本JSON，还支持多种高效的二进制格式。

#include <nlohmann/json.hpp> #include <nlohmann/json_fwd.hpp> // 注意：需要单独包含适配器头文件并链接相关库（如果不用单头文件模式） // 单头文件模式已包含所有功能。 json j = {{"compact", true}, {"schema", 0}}; // 序列化为 CBOR (Concise Binary Object Representation) std::vector<std::uint8_t> cbor = json::to_cbor(j); // 反序列化 json j_from_cbor = json::from_cbor(cbor); // 序列化为 MessagePack std::vector<std::uint8_t> msgpack = json::to_msgpack(j); // 反序列化 json j_from_msgpack = json::from_msgpack(msgpack); // 序列化为 BSON (Binary JSON) std::vector<std::uint8_t> bson = json::to_bson(j); // 反序列化 json j_from_bson = json::from_bson(bson);

在网络传输或存储对空间敏感的数据时，这些二进制格式比文本JSON更节省带宽和磁盘空间。

5. 性能调优、内存管理与避坑指南

用了这么久，我也总结了一些让代码跑得更快、更稳的经验。

5.1 理解内存管理与移动语义

nlohmann::json对象管理其持有的所有数据（字符串、数组、子对象）。它使用std::shared_ptr的变种来实现高效的拷贝（写时复制，Copy-on-Write），但最佳实践是善用移动语义来避免不必要的深拷贝。

json create_large_json() { json j; // ... 构造一个非常大的JSON对象 return j; // 编译器会进行RVO（返回值优化）或移动，不会拷贝。 } void process_json(json&& data) { // 右值引用参数，明确接受可移动对象 // 处理 data } int main() { json big_data = create_large_json(); // 这里没有拷贝 // 错误：传递左值，可能触发拷贝（如果内部引用计数不为1） // some_function(big_data); // 正确：如果some_function后不再需要big_data，移动它 process_json(std::move(big_data)); // 此时 big_data 处于有效但未指定状态（通常是null），不应再使用其旧值。 // 如果需要保留原数据，则传递引用 json another_copy = big_data; // 这是浅拷贝（写时复制），直到修改前成本很低。 }

关键点：在函数间传递大型JSON对象时，优先考虑传递const json&（只读）或json&&（移动）。避免不必要的值传递。

5.2 性能敏感场景的优化建议

1. 解析大量小JSON：如果场景是解析海量独立的小JSON字符串（例如日志行），反复创建json对象和调用parse会有开销。可以考虑复用json对象。

   json j; // 在循环外创建 for (const auto& line : log_lines) { j = json::parse(line); // 复用j，利用移动赋值 // ... 处理 j }

2. 键名查找优化：JSON对象底层是无序映射。如果你需要频繁按固定键访问，可以将键名存储为std::string_view或const char*以避免临时std::string的构造。库内部对operator[]的const char*重载有优化。

   static constexpr char key_name[] = “frequently_used_key”; auto& value = my_json_object[key_name]; // 比 my_json_object[std::string(“frequently_used_key”)] 高效

3. 避免不必要的序列化/反序列化：有时我们只是需要修改或读取JSON中的一小部分，却将整个字符串反复parse和dump。尽量在内存中操作完整的json对象，只在最终需要IO（网络发送、文件保存）时才进行序列化。

5.3 常见编译与运行时问题排查

**问题1：编译错误undefined reference tostd::__throw_out_of_range_fmt等链接错误** 这通常发生在使用单头文件方式，但你的编译器没有默认链接C++标准库的某些扩展（如libstdc++fs`）。在CMake中，确保正确设置了C++标准并链接了标准库。

set(CMAKE_CXX_STANDARD 11) # 或更高 set(CMAKE_CXX_STANDARD_REQUIRED ON) target_link_libraries(your_target PUBLIC stdc++fs) # 对于GCC，如果需要文件系统库

更常见的是，你错误地尝试链接nlohmann_json库。记住，单头文件模式不需要链接。如果你用包管理器，确保链接的是nlohmann_json::nlohmann_json这个接口目标（IMPORTED target），它只传递编译定义。

问题2：parse抛出json::parse_error异常这是最常见的运行时错误。原因包括：

• JSON格式错误：尾随逗号、字符串引号不匹配、键名没加引号等。使用在线的JSON验证器（如 JSONLint ）检查你的原始字符串。
• 编码问题：源数据包含非UTF-8编码的字符（如GBK）。确保输入是有效的UTF-8。nlohmann/json严格遵循JSON标准，要求UTF-8。
• 内存不足：解析一个巨大的JSON文件。考虑使用流式解析（json::sax_parse）或检查输入数据是否异常。

问题3：访问不存在的键导致未定义行为或异常这是逻辑错误。养成好习惯：

• 在访问前用contains()方法检查键是否存在。
• 或者使用value()方法并提供默认值。
• 对于确定存在的键，使用at()可以在错误时快速失败，便于调试。

问题4：类型转换错误json::type_error你试图将JSON值当作不兼容的类型来获取。例如，对字符串调用.get<int>()。

• 在get<T>()或转换前，使用is_number(),is_string()等方法进行类型检查。
• 使用get_to()方法，它内部会进行类型检查和转换。

问题5：跨DLL边界传递json对象导致崩溃（Windows特有）如果主程序和动态链接库（DLL）使用不同版本或不同编译器设置的nlohmann/json，由于STL实现不同（如std::string的内存布局），传递json对象会导致未定义行为。

• 解决方案：在模块（exe和dll）间只传递序列化后的字符串（std::string或char*），在模块内部再解析成json。或者确保所有模块使用完全相同的编译器、标准库版本和编译选项。

6. 实战案例：一个简单的配置文件管理器

光说不练假把式。我们用一个完整的迷你项目来串联所学知识：一个控制台程序，它读取一个JSON格式的配置文件，修改其中一项设置，然后写回文件。

假设我们的配置文件config.json如下：

{ “application”: { “name”: “MyApp”, “version”: “1.0.0”, “debug”: false }, “network”: { “port”: 8080, “host”: “localhost”, “timeout_seconds”: 30 }, “features”: [“logging”, “monitoring”, “api”] }

我们的程序要实现：

1. 读取并解析这个文件。
2. 将application.debug改为true。
3. 将network.port增加 1000。
4. 在features数组末尾添加一项“authentication”。
5. 将修改后的配置以美化格式写回文件，并备份原文件。

// config_manager.cpp #include <nlohmann/json.hpp> #include <fstream> #include <iostream> #include <filesystem> // C++17 文件系统库 namespace fs = std::filesystem; using json = nlohmann::json; bool load_config(const std::string& filename, json& config) { std::ifstream file(filename); if (!file.is_open()) { std::cerr << “Error: Could not open file ” << filename << std::endl; return false; } try { file >> config; } catch (const json::parse_error& e) { std::cerr << “Parse error: ” << e.what() << “\n” << “Byte position: ” << e.byte << std::endl; return false; } return true; } bool save_config(const std::string& filename, const json& config) { std::ofstream file(filename); if (!file.is_open()) { std::cerr << “Error: Could not write to file ” << filename << std::endl; return false; } file << std::setw(4) << config << std::endl; // 美化输出，缩进4空格 return true; } int main(int argc, char* argv[]) { const std::string config_file = “config.json”; const std::string backup_file = “config.json.backup”; // 1. 加载配置 json config; if (!load_config(config_file, config)) { return 1; } std::cout << “Original config loaded.” << std::endl; // 2. 创建备份 try { fs::copy_file(config_file, backup_file, fs::copy_options::overwrite_existing); std::cout << “Backup created at: ” << backup_file << std::endl; } catch (const fs::filesystem_error& e) { std::cerr << “Backup failed: ” << e.what() << std::endl; // 可以选择继续执行，不中断 } // 3. 修改配置 (使用安全访问，避免异常) // 修改 application.debug if (config.contains(“application”) && config[“application”].is_object()) { config[“application”][“debug”] = true; } else { std::cerr << “Warning: ‘application’ object not found or invalid.” << std::endl; } // 修改 network.port if (config.contains(“network”) && config[“network”].is_object()) { auto& network = config[“network”]; // 使用 value() 安全获取，并提供默认值 int current_port = network.value(“port”, 8080); network[“port”] = current_port + 1000; } // 向 features 数组添加元素 if (config.contains(“features”) && config[“features”].is_array()) { config[“features”].push_back(“authentication”); } // 4. 保存修改后的配置 if (save_config(config_file, config)) { std::cout << “Config successfully updated and saved.” << std::endl; // 打印出修改后的关键信息 std::cout << “New port: ” << config[“network”][“port”] << std::endl; std::cout << “Features: ”; for (const auto& feat : config[“features”]) { std::cout << feat << “ ”; } std::cout << std::endl; } else { std::cerr << “Failed to save config.” << std::endl; return 1; } return 0; }

编译与运行 (Linux/macOS):

g++ -std=c++17 config_manager.cpp -o config_manager ./config_manager

这个案例涵盖了文件IO、异常处理、安全的数据访问与修改、以及基本的错误恢复（备份）。在实际项目中，你可能会将配置封装成一个类，并利用前面提到的自定义类型转换功能，将JSON直接映射到配置类的成员变量上，这样访问起来会更加类型安全且直观。