【C++】《C++标准程序库》小结第十五章-自定义空间配置器

第十四章是国际化议题，解决不同地区因为文化差异，产生的输入与输出问题。这对于我暂时没有用，而且还有更好的第三方库可以解决这个问题。

 

（1）怎么使用配置器

配置器是容器的内存管理工具，实际的内存分配、初始化、销毁、回收工作由他干。

C++的配置器继承自allocator类，这是个模板类可以自己设置内存元素大小，所以我们不用关心到底要分配多少字节。

代码	效果
a.allocate(num)	为num个元素分配内存
a.construct(p)	初始化指针p的指向元素
destroy(p)	销毁p所指的元素
deallocate(p,num)	回收从p开始的num个元素空间

 

下面我们来看看vector的一个内部初始化函数的实现代码：

template <class T, class Allocator>

vector<T,Allocator>::vector(size_type num, const T&val, const Allocator& a) :alloc(a)

{

sizeElems =numElems = num;//这两个是类变量

elems =alloc.allocate(num);//这个是类变量

 

for(size_type i= 0; i < num; ++i)

{

alloc.construct(&elems[i], val);//用val初始化

}

}

 

这个for循环效率不行，针对没有初始化的内存空间，所以C++提供了另外一些初始化函数：

代码	效果
uninitialize_fill(beg, end, val)	用val初始化beg-end
uninitialize_fill_n(beg, num, val)	用val初始化beg以及之后num个元素
uninitialize_copy(beg, end, mem)	把beg-end复制到mem开头的空间

 

其中uninitialized_fill_n的代码实现如下，其他原理相同。

template< class ForwardIt, class Size,class T >

void uninitialized_fill_n(ForwardIt beg,Size num

                          const T& value)

{

typedef typename std::iterator_traits<ForwardIt>::value_typeValue;

ForwardIt save(beg);

try{

   for (; num--; ++beg) {

       ::new (static_cast<void*>(&*beg)) Value(value);

}

}

catch(...)

{

for(; save!=beg; ++save)

{

save->~Value();

throw;

}

}

}

使用的是placementnew操作。加入了异常安全。

 

 

这样我的代码很漂亮了。

template <class T, class Allocator>

vector<T,Allocator>::vector(size_type num, const T&val, const Allocator& a) :alloc(a)

{

sizeElems =numElems = num;//这两个是类变量

elems =alloc.allocate(num);//这个是类变量

uninitialize_fill_n(elems,num, val);

}

 

然后是reserve的实现：

template <class T, class Allocator>

void vector<T,Allocator>::reserve(size_type size)

{

if (size <sizeElems)

return;

T* newElems =alloc.allocate(size);

unintialized_copy(elems,elems + numElems, newElem);//把原来的拷贝过来

 

for (size_type i= 0; i < numElems; ++i)

{

alloc.destroy(&elems[i]);

}

alloc.deallocate(elems,sizeElems);

sizeElems =size;

elems =newElems;

}

 

C++中提供了未初始化空间迭代器raw_storage_iterator，这样复制构造函数可以把上面的unintialized_copy，替换成更牛逼的代码：

template <class T, class Allocator>

vector<T, Allocator>::vector( constvector<T,>&val, const Allocator& a) : alloc(a)

{

sizeElems =numElems = val.size();//这两个是类变量

elems =alloc.allocate(numElems);//这个是类变量

......///主要是把原来的删除

copy(val.begin(),val.end(), raw_storage_iterator<T*, T>(elems));

}

 

（2）自定义配置器

现在关注一下怎么自定义配置器，下面是模板，以后照着改就行了。最关键的是怎么编写allocate(), deallocate()函数，这样可以实现内存优化分配。

template<class T>class allocator{

   public:

       typedef  T    value_type;

       typedef  T*    pointer;

       typedef  const T*    const_pointer;

       typedef  T&    reference;

       typedef  const T&    const_reference;

       typedef  size_t    size_type;

       typedef  ptrdiff_t    difference_type;

 

       template<class U>

       struct rebind

       {

           typedef allocator<U>other;

       };

 

allocator() throw(){}

 

template<class U>

allocator(const allocator<U>&) throw(){}

 

~allocator() throw(){}

 

       pointer allocate(size_typen,const void * hint=0)

       {

           return (pointer)(::operator new(num * sizeof(T)));//global new

       }

 

       void deallocate(pointer p,size_type n)

       {

          ::operator delete ((void*)p);//global delete

       }

 

       void construct(pointer p,const T& value)

       {

          new( (void*)p)  T(value);//placementnew operator

       }

 

       void destroy(pointer p){p->~T();}//

 

       pointer address(reference x){return (pointer)&x;}

 

       const_pointer const address(const_referencex)

       {

           return (const_pointer)&x;

       }

 

       size_type max_size() const{

           return size_type(numeric_limits<size_t>::max()/sizeof(T));

       }

};

}//end