走进STL - 空间配置器，STL背后的故事

template <class T,class Alloc = alloc>	//预设使用alloc配置器
class vector{···};

class test{···};

test *pf = new test;	//配置内存，然后构造对象
···
delete pf;		//析构对象，然后释放内存

#include <stl_alloc.h>		//负责内存空间的配置与释放
#include <stl_construct.h>	//负责对象内容的构造与析构

//以下是construct()函数

#include <new.h>

template <typename T1,typename t2>
inline void construct(T1 *p,const T2& value)
{
	new (p) T1(value);	//调用T1::T1(value)
}

//以下是destroy()函数第一版本

template <typename T>	//第一版本，接受一个指针

inline void destroy(T *pointer)
{
	pointer->~T();	  //调用 dtor ~T()
}

//以下是destroy()函数第二版本，接受两个迭代器

template <typename ForwardIterator>

inline void destory(ForwardIterator first,ForwardIterator last)
{
	__destory(first,last,value_type(first));
}

//判断元素的数值型别（value type）是否无关痛痒（trivial destructor）
template <typename ForwardIterator,typename T>

inline void __destroy(ForwardIterator first,ForwardIterator last,T*)
{
	typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;//注1
	__destroy_aux(first,last,trivial_destructor());
}

//如果是有关痛痒（non-trivial destructor）的

template <typename ForwardIterator,typename T>

inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__false_type)
{
	for(;first<last;++first)
	{
		destroy(&*first);
	}
}

//如果是trivial destructor，则no-op

template <typename ForwardIterator,typename T>

inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__true_type){}

#include <new>

//注意，alloc不接受“template 型别参数”，所以就算你定义了也用不上

class __malloc_alloc_template
{
	private:	//这里面都是函数指针，用来处理内存不足的情况
	static void *oom_malloc(size_t);	
	static void *oom_realloc(void *,size_t);
	static void (* __malloc_alloc_oom_handler)();

	public:
	
	//正常空间配置
	static void * allocate(size_t n)
	{
		void *result = malloc(n);	
		if( 0 == result)
			result = oom_malloc(n);
		return result;
	}

	//正常空间回收
	static void deallocate(void *p,size_t /*n*/)
	{
		free(p);
	}

	//正常重分配空间
	static void * reallocate(void *p,size_t /* old_sz */,size_t new_sz)
	{
		void * result = realloc(p,new_sz);
		if( 0 == result )
			result = oom_realloc(p,new_sz);
		return result;
	}
}

void *__malloc_alloc_tempate<0>::oom_malloc(size_t n)
{
	void (* my_malloc_handler)();
	void *result;

	for(;;)
	{
		//不断尝试释放、配置、再释放、再配置
		my_malloc_handler = __malloc_alloc_oom_handler;
		if( 0 == my_malloc_handler)
		{
			__THROW_BAD_ALLOC;
		}

		(* my_malloc_handler)();		//调用处理例程，企图释放内存
	//这行我看的有点晕，找到的资料里能说服我的是：“调用用户定义函数“。当然，这个用户指的不是咱，是处理例程
	//如果有更好的理解，万望不吝赐教。

		result = malloc(n);			//尝试再次配置内存
		if(result)
			return (result);
}

void *__malloc_alloc_tempate<0>::oom_realloc(void *p,size_t n)
{
	void (* my_malloc_handler)();
	void *result;

	for(;;)
	{
		//不断尝试释放、配置、再释放、再配置
		my_malloc_handler = __malloc_alloc_oom_handler;
		if( 0 == my_malloc_handler)
		{
			__THROW_BAD_ALLOC;
		}

		(* my_malloc_handler)();		

		result = realloc(p,n);			//尝试再次配置内存
		if(result)
			return (result);
}

union obj
{
	union obj *free_list_link;
	char client_data[1];
}

enum {__ALIGN = 8};	//小型区块的上调边界
enum {__MAX_BYTES = 128};	//小型区块的上限
enum {__NFREELISTS/ALIGN}	//free-list个数

class __default_alloc_template{
	
private:
//将byte上调至8的倍数
	static size_t ROUND_UP(size_t bytes){
		return (((bytes)+__ALIGN-1) &~ (__ALIGN -1));	
	}
private:
	//free-list的节点构造
private:
	//16个free-list
	static obj *volatile free_list[__NFREELISTS];
	//根据区块大小，决定使用n号free-list。n从1开始算
	static size_t FREELIST_INDEX(size_t bytes)	{
		return return (((bytes)+__ALIGN-1) / __ALIGN -1);	
	}
}

···

static void *alloc(size_t n)
{
	obj * volatile my_free_list;
	obj * result;

//一级
	if( n > (size_t) __MAX_BYTES)
	{
		return (malloc_alloc::allocate(n));
	}

	my_free_list = free_list + FREELIST_INDEX(n);
	result = *my_free_list;
	if(result == 0)
	{
		//没有可用free-list,准备重新填充
		void *r = refill(ROUND_UP(n));
		return r;
	}
	*my_free_list = result->free_list_link;
	return (result);
}

static void deallocate(void *p,size_t n)
{
	obj *q = (obj *)p;
	obj *volatile *my_free_list;

	if( n > (size_t) __MAX_BYTES)
	{
		malloc_alloc::deallocate(p,n);
		return n;
	}

//寻找对应的free list
	my_free_list = free_list + FREELIST_INDEX(n);

//调整free_list，回收区块
	q->free_list_link = *my_free_list;
	*my_free_list = q;
}

void * __default_alloc_template</**参数不管它*/>::refill(size_t n)
{
	int nobjs = 20;

//调用chunk_alloc(),尝试取得nobjs个区块作为新节点
	char *chunk = chunk_alloc(n,nobjs);
	obj *volatile *my_free_list;
	obj *result;
	obj *current_obj,*next_obj;
	int i;

	if(1 == nobjs)	//要是就剩一块儿了，先给调用者
		return (chunk);
	my_free_list = free_list + FREELIST_INDEX(n);


//睁大眼睛吧

//接下来准备在chunk空间中建立free list
	result = (obj *)chunk;	//先给调用者来一块
//接下来引导free list来拿地
	*my_free_list = next_obj = (obj *)(chunk + n);
//然后将新拿到的地消化吸收
	for(i = 1; ;i++)	//从1开始，0给别人了
	{
		current_obj = next_obj;
		next_obj = (obj *) ((char *)next_obj+n);
		if(nobjs - 1 == i)
		{
			current_obj->free_list_link = 0;
			break;
		}
		else
			current_obj -> free_list_link = next_obj;
	}
	return (result);
}

char * __default_alloc_template</*参数不管它*/>::chunk_alloc(size_t size,int &nobjs)
{
	char * result;
	size_t total_bytes = size *nobjs;
	size_t bytes_left = end_free - start_free;	//内存池还有多少水

	if(bytes_left>=total_bytes)
	{
		result = start_free;
		start_free += total_bytes;
		return (result);
	}
	else if(bytes_left >= size)	//不够总量，但是总归还是有一些存货的
	{
		nobjs = bytes_left/size;
		total_bytes = size*nobjs;
		result = start_free;
		start_free += total_bytes;
		return (result);
		//能给多少多少给多少吧
	}
	else
	{
		//一点都没了
		size_t byte_to_get = 2*total_bytes + ROUND_UP(heap_size >> 4);
		//先找些零零散散的拼一下看看
		if(bytes_left>0)
		{
			obj * volatile *my_free_list = free_list + FREELIST_INDEX(bytes_left);
			//调整free-list,将残余空间塞进去
			((obj *)start_free)->free_list_link = *my_free_list;
			*my_free_list = (obj *)start_free;
		}

	//记得我们开头说过，空间总是从system-heap中索求的，现在是时候去索求了
	//这块省略吧，太长了
	}
}