实现简单的分配器

Question

作为矢量实现的一部分，我必须使用函数 malloc() 和 free() 实现一个分配器，给定以下接口：

class Allocator 管理 class 向量的内存：

template<class T>
class Allocator {
public:
    // function members
    T* allocate(int n);
    void deallocate(T* p, int n);

    void construct(T* p, const T& v);
    void destroy(T* p);
};

class Allocator 成员实现：

/*
    Function: allocate()
    Use: allocator_object.allocator(num_of_elements) 

    Implicit in vector_base constructor.
    It wraps malloc(); Throws bad_alloc
    if allocation unsuccessful.
*/
template <class T>
T* Allocator<T>::allocate(int n) {
    try {
        std::auto_ptr<T> mem_ptr = reinterpret_cast<T*>(malloc(n * sizeof(T)));
    } catch (std::bad_alloc& e) {
        std::cerr <<"bad_alloc caught: "<< e.what() <<'\n';
        throw;
    }
    return mem_ptr.release();
}

/*
    Function: deallocate()
    Use: allocator_object.deallocate(mem_ptr, redundant_par);

    Implicit in base_vector destructor.
    It returns memory to free store. 
    First argument is the pointer returned by malloc(). 
*/
template <class T>
void Allocator<T>::deallocate(T* mem_ptr, int n) {
    free(mem_ptr);
}

/*
    Function: construct()
    Use: allocator_object.construct(elem_ptr[i], value)

    Implicit in vector_base constructor
    and all modifying members of vector.
    It assigns the value passed as second
    argument to the element with address
    held by the pointer passed as a first 
    argument.
*/
template <class T>
void Allocator<T>::construct(T* p, const T& v = T()) {
    *p = v;
}

/*
    Function: destroy()
    Use: allocator_object.destroy(elem_ptr[i]); 

    Implicitly in vector members: reserve(), resize();
    It assigns type default value to the element
    with address held by the pointer passed as argument.
*/
template <class T>
void Allocator<T>::destroy(T* p) {
    *p = T(); // ? not sure if right 
}

如何从 malloc() 函数 allocate()¹ 中检查可能的错误分配，是当前的方法正确吗？

编辑：

函数destroy()的实现是否正确²,能否举个正确实现的例子?

在函数 deallocate() 中还有一个额外的参数 n，我不知道如何使用它。

^{1.我知道我正在使用已弃用的 std::auto_ptr，只是遵循书籍建议错误地试图在分配错误的情况下摆脱指针。}

^{2。我读过 the documentation for function destroy()，但考虑到分配的内存是一个连续的块，即通过 malloc() 返回的指针 free()d，唯一合理的 object destruction是赋值一个默认值}

Answer 1

std::bad_alloc 不是神奇生成的。 malloc 通过 returning nullptr 失败并且没有任何东西可以将其转换为异常。您调用 malloc，因此您必须手动检查 return 值。

destroy 错误的原因与 construct 错误的原因相同：它们是一对将原始内存转换为对象并返回的函数。这样做的正常方法是 placement new 并直接调用析构函数。您只是在那里调用赋值运算符，这根本不会影响对象的生命周期。

实现简单的分配器

Implementing simple allocator

c++

malloc

free

memory-management

allocator

编辑：