Question

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

class Allocator管理类向量的内存：

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);
};

类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()的实现是否正确²，你能给我一个正确实现的例子吗？

在函数n中还有一个额外的参数deallocate()，我无法弄清楚如何（使用）。

^{1。我知道我正在使用一个已弃用的std::auto_ptr，，只是按照书中的建议错误地试图在分配错误的情况下摆脱指针。功能}

^{2。我已经读过the documentation for function destroy()，但考虑到分配的内存是一个连续的块，free() d通过传递malloc()返回的指针，唯一合理的对象销毁是默认值的分配。}

Answer 1

std::bad_alloc并非神奇地生成。 malloc通过返回nullptr而失败，并且没有任何可以将其转换为异常的内容。您拨打malloc，因此您必须手动检查返回值。

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

实现简单的分配器

编辑：

1 个答案: