简单的内存分配器

采用自定义的operator运算符实现自己的内存分配策略，在某些时候可以提高程序的效率。

C++中的new运算符，具体工作流程如下：

1.调用operator new申请原始内存

2.调用place new表达式，执行类的构造函数

3.返回内存地址

而delete操作符的工作是：

1.调用对象的析构函数

2.调用operator delete释放内存

这里提供一个简单的内存分配器基类，凡是继承该类的class均具有自定义的operator new 和 operator delete

此示例来自《C++Primer》第四版

大概思想是用static变量维持一个链表，管理空闲的内存块。

代码如下:

#ifndef NEW_H
#define NEW_H 
#include <iostream>
#include <stdexcept>
#include <memory>

template <typename T>
class New
{
public:
    void *operator new(std::size_t );
    void operator delete(void *, std::size_t );
    virtual ~New() { }
protected:
    T *_next;
private:
    static void addToFreeList(T *);     //将内存块加入链表
    static std::allocator<T> _alloc;     //内存分配器
    static T *_freeList;                //空闲内存的链表
    static const std::size_t _chunk;    //一次分配的块数
};

template <typename T> std::allocator<T> New<T>::_alloc;
template <typename T> T *New<T>::_freeList = NULL;
template <typename T> const std::size_t New<T>::_chunk = 24;


template <typename T>
void *New<T>::operator new(std::size_t sz)
{
    if(sz != sizeof(T))
        throw std::runtime_error("wrong size");
    std::cout << "operator new" << std::endl;

    if(_freeList == NULL)
    {
        T *newList = _alloc.allocate(_chunk);
        for(size_t i = 0; i != _chunk; ++ i)
            addToFreeList(&newList[i]);
    }

    T *p = _freeList;
    _freeList = _freeList->New<T>::_next;
    return p;
}

template <typename T>
void New<T>::operator delete(void *p, size_t sz)
{
    std::cout << "operator delete" << std::endl;
    if(p != NULL)
        addToFreeList(static_cast<T *>(p));
}


template <typename T>
void New<T>::addToFreeList(T *p)
{
    p->New<T>::_next = _freeList;
    _freeList = p;
}
#endif  /*NEW_H*/

每次执行new时，调用我们自定义的operator new去空闲链表中取出一块内存，如果链表为空，则执行真正的申请内存操作。

每次delete时，把内存归还给链表。

这样减少了每次new都去申请内存的开销。

测试代码如下：

#include "new.hpp"
#include <iostream>
using namespace std;

//使用继承的策略去使用这个内存分配器
class Test : public New<Test>
{

};

int main(int argc, char const *argv[])
{
    
    //调用自定义的new分配内存
    Test *pt = new Test;
    delete pt;

    //调用默认的new和delete
    pt = ::new Test;
    ::delete pt;

    //不会调用自定义的new和delete
    pt = new Test[10];
    delete[] pt; 

}