为什么不从 std::allocator 继承

Question

我像这样创建了自己的分配器：

template<typename T>
class BasicAllocator
{
    public:
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T value_type;


        BasicAllocator() throw() {};
        BasicAllocator (const BasicAllocator& other) throw() {};

        template<typename U>
        BasicAllocator (const BasicAllocator<U>& other) throw() {};

        template<typename U>
        BasicAllocator& operator = (const BasicAllocator<U>& other) {return *this;}
        BasicAllocator<T>& operator = (const BasicAllocator& other) {return *this;}
        ~BasicAllocator() {}

        pointer address (reference value) const {return &value;}
        const_pointer address (const_reference value) const {return &value;}

        pointer allocate (size_type n, const void* hint = 0) {return static_cast<pointer> (::operator new (n * sizeof (value_type) ) );}
        void deallocate (void* ptr, size_type n) {::operator delete (static_cast<T*> (ptr) );}

        template<typename U, typename... Args>
        void construct (U* ptr, Args&&  ... args) {::new (static_cast<void*> (ptr) ) U (std::forward<Args> (args)...);}
        void construct (pointer ptr, const T& val) {new (static_cast<T*> (ptr) ) T (val);}

        template<typename U>
        void destroy (U* ptr) {ptr->~U();}
        void destroy (pointer ptr) {ptr->~T();}

        size_type max_size() const {return std::numeric_limits<std::size_t>::max() / sizeof (T);} /**return std::size_t(-1);**/

        template<typename U>
        struct rebind
        {
            typedef BasicAllocator<U> other;
        };
};

但我想知道为什么我永远不应该从std::allocator 继承。是因为它没有虚拟析构函数吗？我看过很多帖子说应该创建自己的而不是继承。我明白为什么我们不应该继承 std::string 和 std::vector 但继承 std::allocator 有什么问题？

我可以继承上面的类吗？还是我需要一个虚拟析构函数来做到这一点？

为什么？

Answer 1

很多人会在这个帖子中发布你不应该从std::allocator 继承的帖子，因为它没有虚拟析构函数。他们将通过指向基类的指针讨论多态性和切片和删除，这些都不是标准第 17.6.3.5 节 [allocator.requirements] 中详述的分配器要求所允许的。在有人证明派生自 std::allocator 的类无法满足其中一个要求之前，这就是简单的货物崇拜心态。

也就是说，几乎没有理由从 C++11 中的std::allocator 派生。 C++11 对分配器的大修引入了特征模板std::allocator_traits 位于分配器及其用户之间，并通过模板元编程为许多所需功能提供合理的默认值。 A minimal allocator in C++11 can be as simple as:

template <typename T>
struct mallocator {
  using value_type = T;

  mallocator() = default;
  template <class U>
  mallocator(const mallocator<U>&) {}

  T* allocate(std::size_t n) {
    std::cout << "allocate(" << n << ") = ";
    if (n <= std::numeric_limits<std::size_t>::max() / sizeof(T)) {
      if (auto ptr = std::malloc(n * sizeof(T))) {
        return static_cast<T*>(ptr);
      }
    }
    throw std::bad_alloc();
  }
  void deallocate(T* ptr, std::size_t n) {
    std::free(ptr);
  }
};

template <typename T, typename U>
inline bool operator == (const mallocator<T>&, const mallocator<U>&) {
  return true;
}

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

编辑：std::allocator_traits 的正确使用尚未完全出现在所有标准库中。例如，上面的示例分配器在使用 GCC 4.8.1 编译时无法与 std::list 一起正常工作 - std::list 代码抱怨缺少成员，因为它尚未更新。

Answer 2

类模板std::allocator<...> 没有任何虚函数。因此，提供派生功能显然是一个糟糕的选择。尽管某些类或类模板仍然是合理的基类，即使没有虚拟析构函数和任何其他虚拟函数，它们往往只是标记类型或使用Curiously recurring template pattern。

分配器不打算像那样定制，即std::allocator<T> 不打算作为基类。如果您尝试这样使用它，您的逻辑可能很容易被切断。用于轻松自定义分配器的方法是依靠std::allocator_traits<A> 提供分配器选择不显式提供的各种操作，使用基于相对少量操作的默认实现。

从std::allocator<T> 派生的主要问题是它可能隐藏rebind 成员的问题，例如，成员被省略或拼写错误。下面是一个应该打印my_allocator::allocate() 两次但不是由于拼写错误的示例。我认为my_allocator<T> 是一个完整的分配器，即使没有来自std::allocator<T> 的继承，即不必要的继承只会导致隐藏错误的可能性。您也可能会收到错误消息，例如，allocate() 或 deallocate() 函数错误。

#include <memory>
#include <iostream>

template <typename T>
struct my_allocator
    : std::allocator<T>
{
    my_allocator() {}
    template <typename U> my_allocator(my_allocator<U> const&) {}

    typedef T value_type;
    template <typename U> struct rebimd { typedef my_allocator<U> other; };
    T* allocate(size_t n) {
        std::cout << "my_allocator::allocate()\n";
        return static_cast<T*>(operator new(n*sizeof(T)));
    }
    void deallocate(T* p, size_t) { operator delete(p); }
};

template <typename A>
void f(A a)
{
    typedef std::allocator_traits<A>    traits;
    typedef typename traits::value_type value_type;
    typedef typename traits::pointer    pointer;
    pointer p = traits::allocate(a, sizeof(value_type));
    traits::deallocate(a, p, sizeof(value_type));

    typedef typename traits::template rebind_alloc<int> other;
    typedef std::allocator_traits<other> otraits;
    typedef typename otraits::value_type ovalue_type;
    typedef typename otraits::pointer    opointer;
    other o(a);
    opointer op = otraits::allocate(o, sizeof(ovalue_type));
    otraits::deallocate(o, op, sizeof(ovalue_type));
}

int main()
{
    f(my_allocator<int>());
}

Answer 3

我刚刚在 VS2013 中遇到了一个关于此的问题（但它没有出现在 VS2015 中）。可能不是这个问题的答案，但无论如何我都会分享这个：

在 boost 中有一个函数 call_select_on_container_copy_construction() 测试分配器是否有成员 select_on_container_copy_construction() 并调用该函数以获取分配器的副本。虽然std::allocator 返回其自身的副本，但派生的myallocator 应覆盖此方法以执行相同的操作并返回myallocator 类型，而不是让它继承具有std::allocator 返回类型的那个。这会导致类型不匹配的编译错误。

如果myallocator继承std::allocator，它必须重写任何可能与被重写时的类型不同的返回类型的父方法。

请注意，据我所知，这仅出现在 VS2013 中，因此您可能会认为这是编译器的问题，而不是代码的问题。

我在 Eigen 中使用的 myallocator 是 aligned_allocator，从 3.3.0 版本开始。

Answer 4

嗯，析构函数is not virtual。如果您不以多态方式使用分配器，这不是直接问题。但是考虑这种情况，BasicAllocator 继承自 std::allocator：

std::allocator<int>* ptr = new BasicAllocator<int>();
// ...
delete ptr;

BasicAllocator 的析构函数从未被调用，导致内存泄漏。