处理new分配失败

1993年前，c++一直要求在内存分配失败时operator new要返回0，现在则是要求operator new抛出std::bad_alloc异常。很多c++程序是在编译器开始支持新规范前写的。c++标准委员会不想放弃那些已有的遵循返回0规范的代码，所以他们提供了另外形式的operator new(以及operator new[])以继续提供返回0功能。这些形式被称为“无抛出”，因为他们没用过一个throw，而是在使用new的入口点采用了nothrow对象：

class widget { ... };

widget* pw1 = new widget;// if allocated failed throw std::bad_alloc

if (pw1 == 0) ...	// must be failed

widget* pw2 = new (nothrow)widget; 	// if allocated failed return 0(NULL)
	
if (pw2 == 0) ...	// maybe successful 

operator new默认情况下如果不能满足内存分配请求时会抛出的异常类型std::bad_alloc。因此，如果你不愿意看到诸如：widget* pw2 = new (nothrow) widget; 这样带着nothrow的operator new，最简单的方法是使用set_new_handler自定义newhandler函数。最简单的例子如下：

// main.cpp (vc9.0)

#include "stdafx.h"
#include<new>
#include<iostream>
#include<stdlib.h>
using namespace std;

void __cdecl newhandlerfunc()
{
	cerr << "Allocate failed." << endl;
	abort();
}

int main() 
{
	set_new_handler (newhandlerfunc);
	while (1) 
	{
		int* p = new int[500000000];	// based on own machine's memory size
		cout << "Allocating 500000000 int." << endl;
	}
}

newhandlerfunc函数中没有参数也没有返回值，可提供的信息有限，这样的全局通用函数在c++项目中所能起的作用不大。所以，鉴于c++本身的面向对象的设计，我们考虑每个类有自己的newhandler，与全局的newhandler共存。比较简单的例子如下：

// main.cpp (vc9.0)

#include "stdafx.h"
#include<new>
#include<iostream>
#include<stdlib.h>
using namespace std;

void __cdecl newhandlerfunc()
{
	cerr << "Allocate failed." << endl;
	abort();
}

void __cdecl xnewhandlerfunc()
{
	cerr << "Allocate x object failed" << endl;
	abort();
}

class x {
public:
	x()
	{
		while (1) 
		{
			int* p = new int[500000000];
			cout << "Allocating 500000000 int." << endl;
		}
	}

	static new_handler set_new_handler(new_handler p)
	{
		new_handler oldhandler = currenthandler;
		currenthandler = p;
		return oldhandler;
	}

	static void * operator new(size_t size)
	{
		// setup x's new_handler, now it replaces global handler
		new_handler globalhandler = set_new_handler(currenthandler); 

		void *memory;
		try 
		{ 	
			memory = ::operator new(size); // try to allocate memory
		}
		catch (std::bad_alloc&) // handled by x's new_handler
		{ 	
			set_new_handler(globalhandler); // recover old new_handler     
			throw;	// rethrow exception
		}

		// allocate normally
		std::set_new_handler(globalhandler);	// recover old new_handler 
		return memory;
	}

private:
	static new_handler currenthandler;
};

new_handler x::currenthandler = NULL;

int main() 
{
	//set_new_handler(newhandlerfunc);
	//while (1) 
	//{
	//	int* p = new int[500000000];
	//	cout << "Allocating 500000000 int." << endl;
	//}
	x::set_new_handler(xnewhandlerfunc);
	x* p = new x;

	return 0;
}

如果每个类都这样地写一遍，感觉有些代码重复，所以可能想到会写一个基类，让所有的子类可以继承set_new_handler和operator new功能，但要使每个子类有不同的currenthandler数据成员，一个比较简单的方法就是设计一个模板。
例子如下：

// SetNewHandler.h (vc9.0)

#include<new>
#include<iostream>
#include<stdlib.h>
using namespace std;

template<class t>	
class newhandlersupport {	
public:
	static new_handler set_new_handler(new_handler p);
	static void * operator new(size_t size);

private:
	static new_handler currenthandler;
};

template<class t>
new_handler newhandlersupport<t>::set_new_handler(new_handler p)
{
	new_handler oldhandler = currenthandler;
	currenthandler = p;
	return oldhandler;
}

template<class t>
void * newhandlersupport<t>::operator new(size_t size)
{
	new_handler globalhandler = set_new_handler(currenthandler);
	void *memory;
	try 
	{
		memory = ::operator new(size);
	}
	catch (std::bad_alloc&) 
	{
		set_new_handler(globalhandler);
		throw;
	}

	std::set_new_handler(globalhandler);
	return memory;
}

template<class t>
new_handler newhandlersupport<t>::currenthandler = NULL;

 

// main.cpp (vc9.0)

#include "stdafx.h"
#include "SetNewHandler.h"
#include<new>
#include<iostream>
#include<stdlib.h>
using namespace std;

void __cdecl newhandlerfunc()
{
	cerr << "Allocate failed." << endl;
	abort();
}

void __cdecl xnewhandlerfunc()
{
	cerr << "Allocate x object failed" << endl;
	abort();
}

void __cdecl ynewhandlerfunc()
{
	cerr << "Allocate y object failed" << endl;
	abort();
}

class x {
public:
	x()
	{
		while (1) 
		{
			int* p = new int[500000000];
			cout << "Allocating 500000000 int." << endl;
		}
	}

	static new_handler set_new_handler(new_handler p)
	{
		new_handler oldhandler = currenthandler;
		currenthandler = p;
		return oldhandler;
	}

	static void * operator new(size_t size)
	{
		// setup x's new_handler, now it replaces global handler
		new_handler globalhandler = set_new_handler(currenthandler);

		void *memory;
		try 
		{ 	
			memory = ::operator new(size); // try to allocate memory
		}
		catch (std::bad_alloc&) // handled by x's new_handler
		{ 	
			set_new_handler(globalhandler); // recover old new_handler     
			throw;	// rethrow exception
		}

		// allocate normally
		std::set_new_handler(globalhandler);	// recover old new_handler 
		return memory;
	}

private:
	static new_handler currenthandler;
};

new_handler x::currenthandler = NULL;

class y: public newhandlersupport<y> 
{
public:
	y()
	{
		while (1) 
		{
			int* p = new int[500000000];
			cout << "Allocating 500000000 int." << endl;
		}
	}
};		

int main() 
{
	//set_new_handler(newhandlerfunc);
	//while (1) 
	//{
	//	int* p = new int[500000000];
	//	cout << "Allocating 500000000 int." << endl;
	//}

	//x::set_new_handler(xnewhandlerfunc);
	//x* p = new x;

	y::set_new_handler(ynewhandlerfunc);
	y* p = new y;

	return 0;
}

参考：<<Effective C++>>

转载请注明。