抛砖引玉，发一个初学写的自定义内存分配器

[RabbitLBJ]

初学重载new,自己写了一个，感觉还算方便，效率完全不保证，主要作用在引玉


/************************************************************************/
/* 版本3（自定义继承模板实现） */
/************************************************************************/
template<class T>
class BaseAlloc
{
public:
static void* operator new(size_t size)
{
void* pRet = NULL;
if(!m_freelist)
{
m_freelist = ::new Node;
m_freelist->next = NULL;
for(int i = 0;i < INCREMENT - 1;++i)
{
Node* p = ::new Node;
p->next = m_freelist;
m_freelist = p;
}
m_total += INCREMENT;
}
++m_alloc;
pRet = reinterpret_cast<void*>(m_freelist->data);
m_freelist = m_freelist->next;
return pRet;
}
static void operator delete(void* pr,size_t size)
{
Node* p = reinterpret_cast<Node*>(pr);
p->next = m_freelist;
m_freelist = p;
if(m_total - --m_alloc > DIFFSIZE)
{
for(int i = 0;i < RELEASESIZE;++i)
{
Node* p = m_freelist;
m_freelist = m_freelist->next;
::delete p;
}
m_total -= RELEASESIZE;
cout << "Release One Time" << endl;
}
}
private:
struct Node
{
char data[sizeof(T)];
Node* next;
};
static Node* m_freelist;
static int m_alloc;
static int m_total;
enum
{
INCREMENT = 64,
DIFFSIZE = 1024,
RELEASESIZE = 512,
};
};
template<class T>
typename BaseAlloc<T>::Node* BaseAlloc<T>::m_freelist = NULL;
template<class T>
int BaseAlloc<T>::m_alloc = 0;
template<class T>
int BaseAlloc<T>::m_total = 0;

[RabbitLBJ]

使用的时候直接继承这个基类就可以了

class Rational4 : public BaseAlloc<Rational4>
{
public:
Rational4(int i)
{
i1 = i;
}
void Print()
{
cout << i1 << endl;
}
private:
int i1;
};

[RabbitLBJ]

[Quote=引用 6 楼 qscool1987 的回复:]

应该考虑加上异常处理机制
[/Quote]

恩，谢谢，确实应该加上
new_handler这些都没考虑，改改

[txwd0033]

大神， 膜拜

[qscool1987]

模板写的还可以，不过你确定要这么多static修饰？

[qscool1987]

应该考虑加上异常处理机制

[程序员小迷]

#ifndef CC_BUFFER_MGR_H
#define CC_BUFFER_MGR_H

//#include "ccCommon.h"
//#include "ccVector.h"

#include <vector>
#include <iostream>
using namespace std;

typedef struct _BufInfo
{
    void *  buf;
    int	    size;
}BufInfo;

class CCBufferMgr
{
public:
    CCBufferMgr(int size = /*PAGE_SIZE*/ 4096):size(size) 
    {
	buf = new char[size];
	BufInfo bufInfo = {buf, size};
	unusedBufVec.push_back(bufInfo);

//	usedBufVec.setReallocSizeUnit(1024);
//	unusedBufVec.setReallocSizeUnit(1024);
    }

    ~CCBufferMgr()
    {
	delete []buf;
    }

public:
    int getSize() const { return size; }
    void * getBufPtr() const { return buf; }

public:
    void *  askOneBuffer(int bufSize);	    // if no avaiable buf, return NULL
    bool    returnBackBuffer(void * buf);   // if return false, the buf isn't allocated from the mgr, it will do nothing

public:
    void show() const;

public:
    void setReallocSizeUnit(int	newReallocSizeUnit);

private:
    void askTwoBuffer( void ** bufOne, int sizeOne, void ** bufTwo , int sizeTwo);

private:
    CCBufferMgr(const CCBufferMgr & bufMgr);
    CCBufferMgr & operator=(const CCBufferMgr & bufMgr);

private:
    void *  buf;
    int	    size;
    //CCVector<BufInfo> usedBufVec;
    //CCVector<BufInfo> unusedBufVec;
	vector<BufInfo> usedBufVec;
    vector<BufInfo> unusedBufVec;
};
#endif

[程序员小迷]

void * CCBufferMgr::askOneBuffer( int bufSize )
{
    int size = unusedBufVec.size();
    if(size < 1)
	return NULL;

    for(int i = 0; i < size; ++i)
    {
	BufInfo bufInfo = unusedBufVec[i];
	if(bufSize <= bufInfo.size)
	{
	    if(bufSize < bufInfo.size)
	    {
		BufInfo extraBuf = {(char *)bufInfo.buf + bufSize, bufInfo.size - bufSize};
		unusedBufVec.push_back(extraBuf);
	    }

	    bufInfo.size = bufSize;
	    usedBufVec.push_back(bufInfo);
	    //unusedBufVec.erase(&unusedBufVec[i]);
		unusedBufVec.erase(unusedBufVec.begin() + i);
   
	    return bufInfo.buf;
	}
    }
    return NULL;
}

bool CCBufferMgr::returnBackBuffer( void * buf )
{
    for(int i = 0; i < usedBufVec.size(); ++i)
    {
	BufInfo bufInfo = usedBufVec[i];
	if(bufInfo.buf == buf)
	{
	    //usedBufVec.erase(&usedBufVec[i]);
		usedBufVec.erase(usedBufVec.begin() + i);
	    unusedBufVec.push_back(bufInfo);
	    return true;
	}
    }
    return false;
}

void CCBufferMgr::askTwoBuffer( void ** bufOne, int sizeOne, void ** bufTwo , int sizeTwo)
{
    void * buf = askOneBuffer(sizeOne);
    if(buf == NULL)
    {
	*bufOne = *bufTwo = NULL;
	return;
    }
    *bufOne = buf;

    buf = askOneBuffer(sizeTwo);
    if(buf == NULL)
    {
	*bufTwo = NULL;
    }
}

void CCBufferMgr::show() const
{
    std::cout << "CCBufferMgr " << this << ": " << std::endl;
    for(int i = 0; i < usedBufVec.size(); ++i)
    {
	const BufInfo * info = &usedBufVec[i];
	std::cout << "Used BufInfo: " << info->buf << ", " << info->size << std::endl;
    }

    for(int i = 0; i < unusedBufVec.size(); ++i)
    {
	const BufInfo * info = &unusedBufVec[i];
	std::cout << "Unused BufInfo: " << info->buf << ", " << info->size << std::endl;
    }

    std::cout << std::endl;
}

void CCBufferMgr::setReallocSizeUnit( int newReallocSizeUnit )
{
//    usedBufVec.setReallocSizeUnit(newReallocSizeUnit);
//    unusedBufVec.setReallocSizeUnit(newReallocSizeUnit);
}