template<bool threads,int inst>class __default_alloc_template{private:    enum {__ALIGN=8};    enum {__MAX_BYTES=128;};    enum {__NFREELISTS=__MAX_BYTES/__ALIGN};        /*struct obj    {        struct obj* free_list_link;    };*/    //结构体和下面，在此处中是效果一致的。本模板采取此数据结构    //相对好处，不是很明白

 union obj    {        union obj* free_list_link;        char client_data[1];    };        //函数FREELIST_INDEX表示返回free_list[16]一个索引值    static size_t FREELIST_INDEX(size_t n)    {        return (((n)+__ALIGN-1)/__ALIGN-1);//返回对应的0-15的值。    }    //函数ROUND_UP出现，是为了对于空间大小是8,16，。。。128固定值，让n量化为其中某个值。    size_t ROUND_UP(size_t n)    {        //等效于return(((n-1)/__ALIGN+1)*__ALIGN);        return ((n+__ALIGN-1)&~(__ALIGN-1));    }    //函数chunk_alloc用于申请空间，想内存池    char* chunk_alloc(size_t n,size_t nobjs)    {        char * result;        size_t total_bytes=n*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>=n)        {//满足一个以上            result=start_free;            nobjs=bytes_left/n;//修正个数值            total_bytes=nobjs*n;            start_free+=total_bytes;            return result;        }        else        {//一个都满足不了了            if(bytes_left>0)            {//有内存；注意由于分配出来的都是8的倍数，则此时内存残余也是8的倍数                //收集残余内存                obj* volatile * my_free_list=free_list+FREELIST_INDEX(bytes_left);//适合残余bytes_left的空间收集                ((obj*)start_free)->free_list_link=*my_free_list;                 *my_free_list=(obj*)start_free;            }            //收集完本池中的残余空间后，则重新申请空间作为内存池。            //针对要求空间total_bytes，进行分配预留更多的，且考虑附加量，与已经申请了多少堆有关。            size_t bytes_to_get=2*total_bytes+ROUND_UP(heap_size>>4);            start_free=(char *)malloc(bytes_to_get);            if(start_free==0)            {//申请内存空间失败                //首先检测比分配空间更大的空间表是否有空闲内存。                            obj *volatile*my_free_list,*p;//注意此处*p是obj *p                for(i=n;i<=__MAX_BYTES;i+=__ALIGN)                {                    my_free_list=free_list+FREELIST_INDEX(i);                    p=*my_free_list;                    if(0！=p)                    {//表示i的空间大小有空闲，则将其空间从中删除，作为内存池                        *my_free_list=*my_free_list->free_list_link;                        start_free=(char*)p;                        end_free=(char*)p+i;                        chunk_alloc(n,nobjs);//肯定是大于所需空间大小的。                    }                }                //所有的空间链表都没有空闲的了。                end_free=0;                //二级内存分配方案已经解决不了了，只能扔给第一级分配器来处理。(以为着不需要内存池了)                start_free=(char*)malloc_alloc::allocate(bytes_to_get);                //如果成功返回，那么会继续给二级空间使用。如果不行没有成功，则会扔出错误结束过程。            }                        heap_size+=bytes_to_get;//表示申请了多少空间            end_free=start_free+bytes_to_get;            return chunk_alloc(n,nobjs);//已经分配到空间了，内存池重新注满水了，下一步就是类似前面的返回所需空间了        }    }    //函数refill重新分配固定空间个数    void* refill(size_t n)    {        //默认大小空间数是20；        int nobjs=20;        //向内存池中申请空间，以提供给客端空间申请要求        char *chunk=chunk_alloc(n,nobjs);//nobjs表示希望的个数，如果实际内存池不够，则会修改该值。        obj * result,*current_obj,*next_obj;                    obj* volatile *my_free_list;        if(nobjs==1) return(chunk);//此处注意，它表示申请不到20个空间，只能是一个,char*转为void*。                my_free_list=free_list+FREELIST_INDEX(n);//由于不止一个，则就需要修改空间链表指针。        result=(obj*)chunk;//char*转为obj*         next_obj=(obj*)(chunk+n);//char*转为obj*         *my_free_list=next_obj;//表示所指空间链表首地址        for(i=1;;i++)        {            current_obj=next_obj;            next_obj=(obj*)((char*)next_obj+n);//obj* 转为char*;char*转为obj*            if(nobjs-1==i)//表示分配了nobjs个但是有个被用了，故而就只有这么多个            {                current_obj->free_list_link=0;//最后一个设置为0；则当它被用了后，则原表中的指针只能值为0；                break;            }            else                current_obj->free_list_link=next_obj;        }        return result;    //obj*转为void*    }        static obj* volatile free_list[__NFREELISTS];    static char* end_free;    static char* start_free;    static size_t heap_size;public:    static void *allocate(size_t n)    {    //指针值，该指针指向一个obj*值，且是不可优化的，也就是free_list[16]值不可优化。        obj * volatile *my_free_list;    //分配空间结果位置---返回时其实质也就转为了void*指针类型了。被用时又转为相应的类型        obj * result;        if(n>(size_t)__MAX_BYTES)            return (malloc_alloc::allocate(n));                my_free_list=free_list+FREELIST_INDEX;//根据待分配空间大小给出指针所指free_list的值        //free_list数组所指是空间链表，链表如果没有空间则指向的是0值，否则是空间首地址。        result=*my_free_list;//所指空间处        if(0==result)        {            //需要申请空间配置扩展该固定字段空间。            void *p=refill(ROUND_UP(n));//表示分配后空间，返回一个被用，ROUND_UP是表示n上调其固定值。            return p;                }        //如果成功被分配出去了，则下面就得调整本链表空间。        *my_free_list=result->free_list_link;//只需要修改所指所指首地址，没有空间则指为0        return result;//obj*转为void*    }    static void deallocate(void *p ,size_t n)    {        if(n>__MAX_BYTES)            return (malloc_alloc::deallocate(p,n));        obj* volatile * my_free_list=free_list+FREELIST_INDEX;        ((obj*)p)->free_list_link=*my_free_list;        *my_free_list=(obj*)p;    }    static void *reallocate(void *p ,size_t old_sz,size_t new_sz)    {        void * result;        size_t copy_sz;        //对于老的内存，新的内存都大于128则交给一级处理        if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES)            return(realloc(p, new_sz));        //对于新旧内存上调后一致，则不需要重新分配空间        if (ROUND_UP(old_sz) == ROUND_UP(new_sz))            return(p);        //否则先利用分配空间，分出来        result = allocate(new_sz);        //复制其中空间内容        copy_sz = new_sz > old_sz? old_sz : new_sz;//取空间小的；这里有可能是全拷贝，有富裕空间；也有可能是截断拷贝        memcpy(result, p, copy_sz);//函数用于复制在#include <string.h>；C语言库中        //复制完后，进行收回原来的内存空间。        deallocate(p, old_sz);        return(result);    }};