#ifndef _NEW
#define _NEW

#include <cstddef>
#include <exception>

extern "C++" {

namespace std 
{
  
  //注意此空间内函数或者变量处于std空间，使用时需要添加std::调用
  /**
   *  当内存分配错误的时候抛出bad_alloc异常
   */
  class bad_alloc : public exception 
  {
  public:
    bad_alloc() throw() { }
    virtual ~bad_alloc() throw();
  };

  //当内存分配失败时用此结构体替代异常，使用嵌入式环境，嵌入式环境没有异常功能
  struct nothrow_t { };
  extern const nothrow_t nothrow;

  ///当内存分配失败时，调用new_handler
  ///new_handler试着去分配更多得存储空间，当且仅当申请内存成功时，才会返
  ///否则抛出bad_alloc异常或者终止程序（调用abort或者exit）
  typedef void (*new_handler)();
  new_handler set_new_handler(new_handler) throw();
} // namespace std

//全局空间函数，调用时加上作用域解析符，如::operator new ()
void* operator new(std::size_t) throw (std::bad_alloc);
void* operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void*) throw();
void operator delete[](void*) throw();
void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();

//placement operator new/delete

inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }


inline void  operator delete  (void*, void*) throw() { }
inline void  operator delete[](void*, void*) throw() { }

} // extern "C++"

#endif

int* a = (int *)::operator new(sizeof(int));

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) {       // try to allocate size bytes
        void *p;
        while ((p = malloc(size)) == 0)
                if (_callnewh(size) == 0)
                {       // report no memory
                static const std::bad_alloc nomem;
                _RAISE(nomem);
                }

        return (p);
  }

#include <iostream>
using namespace std;

class Foo{
public:
    Foo(){
        cout<<"Foo constructor"<<endl;
        a = 10;
    }

    //对operator new进行重写
    void* operator new(size_t size){
        cout<<"Foo operator new"<<endl;
        return ::operator new(size);
    }

    int a;
};

int main(){
    Foo* f1 =(Foo *) ::operator new(sizeof(Foo));
    cout<<f1->a<<endl;
    Foo* f2 = new Foo();
    cout<<f2->a<<endl;
}

/***************
 结果为：
 3420040
 Foo operator new
 Foo constructor
 10
 
 *****************/

char *buf  = new char[sizeof(string)]; // pre-allocated buffer
string *p = new (buf) string("hi");    // placement new

  char memory[sizeof(Foo)];     
  void* place = memory;         

  Foo* f = new(place) Foo(); 

#include <iostream>
#include <new>

char* memoryPool = NULL;

void my_new_handler(){
    if(NULL != memoryPool){
        // 删除一些不用的内存
        delete[] memoryPool;
        memoryPool = NULL;
    }else{
        //没有足够的内存
        throw std::bad_alloc();
    }
    return ;
}

int main(){
    std::set_new_handler(my_new_handler);
    memoryPool = new char[512*1024*1024];
    if(memoryPool == NULL){
        std::cout<<"allocator fail"<<std::endl;
        return -1;
    }
    char *p = NULL;
    for(int i = 0 ; i < 4; ++ i){
        p = new char[256*1024*1024];
        std::cout<<i+1<<" allocator 512M  "<<p<<std::endl;
    }
    return 0;
}