类的operator new与operator delete的重载

为什么有必要写自己的operator new和operator delete？

答案通常是：为了效率。
缺省版本的operator new是一种通用型的内存分配器，它必须可以分配任意大小的内存块。同样，operator delete也要可以释放任意大小的内存块。operator delete想弄清它要释放的内存有多大，就必须知道当初operator new分配的内存有多大。有一种常用的方法可以让operator new来告诉operator delete当初分配的内存大小是多少，就是在它所返回的内存里预先附带一些额外信息，用来指明被分配的内存块的大小。
缺省的operator new和operator delete具有非常好的通用性，它的这种灵活性也使得在某些特定的场合下，可以进一步改善它的性能。尤其在那些需要动态分配大量的但很小的对象的应用程序里，情况更是如此。

内存池：内存池的作用主要也是为了效率。通过一次申请比较大的内存空间，来避免小空间内存的频繁申请和释放，每次需要为对象分配内存空间时，在已经申请的大空间内分配。空闲区被按照对象大小划分为若干块，块与块之间通过链表组织起来。

参考代码：

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

class airplanerep  // 表示一个飞机对象
{
public:
    airplanerep(int id,const string & s,const string & d)
    {
        ID = id;
        start = s;
        dest = d;
    }

    ~airplanerep()
    {
        cout<<"airplanerep destructor!"<<endl;
    }

    int getID() const
    {
        return ID;
    }

private:
    int ID;
    string start;
    string dest;
};

// 注意airplane和airplanerep含有一样的成员函数，它们的接口完全相同
// 类airplane实际上是个句炳类(Handle class)
class airplane // 修改后的类 — 支持自定义的内存管理
{
public:
    airplane(int id,const string & s,const string & d)
    {
        rep = new airplanerep(id,s,d);
    }

    ~airplane()
    {
        delete rep;
    }

    int getID() const
    {
        return rep->getID();
    }

    static void * operator new(size_t size);
    static void operator delete(void *deadobject,size_t size);

private:
    union
    {
        airplanerep *rep;  // 用于被使用的对象
        airplane *next;    // 用于没被使用的（在自由链表中）对象
    };

    // 类的常量，指定一个大的内存块中放多少个
    // airplane对象，在后面初始化
    static const int block_size;
    static airplane *headoffreelist;
};

airplane *airplane::headoffreelist; //内存池链表头
const int airplane::block_size = 512; //内存池块的个数

void * airplane::operator new(size_t size)
{
    // 把“错误”大小的请求转给::operator new()处理;
    if(size != sizeof(airplane))
        return ::operator new(size);

    airplane *p = headoffreelist; // p指向自由链表的表头

    // p 若合法，则将表头移动到它的下一个元素
    if(p)
        headoffreelist = p->next;
    else
    {
        // 自由链表为空，则分配一个大的内存块，
        // 可以容纳block_size个airplane对象
        airplane *newblock = static_cast<airplane*>(::operator new(block_size * sizeof(airplane)));

        // 将每个小内存块链接起来形成一个新的自由链表
        // 跳过第0个元素，因为它要被返回给operator new的调用者
        for (int i = 1; i < block_size-1; ++i)
            newblock[i].next = &newblock[i+1];

        // 用空指针结束链表
        newblock[block_size-1].next = 0;

        // p 设为表的头部，headoffreelist指向的
        // 内存块紧跟其后
        p = newblock;
        headoffreelist = &newblock[1];
    }

    return p;
}

// 传给operator delete的是一个内存块, 如果
// 其大小正确，就加到自由内存块链表的最前面
void airplane::operator delete(void *deadobject,size_t size)
{
    if(deadobject == 0) return;
    if(size != sizeof(airplane))
    {
        ::operator delete(deadobject);
        return;
    }

    //将要释放的空间插入空闲区链表前端
    airplane *carcass = static_cast<airplane*>(deadobject);
    carcass->next = headoffreelist;
    headoffreelist = carcass;
}

int main()
{
    airplane *pa = new airplane(101,"shanghai","beijing"); // 第一次分配: 得到大块内存，生成自由链表，等
    cout<<pa->getID()<<endl;
    delete pa;

    airplane *pb = new airplane(102,"shanghai","beijing");
    cout<<pb->getID()<<endl;
    delete pb;

    return 0;
}

airplane类的说明：

airplane实际上是个句炳类(Handle class)，通过指针airplanerep * rep指向一个具体的实现，airplane和airplanerep含有一样的成员函数。句柄类实际上都做了些什么：它只是把所有的函数调用都转移到了对应的主体类中，主体类真正完成工作。
operator new函数负责内存池链表的创建，内存池链表的每个块大小和类airplane一样，每次生成对象的时候分配一个块给对象。
operator delete函数负责收回每个对象的内存块，重新添加到内存池链表。
operator new和operator delete需要同时工作，那么你写了operator new，就也一定要写operator delete。
一个联合（使得rep和next域占用同样的空间），一个常量（指定大内存块的大小），一个静态指针（跟踪自由链表的表头）。表头指针声明为静态成员很重要，因为整个类只有一个自由链表，而不是每个airplane对象都有。
注意：::operator new返回的内存块是从来没有被airplane::operator delete释放。内存泄漏和内存池有一个重要的不同之处：内存泄漏会无限地增长，而内存池的大小决不会超过客户请求内存的最大值。

以上内容基本都来自《Effective C++》，稍作修改。

如果类定义了自己的成员new和delete，类的用户可以通过使用全局作用域确定操作符，强制new和delete使用全局的库函数。如：
Type *p = ::new Type;
::delete p;

如果new使用全局的operator new库函数，那么对应的delete也一定要用全局的operator delete库函数。

一个内存分配器基类

CachedObj的功能：类似于内存池的功能。分配和管理已经分配但未构造对象的自由列表。operator new返回自由列表中的一个元素，当自由列表为空时，operator new分配新的原始内存。operator delete在撤销对象时将元素放回自由列表。

template<class T>
class CachedObj
{
public:
    void * operator new(size_t sz);
    void operator delete(void* p, size_t sz);
    virtual ~CachedObj() {}
protected:
    T * next;
private:
    static void add_to_freelist(T * p);
    static allocator<T> alloc_mem;
    static T * free_store;
    static const size_t chunk;
};

template<class T>
allocator<T> CachedObj<T>::alloc_mem;

template<class T>
T* CachedObj<T>::free_store = NULL;

template<class T>
const size_t CachedObj<T>::chunk = 64;

template<class T>
void *CachedObj<T>::operator new(size_t sz)
{
    if(sz != sizeof(T))
        return ::operator new(sz);

    if (!free_store)
    {
        T * array = alloc_mem.allocate(chunk);
        for(size_t i = 0; i != chunk; ++i)
            add_to_freelist(&array[i]);
    }

    T *p = free_store;
    free_store = free_store->next;
    return p;
}

template<class T>
void CachedObj<T>::operator delete(void * p,size_t sz)
{
    if(p == NULL) return;
    if(sz != sizeof(T))
    {
        ::operator delete(p);
        return;
    }
    add_to_freelist(static_cast<T*>(p));
}

template<class T>
void CachedObj<T>::add_to_freelist(T *p)
{
    p->next = free_store;
    free_store = p;
}

如何使用这个类：

// 表示一个飞机对象
class airplanerep: public CachedObj<airplanerep>
{
public:
    airplanerep(int id,const string & s,const string & d)
    {
        ID = id;
        start = s;
        dest = d;
    }

    ~airplanerep()
    {
        cout<<"airplanerep destructor!"<<endl;
    }

    int getID() const
    {
        return ID;
    }

private:
    int ID;
    string start;
    string dest;
};


int main()
{
    airplanerep *pa = new airplanerep(101,"shanghai","beijing");
    cout<<pa->getID()<<endl;
    delete pa;

    airplanerep *pb = new airplanerep(102,"shanghai","beijing");
    cout<<pb->getID()<<endl;
    delete pb;

    return 0;
}