C++ c++；序列化为一个类设置一个固定的类id

我正在使用boost对一些类进行序列化和反序列化

像这样：

boost::archive::xml_oarchive xmlArchive(oStringStream);

xmlArchive.register_type(static_cast<BaseMessage *>(NULL));
xmlArchive.register_type(static_cast<IncomingTradeMessage *>(NULL));
xmlArchive.register_type(static_cast<InternalRequestInfo *>(NULL));
xmlArchive.register_type(static_cast<InternalTradeTransInfo *>(NULL));

const BaseMessage* myMessage =message;

xmlArchive << make_nvp("Message", myMessage);

在我的项目BaseMessage中的任何地方，class_id都是1234

---

我怎么能做这样的事情呢？我不确定这是否适用于您的情况（如果您的问题是专门寻找boost中的机制还是不），但是字符串呢？据我所知，没有类似的增强功能，但我已经将这种解决方案应用于我们的代码库：

#include <iostream>
#include <string>
using namespace std;

template <class T>
const char* my_type_id()
{
    return "Unknown";
}

#define REGISTER_TYPE(some_type)            \
    template <> inline                      \
    const char* my_type_id<some_type>()     \
    {                                       \
        return #some_type;                  \
    }

REGISTER_TYPE(int)
REGISTER_TYPE(std::string)

int main()
{
    // displays "int"
    cout << my_type_id<int>() << endl;

    // displays "std::string"
    cout << my_type_id<string>() << endl;

    // displays "Unknown" - we haven't registered char
    cout << my_type_id<char>() << endl;
}

#包括
#包括
使用名称空间std；
模板
const char*my_type_id（）
{
返回“未知”；
}
#定义寄存器类型（某些类型）\
模板内联\
const char*my_type_id（）\
{                                       \
返回#某个#类型\
}
寄存器类型（int）
寄存器类型（标准：：字符串）
int main（）
{
//显示“int”
难道你不能使用
BOOST\u CLASS\u EXPORT\u GUID
或类似的东西吗

BOOST_CLASS_EXPORT_GUID(IncomingTradeMessage, "IncomingTradeMessage")
...

由于传输的是字符串而不是整数，因此它将使用更多的带宽，但它将解决您的问题

有关更多信息，请参阅和

编辑：

这很好：

#include <fstream>
#include <boost/serialization/export.hpp>
#include <boost/archive/text_oarchive.hpp>

class Foo {
    friend class boost::serialization::access;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & dummy1;
    }

    int dummy1;

public:
    virtual ~Foo() {}
};

class Bar : public Foo {
    friend class boost::serialization::access;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // serialize base class information
        ar & boost::serialization::base_object<Foo>(*this);
        ar & dummy2;
    }

    int dummy2;
};

BOOST_CLASS_EXPORT_GUID(Foo, "Foo")
BOOST_CLASS_EXPORT_GUID(Bar, "Bar")

int main(int argc, char *argv[]) {
    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);
    Foo *f = new Bar;
    oa << f;

    return 0;
}

#包括
#包括
#包括
福班{
好友类boost:：serialization:：access；
模板
无效序列化（存档和ar，常量未签名整数版本）
{
ar&dummy1；
}
int-dummy1；
公众：
虚拟~Foo（）{}
};
分类栏：公共食品{
好友类boost:：serialization:：access；
模板
无效序列化（存档和ar，常量未签名整数版本）
{
//序列化基类信息
ar&boost:：serialization:：base_对象（*this）；
ar&dummy2；
}
int-dummy2；
};
BOOST\u CLASS\u EXPORT\u GUID（Foo，“Foo”）
BOOST_CLASS_EXPORT_GUID（Bar，“Bar”）
int main（int argc，char*argv[]）{
std：：ofs流（“文件名”）；
boost:：archive:：text\u oarchive oa（ofs）；
Foo*f=新条；
OA为什么你需要这么做？我用它来在C++和C++之间（TCP）进行通信，我希望这个属性不依赖于存档看到的顺序。classes@Hellfrost：您能更具体一点吗？它会产生什么错误？您使用的是什么Boost版本和编译器？我更新了我的答案以包含一个工作示例（它编译，我测试过）。
BOOST_CLASS_EXPORT_GUID(IncomingTradeMessage, "IncomingTradeMessage")
...

#include <fstream>
#include <boost/serialization/export.hpp>
#include <boost/archive/text_oarchive.hpp>

class Foo {
    friend class boost::serialization::access;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & dummy1;
    }

    int dummy1;

public:
    virtual ~Foo() {}
};

class Bar : public Foo {
    friend class boost::serialization::access;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // serialize base class information
        ar & boost::serialization::base_object<Foo>(*this);
        ar & dummy2;
    }

    int dummy2;
};

BOOST_CLASS_EXPORT_GUID(Foo, "Foo")
BOOST_CLASS_EXPORT_GUID(Bar, "Bar")

int main(int argc, char *argv[]) {
    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);
    Foo *f = new Bar;
    oa << f;

    return 0;
}