• Item 9: 자원이 새는걸 막는 파괴자를 사용해라.
  
  

~cpp 
    class ALA{
    publid:
        virtual void processAdiption() = 0;
        ...
    };
    class Puppy: public ALA{
    publid:
        virtual void processAdiption();
        ...
    };
    class Kitten: pubic ALA{
    publid:
        virtual void processAdiption();
        ...
    };

~cpp 
    ALA * readALA(istream& s);

~cpp 
    void processAdoptions( istream& dataSource)
    {
        while (dataSource) {
            ALA *pa = readALA(dataSource);
            pa->processAdoption();
            delete pa;
        }
    }

~cpp 
    template<class T>
    class auto_ptr{
    public:
        auto_ptr(T *p = 0) : ptr(p) {}
    private:
        T *ptr;
    };

~cpp 
    void processAdoptions(istream& dataSource)
    {
        while (dataSource){
            auto_ptr<ALA> pa(readALA(dataSource));
            pa->processAdoption();
        }
    }

~cpp 
    void displayIntoInfo(const Information& info)
    {
        WINDOW_HANDLE w(createWindow());
        display info in window corresponding to w;
        destroyWindow(w);
    }

~cpp 
    class WidnowHandle{
    public:
        WindowHandle(WINDOW_HANDLE handle) : w(handle) {}
        ~WindowHandle() {destroyWindow(w); }
        
        operator WINDOW_HANDLE() {return w;}
    private:
        WINDOW_HANDLE w;
    
        WindowHandle(const WindowHandle&);
        WindowHandle&   operator=(const WindowHandle);

~cpp 
    void displayIntoInfo(const Information& info)
    {
        WINDOW_HANDLE w(createWindow());
        display info in window corresponding to w;
    }

• Item 10: 생성자에서 자원이 세는걸 막아라.
  
  

~cpp 
    class Image{
    public:
        Image(const string& imageDataFileName);
    ...
    };

    class AudioClip{
    public:
        AudioClip(const string& audioDataFileName);
        ...
    }
    class PhoneNumber{ ... };

    class BookEntry{
    public:
        BookEntry(const string& name,
                  const string& address = "",
                  const string& imageFileName = "",
                  const string& audioClipFileName = "");
        ~BookEntry();

        void addPhoneNumber(const PhoneNumber& number);
    
    private:
        string the Name;
        string the Address;
        list<phoneNumber> thePhones;
        Image *theImage;
        AudioClip *theAudioClip;
    };

~cpp 
    if (audioClipFileName != "") {
        theAudioClip = new AudioClip(audioClipFileName);
    }

~cpp 
    void testBookEntryClass()
    {
        BookEntry b( "Addison-Wesley Publishing Company", "One Jacob Way, Reading, MA 018678");
        ...
    }

~cpp 
    void testBookEntryClass()
    {
        BookEntry *pb = 0;
        try{
            pb = new BookEntry( "Addison-Wesley Publishing Company", "One Jacob Way, Reading, MA 018678");
        }
        catch ( ... ) {
            delete pb;
            throw;
        }
        delete pb;
    }

~cpp 
    BookEntry::BookEntry(const string& name,
                         const string& address,
                         const string& imageFileName,
                         const string& audioClipFileName)
    :theName(name), theAddress(address), theImage(0), theAudioClip(0)
    {
        try{
            if (imageFileName != ""){
                theImage = new Image(imageFileName);
            }

            if (audioClipFileName != "") {
                theAudioCilp = new AudioClip( audioClipFileName);
            }
        }
        catch (...){
            delete theImage;
            delete theAudioClip;
            throw;
        }
    }

~cpp 
    class BookEntry{
    public:
        ...
    private:
        ...
        void cleanup(); // 이것이 객체를 삭제하는걸 묶은것
    };

~cpp 
    BookEntry::BookEntry(const string& name,
                         const string& address,
                         const string& imageFileName,
                         const string& audioClipFileName)
    :theName(name), theAddress(address), theImage(0), theAudioClip(0)
    {
        try{
            ...
        }
        catch (...){
            cleanup();
            throw;
        }
    }
    BookEntry::~BookEntry{
        cleanup();
    }

~cpp 
    class BookEntry{
    public :
        ...
    private:
        ...
        Image * const theImage;
        AudioClip * const theAudioClip;
    }

~cpp 
    class BookEntry{
    public :
        ...
    private:
        ...
        Image * initImage(const string& imageFileName);
        AudioClip * initAudioClip(const string& theAudioClip);
    }

    BookEntry::BookEntry(const string& name,
                         const string& address,
                         const string& imageFileName,
                         const string& audioClipFileName)
    :theName(name), theAddress(address), 
     theImage(initImage(imageFileName)), theAudioClip(initAudioClip(AudioCilpFileName))
    {}
    // theImage는 가장 처음 초기화 되어서 자원이 세는 것에대한 걱정이 없다. 그래서 해당 소스에서 
    // 예외처리를 생략하였다.
   Image * initImage(const string& imageFileName)
    {
        if (imageFileName != "") return new Image(imageFileName);
        else return 0;
    }
    // theAudioClip는 두번째로 초기화 되기 때문에, 예외의 발생경우 이미 할당되어진 theImage의 자원을 
    //  해제해주는 예외 처리가 필요하다. 
    AudioClip * initAudioClip(const string& theAudioClip)
    {
        try{
            if (adioClipFileName != ""){
                return new AudioClip(audioClipFileName);
            }
            else return 0;
        }
        catch ( ... ){
            delete theImage;
            throw;
        }
    }

~cpp 
    class BookEntry{
    pubcli:
    ...
    private:
    ...
    const auto_ptr<Image> theImage;
    const auto_ptr<AudioClip> theAudioClip;

~cpp 
    BookEntry::BookEntry(const string& name,
                         const string& address,
                         const string& imageFileName,
                         const string& audioClipFileName)
    :theName(name), theAddress(address),
     theImage(imageFileName != "" ? new Image(imageFileName) : 0),
     theAudioClip( audioClipFileName != "" ? new AudioClip(audioClipFileName):0)
      {}

~cpp 
    BookEntry::~BookEntry()
    {}

• Item 11: 파괴자로 부터의 예외 처리를 막아라.
  
  

~cpp 
    class Session{
    public:
        Session();
        ~Session();
        ...
    private:
        static void logCreation(Session *objAddr);
        static void logDestruction(Session *objAddr);
    };

~cpp 
    Session::~Session()
    {
        logDestruction(this);
    }

~cpp 
    Session::~Sessioni()
    {
        try{
            logDestruction(this);
        }
        catch ( ... ){
            cerr << "해당 주소에서 세션 객체의 파괴기록이 되지 않습니다."
                 << "-주소:"
                 << this << ".\n";
    }       

~cpp 
    Session::~Sessioni()
    {
        try{
            logDestruction(this);
        }
        catch ( ... ){ }       

~cpp 
    Session::Session()
    {
        logCreation(this);
        startTransaction();
    }
    Session::~Session()
    {
        logDestruction(this);
        endTransaction();
    }

• Item 12: 가상 함수 부르기나, 인자 전달로 처리와 예외전달의 방법의 차이점을 이해하라.
  
  

~cpp 
    class Widget { ... };

    void f1(Widget w);
    void f2(Widget& w);
    void f3(const Widget w);
    void f4(Widget *pw);
    void f5(const Widget *pw);

    catch (Widget w) ...
    catch (Widget& w) ...
    catch (const Widget w) ...
    catch (Widget *pw) ...
    catch (const Widget *pw) ...

~cpp 
    // 이 소스는 위의 Widget의 일환이라고 생각하면 무리 없겠다.
    istream operator>>(istream& s, Widget& w);
    void passAndThrowWidget()
    {
        Widget localWidget;
        cin >> localWidget;
        throw localWidget;
    }

~cpp 
class Widget { ...}
class SpecialWidget: public Widget { ... };
void passAndThrowWidget()
{
    SpecialWidget localSpecialWidget;
    ...
    Widget& rw = localSpecialWidget;
    throw rw;                           // rw의 형 즉 Widget의 복사생성자가 작동하여 복사해 예외를 발생시킨다.
}

~cpp 
    catch (Widget& w)
    {
        ...
        throw;              // 해당 객체를 다시 복사하지 않고 던지며, 해당 예외를 propagete 한다. 
    }
    catch (Widget& w)
    {
        ...
        throw w;            // 해당 객체를 다시 복사해서 그 사본을 propagate한다.
    }

~cpp 
catch (Widget w) ...        // 값으로 전달

catch (Widget& w) ...       // 참조 전달

catch (const Widget& w) ... // 상수 참조로 전달

~cpp 
    catch (Widget w) ...    // 값으로 전달

~cpp 
    catch (Widget& w) ...           // 참조 전달.
    catch (const Widget& w) ...     // 상수-참조 전달

~cpp 
    double sqrt(double);

~cpp 
    int i;
    double sqrtOfi = sqrt(i);

~cpp 
    void f (int value)
    {
        try {
            if (someFunction() ) {      // someFunction()이 참이면 int형의 변수를 예외로 던진다.
                throw value;
            }
            ...
        }
        catch (double d) {      // 해당 핸들은 double일때만 예외를 잡을수 있다. 그럼 value를 던지는
            ...                 // try에서의 예외는 절대로 잡히지 않는다. 의도한 바가 아니리라.
        }
        ...
    }

~cpp 
    exception 
        |
        +-logic_error
        |   |
        |   +-domain_error
        |   +-invalid_argument
        |   +-length_error
        |
        +-runtime_error
            |
            +-range_error
            +-underflow_error
            +-overflow_error

~cpp 
catch (runtime_error) ...           // 이렇게 선언하면 runtime_error자식인
catch (runtime_error&) ...          // range_error, underflow_error
catch (const runtime_error&) ...    // overflow_error이 다 잡히는 거다.


catch (runtime_error*) ...          // 이렇게 하면 runtime_error*
catch (const runtime_error*) ...    // range_error*, underflow_error*, overflow_error* 으로 잡히는 것이다.

~cpp 
    catch (const void*) ...

~cpp 
    try{
        ...
    }
    catch (logic_error& ex) {       // 여기에서 모든 logic에러가 잡힌다.
        ...
    }
    catch (invalid_argument & ex){  // 이 문은 작동을 하지 않는다. 위의 catch구분에서 이미 잡아 버린다.
        ...
    }

~cpp 
    try{
        ...
    }
    catch (invalid_argument & ex){  // invalid_argument 예외는 이곳에서 잡힌다.
        ...
    }
    catch (logic_error& ex) {       // 여기서 모든 다른 logic_error 관련은 이곳에서 잡힌다.
        ...
    }

• Item 13: 예외는 참조(reference)로 잡아라.
  
  

~cpp 
    class exception { ... };

    void someFunction()
    {
        static exception ex;        // 이렇게 메모리에 항상 존재하는 객체만을 전달할수 있다.
        ...
        throw &ex;    // 포인터로 전달, 해당 함수 영역을 벗어나므로, static만이 살아 남을수 있다.
        ...
    }
    void doSomething()
    {
        try{
            someFunction();         // 여기에서 exception *을 던진다.
        }
        catch ( exception *ex) {    // exception* 을 잡고 아무런 객체도 복사되지 않는다.
            ...
        }
    }

~cpp 
void someFunction()
{
    exception ex;       // local 예외 객체인데 이 함수의 영역을 벗어나면 파괴되어 진다.

    ...
    throw &ex;          // 그럼 이건 말짱 헛일이라는 소리 이미 파괴된 객체를 가리키고 있으니
    ...
}

~cpp 
    void someFunction() 
    {
        ...
        throw new exception;    // 이것도 어폐가 있는게, new에서 예외 발생하면 어떻게 할것가?
        ...
    }

~cpp 
    class exception {
    public:
        virtual const char * what() throw();
        ...
    }

    class runtime_error:public exception{ ... };

    class Validation_error : public runtime_error{      // 자 해당 객체는 runtime_error를 상속해서 만들었고
    public:             
        virtual const char * what() throw();            // 이 가상함수는 exception상에 있는 것이다.
        ...
    }
    void someFunction()
    {
        ...
        if ( a validation 테스트 실패){
            throw Validation_error();
        }
        ...
    }
    void doSomething()
    {
        try{
            someFunction();
        }
        catch (exception ex) {      // item 12에서 언급했듯 exception의 자식 예외객체들은 다 잡힌다.
            cerr << ex.what();      // 값으로 부모만 복사했기 때문에 what() 가상함수는 exception상의 
                                    // 가상 함수가 불린다. 개발자의 의도는 Validation_error 상의 가상함수를
                                    // 부르길 원하는 것 이었다.
            ...
        }
    }

~cpp 
void someFunction()
{
    ...
    if ( validation 테스트 에러 ){
        throw Validataion_error();
    }
    ...
}

void doSomething()
{
    try{
        someFunction();
    }
    catch (exception& ex){      // 이부분을 참조로만 바꾸었다. 이전의 예제와 특별히 바뀐게 없다.
                                // 하지만 이부분이 바뀌어서
        cerr << ex.what();      // 여기서의 가상 함수도 Validation_error의 메소드가 불린다.
        ...
    }
}

• Item 14: 예외를 신중하게 사용하라.
  

• 하지만 보통 아름다움은 표면이 아닌 내면에 존재한다.
  

~cpp 
    extern void f1();

~cpp 
    void f2() throw(int);

~cpp 
    void f2() throw(int)
    {
        ...
        f1();
        ...
    }

~cpp 
    template<class T>
    bool operator==(const T& lhs, const T& rhs) throw()
    {
        return &lhs == &rhs;
    }

• 두번째로 당신은 unexpected호출을 막기위하여 부족한 예외 명세의 규정으로 인하여 불리는 함수상에서 예외 명세를 생략할수 있다.
  

~cpp 
typedef void (*CallBackPtr) (int eventXLocation, int event YLocation, void *dataToPassBack);

class CallBack{
public:
    CallBack(CallBackPtr fPtr, void *dataToPassBack) :func(fPtr), data(dataToPassBack){}

    void makeCallBack(int eventXLocation, int eventYLocation) const throw();
private:
    CallBackPtr func;
    void *data
}

    void CallBack::makeCallBack(int eventXLocation, int eventYLocation)
    {
        func(eventXLocation, eventYLocation);
    }

~cpp 
typedef void (*CallBackPtr) (int eventXLocation, int event YLocation, void *dataToPassBack) throw();

~cpp 
    // 예외 명세가 없는 함수
    void callBackFcn1(int eventXLocation, int event YLocation, void *dataToPassBack);
    void *vallBackData;
    ...
    CallBack c1(callBackFcn1, callBackData); // 에러다 callBackFcn1은 여기에서 형이 맞지 않아. 에러를 던질것이다.

    // 예외 명세가 있는 함수
    void callBackFcn2(int eventXLocation, int event YLocation, void *dataToPassBack); throw()
    CallBack c1(callBackFcn2, callBackData); // 보다시피 알맞는 형이다.

• 세번째로 당신은 "the system"이 아마 던지는 예외를 핸들링해서 unexcepted의 호출을 피할수 있다. 이러한 예외는 많은 부분이 new와 new[]시 메모리 할당 예외에서 bad_alloc이 발생하여 발생한다. 만약 당신이 new를 어떤 함수에서 쓴다면 우연이라도 bad_alloc 예외를 만날수 있는 가능성을 내포하는 셈이다.
  
  

~cpp 
class UnexpectedException {};

void convertUnexpected()
{
    throw UnexpectedException();
}

~cpp 
    set_unexpected(convertUnexpected);

~cpp 
    void convertUnexpected()
    {
        throw()     // 이건 현제의 예외를 계속 던진다는 의미
    }

    set_unexpected(convertUnexpected);

~cpp 
    class Session{
    public:
        ~Session();
        ...
    private:
        static void logDestuction(Session *objAddr) throw();
    };

    Session::~Session()
    {
        try{
            logDestruction(this);
        }
        catch ( ... ) {}
    }

• Item 15: 예외 핸들링에 대한 비용 지불 대한 이해