C/C++ Qt JSON解析库修改篇

原创 已于 2023-12-20 10:19:18 修改 · 9.7k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#json #qt #c语言 #c++ #开发语言

于 2022-01-07 14:33:00 首次发布

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，通常用于在不同系统之间传递数据。它是一种文本格式，易于阅读和编写，同时也易于解析和生成。JSON 数据格式采用键值对的方式组织数据，支持嵌套结构，包括对象（Object）和数组（Array）。

Qt库为JSON的相关操作提供了完整的类支持，读者可以使用 QJsonDocument 类和相关的类（例如 QJsonObject、QJsonArray、QJsonValue）来解析和生成 JSON 数据。在使用JSON解析文件之前需要先通过TextStream流将文件读入到字符串变量内，然后再通过QJsonDocument等库对该JSON格式进行解析，以提取出我们所需字段。

创建一个解析文件,命名为config.json我们将通过代码依次解析这个JSON文件中的每一个参数,具体解析代码如下:

{
    "blog": "https://xxxxxx",
    "enable": true,
    "status": 1024,
    
    "GetDict": {"address":"192.168.1.1","username":"root","password":"123456","update":"2020-09-26"},
    "GetList": [1,2,3,4,5,6,7,8,9,0],
    
    "ObjectInArrayJson":
    {
        "One": ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],
        "Two": ["Sunday","Monday","Tuesday"]
    },
    
    "ArrayJson": [
        ["192.168.1.1","root","22"],
        ["192.168.1.2","root","23"],
        ["192.168.1.3","root","24"],
        ["192.168.1.4","root","25"],
        ["192.168.1.5","root","26"]
    ],
    
    "ObjectJson": [
        {"address":"192.168.1.1","username":"admin"},
        {"address":"192.168.1.2","username":"root"},
        {"address":"192.168.1.3","username":"lyshark"}
    ],
    
    "ObjectArrayJson": [
        {"uname":"root","ulist":[1,2,3,4,5]},
        {"uname":"lyshark","ulist":[11,22,33,44,55,66,77,88,99]}
    ],
    
    "NestingObjectJson": [
        {
            "uuid": "1001",
            "basic": {
                "lat": "12.657", 
                "lon": "55.789"
            }
        },
        {
            "uuid": "1002",
            "basic": {
                "lat": "31.24", 
                "lon": "25.55"
            }
        }
    ],
    
    "ArrayNestingArrayJson":
    [
        {
            "telephone": "1323344521",
            "path": [
                [
                    11.5,22.4,56.9
                ],
                [
                    19.4,34.6,44.7
                ]
            ]
        }
    ]
}

实现修改单层根节点下面指定的节点元素,修改的原理是读入到内存替换后在全部写出到文件.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();

    // 修改根节点下的子节点
    root["blog"] = "https://www.baidu.com";
    root["enable"] = false;
    root["status"] = 2048;

    // 将object设置为本文档的主要对象
    root_document.setObject(root);

    // 紧凑模式输出
    // https://www.cnblogs.com/lyshark
    QByteArray root_string_compact = root_document.toJson(QJsonDocument::Compact);
    std::cout << "紧凑模式: " << root_string_compact.toStdString() << std::endl;

    // 规范模式输出
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);
    std::cout << "规范模式: " << root_string_indented.toStdString() << std::endl;

    // 分别写出两个配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);
    writeonly_string("d:/compact_config.json",root_string_compact);

    return a.exec();
}

实现修改单层对象与数组下面指定的节点元素,如上配置文件中的GetDict/GetList既是我们需要解析的内容.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();

    // --------------------------------------------------------------------
    // 修改GetDict对象内容
    // --------------------------------------------------------------------

    // 找到对象地址,并修改
    QJsonObject get_dict_ptr = root.find("GetDict").value().toObject();

    // 修改对象内存数据
    get_dict_ptr["address"] = "127.0.0.1";
    get_dict_ptr["username"] = "lyshark";
    get_dict_ptr["password"] = "12345678";
    get_dict_ptr["update"] = "2021-09-25";

    // 赋值给根
    root["GetDict"] = get_dict_ptr;

    // 将对象设置到根
    root_document.setObject(root);

    // 规范模式
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);

    // 写配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);

    // --------------------------------------------------------------------
    // 修改GetList数组内容
    // --------------------------------------------------------------------

    // 找到数组并修改
    QJsonArray get_list_ptr = root.find("GetList").value().toArray();

    // 替换指定下标的数组元素
    get_list_ptr.replace(0,22);
    get_list_ptr.replace(1,33);

    // 将当前数组元素直接覆盖到原始位置
    QJsonArray item = {"admin","root","lyshark"};
    get_list_ptr = item;

    // 设置到原始数组
    root["GetList"] = get_list_ptr;
    root_document.setObject(root);

    QByteArray root_string_list_indented = root_document.toJson(QJsonDocument::Indented);
    writeonly_string("d:/indented_config.json",root_string_list_indented);

    return a.exec();
}

实现修改对象内对象Value列表下面指定的节点元素,如上配置文件中的ObjectInArrayJson既是我们需要解析的内容.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();

    // --------------------------------------------------------------------
    // 修改对象中的列表
    // --------------------------------------------------------------------

    // 找到对象地址并修改
    QJsonObject get_dict_ptr = root.find("ObjectInArrayJson").value().toObject();

    // 迭代器输出对象中的数据
    QJsonObject::iterator it;
    for(it=get_dict_ptr.begin(); it!= get_dict_ptr.end(); it++)
    {
        QString key = it.key();
        QJsonArray value = it.value().toArray();

        std::cout << "Key = " << key.toStdString() << " ValueCount = " << value.count() << std::endl;

        // 循环输出元素
        for(int index=0; index < value.count(); index++)
        {
            QString val = value.toVariantList().at(index).toString();
            std::cout << "-> " << val.toStdString() << std::endl;
        }
    }

    // 迭代寻找需要修改的元素并修改
    for(it=get_dict_ptr.begin(); it!= get_dict_ptr.end(); it++)
    {
        QString key = it.key();

        // 如果找到了指定的Key 则将Value中的列表替换到其中
        if(key.toStdString() == "Two")
        {
            // 替换整个数组
            QJsonArray value = {1,2,3,4,5};
            get_dict_ptr[key] = value;
            break;
        }
        else if(key.toStdString() == "One")
        {
            // 替换指定数组元素
            QJsonArray array = get_dict_ptr[key].toArray();

            array.replace(0,"lyshark");
            array.replace(1,"lyshark");
            array.removeAt(1);

            // 写回原JSON字符串
            get_dict_ptr[key] = array;
        }
    }

    // 赋值给根
    root["ObjectInArrayJson"] = get_dict_ptr;

    // 将对象设置到根
    root_document.setObject(root);

    // 规范模式
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);

    // 写配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);

    return a.exec();
}

实现修改匿名数组中的数组元素下面指定的节点元素,如上配置文件中的ArrayJson既是我们需要解析的内容.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();

    // --------------------------------------------------------------------
    // 修改数组中的数组
    // --------------------------------------------------------------------

    QJsonArray array_value = root.value("ArrayJson").toArray();
    int insert_index = 0;

    // 循环查找IP地址,找到后将其弹出
    for(int index=0; index < array_value.count(); index++)
    {
        QJsonValue parset = array_value.at(index);

        if(parset.isArray())
        {
            QString address = parset.toArray().at(0).toString();

            // 寻找指定行下标,并将其弹出
            if(address == "192.168.1.3")
            {
                std::cout << "找到该行下标: " << index << std::endl;
                insert_index = index;
                array_value.removeAt(index);
            }
        }
    }

    // 新增一行IP地址
    QJsonArray item = {"192.168.1.3","lyshark","123456"};
    array_value.insert(insert_index,item);

    // 赋值给根
    root["ArrayJson"] = array_value;

    // 将对象设置到根
    root_document.setObject(root);

    // 规范模式
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);

    // 写配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);

    return a.exec();
}

实现修改数组中对象元素下面指定的节点元素,如上配置文件中的ObjectJson既是我们需要解析的内容.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();

    // --------------------------------------------------------------------
    // 修改数组中的对象数值
    // --------------------------------------------------------------------

    QJsonArray array_value = root.value("ObjectJson").toArray();

    for(int index=0; index < array_value.count(); index++)
    {
        QJsonObject object_value = array_value.at(index).toObject();

        /*
        // 第一种输出方式
        if(!object_value.isEmpty())
        {
            QString address = object_value.value("address").toString();
            QString username = object_value.value("username").toString();
            std::cout << "地址: " << address.toStdString() << " 用户名: " << username.toStdString() << std::endl;
        }

        // 第二种输出方式
        QVariantMap map = object_value.toVariantMap();
        if(map.contains("address") && map.contains("username"))
        {
            QString address_map = map["address"].toString();
            QString username_map = map["username"].toString();
            std::cout << "地址: " << address_map.toStdString() << " 用户名: " << username_map.toStdString() << std::endl;
        }
        */

        // 开始移除指定行
        QVariantMap map = object_value.toVariantMap();
        if(map.contains("address") && map.contains("username"))
        {
            QString address_map = map["address"].toString();

            // 如果是指定IP则首先移除该行
            if(address_map == "192.168.1.3")
            {
                // 首先根据对象序号移除当前对象
                array_value.removeAt(index);

                // 接着增加一个新的对象
                object_value["address"] = "127.0.0.1";
                object_value["username"] = "lyshark";

                // 插入到移除的位置上
                array_value.insert(index,object_value);
                break;
            }
        }
    }

    // 赋值给根
    root["ObjectJson"] = array_value;

    // 将对象设置到根
    root_document.setObject(root);

    // 规范模式
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);

    // 写配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);

    return a.exec();
}

实现修改对象中数组元素下面指定的节点元素,如上配置文件中的ObjectArrayJson既是我们需要解析的内容.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();

    // --------------------------------------------------------------------
    // 修改对象中的数组元素
    // --------------------------------------------------------------------

    QJsonArray array_value = root.value("ObjectArrayJson").toArray();

    for(int index=0; index < array_value.count(); index++)
    {
        QJsonObject object_value = array_value.at(index).toObject();

        // 开始移除指定行
        QVariantMap map = object_value.toVariantMap();
        if(map.contains("uname") && map.contains("ulist"))
        {
            QString uname = map["uname"].toString();

            // 如果是指定IP则首先移除该行
            if(uname == "lyshark")
            {
                QJsonArray ulist_array = map["ulist"].toJsonArray();

                // 替换指定数组元素
                ulist_array.replace(0,100);
                ulist_array.replace(1,200);
                ulist_array.replace(2,300);

                // 输出替换后数组元素
                for(int index =0; index < ulist_array.count(); index ++)
                {
                    int val = ulist_array.at(index).toInt();
                    std::cout << "替换后: " << val << std::endl;
                }

                // 首先根据对象序号移除当前对象
                array_value.removeAt(index);

                // 接着增加一个新的对象与新列表
                object_value["uname"] = uname;
                object_value["ulist"] = ulist_array;

                // 插入到移除的位置上
                array_value.insert(index,object_value);
                break;
            }
        }
    }

    // 赋值给根
    root["ObjectArrayJson"] = array_value;

    // 将对象设置到根
    root_document.setObject(root);

    // 规范模式
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);

    // 写配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);

    return a.exec();
}

实现修改对象嵌套对象嵌套对象下面指定的节点元素,如上配置文件中的NestingObjectJson既是我们需要解析的内容.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();
    int insert_index = 0;

    // --------------------------------------------------------------------
    // 修改对象中嵌套对象嵌套对象
    // --------------------------------------------------------------------

    // 寻找节点中数组位置
    QJsonArray array_object = root.find("NestingObjectJson").value().toArray();
    std::cout << "节点数量: " << array_object.count() << std::endl;

    for(int index=0; index < array_object.count(); index++)
    {
        // 循环寻找UUID
        QJsonObject object = array_object.at(index).toObject();

        QString uuid = object.value("uuid").toString();

        // 如果找到了则移除该元素
        if(uuid == "1002")
        {
            insert_index = index;
            array_object.removeAt(index);
            break;
        }
    }

    // --------------------------------------------------------------------
    // 开始插入新对象
    // --------------------------------------------------------------------

    // 开始创建新的对象
    QJsonObject sub_json;

    sub_json.insert("lat","100.5");
    sub_json.insert("lon","200.5");

    QJsonObject new_json;

    new_json.insert("uuid","1005");
    new_json.insert("basic",sub_json);

    // 将对象插入到原位置上
    array_object.insert(insert_index,new_json);

    // 赋值给根
    root["NestingObjectJson"] = array_object;

    // 将对象设置到根
    root_document.setObject(root);

    // 规范模式
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);

    // 写配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);

    return a.exec();
}

实现修改对象嵌套多层数组下面指定的节点元素,如上配置文件中的ArrayNestingArrayJson既是我们需要解析的内容.

// 读取JSON文本
QString readonly_string(QString file_path)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.exists())
    {
        return "None";
    }
    if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return "None";
    }
    QString string_value = this_file_ptr.readAll();

    this_file_ptr.close();
    return string_value;
}

// 写出JSON到文件
bool writeonly_string(QString file_path, QString file_data)
{
    QFile this_file_ptr(file_path);
    if(false == this_file_ptr.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

    QByteArray write_byte = file_data.toUtf8();

    this_file_ptr.write(write_byte,write_byte.length());
    this_file_ptr.close();
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 读文件
    QString readonly_config = readonly_string("d:/config.json");

    // 开始解析 解析成功返回QJsonDocument对象否则返回null
    QJsonParseError err_rpt;
    QJsonDocument root_document = QJsonDocument::fromJson(readonly_config.toUtf8(), &err_rpt);
    if (err_rpt.error != QJsonParseError::NoError && !root_document.isNull())
    {
        return 0;
    }

    // 获取根节点
    QJsonObject root = root_document.object();
    int insert_index = 0;

    // --------------------------------------------------------------------
    // 修改对象中嵌套双层数组
    // --------------------------------------------------------------------

    // 寻找节点中数组位置
    QJsonArray array_object = root.find("ArrayNestingArrayJson").value().toArray();
    std::cout << "节点数量: " << array_object.count() << std::endl;

    for(int index=0; index < array_object.count(); index++)
    {
        // 循环寻找UUID
        QJsonObject object = array_object.at(index).toObject();

        QString uuid = object.value("telephone").toString();

        // 如果找到了则移除该元素
        if(uuid == "1323344521")
        {
            insert_index = index;
            array_object.removeAt(index);
            break;
        }
    }

    // --------------------------------------------------------------------
    // 开始新的数组元素
    // --------------------------------------------------------------------

    QJsonArray array;
    QJsonArray x,y;

    // 追加子数组
    x.append(11.5);
    x.append(22.4);
    x.append(33.6);

    y.append(56.7);
    y.append(78.9);
    y.append(98.4);

    // 追加到外层数组
    array.append(x);
    array.append(y);

    // 创建{}对象节点
    QJsonObject object;

    object["telephone"] = "1323344521";
    object["path"] = array;

    // 将对象插入到原位置上
    array_object.insert(insert_index,object);

    // 赋值给根
    root["ArrayNestingArrayJson"] = array_object;

    // 将对象设置到根
    root_document.setObject(root);

    // 规范模式
    QByteArray root_string_indented = root_document.toJson(QJsonDocument::Indented);

    // 写配置文件
    writeonly_string("d:/indented_config.json",root_string_indented);

    return a.exec();
}
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 11万+
C/C++学习路线总结与分享
Qt中的JSON支持 - 使用C++解析和生成JSON数据
PixelProX的博客
09-10 259
Qt提供了强大的JSON支持，使得在C++中解析和生成JSON数据变得非常简单。本文将介绍如何在Qt中使用C++进行JSON解析和生成，包括示例代码。通过上述步骤，我们可以在Qt中使用C++解析和生成JSON数据。通过合理利用Qt的JSON支持，我们可以轻松地在我们的应用程序中处理和操作JSON数据。在开始之前，我们需要包含一些必要的头文件来使用Qt的JSON支持。除了处理JSON对象之外，Qt还提供了对JSON数组的支持。如果是，我们可以使用。Qt中的JSON支持 - 使用C++解析和生成JSON数据。
Qt 常用Json库
11-24
Json是非常有用的工具类，本资源提供Qt的三种常用的Json库： 1.Qt下cppJson，适合嵌入式环境 2. 大家都在用的QJson，含lib和demo 3. jsoncpp
QT解析、修改json文件
FWY0x7CF的博客
06-06 1759
QJsonArray【】的内容有顺序，按QJsonArray::at(int i).value()找值；QJsonObject{}没顺序，按键找值QJsonObject ::value("键")；2.获取节点修改内容。
Qt QJsonObject
最新发布
计算机是信仰
09-04 1552
QJsonObject是Qt6处理JSON数据的核心类，用于表示键值对组成的无序集合，本质类似std::unordered_map<QString, QJsonValue>，支持动态增删改查和嵌套结构。其特性包括键唯一性、自动内存管理、严格JSON规范兼容性，需配合QJsonDocument实现序列化。典型应用包括API响应解析、配置文件读写等。使用时需注意键为QString类型、类型转换安全及性能优化。
基于cJson的 Qt json处理库
dubuzherui的专栏
07-17 1129
qt4没有原生的库对json处理，Qt5提供了json处理库，使用起来稍微感觉有点麻烦，特别是修改值的时候，非常不方便。cJSON是一个C语言编写的json处理库，已经被大量的使用，稳定性和高效性毋庸置疑，该库只包含一个.h 和 .cpp文件，使用起来非常方便，但是对于习惯Qt开发者来说，CJSON库需要自己管理内存的开辟和释放，使用不是特别方便。 QJSON库基于CJSON，进行Qt的封装，解决Qt原生使用不方便和CJSON手动管理内存的问题。本项目已经在Github上开源，QJSON，以下是头文件，一看
QT解析JSON
何文斌的专栏
01-07 824
有时应用程序需要加载数据库中有用数据，目前交主流的就是动态语言创建JSON数据格式，然后应用程序可以解析。 1、在pro文件中添加script，如右： QT += script 2、需要添加头文件#include 3、代码如下，代码str1为json数组，str2为json单个对象的字符串。 #include "json.h" #include #include int main(in
qt 修改json数据并重新保存
weixin_41330194的博客
10-15 8285
qt 对于解析和修改json 的支持是挺不错的，相信大家已经看到了很多对于qt 解析json的文章，现在分享一下qt是如何修改json数据的 先看一个json: { "A":{"AA":11}, "B":[{"BB":["bbb"]}], "C":{"CC":["ccc"]} } 首先是一个大的json对象，以下包含了一个小的对象A，一个数组对象数组B，对象数组C ......
精选资源
QT纯C++实现JSON的封装、解析、修改、删除！
04-08
本文将详细介绍如何在QT框架下，利用纯C++实现JSON的封装、解析、修改和删除。 首先，QT库提供了QJson模块，它包含了QJsonDocument、QJsonObject、QJsonArray、QJsonValue和QJsonParseError等类，这些类为我们处理...
C++ Qt解析JSON数据中的JSON数组
TechO_O的博客
09-04 646
在C++ Qt编程中，解析JSON数据是一项常见的任务。在JSON中，数组是一种重要的数据类型，它允许我们将多个值组合在一起。本文将介绍如何使用C++ Qt框架解析JSON数据中的JSON数组。使用QJsonDocument和QJsonArray类，我们可以轻松地加载和遍历JSON数组，并提取其中的值。根据实际需求，您可以根据需要进行进一步的处理，例如将提取的值存储在自定义的数据结构中，或者进行其他操作。在本例中，我们提取了"name"、"age"和"city"字段的值，并将它们存储在相应的变量中。
使用C++ Qt解析JSON数据中的JSON数组
HackLogic的博客
08-15 570
在现代的软件开发中，JSON成为了一种非常流行的数据格式。C++ Qt提供了一个强大的工具库，可以方便地解析和处理JSON数据。在本篇文章中，我们将重点讨论如何使用C++ Qt来解析JSON数组。在本文中，我们已经涵盖了使用C++ Qt解析JSON数组的关键步骤。通过结合Qt的强大工具库和标准C++代码，可以轻松地处理复杂的JSON数据格式。首先，我们需要从Qt网络模块中获取JSON数据。接下来，我们需要使用QJsonDocument类来解析JSON响应。使用C++ Qt解析JSON数据中的JSON数组。
QT,解析和写json文件
12-07
Qt，使用QT自带类，解析Json文件，写Json文件、、、、
QJsonArray、QJsonObject修改值
dubuzherui的专栏
05-06 6570
Qt5的json读取和新建接口都挺方便的，但是对现有文件进行修改，用起来感觉很不方便，pugixml的接口感觉就做的非常好了，下面对修改方法进行一下记录。 示例代码 //构建测试数据 QJsonObject json; QJsonArray array; for(int i = 0; i < 3; i++) { QJsonObject ...
Qt 操作Json格式文件（创建、插入、解析、修改、删除）_qjsonobject 打开 追加
2401_87555332的博客
10-23 1080
“serialOne”: { “language”: “汉语”, “grade”: 10 },* “serialTwo”: { “language”: “英语”, “grade”: 6 }// 设置读取编码是UTF8。* { “game”: “海岛奇兵”, “price”: 66.65 }* { “game”: “三国杀”, “price”: 58.5 },language1.insert(“language”, “汉语”);likeObject1.insert(“game”, “三国杀”);
QT的JSON格式读写修改
aron566博客
08-04 700
QT的Json格式读写修改使用方式效果测试源码 大部分参考博客 不过由于修改json的方式存在问题，我这边修改了一下，可以运行了。 可以用作配置相关运行参数了 使用方式 使用qtcreator新建工程，直接替换main.c中代码即可编译运行。 效果 原来json内容如下 { "class": [ { "age": "18", "home": "xx", "name": "aron566" },
QT JSON解析
zp33
01-07 300
qt json 多参数解析
qt json解析
YanXueTao_的博客
08-16 1034
qtjson嵌套解析 多维数组解析 {}的嵌套解析 一般解析
使用Qt/C++ 实现JSON的反序列化
07-22
在Qt C++中实现JSON的反序列化，通常可以通过Qt自带的类或者结合第三方库（如nlohmann/json）来完成。以下是几种实现方法： ### 使用Qt自带的类进行反序列化 Qt提供了`QJsonDocument`、`QJsonObject`和`QJsonArray`等类，可以用来解析和操作JSON数据。以下是一个示例，演示如何将JSON字符串反序列化为自定义的C++对象： ```cpp #include <QJsonDocument> #include <QJsonObject> #include <QJsonArray> #include <QString> #include <QDebug> struct Member { QString memberName; int age; QString work; QString num; }; struct Test { QString name; int age; QString class_; QString address; // QString可以表示null QList<Member> members; static Test fromJson(const QString& jsonStr) { Test test; QJsonDocument doc = QJsonDocument::fromJson(jsonStr.toUtf8()); if (!doc.isNull() && doc.isObject()) { QJsonObject obj = doc.object(); test.name = obj["name"].toString(); test.age = obj["age"].toInt(); test.class_ = obj["class"].toString(); if (obj["address"].isNull()) { test.address = QString(); // null处理 } else { test.address = obj["address"].toString(); } QJsonArray membersArray = obj["member"].toArray(); for (const QJsonValue& value : membersArray) { QJsonObject memberObj = value.toObject(); Member member; member.memberName = memberObj["memberName"].toString(); member.age = memberObj["age"].toInt(); member.work = memberObj["work"].toString(); member.num = memberObj["num"].toString(); test.members.append(member); } } return test; } }; int main() { QString jsonStr = R"({"name": "a", "age": 14, "class": "初一", "address": null, "member": [{"memberName":"b", "age":56, "work":".....", "num":"13254484545"}, {"memberName":"c", "age":56, "work":".....", "num":"13254484545"}, {"memberName":"d", "age":56, "work":".....", "num":"13254484545"}]})"; Test test = Test::fromJson(jsonStr); qDebug() << "Name:" << test.name; qDebug() << "Age:" << test.age; qDebug() << "Class:" << test.class_; qDebug() << "Address:" << test.address; for (const Member& member : test.members) { qDebug() << "Member Name:" << member.memberName; qDebug() << "Member Age:" << member.age; qDebug() << "Member Work:" << member.work; qDebug() << "Member Num:" << member.num; } return 0; } ``` ### 使用nlohmann/json库进行反序列化 nlohmann/json是一个非常流行的C++ JSON库，支持现代C++特性，并且可以很方便地与Qt结合使用。首先需要从[GitHub](https://github.com/nlohmann/json.git)下载并安装该库。 以下是使用nlohmann/json库进行反序列化的示例代码： ```cpp #include <nlohmann/json.hpp> #include <QString> #include <QDebug> #include <QList> using json = nlohmann::json; struct Member { QString memberName; int age; QString work; QString num; }; struct Test { QString name; int age; QString class_; QString address; QList<Member> members; }; // 自定义类型转换 void from_json(const json& j, Member& m) { j.at("memberName").get_to(m.memberName); j.at("age").get_to(m.age); j.at("work").get_to(m.work); j.at("num").get_to(m.num); } void from_json(const json& j, Test& t) { j.at("name").get_to(t.name); j.at("age").get_to(t.age); j.at("class").get_to(t.class_); if (j.contains("address") && !j["address"].is_null()) { t.address = j["address"].get<QString>(); } else { t.address = QString(); } if (j.contains("member") && j["member"].is_array()) { for (const auto& item : j["member"]) { Member member; item.get_to(member); t.members.append(member); } } } int main() { QString jsonStr = R"({"name": "a", "age": 14, "class": "初一", "address": null, "member": [{"memberName":"b", "age":56, "work":".....", "num":"13254484545"}, {"memberName":"c", "age":56, "work":".....", "num":"13254484545"}, {"memberName":"d", "age":56, "work":".....", "num":"13254484545"}]})"; Test test = json::parse(jsonStr.toStdString()).get<Test>(); qDebug() << "Name:" << test.name; qDebug() << "Age:" << test.age; qDebug() << "Class:" << test.class_; qDebug() << "Address:" << test.address; for (const Member& member : test.members) { qDebug() << "Member Name:" << member.memberName; qDebug() << "Member Age:" << member.age; qDebug() << "Member Work:" << member.work; qDebug() << "Member Num:" << member.num; } return 0; } ``` ### 总结 - **Qt自带的类**：适合不需要引入额外依赖的项目，能够直接与Qt的数据类型（如QString、QList等）配合使用。 - **nlohmann/json库**：提供更简洁的接口，支持现代C++特性，适合需要更复杂JSON处理的项目。 这两种方法都可以有效地实现JSON的反序列化，具体选择取决于项目的实际需求和依赖管理策略。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

微软技术分享

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值