New Handler

1.new handler

   （1）当operator new 没能力为你分配出你所申请的memory，会抛一个std::bad_alloc exception。某些老编译器则是返回0---你仍然可以令编译器那么做：

             new (nothrow) Foo;

             此为nothrow形式。

   （2）抛出exception之前会先（不止一次）调用一个可由client指定的handler，以下是new handler的形式和设定方法：

             typedef void (*new_handler)();

             new_handlerset_new_handler(new_handler p) throw();

   （3）设计良好的new handler只有两种选择：

            [1]更多memory可用

            [2]调用abort()或exit()、

   （4）

            void* operator new(size_t size, const std::nothrow_t&)

                                                _THROW0()

            {
                   //try to allocate size bytes
                   void* p;
                   while((p = malloc(size)) == 0) {
                           //buy more memory or return null pointer
                  _TRY_BEGIN
                           if(_callnewh(size) == 0) break;
                  _CATCH(std::bad_alloc) return (0);
                  _CATCH_END
                  }
                  return (p);

          }

 （5）示例

   

#include <iostream>#include <new>#include <cassert>using namespace std;void noMoreMemory() {cout << "Out of memory";abort();}int main() {set_new_handler(noMoreMemory);int* p = new int[100000000000000000];assert(p);p = new int[10000000000000];assert(p);return 0;}

本例中的new handler中若无调用abort()，执行后cerr会不断出现"out of memory"，需强制中断。这样的表现是正确的，表示当operator new无法满足申请量时，会不断调用new handler直到获得足够memory

（6）new_handler __cdecl set_new_handler(

                                            new_handlernew_p)

           {

                     //cannot use stub to register a new handler

                    assert(new_p == 0);

                    //remove current handler

                    _set_new_handler(0);

                    return 0;

           }

2.=default，=delete

  class Foo {

  public:

            Foo() = default;

            Foo(const Foo&) = default;

            Foo& operator=(const Foo&) = delete;

            ~Foo() = default;

  };

  it is not only for constructors and assignments,but also applies to operator new/new[],operator delete/delete[] and their overloads.

#include <iostream>using namespace std;class Foo {public:long L;public:Foo() {}Foo(long l): L(l) {}//static void* operator new(size_t size) = default;//error: 'static void* Foo::operator new(size_t)' cannot be defaulted//static void operator delete(void* pdead, size_t size) = default;//error: 'static void Foo::operator delete(void*, size_t)' cannot be defaultedstatic void* operator new[](size_t size);static void operator delete[](void* pdead, size_t size);};class Goo {public:long L;public:Goo() {}Goo(long l): L(l) {}static void* operator new(size_t size) = delete ;static void operator delete(void* pdead, size_t size) = delete ;};int main() {Foo* p1 = new Foo(5);delete p1;//Foo* pF = new Foo[10];//delete[] pF;//Goo* p2 = new Goo(7);//delete p2;Goo* pG = new Goo[10];delete[] pG;return 0;}