定制new和delete

在看《effective C++》第8章(定制new和delete)时，发现自己对new和delete理解的并不是那么深刻。

为什么要定制new和delete呢，因为在某些环境下(嵌入式)，定制的new和delete效率会更高。

我在之前的文章“重载new和delete检测内存泄漏”中也做过类似的总结。

下面的例子中重载了class-specific new和class-specific delete

  void* T::operator new  ( std::size_t count );

  void T::operator delete  ( void* ptr );

如果想使用定制的new和delete需要继承fixedSizeResourcePool类。  

总内存(使用了栈内存模拟)的大小固定，被平均分配成8个字节大小的内存块，每次new取其中一块，delete回收一块。

还是看代码吧。  

借用《effective C++》Item 50中的一句话：编写一个几乎能工作的自定义内存管理器相当容易，编写一个工作得很好的要困难得多。

#include <cstdio>
using namespace std;

typedef long unsigned int uint32_t;
typedef unsigned char uint8_t;
typedef unsigned char Alignment;
typedef void* MemAddress;

template<typename T, Alignment ALIGNMENT = 8>
class fixedSizeResourcePool
{
public:
//根据输入，初始化一块内存
//iNumOfObjects:内存块数量
//address:内存起始位置
//name_p:内存名字
static void init(const int iNumOfObjects, const MemAddress address, const char * name_p)
{
name_p_ = const_cast<char*>(name_p);

uint8_t* currAddress = reinterpret_cast<uint8_t*>(address);
for (int i = 0; i < iNumOfObjects; i++)
{
//做到8字节对齐，便于CPU快速寻址
const uint8_t alignmentError = reinterpret_cast<uint32_t>(currAddress) %ALIGNMENT;
if (alignmentError != 0)
{
//去除多余位置
currAddress += (ALIGNMENT - alignmentError);
}
//这里将内存分块：内存本身不变，poolInfo_.freeList_p_在变
linkedList* tmp_p = reinterpret_cast<linkedList*>(currAddress);
//point to currAddress address
tmp_p->next_p_ = poolInfo_.freeList_p_;
//poolInfo_.freeList_p_->next_p_ = poolInfo_.freeList_p_;
poolInfo_.freeList_p_ = tmp_p;

printf("init:: poolInfo_.freeList_p_ = %x \n",poolInfo_.freeList_p_);
//将内存块按sizeof(T)的大小分块

currAddress += sizeof(T);
}
poolInfo_.numOfObjects_ = iNumOfObjects;

printf("fixedSizeResourcePool %s initialized with iNumOfObjects: %d, sizeof(T): %d, totalBuffer: %d, Address: 0x%08x, ALIGNMENT: %d \n",
name_p_, iNumOfObjects, sizeof(T), iNumOfObjects * sizeof(T), address, ALIGNMENT);
}
//重载operator new
static void *operator new(uint32_t size) throw()
{
linkedList* tmp_p = poolInfo_.freeList_p_;
if (tmp_p != 0)
{
printf("new:: poolInfo_.freeList_p_ = %x \n",poolInfo_.freeList_p_);
printf("new:: poolInfo_.freeList_p_->next_p_ = %x \n",poolInfo_.freeList_p_->next_p_);
//每次在链表中获取一块fixedSize的内存
poolInfo_.freeList_p_ = poolInfo_.freeList_p_->next_p_;
poolInfo_.numAllocatedObjects_++;
return tmp_p;
}
else
{
printf("no pool resource \n");
return 0;
}
}

//placement new
static void* operator new(uint32_t size, void *p)
{
return p;
}

//重载operator delete
static void operator delete(void * p)
{
//每次在链表中删除一块fixedSize的内存
linkedList* tmp_p = reinterpret_cast<linkedList*> (p);
tmp_p->next_p_ = poolInfo_.freeList_p_;
poolInfo_.freeList_p_ = tmp_p;

poolInfo_.numAllocatedObjects_--;
}

static inline int getNumFreeObjects()
{
return poolInfo_.numOfObjects_ - poolInfo_.numAllocatedObjects_;
}

class linkedList
{
private:
linkedList* next_p_;
friend class fixedSizeResourcePool;
};

struct poolInfo
{
linkedList* freeList_p_; //链表
int numAllocatedObjects_; //已分配内存块
int numOfObjects_; //总内存块
};

private:
static poolInfo poolInfo_;
static char* name_p_;

protected:
fixedSizeResourcePool(void) {};
virtual ~fixedSizeResourcePool() {};

};

template<typename T, Alignment ALIGNMENT>
typename fixedSizeResourcePool<T, ALIGNMENT>::poolInfo fixedSizeResourcePool<T, ALIGNMENT>::poolInfo_ = {0, 0, 0};

template<typename T, Alignment ALIGNMENT>
char* fixedSizeResourcePool<T, ALIGNMENT>::name_p_ = 0;

class myClass: public fixedSizeResourcePool<myClass, 8>
{
public:
myClass():fixedSizeResourcePool<myClass>()
{
}
};

int main()
{

const int num= 10;
//phyMem is sizeof(myClass)*num = 80 byte
//在栈内存的基础上分配内存
char phyMem[sizeof(myClass)*num];
myClass::init(num, phyMem, "phy_Mem" );

myClass *mO = new myClass;
myClass *mO2 = new myClass;

int n = fixedSizeResourcePool<myClass, 8>::getNumFreeObjects();
printf("After new, The memory left = %d \n", n);

delete mO;
delete mO2;
n = fixedSizeResourcePool<myClass, 8>::getNumFreeObjects();
printf("After delete, The memory left = %d \n", n);

}