【无标题】QT json 序列化反序列化

已于 2024-03-07 16:27:16 修改
阅读量808 收藏 19
点赞数 19
文章标签： qt json 开发语言
于 2024-03-07 15:55:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15559927/article/details/136536474
版权 
/*****************************************************************
 *  @project     :IntelligentAnalysisGyk15
 *  @File        : JsonSerialize.h
 *  @Author      : zym1
 *  @Date        : 2024-03-06  17:12
 *  @Version     : v1.0
 *  @Copyright   : Copyright By Zhuy, All Rights Reserved
 ******************************************************************/

#ifndef JSONSERIALIZE_H
#define JSONSERIALIZE_H

// json 序列化
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>

#include <QVariant>
#include <QVariantList>
#include <QVariantMap>

///@brief 序列化. object to Json, object to Variant or VariantMap
#define JsonSerialize_Begin()                                                                                                                                  \
public:                                                                                                                                                        \
    operator QVariant() const                                                                                                                                  \
    {                                                                                                                                                          \
        return QVariant::fromValue(this->operator QVariantMap());                                                                                              \
    }                                                                                                                                                          \
    operator QJsonObject() const                                                                                                                               \
    {                                                                                                                                                          \
        return QJsonObject::fromVariantMap(this->operator QVariantMap());                                                                                      \
    }                                                                                                                                                          \
    operator QVariantMap() const                                                                                                                               \
    {                                                                                                                                                          \
        QVariantMap vmap;

#define JsonSerialize_End()                                                                                                                                    \
    return vmap;                                                                                                                                               \
    }

///@brief 序列化属性映射
#define JsonPureProperty(NAME) vmap.unite((QVariantMap)m_##NAME);

#define JsonProperty(NAME)                                                                                                                                     \
    vmap[#NAME] = QVariant::fromValue(m_##NAME);                                                                                                               \
    if (vmap.value(#NAME).isNull())                                                                                                                            \
        vmap.remove(#NAME);

#define JsonContainerProperty(NAME)                                                                                                                            \
    {                                                                                                                                                          \
        QVariantList lst;                                                                                                                                      \
        lst.reserve(m_##NAME.size());                                                                                                                          \
        for (const auto& t : m_##NAME)                                                                                                                         \
        {                                                                                                                                                      \
            lst << QVariant::fromValue(t);                                                                                                                     \
        }                                                                                                                                                      \
        vmap[#NAME] = lst;                                                                                                                                     \
    }

///@brief 反序列化 object from json
#define JsonDeserialize_Begin(class_name)                                                                                                                      \
public:                                                                                                                                                        \
    class_name(const QJsonObject& other)                                                                                                                       \
    {                                                                                                                                                          \
        QVariantMap vmap = other.toVariantMap();

#define JsonDeserialize_End() }

///@brief 部分反序列化
#define JsonPartialDeserialize_Begin(class_name)                                                                                                               \
public:                                                                                                                                                        \
    class_name& operator=(const QJsonObject& other)                                                                                                            \
    {                                                                                                                                                          \
        QVariantMap vmap = other.toVariantMap();

#define JsonPartialDeserialize_End()                                                                                                                           \
    return *this;                                                                                                                                              \
    }

#define JsonDeserializeContainerProperty(NAME)                                                                                                                 \
    if (vmap.value(#NAME).canConvert<QVariantList>())                                                                                                          \
    {                                                                                                                                                          \
        const auto& list = vmap.value(#NAME).value<QVariantList>();                                                                                            \
        m_##NAME.clear();                                                                                                                                      \
        m_##NAME.reserve(list.size());                                                                                                                         \
        for (const auto& v : list)                                                                                                                             \
        {                                                                                                                                                      \
            m_##NAME.push_back(v.value<decltype(m_##NAME)::value_type>());                                                                                     \
        }                                                                                                                                                      \
    }

#define JsonDeserializeProperty(NAME) m_##NAME = vmap.value(#NAME).value<decltype(m_##NAME)>();


#endif // JSONSERIALIZE_H 



/*****************************************************************
 *  @project     :IntelligentAnalysisGyk15
 *  @File        : PropertyHelper.h
 *  @Author      : zym
 *  @Date        : 2024-03-06  17:12
 *  @Version     : v1.0
 *  @Copyright   : Copyright By Zhuy, All Rights Reserved
 ******************************************************************/
#ifndef PROPERTYHELPER_H
#define PROPERTYHELPER_H
#include <QObject>
#include <QtGlobal>

// 比较器的 声明
template <typename T>
struct Compare;

// 通用比较器
template <typename T>
struct Compare
{
    static bool isEqual(const T& t1, const T& t2)
    {
        return t1 == t2;
    }
};
//**********************************普通成员及函数**********************************
// 成员变量
#define PROP_MEM(T, NAME, InitValue) T m_##NAME = InitValue;

// 普通 get 函数
#define MEM_GET(T, NAME)                                                                                                                                       \
    const T& NAME() const                                                                                                                                      \
    {                                                                                                                                                          \
        return m_##NAME;                                                                                                                                       \
    }

// 普通 set 函数
#define MEM_SET(T, NAME)                                                                                                                                       \
    void set_##NAME(const T& value)                                                                                                                            \
    {                                                                                                                                                          \
        m_##NAME = value;                                                                                                                                      \
    }

// 普通 可读可写 成员及函数
#define AUTO_MEM(T, NAME, InitValue)                                                                                                                           \
public:                                                                                                                                                        \
    MEM_GET(T, NAME)                                                                                                                                           \
    MEM_SET(T, NAME)                                                                                                                                           \
private:                                                                                                                                                       \
    PROP_MEM(T, NAME, InitValue)

//**********************************QObject 属性**********************************

// 属性 change 信号
#define PROP_CHANGE(T, NAME) Q_SIGNAL void NAME##Changed(const T& value);

// 属性 get 函数 (和普通get没区别)
#define PROP_GET(T, NAME) MEM_GET(T, NAME)

// 属性 set 函数 (比普通set 多 changeCheck，change 时发信号. check 时处理 float 和 double 数据的精度)
#define PROP_SET(T, NAME)                                                                                                                                      \
    void set_##NAME(const T& value)                                                                                                                            \
    {                                                                                                                                                          \
        if (Compare<T>::isEqual(m_##NAME, value))                                                                                                              \
            return;                                                                                                                                            \
        m_##NAME = value;                                                                                                                                      \
        emit NAME##Changed(value);                                                                                                                             \
    }

// 只读属性，外部不能改
#define READONLY_PROPERTY(T, NAME, InitValue)                                                                                                                  \
private:                                                                                                                                                       \
    Q_PROPERTY(T NAME READ NAME CONSTANT)                                                                                                                      \
public:                                                                                                                                                        \
    PROP_GET(T, NAME)                                                                                                                                          \
private:                                                                                                                                                       \
    PROP_MEM(T, NAME, InitValue)

// 可读属性，比只读属性 多一个 属性set函数。
#define READ_PROPERTY(T, NAME, InitValue)                                                                                                                      \
private:                                                                                                                                                       \
    Q_PROPERTY(T NAME READ NAME NOTIFY NAME##Changed)                                                                                                          \
public:                                                                                                                                                        \
    PROP_GET(T, NAME)                                                                                                                                          \
    PROP_SET(T, NAME)                                                                                                                                          \
    PROP_CHANGE(T, NAME)                                                                                                                                       \
private:                                                                                                                                                       \
    PROP_MEM(T, NAME, InitValue)

// 可读可写 属性。属性set函数 提升为 slot ，可被 invok / qml 调用
#define AUTO_PROPERTY(T, NAME, InitValue)                                                                                                                      \
private:                                                                                                                                                       \
    Q_PROPERTY(T NAME READ NAME WRITE set_##NAME NOTIFY NAME##Changed)                                                                                         \
public:                                                                                                                                                        \
    PROP_GET(T, NAME);                                                                                                                                         \
    Q_SLOT PROP_SET(T, NAME);                                                                                                                                  \
    PROP_CHANGE(T, NAME);                                                                                                                                      \
                                                                                                                                                               \
private:                                                                                                                                                       \
    PROP_MEM(T, NAME, InitValue)


//**********************************QObject 属性 二进制兼容版, 头文件声明 与 源文件定义 分离**********************************

// 属性 get 函数声明
#define PROP_GET_DECL(T, NAME) const T& NAME() const;

// 属性 set 函数声明
#define PROP_SET_DECL(T, NAME) void set_##NAME(const T& value);

// d 指针类型名
#define D_TYPE PrivateData

// d 指针成员变量名
#define D_NAME dPtr

// d 指针的声明
#define D_DECL                                                                                                                                                 \
private:                                                                                                                                                       \
    struct D_TYPE;                                                                                                                                             \
    D_TYPE* D_NAME = nullptr;

// d 指针的定义
#define D_IMPL(ClassName) struct ClassName::D_TYPE

// d 类的成员
#define D_MEM(T, NAME, InitValue) PROP_MEM(T, NAME, InitValue)

// 属性 get 函数定义
#define PROP_GET_IMPL(ClasName, T, NAME)                                                                                                                       \
    const T& ClasName::NAME() const                                                                                                                            \
    {                                                                                                                                                          \
        return D_NAME->m_##NAME;                                                                                                                               \
    }
// 属性 set 函数定义
#define PROP_SET_IMPL(ClasName, T, NAME)                                                                                                                       \
    void ClasName::set_##NAME(const T& value)                                                                                                                  \
    {                                                                                                                                                          \
        if (Compare<T>::isEqual(D_NAME->m_##NAME, value))                                                                                                      \
            return;                                                                                                                                            \
        D_NAME->m_##NAME = value;                                                                                                                              \
        emit NAME##Changed(value);                                                                                                                             \
    }

// 可读可写 属性声明。
#define AUTO_PROPERTY_DECL(T, NAME)                                                                                                                            \
private:                                                                                                                                                       \
    Q_PROPERTY(T NAME READ NAME WRITE set_##NAME NOTIFY NAME##Changed)                                                                                         \
public:                                                                                                                                                        \
    PROP_GET_DECL(T, NAME);                                                                                                                                    \
public slots:                                                                                                                                                  \
    PROP_SET_DECL(T, NAME);                                                                                                                                    \
signals:                                                                                                                                                       \
    PROP_CHANGE(T, NAME)

// 可读可写 属性定义。
#define AUTO_PROPERTY_IMPL(ClassName, T, NAME)                                                                                                                 \
    PROP_GET_IMPL(ClassName, T, NAME)                                                                                                                          \
    PROP_SET_IMPL(ClassName, T, NAME)


#endif // PROPERTYHELPER_H

/**

  • Example:

class AppInfo : public QObject
{
Q_OBJECT

AUTO_PROPERTY(QString, appName, "")
AUTO_PROPERTY(bool, splashShow, false)
AUTO_PROPERTY(float, scale, 1.0f)
AUTO_PROPERTY(double, ratio, 14.0 / 9.0)
AUTO_PROPERTY(QStringList, customs, {})

JsonSerialize_Begin()
    JsonProperty(appName)
    JsonProperty(splashShow)
    JsonProperty(scale)
    JsonProperty(ratio)
    JsonContainerProperty(customs)
JsonSerialize_End()

JsonDeserialize_Begin(AppInfo)
    JsonDeserializeProperty(appName)
    JsonDeserializeProperty(splashShow)
    JsonDeserializeProperty(scale)
    JsonDeserializeProperty(ratio)
    JsonDeserializeContainerProperty(customs)
JsonDeserialize_End()


JsonPartialDeserialize_Begin(AppInfo)
    JsonDeserializeProperty(appName)
    JsonDeserializeProperty(splashShow)
    JsonDeserializeProperty(scale)
    JsonDeserializeProperty(ratio)
    JsonDeserializeContainerProperty(customs)
JsonPartialDeserialize_End()

public:
explicit AppInfo(QObject *parent = nullptr);
virtual ~AppInfo() override;
};

these MACOR will generate these function:

AppInfo(const QJsonobject &obj)
AppInfo &operator=(const QJsonobject &obj)

operator QJsonobject()
operator QVariantMap()
operator QVariant()

*/

老汉憨憨1
关注
  • 19
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
QtJsonSerializer：一个库，用于对JSON和CBOR之间的QObject进行通用的序列化和反序列化
02-05
QtJsonSerializer 一个库，用于对JSON和CBOR之间的QObject进行通用的序列化和反序列化。 使用这个小库，您可以将任何C ++数据类型序列化为JSON或CBOR，然后再序列化。 这是在Qt的元系统的帮助下完成的。 该库最近更新为4.0.0。 请参阅“以了解如何将项目从3. *迁移到4.0.0。 不必担心，对于大多数现有项目，只有类名会更改。 产品特点 在一般情况下，将QObjects，Q_GADGETS，列表，映射等序列化为JSON / CBOR ...当然也可以反序列化JSON / CBOR 反序列化任何QVariant-只要它仅包含基本类型或以上之一甚至可
Qt 5.x Json序列化和反序列化
码农-做一个勤奋的人
12-02 1783
本文主要总结用Qt自带的类QFile、QJsonDocument、QJsonParseError、QJsonObject、QJsonArray、QJsonValue来解析已经写好的json文件 注意：想要解析json文件的主要思路如下：（QJsonValue可以通过函数QJsonValue::toObject()转换为QJsonObject对象） a1先用QFile类将*.json文件所有内容读出，用到关键函数QByteArray QFile::readAll(); a2将读出的内容转换为QJso
Qt 对象序列化/反序列化
1+1=10 个人博客http://kevinlq.com/
08-14 1344
持久化保存类对象，及保存数据到本地磁盘；socket 传输数据，需要把 json/xml/other 类型转为对象，用对象进行业务处理；数据库操作：从 db 中读取出来的值序列化成对象，方便业务进行处理(使用 ORM 框架例外)和界面交互，比如界面使用 QML 编写，那么大部分超场景会使用到 JSON。其他：待补充……
Qt Json 1:序列化与反序列化
weixin_43868793的博客
04-28 1815
#include <QCoreApplication> #include <QJsonDocument> #include <QString> #include <QDebug> #include <QJsonObject> #include <QJsonValue> #include <QJsonArray> #include <QVariantMap> #include <QVariant> s
Qt扫盲-QDataStream 序列化和反序列化理论
洪源兄
10-17 2053
序列化是将对象转换为字节流的过程，可以将对象持久化保存在磁盘或者通过网络传输。反序列化是将字节流转换为对象的过程，可以将保存或传输的对象重新恢复到内存中。数据持久化：将对象保存到磁盘中，实现数据的长期存储。例如，将用户的配置信息序列化为文件，以便在下次打开应用程序时可以重新加载。数据传输：通过网络传输对象，实现不同系统之间的数据交互。分布式计算。
Qt下实现序列化与反序列化
lusanshui的博客
12-18 9235
简述 本文介绍作者在Qt工程中如何将流数据编程结构体对象，把结构体数据编程流数据的实现。代码量不大，非常简洁。 代码之路 写了一个工具类MyDatastream，使用时需要实例化对象，调用相应的序列化或反序列化函数即可，读者可以根据自己定制的结构体自行扩展。例子中的结构体如下： struct UserInfo { unsigned char id[20]; int idint; uns...
qt序列化自定义对象_Qt 自定义序列化
weixin_39617405的博客
12-22 1149
序列化是信息传输和持久化的基石,用于网络传输的序列化,主流是JSON和XML,而持久化保存,则一般是二进制文件,在Qt中,提供了QDataStream类为我们的程序提供了读写二进制数据的能力。QDataStream类实现了序列化C++的基本数据类型的功能，比如char，short，int，char* 等等,不但如此还可以直接序列化QMap ,QList之类的容器(需要保证容器内的元素是基本类型元...
Qt - 序列化之JSON
Hsy的博客
04-06 2506
文章目录Qt-Json相关类QJsonDocumentQJsonObjectQJsonArrayQJsonValueQJsonParseError构建json对象生成js文档json 解析 Qt-Json相关类 QJsonDocument QJsonDocument 类常用于读和写 JSON文档，这里的JSON文档可以是 二进制文档也可以是 UTF-8文档。 QJsonObject QJsonObject 类封装了一个JSON对象。JSON 对象是一个键值对 <key/value>，key 是独
关于一次Json序列化和反序列化使用的情况记录
GrantF的博客
08-01 1727
JSON是专门为浏览器中的网页上运行的JavaScript代码而设计的一种数据格式。JSON是“名值对”的集合。结构由大括号{}，中括号[]，逗号，，冒号：，双引号 ””组成，包含的数据类型有Object，Number,Boolean,String,Array, NULL等。这都是一些基本定义。我要实现的功能是总部对新店政策的制定与变化。先看效果图。这是前台显示的图，用了嵌套显示来显示页面信息。如果
基于Json序列化和反序列化通用的封装完整代码
08-30
JSON 是存储和交换文本信息的语法。类似 XML。JSON 比 XML 更小、更快，更易解析。下面通过实例代码给大家分享Json序列化和反序列化通用的封装，需要的的朋友参考下吧
QT JSON 界面及文件序列化同步实现
04-13
QT JSON 界面及文件序列化同步实现
关于XML、JSON的序列化、发序列化对象或集合
12-06
可将对象、集合进行关于XML、JSON 的序列化，或反序列化。
Json：Qt5的轻量级JSON解析器和序列化器
02-04
Json：Qt5的轻量级JSON解析器和序列化器
【Qt】C++/Qt 实现序列化、反序列化的方式整理
starfire_hit的博客
09-14 1094
C++/Qt 实现序列化、反序列化的方式整理
QT+串口调试助手+扩展版
m0_61973119的博客
05-05 549
此文章是这篇文章的拓展。
Qt | QLineEdit 类(行编辑器)
最新发布
m0_45463480的博客
05-08 361
QLineEdit 类是 QWidget 类的直接子类，该类实现了一个单行的 输入部件，即行编辑器
Qt QInputDialog详解
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
05-06 272
QInputDialog是一个对话框类，用于从用户那里获取一个单一的值。这个值可以是字符串、数字、或者一个列表中的选项。QInputDialog提供了一个方便的方式来快速创建一个输入对话框，无需自己从头开始构建。QInputDialog::TextInput - 允许用户输入文本。QInputDialog::IntInput - 允许用户输入整数。QInputDialog::DoubleInput - 允许用户输入浮点数。
qt对json的序列化和反序列化
10-18
1. JSON序列化 ```cpp QJsonObject obj; obj.insert("name", "Tom"); obj.insert("age", 18); QJsonDocument doc(obj); QString jsonStr(doc.toJson(QJsonDocument::Compact)); ``` 2. JSON反序列化 ```cpp ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

老汉憨憨1

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

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

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

打赏作者

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

抵扣说明：

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

余额充值