QT解析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 Json_GROUND_METE_AREA{
    QString code;
    QString msg;
    struct Data {
            struct Values {
                QString station_id; //站点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 {
        // 在这里处理结构体 A 的数据
        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;
}

原文地址：https://blog.csdn.net/CodeWorld1999/article/details/139324821

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Qt 窗口
下一篇：element-plus datePicker 如何输出时间戳

迅为瑞芯微RK3562开发板/核心板应用于人脸跟踪、身体跟踪、视频监控、自动语音识别(ASR)、图像分类驾驶员辅助系统(ADAS)、车牌识别、物体识别等
iTOP-3562开发板/核心板采用瑞芯微RK3562处理器，内部集成了四核A53+Mali G52架构，主频2GHZ，内置1TOPSNPU算力，RK809动态调频。支持几乎全格式的H.264解码，支
阅读更多2024-12-31
低精度只适用于未充分训练的LLM？腾讯提出LLM量化的scaling laws
尽管有一些研究声称原生的低比特LLM可以媲美fp16/bf16精度下的表现，但这些研究普遍都是在未充分语言模型上得到的结果从而推出的结论，研究人员认为在充分训练的情况下进行比较的话，低比特LLM也将很
阅读更多2024-12-31
医疗数仓配置Flume
Flume需要将Kafka中各topic的数据传输到HDFS，因此选用KafkaSource以及HDFSSink。对于安全性要求高的数据（不允许丢失）选用FileChannel，允许部分丢失的数据如日
阅读更多2024-12-31
Go中CAS算法
CAS算法常被用作乐观锁的实现方式，用于解决并发问题。例如，在计数器、缓存等场景中，可以使用CAS算法来确保数据的一致性和正确性。CAS操作会检查内存位置V的当前值是否与预期的旧值A相等。这一操作是原
阅读更多2024-12-31
Node.js 记账本项目总结
在使用Node.js结合Express框架构建记账本的过程中，遇到了一些常见的问题，这些问题主要集中在路径处理、包管理工具的选择、开发环境优化以及HTTP响应处理等方面。
阅读更多2024-12-31
Java 处理base64文件上传
在系统内有一个类似于公告的模块，如果里面添加的文章不是选择富文本上传图片的方式，而是选择复制别的文章直接粘贴到系统内的富文本，里面的图片就不会url，而是图片的base64格式，这样会导致数据库存储压
阅读更多2024-12-31
Tailwind CSS 实战：现代登录注册页面开发
基础结构搭建表单组件开发社交登录集成响应式适配深色模式支持动画效果表单验证性能优化可访问性增强通过合理使用 Tailwind CSS 的原子类，我们不仅实现了美观的界面，还确保了良好的用户体验和可维护
阅读更多2024-12-31
node.js下载、安装、设置国内镜像源（永久）（Windows11）
系统：Windows 11。
阅读更多2024-12-31
Slate文档编辑器-Decorator装饰器渲染调度
在这里我们主要讨论了slate中的decoration装饰器的实现，以及在实际使用中可能会遇到的问题，主要是在跨节点的情况下，我们需要将range拆分为多个range，然后分别进行处理，并且还分析了源
阅读更多2024-12-31
python去水印
请注意，这种方法仅适用于简单的水印去除，对于复杂的水印或嵌入到图像纹理中的水印，可能无法达到理想的效果。在实际应用中，还可以考虑使用深度学习的方法，如生成对抗网络（GAN）来去除水印，但需要大量的数据
阅读更多2024-12-31