STL源码剖析_读书笔记:第二章 空间配置器 一级和二级配置器篇

作用：帮助容器配置空间存放信息

SGI空间配置器

标准空间配置器allocator：效率不好，只对::operator new和::operator delete做一层封装

特殊空间配置器alloc
：将new算式分为两阶段：用::operator配置内存，构造对象；

将delet算式分为两阶段：析构对象，用::operator delete释放内存



特殊空间配置器

内存配置：allocate()，判断区块大小，大于128字节调用一级配置器，小于检查自由链表中若有可用区块直接使用，否则为自由链表重新填充空间

内存释放：deallocate()，判断区块大小，大于128字节调用一级配置器，小于则找到对应自由链表，进行区块回收。

对象构造：construct()

对象析构：destroy()



双层配置器

一级配置器：使用malloc(),free()进行内存的分配与释放。类名:__malloc_alloc_template。

二级配置器：小于128字节时，采用内存池，维护自由链表，可从自由链表进行内存的分配与释放。内存需求量需上调为8的倍数。类名：__default_alloc_template。



下面的程序是关于第一级和第二级配置器

#include<iostream>

#include<string>

#include<vector>

#include<iterator>

#include <new.h> //使用placement new

#include <stddef.h> //常用常量

#include <limits.h> //类型最值的常量

//#include <algobase.h>

#include <memory> //STL配置器定义于此

//以下是SGI_STL_空间配置器的头文件

//#include <stl_construct.h> //定义有全域函式

////#include <stl_uninitialized.h> //定义了全局函数，赋值大内存数据

using namespace std;

template<class T>

inline T* allocate(ptrdiff_t size,T* )

{

set_new_handler(0);

T* tmp = (T*)(::operator new((size_t)(size * sizeof(T))));

if(tmp==0)

{

cerr<<"内存分配失败"<<endl;

exit(1);

}

return tmp;

}

template<class T>

inline void deallocate(T* maBlock)

{

::operator delete(maBlock);

}

template<typename T>

class MaAllocator

{

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;

public:

pointer allocate(size_type n)

{

return ::allocate((differenc_type)n,(pointer)0);//::表示在全局域

}

void deallocate(pointer p)

{

::deallocate(p);

}

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

const_pointer address(const_reference x){return (const_pointer)&x;}

size_type init_page_size()

{

return max(size_type(1),size_type(4096/sizeof(T)));

}

size_type max_size() const

{

return max(size_type(1),size_type(UINT_MAX/sizeof(T)));

}

};

//特化版本:

template<>

class MaAllocator<void>

{

public:

typedef void* pointer;

};



template<class T1,class T2>

inline void construct(T1* p,const T2& value)//作用：将初值设定到指针所指的空间上

{

new(p) T(value);//调用T1::T1(value)

}

//销毁函数不返回任何类型

template<typename T>

inline void destroy(T* pointer)//将指针所指之物析构掉

{

pointer->~T();//调用~T()

}

/*接受两个迭代器，找出元素的数值型别，用_type_traits<>求最适当措施

对迭代器进行析构，由于析构的东西多，必须判定析构函数是否真正有用，用value_type判定

若为true_type，表明T为简单类型，是无用析构函数，则什么都不做*/

template<typename ForwardIter>

inline void destroy(ForwardIter first,ForwardIter last)

{

_destroy(first,last,value_type(first));//用value_type获取型别

}

//判断元素的数值型别(value_type)是否有trivial destructor(无用的析构函数，即系统自带的)

template<class ForwardIterator,class T>

inline void _destroy(ForwardIterator first,ForwardIterator last,T*)

{

/*_type_traits<T>这个模板类根据不同的T类型定义不同的has_trivial_destructor，如果T是简单类型

就定义为_true_type类型，否则定义为_false_type类型。这两个类。*/

typedef typename _type_traits<T>::has_trivial_destructor trivial_destructor;//?

destroy_aux(first,last,trivial_destructor());//?

}

//如果元素的数值型别为non-trivial destructor，T不是简单类型为_false_type,为有效析构函数

template<class ForwardIterator,class _false_type>

inline void _destroy_aux(ForwardIterator first,ForwardIterator last,_false_type)

{

for(;first!=last;first++)

{

destroy(&*first);

}

}

//如果元素的数值型别为trivial destructor,T为简单类型

//template<class ForwardIterator,class _true_type>

//inline void _destroy_aux(ForwardIterator first,ForwardIterator,_true_type)

//{

//}

//是对迭代器为char* ,wchar_t*

inline void destroy(char* ,char* ){}

//inline void destroy(wchar* ,wchar* ){}

inline void destroy(wchar_t*,wchar_t*){}

template<class T,class Alloc>

class simple_alloc

{

public:

//static T* allocate(size_t n)

static T* allocate(size_t n)

{

return 0==n?0:(T*)Alloc::allocate(n*sizeof(T));

}

static T* allocate()

{

return (T*)Alloc::allocate(n*sizeof(T));

}



static void deallocate(T* p,size_t n)

{

if(0!=n)

{

Alloc::deallocate(p,n*sizeof(T));

}

}

static void deallocate(T* p)

{

Alloc::deallocate(p,sizeof(T));

}

};

template<typename T,typename Alloc = alloc>

class MaVector

{

public:

typedef T value_type;

protected:

//专属空间配置器，每次配置一个元素

typedef simple_alloc<value_type,Alloc> data_allocator;

void deallocate()

{

if(1)//?

{

data_allocator::deallocate(start,end_of_storage-start);

}

}

};

template<int inst>

class _malloc_alloc_template

{

private:

//一下都是函数指针，代表的函数处理内存不足情况,oom=out of memory

//static void* oom(size_t n)//内存分配溢出时的分配

//static void* oom_malloc(size_t )

//{

//}

////static void* oom_realloc(void* ,size_t)

//static void* oom_realloc(void* ,size_t )

//{

//}

////static void(*__malloc_alloc_oom_handler)//不能有2个下划线

//static void(*_malloc_alloc_oom_handler())

//{

//}

public:

static void* allocate(size_t n)

{

//第一级配置器用malloc分配

//void* result = oom_malloc(n);

void* resule = malloc(n);

if(0==result)//分配溢出时，改用oom_malloc分配

{

result = oom_malloc(n);

}

return result;

}

//static void deallocate()//必须释放指针的内存

static void deallocate(void* p)

{

free(p);//第一级配置器使用free

}

static void* reallocate(void* p,size_t old_sz,size_t new_sz)

{

//第一级配置器直接使用realloc

void* result = realloc(p,new_sz);

if(0==result)

{

result = oom_realloc(p,new_sz);

}

return result;

}

//下面是自定义的内存溢出处理方法

static void(*set_malloc_alloc_oom_handler(void (*f)()))()//为什么最后还多一个()

{

void(*old)() = _malloc_alloc_oom_handler;

_malloc_alloc_oom_handler = f;

return(old);

}

void* oom_malloc(size_t n)

{

void* result;

void(*my_malloc_handler());//?

for(;;)//不断释放，配置，在释放，再配置

{

my_malloc_hander = _malloc_alloc_oom_handler;

if(0==my_malloc_handler)

{

throw std::bad_alloc;

}

(*my_alloc_handler());

//result = my_alloc_handler;//分配多个字节

result = malloc(n);

if(result)

{

return result;

}

}

}

//void* _malloc_alloc_template<inst>::oom_malloc(size_t n)

//template<int inst>

//void(*_malloc_alloc_template<inst>::_malloc_alloc_oom_handler)()=0;

void* oom_realloc(void* p,size_t n)

{

void* result;

void(*_my_malloc_handler());

for(;;)

{

my_malloc_handler = _malloc_alloc_oom_handler;

if(0==my_malloc_handler)

{

throw std::bad_alloc;

}

(*my_malloc_handler());//执行处理函数

result = realloc(p,n);

if(result)

{

return result;

}

}

}

};

typedef _malloc_alloc_template<0> malloc_alloc;

//第二级配置器

union obj//obj可视为指另一个针指向相同形式的obj

{

union obj* free_list_link;

char client_data[1];

};

template<bool threads,int inst>

class _default_alloc_template

{

private:

//ROUND_UP()将比特上调为8的倍数

static size_t ROUND_UP(



)

}

enum {_ALIGN = 8};//小数据块的上调边界

enum {_MAX_BYTES = 128}; //小型区块的上限

enum {_NFREELISTS = _MAX_BYTES/_ALIGN};//自由链数目

int main(int argc,char *argv[])

{

cout<<"2.2:具备次配置力的SGL空间配置器"<<endl;

cout<<"STL Allocator的函数:"<<endl;

cout<<"内存申请：alloc::allocate()负责"<<endl;

cout<<"内存释放: alloc::deallocate()负责"<<endl;

cout<<"对象构造: 全局 ::construct()负责"<<endl;

cout<<"对象析构：全局 ::destroy()负责"<<endl;

cout<<"第一回合:SGI特殊的空间配置器"<<endl;

cout<<"new 运算式含量阶段操作:1调用::operator new 配置内存，2调用构造函数构造对象内容"<<endl;

cout<<"delete阶段操作: 调用析构函数将对象析构，2调用::operator delete释放内存"<<endl;

cout<<"placement new 定义：是重载operator new的全局版本，不能够被自定义版本代替，忽略size_t参数，只返还第二个参数"<<endl;

cout<<" 用法:pi = new(ptr) int;ptr指向内存缓冲器，比new多了一个“(内存地址)”参数placement new（替换符new）返回值是这个被构造对象的地址"<<endl;

cout<<" 适用:时间要求高；长时间运行；执行垃圾收集器"<<endl;

cout<<"new:不能被重载。先调用operator new分内存，调用构造函数初始化内存"<<endl;

cout<<"operator new:实现不同内存分配应重载operator new"<<endl;

cout<<"placement new:是operator new的一个重载版本。不分配内存，只返回已分配内存指针。不能删除，但需调用析构函数"<<endl;

cout<<"第二回合:构造和析构基本工具construct与destroy"<<endl;

cout<<"第四回合：空间的配置与释放: std::alloc"<<endl;

cout<<"::operator new()内存配置的基本操作是全局函数=malloc"<<endl;

cout<<"小型区块内存破碎解决方案:设计双层级配置器。第1层用:malloc,free;第二层视情况而定"<<endl;

cout<<"配置区<128B时，采用内存池。"<<endl;

//测试配置器是用1级，还是1，2级同时开启

//#ifdef _USE_MALLOC

// typedef _malloc_alloc_template<0> malloc_alloc;

// typedef malloc_alloc alloc;//令alloc为第一级配置器

//#else

// //另alloc为第二级配置器

// typedef _default_alloc_template<_NODE_ALLOCATOR_THREADS,0> alloc;

//#endif

cout<<"第5回合：第一级配置器__malloc_alloc_template"<<endl;

cout<<"new-handler机制：系统内存配置无法满足时，调用你指定的函数,然后抛bad_alloc异常"<<endl;

cout<<"SGI以malloc而非::operator new 来配置内存"<<endl;

cout<<"第二级配置器:__default_alloc_template"<<endl;

cout<<"次层配置:区块小于128bytes，以内存池管理。"<<endl;

getchar();

return 0;

}