C ++池分配器程序仅在控制台关闭时崩溃

Question

我正在看这个pool allocator实现。我实际上修改了一下，我的完整代码是：

template <class T, size_t T_per_page = 200>
class PoolAllocator
{
    private:
        const size_t pool_size = T_per_page * sizeof(T);
        std::vector<T *> pools;
        size_t count;
        size_t next_pos;

        void alloc_pool() {
            next_pos = 0;
            void *temp = operator new(pool_size);
            pools.push_back(static_cast<T *>(temp));
        }
    public:
        PoolAllocator() {
            count = 0;
            alloc_pool();
        }

        void* allocate() {
            if (next_pos == T_per_page)
                alloc_pool();

            void* ret = pools.back() + next_pos;
            ++next_pos;
            ++count;
            return ret;
        }

        size_t getSize() const
        {
            return T_per_page * (pools.size() - 1) + next_pos;
        }

        size_t getCount() const
        {
            return count;
        }

        size_t getCapacity() const
        {
            return T_per_page * pools.size();
        }

        T* get(size_t index) const
        {
            if (index >= getCount()) { return NULL; }

            size_t poolIndex = index / T_per_page;
            return pools[poolIndex] + (index % T_per_page);
        }

        ~PoolAllocator() {
            std::cout << "POOL ALLOCATOR DESTRUCTOR CALLED" << std::endl;
            while (!pools.empty()) {
                T *p = pools.back();
                size_t start = T_per_page;
                if (pools.size() == 1){
                    start = next_pos;
                }

                std::cout << "start: " << start << std::endl;
                for (size_t pos = start; pos > 0; --pos)
                {
                    std::cout << "pos: " << pos << std::endl;
                    p[pos - 1].~T();
                }
                operator delete(static_cast<void *>(p));
                pools.pop_back();
            }
        }
};

template<class T>
PoolAllocator<T>& getAllocator()
{
    static PoolAllocator<T> allocator;
    return allocator;
}

class Node
{
    private:
        int id;
        std::vector<float> vertices;

    public:
        Node() : id(42)
        { 
            std::cout << "Node constructor called" << std::endl;
        }
        ~Node(){ std::cout << "Node destructor called" << std::endl; }

        void* operator new(size_t size)
        {
            std::cout << "Node operator new called" << std::endl;
            return getAllocator<Node>().allocate();
        }

        void operator delete(void*)
        {
            std::cout << "Node operator delete called" << std::endl;
        }
    };

int _tmain(int argc, _TCHAR* argv[])
{
    Node* n1 = new Node();
    Node* n2 = new Node();  
    Node* n3 = new Node();
    Node* n4 = new Node();

    std::cout << "Count: " << getAllocator<Node>().getCount() << " size: " << getAllocator<Node>().getSize() << " capacity: " << getAllocator<Node>().getCapacity() << std::endl;

    while (true){}

    return 0;
}

当我在visual studio中运行此代码时，它似乎正常工作，直到我关闭控制台，此时我收到访问冲突错误。我已经尝试在分配器上手动调用析构函数，它似乎工作正常但我必须在某处犯错。我得到的错误是：

谁能发现我犯错的地方？

编辑1：

经过进一步调查，即使没有新的Node线路，它仍然会崩溃。似乎与getAllocator（）方法有关，以及如何调用析构函数？或者分配器是静态的？

编辑2：

我实际上根本不认为它与我的分配器有任何关系！如果我尝试代码：

class Node2
{
    private:
        int x;
    public:
        Node2():x(42){std::cout << "Node2 constructor called" << std::endl;};
        Node2(const Node2& other){ std::cout << "Node2 copy constructor called" << std::endl; };
        ~Node2(){ std::cout << "Node2 destructor called" << std::endl; };
};

Node2& Test(){
    static Node2 myIndex;

    return myIndex;
}

int _tmain(int argc, _TCHAR* argv[])
{
    Test();

    while (true){}

    return 0;
}

它会导致同样的错误！情节变粗。我认为是编写自定义分配器的新手，分配器代码就是问题所在。仍然不确定为什么我的小代码发生了这个错误...

Answer 1

写一个答案因为我不能评论这个问题。

我在上一段代码中找不到任何明显的错误。您确定要编译正确的文件而不是旧的未保存版本吗？

您可以尝试删除该行

while (true){}

让程序正常结束。

此外，您可以尝试在调试模式下运行代码，单步执行指令以找到导致问题的代码。

Answer 2

我可以发现池分配器的一些问题。

1. PoolAllocator拥有资源，但既没有特殊的复制构造函数也没有赋值。很可能你应该声明删除它们。并提供move-constructor和move-assignment。虽然不是这个特定示例中的一个因素，但它可以保护您不会无意义地按值返回分配器。
2. 函数alloc_pool()在分配新块之前重置next_pos。如果operator new抛出异常，则会使池处于不一致状态。
3. 同样，pools.push_back()的一个例外是新的大块泄露。我相信std::vector<std::vector<std::byte>>会做得恰到好处，现代矢量是可移动的。但是如果你绝对想要使用原始指针的向量，你应该在pools中保留额外的空间，然后分配新的块，然后只调用push_back并修改状态。
4. PoolAllocator的构造函数可能没有任何理由抛出。因为allocate()方法无论如何都要调用alloc_pool()，为什么要在构造函数中调用它？只需将所有分配工作留给allocate()，就可以得到一个简单的noexcept构造函数。
5. PoolAllocator::allocate()和PoolAllocator::~PoolAllocator()不对称。前者返回没有初始化对象的原始内存，而后者假定在每个分配的插槽中都有正确构造的对象。这种假设是危险的，非常脆弱。想象一下，例如，T::T()投掷。
6. 似乎getSize（）和getCount（）总是返回相同的值。有意吗？
7. 析构函数将删除每个其他池中第一个池，next_pos和pools[0]对象中的T_per_page对象。但是它应该删除最后一个池中的next_pos对象。
8. 如果T:~T()从池的析构函数调用曾试图从同一个池中分配另一个对象，那么你就会遇到奇妙的错误。这种情况可能看起来很奇怪，但从技术上来说，它可能会发生。析构函数最好将池的当前状态交换为局部变量并对其进行处理。必要时重复。
9. main（）中的无限循环可能会破坏全局对象的破坏。编译器可能足够聪明，可以发现return无法访问并完全跳过破坏部分。
10. pool_size可能是一个静态成员。