json.hpp中的contains

json.hpp是一个C++的JSON库，其中的contains函数用于检查JSON对象中是否包含指定的键。它的用法类似于std::map::count()函数，但是返回的是布尔值而不是计数器。下面是一个简单的示例：

#include <iostream>
#include "json.hpp"

using json = nlohmann::json;

int main() {
    json j = {
        {"name", "Alice"},
        {"age", 20}
    };

    // 检查JSON对象中是否包含指定的键
    if (j.contains("name")) {
        std::cout << "The JSON object contains the key 'name'." << std::endl;
    } else {
        std::cout << "The JSON object does NOT contain the key 'name'." << std::endl;
    }

    return 0;
}

在上面的示例中，我们创建了一个名为j的JSON对象，并使用contains函数检查它是否包含名为"name"的键。如果包含，则输出"The JSON object contains the key 'name'."，否则输出"The JSON object does NOT contain the key 'name'."。

相关问题

请给我一个在c++中使用nlohmann的完整类例子 需要可以解析json字符串和使用json类置对象和成员 然后获取json数据帮我封装下

好的，以下是一个使用 nlohmann/json 库的完整例子，包括解析 JSON 字符串、使用 JSON 对象设置成员、获取 JSON 数据的过程，并且将其封装在一个类中，方便调用。

JsonParser.h 文件：

#pragma once
#include <string>
#include "nlohmann/json.hpp"

using json = nlohmann::json;

class JsonParser
{
public:
    JsonParser() = default;
    JsonParser(const std::string& json_str);

    std::string getString(const std::string& key);
    int getInt(const std::string& key);
    bool getBool(const std::string& key);
    double getDouble(const std::string& key);
    json getJson(const std::string& key);

    void setString(const std::string& key, const std::string& value);
    void setInt(const std::string& key, int value);
    void setBool(const std::string& key, bool value);
    void setDouble(const std::string& key, double value);
    void setJson(const std::string& key, const json& value);

    std::string serialize();

private:
    json m_json_obj;
};

JsonParser.cpp 文件：

#include "JsonParser.h"

JsonParser::JsonParser(const std::string& json_str)
{
    m_json_obj = json::parse(json_str);
}

std::string JsonParser::getString(const std::string& key)
{
    if (m_json_obj.contains(key)) {
        return m_json_obj[key].get<std::string>();
    }
    return "";
}

int JsonParser::getInt(const std::string& key)
{
    if (m_json_obj.contains(key)) {
        return m_json_obj[key].get<int>();
    }
    return 0;
}

bool JsonParser::getBool(const std::string& key)
{
    if (m_json_obj.contains(key)) {
        return m_json_obj[key].get<bool>();
    }
    return false;
}

double JsonParser::getDouble(const std::string& key)
{
    if (m_json_obj.contains(key)) {
        return m_json_obj[key].get<double>();
    }
    return 0.0;
}

json JsonParser::getJson(const std::string& key)
{
    if (m_json_obj.contains(key)) {
        return m_json_obj[key];
    }
    return json();
}

void JsonParser::setString(const std::string& key, const std::string& value)
{
    m_json_obj[key] = value;
}

void JsonParser::setInt(const std::string& key, int value)
{
    m_json_obj[key] = value;
}

void JsonParser::setBool(const std::string& key, bool value)
{
    m_json_obj[key] = value;
}

void JsonParser::setDouble(const std::string& key, double value)
{
    m_json_obj[key] = value;
}

void JsonParser::setJson(const std::string& key, const json& value)
{
    m_json_obj[key] = value;
}

std::string JsonParser::serialize()
{
    return m_json_obj.dump();
}

使用示例：

#include <iostream>
#include "JsonParser.h"

using namespace std;

int main()
{
    // 构造 JsonParser 对象并解析 JSON 字符串
    string json_str = "{\"name\": \"Tom\", \"age\": 20, \"is_student\": true, \"scores\": [85, 90, 95]}";
    JsonParser jp(json_str);

    // 获取 JSON 数据
    string name = jp.getString("name");
    int age = jp.getInt("age");
    bool is_student = jp.getBool("is_student");
    auto scores = jp.getJson("scores");
    if (scores.is_array()) {
        cout << "Scores: ";
        for (auto& score : scores) {
            cout << score.get<int>() << " ";
        }
        cout << endl;
    }

    cout << "Name: " << name << endl;
    cout << "Age: " << age << endl;
    cout << "Is student: " << boolalpha << is_student << endl;

    // 使用 JSON 对象设置成员
    jp.setString("email", "tom@example.com");

    // 将 JSON 对象序列化为字符串
    cout << "Serialized JSON: " << jp.serialize() << endl;

    return 0;
}

输出结果：

Scores: 85 90 95
Name: Tom
Age: 20
Is student: true
Serialized JSON: {"age":20,"email":"tom@example.com","is_student":true,"name":"Tom","scores":[85,90,95]}

这个例子中，我们使用了一个名为 JsonParser 的类来封装了解析 JSON 字符串、使用 JSON 对象设置成员、获取 JSON 数据和将 JSON 对象序列化为字符串的过程，使得调用起来更加方便。

json exprJson = json::parse(funExpression);后可以直接把exprJson[“children”]当做string传入函数GetFunExprInfo中吗？已知Void GetFunExprInfo(string strFunExpr);

在C++中，使用nlohmann/json库可以很方便地解析JSON字符串，并且操作JSON对象。当你通过`json::parse`函数将JSON字符串解析成一个json对象后，你可以通过键名来访问JSON对象中的数据。

在你提供的情况下，`exprJson["children"]`将返回一个json对象，因为JSON中的键对应的值可以是任何JSON数据类型，包括字符串、数字、数组、对象等。如果你想将`exprJson["children"]`作为字符串传入`GetFunExprInfo`函数中，你需要确保`exprJson["children"]`确实是一个字符串类型。

在实际使用中，你应该先检查`exprJson["children"]`的类型，如果它是一个字符串（`json::string_t`），那么你可以将其作为字符串参数传递给`GetFunExprInfo`。如果`"children"`对应的不是字符串类型，你需要做相应的类型转换或者处理。

这里是一个简单的例子：

#include <nlohmann/json.hpp>
#include <string>

using json = nlohmann::json;

void GetFunExprInfo(const std::string& strFunExpr);

int main() {
    std::string funExpression = R"({"children": "actual_string_value"})"; // 假设的JSON字符串
    json exprJson = json::parse(funExpression);

    // 检查"children"是否存在且为字符串类型
    if (exprJson.contains("children") && exprJson["children"].is_string()) {
        // "children"是一个字符串，可以直接传入GetFunExprInfo函数
        GetFunExprInfo(exprJson["children"].get<std::string>());
    } else {
        // 处理"children"不是字符串的情况，例如抛出异常或进行其他操作
    }

    return 0;
}

在上述代码中，我们使用了`contains`来检查键`"children"`是否存在，使用`is_string`来检查它的类型是否为字符串。如果是的话，我们使用`get<std::string>()`来获取其字符串值并传递给`GetFunExprInfo`。