[Effective C++] Chapter 8. new와 delete를 내 맘대로

// <new>에 선언되어 있는 함수들

namespace std
{
  typedef void (*new_handler)();
  // 매개변수와 반환값이 없는 함수에 대한 포인터이다. 
  
  new_handler set_new_handler(new_handler p) throw();
  // 매개변수 : 새롭게 설치할 new 처리자 
  // 반환값 : 새롭게 설치하기 전까지 사용하던 new 처리자 
  // throw() : 이 함수는 어떤 예외도 던지지 않을 것이라는 뜻이다. 
}

// 자원 관리 객체를 통해 할당에러를 처리한다. 
class NewHandlerHolder
{
private:
  std::new_handler handler;
  
  // 복사를 막기 위함 (Item 14)
  NewHandlerHolder(const NewHandlerHolder&);
  NewHandlerHolder& operator=(const NewHandlerHolder&);
  
public:
  // 매개변수로 들어온 처리자를 들고 있다가  
  explicit NewHandlerHolder(std::new_handler nh) : handler(nh) {}
  
  // 객체가 소멸될 때 그 처리자를 설치한다. 
  ~NewHandlerHolder() { std::set_new_handler(handler); }
};

class Widget
{
private:
  static std::new_handler currentHandler;
  
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);
};

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(std::bad_alloc)
{
  // 가지고 있는 현재 처리자를 설치하고, 
  // 이전 처리자는 NewHandlerHolder가 가지고 있다가
  // 이 함수를 빠져나가면 이전 처리자(전역 처리자)로 재설치한다. 
  NewHandlerHolder h(std::set_new_handler(currentHandler));
  
  // 메모리를 할당하고, 실패하면 예외를 던진다. 
  return ::operator new(size); 
}

void outOfMem();

int main()
{
  // 새로운 처리자 설치 
  Widget::set_new_handler(outOfMem);
  
  // 여기서 new 실패시 outOfMem이 불린다. 
  Widget * pw1 = new Widget;
  
  // 여기서 new 실패시 전역 new 처리자가 불린다. 
  std::string * ps = new std::string;
  
  // null로 설정 
  Widget::set_new_handler(0);
  
  // 여기서 new 실패시 예외를 바로 던진다. 
  Widget * pw2 = new Widget;
}

template<typename T>
class NewHandlerSupport
{
private:
  static std::new_handler currentHandler;
  
public:
  static std::new_handler set_new_handler(std::new_hanlder p) throw();
  static void * operator new(std::size_t size) throw(std::bad_alloc);
};

template<typename T>
std::new_handler NewHandlerSupport<T>::set_new_handler(std::new_hanlder p) throw()
{
  std::new_handler oldHandler = currentHandler;
  currentHandler = p;
  return oldHandler;
}

template<typename T>
void * newHandlerSupport<T>::operator new(std::size_t size) throw(bad_alloc)
{
  NewHandlerSupport h(std::set_new_handler(currentHandler));
  return ::operator new(size);
}

template<typename T>
std::new_handler NewHandlerSupport<T>::currentHandler = 0;

// 신기하게 반복되는 템플릿 패턴(curiously recurring template pattern: CRTP)
// Widget이 필요한건, NewHandlerSupport에 대한 사본이다. 
// NewHandlerSupport은 마치, 인스턴스화될 때 전달되는 T를 위한 
// NewHandlerSupport의 사본을 찍어내는 공장과 같다. 
class Widget : public NewHandlerSupport<Widget>
{
  // ...
};

Widget * pw1 = new Widget;
// Widget을 할당하다가 실패하면 bad_alloc 예외를 던진다. 

if (pw1 == 0)
// 이것은 늘 false일 것이다. 

Widget * pw2 = new (std::nothrow) Widget;
// Widget을 할당하다가 실패하면 0(널)을 반환한다. 

if (pw2 == 0)
// 실패하면 널을 반환하므로 점검해보는 것이 가능하다. 

void * operator new(std::size_t size) throw(std::bad_alloc)
{
  using namespace std;
  
  // (3) 0바이트 메모리 요청이 들어오면 1바이트 요구로 간주한다. 
  if (size == 0) size = 1;
  
  // (1) opreator new 함수에는 무한 루프가 있다. 
  // 그래서 메모리 할당에 성공하든지, 
  // 아니면 Item 49에서 나왔던 것들 중 하나는 꼭 처리해야 한다. 
  while(true)
  {
    size바이트를 할당해 본다. 
    if (할당 성공) return 할당한 메모리의 포인터;
    
    // 현재 설정되어 있는 new 처리자를 얻는다. 
    new_handler globalHandler = set_new_handler(0);
    set_new_hanlder(globalHandler);
    
    // (2) new 처리자를 호출한다. 
    if (globalHanlder) (*globalHandler)();
    else               throw std::bad_alloc();
  }
}

void * Base::operator new(std::size_t size) throw(bad_alloc)
{
  if (size != sizeof(Base))
    return ::operator new(size);
  // size가 Base와 다르면 표준 operator new 쪽에서 처리하도록 넘긴다. 
}

void Base::operator delete(void * rawMemory, std::size_t size) throw()
{
  // 널 포인터의 경우 아무것도 하지 않는다. 
  if (rawMemory == 0) return;

  // 클래스 전용 버전인 경우 size를 점검한다. 
  if (size != sizeof(Base))
  {
    ::operator delete(rawMemory); // 표준 operator delete가 처리하도록 한다. 
    return;
  }
  
  // ... rawMemory가 가리키는 메모리를 해제한다. 
}

// 기본형 new
void * operator new(std::size_t) throw(std::bad_alloc);

// 위치지정 new
void * operator new(std::size_t, void *) throw();

// 예외불가 new (Item 49)
void * operator new(std::size_t, const std::nothrow_t&) throw();

class Widget
{
public:
  // 새로운 매개변수 ostream을 받는 operator new (비표준 형태)
  static void * operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);
  
  // 클래스 전용 operator delete (표준 형태)
  static void operator delete(void * rawMemory, std::size_t size) throw();
};

int main()
{
  Widget * pw = new (std::cerr) Widget;
  // 여기서 Widget생성자에서 오류가 난다면?
  // 그럼 delete가 제대로 되겠는가?
  // 새로운 매개변수 ostream을 받는 new와 짝이 맞는 delete가 없어서
  // 결국 아무것도 불리지 않고 메모리는 누수가 된다. 
  // 따라서 새로운 매개변수 ostream을 받는 delete도 있어야 하겠다. 
}

class StandardNewDeleteForms
{
public:
  // 기본형 
  static void * operator new(std::size_t size) throw(std::bad_alloc) { return ::operator new(size); }
  static void operator delete(void * pMemory) throw() { ::operator delete(pMemory); }
  
  // 위치지정 
  static void * operator new(std::size_t size, void *ptr) throw() { return ::operator new(size, ptr); }
  static void operator delete(void * pMemory, void * ptr) throw() { ::operator delete(pMemory, ptr); }
  
  // 예외불가 
  static void * operator new(std::size_t size, const std::nothrow_t& nt) throw() { return ::operator new(size, nt); }
  static void operator delete(void * pMemory, const std::nothrow_t&) throw() { ::operator delete(pMemory); }
};

class Widget : public StandardNewDeleteForms
{
public:
  // StandardNewDeleteForms의 표준 형태가 Widget 내부에서 보이도록 만든다. 
  using StandardNewDeleteForms::operator new;
  using StandardNewDeleteForms::operator delete;
 
  // 새롭게 정의한 위치지정 new와 그와 짝이 맞는 위치지정 delete
  static void * operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);
  static void operator delete(void *pMemory, std::ostream& logStream) throw();
};