我试图在C ++中理解更好的std::allocator，我遇到了this question，在我看来实际上只有一个分配器类通常被容器使用（比如std::vector）我的问题是这个分配器是如何实现的？它是否像定期重新分配的堆栈一样？如果不是如何实际实施？
默认的分配器是std::allocator，并且只在需要时使用::operator new，所以没什么特别的。它或多或少与为每个需要的对象自己做new和delete相同。您可以在标准中的[default.allocator]下阅读更多相关信息。
分配器“接口”（实际上只是一组需求，在模板实例化期间强制执行）是这个过程的包装器，允许使用替代的内存供应方法。
例如，您可能提供的替代分配器可以实现memory pool或其他特定于您的需求的东西，从而减少诚实到良好的动态分配。
标准容器以及它们的元素类型具有分配器类型作为模板参数（您通常不会注意到这一点！）这就是您选择与该容器一起使用的替代实现的方式。
在这些情况下，你通常会预先分配一大块内存，然后在什么时候抛出一小块内存。从这个意义上讲，这样的实现可以被认为是一种“堆内堆”，但实际上你根本没有必要给它堆语义。它只需要遵守Allocator概念的要求。
Josuttis先生在http://www.josuttis.com/cppcode/allocator.html上放了一个（无聊的）例子;我在这里重现它：
/* The following code example is taken from the book
* "The C++ Standard Library - A Tutorial and Reference"
* by Nicolai M. Josuttis, Addison-Wesley, 1999
*
* (C) Copyright Nicolai M. Josuttis 1999.
* Permission to copy, use, modify, sell and distribute this software
* is granted provided this copyright notice appears in all copies.
* This software is provided "as is" without express or implied
* warranty, and with no claim as to its suitability for any purpose.
*/
#include <limits>
#include <iostream>
namespace MyLib {
template <class T>
class MyAlloc {
public:
// type definitions
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
// rebind allocator to type U
template <class U>
struct rebind {
typedef MyAlloc<U> other;
};
// return address of values
pointer address (reference value) const {
return &value;
}
const_pointer address (const_reference value) const {
return &value;
}
/* constructors and destructor
* - nothing to do because the allocator has no state
*/
MyAlloc() throw() {
}
MyAlloc(const MyAlloc&) throw() {
}
template <class U>
MyAlloc (const MyAlloc<U>&) throw() {
}
~MyAlloc() throw() {
}
// return maximum number of elements that can be allocated
size_type max_size () const throw() {
return std::numeric_limits<std::size_t>::max() / sizeof(T);
}
// allocate but don't initialize num elements of type T
pointer allocate (size_type num, const void* = 0) {
// print message and allocate memory with global new
std::cerr << "allocate " << num << " element(s)"
<< " of size " << sizeof(T) << std::endl;
pointer ret = (pointer)(::operator new(num*sizeof(T)));
std::cerr << " allocated at: " << (void*)ret << std::endl;
return ret;
}
// initialize elements of allocated storage p with value value
void construct (pointer p, const T& value) {
// initialize memory with placement new
new((void*)p)T(value);
}
// destroy elements of initialized storage p
void destroy (pointer p) {
// destroy objects by calling their destructor
p->~T();
}
// deallocate storage p of deleted elements
void deallocate (pointer p, size_type num) {
// print message and deallocate memory with global delete
std::cerr << "deallocate " << num << " element(s)"
<< " of size " << sizeof(T)
<< " at: " << (void*)p << std::endl;
::operator delete((void*)p);
}
};
// return that all specializations of this allocator are interchangeable
template <class T1, class T2>
bool operator== (const MyAlloc<T1>&,
const MyAlloc<T2>&) throw() {
return true;
}
template <class T1, class T2>
bool operator!= (const MyAlloc<T1>&,
const MyAlloc<T2>&) throw() {
return false;
}
}
用法：
#include <vector>
#include "myalloc.hpp"
int main()
{
// create a vector, using MyAlloc<> as allocator
std::vector<int,MyLib::MyAlloc<int> > v;
// insert elements
// - causes reallocations
v.push_back(42);
v.push_back(56);
v.push_back(11);
v.push_back(22);
v.push_back(33);
v.push_back(44);
}
分配器只提供分配内存，释放内存，构造对象和销毁它们的策略。
它们不提供重新分配内存的策略（增加先前分配的内存区域的大小）。所以在所有容器中，如果必须增加内存：
vector那样，分配一个新的更大的内存区域，复制其中的旧元素，然后释放以前的内存区域。