[effictive c++]在new失败的时候该做点什么呢

  在new分配内存失败的时候，标准里有个std::new_handle函数来处理，在new_handle里会反复的申请内存，直到申请成功或者失败退出。其过程为new  调用 operator new ，而operator new 中如果出错，会交给 new_handle 来处理。

 在自己的程序中，如果要改写这个new_handle ，自己处理new出错的情况，该怎么办呢？我们可以重载operator new，在operator new 函数中定义自己的new_handle 函数。

代码如下：

#include <iostream>


//operator new不能满足内存分配请求时，new-handler函数不只调用一次，而是不断重复，直至找到足够的内存。
//如果在类中申请的内存失败，而又不想调用全局的set_new_handle处理函数,要自己写，该怎么写呢？
template <new_handler new_hanle_type>
class c_test
{
public:
	c_test(){current_handle = new_hanle_type; }
	virtual ~c_test(){}

	virtual void no_memory()
	{
		std::cerr << "out of memory" << std::endl;
	}
public:
	static new_handler set_new_handler(new_handler p);
	static void* operator new(size_t size);
private:
	static new_handler current_handle ;

};

// template <typename new_hanle_type>
// new_handler c_test<new_hanle_type>::current_handle = 0;

template <new_handler new_hanle_type>
new_handler c_test<new_hanle_type>::set_new_handler(new_handler p)
{
	new_handler old_handle = c_test::current_handle;
	current_handle = p;
	return old_handle;
}

template <new_handler new_hanle_type>
void* c_test<new_hanle_type>::operator new(size_t size)
{
	std::cout  << "operator new function" << std::endl;
	
	// 安装c_test的new_handle
	new_handler global_handle = std::set_new_handler(current_handle);

	void *memory;
	try
	{
		//调用全局的new 函数,如果operator new  失败，则调用自己的出错处理函数
		memory = ::operator new(size);
	}
	catch (std::bad_alloc &)
	{
		std::set_new_handler(global_handle);
		throw;
	}

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

// class no_memory
// {
// public:
// 	virtual void out_of_memory()
// 	{
// 		std::cerr << "out of memory " << std::endl;
// 	}
// };

void out_of_memory()
{
	//在这里写出自己的new失败处理函数
}

int main()
{
	
	c_test<out_of_memory>* my_c_test = new c_test<out_of_memory>;



	return 0;
}

在这里讲new_handle函数作为模版参数，这样对于每个不同的类，或者继承，只要给出自己才出错处理函数就可以了。

参考或者说是抄袭 ： << effictive c++ >>