C++的内存分配

C++的内存分配有两种方法（分配和释放未构造的原始内存）：

1）allocator类，2）new 和delete

第一种：

allocator类的定制算法：

allocator<T>a ：定义分配类型为T的分配对象a;

a.allocate(n) ： 分配T类型的n个空间，不调用类型的构造函数;

a.deallocate(p,n)： 释放在T*的p指针处的n个对象所具有的内存空间，不用类型析构函数，在此这之前调用对象的析构函数是用户的责任 ;

a.construct(p,t) ： 在T*的p指针处调用类型的复制构造函数用t初始化该对象;

a.destroy(p)： 调用T*的p指针所指对象的析构函数;

uninitialized_copy(b,e,b2)： 从迭代器b和e之间的元素复制构造到迭代器b2中;

uninitialzed_fill(b,e,t):

uninitialzed_fill_n(b,e,t,n):

下面用vector的内存分配策略来理解allocator类：

template<class T>class Vector {

public:

Vector():elements(0),first_free(0),end(0) {}

void push_back(const T&) ;

private:

static std::allocator<T>alloc ;

void reallocate() ;

T* elements ;

T* first_free ;

T* end ;

} ;

 

 

使用construct：

template<class T>

void Vector<T>::push_back(const T&)

{

if(first_free == end)

  reallocate() ;

alloc.construct(first_free,t) ;

++first_free ;
}

 

 

重新分配元素与复制元素：

template<class T>

void Vector<T>::reallocte()

{

  std::ptrdiff_t size = first_free-elements ;

  std::ptrdiff_t newcapacity = 2 * max(size,1) ;

  T* newelements = alloc.allocate(newcapacity) ;

  uninitialized_copy(elements,first_free,newelements) ;

  for(T* p = first_free ; p!= elements;)

   alloc.destroy(--p) ;

 if(elements)

   alloc.deallocate(elements,end-elements) ;

 

  elements = newelements ;

  first_free = newelements+size ;

  end = newelements+newcapacity ;
}

 

 

第二种：

new和delete会自动调用对象的构造函数和析构函数的;是运算符，可重载;