重载new和delete，处理内存溢出

很多时候，我们使用new/delete来分配和释放内存。那么这篇问题主要讲的是，使用new来处理实际编程中可能出现的内存泄漏的问题。奇怪，既然你说delete可以释放内存呢，只要用好这两个函数，保证匹配不就得了。然后这是一种很被动的做法，当内存泄露了，问题显现出来知道时，事态可能已经很严重了。

那么我们该如何处理呢？

主要思路是重载new和delete。

先提供一个如何重载全局new和delete的简单例子。

//Overload global new/delete
#include <cstdio>
#include <cstdlib>
using namespace std;

void * operator new(size_t sz)
{
printf("operator new:%d Bytes\n",sz);
void* m = malloc(sz);
if(!m)
puts("out of memory");
return m;
}

void operator delete(void *m)
{
puts("operator delete");
free(m);
}

class S{
int i[100];
public:
S() {puts("S::S()");}
~S() {puts("S::~S()");}
};

int main()
{
puts("creating & destroying an int");
int* p = new int(47);
delete p;
puts("creating & destroying an s");
S* s = new S;
delete s;
puts("creating & destroying S[3]");
S* sa = new S[3];
delete []sa;
}

编译运行得：

creating & destroying an int

operator new:4 Bytes

operator delete

creating & destroying an s

operator new:400 Bytes

S::S()

S::~S()

operator delete

creating & destroying S[3]

operator new:1204 Bytes

S::S()

S::S()

S::S()

S::~S()

S::~S()

S::~S()

operator delete

其实这里看得出new的实质其实是调用malloc，而delete实际上调用free。

分析下创建一个类型S的数组时，所需要的字节，其可以知道额外的内存被分配用于存放它所包含对象的数量的信息。

那么接下来对一个类重载new和delete，为其内存分配系统做些标明，表示哪块存储单元被使用，这里使用了一个字节（byte）数组，一个字节代表一块存储单元。

//Local overloaded new & delete
#include <cstddef> //size_t
#include <fstream>
#include <iostream>
#include <new>
using namespace std;
ofstream out("Framis.out");

class Framis{
enum {sz = 10};
char c[sz]; //To take up space,not used
static unsigned char pool[];
static bool alloc_map[];
public:
enum {psize = 100}; //frami allowed
Framis(){ out << "Framis()\n"; }
~Framis(){ out << "~Framis()..."; }
void* operator new(size_t) throw(bad_alloc);
void operator delete(void*);
};

unsigned char Framis::pool[psize * sizeof(Framis)];
bool Framis::alloc_map[psize] = {false};
//size is ignored -- assume a Framis object
void* Framis::operator new(size_t) throw(bad_alloc)
{
for(int i = 0;i < psize;i++)
if(!alloc_map[i])
{
out<<"using block"<< i <<"...";
alloc_map[i] = true;    //Mark it used
return pool + (i * sizeof(Framis));
}
out << "out of memory" <<endl;
throw bad_alloc();
}

void Framis::operator delete(void* m)
{
if(!m)      // check for null pointer
return;
//Assume it was created in the pool
//Calculate which block number it is:
unsigned long block = (unsigned long)m - (unsigned long)pool;
block /= sizeof(Framis);
out<< "freeing block"<<block <<endl;
//Mark it free:
alloc_map[block] = false;
}

int main()
{
Framis* f[Framis::psize];
try{
for(int i = 0;i < Framis::psize;i++)
f[i] = new Framis;
//      new Framis; //out of memory
}catch(bad_alloc){
cerr<<" Out of memory!"<<endl;
}
delete f[10];
f[10] = 0;
//Use released memory;
Framis* x = new Framis;
delete x;
for(int j = 0;j < Framis::psize;j++)
delete f[j];//Delete f[10] ok
}

通过穿件一个能够容纳psize个Framis对象的字节数组的方法，为Framis堆分配了内存。相应地，分配表中也会有psize个成员，其中每一bool类型成员对应一块内存。初始化时，分配表中所有的值都被置为false，第23行。

new（）首先对分配表进行搜索，寻找值为false的成员，找到后将该成员设置为true，并且返回这个存储单元的地址。如果找不到任何空闲内存，将会给跟踪文件发送一个消息，并且产生一个bad_alloc类型的异常信息。

关于这里的异常处理：

函数参数表后的throw(bad_alloc)，它通知了编译器及用户这个函数可产生一个bad_alloc的异常信息，如果没内存可用时，此函数会由throw bad_alloc语句产生一个异常信息，当异常发生时，函数停止执行并把控制权交给catch子句的异常处理。

c++primer及任何一本讲述c++的书都会讲到异常处理。try后用大括号{}包含了可以产生异常信息的所有代码，程序中表示对Framis对象的new的调用。因此当57行的注释去掉时，因为无法分配内存而throw bad_alloc。

try部分后是一个或多个catch子句，每一个都指明他们获取的异常信息的类型，该程序中，catch（bad_alloc）将会捕获bad_alloc类型的异常，其子句被执行。

在main中，先分配足够多的Framis对象后，61行释放掉一个内存，而后又在64行分配内存，表明释放掉的内存可被重用。

其实这里并没有讲如何去处理，只是提供了一种思路：重载new和delete，实时打印相关信息表示内存的使用情况，通过这些信息我们来做处理，甚至可以说是一种log