1. 问题
动态申请数组可以无限大吗?如果动态分配一个很大的数组会出现什么情况?
int main(){
int *p = new int[0x1fffffff];
}
执行结果:程序终止
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
我们可以尝试捕获异常
#include
int main(){
try{
int *p = new int[0x1fffffff];
}catch(std::exception& e){
std::cout << e.what() << std::endl;
}
}
执行结果:程序退出
std::bad_alloc
2. 内存申请失败
当申请内存不够时就会抛出out of memory
的异常。但是有时,我们希望能够调用自己定制的异常处理函数,优先处理。这就是set_new_handler
。
// 定义在中
namespace std{
typedef void (*new_handler)();
std::new_handler set_new_handler( std::new_handler new_p );
}
例子
#include
void out_of_memory() {
std::cout<<"out of memory!"<
执行结果:
out of memory!
out of memory!
out of memory!
out of memory!
out of memory!
...
分析
当operator new
申请一个内存失败的时候,它会进行如下的处理步骤:
- 如果存在客户指定的处理函数,则调用处理函数(
new_handler
),如果不存在则抛出一个异常。 - 继续申请内存分配请求。
- 判断申请内存是否成功,如果成功则返回内存指针,如果失败转向处理步骤1
当operator new
无法满足内存分配需求时,它会不断调用new_handler
函数,直到找到足够的内存。
处理
如何避免重复调用new_handler
函数?
#include
void out_of_memory() {
std::cout<<"out of memory!"<
执行结果:
out of memory!
std::bad_alloc
3. set_new_handler
机制的运行原理
当operator new
无法满足某一个内存分配的需求的时候,它会抛出一个异常。在这之前,它会先调用一个用户制定的错误处理函数new_handler
。为了指定这个处理内存不足的函数,用户需要调用标准库程序函数set_new_handler
。
4. 设计new_handler
函数
- 删除其它无用的内存
使系统具有可以更多的内存可以使用,为下一步的内存申请作准备。
实现此策略的办法是:程序一开始执行就分配一大块内存,当new_handler
被调用时,将它们释放还给程序使用。 - 设置另外一个
new_handler
。
如果当前的new_handler
不能够做到更多的内存申请操作,或者它知道另外一个new_handler
可以做到,则可以调用set_new_handler
函数设置另外一个new_handler
,这样在operator new
下一次调用的时候,可以使用这个新的new_handler
。 - 卸载
new_handler
,使operator new
在下一次调用的时候,因为new_handler
为空抛出内存申请异常。 -
new_handler
抛出自定义的异常。 - 不再返回,调用
abort()
或者exit()
退出程序。
类的new_handler
上面的new_handler
是全局的new_handler
,对类也可以使用。
#include
void out_of_memory() {
std::cout<<"out of memory!"<
但是如果要实现类自己的new_handler
,就需要添加如下处理。
1. 添加静态的new_handler
函数和operator new
函数
class Test{
public:
static std::new_handler set_new_handler(std::new_handler p) throw();
static void* operator new(std::size_t size) throw(std::bad_alloc);
private:
static std::new_handler currentHandler;
int data[0x1fffffff];
};
new_handler Test::currentHandler = 0;
2. 实现set_new_handler
函数
new_handler Test::set_new_handler(new_handler p) throw() {
new_handler oldHandler = currentHandler;
currentHandler = p;
return oldHandler;
}
3. 实现operator new
函数
void* Test::operator new(std::size_t size) throw(std::bad_alloc) {
HandlerHolder holder(std::set_new_handler(currentHandler));
return ::operator new(size);
}
其中,HandlerHolder
是一个简单的资源处理类。
class HandlerHolder{
public:
explicit HandlerHolder(std::new_handler nh):handler(nh){}
~HandlerHolder(){
std::set_new_handler(handler);
}
private:
std::new_handler handler;
HandlerHolder(HandlerHolder const&);
HandlerHolder& operator=(HandlerHolder const&);
};
测试代码
#include
void out_of_memory() {
std::cerr<<"out of memory!"<
执行结果
class out of memory!
如果把Test* p = new Test;
改为int* p = int[0x1fffffff]
,执行结果是
out of memory!
问题
如果是Test* p = new Test[0x1fffffff];
呢?
扩展阅读
- 《Effective c++》第三版 条款49:了解
new_handler
的行为