C++模板来实现一个通用的内存池.

从最简单的入手

1.实现一个固定大小的allocator

//分配固定大小内存块的模板类,内部缓存算法自己实现了,

//我用的是预分配+回收cache链

//即分配时先检查回收链有无数据,无的话每次分配n*size个块,然后返回其中一个,直到该块用完后继续分配

//释放时直接加入回收链即可

//好处是速度够块,但是浪费空间可能就比较大了

template class Fix_Allocator{

void* alloc(size_t size);

void free(void*p);

typedef     Fix_Allocator me;

static me Instance;

};

提供一个给host class用的impl template

template class new_op{

void* operator new(size_t size);

//........

};

template < 
   typename Host
   >
inline void* new_op:: operator new(size_t size){
 return Fix_Allocator::Instance.alloc(size);
}

 

然后所有需要内存池的类继承new_op即可

 

class cls_usePool:public new_op{

.........

};

2.改进

 

以上方法的不足,大小近似的类不能共享内存池,如sizeof(clsA)==11,sizeof(clsB)==12,

内存池并不能提高程序太多效率.

我用的办法是将所有分配大小对齐到2的冥(这样最大内存占用将会接近原来的一倍,考虑(17,33这样大小的对像很多的情况)

解决方法如下

template
struct TypeSelectT
{
private:
 template
 struct In
 { typedef T Result; };

 template<>
 struct In
 { typedef U Result; };

public:
 typedef typename In::Result Result;
};

#define countof(x) (sizeof(x)/sizeof(x[0]))

template 
struct extr{
protected:
 template 
 struct imp{
  enum {
   next=(x1+y-1)/y,
  };
  enum {Result=1+imp::Result};
 };

 template <>struct imp<1>{
  enum {Result=0};
 };

public:
 enum {Result=imp::Result};
};

template 
struct pwr{
protected:
 template 
 struct imp{
  enum{
   next=y1-1
  };
  enum{
   Result=x*imp::Result
  };
 };
 template<> struct imp<0>{
  enum{
   Result=1
  };
 };

public:
 enum{
  Result=imp::Result
 };
};

template struct allocIdx{
 template  struct table{
//  enum{  }
  struct accept{
   enum{ Result=0};
  };
  struct Overflow{
   enum{ Result =1};
  };
  enum {
   k
//   Result =TypeSelectT< (idx>=0)&&(idx::Result::Result
  };
 };

};

先用extr算sizeof(cls)最接近2的多少次冥n,然后用pwr计算2的n次冥的值

最后用n查allocidx表得到该大小下,内存块的cache数.

最后将这些值传递给new_op的方法

这样就做到了11 12 13大小的对像全部共享16的allocator,而且是静态绑定的.