如何防止在 boost::fast_pool_allocator 管理的对象上调用析构函数？

我想利用以下广告功能boost::fast_pool_allocator (see Boost Pool 的 Boost 文档):

例如，您可能会遇到这样的情况：您想要分配一个 一堆小物体在一个点上，然后到达你的一个点 不再需要它们的程序。使用池接口， 你可以选择运行它们的析构函数或者只是把他们扔进 遗忘...

(See here对于这个报价。）

关键短语是让他们被遗忘. I do not希望在这些对象上调用析构函数。

（原因是我有数百万个微小对象，它们在堆上形成了一个极其复杂的所有权网络，当单个最父对象离开堆栈时，我的程序需要大约 20 分钟才能调用所有析构函数。我不需要调用这些析构函数，因为没有期望的副作用，并且所有内存都包含在boost::pool.)

不幸的是，尽管上述文档做出了承诺，并且boost::pool概念，我找不到一种方法来阻止调用托管对象的析构函数。

该问题很容易在一个小示例程序中隔离：

class Obj
{
public:
    ~Obj()
    {
        // Placing a breakpoint here indicates that this is *always* reached
        // (except for the crash scenario discussed below)
        int m = 0;
    }
};

typedef std::map<int, Obj, std::less<int>,
                 boost::fast_pool_allocator<std::pair<int const, Obj>>>
        fast_int_to_int_map;

class Foo
{
public:
    ~Foo()
    {
        // When the following line is uncommented, the program CRASHES
        // when the destructor is exited - because the Obj destructors
        // are called on the invalid Obj ghost instances

        //boost::singleton_pool<boost::fast_pool_allocator_tag,
        //                  sizeof(std::pair<int const, Obj>)>::purge_memory();
    }

    fast_int_to_int_map mmap;
};

void mfoo()
{
    // When this function exits, the Foo instance goes off the stack
    // and its destructor is called, in turn calling the destructors
    // of the Obj instances - this is NOT desired!

    Foo foo;
    foo.mmap[0] = Obj();
    foo.mmap[1] = Obj();
}

int main()
{
    mfoo();

    // The following line deallocates the memory of the pool just fine -
    // but does nothing to prevent the destructors of the Obj instances
    // from being called

    boost::singleton_pool<boost::fast_pool_allocator_tag,
                          sizeof(std::pair<int const, Obj>)>::purge_memory();
}

正如代码注释中所述，析构函数Obj由管理的实例boost::pool总是被调用。

我该怎么做才能引用 Boost Pool 文档中的有希望的内容，drop them off into oblivion， 成真？

您将自定义分配器传递到您的std::map班级。所以，这个分配器将用于内部的所有内容std::map： 对全部Obj数据以及二叉树的节点std::map。结果，如果你打电话purge_memory() in Foo的析构函数，然后所有这些内存都变得无效，并且崩溃std::map析构函数。

您认为自定义分配器负责对象的解除分配的假设是不正确的：它是std::map的任务是释放所有对象。所以，~Obj()无论您传递自定义分配器还是使用默认分配器，都会被调用。

我没有看到你的问题有任何优雅的解决方案。但这种方法应该有效：

• use placement new创造Foo来自池内存的对象，
• 用这个Foo一如既往的对象，
• call purge_memory()从池中释放所有内存。没有析构函数~Obj or ~std::map将被调用。