为什么“在一个库中分配而在另一个库中释放”是错误的

Question

谷歌在Android ndk guides site写道：

在一个库中分配内存，在另一个库中释放，导致内存泄漏或堆损坏。

1. 为什么？
2. 总是正确的？

编辑

正如@Galik 所写，这句话的上下文是：

在 C++ 中，在单个程序中定义多个相同函数或对象的副本是不安全的。这是 C++ 标准中存在的单一定义规则的一个方面。

当使用静态运行时（以及一般的静态库）时，很容易意外违反此规则。例如，以下应用程序违反了此规则：

...

在这种情况下，STL，包括全局数据和静态构造函数，将出现在两个库中。这个应用程序的运行时行为是未定义的，在实践中崩溃是很常见的。其他可能的问题包括：

• 在一个库中分配内存，在另一个库中释放，导致内存泄漏或堆损坏。
• libfoo.so 中引发的异常在 libbar.so 中未被捕获，导致您的应用崩溃。
• std::cout 的缓冲无法正常工作。

Answer 1

将其视为错误的一个可能原因是，分配通常伴随着某种初始化，而释放则伴随着一些破坏逻辑。

---

理论：

主要的危险是初始化/销毁逻辑不匹配。

让我们将两个不同的 STL 版本视为两个不同且独立的库。

考虑一下：每个库都允许您分配/取消分配某些东西。在获取资源后，每个图书馆都以自己的方式对那个东西进行一些内务处理，这些内容被封装（阅读：你不知道，也不需要）。 如果每个人做的家务有很大不同会怎样？

---

示例：

class Foo
{
private:
    int x;

public:
    Foo() : x(42) {}
};


namespace ModuleA
{
    Foo* createAFoo()
    {
        return new Foo();
    }

    void deleteAFoo(Foo* foo)
    {
        if(foo != nullptr)
            delete foo;
    }
}

namespace ModuleB
{
    std::vector<Foo*> all_foos;

    Foo* createAFoo()
    {
        Foo* foo = new Foo();
        all_foos.push_back(foo);
        return foo;
    }

    void deleteAFoo(Foo* foo)
    {
        if(foo != nullptr)
        {
            std::vector<int>::iterator position = std::find(all_foos.begin(), all_foos.end(), foo);
            if (position != myVector.end())
            {
                myVector.erase(position);
            }
            delete foo;
        }
    }
}

---

问题：如果我们执行以下操作会发生什么？

Foo* foo = ModuleB::createAFoo();
ModuleA::deleteAFoo(foo);

答案：ModuleB 现在有一个dangling pointer。 这可能会导致各种可怕且难以调试的问题。 我们也没有让all_foos 变小，这可能被认为是内存泄漏（每次指针的大小）。

---

问题：如果我们执行以下操作会发生什么？

Foo* foo = ModuleA::createAFoo();
ModuleB::deleteAFoo(foo);

Answer: 看起来……没有什么不好的事情发生！ 但是如果我删除了if (position != myVector.end()) 支票呢？那我们就有问题了。 STL 可能会以优化的名义这样做，所以...

Answer 2

我写了文档的那一部分。我不得不调试一个问题，其中一个标准流对象（cout 或类似的）被双重链接到库，导致对象的两个不同实例。对象的构造函数运行了两次，但在对象的同一个实例上运行了两次。一个对象被双重初始化，另一个未初始化。当使用未构造的对象时，它会尝试访问一些未初始化的内存并崩溃。

对于未定义行为的奇异性确实没有限制。我记得的错误完全有可能是我们当时使用的编译器、链接器或加载器版本所独有的。

编辑：这是一个复制案例：

// foo.cpp
#include <stdio.h>

class Foo {
 public:
  Foo() { printf("this: %p\n", this); }
};

Foo foo;

// main.cpp
int main() {
}

构建：

$ clang++ --version
clang version 7.0.0 (trunk 330210)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /usr/local/bin
$ clang++ foo.cpp -shared -o libfoo.so
$ clang++ foo.cpp -shared -o libbar.so
$ clang++ main.cpp -L. -lfoo -lbar -rpath  '$ORIGIN'

libfoo 和 libbar 都将被加载，并且每个都有自己的对象副本。构造函数将运行两次，但正如您所见，只有一个对象实例运行其构造函数；它只运行了两次。

$ ./a.out
this: 0x7f9475d48031
this: 0x7f9475d48031