c++ allocator类

   <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 oft. 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 nelements in size. The objects are constructed using the copy constructor.

 更多：

http://mathbox59.blog.163.com/blog/static/12845359920102325635884/

http://www.yekezhong.com/574

http://cissco.iteye.com/blog/379093

http://www.codeproject.com/Articles/4795/C-Standard-Allocator-An-Introduction-and-Implement

 http://en.cppreference.com/w/cpp/memory/allocator