C++ 中多态对象串行化(Serialize)的一个实现方案

在开发中经常要遇到需要将对象进行串行化(serialize)的情况，但c++语言或标准库目前并无直接的实现支持。同时由于c++本身的RTTI机制比较简单，功能有限，在面向对象编程时通过基类或接口指针进行串行化操作时更麻烦。本文是尝试解决该问题的一个实现。

程序中需要序列化的数据为对象Data及其派生类DataAnalog、DataDigital。架构中引入一个单件（Singleton）类DataFacotry，用于保存类信息与运行时的对象的动态创建。而类的具体创建则使用Prototype模式，便于扩充。类信息则通过C++的typeid获得。序列化的结果保存到一个json文本中，对json的读写使用了Qt的json类。

全部实现及测试代码如下：

#include <QCoreApplication>

#include <memory>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <QFile>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>

class Data
{    
public:
    Data(void){}
    Data(const std::wstring &name) : dataName(name){}
    virtual ~Data() {}

    std::string getClassName(void){
        return typeid(*this).name();
    }
    std::shared_ptr<Data> clone(void) const{
        auto data = newData();
        QJsonObject json;
        write(json);
        data->read(json);
        return data;
    }

    std::wstring getName(void){
        return dataName;
    }

    virtual void write(QJsonObject &json) const{
        json["Name"] = QString::fromStdWString(dataName.c_str());

    }
    virtual void read(const QJsonObject &json){
        dataName = json["Name"].toString().toStdWString();
    }

    virtual void print(std::wostream &out){
        out << dataName.c_str() << std::endl;
    }

protected:
    virtual std::shared_ptr<Data> newData(void) const = 0;

private:
    std::wstring dataName;
};

class DataAnalog : public Data
{
public:
    DataAnalog(void){}
    DataAnalog(const std::wstring &name, const double value):Data(name), dataValue(value) {}
    virtual ~DataAnalog(){}

    virtual void write(QJsonObject &json) const override{
        Data::write(json);
        json["Value"] = dataValue;
    }
    virtual void read(const QJsonObject &json) override{
        Data::read(json);
        dataValue = json["Value"].toDouble();
    }

    virtual void print(std::wostream &out){
        out << getName().c_str() << L"=" << dataValue << std::endl;
    }

protected:
    virtual std::shared_ptr<Data> newData(void) const override{
        return std::make_shared<DataAnalog>();
    }

private:
    double dataValue = 0;
};

class DataDigital : public Data
{
public:
    DataDigital(void) {}
    DataDigital(const std::wstring &name, const bool value):Data(name), dataValue(value){}
    virtual ~DataDigital(){}

    virtual void write(QJsonObject &json) const override{
        Data::write(json);
        json["Value"] = dataValue;
    }
    virtual void read(const QJsonObject &json) override{
        Data::read(json);
        dataValue = json["Value"].toBool();
    }

    virtual void print(std::wostream &out) override{
        out << getName().c_str() << L"=" << (dataValue?L"true":L"false") << std::endl;
    }

protected:
    virtual std::shared_ptr<Data> newData(void) const override{
        return std::make_shared<DataAnalog>();
    }

private:
    bool dataValue = false;
};

class DataFacotry
{
public:
    static DataFacotry& instance(void){
        static DataFacotry ins;
        static bool initialized = false;
        if(!initialized)
        {
            ins.registerPrototype(std::make_shared<DataAnalog>());
            ins.registerPrototype(std::make_shared<DataDigital>());
            initialized = true;
        }
        return ins;
    }

    void registerPrototype(std::shared_ptr<Data> protoType){
        prototypeDatas.emplace(protoType->getClassName(), protoType);
    }

    std::shared_ptr<Data> create(const std::string &className){
        auto it = prototypeDatas.find(className);
        if(it!=prototypeDatas.end()){
            return it->second->clone();
        }
        return nullptr;
    }

private:
    std::map<std::string, std::shared_ptr<Data>> prototypeDatas;
};

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

    {        
        std::vector<std::shared_ptr<Data>> datas;
        datas.emplace_back(new DataAnalog(L"Anlog_1", 1.1));
        datas.emplace_back(new DataAnalog(L"Anlog_2", 2.2));
        datas.emplace_back(new DataDigital(L"Digita_1", true));
        datas.emplace_back(new DataDigital(L"Digita_2", false));

        QFile file(QCoreApplication::applicationDirPath() + "\\data.json");
        if(file.open(QFile::WriteOnly))
        {
            QJsonArray dataArray;
            for(auto data:datas)
            {
                QJsonObject obj;
                obj["Class"] = data->getClassName().c_str();
                QJsonObject dataObj;
                data->write(dataObj);
                obj["Data"] = dataObj;
                dataArray.append(obj);
            }

            QJsonObject json;
            json["Datas"] = dataArray;
            QJsonDocument doc(json);
            file.write(doc.toJson());
        }
    }

    {
        QFile file(QCoreApplication::applicationDirPath() + "\\data.json");
        if(file.open(QFile::ReadOnly))
        {
            QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
            if(!doc.isNull())
            {
                QJsonObject json = doc.object();
                std::vector<std::shared_ptr<Data>> datas;
                QJsonArray dataArray = json["Datas"].toArray();
                for(auto i : dataArray)
                {
                    QJsonObject obj = i.toObject();
                    QString className = obj["Class"].toString();
                    auto data = DataFacotry::instance().create(className.toStdString());
                    if(data)
                    {
                        datas.emplace_back(data);
                        datas.back()->read(obj["Data"].toObject());
                    }
                }

                std::for_each(datas.begin(), datas.end()
                              , [](std::shared_ptr<Data> data){data->print(std::wcout);});

            }
        }
    }

    return a.exec();
}

发生