C++如何实现一个简单的JSON解析器_从零开始编写C++递归下降JSON解析器

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

C++如何实现一个简单的JSON解析器_从零开始编写C++递归下降JSON解析器

2025-11-30

浏览次数：次

返回列表

答案：本文介绍如何用C++从零实现一个简单的JSON解析器，核心是定义支持null、boolean、number、string、array和object的JsonValue类型，使用std::variant存储不同类型，并通过递归下降解析法为每种类型编写解析函数，最终组合成完整解析器。代码包含数据结构定义、解析逻辑和测试示例，适合理解JSON结构与编译原理基础。

c++如何实现一个简单的json解析器_从零开始编写c++递归下降json解析器

想用C++从零实现一个简单的JSON解析器？关键在于理解JSON的结构和递归下降的基本思路。JSON支持几种基本类型：null、boolean、number、string、array 和 object，我们可以为每种类型写一个解析函数，通过递归组合起来。整个过程不需要复杂的工具，纯手工编写即可。

1. 定义JSON数据结构

首先，我们需要一个能表示任意JSON值的C++类型。使用 std::variant 是个好选择，它能安全地存储不同类型的数据。

#include <string>
#include <vector>
#include <map>
#include <variant>
#include <memory>
<p>// 前向声明解析器类
struct JsonValue;</p><p>using JsonObject = std::map<std::string, JsonValue>;
using JsonArray = std::vector<JsonValue>;
using JsonNumber = double;
using JsonString = std::string;</p><p>// 核心类型：一个JSON值可以是 null, bool, number, string, array, object
struct JsonValue {
std::variant<std::nullptr_t, bool, JsonNumber, JsonString, JsonArray, JsonObject> value;</p><pre class="brush:php;toolbar:false;">// 构造函数
JsonValue() : value(nullptr) {}
JsonValue(std::nullptr_t) : value(nullptr) {}
JsonValue(bool b) : value(b) {}
JsonValue(double d) : value(d) {}
JsonValue(const std::string& s) : value(s) {}
JsonValue(JsonArray a) : value(std::move(a)) {}
JsonValue(JsonObject o) : value(std::move(o)) {}

// 类型判断辅助函数
bool is_null() const { return std::holds_alternative<std::nullptr_t>(value); }
bool is_bool() const { return std::holds_alternative<bool>(value); }
bool is_number() const { return std::holds_alternative<JsonNumber>(value); }
bool is_string() const { return std::holds_alternative<JsonString>(value); }
bool is_array() const { return std::holds_alternative<JsonArray>(value); }
bool is_object() const { return std::holds_alternative<JsonObject>(value); }

// 获取值（需确保类型正确）
bool as_bool() const { return std::get<bool>(value); }
double as_number() const { return std::get<double>(value); }
const std::string& as_string() const { return std::get<std::string>(value); }
const JsonArray& as_array() const { return std::get<JsonArray>(value); }
const JsonObject& as_object() const { return std::get<JsonObject>(value); }

};

2. 实现递归下降解析器

我们定义一个解析器类，维护当前解析位置和输入字符串。每个JSON类型对应一个解析函数。

class JsonParser {
private:
    const std::string& input;
    size_t pos;
<pre class="brush:php;toolbar:false;">// 跳过空白字符
void skip_whitespace() {
    while (pos < input.size() && (input[pos] == ' ' || input[pos] == '	' || input[pos] == '
' || input[pos] == ''))
        ++pos;
}

// 匹配并消耗指定字符
bool match(char c) {
    skip_whitespace();
    if (pos < input.size() && input[pos] == c) {
        ++pos;
        return true;
    }
    return false;
}

// 解析 "null"
JsonValue parse_null() {
    if (input.substr(pos, 4) == "null") {
        pos += 4;
        return JsonValue(nullptr);
    }
    throw std::runtime_error("Expected 'null'");
}

// 解析 "true" / "false"
JsonValue parse_boolean() {
    if (input.substr(pos, 4) == "true") {
        pos += 4;
        return JsonValue(true);
    }
    if (input.substr(pos, 5) == "false") {
        pos += 5;
        return JsonValue(false);
    }
    throw std::runtime_error("Expected 'true' or 'false'");
}

// 解析数字（简单版本，支持整数和小数）
JsonValue parse_number() {
    size_t start = pos;
    if (pos < input.size() && input[pos] == '-') ++pos;

    if (pos == input.size() || !isdigit(input[pos]))
        throw std::runtime_error("Invalid number");

    while (pos < input.size() && isdigit(input[pos])) ++pos;

    if (pos < input.size() && input[pos] == '.') {
        ++pos;
        if (pos == input.size() || !isdigit(input[pos]))
            throw std::runtime_error("Invalid number");
        while (pos < input.size() && isdigit(input[pos])) ++pos;
    }

    std::string numStr = input.substr(start, pos - start);
    try {
        return JsonValue(std::stod(numStr));
    } catch (...) {
        throw std::runtime_error("Invalid number format");
    }
}

// 解析带引号的字符串（未处理转义字符）
JsonValue parse_string() {
    if (!match('"')) throw std::runtime_error("Expected '"'");

    size_t start = pos;
    while (pos < input.size() && input[pos] != '"') {
        ++pos;
    }

    if (pos == input.size()) throw std::runtime_error("Unterminated string");

    std::string str = input.substr(start, pos - start);
    ++pos; // 跳过结尾的 "
    return JsonValue(str);
}

// 解析数组
JsonValue parse_array() {
    if (!match('[')) throw std::runtime_error("Expected '['");

    JsonArray arr;
    skip_whitespace();

    if (match(']')) return JsonValue(arr); // 空数组

    while (true) {
        arr.push_back(parse_value());
        skip_whitespace();

        if (match(']')) break;
        if (!match(',')) throw std::runtime_error("Expected ',' or ']'");
    }

    return JsonValue(arr);
}

// 解析对象
JsonValue parse_object() {
    if (!match('{')) throw std::runtime_error("Expected '{'");

    JsonObject obj;
    skip_whitespace();

    if (match('}')) return JsonValue(obj); // 空对象

    while (true) {
        JsonValue keyVal = parse_string();
        std::string key = keyVal.as_string();

        skip_whitespace();
        if (!match(':')) throw std::runtime_error("Expected ':'");

        JsonValue value = parse_value();
        obj[key] = value;

        skip_whitespace();
        if (match('}')) break;
        if (!match(',')) throw std::runtime_error("Expected ',' or '}'");
    }

    return JsonValue(obj);
}

// 主解析入口
JsonValue parse_value() {
    skip_whitespace();
    if (pos >= input.size()) throw std::runtime_error("Unexpected end of input");

    char c = input[pos];
    if (c == 'n') return parse_null();
    if (c == 't' || c == 'f') return parse_boolean();
    if (c == '-' || isdigit(c)) return parse_number();
    if (c == '"') return parse_string();
    if (c == '[') return parse_array();
    if (c == '{') return parse_object();

    throw std::runtime_error("Unexpected character: " + std::string(1, c));
}

public: explicit JsonParser(const std::string& str) : input(str), pos(0) {}

JsonValue parse() {
    JsonValue result = parse_value();
    skip_whitespace();
    if (pos != input.size())
        throw std::runtime_error("Extra characters after JSON");
    return result;
}

};

3. 使用示例

写个简单的main函数测试一下：

GoEnhance

全能AI视频制作平台：通过GoEnhance AI让视频创作变得比以往任何时候都更简单。

347 查看详情 GoEnhance

#include <iostream>
#include <stdexcept>
<p>void print_json(const JsonValue& val, int indent = 0) {
std::string space(indent, ' ');
if (val.is_null()) {
std::cout << "null";
} else if (val.is_bool()) {
std::cout << (val.as_bool() ? "true" : "false");
} else if (val.is_number()) {
std::cout << val.as_number();
} else if (val.is_string()) {
std::cout << """ << val.as_string() << """;
} else if (val.is_array()) {
std::cout << "[
";
const auto& arr = val.as_array();
for (size_t i = 0; i < arr.size(); ++i) {
std::cout << std::string(indent + 2, ' ');
print_json(arr[i], indent + 2);
if (i != arr.size() - 1) std::cout << ",";
std::cout << "
";
}
std::cout << std::string(indent, ' ') << "]";
} else if (val.is_object()) {
std::cout << "{
";
const auto& obj = val.as_object();
auto it = obj.begin();
while (it != obj.end()) {
std::cout << std::string(indent + 2, ' ') << """ << it->first << "": ";
print_json(it->second, indent + 2);
++it;
if (it != obj.end()) std::cout << ",";
std::cout << "
";
}
std::cout << std::string(indent, ' ') << "}";
}
}</p><p>int main() {
std::string json_str = R"({
"name": "Alice",
"age": 30,
"is_student": false,
"grades": [85.5, 92.0, 78.5],
"address": {
"city": "Beijing",
"zipcode": "100000"
},
"spouse": null
})";</p><pre class="brush:php;toolbar:false;">try {
    JsonParser parser(json_str);
    JsonValue root = parser.parse();
    print_json(root);
    std::cout << std::endl;
} catch (const std::exception& e) {
    std::cerr << "Parse error: " << e.what() << std::endl;
    return 1;
}

return 0;

}