c++ allocator类

转载

mob60475707634e 2012-06-07 13:25:00

文章标签 初始化成员函数 c++11 头文件嵌套 文章分类 C/C++ 后端开发

<memory>头文件提供了一个类allocator<T>，它可以分配用来保存T类型的对象的整块内存，而不需要初始化，并且他会返回一个指针，指向这块内存的首元素。这样的指针是危险的，因为他们的类型表面指向的是对象，但是这些内存却并不包含真正的对象。标准库还提供了一种方式在这些内存中构造对象，销毁对象--但是并没有释放内存。由程序员使用allocator类来确定哪些空间保存构造的对象，哪些空间还未初始化。

对我们的目的来说，allocator类中最有趣的部分是，它包含4个成员函数和两个相关的非成员函数(不仅仅只有4个，有多个重载版本）

<template class T>class allocator{

public :

T* allocate(size_t);

void deallocate(T*,size_t);

void construct(T*,const T&);

void destroy(T*);

//...

};

pointer allocate (size_type n, allocator<void>::const_pointer hint=0);

Allocate block of storage


void deallocate (pointer p, size_type n);      释放为初始化的内存

Releases a block of storage previously allocated with member allocate and not yet released

void construct ( pointer p, const_reference val );

Construct an object

Constructs an object of type T (the template parameter) on the location pointed by p using its copy constructor to initialize its value to val.

Notice that this does not allocate space for the element, it should already be available at p (see member allocate to allocate space).

It is equivalent to:

new ((void*)p) T (val);

void destroy (pointer p); 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

Destroy an object

Destroys the object of type T (the template parameter) pointed by p.

Notice that this does not deallocate space for the element. (see member deallocate to release storage space).

It is equivalent to: ((T*)p)->~T();

address

obtains the address of an object, even if operator& is overloaded
(public member function)

rebind: 一个嵌套（nested）的class template，class rebind<U>拥有唯一成员other，那是一个typedef，代表allocator<U>

参考：http://en.cppreference.com/w/cpp/memory/allocator

Notes

The member template class rebind provides a way to obtain an allocator for a different type. For example,

`std::list<T, A>` allocates nodes of some internal type `Node<T>`, using the allocator A::rebind<Node<T>>::other	(until C++11)
`std::list<T, A>` allocates nodes of some internal type `Node<T>`, using the allocator std::allocator_traits<A>::rebind_alloc<Node<T>>, which is implemented in terms of A::rebind<Node<T>>::other if A is an `std::allocator`	(since C++11)

与allocator类相关的两个非成员函数是：

template<class In,class For> For uninitialized_copy(In,In,For);

作用于copy类似，把前两个参数指定的序列中的值，负责到第三个参数的目的序列中。

template<class For,class T> vooid uniinitialized_fill(For,For,const T&) ; 使用指定值来填充未初始化的空间。

列表:allocator类分配内存以及构建对象时候，常用的几个方法：

`allocator<T> a;`	Defines an `allocator` object named `a` that can allocate memory or construct objects of type `T`.
`a.allocate(n)`	Allocates raw, unconstructed memory to hold `n` objects of type `T`.
`a.deallocate(p, n)`	Deallocates memory that held `n` objects of type `T` starting at address contained in the `T*` pointer named `p`. It is the user's responsibility to run `destroy` on any objects that were constructed in this memory before calling `deallocate`.
`a.construct(p, t)`	Constructs a new element in the memory pointed to by the `T*` pointer `p`. The copy constructor of type `T` is run to initialize the object from `t`.
`a.destroy(p)`	*Runs the destructor on the object pointed to by the `T` pointer `p`.**
`uninitialized_copy(b, e, b2)`	Copies elements from the input range denoted by iterators `b` and `e` into unconstructed, raw memory beginning at iterator `b2`. The function constructs elements in the destination, rather than assigning them. The destination denoted by `b2` is assumed large enough to hold a copy of the elements in the input range.
`uninitialized_fill(b, e, t)`	Initializes objects in the range denoted by iterators `b` and `e` as a copy of`t`. The range is assumed to be unconstructed, raw memory. The objects are constructed using the copy constructor.
`uninitialized_fill_n(b, e, t, n)`	Initializes at most an integral number `n` objects in the range denoted by iterators `b` and `e` as a copy of `t`. The range is assumed to be at least `n`elements in size. The objects are constructed using the copy constructor.