50. 综合实战：设计一个支持移动语义和完美转发的轻量级JSON解析器核心类

好，终于到了最后一章。说实话，我设计这个实战题的时候，心里挺感慨的。前面49个问题，我们把移动语义和完美转发拆成了一个个零件来讲。现在，是时候把它们组装起来了。

为什么要拿JSON解析器来练手？因为JSON解析器天然就适合展示移动语义的价值。你想想看，一个JSON文档里，字符串、数组、对象层层嵌套，拷贝开销巨大。如果不用移动语义，解析一个几百KB的JSON文件，光拷贝就能让你怀疑人生。

我在项目里遇到过好几次，团队里有人自己手写JSON解析器，结果性能惨不忍睹。后来我帮他们一分析，发现90%的时间都花在了字符串拷贝上。嗯，这就是典型的「能用但不好用」的代码。

核心设计思路

我们要设计的这个JSON解析器核心类，叫 JsonValue。它需要支持：

• 多种数据类型：null、bool、int、double、string、array、object
• 移动构造和移动赋值，避免深拷贝
• 完美转发，让工厂函数能高效构造
• 引用限定符，区分左值和右值操作

说白了，就是让这个类用起来像原生类型一样轻快。

第一步：定义数据类型和基础结构

#include <string>
#include <vector>
#include <map>
#include <variant>
#include <memory>

enum class JsonType {
    Null,
    Bool,
    Int,
    Double,
    String,
    Array,
    Object
};

class JsonValue {
public:
    // 用 variant 存储所有可能类型
    using Array = std::vector<JsonValue>;
    using Object = std::map<std::string, JsonValue>;
    using Storage = std::variant<
        std::nullptr_t,
        bool,
        int64_t,
        double,
        std::string,
        Array,
        Object
    >;

private:
    Storage data_;

public:
    // 构造函数
    JsonValue() : data_(nullptr) {}
    JsonValue(std::nullptr_t) : data_(nullptr) {}
    JsonValue(bool b) : data_(b) {}
    JsonValue(int64_t i) : data_(i) {}
    JsonValue(double d) : data_(d) {}
    JsonValue(const std::string& s) : data_(s) {}
    JsonValue(std::string&& s) : data_(std::move(s)) {}
    // ... 其他构造函数
};

这里有个小细节：std::variant 本身已经支持移动语义了。但如果你直接传一个左值字符串，它还是会拷贝。所以我专门写了一个右值引用的重载版本。

第二步：移动构造和移动赋值

这一步其实很简单，因为 std::variant 已经帮我们处理好了。但为了展示原理，我还是手动实现一下：

class JsonValue {
public:
    // 移动构造
    JsonValue(JsonValue&& other) noexcept 
        : data_(std::move(other.data_)) 
    {
        other.data_ = nullptr;  // 源对象置为null
    }

    // 移动赋值
    JsonValue& operator=(JsonValue&& other) noexcept {
        if (this != &other) {
            data_ = std::move(other.data_);
            other.data_ = nullptr;
        }
        return *this;
    }

    // 拷贝构造（保留，但效率低）
    JsonValue(const JsonValue& other) = default;
    JsonValue& operator=(const JsonValue& other) = default;
};

我曾经在项目里见过有人把移动赋值写成 data_ = other.data_，然后忘了 std::move。结果就是，明明写了移动语义，实际上还是在拷贝。嗯，这种坑我踩过一次就记住了。

第三步：完美转发的工厂函数

现在我们来写一个创建 JsonValue 的工厂函数。这个函数要能接受任意类型的参数，并且完美转发给构造函数：

class JsonValue {
public:
    // 工厂函数：创建JsonValue
    template<typename T>
    static JsonValue make(T&& value) {
        return JsonValue(std::forward<T>(value));
    }

    // 针对字符串的特殊处理
    template<typename... Args>
    static JsonValue make_string(Args&&... args) {
        // 使用完美转发构造字符串
        std::string s(std::forward<Args>(args)...);
        return JsonValue(std::move(s));
    }
};

为什么要单独写一个 make_string？因为字符串的构造方式太多了：可以从 const char*、从另一个字符串、从子串等等。用完美转发，我们可以把任意参数组合转发给 std::string 的构造函数。

第四步：引用限定符与访问器

接下来，我们要给 JsonValue 添加访问器。这里有个讲究：如果 JsonValue 本身是右值，那么访问器应该返回内部数据的右值引用，方便外部继续移动：

class JsonValue {
public:
    // 左值版本：返回拷贝
    std::string as_string() const & {
        return std::get<std::string>(data_);
    }

    // 右值版本：返回移动后的结果
    std::string as_string() && {
        return std::move(std::get<std::string>(data_));
    }

    // 数组访问器
    const JsonValue& operator[](size_t index) const & {
        return std::get<Array>(data_)[index];
    }

    JsonValue&& operator[](size_t index) && {
        return std::move(std::get<Array>(data_)[index]);
    }
};

你想想看，如果用户写 JsonValue::make("hello").as_string()，这里 JsonValue 是临时对象（右值），那么 as_string() && 就会被调用，直接移动字符串出来，避免拷贝。这个优化在解析大JSON数组时特别明显。

第五步：解析器的核心逻辑

解析器本身不复杂，但我们要确保在解析过程中充分利用移动语义：

class JsonParser {
public:
    JsonValue parse(const std::string& json) {
        // 解析字符串，返回JsonValue
        // 注意：这里传入的是const引用，所以内部会拷贝
        return parse_value(json, 0);
    }

    JsonValue parse(std::string&& json) {
        // 右值版本：可以移动字符串
        // 适合从文件读取后直接解析的场景
        return parse_value(std::move(json), 0);
    }

private:
    JsonValue parse_value(const std::string& json, size_t& pos) {
        skip_whitespace(json, pos);
        char c = json[pos];
        
        if (c == '"') {
            // 解析字符串
            std::string s = parse_string(json, pos);
            return JsonValue(std::move(s));  // 移动构造
        }
        else if (c == '[') {
            // 解析数组
            JsonValue::Array arr;
            // ... 解析元素
            for (...) {
                arr.push_back(parse_value(json, pos));  // 移动语义
            }
            return JsonValue(std::move(arr));  // 移动构造
        }
        // ... 其他类型
    }
};

这里有个我特别想强调的点：arr.push_back(parse_value(...)) 这一行，如果 JsonValue 没有移动语义，每次 push_back 都会拷贝整个值。但有了移动语义，临时对象会被移动进数组，效率高得多。

第六步：完整的使用示例

int main() {
    // 从字符串解析
    std::string json = R"({"name": "Alice", "scores": [95, 87, 92]})";
    JsonValue val = JsonParser::parse(json);
    
    // 使用移动语义提取数据
    std::string name = std::move(val)["name"].as_string();
    // 这里 val 被移动后，内部数据变为 null
    
    // 使用工厂函数创建
    auto arr = JsonValue::make(JsonValue::Array{
        JsonValue::make(1),
        JsonValue::make(2.5),
        JsonValue::make_string("hello")
    });
    
    // 完美转发示例
    auto str = JsonValue::make_string(10, 'a');  // 构造 "aaaaaaaaaa"
    
    return 0;
}

知识体系总览

下面这张图，我把整个设计思路串起来了：

避坑指南

总结

这个实战题，说白了就是把前面49个问题的知识点串起来。移动语义让数据传递变得轻量，完美转发让工厂函数变得灵活，引用限定符让接口更加安全。这三者结合起来，就能写出既高效又易用的C++代码。

我个人觉得，JSON解析器是一个非常好的练手项目。它不复杂，但涵盖了C++现代特性的方方面面。如果你能把这个类写好，那移动语义和完美转发这块，基本就吃透了。

好了，50问到此结束。希望这些内容对你有帮助。记住，写代码的时候多想想「这个数据是左值还是右值？」，慢慢就会形成肌肉记忆。