当前位置：首页 > news >正文

从零实现C++高效JSON解析器：词法分析、递归下降与性能优化实战

news 2026/7/21 19:26:44

1. 项目概述：为什么我们需要自己动手写一个JSON解析器？

在C++的世界里，处理JSON数据几乎是现代软件开发的标配。无论是网络API交互、配置文件读取，还是游戏引擎中的资源描述，JSON都无处不在。市面上有成熟的库，比如RapidJSON、nlohmann/json，它们功能强大、性能优异。那么，为什么我们还要“重复造轮子”，自己动手实现一个高效的JSON解析器呢？

这恰恰是问题的核心。作为一名C++开发者，如果你只停留在调用parse()和dump()的层面，那么你对JSON的理解，以及你对内存管理、状态机、递归下降解析、性能优化等核心C++概念的理解，就始终隔着一层纱。自己实现一个解析器，不是要替代那些工业级库，而是一次深度的、系统性的实战演练。它能让你彻底搞明白：一个字符串是如何被一步步识别为对象、数组、数字和布尔值的；内存是如何被精确分配和释放以避免泄漏的；以及，在面对海量或嵌套极深的JSON数据时，如何通过设计上的巧思来榨干最后一点性能。

这个项目，就是带你从零开始，构建一个符合RFC 8259标准的、高效的JSON解析器。我们将聚焦于解析这一核心过程，目标是将一个JSON格式的字符串，高效、准确地转换为我们程序内部可以操作的数据结构。通过这个过程，你会深刻理解词法分析、语法分析、内存池、移动语义等高级主题，并掌握一系列性能调优的实战技巧。无论你是为了准备C++面试中的“八股文”，还是为了在单片机等资源受限环境中解析配置文件，亦或是单纯想提升自己的底层编码能力，这个项目都将是一次极有价值的旅程。

2. 核心设计思路与架构选型

在动手写代码之前，先想清楚我们要做什么，以及怎么做最好。一个JSON解析器的核心任务很明确：输入字符串，输出结构化的数据。但如何高效、安全地完成这个任务，里面门道很多。

2.1 解析流程的顶层设计

一个标准的解析器通常采用经典的“两步走”策略：词法分析（Lexing）和语法分析（Parsing）。这种分离关注点的设计，让代码结构更清晰，也更容易调试和维护。

词法分析器（Lexer）：它的任务是把原始的、连续的字符流，切割成一个个有意义的“单词”，在编译原理里称为“词法单元”或“Token”。对于JSON来说，Token包括：
- {、}、[、]、:、,这些结构符号。
- true、false、null这些字面量。
- 带引号的字符串（"..."）。
- 数字（包括整数和浮点数）。
- 以及文件结束符（EOF）。
Lexer不需要理解{后面是否应该跟着一个字符串键，它只负责识别并报告：“嘿，我看到了一个左花括号”。这种“傻傻”的专注，正是其价值所在。
语法分析器（Parser）：它接收来自Lexer的Token流，并根据JSON的语法规则，检查这些Token的排列顺序是否合法，并同时构建出对应的内存数据结构。JSON的语法可以用一种叫做“上下文无关文法”的东西来精确定义。我们的Parser将实现一种称为“递归下降解析”的方法，这种方法非常直观，几乎就是直接把文法规则翻译成代码函数。

2.2 内存中数据结构的表示

解析后的数据需要在内存中表示。我们设计一个JsonValue类（或变体类）来封装所有可能的JSON类型。通常，我们会使用C++17的std::variant，或者传统的带标签的联合体（tagged union）来实现。

enum class JsonType { Null, Boolean, Number, String, Array, Object }; class JsonValue { private: JsonType type_; std::variant<std::nullptr_t, bool, double, std::string, std::vector<JsonValue>, std::unordered_map<std::string, JsonValue>> value_; public: // 构造函数、访问器、类型判断函数等... bool is_object() const { return type_ == JsonType::Object; } double as_number() const { return std::get<double>(value_); } // ... };

对于对象（Object），我们选择std::unordered_map<std::string, JsonValue>，因为查询效率（O(1)）远高于std::map（O(log n)），这对于JSON这种经常需要按键访问的场景至关重要。数组（Array）则自然使用std::vector<JsonValue>。

2.3 追求“高效”的关键设计决策

“高效”体现在解析速度和内存使用两方面。

零拷贝字符串解析：这是性能提升的关键。对于JSON字符串值（如"name": "value"中的"value"），我们不应该在解析时立即创建一个新的std::string对象并复制内容。理想的做法是，Lexer只记录这个字符串在原始输入缓冲区中的起始位置和长度。只有当用户真正通过as_string()方法请求这个字符串时，或者当我们需要将字符串放入Object的map中时（因为map的键需要独立的字符串对象），我们才进行拷贝或转移。这可以避免大量临时字符串的构造和销毁开销。
手写状态机 vs. 标准库函数：在Lexer中识别数字时，很多人第一反应是用std::stod。但std::stod会进行完整的错误检查和本地化处理，开销较大。为了极致性能，我们需要手写一个数字解析状态机，逐个字符处理，并自己处理-、0、.、e、E、+、-等情况。虽然代码复杂些，但速度上有显著优势。
内存分配优化：频繁地创建单个JsonValue、std::string、std::vector会调用很多次内存分配，这是性能杀手。一个高级的优化是引入内存池或自定义分配器。例如，可以一次性分配一大块内存，用于存放解析过程中产生的所有JsonValue节点，然后在这块内存上进行对象构造和放置。这能极大减少malloc/new的调用次数，并提高缓存局部性。
移动语义的广泛应用：在构建Array和Object时，应该使用std::move将子元素移动到容器中，避免不必要的拷贝。确保你的JsonValue实现了移动构造函数和移动赋值运算符。

注意：关于Unicode和编码：一个健壮的JSON解析器必须处理Unicode转义序列（如\u4F60\u597D表示“你好”）。我们的Lexer在识别字符串时，需要将\uXXXX这样的序列解码为UTF-8编码的多字节序列。虽然这增加了复杂性，但这是符合标准所必需的。我们假设输入是UTF-8编码，这也是网络传输中最常见的格式。

3. 词法分析器（Lexer）的详细实现

Lexer是整个解析器的前线。它的效率直接决定了整个解析流程的下限。我们将实现一个基于指针遍历的手动状态机，它比基于std::istream或std::stringstream的方法快得多。

3.1 Token的定义

首先，我们需要定义所有可能的Token类型。

enum class TokenType { BeginObject, // { EndObject, // } BeginArray, // [ EndArray, // ] Colon, // : Comma, // , String, Number, True, False, Null, EndOfFile, Error }; struct Token { TokenType type; // 对于String和Number类型的Token，我们需要记录它的值在原始输入中的位置。 const char* start; // 指向Token起始字符的指针 size_t length; // Token的长度 // 对于Number，我们也可以选择在这里直接解析成double，但为了灵活性，我们通常只记录位置。 };

3.2 核心解析逻辑：逐个字符驱动

Lexer的核心是一个next_token()函数，它从当前指针位置读取，返回下一个Token。

class Lexer { public: Lexer(const char* data, size_t len) : start_(data), current_(data), end_(data + len) {} Token next_token(); private: const char* start_; // 输入字符串起始 const char* current_; // 当前解析位置 const char* end_; // 输入字符串末尾（哨兵） char advance() { return (current_ < end_) ? *current_++ : '\0'; } char peek() const { return (current_ < end_) ? *current_ : '\0'; } bool match(char expected) { if (current_ >= end_ || *current_ != expected) return false; ++current_; return true; } void skip_whitespace(); Token parse_string(); Token parse_number(); Token parse_literal(const char* literal, size_t len, TokenType type); };

skip_whitespace()函数：JSON允许的空白符包括空格( )、制表符(\t)、回车符(\r)、换行符(\n)。我们需要一个循环来跳过它们。

void Lexer::skip_whitespace() { while (current_ < end_) { char c = *current_; if (c == ' ' || c == '\t' || c == '\r' || c == '\n') { ++current_; } else { break; } } }

parse_string()函数：这是Lexer中最复杂的部分。我们需要处理转义字符(\",\\,\/,\b,\f,\n,\r,\t)和Unicode转义(\uXXXX)。

Token Lexer::parse_string() { const char* begin = current_; // 跳过开头的双引号 while (current_ < end_) { char c = advance(); if (c == '"') { // 找到结尾的引号 return Token{TokenType::String, begin, static_cast<size_t>(current_ - begin - 1)}; // 长度不包括两边的引号 } else if (c == '\\') { // 处理转义 if (current_ >= end_) return Token{TokenType::Error, nullptr, 0}; char esc = advance(); switch (esc) { case '"': case '\\': case '/': case 'b': case 'f': case 'n': case 'r': case 't': break; // 简单转义，继续 case 'u': { // Unicode转义，需要读取4个十六进制字符 for (int i = 0; i < 4; ++i) { if (current_ >= end_ || !std::isxdigit(*current_)) { return Token{TokenType::Error, nullptr, 0}; } advance(); } break; } default: return Token{TokenType::Error, nullptr, 0}; // 非法转义 } } else if (static_cast<unsigned char>(c) < 0x20) { // 控制字符在字符串中是非法的（U+0020以下） return Token{TokenType::Error, nullptr, 0}; } // 普通字符，继续循环 } return Token{TokenType::Error, nullptr, 0}; // 未找到结尾引号 }

实操心得：在实现parse_string时，最容易出错的地方就是Unicode转义和错误处理。务必严格按照标准，检查4位十六进制数。另外，上面的实现只是记录了字符串的原始位置，并没有进行Unicode解码和转义字符的替换。替换工作可以延迟到用户真正需要字符串值时再进行（即“延迟求值”），这符合我们零拷贝的优化思想。

parse_number()函数：手写数字解析状态机。我们需要识别如-123.456e+78这样的格式。可以定义几个状态：Minus、Zero、Digit、Dot、Fraction、ExpSign、ExpDigit等，根据当前字符跳转状态。这里给出一个简化版的非状态机实现思路：

Token Lexer::parse_number() { const char* begin = current_ - 1; // 当前字符已经是数字的第一个字符（或负号） // 检查负号 if (peek() == '-') advance(); // 整数部分 if (peek() == '0') { advance(); } else if (std::isdigit(peek())) { while (std::isdigit(peek())) advance(); } else { return Token{TokenType::Error, nullptr, 0}; } // 小数部分 if (peek() == '.') { advance(); if (!std::isdigit(peek())) return Token{TokenType::Error, nullptr, 0}; while (std::isdigit(peek())) advance(); } // 指数部分 if (peek() == 'e' || peek() == 'E') { advance(); if (peek() == '+' || peek() == '-') advance(); if (!std::isdigit(peek())) return Token{TokenType::Error, nullptr, 0}; while (std::isdigit(peek())) advance(); } return Token{TokenType::Number, begin, static_cast<size_t>(current_ - begin)}; }

parse_literal()函数：用于解析true、false、null。直接比较后续字符即可。

Token Lexer::parse_literal(const char* literal, size_t len, TokenType type) { for (size_t i = 0; i < len; ++i) { if (current_ >= end_ || *current_ != literal[i]) { return Token{TokenType::Error, nullptr, 0}; } ++current_; } return Token{type, nullptr, 0}; }

最后，next_token()函数就是把这些组合起来的一个大的switch语句。

Token Lexer::next_token() { skip_whitespace(); if (current_ >= end_) return Token{TokenType::EndOfFile, nullptr, 0}; char c = advance(); switch (c) { case '{': return Token{TokenType::BeginObject, nullptr, 0}; case '}': return Token{TokenType::EndObject, nullptr, 0}; case '[': return Token{TokenType::BeginArray, nullptr, 0}; case ']': return Token{TokenType::EndArray, nullptr, 0}; case ':': return Token{TokenType::Colon, nullptr, 0}; case ',': return Token{TokenType::Comma, nullptr, 0}; case '"': return parse_string(); case 't': return parse_literal("rue", 3, TokenType::True); // 第一个字符't'已消费 case 'f': return parse_literal("alse", 4, TokenType::False); case 'n': return parse_literal("ull", 3, TokenType::Null); default: // 可能是数字（以-或0-9开头） if (c == '-' || std::isdigit(c)) { // 我们需要回退一个字符，因为parse_number期望当前指针在数字的第一个字符上 --current_; return parse_number(); } return Token{TokenType::Error, nullptr, 0}; } }

4. 语法分析器（Parser）与数据构建

Parser是解析器的大脑，它理解Token序列的意义。我们将采用递归下降解析，为JSON的每一条语法规则编写一个对应的解析函数。

4.1 JSON语法规则回顾

JSON的语法非常简洁，可以用巴科斯范式（BNF）近似描述：

value->object|array|string|number|true|false|null
object->{}|{members}
members->member|member,members
member->string:value
array->[]|[elements]
elements->value|value,elements

4.2 递归下降解析的实现

我们的Parser类将持有Lexer的实例，并提供一个parse()入口函数。

class Parser { public: Parser(const char* data, size_t len) : lexer_(data, len) { current_token_ = lexer_.next_token(); } JsonValue parse(); private: Lexer lexer_; Token current_token_; void advance() { current_token_ = lexer_.next_token(); } bool match(TokenType type) { return current_token_.type == type; } bool consume(TokenType type); // 匹配并消费一个Token，不匹配则报错 JsonValue parse_value(); JsonValue parse_object(); JsonValue parse_array(); JsonValue parse_string(); // 这个函数会真正创建std::string JsonValue parse_number(); // 这个函数会真正解析成double };

parse_value()函数：这是解析的起点，根据当前Token的类型，分发到具体的解析函数。

JsonValue Parser::parse_value() { switch (current_token_.type) { case TokenType::BeginObject: return parse_object(); case TokenType::BeginArray: return parse_array(); case TokenType::String: return parse_string(); case TokenType::Number: return parse_number(); case TokenType::True: advance(); return JsonValue(true); case TokenType::False: advance(); return JsonValue(false); case TokenType::Null: advance(); return JsonValue(); // 构造一个Null值 default: throw std::runtime_error("Unexpected token in value"); } }

parse_object()函数：解析JSON对象。这是递归下降的典型体现。

JsonValue Parser::parse_object() { consume(TokenType::BeginObject); // 消费掉 '{' std::unordered_map<std::string, JsonValue> obj; // 处理空对象 `{}` if (match(TokenType::EndObject)) { advance(); return JsonValue(std::move(obj)); } while (true) { // 1. 解析一个 `member`，即 `string : value` if (!match(TokenType::String)) { throw std::runtime_error("Expected string key in object"); } JsonValue key_val = parse_string(); // 获取键的JsonValue（内部是std::string） std::string key = std::move(key_val.as_string()); // 提取出键字符串 // 2. 解析冒号 `:` consume(TokenType::Colon); // 3. 解析值 `value` JsonValue val = parse_value(); // 4. 将键值对插入map obj.emplace(std::move(key), std::move(val)); // 5. 判断后面是逗号继续，还是直接结束 if (match(TokenType::Comma)) { advance(); // 如果逗号后面直接是 `}`，这是错误的，如 `{"a":1,}` if (match(TokenType::EndObject)) { throw std::runtime_error("Trailing comma in object"); } } else if (match(TokenType::EndObject)) { advance(); break; } else { throw std::runtime_error("Expected ',' or '}' in object"); } } return JsonValue(std::move(obj)); }

parse_array()函数：与parse_object逻辑类似，但更简单。

JsonValue Parser::parse_array() { consume(TokenType::BeginArray); std::vector<JsonValue> arr; if (match(TokenType::EndArray)) { advance(); return JsonValue(std::move(arr)); } while (true) { // 解析一个元素（value） arr.push_back(parse_value()); if (match(TokenType::Comma)) { advance(); if (match(TokenType::EndArray)) { throw std::runtime_error("Trailing comma in array"); } } else if (match(TokenType::EndArray)) { advance(); break; } else { throw std::runtime_error("Expected ',' or ']' in array"); } } return JsonValue(std::move(arr)); }

parse_string()和parse_number()函数：这两个函数需要将Lexer记录的Token位置信息，转换成实际的值。

JsonValue Parser::parse_string() { // 这里需要处理转义字符和Unicode。 // 我们有一个辅助函数 decode_string(token.start, token.length) std::string str = decode_string(current_token_.start, current_token_.length); advance(); // 消费掉这个String Token return JsonValue(std::move(str)); } JsonValue Parser::parse_number() { // 将Token指向的字符序列转换为double。 // 注意：这里可以使用std::from_chars（C++17），它比std::stod更快且不抛异常。 double val = 0.0; auto [ptr, ec] = std::from_chars(current_token_.start, current_token_.start + current_token_.length, val); if (ec != std::errc()) { throw std::runtime_error("Invalid number format"); } advance(); return JsonValue(val); }

注意：错误处理：上面的代码使用了throw std::runtime_error。在一个健壮的库中，你应该定义自己的异常类型，并包含更详细的信息，比如错误发生的位置（行号、列号）。这需要在Lexer中跟踪行和列的信息。

5. 性能优化进阶：内存池与延迟解析

基础版本已经可以工作，但要称得上“高效”，我们还需要引入更高级的优化技术。

5.1 实现一个简单的内存池

内存池的核心思想是：一次性申请一大块内存（例如，使用std::vector<char>或直接new char[POOL_SIZE]），然后在这块内存上手动管理对象的分配。这避免了频繁向系统申请小内存块的开销和碎片。

我们可以为JsonValue设计一个专用的分配器。但更简单直接的方法是，在Parser内部维护一个std::vector<JsonValue>作为“节点池”。在解析array或object时，我们不是直接创建std::vector或std::unordered_map，而是先创建一个“代理”节点，并将其放入池中。解析子元素时，再从池中分配。

class PooledParser { struct PooledJsonValue { /* 类似JsonValue，但使用指针指向子容器 */ }; std::vector<PooledJsonValue> value_pool_; std::vector<char> string_buffer_; // 字符串存储池 PooledJsonValue* allocate_value() { if (value_pool_.size() >= value_pool_.capacity()) { // 池子不够，扩容。注意：这会使所有指针失效，需要谨慎设计。 // 更优方案是使用链式块分配器。 } value_pool_.emplace_back(); return &value_pool_.back(); } // ... 解析逻辑修改为操作PooledJsonValue指针 };

这种优化在解析超大型JSON树时效果显著，但实现复杂度也急剧上升。它更适合作为第二次迭代的优化目标。

5.2 延迟解析（Lazy Parsing）

对于某些场景，我们可能只需要访问JSON中的一小部分数据。例如，一个巨大的JSON配置文件，我们只想读取其中的“server.port”字段。延迟解析的思想是：在Parser的第一遍扫描中，只构建出整个JSON的结构骨架（知道哪里是对象，哪里是数组，键的位置），但并不立即解析所有的字符串和数字值，也不构建完整的子对象map和vector。

当用户通过路径（如root[“server”][“port”]）访问某个深层值时，解析器才按需去解析那部分具体的字符串和数字。这类似于数据库的索引扫描。实现延迟解析需要更复杂的数据结构来记录原始字符串的片段信息，并且访问器的设计也会变得复杂，但它对于读取巨型JSON文件是革命性的性能提升。

5.3 SIMD加速词法扫描

在极端性能追求下，可以使用SIMD（单指令多数据流）指令来加速Lexer中的空白符跳过和字符串扫描。例如，一次读取16或32个字节，使用SSE或AVX指令集并行判断这些字节中是否有特殊字符（如引号、反斜杠、结构字符）。这能将词法分析的速度提升一个数量级。但这属于非常底层的优化，需要针对特定CPU架构，并且代码可读性会变差，通常只在RapidJSON这样的顶级库中见到。

6. 常见问题、调试技巧与测试策略

自己实现解析器，一定会遇到各种奇怪的bug。下面是一些常见坑点和应对方法。

6.1 典型Bug与排查

内存泄漏：这是C++项目的头号敌人。确保每个new都有对应的delete，每个malloc都有对应的free。使用std::unique_ptr或std::shared_ptr来管理资源。在解析器中最容易泄漏的是JsonValue内部std::vector和std::unordered_map中的动态内容。确保你的JsonValue析构函数能正确递归释放所有子节点。
悬空指针：在实现零拷贝字符串时，我们保存了指向原始输入缓冲区的指针。必须确保JsonValue对象的生命周期不超过原始输入缓冲区。如果输入是临时字符串，解析后需要立即使用结果，或者采用拷贝模式。
数字解析精度与溢出：double类型有精度限制，对于超长整数可能会丢失精度。如果需要高精度数字，可以考虑用字符串存储，或者使用int64_t/uint64_t和double的联合体，并在解析时判断数字是否在整数范围内。
递归深度限制：JSON是递归定义的，array和object可以无限嵌套。递归下降解析会使用函数调用栈，嵌套太深会导致栈溢出。对于可能不受信任的输入，必须设置一个最大递归深度（比如512或1024层），并在解析时进行计数，超过则报错。
尾随逗号：根据JSON标准，对象或数组的最后一个元素后面不允许有逗号（如[1,2,]）。我们的Parser必须检测并报错。这在parse_object和parse_array的代码中已经体现。

6.2 调试技巧

打印Token流：在开发Lexer时，最有效的调试方法是把next_token()输出的每一个Token类型和内容（对于字符串和数字）都打印出来。确保它能正确识别你的测试用例。
可视化解析树：为JsonValue实现一个格式化的dump()或to_string()函数，将内存中的结构以缩进格式打印出来。这能帮你直观地看到Parser构建的数据结构是否正确。
使用Valgrind或AddressSanitizer：在Linux/macOS下，用Valgrind检查内存错误。在支持Clang/GCC的平台上，编译时加上-fsanitize=address,undefined选项，可以在运行时检测内存越界、使用未初始化内存等问题。
单元测试：这是保证代码质量最根本的方法。为Lexer和Parser分别编写测试用例。

6.3 测试策略与用例

建立一个全面的测试套件至关重要。测试用例应该包括：

合规用例：RFC 8259标准中的例子，以及边界情况（空对象{}、空数组[]、嵌套最深允许的层级、最大整数等）。
错误用例：各种语法错误的JSON，确保你的解析器能正确报告错误位置和类型，而不是崩溃或产生错误结果。
- 缺少引号的字符串。
- 无效的转义序列\x。
- 无效的数字01,1.,.2,1e。
- 尾随逗号[1,2,]。
- 多余的逗号{,}。
性能测试：使用大型JSON文件（如数MB的GitHub API响应）测试解析速度，并与RapidJSON等库进行对比。使用工具如perf或valgrind --tool=cachegrind分析热点，看时间是花在词法分析、内存分配还是语法分析上。

一个简单的测试框架可以这样组织：

void test_lexer() { Lexer l("{\"key\": 123.45}", 15); assert(l.next_token().type == TokenType::BeginObject); assert(l.next_token().type == TokenType::String); // ... std::cout << "Lexer tests passed!" << std::endl; } void test_parser() { std::string json = R"({"name": "Alice", "age": 30, "scores": [95.5, 88.0]})"; Parser p(json.c_str(), json.size()); try { auto val = p.parse(); assert(val.is_object()); auto& obj = val.as_object(); assert(obj.at("name").as_string() == "Alice"); // ... std::cout << "Parser tests passed!" << std::endl; } catch (const std::exception& e) { std::cerr << "Parser test failed: " << e.what() << std::endl; } }

7. 从解析器到完整库：序列化与访问接口

一个完整的JSON库不仅需要解析（反序列化），还需要序列化（将内存中的JsonValue转换成JSON字符串）和方便的访问接口。

7.1 序列化实现

序列化相对解析要简单很多，本质上是对JsonValue树的深度优先遍历。

class JsonWriter { public: std::string dump(const JsonValue& val, bool pretty = false, int indent = 2) { output_.clear(); indent_level_ = 0; pretty_ = pretty; indent_space_ = indent; write_value(val); return output_; } private: std::string output_; int indent_level_; bool pretty_; int indent_space_; void write_indent() { if (pretty_) { output_.append(indent_level_ * indent_space_, ' '); } } void write_string(const std::string& s) { output_ += '"'; for (char c : s) { switch (c) { case '"': output_ += "\\\""; break; case '\\': output_ += "\\\\"; break; // ... 处理其他转义字符 default: output_.push_back(c); } } output_ += '"'; } void write_value(const JsonValue& val) { switch (val.type()) { case JsonType::Null: output_ += "null"; break; case JsonType::Boolean: output_ += (val.as_boolean() ? "true" : "false"); break; case JsonType::Number: { // 将double转换为字符串，注意控制精度，避免输出像`1.2999999999999998`这样的结果 char buffer[32]; auto len = std::snprintf(buffer, sizeof(buffer), "%.15g", val.as_number()); output_.append(buffer, len); break; } case JsonType::String: write_string(val.as_string()); break; case JsonType::Array: { output_ += '['; if (pretty_) output_ += '\n'; indent_level_++; const auto& arr = val.as_array(); for (size_t i = 0; i < arr.size(); ++i) { if (pretty_) write_indent(); write_value(arr[i]); if (i != arr.size() - 1) output_ += ','; if (pretty_) output_ += '\n'; } indent_level_--; if (pretty_) { write_indent(); output_ += ']'; } else { output_ += ']'; } break; } case JsonType::Object: { // 类似数组，但需要处理键值对 output_ += '{'; if (pretty_) output_ += '\n'; indent_level_++; const auto& obj = val.as_object(); bool first = true; for (const auto& [k, v] : obj) { if (!first) output_ += ','; if (pretty_) { if (!first) output_ += '\n'; write_indent(); } write_string(k); output_ += pretty_ ? ": " : ":"; write_value(v); first = false; } indent_level_--; if (pretty_) { output_ += '\n'; write_indent(); output_ += '}'; } else { output_ += '}'; } break; } } } };

7.2 设计友好的访问接口

直接操作std::unordered_map和std::vector虽然强大，但不够安全（at会抛异常）和方便。可以重载operator[]并提供get、get_or等函数。

class JsonValue { public: // 针对Object的重载 [] JsonValue& operator[](const std::string& key) { if (!is_object()) throw std::runtime_error("Not an object"); return as_object()[key]; // 注意：如果key不存在，会创建一个新的空值，这可能不是预期行为 } const JsonValue& operator[](const std::string& key) const { if (!is_object()) throw std::runtime_error("Not an object"); return as_object().at(key); // at会检查存在性，不存在则抛异常 } // 针对Array的重载 [] JsonValue& operator[](size_t index) { /* ... */ } const JsonValue& operator[](size_t index) const { /* ... */ } // 安全的访问函数，返回指针，避免异常 const JsonValue* find(const std::string& key) const { if (!is_object()) return nullptr; const auto& obj = as_object(); auto it = obj.find(key); return (it != obj.end()) ? &(it->second) : nullptr; } // 带默认值的访问 std::string get_string_or(const std::string& key, const std::string& default_val) const { auto v = find(key); return (v && v->is_string()) ? v->as_string() : default_val; } };

7.3 与现代C++特性结合

使用std::optional作为返回值：find函数可以返回std::optional<JsonValue>，更现代。
使用std::string_view：在接口中，对于只读的字符串参数（如键），使用std::string_view可以避免不必要的拷贝。
支持移动语义：确保JsonValue的移动构造函数和移动赋值运算符是noexcept的，这能让它在容器中高效移动。
自定义分配器：为内部的std::string、std::vector、std::unordered_map提供自定义分配器支持，让库的使用者可以嵌入自己的内存管理策略，这在游戏开发或嵌入式系统中非常有用。

实现一个高效的JSON解析器，就像打造一把精密的瑞士军刀。从最基础的字符识别，到复杂的内存管理和性能优化，每一步都充满了挑战和乐趣。当你看到自己写的解析器能够流畅地处理兆字节级的JSON数据，并且内存和速度表现接近甚至在某些场景超越成熟的开源库时，那种成就感是无与伦比的。更重要的是，这个过程强迫你去思考那些平时被封装好的底层细节，你的C++功力会在这个过程中得到实实在在的淬炼。最后，别忘了将你的代码放到GitHub上，写一份清晰的README，这不仅是你的技术名片，也可能帮助到其他正在爬同样坡的开发者。

查看全文

http://www.cnnetsun.cn/news/3567787.html