我不是C++专家，但之前已经几次序列化过东西。不幸的是，这一次我试图序列化一个包含 std::string 的类，这个类似乎就像序列化一个指针。
我可以把这个类写入文件并读回来。所有的 int 字段都没问题，但是 std::string 字段会出现“地址越界”的错误，可能是因为它指向的数据不再存在。
有没有标准的解决办法？我不想回到使用 char 数组，但至少我知道在这种情况下它们是有效的。如果需要，我可以提供代码，但我希望我已经清楚地解释了我的问题。
我通过将该类转换为 char* 并使用 std::fstream 将其写入文件来进行序列化。当然，读取也是反过来的。
我通过将类强制转换为char*并使用fstream将其写入文件来进行序列化，然后反向读取。但是如果涉及到指针，这种方法就不起作用了。你可能希望给你的类添加
void MyClass::serialize(std::ostream)和void MyClass::deserialize(std::ifstream)方法，并调用它们。对于这种情况，你需要
std::ostream& MyClass::serialize(std::ostream &out) const {
out << height;
out << ',' //number seperator
out << width;
out << ',' //number seperator
out << name.size(); //serialize size of string
out << ',' //number seperator
out << name; //serialize characters of string
return out;
}
std::istream& MyClass::deserialize(std::istream &in) {
if (in) {
int len=0;
char comma;
in >> height;
in >> comma; //read in the seperator
in >> width;
in >> comma; //read in the seperator
in >> len; //deserialize size of string
in >> comma; //read in the seperator
if (in && len) {
std::vector<char> tmp(len);
in.read(tmp.data() , len); //deserialize characters of string
name.assign(tmp.data(), len);
}
}
return in;
}
您可能还想重载流运算符以便更轻松地使用。
std::ostream &operator<<(std::ostream& out, const MyClass &obj)
{obj.serialize(out); return out;}
std::istream &operator>>(std::istream& in, MyClass &obj)
{obj.deserialize(in); return in;}
in.read(&name[0], len); 这肯定是错误的。你不能把一个字符串当作向量来处理。即使作为向量，如果len == 0，它也会失败。 - johnc_str()写入将会创建问题，因为会写入较少的字符。您应该循环遍历字符串并编写正确数量的字符，或者如果想要在第一个NUL之后丢弃字符，则应编写strlen(c_str())而不是size。如果在字符串中存储了NUL，则编写size和c_str将使您读取损坏的数据。 - 6502将对象的二进制内容直接写入文件不仅不可移植，而且正如您所认识到的那样，对于指针数据也行不通。你基本上有两个选择：要么编写一个真正的序列化库，通过例如使用c_str()输出实际字符串到文件中来正确处理std::strings，要么使用出色的boost序列化库。如果可能的话，我建议使用后者，然后可以像这样使用简单的代码进行序列化：
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/string.hpp>
class A {
private:
std::string s;
public:
template<class Archive>
void serialize(Archive& ar, const unsigned int version)
{
ar & s;
}
};
这里的serialize函数可用于将数据进行序列化或反序列化处理，具体取决于你如何调用它。请查看文档以获取更多信息。
对于可变大小的字符串或其他二进制数据，最简单的序列化方法是先序列化大小（如序列化整数一样），然后将内容复制到输出流中。
在读取时，您首先读取大小，然后分配字符串，最后通过从流中读取正确数量的字节来填充它。
另一种选择是使用定界符和转义，但需要更多代码，并且在序列化和反序列化方面都较慢（但结果可以保持易于阅读）。
string），则必须使用比将类强制转换为char*并将其写入文件更复杂的序列化方法。您关于为什么出现分段错误的正确。fstream并从中读取数据，以及一个反向函数，它将接受一个fstream并将其内容写入文件以便稍后恢复，就像这样：class MyClass {
pubic:
MyClass() : str() { }
void serialize(ostream& out) {
out << str;
}
void restore(istream& in) {
in >> str;
}
string& data() const { return str; }
private:
string str;
};
MyClass c;
c.serialize(output);
// later
c.restore(input);
您还可以定义operator<<和operator>>来与istream和ostream一起使用，以便序列化和恢复您的类，如果您想要这种语法糖。
(i|o)stream 的 operator<< 和 >>，用于将 string 的内容写入文件。显然，你可能有多个数据成员，所以只需将它们全部写入输出文件，然后按照相同的顺序从输入文件中读取即可。 - Seth Carnegie/*!
* reads binary data into the string.
* @status : OK.
*/
class UReadBinaryString
{
static std::string read(std::istream &is, uint32_t size)
{
std::string returnStr;
if(size > 0)
{
CWrapPtr<char> buff(new char[size]); // custom smart pointer
is.read(reinterpret_cast<char*>(buff.m_obj), size);
returnStr.assign(buff.m_obj, size);
}
return returnStr;
}
};
class objHeader
{
public:
std::string m_ID;
// serialize
std::ostream &operator << (std::ostream &os)
{
uint32_t size = (m_ID.length());
os.write(reinterpret_cast<char*>(&size), sizeof(uint32_t));
os.write(m_ID.c_str(), size);
return os;
}
// de-serialize
std::istream &operator >> (std::istream &is)
{
uint32_t size;
is.read(reinterpret_cast<char*>(&size), sizeof(uint32_t));
m_ID = UReadBinaryString::read(is, size);
return is;
}
};
std::ofstream ofs;
...
ofs << my_str;
然后：
std::ifstream ifs;
...
ifs >> my_str;
char *一起使用。 - Oliver Charlesworth我已经很久没写C++了，但也许你可以将一个char数组序列化。
然后，当你打开文件时，你的string就只需指向该数组。
仅供参考。
writev函数(http://linux.die.net/man/2/writev)，以便一次性写入所有内容。 - RocketR