C++ 使用malloc（）和free（）实现一个简单的分配器类

这种简单的分配器实现可以接受吗

template<typename T>
class Allocator
{
public:
    T * allocate(int n);  //allocate space for n objects of type T 
    void deallocate(T* p, int n);  //deallocate n objects of type T starting at p

    void construct(T* p, const T& v);  //construct a T with the value v in p
    void destroy(T* p);  //destroy the T in p
};

template<typename T>
T* Allocator<T>::allocate(int n)
{
    T* new_mem = (T*)malloc(n * sizeof(T));
    return new_mem;
}

template<typename T>
void Allocator<T>::construct(T* p, const T& v)
{
    T* constructed_object = new(p) T{ v };
}

template<typename T>
void Allocator<T>::deallocate(T* p, int n)
{
    for (int i = 0; i < n; ++i)
    {
        free(&p[i]);
    }
}

template<typename T>
void Allocator<T>::destroy(T* p)
{
    p->~T();
}

模板
类分配器
{
公众：
T*allocate（int n）；//为T类型的n个对象分配空间
void解除分配（T*p，int n）；//解除分配从p开始的T类型的n个对象
void构造（T*p，const T&v）；//用p中的值v构造一个T
无效销毁（T*p）；//销毁p中的T
};
模板
T*分配器：：分配（int n）
{
T*new_mem=（T*）malloc（n*sizeof（T））；
返回新的_mem；
}
模板
无效分配器：：构造（T*p，常量T&v）
{
T*constructed_object=new（p）T{v}；
}
模板
无效分配器：：取消分配（T*p，int n）
{
对于（int i=0；i~T（）；
}

我将在向量中使用它来实现保留exra空间的函数，如下所示：

template<typename T, typename A>
void vector<T, A>::reserve(int newalloc)
{
    if (newalloc <= space)return;
    T* p = alloc.allocate(newalloc);
    for (int i = 0; i < sz; ++i)alloc.construct(&p[i], elem[i]);
    for (int i = 0; i < sz; ++i)alloc.destroy(&elem[i]);
    elem = p;
    space = newalloc;
}

模板
无效向量：：保留（int newalloc）
{
如果（newallocNo，这将不起作用


您应该有一个
rebind
方法

您需要提供比较运算符（
=
和
！=
）

您的
allocate
方法分配的太多。当它到达您的位置时，
sizeof（T）
已经发生了

您的
deallocate
方法完全错误。您得到一个指针。第二个参数是分配大小的提示

construct
和
destruct
方法是可选的。如果您不提供它们，它们将由
allocator\u traits
为您合成


有关最小分配器的示例，请参见（尽管没有
rebind
）
您的释放函数确实不正确。
free
和
malloc
的规则很简单：您必须准确地将从
malloc
到
free
的指针传递

template<typename T>
void Allocator<T>::deallocate(T* p, size_t)
{
    free(p);
}

模板
无效分配器：：取消分配（T*p，size\u T）
{
自由基（p）；
}

注意：通常，您也应该将相同的指针类型传递给解除分配函数，但在这种情况下，由于
free
仅将
void*
作为参数，因此隐式转换将处理该问题。
我猜placement new返回的
void*
可能不是
T*
。分配函数是cor你的链接证实了这一点。