8. new와 delete를 내 맘대로

49. new 처리자의 동작 원리를 제대로 이해하자

할당할 메모리가 없어서 operator new 함수가 동작하지 않을 때, operator new 함수는 예외를 던진다.

예외를 던지기 전에 사용자가 에러 처리를 할 수 있도록 new 처리자(핸들러)를 먼저 호출하게 된다.

 

표준 라이브러리에서 set_new_handler라는 함수를 제공한다.

 

 

namespace std {
    typedef void (*new_handler)();
    new_handler set_new_handler(new_handler p) throw();
}

 

새로운 new 핸들러를 인자로 받고 기존 new 핸들러를 반환시켜준다.

operator new 함수가 예외를 던지면 충분한 메모리를 찾아낼 때까지 new 핸들러를 반복해서 호출하게 된다.

이 때, new 핸들러가 프로그램 동작에 있어서 긍정적인 영향을 주게끔 설계했다면 아래의 동작 중 한가지를 반드시 수행해주어야 한다.

 

◾ 사용할 수 있는 메모리를 더 많이 확보한다

메모리 풀을 사용하는 방식이 이에 해당할 수 있다. 프로그램 시작 시, 메모리 블록을 미리 크게 잡아놓고 new 핸들러가 호출되면 메모리 블록을 사용할 수 있게 허용하는 방식이다.

 

◾ 다른 new 처리자를 설치한다

현재의 new 핸들러가 문제를 처리할 수 없으면 다음부터 다른 new 핸들러를 호출할 수 있도록 set_new_handler 함수를 통해 새로운 new 핸들러를 설정한다.

 

◾ new 처리자의 설치를 제거한다

set_new_handler 함수에 널 포인터를 넘김으로써 operator new 함수가 예외를 던지게 만든다.

 

◾ 예외를 던진다

bad_alloc이나 거기서 파생된 타입의 예외는 operator new 함수에서 처리하지 못하기 때문에 new 핸들러 안에서 던지게 만든다.

 

◾ 복귀하지 않는다

abort나 exit 함수를 호출하여 프로그램을 종료시킨다.

 

클래스 별로 new 핸들러를 다르게 제공하고 싶다면 클래스 내부에서 operator new와 new 핸들러를 정의하면 된다.

 

 

class NewHandlerHolder {
public:
    explicit NewHandlerHolder(std::new_handler nh) : handler(nh) {} // 현재 new 핸들러 보관
    ~NewHandlerHolder() { std::set_new_handler(handler); } // 보관한 new 핸들러로 복구
private:
    std::new_handler handler;
    
    NewHandlerHolder(const NewHandlerHolder&);
    NewHandlerHolder& operator=(const NewHandlerHolder&); // 복사 방지
};


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; // 현재 new 핸들러
};

std::new_handler Widget::currentHandler = 0;

std::new_handler Widget::set_new_handler(std::new_handler) throw()
{
    std::new_handler oldHandler = currentHandler;
    currentHandler = p;
    return oldHandler;
}    

void* Widget::operator new(std::size_t size) throw(std::bad_alloc)
{
    NewHandlerHolder h(std::set_new_handler(currentHandler)); // 기존 new 핸들러 저장
    
    return ::operator new(size); // 할당 실패시 currentHandler 호출
} // 자원 관리 객체에 의해 이전의 전역 new 핸들러로 자동 복원

void outOfMem(); // new 핸들러가 가리킬 함수

Widget::set_new_handler(outOfMem); // new 핸들러 교체
Widget *pw1 = new Widget;

 

Widget 객체를 동적 할당하기 전에 new 핸들러를 지정해야하고(지정되지 않으면 널 포인터이므로 바로 예외를 던진다), 자원 관리 객체에 의해 Widget::operator new 호출이 종료되는 시점에 자동으로 기존의 new 핸들러로 복원시킨다.

 

자원 관리 객체를 이용한 할당에러 처리를 구현하는 코드는 어느 클래스에서 구현하더라도 똑같이 나올것이다.

그래서 할당에러 처리 기능만 따로 기본 클래스 템플릿으로 만들고 할당에러 처리가 필요한 클래스들이 상속 받아서 사용하면 훨씬 더 깔끔해진다.

 

template<typename T>
class NewHandlerSupport {
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);
    ... // 필요하면 operator new의 다른 버전들도 추가
private:
    static std::new_handler currentHandler;
};

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

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

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


class Widget: public NewHandlerSupport<Widget> { ... };

 

Widget 클래스에서는 더 이상 set_new_handler 및 operator new 함수를 선언할 필요가 없다.

그리고 특이하게도 NewHandlerSupport 클래스 템플릿은 템플릿 매개변수를 받음에도 불구하고 매개변수를 전혀 사용하지 않는다. 그저 정적 데이터 멤버인 std::new_handler의 사본을 만들기 위해서 존재한다.

참고로 이 패턴을 CRTP라고 부른다. 정적 다형성 및 메타프로그래밍에 사용되는 패턴이다.

대신 CRTP를 사용하면 다중 상속이 어쩔 수 없이 끌려나올 수 있다.

 

마지막으로 일반적인 new를 사용하든, 예외불가 new를 사용하든 어쨌거나 new 처리자는 양쪽에서 모두 쓰인다.

 

◾ set_new_handler 함수를 쓰면 메모리 할당 요청이 만족되지 못했을 때 호출되는 함수를 지정할 수 있습니다.

◾ 예외불가(nothrow) new는 영향력이 제한되어 있습니다. 메모리 할당 자체에만 적용되기 때문입니다. 이후에 호출되는 생성자에서는 얼마든지 예외를 던질 수 있습니다.

 

 

50. new 및 delete를 언제 바꿔야 좋은 소리를 들을지를 파악해 두자

new 와 delete를 바꾸는 일반적인 세 가지 이유

 

◾ 잘못된 힙 사용을 탐지하기 위해

요구하는 크기보다 약간 더 크게 할당해서 탐지용 비트를 추가하여 메모리 블록에 잘못 접근했을 경우 로그를 남긴다.

 

 

◾ 효율을 향상시키기 위해

메모리 단편화 등의 문제를 방지하기 위해. new/delete는 일반적으로 무난하게 동작하지만 프로그램에 따라 사용자 정의 버전의 성능이 더 좋을수도 있다.

 

◾ 동적 할당 메모리의 실제 사용에 관한 통계 정보를 수집하기 위해

 

물론 꼭 만들어 써야 할 필요가 없다면 굳이 만들 필요가 없다. 만들게 되더라도 오픈 소스 라이브러리를 보는것이 좋다.

그리고 new 처리자 함수를 호출하는 루프가 반드시 있어야 하는것이 관례이다.

 

◾ 개발자가 스스로 사용자 정의 new 및 delete를 작성하는 데는 여러 가지 나름대로 타당한 이유가 있습니다. 여기에는 수행 성능을 향상시키려는 목적, 힙 사용 시의 에러를 디버깅하려는 목적, 힙 사용 정보를 수집하려는 목적 등이 포함됩니다.

 

 

51. new 및 delete를 작성할 때 따라야 할 기존의 관례를 잘 알아 두자

operator new 함수를 구현할 때의 기본적인 요구사항들이 있다.

 

◾ 값 반환

◾ 할당 실패 시, new 처리자 호출 및 0바이트 메모리 할당 요청에 대한 대비

◾ 기본 형태의 new가 가려지지 않게 함

 

operator new는 메모리 할당이 성공할 때까지 new 처리자를 호출하게끔 무한루프로 구현하는 것이 관례이다.

루프를 빠져나올 수 있는 조건은 메모리 할당에 성공하거나 new 처리자 함수가 항목 49에서 언급한 다섯가지 조건 중 한가지를 만족시켜야 한다.

 

주의해야 할 점으로는 operator new 역시 파생 클래스로 상속되는 함수라는 점이다.

 

class Base {
public:
    static void* operator new(...);
};
class Derived: public Base {};

Derived *p = new Derived; // Base::operator new 호출

 

Base의 operator new는 Base의 크기에 맞는 메모리를 할당하게 될텐데, Derived가 상속받아 호출하게 되면 크기가 맞지 않게될 수 있다.

이런 경우 틀린 메모리 크기가 들어왔을 때, 표준 operator new를 호출하도록 우회시키면 된다.

 

void* Base::operator new(std::size_t size) throw(std::bad_alloc)
{
    if (size != sizeof(Base)) return ::operator new(size);
    ...
}

 

추가로 operator new[]를 직접 구현하게 된다면 원시 메모리의 덩어리를 할당하는 작업만 해야한다.

 

 

operator delete의 구현 관례는 매우매우 단순하다. 널 포인터에 대한 delete 적용이 안전하다는 보장만 지켜주면 된다.

틀린 메모리 크기에 대한 우회를 구현했다면 delete에서도 동일하게 처리해주면 된다.

 

마지막으로 가상 소멸자가 없는 파생 클래스의 객체를 삭제하려는 경우, operator delete의 매개변수인 size_t의 이상할 수도 있다.

 

◾ 관례적으로, operator new 함수는 메모리 할당을 반복해서 시도하는 무한 루프를 가져야 하고, 메모리 할당 요구를 만족시킬 수 없을 때 new 처리자를 호출해야 하며, 0바이트에 대한 대책도 있어야 합니다. 클래스 전용 버전은 자신이 할당하기로 예정된 크기보다 더 큰(틀린) 메모리 블록에 대한 요구도 처리해야 합니다.

◾ operator delete 함수는 널 포인터가 들어왔을 때 아무 일도 하지 않아야 합니다. 클래스 전용 버전의 경우에는 예정 크기보다 더 큰 블록을 처리해야 합니다.

 

 

52. 위치지정 new를 작성한다면 위치지정 delete도 같이 준비하자

new 표현식을 쓰게되면 우선 operator new 호출로 메모리가 할당되고 이후 생성자가 호출되는 구조를 가지게 되어있다.

두개의 함수가 호출되는 것이다.

 

Widget *pw = new Widget;

 

만약 operator new 호출로 메모리 할당에는 성공했지만 생성자 호출 도중에 예외가 발생하면 할당된 메모리를 취소시켜야 한다. 하지만 생성자에서 예외가 발생했기 때문에 pw에 포인터가 대입되는 일은 생기지 않는다.

메모리는 할당되었지만 포인터를 돌려받지 못했기 때문에 사용자 입장에서는 해당 메모리에 접근할 방법이 아예 없다.

그래서 런타임 시스템이 할당된 메모리를 대신 반환해준다.

 

이 때 런타임 시스템은 호출된 operator new와 짝이 되는 operator delete를 호출하게 되는데, 이건 사용자가 준비해두어야 한다.

 

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

 

new-delete의 짝이 맞지 않는다면 생성자에서 예외 발생 시, 런타임 시스템은 아무런 operator delete도 실행하지 않는다.

또한 new의 호출이 예외 없이 잘 이루어졌다면 추후 delete 호출 시 절대로 위치지정 delete를 호출하는 쪽으로 가지 않는다. 위치지정 delete는 오로지 생성자에서 예외가 발생했을 때만 호출된다.

 

그리고 클래스 내에서 operator new, delete를 하나라도 선언했다면 외부에 존재하는 다른 operator new, delete들의 이름이 가려지기 때문에 신경을 써야한다.

 

이름이 가려지는 문제는 new, delete를 구현해둔 기본 클래스를 만들어서 파생 클래스에 상속시키는 방법이 있다.

 

class StandardNewDeleteFormss {
public:
    // 기본형
    static void* operator new(std::size_t size) throw(std::bac_alloc)
    { return ::operator new(size); }
    static void operator delete(void *pMemory) throw()
    { ::operator delete(pMemory); }
    
    // 위치지정
    static void* operator new(std::size_t, void *ptr) throw()
    { return ::operator new(size, ptr); }
    static void operator delete(void *pMemory, void *ptr) throw()
    { ::operator delete(pMemory, ptr); }
    ...
};

class Widget: public StandardNewDeleteForms {
public:
    using StandardNewDeleteForms::operator new;
    using StandardNewDeleteForms::operator delete;
    
    // 또다른 위치지정
    static void* operator new(std::size_t size, std::ostream& logStream) throw(std::bad_alloc);
    static void operator delete(void *pMemory, std::ostream&) throw();
};

 

◾ operator new 함수의 위치지정 버전을 만들 때는, 이 함수와 짝을 이루는 위치지정 버전의 operator delete 함수도 꼭 만들어 주세요. 이 일을 빼먹었다가는, 찾아내기도 힘들여 또 생겼다가 안 생겼다 하는 메모리 누출 현상을 경험하게 됩니다.

◾ new 및 delete의 위치지정 버전을 선언할 때는, 의도한 바도 아닌데 이들의 표준 버전이 가려지는 일이 생기지 않도록 주의해 주세요.