为何自定义C++11分配器的析构函数被调用两次？

嘿，这个问题在自定义C++分配器时真的很容易碰到，我来给你拆解清楚～

为什么析构函数会被调用两次？ #

这其实是符合C++标准的预期行为。像vector这类标准容器，在某些操作（比如扩容、构造临时容器实例、或者容器复制/移动）中，会内部创建分配器的副本。当这些临时的分配器实例生命周期结束时，就会触发析构函数。加上你原本创建的那个分配器实例，自然就会出现两次析构的情况。

对于无状态分配器来说，这根本不是问题——因为所有副本都是完全等价的，多次析构不会有任何副作用。但如果你的分配器是有状态的（比如持有一个动态分配的指针、文件句柄或者其他资源），第一次析构可能已经释放了资源，第二次析构就会出现解引用空指针、重复释放资源这类严重问题。

怎么规避这个问题？ #

根据你的分配器是否需要状态，有几种不同的解决思路：

1. 优先使用无状态分配器 #

这是最简单也最推荐的方案。如果你的分配器不需要保存任何状态（比如只是封装了malloc/free），那所有分配器实例都是等价的，多次析构完全不会有问题。标准库的std::allocator就是无状态的典型例子。

2. 调整分配器的「传播特性」 #

C++11开始允许我们通过定义三个类型别名，控制容器在复制/移动/交换时是否复制分配器：

• propagate_on_container_copy_assignment
• propagate_on_container_move_assignment
• propagate_on_container_swap

把它们设为std::false_type，容器就不会在这些操作中复制分配器，而是复用原来的实例，从而减少析构次数。举个例子：

#include <iostream>
#include <vector>
#include <memory>

template <typename T>
class MyAllocator {
public:
    using value_type = T;

    // 告诉容器：操作时不要复制分配器
    using propagate_on_container_copy_assignment = std::false_type;
    using propagate_on_container_move_assignment = std::false_type;
    using propagate_on_container_swap = std::false_type;

    MyAllocator() { std::cout << "Allocator constructed\n"; }
    ~MyAllocator() { std::cout << "Allocator destructed\n"; }

    // 分配内存的核心方法
    T* allocate(std::size_t n) {
        return static_cast<T*>(std::malloc(n * sizeof(T)));
    }

    // 释放内存的核心方法
    void deallocate(T* p, std::size_t) {
        std::free(p);
    }
};

// 无状态分配器的等价性判断：所有实例都等价
template <typename T, typename U>
bool operator==(const MyAllocator<T>&, const MyAllocator<U>&) { return true; }

template <typename T, typename U>
bool operator!=(const MyAllocator<T>&, const MyAllocator<U>&) { return false; }

// 测试代码
int main() {
    std::vector<int, MyAllocator<int>> vec;
    vec.push_back(1);
    vec.push_back(2);
    return 0;
}

这样调整后，你会发现析构次数明显减少，因为容器不会再创建多余的分配器副本了。

3. 用共享状态管理有状态分配器 #

如果你的分配器必须持有状态，那可以把状态放在动态内存中，用std::shared_ptr来管理。这样即使多个分配器实例被析构，只有当最后一个实例销毁时，才会真正释放状态资源，避免空指针问题。例子如下：

#include <iostream>
#include <vector>
#include <memory>

template <typename T>
class StatefulAllocator {
public:
    using value_type = T;

    // 定义分配器的状态
    struct AllocatorState {
        int resource_id;
        AllocatorState() : resource_id(42) {
            std::cout << "State created, ID: " << resource_id << "\n";
        }
        ~AllocatorState() {
            std::cout << "State destroyed, ID: " << resource_id << "\n";
        }
    };

    // 用shared_ptr共享状态
    std::shared_ptr<AllocatorState> state;

    StatefulAllocator() : state(std::make_shared<AllocatorState>()) {
        std::cout << "Allocator constructed\n";
    }

    // 复制构造函数：共享同一个状态
    StatefulAllocator(const StatefulAllocator& other) : state(other.state) {
        std::cout << "Allocator copied (shared state)\n";
    }

    ~StatefulAllocator() {
        std::cout << "Allocator destructed\n";
    }

    T* allocate(std::size_t n) {
        return static_cast<T*>(std::malloc(n * sizeof(T)));
    }

    void deallocate(T* p, std::size_t) {
        std::free(p);
    }
};

// 等价性判断：状态相同则分配器等价
template <typename T, typename U>
bool operator==(const StatefulAllocator<T>& a, const StatefulAllocator<U>& b) {
    return a.state == b.state;
}

template <typename T, typename U>
bool operator!=(const StatefulAllocator<T>& a, const StatefulAllocator<U>& b) {
    return !(a == b);
}

// 测试代码
int main() {
    std::vector<int, StatefulAllocator<int>> vec;
    vec.push_back(1);
    vec.push_back(2);
    return 0;
}

运行这段代码你会看到：即使分配器被析构两次，状态只会在最后一次析构时被销毁，完全不会出现资源重复释放的问题。

内容的提问来源于stack exchange，提问作者Robert