QT解析JSON格式超简单

已于 2024-06-03 17:10:33 修改
阅读量2.6k 收藏 31
点赞数 29
分类专栏： QT 文章标签： qt json
于 2024-05-30 15:32:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CodeWorld1999/article/details/139324821
版权

目录

还是从最基础开始、什么是JSON

一、只解析json

 1..解析JSON的主要类

 2.主函数

二、解析并利用结构体存储

1.定义结构体

2.从 JSON 解析并填充结构体

实战示例

还是从最基础开始、什么是JSON

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它基于ECMAScript的一个子集，采用完全独立于语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得JSON成为理想的数据交换语言。

JSON 的基本结构包括两种：

对象（在 JavaScript 中用花括号 {} 表示）

一个对象由一对大括号 {} 包围，对象内的属性是键值对的形式，键（key）和值（value）之间用冒号 : 分隔，多个键值对之间用逗号 , 分隔。

示例

{ "name": "John", "age": 30, "city": "New York" }

数组（在 JavaScript 中用方括号 [] 表示）

一个数组由一对方括号 [] 包围，数组中的元素可以是任意类型的值（包括对象或数组），多个元素之间用逗号 , 分隔。

示例：

[ { "name": "John", "age": 30 }, { "name": "Jane", "age": 25 } ]

在 JSON 中，字符串必须使用双引号 "" 包围，不能使用单引号 ''。对象的键（key）也必须是字符串，并且用双引号包围。

除了对象和数组，JSON 还支持以下数据类型：

  • 字符串（string）
  • 数字（number）
  • 对象（object）
  • 数组（array）
  • 布尔值（true/false）
  • null

注意：JSON 不支持 JavaScript 中的函数、日期对象等复杂类型。

一、只解析json

示例JSON

假设我们有一个JSON文件data.json，内容如下：

{
    "name": "John Doe",
    "age": 30,
    "address": {
        "street": "1234 Elm Street",
        "city": "Somewhere",
        "zipcode": "12345"
    },
    "phones": [
        {"type": "home", "number": "123-456-7890"},
        {"type": "work", "number": "098-765-4321"}
    ]
}

 1..解析JSON的主要类

#include <QCoreApplication>
#include <QFile>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonValue>
#include <QDebug>

class JsonParser {
public:
    JsonParser(const QString& filePath) : filePath(filePath) {}

    void parse() {
        QFile file(filePath);
        if (!file.open(QIODevice::ReadOnly)) {
            qWarning() << "Could not open file" << filePath;
            return;
        }

        QByteArray data = file.readAll();
        QJsonDocument doc = QJsonDocument::fromJson(data);

        if (!doc.isObject()) {
            qWarning() << "Invalid JSON format";
            return;
        }

        QJsonObject rootObj = doc.object();
        parseObject(rootObj);
    }

private:
    QString filePath;

    void parseObject(const QJsonObject& obj) {
        for (const QString& key : obj.keys()) {
            QJsonValue value = obj.value(key);
            if (value.isObject()) {
                qDebug() << "Object:" << key;
                parseObject(value.toObject());
            } else if (value.isArray()) {
                qDebug() << "Array:" << key;
                parseArray(value.toArray());
            } else {
                qDebug() << key << ":" << value.toVariant().toString();
            }
        }
    }

    void parseArray(const QJsonArray& arr) {
        for (const QJsonValue& value : arr) {
            if (value.isObject()) {
                parseObject(value.toObject());
            } else if (value.isArray()) {
                parseArray(value.toArray());
            } else {
                qDebug() << value.toVariant().toString();
            }
        }
    }
};

 2.主函数

#include <QCoreApplication>
#include "jsonparser.h"

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

    QString filePath = "data.json";  // JSON文件路径
    JsonParser parser(filePath);
    parser.parse();

    return a.exec();
}

这样利用嵌套的方法，就可以遍历所有的JSON的节点，输出所有的值，当然这个时候没有办法存储，只是解析出来内容，如果想要通过一个结构体来存储解析出来的所有数据，并且结构体需要合适的话，就需要声明好正确的结构体。

二、解析并利用结构体存储

示例JSON

假设我们有以下 JSON 数据：

{
    "name": "John Doe",
    "age": 30,
    "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "zip": "12345"
    },
    "phone_numbers": [
        {"type": "home", "number": "555-555-5555"},
        {"type": "work", "number": "555-555-5556"}
    ]
}

 那么我们需要按照这个json格式来定义好结构体，用于存储解析出来的内容

1.定义结构体

#include <QString>
#include <QVector>

struct PhoneNumber {
    QString type;
    QString number;
};

struct Address {
    QString street;
    QString city;
    QString zip;
};

struct Person {
    QString name;
    int age;
    Address address;
    QVector<PhoneNumber> phoneNumbers;
};

2.从 JSON 解析并填充结构体

#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QFile>
#include <QDebug>

bool parseJsonToPerson(const QString& jsonString, Person& person) {
    QJsonDocument doc = QJsonDocument::fromJson(jsonString.toUtf8());
    if (doc.isNull() || !doc.isObject()) {
        qWarning() << "Failed to parse JSON";
        return false;
    }

    QJsonObject obj = doc.object();

    person.name = obj["name"].toString();
    person.age = obj["age"].toInt();

    QJsonObject addressObj = obj["address"].toObject();
    person.address.street = addressObj["street"].toString();
    person.address.city = addressObj["city"].toString();
    person.address.zip = addressObj["zip"].toString();

    QJsonArray phoneArray = obj["phone_numbers"].toArray();
    for (const QJsonValue& val : phoneArray) {
        QJsonObject phoneObj = val.toObject();
        PhoneNumber phone;
        phone.type = phoneObj["type"].toString();
        phone.number = phoneObj["number"].toString();
        person.phoneNumbers.append(phone);
    }

    return true;
}

int main() {
    QString jsonString = R"({
        "name": "John Doe",
        "age": 30,
        "address": {
            "street": "123 Main St",
            "city": "Anytown",
            "zip": "12345"
        },
        "phone_numbers": [
            {"type": "home", "number": "555-555-5555"},
            {"type": "work", "number": "555-555-5556"}
        ]
    })";

    Person person;
    if (parseJsonToPerson(jsonString, person)) {
        qDebug() << "Name:" << person.name;
        qDebug() << "Age:" << person.age;
        qDebug() << "Address:" << person.address.street << person.address.city << person.address.zip;
        for (const PhoneNumber& phone : person.phoneNumbers) {
            qDebug() << "Phone:" << phone.type << phone.number;
        }
    } else {
        qDebug() << "Failed to parse JSON.";
    }

    return 0;
}

 之后的问题就是看JSON的复杂程度了，因为JSON所有的内容很少，解析也只有这么些，但是如果JSON串很复杂，比如数组嵌套节点嵌套数组等等，就需要按照上方的方法，像解锁一样一层一层的解开，只是需要读懂json，但绝不是难的。

实战示例

这里就举例一个结构体嵌套结构体来存储JSON的实战示例吧

结构体定义为

struct RefineNumericalValuesElems
{
    RefineNumericalValuesElems() {}
    QString RH; 
    QString SNOW; 
    QString WW;
    QString VV; 
    QString UU100;
    QString CH;
    QString UU;
    QString SDEPTH;
    QString LSRAIN;
    QString TCC;
    QString VV10;
    QString HH;
    QString PS;
    QString DT;
    QString VIS;
    QString UU10;
    QString LCC; 
    QString TT; 
    QString RAIN; 
    QString CRAIN;
    QString HCC;
    QString TT2;
    QString STT;
    QString MSLP;
    QString CAPE;
    QString SH;
    QString SSTT;
    QString WG3H10M;
    QString VV100; 
    QString DEG0;
    QString VO; 
    QString DO; 

    void showInfo() const {
        qDebug() << "RH:" << RH;
        qDebug() << "SNOW:" << SNOW;
        qDebug() << "WW:" << WW;
        qDebug() << "VV:" << VV;
        qDebug() << "UU100:" << UU100;
        qDebug() << "CH:" << CH;
        qDebug() << "UU:" << UU;
        qDebug() << "SDEPTH:" << SDEPTH;
        qDebug() << "LSRAIN:" << LSRAIN;
        qDebug() << "TCC:" << TCC;
        qDebug() << "VV10:" << VV10;
        qDebug() << "HH:" << HH;
        qDebug() << "PS:" << PS;
        qDebug() << "DT:" << DT;
        qDebug() << "VIS:" << VIS;
        qDebug() << "UU10:" << UU10;
        qDebug() << "LCC:" << LCC;
        qDebug() << "TT:" << TT;
        qDebug() << "RAIN:" << RAIN;
        qDebug() << "CRAIN:" << CRAIN;
        qDebug() << "HCC:" << HCC;
        qDebug() << "TT2:" << TT2;
        qDebug() << "STT:" << STT;
        qDebug() << "MSLP:" << MSLP;
        qDebug() << "CAPE:" << CAPE;
        qDebug() << "SH:" << SH;
        qDebug() << "SSTT:" << SSTT;
        qDebug() << "WG3H10M:" << WG3H10M;
        qDebug() << "VV100:" << VV100;
        qDebug() << "DEG0:" << DEG0;
        qDebug() << "VO:" << VO;
        qDebug() << "DO:" << DO;
    }
};

struct GroundMeteorologyElems {
    QString clo_cov_lm; 
    QString clo_cov_low; 
    QString clo_height_lom; 
    QString td; 
    QString rh; 
    QString mslp; 
    QString rain_1h; 
    QString rain_3h; 
    QString rain_6h; 
    QString rain_12h;
    QString rain_24h; 
    QString pressure; 
    QString pressure_change_24h; 
    QString pressure_change_3h; 
    QString tt; 
    QString temp_change_24h; 
    QString temp_max_24h;
    QString temp_min_24h; 
    QString vis_human; 
    QString weather;
    QString wd_avg_10mi;
    QString wd_avg_2mi; 
    QString ws_avg_10mi;
    QString ws_avg_2mi;
    void showInfo() const {
        qDebug() << "clo_cov_lm:" << clo_cov_lm;
        qDebug() << "clo_cov_low:" << clo_cov_low;
        qDebug() << "clo_height_lom:" << clo_height_lom;
        qDebug() << "td:" << td;
        qDebug() << "rh:" << rh;
        qDebug() << "mslp:" << mslp;
        qDebug() << "rain_1h:" << rain_1h;
        qDebug() << "rain_3h:" << rain_3h;
        qDebug() << "rain_6h:" << rain_6h;
        qDebug() << "rain_12h:" << rain_12h;
        qDebug() << "rain_24h:" << rain_24h;
        qDebug() << "pressure:" << pressure;
        qDebug() << "pressure_change_24h:" << pressure_change_24h;
        qDebug() << "pressure_change_3h:" << pressure_change_3h;
        qDebug() << "tt:" << tt;
        qDebug() << "temp_change_24h:" << temp_change_24h;
        qDebug() << "temp_max_24h:" << temp_max_24h;
        qDebug() << "temp_min_24h:" << temp_min_24h;
        qDebug() << "vis_human:" << vis_human;
        qDebug() << "weather:" << weather;
        qDebug() << "wd_avg_10mi:" << wd_avg_10mi;
        qDebug() << "wd_avg_2mi:" << wd_avg_2mi;
        qDebug() << "ws_avg_10mi:" << ws_avg_10mi;
        qDebug() << "ws_avg_2mi:" << ws_avg_2mi;
    }
};

struct WAFSForecastElems {
    QString CAT;
    QString CBE;
    QString CBTOP;
    void showInfo() const{
        qDebug() << "CAT:" << CAT;
        qDebug() << "CBE:" << CBE;
        qDebug() << "CBTOP:" << CBTOP;
    }
};

struct Json_GROUND_METE_AREA{
    QString code;
    QString msg;
    struct Data {
            struct Values {
                QString station_id; 
                QString name; 
                QString lon; 
                QString record_time; 
                QString alti; 
                QString lat;
                //要素组
                RefineNumericalValuesElems refineNumericalValuesElems;
                GroundMeteorologyElems groundMeteorologyElems;
                WAFSForecastElems wafsForecastElems;
            };
            QVector<Values> values;
    } data;
    void showInfo() const {
        qDebug() << "Json_GROUND_METE_AREA: \n";
        qDebug() << "Code:" << code;
        qDebug() << "Message:" << msg;

        for (const Data::Values &value : data.values) {
            qDebug() << "Values List:";
            qDebug() << "station_id:" << value.station_id;
            qDebug() << "name:" << value.name;
            qDebug() << "lon:" << value.lon;
            qDebug() << "record_time:" << value.record_time;
            qDebug() << "alti:" << value.alti;
            qDebug() << "lat:" << value.lat;
            value.refineNumericalValuesElems.showInfo();
            value.groundMeteorologyElems.showInfo();
            value.wafsForecastElems.showInfo();
        }
    }
};

解析函数

void Widget::parseRefineNumericalValuesElems(const QJsonObject &obj, RefineNumericalValuesElems &elems) {
    QMap<QString, QString*> map = {
        {"RH", &elems.RH},
        {"SNOW", &elems.SNOW},
        {"WW", &elems.WW},
        {"VV", &elems.VV},
        {"UU100", &elems.UU100},
        {"CH", &elems.CH},
        {"UU", &elems.UU},
        {"SDEPTH", &elems.SDEPTH},
        {"LSRAIN", &elems.LSRAIN},
        {"TCC", &elems.TCC},
        {"VV10", &elems.VV10},
        {"HH", &elems.HH},
        {"PS", &elems.PS},
        {"DT", &elems.DT},
        {"VIS", &elems.VIS},
        {"UU10", &elems.UU10},
        {"LCC", &elems.LCC},
        {"TT", &elems.TT},
        {"RAIN", &elems.RAIN},
        {"CRAIN", &elems.CRAIN},
        {"HCC", &elems.HCC},
        {"TT2", &elems.TT2},
        {"STT", &elems.STT},
        {"MSLP", &elems.MSLP},
        {"CAPE", &elems.CAPE},
        {"SH", &elems.SH},
        {"SSTT", &elems.SSTT},
        {"WG3H10M", &elems.WG3H10M},
        {"VV100", &elems.VV100},
        {"DEG0", &elems.DEG0},
        {"VO", &elems.VO},
        {"DO", &elems.DO}
    };

    for (auto it = map.begin(); it != map.end(); ++it) {
        if (obj.contains(it.key())) {
            *(it.value()) = obj[it.key()].toVariant().toString();
        }
    }
}

void Widget::parseGroundMeteorologyElems(const QJsonObject &obj, GroundMeteorologyElems &elems)
{
    QMap<QString, QString*> map = {
        {"clo_cov_lm", &elems.clo_cov_lm},
        {"clo_cov_low", &elems.clo_cov_low},
        {"clo_height_lom", &elems.clo_height_lom},
        {"td", &elems.td},
        {"rh", &elems.rh},
        {"mslp", &elems.mslp},
        {"rain_1h", &elems.rain_1h},
        {"rain_3h", &elems.rain_3h},
        {"rain_6h", &elems.rain_6h},
        {"rain_12h", &elems.rain_12h},
        {"rain_24h", &elems.rain_24h},
        {"pressure", &elems.pressure},
        {"pressure_change_24h", &elems.pressure_change_24h},
        {"pressure_change_3h", &elems.pressure_change_3h},
        {"tt", &elems.tt},
        {"temp_change_24h", &elems.temp_change_24h},
        {"temp_max_24h", &elems.temp_max_24h},
        {"temp_min_24h", &elems.temp_min_24h},
        {"vis_human", &elems.vis_human},
        {"weather", &elems.weather},
        {"wd_avg_10mi", &elems.wd_avg_10mi},
        {"wd_avg_2mi", &elems.wd_avg_2mi},
        {"ws_avg_10mi", &elems.ws_avg_10mi},
        {"ws_avg_2mi", &elems.ws_avg_2mi}
    };

    for (auto it = map.begin(); it != map.end(); ++it) {
        if (obj.contains(it.key())) {
            *(it.value()) = obj[it.key()].toVariant().toString();
        }
    }
}

void Widget::parseWAFSForecastElems(const QJsonObject &obj, WAFSForecastElems &elems)
{
    QMap<QString, QString*> map = {
        {"CAT", &elems.CAT},
        {"CBE", &elems.CBE},
        {"CBTOP", &elems.CBTOP}
    };

    for (auto it = map.begin(); it != map.end(); ++it) {
        if (obj.contains(it.key())) {
            *(it.value()) = obj[it.key()].toVariant().toString();
        }
    }
}


Json_GLOBAL_REGIONAL_GROUND_METE Widget::parseGlobalRegionalGroundMeteData(const QByteArray &response)
{
    Json_GLOBAL_REGIONAL_GROUND_METE jsonToStructdata;
    QJsonDocument doc = QJsonDocument::fromJson(response);
    QJsonObject rootObj = doc.object();

    jsonToStructdata.code = rootObj["code"].toVariant().toString();
    jsonToStructdata.msg = rootObj["msg"].toVariant().toString();
        // 获取data对象
        QJsonObject dataObject = rootObj["data"].toObject();
        // 获取values字段
//        QJsonObject valuesObject = dataObject["values"].toObject();
        QJsonArray valuesArray = dataObject.value("values").toArray();
        // 将values字段的数据填充到结构体中
         for (const QJsonValue &val : valuesArray) {
             QJsonObject valueObj = val.toObject();
            Json_GROUND_METE_AREA::Data::Values value;
            value.station_id = valueObj["station_id"].toVariant().toString();
            value.name = valueObj["name"].toVariant().toString();
            value.lon = valueObj["lon"].toVariant().toString();
            value.record_time = valueObj["record_time"].toVariant().toString();
            value.alti = valueObj["alti"].toVariant().toString();
            value.lat = valueObj["lat"].toVariant().toString();
            parseRefineNumericalValuesElems(valueObj, value.refineNumericalValuesElems);
            parseGroundMeteorologyElems(valueObj, value.groundMeteorologyElems);
            parseWAFSForecastElems(valueObj, value.wafsForecastElems);
            jsonToStructdata.data.values.append(value);
        }
//    jsonToStructdata.showInfo();
    return jsonToStructdata;
}

$老无所依￥
关注
专栏目录
Qt json解析
啊渊的专栏
04-27 4129
目录JSON解析对象解析数组解析数组对象混合解析对象数组混合解析Qt中内置了一个QJsonDocument类用来处理json文件，以及json字符串。解析JSON是一种存储结构化数据的格式。它有6种基本数据类型：bool、double、string、array、object、null测试数据 Qt json解析对象 代码 运行结果 数组解析 测试数据 Qt json解析数组代码 运行结果 数组对象混合解析 测试数据 Qt json解析代码 运行结果 对象数组混合解析
QT,解析和写json文件
12-07
Qt，使用QT自带类，解析Json文件，写Json文件、、、、
Qt4实现json文件的读取和显示
04-28
QT4不支持JSON格式，QT5自带了库，所以QT4需要引入第三方，这里使用的是Eeli Reilin的QtJson。本资源是对json库的实现案例，适合学习和理解json库的qt读写使用。
Qt构建JSON及解析JSON
最新发布
a1937194471的博客
09-17 1666
一般来讲C++类和对象在java中是无法直接直接使用的，因为压根就不是一个规则。但是他们在内存中都是二进制表示的，所以把C++的类和对象转成二进制再按照java的规则解析这段二进制代码就可以做到C++描述的东西在java中复现了。
【Qt 】JSON 数据格式详解
Hou_lang_LJ的博客
07-23 1554
🐧 ①JSON字符串的构建和解析；🖊
Qt--解析Json
hw5230的博客
01-28 5867
QT4中使用第三方库QJson解析JSON文件。QT5新增加了处理JSON的类，类均以QJson开头，包含在QtCore模块中。QT5新增加六个相关类：QJsonArray封装 JSON 数组读写 JSON 文档封装 JSON 对象用于遍历QJsonObject的STL风格的非const遍历器报告 JSON 处理过程中出现的错误QJsonValue封装 JSON 值QJsonDocument提供了读写Json文档的方法。
【Qt】Json解析
卡钦斯基的博客
08-21 3839
它是一种轻量级的、开放的、易于阅读和理解的数据格式，适用于广泛的应用场景。正是由于Json格式的数据的常用性，所以很多时候我们使用Qt框架来写程序是绕不开它的。而Qt自然也有专门的类用来读写Json格式的数据。
Qt解析JSON
qq_44723937的博客
07-27 3685
Qt解析JSON的类QJsonDocument、QJsonObject、QJsonArray
Qt解析Json数据
北极星的技术笔记
01-10 2707
本文主要介绍了使用Qt框架编程时如何解析JSON数据的一种方法。JSON是英文的缩写，它是一种轻量级的数据交换格式，具有方便阅读和编写的优点，同时也易于机器解析和生成。JSON数据格式应用广泛，能够用于多种语言之间的数据交换。当前开源的C++JSON解析库有大概几十种，比较著名的有jsoncpp、nlohmann/json、rapidjson、jsonxx等。除此之外Qt5.0以上的版本也提供了JSON数据的读写支持。本文以jsoncpp库为例介绍如何使用第三方库实现JSON数据的读写。
Qt 解析Json
司马懿的西山居
06-04 4279
常用的Json库 (1) JsonCpp     JsonCpp是一个C++用来处理JSON数据的开发包。     网址：http://jsoncpp.sourceforge.net/. (2) cJSON     cJSON是一个超轻巧，携带方便，单文件，简单的可以作为ANSI-C标准的JSON解析器。     网址：http://sourceforge.net/projects/c
QT解析 JSON 格式的数据
AUTUMN STUDIO
03-08 7747
QT解析 JSON 格式的数据 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON 采用完全独立于语言的文本格式，这些特性使 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成。 1、基础结构 名称/值对 集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object）、记录（record）、结构（struct）、字典（dictionary）、哈希表（hash tabl
C++ Qt解析JSON数据中的JSON数组
TechO_O的博客
09-04 477
在C++ Qt编程中，解析JSON数据是一项常见的任务。在JSON中，数组是一种重要的数据类型，它允许我们将多个值组合在一起。本文将介绍如何使用C++ Qt框架解析JSON数据中的JSON数组。使用QJsonDocument和QJsonArray类，我们可以轻松地加载和遍历JSON数组，并提取其中的值。根据实际需求，您可以根据需要进行进一步的处理，例如将提取的值存储在自定义的数据结构中，或者进行其他操作。在本例中，我们提取了"name"、"age"和"city"字段的值，并将它们存储在相应的变量中。
QT JSON解析
zp33
01-07 217
qt json 多参数解析
Qt解析JSON文件
笔记本IT的博客
12-01 1257
json是一种与语言无关的数据交换的格式，使用Json的格式与解析方便的可以表示一个对象信息，json有两种格式：①对象格式：{“key1”:obj,“key2”:obj,“key3”:obj…}、②数组/集合格式：[obj,obj,obj…]。json是 JavaScript Object Notation 的首字母缩写，单词的意思是javascript对象表示法，这里说的json指的是类似于javascript对象的一种数据格式，目前这种数据格式比较流行，逐渐替换掉了传统的xml数据格式。
QT解析JSON格式文件
ljjjjjjjjjjj的博客
11-23 765
【代码】QT解析JSON格式文件。
Qt 解析 JSON 数据
weixin_46870692的博客
08-15 2960
Qt 解析 JSON 数据
Qt 中解析JSON
RDC01的博客
04-20 330
#pragma execution_character_set("utf-8") #include "widget.h" #include "ui_widget.h" #include <QJsonParseError> #include<QJsonArray> #include <QJsonValue> #include <QFile> #incl...
qt 解析 嵌套的json格式
06-02
如果你想使用 Qt 来解析嵌套的 JSON 格式，可以使用 Qt 提供的 Json 模块。这个模块提供了一个 QJsonDocument 类，可以将 JSON 数据转换成 Qt 的数据结构，比如 QVariant、QVariantList 和 QVariantMap。QVariantMap 可以用来表示嵌套的 JSON 对象，QVariantList 可以用来表示 JSON 数组。下面是一个示例代码，演示了如何解析嵌套的 JSON 格式： ```cpp #include <QJsonDocument> #include <QJsonObject> #include <QJsonArray> // ... QJsonDocument doc = QJsonDocument::fromJson(jsonData); if (!doc.isNull()) { if (doc.isObject()) { QJsonObject obj = doc.object(); QVariantMap map = obj.toVariantMap(); // 处理嵌套的 JSON 对象 } else if (doc.isArray()) { QJsonArray array = doc.array(); QVariantList list = array.toVariantList(); // 处理嵌套的 JSON 数组 } } ``` 在上面的代码中，jsonData 是一个 QString 类型的 JSON 数据。首先，我们将 JSON 数据转换成 QJsonDocument 对象。然后，我们检查 QJsonDocument 对象的类型，如果是 JSON 对象，我们就将其转换成 QVariantMap 对象。如果是 JSON 数组，我们就将其转换成 QVariantList 对象。最后，我们可以使用 QVariantMap 和 QVariantList 对象来访问和处理嵌套的 JSON 数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值