本文主要是介绍Effective C++ 8. 定制 new 和 delete，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
条款49: 了解new-handler的行为为了指定这个"用以处理内存不足"的函数，客户必须调用 set_new_handler, 那是声明于
<new>的标准程序库函数。
namespace std
{
typedef void (*new_handler) {};
new_handler set_new_handler(new handler p) throw();
}
// 你可以这样使用 set_new_handler
void OutOfMem()
{
std::cerr<<"Unable to satisfy request for memory"<<std::endl;
std::abort();
}
int main()
{
std::set_new_handler(OutOfMem);
int* pBigDataArray = new int[100000000L];
... ...
}
就本例而言， operator new 无法为 100000000 个整数分配足够的内存空间， OutOfMem会被调用，于是程序在
发出一个信息之后夭折(abort)。
operator new抛出异常以反映一个未获满足的内存需求之前，它会先调用一个客户指定的错误处理函数，客户必须调用set_new_handler设定。
class NewHandlerHolder
{
public:
// 禁止隐式转化
explicit NewHandlerHolder (std::new_handler nh):handler(nh){}
// 析构函数
~NewHandlerHolder() {std::set_new_handler(handler);}
private:
std::new_handler handler;
};
class Widget
{
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;
};
// Widget静态成员变量 和 静态成员函数的定义
std::new_handler Widget::currentHandler = 0;
std::new_handler Widget::set_new_handler (std::new_handler p) throw
{
std::new_handler oldHandler = currentHandler;
currentHandler = p;
return oldHandler;
}
void* Widget:: operator new (std::size_t size) throw
{
NewHandlerHolder h( std::set_new_handler(currentHandler) );
return ::operator new(size);
}
条款50：了解new和delete的合理替换时机
略
条款51：编写new和delete时需固守常规
实现一致性operator new必得返回正确的值，内存不足时必得调用new-handling函数，必须有对付0内存需求的准备。
operator new返回值十分单纯，如果它有能力供应客户申请的内存，就返回一个指针指向那块内存，如果没有那个能力，抛出一个bad_alloc异常。
然而也不是非常单纯，因为operator new实际上不只一次尝试分配内存，并在每次失败后调用new-handling函数。
这里假设new-handling函数能够做某些动作将内存释放出来，只有当new-handling指针为null时，operator new才会抛出异常。
下面是 non-member operator new 的伪码
void* operator new(std::size_t size) throw(std::bad_alloc)
{
using namespace std;
if(0 == size)
size = 1;
while(true)
{
尝试分配 size bytes;
if 分配成功
return 一个指针指向分配的内存
new_handler globalHandler = set_new_handler(0);
set_new_handler(globalHandler);
if(globalHandler)
(*globalHandler)();
else
throw std::bad_alloc();
}
}
许多人没有考虑operator new成员函数会被derived class继承。一旦被继承base class的operator new被调用以分配derived class对象。例如：
class Base{
public: static void * operator new(std::size_t size) throw(std::bad_alloc);
…
}
class Derived: public Base { … }
Derived* p = new Derived; //调用Base::operator new
解决方法：
void * Base::operator new(std::size_t size) throw(std::bad_alloc)
{
if(size != sizeof(Base) ) return ::operator new(size);
…
}
operator new 应该内含有一个无穷循环，并在其中尝试分配内存，如果它无法满足内存需求，就该调用 new-handler.
它也应该有能力处理 0 bytes 申请。 class 专属版本则还应该还处理 "比正确大小更大的(错误)申请"
operator delete 应该在收到 null 指针时不做任何事情。 class 专属版本则还应该处理"比正确大小更大的(错误)申请"
条款52：写了placement new也要写placement delete
如果operator new接受的参数除了一定会有的那个size_t之外还有其他，这便是所谓的placement new。
众多placement new版本中特别有用的一个是“接受一个指针指向对象该被构造之处”，那样的operator new声明如下：
void * operator new(std::size_t, void *)throw();
对于以下代码：
class Widget{
public:
static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);
static void operator delete(void* pMemory, std::size_t size)throw( );
…
};
上述代码存在微妙的内存泄漏。它在动态创建一个Widget时将相关分配信息志记于cerr:
Widget* pw = new (std::cerr) Widget;
如果内存分配成功，但Widget构造函数抛出异常，运行系统有责任取消operator new的分配。运行系统会寻找参数个数和类型都 与operator new相同 的某个operator delete，如果找到，那就是它的调用对象。
class Widget{
public:
static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);
static void operator delete(std::size_t size, std::ostream& logStream)throw( );
static void operator delete(void* pMemory) throw( );
…
};
Widget* pw = new (std::cerr) Widget; //不再泄漏
但 delete pw;//调用正常的operator delete，而非 placement版本。
因此，我们必须同时提供一个正常的operator delete和一个placement版本（参数必须和operator new一样）。只要这样做，就不会有难以察觉的内存泄漏了。
另外，考虑到成员函数的名称会掩盖其外因作用域中的相同名称，例如：
class Base{
public:
static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);
…
};
Base* pb = new Base; //error,掩盖
Base* pb = new (std::cerr) Base; //OK
同理，derived classes 中的operator new掩盖global版本和继承版。
class Derived: public Base{
public:
static void* operator new(std::size_t size) throw(std::bad_alloc);
…
};
Derived* pd = new (std::clog) Derived; //error,掩盖
Derived* pd = new Derived;
解决办法：建立一个base class,内含所有正常形式的new 和 delete。
若想以自定义形式扩展标准形式的客户，可利用继承机制及using声明式取得标准形式。
这篇关于Effective C++ 8. 定制 new 和 delete的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
