用C++中的指针序列化类

第一：在类中使用std:：string，从长远来看，它会让你的生活变得更轻松。

但这个建议对std:：string和char*都有效（需要一些明显的小调整）。

基本上，您希望序列化未知大小的数据（在编译时）。这意味着当您对数据进行去串行化时，您必须有一种技术来告诉数据的长度（在对象前面加一个大小），或者有一种方法来找到数据的结尾（终止标记）。

终止标记更易于序列化。但反序列化更难（因为您必须向前寻找结尾）。此外，您必须转义对象中出现的任何终止标记，并且反序列化必须知道转义并将其删除

因此，由于这种并发症，我宁愿不使用终止标记。因此，我在对象前面加了一个大小。这样做的代价是，我必须以一种不会破坏的方式对对象的大小进行编码。

因此，如果我们在一个对象前面加上它的大小，你可以这样做：

// Place a ':' between the string and the size.
// There must be a marker as >> will continue reading if
// fname contains a digit as its first character.
// I don;t like using a space as >> skips spaces if you are not carefull
// and it is hard to tell the start of the string if the first characters in fname
// are the space character.
std::cout << strlen(fname) << ":" << fname;

然后你可以像这样反序列化：

size_t size;
char   mark;
std::cint >> size >> mark;
if (!std::cin || mark != ':')
{    throw BadDataException;
}
result = new char[size+1]();  // Note the () to zero fill the array.
std::cin.read(result, size)

编辑1（基于注释）更新：与字符串一起使用：

size_t size;
char   mark;
std::cint >> size >> mark;
if (!std::cin || mark != ':')
{    throw BadDataException;
}
std::string  result(' ', size);  // Initialize string with enough space.
std::cin.read(&result[0], size)  // Just read directly into the string

编辑2（基于评论）

序列化字符串的Helper函数

struct StringSerializer
{
    std::string&    value;
    StringSerializer(std::string const& v):value(const_cast<std::string&>(v)){}
    friend std::ostream& operator<<(std::ostream& stream, StringSerializer const& data)
    {
        stream << data.value.size() << ':' << data.value;
    }
    friend std::istream& operator>>(std::istream& stream, StringSerializer const& data)
    {
        std::size_t size;
        char        mark(' ');
        stream >> size >> mark;
        if (!stream || mark != ':')
        {    stream.setstate(std::ios::badbit);
             return stream;
        }
        data.value.resize(size);
        stream.read(&data.value[0], size);
    }
};

序列化个人

std::ostream& operator<<(std::ostream& stream, Person const& data)
{
    return stream << StringSerializer(data.fname) << " "
                  << StringSerializer(data.lname) << " "
                  << data.age                     << "n";
}
std::istream& operator>>(std::istream& stream, Person& data)
{
    stream    >> StringSerializer(data.fname)
              >> StringSerializer(data.lname)
              >> data.age;
    std::string line;
    std::getline(stream, line);
    if (!line.empty())
    {    stream.setstate(std::ios::badbit);
    }
    return stream;
}

用法：

int main()
{
    Person p;
    std::cin  >> p;
    std::cout << p;
    std::ofstream  f("data");
    f << p;
}

不能序列化指针，需要序列化指向.的数据指针

您需要序列化整个对象网络，从Person（或Game）开始，并查看每个对象，从您的起始对象可以访问这些对象。

反序列化时，您从存储中读取数据，为该数据分配内存，并将此新分配的内存的地址用作Person/Game对象的成员

指针字段使它更难序列化，但也不是不可能序列化。如果您不想使用任何序列化库，下面是您可以做到的方法

您应该在序列化时确定所指向对象的大小（例如，它可能是固定大小的，也可能是末尾带有null字符的C字符串），然后您可以保存一个标记，指示您正在序列化一个间接对象以及所指向区域的大小和实际内容。

当您在反序列化过程中偶然发现该标记时，可以分配适当数量的内存，将对象复制到其中，并将指针存储到反序列化对象中的区域。

我建议使用向量来封装序列化。

#include <vector>
using namespace std;
map vector<unsigned char> cbuff;
inline cbuff vchFromString(const std::string &str) {
unsigned char *strbeg = (unsigned char*) str.c_str();
  return cbuff(strbeg, strbeg + str.size());
}
inline std::string stringFromVch(const cbuff &vch) {
 std::string res;
 std::vector<unsigned char>::const_iterator vi = vch.begin();
 while (vi != vch.end()) {
  res += (char) (*vi);
  vi++;
 }
 return res;
}
class Example
{
  cbuff label;
  Example(string labelIn)
  {
    SetLabel(labelIn);
  }
  IMPLEMENT_SERIALIZE
  (
    READWRITE(label);
  )
  void SetLabel(string labelIn)
  {
    label = vchFromString(labelIn);
  }
  string GetLabel()
  {
    return (stringFromVch(label));
  }
};