1. 问题
动态申请数组可以无限大吗？如果动态分配一个很大的数组会出现什么情况？
int main(){
int *p = new int[0x1fffffff];
}
执行结果：程序终止
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
我们可以尝试捕获异常
#include <iostream>
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。
// 定义在<new>中
namespace std{
typedef void (*new_handler)();
std::new_handler set_new_handler( std::new_handler new_p );
}
例子
#include <iostream>
void out_of_memory() {
std::cout<<"out of memory!"<<std::endl;
}
int main() {
std::set_new_handler(out_of_memory);
try{
int *p = new int[0x1fffffff];
}catch(std::exception& e){
std::cout << e.what() << std::endl;
}
return 0;
}
执行结果：
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 <iostream>
void out_of_memory() {
std::cout<<"out of memory!"<<std::endl;
std::set_new_handler(NULL);
}
int main() {
std::set_new_handler(out_of_memory);
try{
int *p = new int[0x1fffffff];
}catch(std::exception& e){
std::cout << e.what() << std::endl;
}
return 0;
}
执行结果：
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 <iostream>
void out_of_memory() {
std::cout<<"out of memory!"<<std::endl;
std::set_new_handler(NULL);
}
class Test{};
int main() {
std::set_new_handler(out_of_memory);
try{
Test* p = new Test[0x1fffffff];
}catch(std::exception& e){
std::cout << e.what() << std::endl;
}
return 0;
}
但是如果要实现类自己的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 <iostream>
void out_of_memory() {
std::cerr<<"out of memory!"<<std::endl;
std::set_new_handler(NULL);
}
void class_out_of_memory() {
std::cerr<<"class out of memory!"<<std::endl;
std::set_new_handler(NULL);
}
int main(){
std::set_new_handler(out_of_memory);
Test::set_new_handler(class_out_of_memory);
try{
Test* p = new Test;
}catch(std::exception& e){
std::cout << e.what() << std::endl;
}
return 0;
}
执行结果
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的行为
