Question

我有这个类我要序列化:(私人attr's）

class Task {
    public:
        enum Status { COMPLETED, PENDIENT };
        // GETTERS SETTERS... 
        // UTILS
        const std::ostream& storeTask( std::ostream &stream );
        const std::istream& retrieveTask( std::istream &stream );
private:
        void setID();
        static int sCount;
        int id;
        std::string text;
        Status status;
        tm timestamp;
};

正如您所看到的，我正试图通过实施我定义的storeTask和retrieveTask方法来实现这一目标：

// SERIALIZATION
const std::ostream& Task::storeTask( std::ostream &stream ) {
  stream.write((char *) &id, sizeof(int));
  stream.write((char *) text.c_str(), sizeof(text.length()));
  stream.write((char *) &status, sizeof(Status));
  stream.write((char *) &timestamp, sizeof(tm));
  return stream;
}
const std::istream& Task::retrieveTask( std::istream &stream ) {
  stream.read((char *) &id, sizeof(int));
  stream.read((char *) text.c_str(), sizeof(text.length()));
  stream.read((char *) &status, sizeof(Status));
  stream.read((char *) &timestamp, sizeof(tm));
  return stream;
}

我正在通过创建2个Task对象的向量来测试实现，使用他们的storeTask方法编写它们，然后创建包含2个不同Task的另一个Task向量，并尝试将Task向量的值重新加载到第二个向量

使用这两个任务编写二进制文件似乎工作正常，但是再次读取它时，它只获取文本字符串的4个第一个字符。

int main() {
        std::vector<Task> myTasks;
        Task task1("First Task");
        Task task2("Second Task");
        myTasks.push_back(task1);
        myTasks.push_back(task2);

        std::vector<Task> myTasks2;
        Task task3("Task num1");
        Task task4("Task num2");
        myTasks2.push_back(task3);
        myTasks2.push_back(task4);

        writeTasks(myTasks);
        readTasks(myTasks2);

    return 0;
}

void writeTasks(std::vector<Task> aTasks) {
        std::fstream fileStream("fileStream", std::ios::out | std::ios::binary);
        for ( int x = 0; x < aTasks.size(); x++ ) {
            std::cout << "Storing: " << aTasks[x].getText() << "\n";
            aTasks[x].storeTask(fileStream);
        }
        fileStream.close();
}
void readTasks(std::vector<Task> aTasks) {
        std::fstream fileStream;
        fileStream.open("fileStream", std::ios::in | std::ios::binary);
        for ( int x = 0; x < aTasks.size(); x++ ) {
            std::cout << "Retrieving " << aTasks[x].getText();
            aTasks[x].retrieveTask(fileStream);
            std::cout << " as --> " << aTasks[x].getText() << " - " << aTasks[x].getTime() << "\n";
        }
        fileStream.close();
}

然后返回：

Storing: First Task
Storing: Second Task
Retrieving Task num1 as --> Firs num1 - 01:02:26
Retrieving Task num2 as --> Seco num2 - 01:02:26

何时返回：

Storing: First Task
Storing: Second Task
Retrieving Task num1 as --> First Task - 01:02:26
Retrieving Task num2 as --> Second Task - 01:02:26

有什么想法吗？不知道问题是写二进制序列化还是读取它... 其他值，如时间，日期似乎工作正常。

当text.c_str()返回const char *时，我声明了一个从字符串转换为char *的小函数：

char * str_to_char(std::string s) {
    char *a=new char[s.size()+1];
    a[s.size()]=0;
    memcpy(a,s.c_str(),s.size());
    return a;
}

在retireveTask方法中尝试了这个：

stream.read(str_to_char(text), text.size() + 1);

但得到了：

Storing: First Task
Storing: Second Task
Retrieving Task num1 as --> Task num1 - 589824:524288:131072
Retrieving Task num2 as --> Task num2 - 112:09:08

Answer 1

您有两个主要问题：

写作时写sizeof(text.length()))。 sizeof运算符返回std::string::size_type返回的text.length()大小（通常为4或8个字节）。仅使用text.length()。
阅读时，您尝试读取直接放入字符串的文本。这绝对不会起作用，因为甚至可能没有分配实际字符串，或者没有分配足够的空间。我会说你很幸运，你设法阅读了一些东西，你的程序也不会崩溃。

要序列化字符串（或任何可变大小的数据），您需要先存储字符串的长度，这样您就可以知道稍后要阅读的内容。

正确的序列化并不容易，我真的建议你研究Boost serialization来正确处理所有陌生和角落的情况。

C ++序列化只检索一半的字符串

1 个答案: