有没有可能在 C + + 中序列化和反序列化一个类？

如果你想要简单和最好的性能，不关心向后的数据兼容性，试试 HPS，它是轻量级的，比 Boost 等更快，比 Protobuf 等更容易使用。

例如:

std::vector<int> data({22, 333, -4444});
std::string serialized = hps::serialize_to_string(data);
auto parsed = hps::parse_from_string<std::vector<int>>(serialized);

下面是一个简单的序列化程序库，它只有头文件，c11和 有序列化基本类型的示例。

Https://github.com/goblinhack/simple-c-plus-plus-serializer

#include "c_plus_plus_serializer.h"


class Custom {
public:
int a;
std::string b;
std::vector c;


friend std::ostream& operator<<(std::ostream &out,
Bits my)
{
out << bits(my.t.a) << bits(my.t.b) << bits(my.t.c);
return (out);
}


friend std::istream& operator>>(std::istream &in,
Bits my)
{
in >> bits(my.t.a) >> bits(my.t.b) >> bits(my.t.c);
return (in);
}


friend std::ostream& operator<<(std::ostream &out,
class Custom &my)
{
out << "a:" << my.a << " b:" << my.b;


out << " c:[" << my.c.size() << " elems]:";
for (auto v : my.c) {
out << v << " ";
}
out << std::endl;


return (out);
}
};


static void save_map_key_string_value_custom (const std::string filename)
{
std::cout << "save to " << filename << std::endl;
std::ofstream out(filename, std::ios::binary );


std::map< std::string, class Custom > m;


auto c1 = Custom();
c1.a = 1;
c1.b = "hello";
std::initializer_list L1 = {"vec-elem1", "vec-elem2"};
std::vector l1(L1);
c1.c = l1;


auto c2 = Custom();
c2.a = 2;
c2.b = "there";
std::initializer_list L2 = {"vec-elem3", "vec-elem4"};
std::vector l2(L2);
c2.c = l2;


m.insert(std::make_pair(std::string("key1"), c1));
m.insert(std::make_pair(std::string("key2"), c2));


out << bits(m);
}


static void load_map_key_string_value_custom (const std::string filename)
{
std::cout << "read from " << filename << std::endl;
std::ifstream in(filename);


std::map< std::string, class Custom > m;


in >> bits(m);
std::cout << std::endl;


std::cout << "m = " << m.size() << " list-elems { " << std::endl;
for (auto i : m) {
std::cout << "    [" << i.first << "] = " << i.second;
}
std::cout << "}" << std::endl;
}


void map_custom_class_example (void)
{
std::cout << "map key string, value class" << std::endl;
std::cout << "============================" << std::endl;
save_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
load_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
std::cout << std::endl;
}

产出:

map key string, value class
============================
save to map_of_custom_class.bin
read from map_of_custom_class.bin


m = 2 list-elems {
[key1] = a:1 b:hello c:[2 elems]:vec-elem1 vec-elem2
[key2] = a:2 b:there c:[2 elems]:vec-elem3 vec-elem4
}

我使用以下模板来实现序列化:

template <class T, class Mode = void> struct Serializer
{
template <class OutputCharIterator>
static void serializeImpl(const T &object, OutputCharIterator &&it)
{
object.template serializeThis<Mode>(it);
}


template <class InputCharIterator>
static T deserializeImpl(InputCharIterator &&it, InputCharIterator &&end)
{
return T::template deserializeFrom<Mode>(it, end);
}
};


template <class Mode = void, class T, class OutputCharIterator>
void serialize(const T &object, OutputCharIterator &&it)
{
Serializer<T, Mode>::serializeImpl(object, it);
}


template <class T, class Mode = void, class InputCharIterator>
T deserialize(InputCharIterator &&it, InputCharIterator &&end)
{
return Serializer<T, Mode>::deserializeImpl(it, end);
}


template <class Mode = void, class T, class InputCharIterator>
void deserialize(T &result, InputCharIterator &&it, InputCharIterator &&end)
{
result = Serializer<T, Mode>::deserializeImpl(it, end);
}

这里的 T是你想序列化的类型 Mode是一个用来区分不同类型序列化的虚拟类型，例如同一个整数可以被序列化为小端点、大端点、变量等等。

默认情况下，Serializer将任务委托给正在序列化的对象。对于内置类型，您应该为 Serializer制作一个模板专门化。

还提供了方便的函数模板。

例如，无符号整数的小端序列化:

struct LittleEndianMode
{
};


template <class T>
struct Serializer<
T, std::enable_if_t<std::is_unsigned<T>::value, LittleEndianMode>>
{
template <class InputCharIterator>
static T deserializeImpl(InputCharIterator &&it, InputCharIterator &&end)
{
T res = 0;


for (size_t i = 0; i < sizeof(T); i++)
{
if (it == end) break;
res |= static_cast<T>(*it) << (CHAR_BIT * i);
it++;
}


return res;
}


template <class OutputCharIterator>
static void serializeImpl(T number, OutputCharIterator &&it)
{
for (size_t i = 0; i < sizeof(T); i++)
{
*it = (number >> (CHAR_BIT * i)) & 0xFF;
it++;
}
}
};

然后连载:

std::vector<char> serialized;
uint32_t val = 42;
serialize<LittleEndianMode>(val, std::back_inserter(serialized));

反序列化:

uint32_t val;
deserialize(val, serialized.begin(), serialized.end());

由于抽象迭代器逻辑，它应该与任何迭代器(如流迭代器) ，指针等工作。

C + + 14(推荐 C + + 17)

• 没有宏
• 没有需要显式编写的代码

小样