为什么我会得到“双重自由或腐败”？

Question

我正在尝试序列化一个结构，但程序崩溃了：

*** glibc detected *** ./unserialization: double free or corruption (fasttop): 0x0000000000cf8010 ***

---

#include <iostream>
#include <cstdlib>
#include <cstring>

struct Dummy
{
    std::string name;
    double height;
};

template<typename T>
class Serialization
{
    public:
        static unsigned char* toArray (T & t)
        {
            unsigned char *buffer = new unsigned char [ sizeof (T) ];
            memcpy ( buffer , &t , sizeof (T) );
            return buffer;
        };

        static T fromArray ( unsigned char *buffer )
        {
            T t;
            memcpy ( &t , buffer , sizeof (T) );
            return t;
        };
};

int main ( int argc , char **argv ) 
{
    Dummy human;
    human.name = "Someone";
    human.height = 11.333;

    unsigned char *buffer = Serialization<Dummy>::toArray (human);

    Dummy dummy = Serialization<Dummy>::fromArray (buffer);

    std::cout << "Name:" << dummy.name << "\n" << "Height:" << dummy.height << std::endl;

    delete buffer;

    return 0;
}

Answer 1

我发现此代码有两个问题：

1. 您通过将包含 std::string 的 struct 的 memcpy 转换为另一个来调用未定义的行为地点。如果您 memcpy 一个不仅仅是纯结构的类（例如 std::string），它可能会导致各种问题。在这种特殊情况下，我认为部分问题可能是 std::string 有时存储一个指向包含字符串实际内容的字符缓冲区的内部指针。如果您memcpy std::string，您就绕过了字符串的普通复制构造函数，该构造函数会复制该字符串。相反，您现在有两个不同的 std::string 实例共享一个指针，因此当它们被销毁时，它们都会尝试删除字符缓冲区，从而导致您看到的错误。除了不做你正在做的事情之外，没有简单的解决办法。这从根本上来说是不安全的。

2. 您正在使用new[]分配内存，但使用delete删除它。您应该使用数组删除运算符delete[]来删除此内存，因为对其使用常规delete将导致未定义的行为，可能导致此崩溃。

希望这有帮助！

Answer 2

将 memcpy() 与 std::string 类型的数据元素（或者实际上任何非 POD 数据类型）。 std::string 类将实际字符串数据存储在动态分配的缓冲区中。当您memcpy()周围的std::string内容时，您正在删除内部分配的指针并最终访问已经释放的内存。

您可以通过将声明更改为来使代码正常工作：

struct Dummy
{
    char name[100];
    double height;
};

但是，这具有固定大小 name 缓冲区的缺点。如果您想维护动态大小的 name，那么您将需要一个更复杂的 toArray 和 fromArray 实现，这些实现不能直接执行记忆副本。

Answer 3

您将在 toArray 调用中复制 string 的内部缓冲区。当使用 fromArray 反序列化时，您在 dummy 中“创建”第二个字符串，它认为它拥有与 human 相同的缓冲区。

Answer 4

std::string 可能包含一个指向包含字符串数据的缓冲区的指针。当您调用 toArray ( human) 时，您正在 memcpy() 处理 Dummy 类的字符串，包括指向字符串数据的指针。然后，当您通过直接 memcpy() 创建一个新的虚拟对象时，您就创建了一个新的字符串对象，该对象具有与第一个对象相同的指向字符串数据的指针。接下来你知道，dummy 被破坏，指针的副本被破坏，然后 human 被破坏，然后 BAM，你得到了双重释放。

一般来说，像这样使用 memcpy 复制对象会导致各种各样的问题，就像您所看到的那样。这可能只是冰山一角。相反，您可能会考虑为要序列化的每个类显式实现某种编组函数。

或者，您可以查看 C++ 的 json 库，它可以将事物序列化为方便的基于文本的格式。 JSON 协议通常与您想要序列化对象以通过套接字发送的自定义网络协议一起使用。