Qt C++如何实现可编辑、兼容类变更的对象XML序列化？

针对你用QDataStream存储二进制配置遇到的可读性差、版本兼容问题，下面给出满足需求的实现方案，包括Qt原生方案和类似C#反射的框架选项：

一、Qt原生XML序列化（无额外依赖） #

直接用Qt的QXmlStreamWriter/QXmlStreamReader手动实现配置类与XML的映射，同时处理版本兼容：

核心实现示例 #

给配置类添加序列化和反序列化方法：

#include <QXmlStreamWriter>
#include <QXmlStreamReader>
#include <QFile>

class Config {
public:
    int windowWidth = 800;
    int windowHeight = 600;
    bool autoSave = false; // 新增字段带默认值

    // 序列化到XML
    bool saveToXml(const QString& filePath) const {
        QFile file(filePath);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) return false;

        QXmlStreamWriter writer(&file);
        writer.setAutoFormatting(true); // 生成格式化XML，方便手动编辑
        writer.writeStartDocument();
        writer.writeStartElement("Config");
        writer.writeAttribute("version", "1.1"); // 版本号，用于兼容

        writer.writeTextElement("WindowWidth", QString::number(windowWidth));
        writer.writeTextElement("WindowHeight", QString::number(windowHeight));
        writer.writeTextElement("AutoSave", autoSave ? "true" : "false");

        writer.writeEndElement();
        writer.writeEndDocument();
        return true;
    }

    // 从XML反序列化
    bool loadFromXml(const QString& filePath) {
        QFile file(filePath);
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) return false;

        QXmlStreamReader reader(&file);
        while (!reader.atEnd() && !reader.hasError()) {
            if (reader.readNextStartElement()) {
                if (reader.name() == "Config") {
                    QString version = reader.attributes().value("version").toString();
                    while (reader.readNextStartElement()) {
                        if (reader.name() == "WindowWidth") {
                            windowWidth = reader.readElementText().toInt();
                        } else if (reader.name() == "WindowHeight") {
                            windowHeight = reader.readElementText().toInt();
                        } else if (reader.name() == "AutoSave") {
                            autoSave = (reader.readElementText() == "true");
                        } else {
                            reader.skipCurrentElement(); // 跳过未知节点，兼容旧文件
                        }
                    }
                    // 旧版本无AutoSave字段时，用默认值
                    if (version < "1.1") {
                        autoSave = false;
                    }
                } else {
                    reader.skipCurrentElement();
                }
            }
        }
        return !reader.hasError();
    }
};

版本兼容关键 #

• 根节点必须带version属性，类定义修改时升级版本号
• 解析时跳过未知节点，不中断流程
• 新增字段设置默认值，旧文件无对应节点时自动填充

二、C++中类似反射的序列化框架（简化映射） #

C++没有原生反射，但可以借助框架或Qt元对象系统实现类似C#的自动字段映射：

1. Qt元对象系统（推荐，适配Qt项目） #

利用Q_OBJECT宏和Q_PROPERTY标记字段，通过QMetaObject遍历属性自动序列化：

#include <QObject>
#include <QXmlStreamWriter>
#include <QXmlStreamReader>

class Config : public QObject {
    Q_OBJECT
    Q_PROPERTY(int windowWidth READ windowWidth WRITE setWindowWidth)
    Q_PROPERTY(int windowHeight READ windowHeight WRITE setWindowHeight)
    Q_PROPERTY(bool autoSave READ autoSave WRITE setAutoSave)

public:
    explicit Config(QObject* parent = nullptr) : QObject(parent) {}

    int windowWidth() const { return m_windowWidth; }
    void setWindowWidth(int width) { m_windowWidth = width; }

    int windowHeight() const { return m_windowHeight; }
    void setWindowHeight(int height) { m_windowHeight = height; }

    bool autoSave() const { return m_autoSave; }
    void setAutoSave(bool save) { m_autoSave = save; }

private:
    int m_windowWidth = 800;
    int m_windowHeight = 600;
    bool m_autoSave = false;
};

// 序列化函数
bool saveConfig(const Config* config, const QString& path) {
    QFile file(path);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) return false;

    QXmlStreamWriter writer(&file);
    writer.setAutoFormatting(true);
    writer.writeStartDocument();
    writer.writeStartElement("Config");
    writer.writeAttribute("version", "1.1");

    const QMetaObject* metaObj = config->metaObject();
    // 遍历所有Q_PROPERTY标记的属性
    for (int i = metaObj->propertyOffset(); i < metaObj->propertyCount(); ++i) {
        QMetaProperty prop = metaObj->property(i);
        writer.writeTextElement(prop.name(), prop.read(config).toString());
    }

    writer.writeEndElement();
    writer.writeEndDocument();
    return true;
}

// 反序列化函数
bool loadConfig(Config* config, const QString& path) {
    QFile file(path);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) return false;

    QXmlStreamReader reader(&file);
    while (!reader.atEnd() && !reader.hasError()) {
        if (reader.readNextStartElement()) {
            if (reader.name() == "Config") {
                QString version = reader.attributes().value("version").toString();
                const QMetaObject* metaObj = config->metaObject();

                while (reader.readNextStartElement()) {
                    QString propName = reader.name().toString();
                    int propIndex = metaObj->indexOfProperty(propName.toUtf8());
                    if (propIndex != -1) {
                        QMetaProperty prop = metaObj->property(propIndex);
                        prop.write(config, QVariant(reader.readElementText()));
                    } else {
                        reader.skipCurrentElement(); // 兼容未知属性
                    }
                }

                if (version < "1.1") {
                    config->setAutoSave(false);
                }
            } else {
                reader.skipCurrentElement();
            }
        }
    }
    return !reader.hasError();
}

这种方式无需手动映射每个字段，新增字段只需加Q_PROPERTY，和C#反射的使用体验类似。

2. Boost.Serialization（跨平台通用框架） #

如果项目允许引入Boost库，它的XML序列化模块支持自动映射字段和版本控制：

#include <boost/serialization/serialization.hpp>
#include <boost/serialization/xml_oarchive.hpp>
#include <boost/serialization/xml_iarchive.hpp>
#include <fstream>

class Config {
private:
    int m_windowWidth = 800;
    int m_windowHeight = 600;
    bool m_autoSave = false;

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version) {
        ar & BOOST_SERIALIZATION_NVP(m_windowWidth);
        ar & BOOST_SERIALIZATION_NVP(m_windowHeight);
        // 版本1新增autoSave字段，旧版本解析时跳过
        if (version >= 1) {
            ar & BOOST_SERIALIZATION_NVP(m_autoSave);
        }
    }
};

// 注册类版本号
BOOST_CLASS_VERSION(Config, 1)

// 序列化到XML
void saveConfig(const Config& config, const std::string& path) {
    std::ofstream file(path);
    boost::archive::xml_oarchive ar(file);
    ar << BOOST_SERIALIZATION_NVP(config);
}

// 从XML反序列化
void loadConfig(Config& config, const std::string& path) {
    std::ifstream file(path);
    boost::archive::xml_iarchive ar(file);
    ar >> BOOST_SERIALIZATION_NVP(config);
}

生成的XML结构清晰，支持手动编辑，版本兼容通过版本号判断自动处理。

三、确保满足所有需求的细节 #

• XML可读性：开启格式化输出（Qt中setAutoFormatting(true)），节点名使用语义化的字段名，避免嵌套过深。
• 手动编辑支持：所有字段值用纯文本存储，避免二进制内容，编辑后保存为标准XML格式即可被程序解析。
• 版本兼容：
  1. 永远保留旧版本字段的解析逻辑，不要删除
  2. 新增字段必须设置默认值
  3. 根节点的版本号必须随类定义修改而升级

内容的提问来源于stack exchange，提问作者Flag Time