STL — 浅析一级空间配置器

template < class T, class Alloc = allocator<T> >

class vector;

/*__malloc_alloc_template 就是第一级配置器*/  
typedef __malloc_alloc_template<0> malloc_alloc;      
typedef malloc_alloc alloc;

#define __THROW_BAD_ALLOC fprintf(stderr, "out of memory\n"); exit(1)  
  
static void* allocate(size_t __n)  
{  
    void* __result = malloc(__n);      //调用malloc()分配内存，向 system heap 要求空间  
    if (0 == __result) __result = _S_oom_malloc(__n);     //malloc分配失败，调用_S_oom_malloc()  
    return __result;                                      
}  
  
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG  
template <int __inst>  
void(*__malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;  
#endif                       
//内存不足处理例程，初值为0，待用户自定义，考虑内存不足时的应变措施。  
  
template <int __inst>  
void*  
__malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n)  
{  
    void(*__my_malloc_handler)();    //函数指针  
    void* __result;  
  
    for (;;) {   //不断的尝试释放、配置、再释放、再配置……  
        __my_malloc_handler = __malloc_alloc_oom_handler;  
        /*由于初值设定为0，如果用户没有自定义相应的内存不足处理例程，那么还是抛出异常*/  
        if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; }    
        (*__my_malloc_handler)();          //用户有自定义(释放内存)，则进入相应的处理程序  
        __result = malloc(__n);              
        if (__result) return(__result);  
    }  
    //不断的尝试释放和配置是因为用户不知道还需要释放多少内存来满足分配需求，只能逐步的释放配置  
}

根据注释很容易看懂代码往下走，唯一有一点点难度的地方就是那个死循环的地方，我们来着重看一下这个循环的内容:( 敲敲黑板 重点！ )

函数时，下面的

static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)  
{  
    void* __result = realloc(__p, __new_sz);  
    if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);  
    return __result;  
}  
  
template <int __inst>  
void* __malloc_alloc_template<__inst>::_S_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);  
    }  
}

static void deallocate(void* __p, size_t /* __n */)  
{  
    free(__p);        //第一级配置器直接使用free()  
}

/*该函数接收一个返回值为空，参数为空的函数指针作为参数，最后返回一个返回值和参数均为空的函数指针*/  
static void (* __set_malloc_handler(void (*__f)()))()     
{  
    void (* __old)() = __malloc_alloc_oom_handler;       //保存原有处理例程  
    __malloc_alloc_oom_handler = __f;                    //重新指定异常处理例程  
    return(__old);  
}

#include<iostream>
#include<Windows.h>

using namespace std;

//一级空间配置器
#define _THROW_BAN_ALLOC 0

template<int inst>
class __MallocAllocTemplate
{
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)
	{
		free(p);
	}
	static void* Reallocate(void* p,size_t new_size)
	{
		void* result = realloc(p,new_size);
		if (0 == result) result = __Oom_Realloc(p,new_size);

		return result;
	}

	static void(*Set_Malloc_Handler(void(*f)()))()
	{
		void(*old)() = __Malloc_Alloc_Oom_Handler;
		__Malloc_Alloc_Oom_Handler = f;
		return(old);
	}

private:
	static void(*__Malloc_Alloc_Oom_Handler)();

	static void *__Oom_Malloc(size_t n)
	{
		void(*My_Malloc_Handler)();
		void* result;

		for (;;) 
		{
			My_Malloc_Handler = __Malloc_Alloc_Oom_Handler; //用户自定义处理函数地使用
			if (My_Malloc_Handler == 0) 
				throw _THROW_BAN_ALLOC;
			(*My_Malloc_Handler)(); //调用处理函数释放内存;
			result = malloc(n); //再次开辟内存
			if (result)
				return result;
		}
	}


	static void *__Oom_Realloc(void *p,size_t n)
	{
		void(*My_Malloc_Handler)();
		void* result;

		for (;;)
		{
			My_Malloc_Handler = __Malloc_Alloc_Oom_Handler; //用户自定义处理函数地使用
			if (My_Malloc_Handler == 0 )
				throw _THROW_BAN_ALLOC;
			(*My_Malloc_Handler)(); //调用处理函数释放内存;
			result = realloc(p,n); //再次开辟内存
			if (result)
				return result;
		}
	}
};

template<int inst>
void(*__MallocAllocTemplate<inst>::__Malloc_Alloc_Oom_Handler)() = 0; //默认为0

typedef __MallocAllocTemplate<0> malloc_alloc;

void Test()
{
	

	int* p = (int*)malloc_alloc::Allocate(sizeof(int)* 10);

	for (size_t i = 0; i < 10; ++i)
	{
		p[i] = i;
	}

	p = (int*)malloc_alloc::Reallocate(p, sizeof(int)* 20);
	for (int i = 10; i < 20; ++i)
	{
		p[i] = i * 3;
	}

	for (int i = 0; i < 20; ++i)
	{
		cout << p[i] << " ";
	}

	malloc_alloc::Deallocate(p);

	system("pause");
}

template<int inst>
void(*__MallocAllocTemplate<inst>::__Malloc_Alloc_Oom_Handler)() = 0; //默认为0

typedef __MallocAllocTemplate<0> malloc_alloc;


void DoFreeAlloc()
{
	for (int i = 0;; ++i)
	{
		cout << "我正在拼命地释放空间\n" << endl;
	}
}


void Test()
{
	malloc_alloc::Set_Malloc_Handler(DoFreeAlloc);
	
	int* p = (int*)malloc_alloc::Allocate(sizeof(int*)* 1000000000);

	malloc_alloc::Deallocate(p);

	system("pause");
}