关闭

了解new_handler

标签: C++new-handlenew内存管理
336人阅读 评论(0) 收藏 举报
分类:

了解new_handler

内存管理是C++的难点,也是重点,今天就把new_handler的学习笔记和大家分享。请大家多多指点。
参考书籍:《Effective C++》

关于new_handler

new_handler位于头文件< new >中
当new无法成功申请内存,在抛出异常之前,new会调用一个系统默认或用户指定的错误处理函数,也就是这里的new_handler。我们可以通过set_new_handler来设置我们的错误处理函数。

new_handler的定义

namespace std{
    typedef void(*new_handler)();
    new_handler set_new_handler(new_handler) throw();
}

所以new_handler是一个函数指针。而set_new_handler是用来设置新的new_handler,后返回旧的new_handler的函数。

new_handler的简单使用实例

使用的是vs2015

#include <iostream>
#include <new>
#include <windows.h>

void OutOfMem() {
    std::cout << "内存空间不足" << std::endl;
    abort();
}

int main() {
    std::set_new_handler(OutOfMem);
    char *pint(new char[0x7fffffff]);
    return 0;
}

VS2015

当new发现没有足够内存空间时,调用new_handler指向的函数,打印出“内存空间不足”后 abort() 。如果没有 abort() 它的行为又是怎样的呢?

这里写图片描述

如图所示,他将会无止境的调用OutOfMem。当new无法满足内存申请的要求时,他会不断地调用new_handler,直至new找到一片足够大的内存返回为止。

为类设置自己的new_handler

为类实现自己的new_handler将通过重载 局部的new 实现。
看一个例子:

#include <iostream>
#include <new>
#include <windows.h>

//这里用于保存 默认的全局的new_handler,当该类的析构函数调用时,将handler还原
//相当于一个简易的GC
class HandlerHolder {
public:
    explicit HandlerHolder(std::new_handler nh) :handler(nh) {}
    ~HandlerHolder() { std::set_new_handler(this->handler); } //将保存的默认的全局handler还原
    HandlerHolder(const HandlerHolder&) = delete;  //阻止拷贝行为
    HandlerHolder&operator=(const HandlerHolder&) = delete;//阻止拷贝行为
private:
    std::new_handler handler;//保存 new_handler,这里用来保存全局的new_handler
};

class Demo {
public:
    static std::new_handler set_new_handler(std::new_handler nh) {
        std::new_handler oldhandler = cur_handler;
        cur_handler = nh;
        return oldhandler;
    }
    void * operator new(size_t size)throw(std::bad_alloc){
        HandlerHolder h(std::set_new_handler(cur_handler)); //handlerHolder 保存旧版的new_handler,
                                                            //当new结束时,handlerHolder的析构函数将被调用,
                                                            //new_handler将被还原为全局的new_handler
        return ::operator new(size);  //调用全局的new
    }
        void *operator new[](size_t size) {
        return operator new(size);
    }
private:
    static std::new_handler cur_handler;//保存当前的new_handler
};

std::new_handler Demo::cur_handler(nullptr);

void OutOfMem() {
    std::cout << "Run out of Men" << std::endl;
    abort();
}

int main() {
    Demo::set_new_handler(OutOfMem);
    Demo * p(new Demo[0x7fffffff]);
    //1.当new发生时,首先调用Demo的operator new[]跳转到operator new,这时在new函数中,new_handler被装载
    //2.如果new失败,将调用OutOfMen;如果new成功,将返回内存地址,HandlerHolder将被析构,在析构时调用set_new_handler
    //  还原装载OutOfMem之前的new_handler
    return 0;
}

这里写图片描述
在Demo::set_new_handler的参数中,我们可以传入各种自定义的内存分配失败的处理方法。在《Effective C++》中,为我们呈现了几种:

1.让更多的内存可以被使用(也就是清理内存,让出更多的空间给这里的内存分配操作)
2.安装另一个new_handler(当这个new_handler无法处理当前分配失败的情况时,我们可以装在另外一个new_handler试图处理这种情况)
3.卸载new_handler(如果当前的new_handler确实无法处理当前错误,那么就将当前的new_handler卸载,例如nullptr,让new抛出bad::alloc的异常)
4.直接抛出bad::alloc的异常
5.调用abort()或exit()直接终止程序

用继承和模板为类提供其独有的new_handler

#include <iostream>
#include <new>
#include <Windows.h>

//这里用于保存 默认的全局的new_handler,当该类的析构函数调用时,将handler还原
//相当于一个简易的GC
class HandlerHolder {
public:
    explicit HandlerHolder(std::new_handler nh) :handler(nh) {}
    ~HandlerHolder() { std::set_new_handler(this->handler); } //将保存的默认的全局handler还原
    HandlerHolder(const HandlerHolder&) = delete;  //阻止拷贝行为
    HandlerHolder&operator=(const HandlerHolder&) = delete;//阻止拷贝行为
private:
    std::new_handler handler;//保存 new_handler,这里用来保存全局的new_handler
};

template<typename T>class NewHandler {
public:
    static std::new_handler set_new_handler(std::new_handler nh) {
        std::new_handler oldhandler = cur_handler;
        cur_handler = nh;
        return oldhandler;
    }
    void *operator new(size_t size){
        HandlerHolder holder(std::set_new_handler(cur_handler));
        return ::operator new(size);
    }
        void *operator new[](size_t size) {
        return operator new(size);
    }
private:
    static std::new_handler cur_handler;
};

template<typename T>std::new_handler NewHandler<T>::cur_handler(nullptr);

class Demo :public NewHandler<Demo> {
public:
private:
    static std::new_handler cur_handler;//保存当前的new_handler
};

void OutOfMem() {
    std::cout << "Run out of Mem" << std::endl;
    abort();
}

int main() {
    Demo::set_new_handler(OutOfMem);
    Demo * p(new Demo[0x7fffffff]);
    return 0;
}

这里写图片描述

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:20692次
    • 积分:439
    • 等级:
    • 排名:千里之外
    • 原创:20篇
    • 转载:1篇
    • 译文:0篇
    • 评论:0条