使用重新诠释铸件来保存结构或类以文件

Question

这是教授在他的剧本中向我们展示的东西。我没有在我编写的任何代码中使用此方法。

基本上，我们参加一堂课或结构，然后retinterpret_ctect并保存整个结构：

struct Account
{
    Account()
    {   }
    Account(std::string one, std::string two)
        : login_(one), pass_(two)
    {   }

private:
    std::string login_;
    std::string pass_;
};

int main()
{
    Account *acc = new Account("Christian", "abc123");

    std::ofstream out("File.txt", std::ios::binary);
    out.write(reinterpret_cast<char*>(acc), sizeof(Account));
    out.close();

输出（在文件中）

ÍÍÍÍChristian ÍÍÍÍÍÍ              ÍÍÍÍabc123 ÍÍÍÍÍÍÍÍÍ     

这会产生我困惑的 。该方法实际上是否起作用，还是引起UB，因为在单个编译器的异想天开的类和结构中发生了神奇的事情？

Answer 1

它实际上行不通，但也不会引起不确定的行为。

在C ++中，将任何对象重新诠释为char的数组是合法的，因此这里没有未定义的行为。

但是，结果通常仅在类是POD（有效地，当类是简单的C风格结构）和独立的（即结构没有指针数据成员）的情况下才能使用。

在这里，帐户不是POD，因为它具有std :: String成员。 std :: String的内部已实现定义，但它不是POD，它通常具有指向存储实际字符串的某些堆积的块（在您的特定示例中，实现是使用小弦优化的，其中字符串的值存储在std :: String对象本身中）。

有一些问题：

• 您并不总是会获得期望的结果。如果您的字符串较长，则std :: String将使用在堆上分配的缓冲区存储字符串，因此您最终只会序列化指针，而不是尖头的字符串。<<<<<<<<<<<<<<<<< /p>

• 您实际上无法使用您在此处序列化的数据。您不能仅仅将数据重新解释为帐户并期望它可以正常工作，因为std :: String构造函数不会被调用。

简而言之，您不能使用此方法来序列化复杂的数据结构。

Answer 2

它不是不确定的。相反，它是平台依赖性或实现定义的行为。总的来说，这是因为同一编译器的不同版本，甚至是同一编译器上的不同开关都可以破坏您的保存文件格式。

Answer 3

这可以根据结构的内容以及数据回读的平台来起作用。这是一个有风险的，不可交付的黑客，您的老师不应该传播它。

您在结构中是否有指针或int？回读时，指针将在新过程中无效，并且int格式在所有计算机上都不相同（以这种方法为单位，而是两个令人震惊的问题）。任何指向对象图的一部分的内容都不会被处理。在目标计算机（32位与64位）上的结构包装可能有所不同，甚至可能是由于编译器选项在同一硬件上更改，从而使sizeof（account）不可靠，因为读取了返回数据大小。

有关更好的解决方案，请查看序列化库为您处理这些问题。 boost.serialization 是一个很好的例子。

在这里，我们使用“序列化”一词
表示可逆解构
一组任意的C ++数据
结构为一系列字节。
这样的系统可用于
重构等效结构
在另一个程序上下文中。取决于
在上下文中，这可能会使用
实施对象持久性，远程
参数传递或其他设施。

Google协议缓冲器也适用于简单的对象层次结构。

Answer 4

它不能代替适当的序列化。考虑任何包含指针的复杂类型的情况 - 如果将指针保存到文件中，则在以后加载它们时，它们不会指向任何有意义的东西。

此外，如果代码更改，或者即使使用不同的编译器选项重新编译，则可能会破坏。

因此，它实际上仅对于简单类型的短期存储才是有用的 - 在此过程中，它占用了比该任务所需的更多空间。

Answer 5

如果该方法完全有效，则远非强大。最好决定某些“串行”形式，无论是二进制，文本，XML等，并将其写出来。

这里的关键：您需要一个函数/代码来可靠地将类或结构转换为/从一系列字节中。 reinterpret_cast不执行此操作，因为用于代表类或结构的内存中的确切字节可以更改诸如填充，成员订单等之类的内容。

Answer 6

否。

为了使其正常工作，结构必须是一个POD（纯旧数据：只有简单的数据成员和POD数据成员，没有虚拟功能……可能是我不记得的其他一些限制）。

因此，如果您想这样做，则需要这样的结构：

struct Account {
    char login[20];
    char password[20];
};

请注意，STD :: String不是吊舱，因此您需要简单的数组。

尽管如此，对您来说不是一个好方法。关键字：“序列化” :)。

Answer 7

字符串的某些版本不实际使用动态内存，当字符串小时。因此，将字符串内部存储在字符串对象中。

想一想：

 struct SimpleString
 {
     char*    begin;        // beginning of string
     char*    end;          // end of string
     char*    allocEnd;     // end of allocated buffer end <= allocEnd
     int*     shareCount;   // String are usually copy on write
                            // as a result you need to track the number of people
                            // using this buffer
 };

现在在64位系统上。每个指针是8个字节。因此，小于32个字节的字符串可以适合相同的结构，而无需分配缓冲区。

 struct CompressedString
 {
     char buffer[sizeof(SimpleString)];
 };
 stuct OptString
 {
     int      type;        // Normal /Compressed
     union
     {
         SimpleString     simple;
         CompressedString compressed;
     }
 };

所以这就是我认为正在发生的事情。
正在使用一个非常有效的字符串实现，从而使您可以将对象倒入不用担心指针的情况下（因为STD :: String不使用指针）。

显然，这是不可移植的，因为这取决于STD :: String的实现详细信息。

如此有趣的技巧，但不能便携（并且在没有一些编译时间检查的情况下很容易破裂）。