book.51cto.com/art/201202/… 编码质量150建议
总体分两个部分，一个是：hi.baidu.com/bellgrade/i… 写的比较容易理解。
另一个是 book.51cto.com/art/201202/… 有具体代码说明，更具体。
————————————————————————————————————————————————————————————
我们都知道，使用 malloc/calloc 等分配内存的函数时，一定要检查其返回值是否为“空指针”（亦即检查分配内存的操作是否成功），这是良好的编程习惯，也是编写可靠程序所必需的。但是，如果你简单地把这一招应用到 new 上，那可就不一定正确了。我经常看到类似这样的代码：
int* p = new int[SIZE];
if ( p == 0 ) // 检查 p 是否空指针
return -1;
// 其它代码
其实，这里的 if ( p == 0 ) 完全是没啥意义的。C++ 里，如果 new 分配内存失败，默认是抛出异常的。所以，如果分配成功，p == 0 就绝对不会成立；而如果分配失败了，也不会执行 if ( p == 0 )，因为分配失败时，new 就会抛出异常跳过后面的代码。如果你想检查 new 是否成功，应该捕捉异常：
try {
int* p = new int[SIZE];
// 其它代码
} catch ( const bad_alloc& e ) {
return -1;
}
据说一些老的编译器里，new 如果分配内存失败，是不抛出异常的（大概是因为那时 C++ 还没加入异常机制），而是和 malloc 一样，返回空指针。不过我从来都没遇到过 new 返回空指针的情况。
当然，标准 C++ 亦提供了一个方法来抑制 new 抛出异常，而返回空指针：
int* p = new (std::nothrow) int; // 这样如果 new 失败了，就不会抛出异常，而是返回空指针
if ( p == 0 ) // 如此这般，这个判断就有意义了
return -1;
// 其它代码
===============================详解===================================
首先按c++标准的话，new失败会抛出bad_alloc异常，但是有些编译器对c++标准支持不是很好，比如vc++6.0中new失败不会抛出异常，而返回0.
//不支持c++标准的做法如下
double *ptr=new double[1000000];
if( 0 == ptr)
……处理失败……
//标准推荐做法一。
try
{
double *ptr=new double[1000000];
}
catch(bad_alloc &memExp)
{
//失败以后，要么abort要么重分配
cerr<<memExp.what()<<endl;
}
//标准推荐做法二
是使用set_new_handler函数处理new失败。它在头文件<new>里大致是象下面这样定义的：
typedef void (*new_handler)();
new_handler set_new_handler(new_handler p) throw();
可以看到，new_handler是一个自定义的函数指针类型，它指向一个没有输入参数也没有返回值的函数。set_new_handler则是一个输入并返回new_handler类型的函数。
set_new_handler的输入参数是operator new分配内存失败时要调用的出错处理函数的指针，返回值是set_new_handler没调用之前就已经在起作用的旧的出错处理函数的指针。
可以象下面这样使用set_new_handler：
// function to call if operator new can't allocate enough memory
void nomorememory()
{
cerr << "unable to satisfy request for memory\n";
abort();
}
int main()
{
set_new_handler(nomorememory);
int *pbigdataarray = new int[100000000];
...
}
operator new不能满足内存分配请求时，new-handler函数不只调用一次，而是不断重复，直至找到足够的内存。实现重复调用的代码在条款8里可以看到，这里我用描述性的的语言来说明：一个设计得好的new-handler函数必须实现下面功能中的一种。
·产生更多的可用内存。这将使operator new下一次分配内存的尝试有可能获得成功。实施这一策略的一个方法是：在程序启动时分配一个大的内存块，然后在第一次调用new-handler时释放。释放时伴随着一些对用户的警告信息，如内存数量太少，下次请求可能会失败，除非又有更多的可用空间。
·安装另一个不同的new-handler函数。如果当前的new-handler函数不能产生更多的可用内存，可能它会知道另一个new-handler函数可以提供更多的资源。这样的话，当前的new-handler可以安装另一个new-handler来取代它(通过调用set_new_handler)。下一次operator new调用new-handler时，会使用最近安装的那个。(这一策略的另一个变通办法是让new-handler可以改变它自己的运行行为，那么下次调用时，它将做不同的事。方法是使new-handler可以修改那些影响它自身行为的静态或全局数据。)
·卸除new-handler。也就是传递空指针给set_new_handler。没有安装new-handler，operator new分配内存不成功时就会抛出一个标准的std::bad_alloc类型的异常。
·抛出std::bad_alloc或从std::bad_alloc继承的其他类型的异常。这样的异常不会被operator new捕捉，所以它们会被送到最初进行内存请求的地方。(抛出别的不同类型的异常会违反operator new异常规范。规范中的缺省行为是调用abort，所以new-handler要抛出一个异常时，一定要确信它是从std::bad_alloc继承来的。想更多地了解异常规范)
·没有返回。典型做法是调用abort或exit。abort/exit可以在标准c库中找到(还有标准c++库)。
上面的选择给了你实现new-handler函数极大的灵活性。
更多知识请参考《Effective c++》
————————————————————————————————————————————————————————————
建议30：new内存失败后的正确处理
应该有很多的程序员对比尔盖茨的这句话有所耳闻：
对于任何一个人而言，640KB应当是足够的了。（640K ought to be enough for everybody.）
不幸的是，伟大的比尔盖茨也失言了。随着硬件水平的发展，内存变得越来越大，但是似乎仍不能满足人们对内存日益增长的需求。所以呢，我们C/C++程序员在写程序时也必须考虑一下内存申请失败时的处理方式。
通常，我们在使用new进行内存分配的时候，会采用以下的处理方式：
- char *pStr = new string[SIZE];
- if(pStr == NULL)
- {
- ... // Error processing
- return false;
- }
你能发现上述代码中存在的问题吗？这是一个隐蔽性极强的臭虫（Bug）。
我们沿用了C时代的良好传统：使用 malloc 等分配内存的函数时，一定要检查其返回值是否为“空指针”，并以此作为检查分配内存操作是否成功的依据，这种Test-for-NULL代码形式是一种良好的编程习惯，也是编写可靠程序所必需的。可是，这种完美的处理形式必须有一个前提：若new失败，其返回值必须是NULL。只有这样才能保证上述看似“逻辑正确、风格良好”的代码可以正确运行。
那么new失败后编译器到底是怎么处理的？在很久之前，即C++编译器的蛮荒时代，C++编译器保留了C编译器的处理方式：当operator new不能满足一个内存分配请求时，它返回一个NULL 指针。这曾经是对C的malloc函数的合理扩展。然而，随着技术的发展，标准的更新，编译器具有了更强大的功能，类也被设计得更漂亮，新时代的new在申请内存失败时具备了新的处理方式：抛出一个bad_alloc exception（异常）。所以，在新的标准里，上述Test-for-NULL处理方式不再被推荐和支持。
如果再回头看看本建议开头的代码片段，其中的 if (pStr == 0 )从良好的代码风格突然一下变成了毫无意义。在C++里，如果 new 分配内存失败，默认是抛出异常。所以，如果分配成功，pStr == 0就绝对不会成立；而如果分配失败了，也不会执行if ( pStr == 0 )，因为分配失败时，new 就会抛出异常并跳过后面的代码。
为了更加明确地理解其中的玄机，首先看看相关声明：
- namespace std
- {
- class bad_alloc
- {
- // ...
- };
- }
- // new and delete
- void *operator new(std::size_t) throw(std::bad_alloc);
- void operator delete(void *) throw();
- // array new and delete
- void *operator new[](std::size_t) throw(std::bad_alloc);
- void operator delete[](void *) throw();
- // placement new and delete
- void *operator new(std::size_t, void *) throw();
- void operator delete(void *, void *) throw();
- // placement array new and delete
- void *operator new[](std::size_t, void *) throw();
- void operator delete[](void *, void *) throw();
在以上的new操作族中，只有负责内存申请的operator new才会抛出异常std::bad_alloc。如果出现了这个异常，那就意味着内存耗尽，或者有其他原因导致内存分配失败。所以，按照C++标准，如果想检查 new 是否成功，则应该捕捉异常：
- try
- {
- int* pStr = new string[SIZE];
- ... // processing codes
- }
- catch ( const bad_alloc& e )
- {
- return -1;
- }
但是市面上还存在着一些古老编译器的踪迹，这些编译器并不支持这个标准。同时，在这个标准制定之前已经存在的很多代码，如果因为标准的改变而变得漏洞百出，肯定会引起很多人抗议。C++标准化委员会并不想遗弃这些 Test-for-NULL的代码，所以他们提供了operator new 的另一种可选形式— nothrow ，用以提供传统的Failure-yields-NULL行为。
其实现原理如下所示：
- void * operator new(size_t cb, const std::nothrow_t&) throw()
- {
- char *p;
- try
- {
- p = new char[cb];
- }
- catch (std::bad_alloc& e)
- {
- p = 0;
- }
- return p;
- }
文件中也声明了nothrow new的重载版本，其声明方式如下所示：
- namespace std
- {
- struct nothrow_t
- {
- // ...
- };
- extern const nothrow_t nothrow;
- }
- // new and delete
- void *operator new(std::size_t, std::nothrow_t const &) throw();
- void operator delete(void *, std::nothrow_t const &) throw();
- // array new and delete
- void *operator new[](std::size_t, std::nothrow_t const &) throw();
- void operator delete[](void *, std::nothrow_t const &) throw();
如果采用不抛出异常的new形式，本建议开头的代码片段就应该改写为以下形式：
- int* pStr = new(std::nothrow) string[SIZE];
- if(pStr==NULL)
- {
- ... // 错误处理代码
- }
根据建议29可知，编译器在表达式 new (std::nothrow) ClassName中一共完成了两项任务。首先，operator new 的 nothrow 版本被调用来为一个ClassName object分配对象内存。假如这个分配失败，operator new返回null指针；假如内存分配成功，ClassName 的构造函数则被调用，而在此刻，对象的构造函数就能做任何它想做的事了。如果此时它也需要new 一些内存，但是没有使用 nothrow new形式，那么，虽然在"new (std::nothrow) ClassName" 中调用的operator new 不会抛出异常，但其构造函数却无意中办了件错事。假如它真的这样做了，exception就会像被普通的operator new抛出的异常一样在系统里传播。所以使用nothrow new只能保证operator new不会抛出异常，无法保证"new (std::nothrow) ClassName"这样的表达式不会抛出exception。所以，慎用nothrow new。
最后还需要说明一个比较特殊但是确实存在的问题：在Visual C++ 6.0 中目前operator new、operator new(std::nothrow) 和 STL 之间不兼容、不匹配，而且不能完全被修复。如果在非MFC项目中使用Visual C++6.0中的STL，其即装即用的行为可能导致STL在内存不足的情况下让应用程序崩溃。对于基于MFC的项目，STL是否能够幸免于难，完全取决于你使用的 STL 针对operator new的异常处理。这一点，在James Hebben的文章《不要让内存分配失败导致您的旧版 STL 应用程序崩溃》中进行了详细的介绍，如果你在使用古老的Visual C++ 6.0编译器，而且对这个问题充满兴趣，请Google之。
请记住：
当使用new申请一块内存失败时，抛出异常std::bad_alloc是C++标准中规定的标准行为，所以推荐使用try{ p = new int[SIZE]; } catch( std::bad_alloc ) { ... }的处理方式。但是在一些老旧的编译器中，却不支持该标准，它会返回NULL，此时具有C传统的Test_for_NULL代码形式便起了作用。所以，要针对不同的情形采取合理的处置方式。
============================================================================================
关于new你应当知道的一切
new在C++中是一个我们经常用到的运算符。由它所创建的变量会被分配在堆中，并且在程序结束之前应当将分配的内存delete掉，否则就会导致内存泄漏。但是除此之外，你对new有更深入的了解吗？本篇文章将深入探讨C++中的new运算符，我在这篇文章中总结了new的以下知识点：
1. new内存分配失败后的处理
如果你认为new分配失败后应当如以下代码处理：
| 12345 | int``*p=``new int``;``if``(!p)``{`` ``//error processing``} |
|---|
那么你就大错特错了。C++中规定当new分配失败时，它会抛出一个bad_alloc exception，此时应当采用异常处理的方法：
| 12345678 | try``{`` ``int``* pStr=``new string[SIZE];``}``catch``(``const bad_alloc& e)``{`` ``//error processing ``} |
|---|
2. new的三种形态。
new实际上有三种形态：new operator、operator new和placement new。
new operator是我们最常用的形态（用法如上文的代码所示），它是语言内建的，不能重载，也不能改变其行为。它在执行过程中，与其余的两种形态都发生了密切的关系：第一步通过operator new来实现内存申请，第二步通过placement new来调用构造函数。
operator new在默认情况下为调用分配内存的代码，尝试从堆上得到一段空间，如果分配成功则直接返回，分配失败则调用new_handler函数，然后继续重复前面的过程，直到抛出了异常为止。如下的代码便重载了A的operator new函数：
| 12345678910111213 | class A``{``public``:`` ``A(``int a);`` ``~A();`` ``void``* operator ``new``(``size_t size); ``} void``* A::operator ``new``(``size_t size)``{`` ``cout<<``"A's operator new"``<<endl;`` ``return ::operator ``new``(size);``} |
|---|
这里调用了全局的new来进行内存分配。
placement new则是决定在分配的空间里采用哪种构造函数。通常情况下，构造函数是由编译器自动调用的，但你也可以手动调用构造函数。如以下代码所示：
| 1234567891011121314151617181920212223242526272829303132 | #include <iostream>``class X``{``public``:`` ``X() { std::cout << ``"constructor of X" << std::endl; }`` ``~X() { std::cout << ``"destructor of X" << std::endl; } ``void SetNum(``int n)`` ``{`` ``num = n;`` ``} ``int GetNum()`` ``{`` ``return num;`` ``} private``:`` ``int num;``}; int main()``{`` ``char``* buf = ``new char``[``sizeof``(X)];`` ``X *px = ``new``(buf)X;`` ``px->SetNum(10);`` ``std::cout << px->GetNum() << std::endl;`` ``px->~X();`` ``delete``[]buf; ``return 0;``} |
|---|
当然，如果显示地调用placement new,那么也得显示地调用对应的placement delete。
placement new的意义在于，operator new开辟内存是比较花费时间的，因此你可以一次用operator new开辟一片内存，然后利用placement new重复地在这片内存上构建对象，这样可以省去很多时间。
3. new_handler函数
在使用operator new申请内存失败之后， 编译器会调用new_handler函数来进行相应的处理。你可以定制属于自己的new_handler函数，只需要调用<new>中的set_new_handler之中即可，set_new_handler的参数为一个函数指针，返回值为指向的是set_new_handler调用之前的异常处理函数。
我们也可以根据类设定不同的new_handler函数，以下是一个例子：
| 123456789101112131415161718192021222324252627 | class A``{``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);`` ``static void MemoryErrorHandling(); ``// new_handler function``private``:`` ``static std::new_handler m_curHandler;``};``std::new_handler A::m_curHandler=NULL;``std::new_handler A::set_new_handler(std::new_handler p)``throw``()``{`` ``std::new_handler old_handler=m_curHandler;`` ``m_curHandler=p;`` ``return old_handler;``} void MemoryErrorHandling()``{`` ``//...``} void *operator ``new (std::``size_t size)``throw``(std::bad_alloc)``{`` ``set_new_handler(MemoryErrorHandling);`` ``return ::operator ``new``(size);``} |
|---|
