U E D R , A S I H C RSS

More EffectiveC++/Exception

1. Exception

1.1. Item 9: Use destuctors to prevent resource leaks.

  • Item 9: ž›ด ƒˆ๋Š”๊ธ ๋ง‰๋Š” ŒŒ๊ดดž๋ฅผ ‚ฌšฉ•ด๋ผ.

๊ท€—ฌ๋ธ ๋™๋ฌผ๋“ค ด๋ž˜Šค๋ฅผ ๋งŒ๋“ค–ด ๋ณดž.

ALA๋Š” (Adorable Little Animalด๋‹ค.)
~cpp 
    class ALA{
    publid:
        virtual void processAdiption() = 0;
        ...
    };
    class Puppy: public ALA{
    publid:
        virtual void processAdiption();
        ...
    };
    class Kitten: pubic ALA{
    publid:
        virtual void processAdiption();
        ...
    };

ผ๋‹จ —ฌ๋Ÿฌ๋ถ„€ ŒŒผ—„œ ๋ถ€„ฐ puppy™€ kitten™€ ‚คŠผ˜  •๋ณด๋ฅผ ด๋ ‡๊ฒŒ ฝ๊ณ  ๋งŒ๋“ ๋‹ค. ‚ฌ‹ค Item 25— –ธ๊ธ‰•  virtual constructor๊ฐ€  œ๊ฒฉดง€๋งŒ, ผ๋‹จ šฐ๋ฆฌ— ๋ชฉ — ๋งž๋Š” •จˆ˜๋กœ ๋Œ€ฒด•œ๋‹ค.
~cpp 
    ALA * readALA(istream& s);

๋‹คŒ๊ณผ ๊ฐ™€ ๋А๋‚Œ(?)œผ๋กœ ถœ๋ ฅ•œ๋‹ค.
~cpp 
    void processAdoptions( istream& dataSource)
    {
        while (dataSource) {
            ALA *pa = readALA(dataSource);
            pa->processAdoption();
            delete pa;
        }
    }
pa— •ด๋‹น•˜๋Š” processAdoption()€ ˜ค๋ฅ˜‹œ— exception„ ๋˜„๋‹ค. •˜ง€๋งŒ, exception‹œ— •ด๋‹น ฝ”๋“œ๊ฐ€ ๋ฉˆถ˜๋‹ค๋ฉด "delete pa;"๊ฐ€ ˆ˜–‰๋˜ง€ •Š•„„œ ๊ฒฐ๊ตญ ž›ด ƒˆ๋Š” šจ๊ณผ๊ฐ€ žˆ๊ฒ ง€ ๊ทธ๋ ‡๋‹ค๋ฉด ๋‹คŒ๊ณผ ๊ฐ™ด ผ๋‹จ ˜ˆ™ธ ฒ˜๋ฆฌ๋ฅผ •œ๋‹ค. ๋ฌผ๋ก  •ด๋‹น •จˆ˜—„œ propagate•ดฃผ–ด •จˆ˜ žฒด—„œ๋„ ˜ˆ™ธ๋ฅผ ๋ฐœƒ ‹œ‚จ๋‹ค.

~cpp 
    void processAdoptions( istream& dataSource)
    {
        while (dataSource) {
            ALA *pa = readALA(dataSource);
            try{
                pa->processAdoption();
            }
            catch ( ... ) {
                delete pa;
                throw;
            }
            delete pa;
        }
    }
๋ฐฉ๋ฒ•€ ˜ฌ๋ฐ”๋ฅด๋‹ค. ˜ˆ™ธ‹œ— •ด๋‹น ๊ฐฒด๋ฅผ ง€›Œ ๋ฒ„๋ฆฌ๋Š”๊ฒƒ, ๊ทธ๋ฆฌ๊ณ  ด๊šฐ๋ฆฌ๊ฐ€ ๋ฐฐšด try-catch-throw๋ฅผ ถฉ‹คžˆ ‚ฌšฉ•œ ๊ฒƒด๋‹ค. •˜ง€๋งŒ.. ๋ณตžก•˜ง€ •Š€๊ฐ€? •ด๋‹น ฝ”๋“œ๋Š” ๋ง๊ทธ๋Œ€๋กœ Žผณ„๋‹ค.(˜„œ˜ ‘œ˜„) ๊ทธ๋ฆฌ๊ณ  ฝ”๋“œ˜ ๊ฐ€๋…„๋„ ๋–จ–ดง€๋ฉฐ, ฐจ›„ ๊ด€๋ฆฌ ฐจ›—„œ ถ”๊ฐ€ ฝ”๋“œ˜ ๋ฐœƒ‹œ—๋„ –ด๋А ˜—ญ— ๋ณด๊ฐ•• ๊ฒƒ ธ๊ฐ€— ๊ด€•˜—ฌ ๋ฌธ œ‹œ ๋œ๋‹ค.

—ฌ๊ธฐ—„œ žฌ๋ฏธžˆ๋Š” ๊ธฐ๋ฒ•„ ด•ผ๊ธฐ •ด๋ณธ๋‹ค. ฐจฐจ †Œ๊ฐœ๋  smart pointer™€ ๋”๋ถˆ–ด Standard C++ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ— ฌ•จ๋˜–ด žˆ๋Š” auto_ptr template ด๋ž˜Šค๋ฅผ ดšฉ•œ •ด๊ฒฐ…ธ๋ฐ auto_prt€ ด๋ ‡๊ฒŒ ƒ๊ฒผ๋‹ค.

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

๊ทธ๋ฆฌ๊ณ  •ด๋‹น auto_prt˜  šฉ•œ ๋ชจŠต€ ๋‹คŒ๊ณผ ๊ฐ™ด ๋ณดธ๋‹ค.
~cpp 
    void processAdoptions(istream& dataSource)
    {
        while (dataSource){
            auto_ptr<ALA> pa(readALA(dataSource));
            pa->processAdoption();
        }
    }

˜ˆ™ธ ๋ฐœƒ‹œ— •จˆ˜๊ฐ€ ข…๋ฃŒ๋˜๋ฉด auto_ptrƒ˜ ๊ฐฒด๋Š” ๋ฌดกฐ๊•ด œ๋œ๋‹ค.

žž ๋‹คŒ ฝ”๋“œ๋„ ž›ด …€๊ฒƒด๋‹ค.
~cpp 
    void displayIntoInfo(const Information& info)
    {
        WINDOW_HANDLE w(createWindow());
        display info in window corresponding to w;
        destroyWindow(w);
    }

ผ๋ฐ˜ œผ๋กœ C˜ ๊ฐœ๋…œผ๋กœ งœ—ฌ„ ”„๋กœ๊ทธ๋žจ๋“ค€ createWindow and destroyWindow™€ ๊ฐ™ด ๊ด€๋ฆฌ•œ๋‹ค. ๊ทธ๋ ‡ง€๋งŒ ด๊ฒƒ —ญ‹œ 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);

auto_ptr๊ณผ ๊ฐ™€ ›๋ฆฌด๋‹ค.
~cpp 
    void displayIntoInfo(const Information& info)
    {
        WINDOW_HANDLE w(createWindow());
        display info in window corresponding to w;
    }

1.2. Item 10: Prevent resource leaks in constructors.

  • 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;
    };

๊ฐ๊ฐ˜ BookEntry๋Š” ด๋ฆ„๊ณผ ๋”๋ถˆ–ด ๋‹ค๋ฅธ •„๋“œ๋ฅผ ๊ฐ€ง€๊ณ  žˆœผ๋ฉฐ ๊ธฐ๋ณธ ƒ„ž๋Š” ๋‹คŒ๊ณผ ๊ฐ™๋‹ค.

~cpp 
    // ๊ธฐ๋ณธ ƒ„ž
    BookEntry::BookEntry(const string& name,
                         const string& address,
                         const string& imageFileName,
                         const string& audioClipFileName)
    :theName(name), theAddress(address), theImage(0), theAudioClip(0)
    {
        if (imageFileName != ""){       // ด๋ฏธง€๋ฅผ ƒ„•œ๋‹ค.
            theImage = new Image(imageFileName);
        }

        if (audioClipFileName != "") {  // †Œ๋ฆฌ  •๋ณด๋ฅผ ƒ„•œ๋‹ค.
            theAudioCilp = new AudioClip( audioClipFileName);
        }
    }
    BookEntry::~BookEntry()
    {
        delete theImage;
        delete theAudioClip;
    }

ƒ„ž๋Š” theImage™€ theAudioClip๋ฅผ null๋กœ ˆ๊ธฐ™” ‹œ‚จ๋‹ค. C++ƒ—„œ null๊ฐ’ด๋ž€ deleteƒ—„œ˜ •ˆ „„ ๋ณดžฅ•œ๋‹ค. •˜ง€๋งŒ... œ„˜ ฝ”๋“œค‘— ๋‹คŒ ฝ”๋“œ—„œ new๋กœ ƒ„• ‹œ— ˜ˆ™ธ๊ฐ€ ๋ฐœƒ๋œ๋‹ค๋ฉด?
~cpp 
    if (audioClipFileName != "") {
        theAudioClip = new AudioClip(audioClipFileName);
    }

žž ˜ˆ๋ฅผ๋“ค–ด„œ ด๋Ÿฐ •จˆ˜—„œ ˜ˆ™ธ ฒ˜๋ฆฌ๋ฅผ •ด•ผ• ๊ฒƒด๋‹ค.
~cpp 
    void testBookEntryClass()
    {
        BookEntry b( "Addison-Wesley Publishing Company", "One Jacob Way, Reading, MA 018678");
        ...
    }

ด๋ ‡๊ฒŒ try-catch-throw๋กœ ๋งด๋‹ค.
~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;
    }

ด๋ ‡๊ฒŒ •ด๋„ —ฌ „žˆ ๋ฌธ œ๋Š” ๋‚จ๋Š”๋‹ค. ๋ฌด—‡ด๋ƒ •˜๋ฉด, ๋งŒ•ฝ BookEntry˜ ƒ„žค‘—„œ AudioClip ๊ฐฒด ƒ„ค‘— ˜ˆ™ธ๋ฅผ propagate•˜๋ฉด ๋ฐ”๋กœ œ„ ฝ”๋“œค‘ pb ฌธ„— null„ ๋ฐ˜™˜•ด ๋ฒ„๋ฆฐ๋‹ค. ๋ฐ˜๋‚ฉ๋œ ด๋ ‡๊ฒŒ ๋˜๋ฉด ด๋ฏธ  •ƒ œผ๋กœ ƒ„๋œ theImage๋ฅผ ง€šฐง€ ๋ชป•˜๋Š” ‚ฌƒœ๊ฐ€ ๋ฐœƒ•ด ๋ฒ„๋ฆฌ๋Š” ๊ฒƒด๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด ƒ„ž˜ ๋‚ด๋ถ€—„œ ๋‹ค‹œ try-catch-throw๋กœ •ด•ผ • ๊ฒƒด๋‹ค.

~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;
        }
    }

ž ด๋ ‡๊ฒŒ •ดฃผ๋ฉด ๋ฌธ œ ๋ ๊ฒƒด —†๋‹ค. ž ดƒƒœ— refactoringด •„š”•œ ฝ”๋“œ๋“คด ๋ณดผ๊ฒƒด๋‹ค •˜๊ฒ ๋‹ค. delete๋ถ€๋ถ„„ •จˆ˜๋กœ —ญ–ด ๋„ค๋Š” ๊ฒƒด๋‹ค.

~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;
    }

ด๋Ÿฐ const ฌธ„˜ ๊ฒฝšฐ—๋Š” ๋ฐ˜๋“œ‹œ ˆ๊ธฐ™” ๋ฆฌŠคŠธ๋ฅผ ดšฉ•˜—ฌ ธž๋ฅผ ˆ๊ธฐ™” •ดฃผ–ด•ผ •˜๋Š” ๊ฒฝšฐด๋‹ค.

~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;
        }
    }
ด๋Ÿฐ •ด๊ฒฐ ๋ฐฉ๋ฒ•€ ˜ฌ๋ฐ”๋ฅด๋‹ค •˜ง€๋งŒ, ด „— –ธ๊ธ‰•œ ๊ฒƒ๊ณผ ๊ฐ™ด †ŒŠค ‚ฌ›„ ๊ด€๋ฆฌ™€ ˜„žฌ †ŒŠค žฒด๋„ ๋งŽด ง€ €๋ถ„•˜๋‹ค

๊ทธ๋ž˜„œ ๋” ข‹€ ๋ฐฉ๋ฒ•€ Item 9—„œ –ธ๊ธ‰•œ ๋ฐฉ๋ฒ•„ ‚ฌšฉ•˜๋Š” ๊ฒƒด๋‹ค.
~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()
    {}
ด๋ ‡๊ฒŒ •„๋ฌด๊ฒƒ๋„ •ดฃผง€ •Š•„๋„ ๊ฐฒด๊ฐ€ ๊ฐ™ด ŒŒ๊ดด๋˜๊ณ  ๋ฆฌ†ŒŠค๊ฐ€ ƒˆ๋Š” ๊ฒƒ„ ๋ฐฉง€ • ˆ˜ žˆ๋‹ค.

1.3. Item 11: Prevent exception from leaving destuctors.

  • Item 11: ŒŒ๊ดดž๋กœ ๋ถ€„˜ ˜ˆ™ธ ฒ˜๋ฆฌ๋ฅผ ๋ง‰•„๋ผ.

ŒŒ๊ดดž ˜ธถœ€ ๋‘๊ฐ€ง€˜ ๊ฒฝšฐ๊ฐ€ žˆ๋‹ค. ฒซ๋ฒˆงธ๊ฐ€ 'normal'ƒƒœ๋กœ ๊ฐฒด๊ฐ€ ŒŒ๊ดด๋˜–ด ˆ๋•Œ๋กœ ๊ทธ๊ฒƒ€ ๋ณด†ต ๋ช…‹œ œผ๋กœ delete๊ฐ€ ๋ถˆ๋ฆฐ๋‹ค. ๋‘๋ฒˆงธ๋Š” ˜ˆ™ธ๊ฐ€  „๋‹ฌ๋˜๋ฉด„œ Šคƒด ’€๋ฆด๋•Œ ˜ˆ™ธ ฒ˜๋ฆฌ‹œ(exception-handling) ๊ฐฒด๊ฐ€ ŒŒ๊ดด๋˜–ด ง€๋Š” ๊ฒฝšฐ๊ฐ€ žˆ๋‹ค.

๋‹คŒ ˜ˆ œ๋Š” online ปด“จ„„…˜„ œ„•œ Session ด๋ž˜Šค๋ฅผ ƒ๊ฐ•ด ๋ณธ ๊ฒƒด๋‹ค. ๊ฐ „…˜ ๊ฐฒด๋“ค€ ƒ„๊ณผ ŒŒ๋˜๋œ ๋‚ งœ๋ฅผ ๊ธฐ๋ก•ด•ผ๋งŒ •œ๋‹ค.
~cpp 
    class Session{
    public:
        Session();
        ~Session();
        ...
    private:
        static void logCreation(Session *objAddr);
        static void logDestruction(Session *objAddr);
    };

๋‹คŒ๊ณผ ๊ฐ™ด ŒŒ๊ดดž—„œ ๋กœ๊ทธ ๋ฐด„ฐ๋ฅผ ๋‚จ๊ธด๋‹ค.
~cpp 
    Session::~Session()
    {
        logDestruction(this);
    }

ž ด๊ด ๊ดœฐฎ•„ ๋ณดธ๋‹ค. •˜ง€๋งŒ  € logDestructionƒ—„œ ˜ˆ™ธ๊ฐ€ ๋ฐœƒ•œ๋‹ค๋ฉด –ดฉŒ๊ฒŒ • ๊ฒƒธ๊ฐ€? •ด๋‹น †ŒŠค๋Š” Session˜ ŒŒ๊ดดž •ˆ—„œ๋Š” ˜ˆ™ธ๋ฅผ žกง€ ๋ชป•œ๋‹ค. ๊ทธ๋ž˜„œ •ด๋‹น ŒŒ๊ดดž๋ฅผ ˜ธถœ•œ ž—๊ฒŒ ˜ˆ™ธ๋ฅผ ๋˜„( „๋‹ฌ•œ)๋‹ค. ๊ทธ๋ ‡ง€๋งŒ ๋‹ค๋ฅธ —๋Ÿฌ๋“คด ๋˜ ธ„ ƒ™ฉ—„œ ŒŒ๊ดดž๊ฐ€ ŠคŠค๋กœ ž‹ „ ๋ถ€๋ฅธ๊ฐ๋ผ๋ฉด •จˆ˜˜ ข…๋ฃŒ๊ฐ€ ž๋™œผ๋กœ ด๋ฃจ–ดง€๊ธฐ๋ฅผ ›•  ๊ฒƒด๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋‹น‹ ˜ ”„๋กœ๊ทธ๋žจ€ ดฏค—„œ ๋จธถ”–ด ๋ฒ„๋ฆด ๊ฒƒด๋‹ค. -•ด„ด ดƒ•˜๊ตฐ, •”Šผ ๋‹ค๋ฅธ ˜ˆ™ธ ฒ˜๋ฆฌ‹œ— „…˜ ŒŒ๊ดดž ๋กœ๊ทธ‹œ ˜ˆ™ธ๊ฐ€ ๋ฐœƒ•œ๋‹ค๋ฉด ”„๋กœ๊ทธ๋žจด ๋ฉˆถ˜๋‹ค๋Š” †Œ๋ฆฌ๋‹ค.

•„๋งˆ ๋Œ€๋‹คˆ˜˜ ‚ฌ๋žŒ๋“คด ด๋Ÿฐ ƒƒœ๋กœ ๋น ง€๋Š”๊›•˜ง€ •Š„ ๊ฒƒด๋‹ค. Session ๊ฐฒด˜ ŒŒ๊ดด๋Š” ๊ธฐ๋ก๋˜ง€ •Š„ ƒœ๋‹ˆ๊นŒ. ๊ทธ๊ƒ๋‹นžˆ ปค๋‹ค๋ž€ ๋ฌธ œด๋‹ค ๊ทธ๋Ÿฌ๋‚˜ ๊ทธ๊ฒƒด ข€๋” ‹ฌ•œ ๋ฌธ œ๋ฅผ œ ๋ฐœ•˜๋Š”๊”„๋กœ๊ทธ๋žจด ๋” „• ˆ˜ —†„ ๋•Œ ผ๊ฒƒด๋‹ค. ๊ทธ๋ž˜„œ Session˜ ŒŒ๊ดดž—„œ˜ ˜ˆ™ธ  „๋‹ฌ„ ๋ง‰•„•ผ •œ๋‹ค. ๋ฐฉ๋ฒ•€ •˜๋‚˜ try-catch๋กœ žก•„ ๋ฒ„๋ฆฌ๋Š” ๊ฒƒด๋‹ค.
~cpp 
    Session::~Sessioni()
    {
        try{
            logDestruction(this);
        }
        catch ( ... ){
            cerr << "•ด๋‹น ฃผ†Œ—„œ „…˜ ๊ฐฒด˜ ŒŒ๊ดด๊ธฐ๋กด ๋˜ง€ •ŠŠต๋‹ˆ๋‹ค."
                 << "-ฃผ†Œ:"
                 << this << ".\n";
    }       
•˜ง€๋งŒ ด๊ฒƒ๋„ ›๋ž˜˜ ฝ”๋“œ๋ณด๋‹ค •ˆ „•  ๊ฒƒด —†๋‹ค. ๋งŒ•ฝ operator<< ๋ถ€๋ฅผ๋•Œ exception์ด ๋ฐœ์ƒํ•œ๋‹ค๋ฉด ํŒŒ๊ดด์ž๊ฐ€ ๋˜์ง€๋Š” exception์œผ๋กœ ๋‹ค์‹œ ์šฐ๋ฆฌ๊ฐ€ ํ•ด๊ฒฐํ•˜๊ณ ์ž ํ•˜๋Š” ์›์ ์œผ๋กœ ๋Œ์•„๊ฐ€ ๋ฒ„๋ฆฐ๋‹ค. ๊ทธ๋ ‡๋‹ค๋ฉด
~cpp 
    Session::~Sessioni()
    {
        try{
            logDestruction(this);
        }
        catch ( ... ){ }       
ด๋ ‡๊ฒŒ •„๋ฌด๋Ÿฐ ฒ˜๋ฆฌ๋ฅผ •˜ง€ •Š๋Š”๋‹ค๋ฉด logDestuction—„œ ๋ฐœƒ•œ ˜ˆ™ธ๊ฐ€  „๋‹ฌ๋˜๋Š”๊ธ ๋ง‰๊ณ  ”„๋กœ๊ทธ๋žจ ค‘ง€๋ฅผ œ„•˜—ฌ Šคƒด ’€๋ ค๋‚˜๊ฐ€๋Š”๊ธ ๋ง‰„ˆ˜๋Š” žˆ„ ๊ฒƒด๋‹ค.

•˜ง€๋งŒ ด๋Ÿฐ ๋‘๋ฒˆงธ˜ ƒ๊ฐ๋„ ŒŒ๊ดดž—„œ ๋ฐœƒ•˜๋Š” ๋ชจ๋“  —๋Ÿฌ๋ฅผ ๋ง‰•„ ๋ฒ„๋ฆฌ๊ณ  ๊ทธ๋ƒฅ ๋„˜–ด๊ฐ€ ๋ฒ„๋ฆฐ๋‹ค๋Š” ๋‹จ ด žˆ๋‹ค.
๋ฐ‘˜ ฝ”๋“œ๋Š” DB˜ Šธ๋žœ …˜„ ดšฉ•ด„œ —๋Ÿฌ๋ฅผ ฒ˜๋ฆฌ•˜๋Š” ๋ชจŠตด๋‹ค.
~cpp 
    Session::Session()
    {
        logCreation(this);
        startTransaction();
    }
    Session::~Session()
    {
        logDestruction(this);
        endTransaction();
    }
ด๋Ÿด ๊ฒฝšฐ—๋Š” Session˜ ŒŒ๊ดดž—๊ฒŒ ๋ฌธ œ๋ฅผ  œ๊•˜๋Š” ๋ช…๋ น„ ๋‹ค‹œ ๋‚ด๋ฆดˆ˜ žˆ๋”ฐ •˜ง€๋งŒ endTransactionด ˜ˆ™ธ๋ฅผ ๋ฐœƒžˆ‚จ๋‹ค๋ฉด ๋‹ค‹œ try-catch๋ฌธœผ๋กœ ๋Œ•„ ๊ฐˆˆ˜ ๋ฐ–— —†๋‹ค.

๋‚œ œ๋‹ค ๋‚œ œ

1.4. Item 12: Understand how throwing an exception differs from passing a parameter or calling a virtual function

  • Item 12: ๊ฐ€ƒ •จˆ˜ ๋ถ€๋ฅด๊ธฐ๋‚˜, ธž  „๋‹ฌ๋กœ ฒ˜๋ฆฌ™€ ˜ˆ™ธ „๋‹ฌ˜ ๋ฐฉ๋ฒ•˜ ฐจด „ ด•ด•˜๋ผ.

๋‹คŒ˜ ๊ฐ€ƒ•จˆ˜˜ „ –ธ๊ณผ ๊ฐ™ด ๋‹น‹ € catch ๊ตฌ๋ฌธ—„œ๋„ ๋น„Šท•˜๊ฒŒ ธž๋“ค„„„ˆ˜ žˆ๋‹ค.
~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) ...

๊ทธ๋ž˜„œ •„๋งˆ •จˆ˜˜ธถœ—„œ ธž  „๋‹ฌ๊ณผ ๊ณผ ˜ˆ™ธ๊ฐ€  „๋‹ฌ๋˜๋Š” ๊ฒƒด ๊ธฐ๋ณธ œผ๋กœ ๊ฐ™€๊ฒƒด๋ผ๊ณ  ƒ๊ฐ • ง€๋„ ๋ชจ๋ฅธ๋‹ค. ๋ถ„๋ช… ๋‘˜€ ๋น„Šท•œ ๋ฉดด žˆ๋‹ค. •˜ง€๋งŒ ค‘š”•œ ฐจด  —ญ‹œ กดžฌ •œ๋‹ค.

ž, ๋น„Šท•œ ๋ฉด€ –ธ๊ธ‰•ด๋ณด๋ฉด, •จˆ˜ ˜ˆ™ธ ๋ชจ๋‘ — ธž๋ฅผ  „๋‹ฌ• ๋•Œ „ธ๊ฐ€ง€๋กœ  „๋‹ฌ• ˆ˜ žˆ๋‹ค. ๊ฐ’(by value)ด๋ƒ ฐธกฐ(by reference)๋ƒ, ˜น€ ฌธ„ฐ(by pointer)๋ƒ ๋ฐ”๋กœ ด๊ฒƒด๋‹ค. •˜ง€๋งŒ ด •จˆ˜™€ ˜ˆ™ธ—„œ˜ ธž˜  „๋‹ฌ ๋ฐฉ‹€ ๊ตฌ๋™ ๋ฐฉ๋ฒ•—„œ ๊ฒฐ • ธ ฐจด „ ๋ณดธ๋‹ค. ด๋Ÿฐ ฐจด € ๋‹น‹ ด •จˆ˜๋ฅผ ˜ธถœ• ๋•Œ ตœข… œผ๋กœ ๋ฐ˜™˜๋˜๋Š” ๊ฐ’(returns)ด •ด๋‹น •จˆ˜๋ฅผ ๋ถ€๋ฅด๋Š” œ„น˜๋กœ ๊ฐ€ง€๋งŒ, ˜ˆ™ธ˜ ๊ฒฝšฐ— throw˜ œ„น˜™€ return˜ œ„น˜๊ฐ€ ๋‹ค๋ฅด๋‹ค๋Š”  —„œ ๊ธฐธ•œ๋‹ค.

๋‹คŒ •จˆ˜—„œ Widget˜ ธž  „๋‹ฌ๊ณผ ˜ˆ™ธ—„œ˜  „๋‹ฌ„ ƒ๊ฐ•ด ๋ณดž.
~cpp 
    // ด †ŒŠค๋Š” œ„˜ Widget˜ ผ™˜ด๋ผ๊ณ  ƒ๊ฐ•˜๋ฉด ๋ฌด๋ฆฌ —†๊ฒ ๋‹ค.
    istream operator>>(istream& s, Widget& w);
    void passAndThrowWidget()
    {
        Widget localWidget;
        cin >> localWidget;
        throw localWidget;
    }

localWidgetด operator>> ๋กœ  „๋‹ฌ๋ ๋•Œ๋Š” ๋ณต‚ฌ˜ ๊ณผ •ด ผ–ด๋‚˜ง€ •Š๋Š”๋‹ค. ๋Œ€‹  operator>> •ˆ˜ ฐธกฐ w๊ฐ€ localWidget๊ณผ ๋ฌถ—ฌ„œ –ด๋– •œ ๊ณผ •„ ฒ˜๋ฆฌ•˜๊ฒŒ ๋œ๋‹ค. •˜ง€๋งŒ ˜ˆ™ธ˜ ฒ˜๋ฆฌ—„œ localWidget€ ข€ ๋‹ค๋ฅธ ด•ผ๊ธฐ๋ฅผ ๋งŒ๋“ค–ด ๋‚˜๊ฐ„๋‹ค. ˜ˆ™ธ๊ฐ€ ๊ฐ’ด๋‚˜, ฐธกฐ๋ฅผ žก๋“  žกง€(pointer๋Š” žกง€ ๋ชป•œ๋‹ค.) •Š๋“  ƒ๊ด€ —†ด localWidget˜ ‚ฌ๋ณธด ๋งŒ๋“ค–ดง€๊ณ , ๊ทธ ‚ฌ๋ณธ€ catch๋กœ  €๋‚Ÿใ„น ๋œ๋‹ค. ™œ๋ƒ•˜๋ฉด passAndThrowWidget˜ ˜—ญ„ ๋ฒ—–ด๋‚˜๋ฉด localWidget˜ ŒŒ๊ดดž˜ ˜ธถœด ๋˜๊ธฐ ๋•Œ๋ฌธ— ๋ฐ˜๋“œ‹œ ด๋ ‡๊ฒŒ ๋˜–ด•ผ •œ๋‹ค. ด๊ฒƒ€ C++ —„œ ˜ˆ™ธ๋Š” •ญƒ ‚ฌ๋ณธœผ๋กœ  „๋‹ฌ๋œ๋‹ค๋Š” ดœ ๊ฐ€ ๋œ๋‹ค.

ด๋Ÿฐ ๋ณต‚ฌ˜ ๊ณผ •€ •„๋ฌด๋ฆฌ ŒŒ๊ดด˜ œ„—˜ด —†๋Š” ˜ˆ™ธ๋ผ๋„ ด๋ฃจ–ด „๋‹ค. ˜ˆ๋ฅผ ๋“คž๋ฉด

~cpp 
    void passAndThrowWidget()
    {
        static Widget localWidget;
        cin >> localWidget;
        throw localWidget;
    }

•ด๋‹น ‚ฌ๋ณธ€ ๊ตฌง€ ๋ณต‚ฌ•  •„š”๊ฐ€ —†„ ๊ฒƒด๋‹ค. •˜ง€๋งŒ catch ๋Š” ๋ณต‚ฌ•ด ๋‚˜๊ฐ€๊ณ  ๊ทธ๋ž˜•ผ๋งŒ catch —„œ localWidget˜ ‚ฌ๋ณธ„ Žธง‘•ด„œ ดšฉ• ˆ˜ žˆ๋‹ค. ด๋Ÿฌ•œ ๋ณต‚ฌ˜ ๊ทœน™€ •จˆ˜  „๋‹ฌ๊ณผ ˜ˆ™ธ ธž  „๋‹ฌ˜ ฐจด „ „ค๋ช…•ด ค€๋‹ค.

๊ฐฒด๊ฐ€ ˜ˆ™ธ๋ฅผ œ„•˜—ฌ ๋ณต‚ฌ๊ฐ€ ๋ ๋•Œ ๋ณต‚ฌ๋Š” •ด๋‹น ๊ฐฒด˜ ๋ณต‚ฌƒ„ž(copy constructor)— ˜•˜—ฌ ˆ˜–‰ ๋œ๋‹ค. ด ๋ณต‚ฌƒ„ž๋Š” ๊ฐฒด˜ dynamic˜•ด •„๋‹Œ static ˜•— •ด๋‹น•˜๋Š” ด๋ž˜Šคค‘ •˜๋‚˜ด๋‹ค. ๊ฐœ๋…˜ ™•ธ„ œ„•ด œ„ †ŒŠค˜ ˆ˜ • ๋ฒ„ „„ ƒ๊ฐ•ด ๋ณดž
~cpp 
class Widget { ...}
class SpecialWidget: public Widget { ... };
void passAndThrowWidget()
{
    SpecialWidget localSpecialWidget;
    ...
    Widget& rw = localSpecialWidget;
    throw rw;                           // rw˜ ˜• ฆ‰ Widget˜ ๋ณต‚ฌƒ„ž๊ฐ€ ž‘๋™•˜—ฌ ๋ณต‚ฌ•ด ˜ˆ™ธ๋ฅผ ๋ฐœƒ‹œ‚จ๋‹ค.
}

๋‹คŒ˜ ๊ฒฝšฐ passAndThrowWidget ด ๋˜ง€๋Š”๊ด Widget ด๋‹ค. œ„—„œ –ธ๊ธ‰–ˆ๋“ฏด static typeœผ๋กœ ˜ˆ™ธ๋Š”  „๋‹ฌ๋œ๋‹ค. ปดŒŒผ๋Ÿฌ๋Š” rw๊ฐ€ SpecialWidgetœผ๋กœ˜ ๋™ž‘„  „˜€ ƒ๊ฐ•˜ง€ •Š๋Š”๋‹ค.

˜ˆ™ธฒ˜๋ฆฌ‹œ— ๋‹ค๋ฅธ ๊ฐฒด˜ ‚ฌ๋ณธด  „๋‹ฌ ๋œ๋‹ค๋Š”  € ˜ˆ™ธ๊ฐ€ ๊ณ„†  „๋‹ฌ(ผ ธ๋‚˜๊ฐˆ๋•Œ,propagate)—๋„ •œ๊ฐ€ง€˜ ๊ณ ๋ ค‚ฌ•ญด ๋ฐœƒ•œ๋‹ค. ๋‹คŒ˜ ๋‘๊ฐ€ง€˜ catch ๋ธ”๋Ÿญ€ ฐจด ด žˆ๋‹ค. •˜ง€๋งŒ ™ธ๊ฒฌƒ ๊ฐ™€ —ญ• „ •œ๋‹ค.
~cpp 
    catch (Widget& w)
    {
        ...
        throw;              // •ด๋‹น ๊ฐฒด๋ฅผ ๋‹ค‹œ ๋ณต‚ฌ•˜ง€ •Š๊ณ  ๋˜ง€๋ฉฐ, •ด๋‹น ˜ˆ™ธ๋ฅผ propagete •œ๋‹ค. 
    }
    catch (Widget& w)
    {
        ...
        throw w;            // •ด๋‹น ๊ฐฒด๋ฅผ ๋‹ค‹œ ๋ณต‚ฌ•ด„œ ๊ทธ ‚ฌ๋ณธ„ propagate•œ๋‹ค.
    }
ฃผ„— ๋˜–ด žˆ๋Š”๋ฐ๋กœ, ƒ๊ฐ•ด ๋ณด๋ผ. throw๊ฐ€ ๋ณต‚ฌƒ„ž๋ฅผ ˜ธถœ•˜ง€ •Š•„„œ šจœจ ด๋‹ค. ๊ทธ๋ฆฌ๊ณ  throw๋Š” –ด๋– •œ ˜•ด๋“  ˜ˆ™ธ๋ฅผ  „๋‹ฌ•œ๋Š”๋ฐ ƒ๊ด€•˜ง€ •Š๋Š”๋‹ค. •˜ง€๋งŒ, ‚ฌ‹ค ˜ˆ™ธžฒด๊ฐ€ ๊ทธ ˜•— ๋งž๊ฒŒ ๋˜ ธง€๋ฏ€๋กœ ๊ •ด —†๋‹ค. •˜ง€๋งŒ catch๋ฌธ—„œ ˜ˆ™ธ๋ฅผ ๋˜ง€๋Š” ๊ฐฒด˜ ˜•ƒœ๋ฅผ ๋ฐ”๊ฟ€ •„š”„ด žˆ„๋•Œ ›„ž๋ฅผ ‚ฌšฉ•ด•ผ ๊ฒ ๋‹ค.

ž ๊ทธ๋Ÿผ ๋‹คŒ˜ „ธ๊ฐ€ง€ catch— ๊ด€•ด„œ ‹œ—˜•ด ๋ณดž. passAndThrowWidget—„œ ๋ฐœƒ•œ ˜ˆ™ธ๋Š” ๋‹คŒ˜ „ธ๊ฐ€ง€˜ ๊ฒฝšฐ๋กœ žก„ˆ˜ žˆ๋Š”๊˜ˆƒ• ˆ˜ žˆ๋‹ค.
~cpp 
catch (Widget w) ...        // ๊ฐ’œผ๋กœ  „๋‹ฌ

catch (Widget& w) ...       // ฐธกฐ  „๋‹ฌ

catch (const Widget& w) ... // ƒˆ˜ ฐธกฐ๋กœ  „๋‹ฌ
 „๋‹ฌ๋œ ๊ฐฒด๋Š” ๊ฐ„๋‹จžˆ ฐธกฐ๋กœ žก„ˆ˜ žˆ๋‹ค;๊ทธ๊ฒƒ€ ƒˆ˜ ฐธกฐ๋กœ  „๋‹ฌ๋  •„š”„€ —†๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ƒˆ˜ ฐธกฐ๊ฐ€ •„๋‹Œ  „๋‹ฌ ž„‹œ ๊ฐฒด๋“ค€ •จˆ˜๋ฅผ ๋ถ€๋ฅด๋Š”๊—ˆšฉ•˜ง€ •Š๋Š”๋‹ค.

๊ทธ๋Ÿผ ด๋“ค˜ ฐจด „ ‚ดŽด๋ณด๊ณ  ˜ˆ™ธ ๊ฐฒด๋“ค„ ๋ฆฌ„•ด ๋ณดž.

~cpp 
    catch (Widget w) ...    // ๊ฐ’œผ๋กœ  „๋‹ฌ
ด๋ ‡๊ฒŒ ๊ฐ’œผ๋กœ  „๋‹ฌ•˜๋ฉด ๋‘๋ฒˆ˜ ๋ณต‚ฌ๊ฐ€ ผ–ด๋‚˜๋Š”๊˜ˆƒ• ˆ˜ žˆ๋‹ค. throw‹œ •œ๋ฒˆ catch‹œ •œ๋ฒˆ ok? ๋น„šจœจด๋‹ค.

ฐธกฐ๋กœ  „๋‹ฌ• ๋•Œ ˜ˆƒ•ด ๋ณดž
~cpp 
    catch (Widget& w) ...           // ฐธกฐ  „๋‹ฌ.
    catch (const Widget& w) ...     // ƒˆ˜-ฐธกฐ  „๋‹ฌ
šฐ๋ฆฌ๋Š” ง€๊ธˆ๊นŒง€ ๋ณต‚ฌ— ˜•œ ง€๋ถˆ„ ƒ๊ฐ• ˆ˜ žˆ๋Š”๋ฐ ฐธกฐ˜  „๋‹ฌ€ ๋ฐ˜๋Œ€๋กœ ๋ณต‚ฌ•˜๋Š” ž‘—…ด —†๋‹ค. ฆ‰, •œ๋ฒˆ˜ ๋ณต‚ฌ ด›„ ๊ณ„† ๊ฐ™€ ๊ฐฒด๋ฅผ ‚ฌšฉ•˜๊ฒŒ ๋˜๋Š” …ˆด๋‹ค.

šฐ๋ฆฐ •„ง ฌธ„ „๋‹ฌ— ˜•œ ๊˜๋…ผ•˜ง€ •Š•˜๋‹ค. •˜ง€๋งŒ ฌธ„ฐ๋ฅผ ดšฉ•ด ˜ˆ™ธ๋ฅผ ๋˜ง€( „๋‹ฌ:throw)•˜๋Š” ๊ฒƒ€ •จˆ˜ƒ—„œ ฌธ„ฐ๋ฅผ  „๋‹ฌ(pass)•˜๋Š” ๊ฒƒ๊ณผ๋Š” ๋‹ค๋ฅธ๊•Œˆ˜ ž‡„ ๊ฒƒด๋‹ค. ฆ‰, ฌธ„˜ ๋ณต‚ฌ๋ณธด ด๋™•˜๋Š”๋ฐ, ด๋ ‡๊ฒŒ ๋˜๋ฉด pointer๋ฅผ  „๋‹ฌ•˜๋Š” ชฝ˜ ˜—ญ—„œ throw— ˜•ด Š€–ด ๋‚˜๊ฐ€๋ฉด ฌธ„ฐ๊ฐ€ ๊ฐ€๋ฆฌ‚ค๊ณ  žˆ๋Š” ๊ฐฒด๋Š” †Œ๋ฉธ๋˜๋ฏ€๋กœ ฌธ„— ˜•œ ˜ˆ™ธ  „๋‹ฌ(๋˜ง€๋Š”๊ฒƒ:throw)๋Š” ”ผ•ด•ผ •œ๋‹ค. ( „—ญ˜ static ๊ฐฒด˜ ฌธ„ฐ๋ผ๋ฉด ด•ผ๊ธฐ๋Š” ๋‹ฌ๋ผ„๋‹ค. ๋’ค— ๋‹ค๋ฃฌ๋‹ค.)

ž ๊ทธ๋Ÿผ ˜ˆ™ธ๋ฅผ ๋˜ˆ๋•Œ˜ ˜•— ๊ด€•œ ฃผ˜๋ฅผ ‚ดŽด ๋ณดž. C++˜ •”‹œ  ๋ณ€™˜— ˜•œ ๊ฒƒด ๊ทธ ๋ฌธ œ˜ ๋ฐœ๋‹จธ๋ฐ, ฝ”๋“œ๋ฅผ ๋ณดž ‘œค€ ˆ˜•™ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ—„œ
~cpp 
    double sqrt(double);
๋ฅผ ด๋ ‡๊ฒŒ ‚ฌšฉ • ˆ˜ žˆ๋‹ค.
~cpp 
    int i;
    double sqrtOfi = sqrt(i);
Item 5—๋„ –ธ๊ธ‰๋˜–ด žˆ๋“ฏด C++ƒ—„œ˜ •”‹œ  ๋ณ€™˜€ ๊ด‘ ๋ฒ”œ„•˜๋‹ค. i˜•˜ double๋ณ€™˜€ ๊ฐ€๋ฟ? •˜๋‹ค. •˜ง€๋งŒ ๋‹คŒ„ ๋ณดž
~cpp 
    void f (int value)
    {
        try {
            if (someFunction() ) {      // someFunction()ด ฐธด๋ฉด int˜•˜ ๋ณ€ˆ˜๋ฅผ ˜ˆ™ธ๋กœ ๋˜„๋‹ค.
                throw value;
            }
            ...
        }
        catch (double d) {      // •ด๋‹น •ธ๋“ค€ doubleผ๋•Œ๋งŒ ˜ˆ™ธ๋ฅผ žก„ˆ˜ žˆ๋‹ค. ๊ทธ๋Ÿผ value๋ฅผ ๋˜ง€๋Š”
            ...                 // try—„œ˜ ˜ˆ™ธ๋Š”  ˆ๋Œ€๋กœ žกžˆง€ •Š๋Š”๋‹ค. ˜๋„•œ ๋ฐ”๊ฐ€ •„๋‹ˆ๋ฆฌ๋ผ.
        }
        ...
    }
ด๋Ÿฐ ‚ฌ•ญ„ œ ˜ •ด•ผ •œ๋‹ค. ˜ˆ™ธ—„œ๋Š” •”‹œ  ๋ณ€™˜„ ƒ๊ฐ•˜ง€ •Š๋Š”๋‹ค.

๊ทธ๋Ÿผ ˜ˆ™ธ˜ ๋ณ€™˜—๋Š” ฌ๊ฒŒ ๋‘๊ฐ€ง€˜ ƒ๊ฐ•   ด žˆ๋Š”๋ฐ. ฒซ๋ฒˆงธ๊ฐ€ ƒ† ๊ด€๊ณ„(˜ˆ™ธ ƒ˜) ด๋‹ค. ˜ˆ™ธ—„œ๋Š” •œ ˜ˆ™ธ ๊ฐฒด—„œ ŒŒƒ๋œ ๋‹ค๋ฅธ ˜ˆ™ธ๊ฐฒด๋“ค„ žก๋Š”๊ฒƒด ๊ฐ€๋Šฅ•œ๋ฐ ˜ˆ๋ฅผ๋“ค–ด„œ ‘œค€ C++ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ—„œ˜ ˜ˆ™ธ ƒ†๋„๋Š” ด๋ ‡๊ฒŒ ๊ตฌ„๋˜—ˆ๋‹ค. (๋ชจ๋“  ˜ˆ™ธ๊ฐ€ ๋‚˜™”๋Š”ง€๋Š” ๋ชจ๋ฅด๊ฒ ๋‹ค.)
~cpp 
    exception 
        |
        +-logic_error
        |   |
        |   +-domain_error
        |   +-invalid_argument
        |   +-length_error
        |
        +-runtime_error
            |
            +-range_error
            +-underflow_error
            +-overflow_error

catch—„œ ๋ถ€๋ชจ ๊ฐฒด๋กœ žกœผ๋ฉด ž‹ ๊ฐฒด˜ ˜ˆ™ธ๋“คด ๋‹ค žกžˆ๋Š” ‹ด๋‹ค .˜ˆ๋ฅผ ๋“คž๋ฉด
~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*) ...
ด๋ ‡๊ฒŒ •˜๋ฉด –ด๋– •œ ฌธ„ฐ type๋ผ๋„ žก„ ๊ฒƒด๋‹ค.

๋งˆง€๋ง‰œผ๋กœ ธž ๋„˜๊ธฐ๊ธฐ™€ ˜ˆ™ธ  „๋‹ฌ(๋˜ง€๊ธฐ:throw)˜ ๋‹ค๋ฅธ  € catch ๊ตฌ๋ฌธ€ •ญƒ catch๊ฐ€ “ฐ—ฌ„ ˆœ„œ๋Œ€๋กœ (in the order of their appearance) ๊ตฌ๋™๋œ๋‹ค๋Š”  ด๋‹ค. (˜–ด ๊ตฌ๋ฌธ„ ฐธกฐ•˜‹œ๊ธธ) ๋งด ดƒ•˜๋‹ค. ๊ทธ๋ƒฅ ๋‹คŒ ˜ˆ œ๋ฅผ ๋ณดž

~cpp 
    try{
        ...
    }
    catch (logic_error& ex) {       // —ฌ๊ธฐ—„œ ๋ชจ๋“  logic—๋Ÿฌ๊ฐ€ žกžŒ๋‹ค.
        ...
    }
    catch (invalid_argument & ex){  // ด ๋ฌธ€ ž‘๋™„ •˜ง€ •Š๋Š”๋‹ค. œ„˜ catch๊ตฌ๋ถ„—„œ ด๋ฏธ žก•„ ๋ฒ„๋ฆฐ๋‹ค.
        ...
    }

๋ฐ˜๋Œ€๋กœ ๊ฐ€ƒ•จˆ˜๋ฅผ ๋ถ€๋ฅผ๋•Œ ผ–ด๋‚˜๋Š”ผด žˆ๋‹ค. ๋‹น‹ ด ๊ฐ€ƒ•จˆ˜๋ฅผ ˜ธถœ•˜๋ฉด •จˆ˜๋Š” •ด๋‹น ๊ฐฒด˜ ๊ฐ€žฅ •ฉ๋‹น•œ •จˆ˜๋ฅผ dynamicœผ๋กœ ฐพ•„๋‚ธ๋‹ค. ด๊ฒƒ€ ตœ๊ณ ๋กœ  •ฉ•œ ๊ฒƒ(best fit)„ ˜๋ฏธ•˜ง€ ๊ฐ€žฅ ฒ˜Œ— ฐพ•„ ง€๋Š” ๊ฒƒ(first fit)„ ˜๋ฏธ•˜๋Š” ๊ฒƒด •„๋‹ˆ๋‹ค. œ„˜ †ŒŠค๋ฅผ ๋ฐ˜๋Œ€๋กœ •œ๋‹ค๋ฉด

~cpp 
    try{
        ...
    }
    catch (invalid_argument & ex){  // invalid_argument ˜ˆ™ธ๋Š” ด๊ณณ—„œ žกžŒ๋‹ค.
        ...
    }
    catch (logic_error& ex) {       // —ฌ๊ธฐ„œ ๋ชจ๋“  ๋‹ค๋ฅธ logic_error ๊ด€๋ จ€ ด๊ณณ—„œ žกžŒ๋‹ค.
        ...
    }
ด๋ ‡๊ฒŒ ๋Œ•„๊ฐ€๋Š” ๊ฐ๋‹ค.

žž  •๋ฆฌ
  • ฒซงธ๋กœ ˜ˆ™ธ ๊ฐฒด๋Š” •ญƒ ๋ณต‚ฌ ๋œ๋‹ค.
  • ๋‘˜งธ๋กœ ๋˜ €ง€๋Š” ๊ฐฒด๋Š” •จˆ˜๋กœ  „๋‹ฌ๋ ๋•Œ ๋น„•˜—ฌ ˜•— ๋Œ€•œ ๋ณ€™˜ด ˜•— ˜–ฅ ๋ฐ›๊ธฐ ‰ฝ๋‹ค.
    ˜ˆ™ธ ๊ฐฒด๋Š” ƒ†— ๊ทœน™„ ๋”ฐ๋ฅธ๋‹ค. („ค๋ช…„ ๋ณด‹œ๊ธธ)
  • …‹งธ๋กœ †ŒŠค ฝ”๋“œ— ๋‚˜ƒ€๋‚˜๋Š” ˆœ„œ๋Œ€๋กœ ˜ˆ™ธ๋Š” žกžŒ๋‹ค.

1.5. Item 13: Catch exception by reference

  • Item 13: ˜ˆ™ธ๋Š” ฐธกฐ(reference)๋กœ žก•„๋ผ.

catch ๊ตฌ๋ฌธ„ ‚ฌšฉ• ๋•Œ •ด๋‹น ๊ตฌ๋ฌธ„ †ต•ด„œ  „๋‹ฌ๋ฐ›€ ˜ˆ™ธ ๊ฐฒด๋“ค„ ๋ฐ›๋Š” ๋ฐฉ๋ฒ•„ ž˜•Œ•„•ผ •œ๋‹ค. ๋‹น‹ € „ธ๊ฐ€ง€˜ „ ƒ„ • ˆ˜ žˆ๋‹ค. ๋ฐ”๋กœ  „ Item 12—„œ –ธ๊ธ‰•œ ๊ฒƒฒ˜๋Ÿผ ๊ฐ’(by value), ฐธกฐ(by reference), ฌธ„ฐ(by pointer)ด๋ ‡๊ฒŒ „ธ๊ฐ€ง€  •๋„๊ฐ€ ๋ ๊ฒƒด๋‹ค.

ž, ๋จผ € pointer(by pointer)— ๊ด€•œ  „๋‹ฌ„ ƒ๊ฐ•ด ๋ณดž. ด๋ก  œผ๋กœ ด ๋ฐฉ๋ฒ•€ throwœ„น˜—„œ catch๊ตฌ๋ถ„œผ๋กœ ˜ˆ™ธ๋ฅผ Šน๋ณ„•œ ๋ณ€™” —†ด ๋А๋ฆฐ ”„๋กœ๊ทธ๋žจ ˆ˜–‰ ƒƒœ—„œ  „๋‹ฌ•˜๊ธฐ— ๊ฐ€žฅ ข‹€ ๋ฐฉ๋ฒ•ด๋‹ค. ๊ทธ ดœ ๋Š” ฌธ„˜  „๋‹ฌ€ •ด๋‹น ˜ˆ™ธ ๊ฐฒด๊ฐ€ ๋ณต‚ฌ๋˜๋Š” ผ—†ด ฌธ„ฐ ๊ฐ’๋งŒ  „๋‹ฌ๋˜๋Š” ๋ฐฉ๋ฒ•๋งŒ„ ทจ•ด•ผ •˜๊ธฐ ๋•Œ๋ฌธด๋‹ค. ๋งด ข€ ดƒ•œ๋ฐ ˜ˆ™ธ๋ฅผ ๋ณด๋ฉด„œ „ค๋ช…•œ๋‹ค.

Item 12—„œ –ธ๊ธ‰•œ๊ฒƒ๊ณผ ๊ฐ™ด ˜ˆ™ธ๋Š” ๋ณต‚ฌ๋˜–ด„œ  „๋‹ฌ๋œ๋‹ค. ๊ทธ๊ƒ๊ฐ•ด๋ผ.
~cpp 
    class exception { ... };

    void someFunction()
    {
        static exception ex;        // ด๋ ‡๊ฒŒ ๋ฉ”๋ชจ๋ฆฌ— •ญƒ กดžฌ•˜๋Š” ๊ฐฒด๋งŒ„  „๋‹ฌ• ˆ˜ žˆ๋‹ค.
        ...
        throw &ex;    // ฌธ„ฐ๋กœ  „๋‹ฌ, •ด๋‹น •จˆ˜ ˜—ญ„ ๋ฒ—–ด๋‚˜๋ฏ€๋กœ, static๋งŒด ‚ด•„ ๋‚จ„ˆ˜ žˆ๋‹ค.
        ...
    }
    void doSomething()
    {
        try{
            someFunction();         // —ฌ๊ธฐ—„œ exception *„ ๋˜„๋‹ค.
        }
        catch ( exception *ex) {    // exception* „ žก๊ณ  •„๋ฌด๋Ÿฐ ๊ฐฒด๋„ ๋ณต‚ฌ๋˜ง€ •Š๋Š”๋‹ค.
            ...
        }
    }

ด ฝ”๋“œ๋Š” ๊นจ๋—•˜๊ฒŒ ๋ณดดง€๋งŒ, ตœ„ …€ •„๋‹ˆ๋‹ค. ด๋Ÿฐ ผ„ œ„•ด„œ ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ˜ˆ™ธ ๊ฐฒด๋ฅผ •ญƒ ’ˆ๊ณ žˆ๋Š” ”„๋กœ๊ทธ๋žจ„ ž‘„•ด•ผ • ๊ฒƒด๋‹ค. ๊ฐ„๋‹จžˆ  „—ญ(Global) staitcœผ๋กœ „ –ธ•˜๋ฉด ๋œ๋‹ค๊ณ  ๋ฐ˜๋ฌธ•˜๊ฒ ง€๋งŒ,  „—ญ˜ œ„—˜„€ ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ๊ทธ๊‰ฝ๊ฒŒ ๊นŒ๋จน„ˆ˜ žˆ๋‹ค๋Š”๋ฐ žˆ๋‹ค. ๋‹คŒ ˜ˆ œ๋ฅผ ๋ณด๋ฉด
~cpp 
void someFunction()
{
    exception ex;       // local ˜ˆ™ธ ๊ฐฒดธ๋ฐ ด •จˆ˜˜ ˜—ญ„ ๋ฒ—–ด๋‚˜๋ฉด ŒŒ๊ดด๋˜–ด „๋‹ค.

    ...
    throw &ex;          // ๊ทธ๋Ÿผ ด๊ด ๋ง —›ผด๋ผ๋Š” †Œ๋ฆฌ ด๋ฏธ ŒŒ๊ดด๋œ ๊ฐฒด๋ฅผ ๊ฐ€๋ฆฌ‚ค๊ณ  žˆœผ๋‹ˆ
    ...
}
ž ด๊ด ๋‚˜œ ฝ”๋“œ˜ œ ˜•ผ ๊ฒƒด๋‹ค. ฃผ„—„œ –ธ๊ธ‰•œ๊ฒƒ๊ณผ ๊ฐ™ด •จˆ˜—„œ ๋ฒ—–ด๋‚˜๋ฉด new๋‚˜ staticด •„๋‹Œดƒ ๋งŒ๋“ค–ด„ ๊ฐฒด๋Š” ŒŒ๊ดด๋˜–ด „๋‹ค. ๊ทธ๋ฆฌ๊ณ  catch—„œ๋Š” ŒŒ๊ดด๋˜–ด„ ๊ฐฒด˜ ฃผ†Œ ๊ฐ’„ ๋ฐ›๊ฒŒ ๋˜๋Š” ๊ฒƒด๋‹ค.

•ด๋‹น ฝ”๋“œ๋ฅผ ๋‹คŒ๊ณผ ๊ฐ™ด new heap object๋กœ ๋Œ€ฒด• ˆ˜ žˆ„ ๊ฒƒด๋‹ค.
~cpp 
    void someFunction() 
    {
        ...
        throw new exception;    // ด๊ฒƒ๋„ –ด๊ฐ€ žˆ๋Š”๊ฒŒ, new—„œ ˜ˆ™ธ ๋ฐœƒ•˜๋ฉด –ด๋–ป๊ฒŒ • ๊ฒƒ๊ฐ€?
        ...
    }

ด๊ฒƒ๋„ ”ผ•ด•ผ •  ๋ฐฉ๋ฒ•ด๋‹ค. ™œ๋ƒ•˜๋ฉด I-just-caught-a-pointer-to-a-destoyed-object ๋ฌธ œ ๋•Œ๋ฌธด๋‹ค. ๊ฒŒ๋‹ค๊ฐ€ catch๊ตฌ๋ฌธ—„œ ง๋ฉด•œ ๋˜•˜๋‚˜˜ ๋ฌธ œ๋Š” ๋Œ€ฒด ด ฌธ„ฐ๋ฅผ ๋ˆ„๊ฐ€ –ด๋””„œ ง€šฐ๋А๋ƒ ด๋‹ค. ๋‹ค๋ฅธ ๋ฉดœผ๋กœ ƒ๊ฐ•ด๋ณผ ๋ฌธ œ๋Š” ˜ˆ™ธ ๊ฐฒด๊ฐ€ heapƒ— ๋ฐฐน˜๋œ๋‹ค๋ฉด ง€›Œ ง€ง€ •Š€ ˜ˆ™ธ ๊ฐฒด๋Š” ‹€ž„—†ด resource leak๋ฅผ ๋ฐœƒ ‹œ‚ฌ ๊ฒƒด๋‹ค. ๋„ˆ๋ฌด ๋ป”•œ ด•ผ๊ธฐ ธ๊ฐ€. ๊ทธ๋ฆฌ๊ณ  ”„๋กœ๊ทธ๋žจ˜ –‰๋ณด๊ฐ€ –ด๋–ป๊ฒŒ ๋ ง€ ˜ˆธก • ˆ˜๋„ —†๋‹ค. •ˆ๊ทธ๋Ÿฐ๊ฐ€?

๋ช‡๋ช‡ ด๋ผด–ธŠธ๋Š”  „—ญ(global)ด๋‚˜  •  ๊ฐฒด๋ฅผ(static object)˜ ฃผ†Œ๋ฅผ ๋„˜๊ธฐž๊ณ  ๋ง•˜๊ณ , ๋ช‡๋ช‡€ heapƒ˜ ˜ˆ™ธ ๊ฐฒด˜ ฃผ†Œ๋ฅผ  „๋‹ฌ•˜ž๊ณ  ๋ง•œ๋‹ค. ดฒ˜๋Ÿผ ฌธ„ฐ๋ฅผ †ต•œ ˜ˆ™ธ˜  „๋‹ฌ€ (Catch by pointer) •„๋ฆฌ†ก•œ ๋ฌธ œ๋ฅผ ๋ฐœƒ ‹œ‚จ๋‹ค. ง€›Œ กŒ๋Š”๊ฐ€? •ˆง€›Œ กŒ๋Š”๊ฐ€? •ญƒ ๋Œ€๋‹ต€ ™•‹ค•˜ง€ •Š๋‹ค.

๊ฒŒ๋‹ค๊ฐ€ catch-by-pointer(ฌธ„ฐ๋ฅผ †ต•œ ˜ˆ™ธ  „๋‹ฌ)€ –ธ–ดƒ—„œ ‚ฌ๋žŒ๋“ค˜ ๋Œ€๋ฆฝ„ œ ๋„ •œ๋‹ค. ๋„ค๊ฐ€ง€˜ ‘œค€ ˜ˆ™ธ ๊ฐฒด๋“ค๋“ค( bad_alloc(Item 8:operator new—„œ ๋ถˆถฉ๋ถ„•œ ๋ฉ”๋ชจ๋ฆฌ ๋ฐ˜™˜), bad_cast(Item 2:dynamic_cast—„œ ฐธกฐ ‹คŒจ), bad_typeid(dynamic_castผ๋•Œ nullฌธ„ฐ๋กœ ๋ณ€™˜), bad_exception(Item 14:˜ˆธก ๋ชป•˜๋Š” ˜ˆ™ธ๋กœ ๋น ง€๋Š” ๊ฒƒ unexpected exception ๋ฌธ œ) ๊ฐ€ ˜ˆ™ธ ๊ฐฒด๋“ค˜ ๋ชจ๋“  ๊ฒƒธ๋ฐ, ด๋“ค„ –ฅ•œ ๊ธฐ๋ณธ ธ ฌธ„ฐ๋Š” กดžฌ•˜ง€ •Š๋Š”๋‹ค. ๊ทธ๋ž˜„œ ๋‹น‹ € ˜ˆ™ธ๋ฅผ ๊ฐ’œผ๋กœ(by value)˜น€ ฐธกฐ๋กœ(by reference) ๋ฐ–—๋Š” ๋Œ€•ˆด —†๋‹ค.

Catch-by-value๋Š” ‘œค€ ˜ˆ™ธ ๊ฐฒด๋“ค ƒ——„œ ˜ˆ™ธ ๊ฐฒด˜ ‚ญ œ ๋ฌธ œ— ๊ด€•ด„œ ๊ณ ๋ฏผ•  •„š”๊ฐ€ —†๋‹ค. •˜ง€๋งŒ ˜ˆ™ธ๊ฐ€  „๋‹ฌ๋ ๋•Œ ๋‘๋ฒˆ˜ ๋ณต‚ฌ๊ฐ€ ด๋ฃจ–ด „๋‹ค๋Š”๊ฒŒ ๋ฌธ œ๋‹ค. (Item 12ฐธ๊ณ ) ๊ฒŒ๋‹ค๊ฐ€ ๊ฐ’œผ๋กœ˜  „๋‹ฌ€ slicing problemด๋ผ๋Š” ๋ฌธ œ๋ฅผ ๋ฐœƒ‹œ‚จ๋‹ค. ด๊ฒŒ ๋ญ๋ƒ •˜๋ฉด, ๋งŒ•ฝ ‘œค€ ˜ˆ™ธ ๊ฐฒด—„œ œ ๋„(ƒ†)•ด„œ ๋งŒ๋“ค–ด„ ˜ˆ™ธ ๊ฐฒด๋“คด •ด๋‹น ๊ฐฒด˜ ๋ถ€๋ชจ๋กœ ๋˜ € „๋‹ค๋ฉด, ๋ถ€๋ชจ ŒŒŠธ ๋ถ€๋ถ„๋งŒ ๊ฐ’œผ๋กœ ๋‘๋ฒˆงธ ๋ณต‚ฌ‹œ— ๋ณต‚ฌ๋˜–ด„œ  „๋‹ฌ๋˜–ด ๋ฒ„๋ฆฐ๋‹ค๋Š” ๋ฌธ œ๋‹ค. ฆ‰ ž˜๋ผ๋ฒ„๋ฆฌ๋Š” ๋ฌธ œ "slice off" ๋ผ๋Š” ‘œ˜„ด ๋“ค–ด ๊ฐˆ๋งŒ •˜๊ฒ ง€. ๊ทธ๋“ค˜ data member๋Š” •„๋งˆ ๋ถ€•จด ƒ๊ฒจ ๋ฒ„๋ฆด ๊ฒƒด๊ณ  •ด๋‹น ๊ฐฒดƒ—„œ ๊ฐ€ƒ •จˆ˜๋ฅผ ๋ถ€๋ฅผ๋•Œ —ญ‹œ ๋ฌธ œ๊ฐ€ ๋ฐœƒ•ด ๋ฒ„๋ฆด ๊ฒƒด๋‹ค. •„๋งˆ ๋ฌดกฐ๊ด ๋ถ€๋ชจ ๊ฐฒด˜ ๊ฐ€ƒ •จˆ˜๋ฅผ ๋ถ€๋ฅด๊ฒŒ ๋  ๊ฒƒด๋‹ค.(ด ๊ฐ™€ ๋ฌธ œ๋Š” •จˆ˜— ๊ฐฒด๋ฅผ ๊ฐ’œผ๋กœ ๋„˜๊ธธ๋•Œ๋„ ๋˜‘๊ฐ™ด  œ๊ธฐ ๋œ๋‹ค.) ˜ˆ๋ฅผ ๋“ค–ด„œ ๋‹คŒ„ ƒ๊ฐ•ด ๋ณดž
~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 ƒ˜ ๊ฐ€ƒ•จˆ˜๋ฅผ
                                    // ๋ถ€๋ฅด๊ธธ ›•˜๋Š” ๊ฒƒ ด—ˆ๋‹ค.
            ...
        }
    }
ฃผ„— –ธ๊ธ‰๋˜–ด žˆ๋“ฏด ด ๋ฒ„ „€ slicing ๋ฌธ œ๊ฐ€ ๋ฐœƒ•œ๋‹ค. ๊ตฌฐจ•œ „ค๋ช… ๊ท€ฐฎ๋‹ค. ๊ฒฐ๋ก € ๊ฐ’œผ๋กœ(by value)˜ ˜ˆ™ธ ๊ฐฒด  „๋‹ฌ€ ด๋Ÿฐ slicing ๋ฌธ œ๋กœ ๋‹น‹ ด ›•˜๋Š” –‰๋™„  ˆ๋Œ€๋กœ ๋ชป•œ๋‹ค.

žž ๊ทธ๋Ÿผ ๋‚จ€๊˜คง catch-by-reference(ฐธกฐ๋กœ„œ ˜ˆ™ธ  „๋‹ฌ)ด๋‹ค. catch-by-reference๋Š” ด œ๊นŒง€˜ ๋…ผ˜๋ฅผ ๊นจ๋—ด —†•  ค€๋‹ค. catch-by-pointer˜ ๊ฐฒด ‚ญ œ ๋ฌธ œ™€ ‘œค€ ˜ˆ™ธ ƒ€ž…๋“ค„ žก๋Š”๊— ๋Œ€•œ –ด๋ ค›€, catch-by-value™€ ๊ฐ™€ slicing ๋ฌธ œ๋‚˜ ๋‘๋ฒˆ ๋ณต œ๋˜๋Š” –ด๋ ค›€ด —†๋‹ค. ฐธกฐ๋กœ„œ ˜ˆ™ธ  „๋‹ฌ—„œ ˜ˆ™ธ ๊ฐฒด๋Š” ˜คง •œ๋ฒˆ ๋ณต‚ฌ๋˜–ด ˆ ๋ฟด๋‹ค.

๋‹คŒ ˜ˆ œ๋ฅผ ๋ณดž.
~cpp 
void someFunction()
{
    ...
    if ( validation …ŒŠคŠธ —๋Ÿฌ ){
        throw Validataion_error();
    }
    ...
}

void doSomething()
{
    try{
        someFunction();
    }
    catch (exception& ex){      // ด๋ถ€๋ถ„„ ฐธกฐ๋กœ๋งŒ ๋ฐ”๊พธ—ˆ๋‹ค. ด „˜ ˜ˆ œ™€ Šน๋ณ„žˆ ๋ฐ”๋€๊ฒŒ —†๋‹ค.
                                // •˜ง€๋งŒ ด๋ถ€๋ถ„ด ๋ฐ”๋€Œ–ด„œ
        cerr << ex.what();      // —ฌ๊ธฐ„œ˜ ๊ฐ€ƒ •จˆ˜๋„ Validation_error˜ ๋ฉ”†Œ๋“œ๊ฐ€ ๋ถˆ๋ฆฐ๋‹ค.
        ...
    }
}

•ด๋‹น †ŒŠค๋Š” catch—„œ ฐธกฐ๋กœ๋งŒด ๋ฐ”๋€Œ—ˆ๋‹ค. &•˜๋‚˜๋งŒด ถ”๊ฐ€๋˜–ด ง€๊ธˆ๊นŒง€  œ๊ธฐ๋œ ๋ฌธ œ๊ฐ€ ‚ฌ๋ผ ธ ๋ฒ„๋ฆฐ๋‹ค.

catch-by-reference๋Š” ด œ๊นŒง€˜ ๋ฌธ œ— ๋ชจ๋“  •ด๊ฒฐ…„  œ‹œ•œ๋‹ค. (slicing, delete๋ฌธ œ etc)๊ทธ๋Ÿผ ด œ ๊ฒฐ๋ก € •˜๋‚˜ •„๋‹๊นŒ?

Catch exception by reference!

1.6. Item 14: Use exception specifications judiciously.

  • Item 14: ˜ˆ™ธ๋ฅผ ‹ ค‘•˜๊ฒŒ ‚ฌšฉ•˜๋ผ.
(judiciously- ‹ ค‘•œ)

ผ๋‹จ ด ฃผ œ๋ฅผ ๋ถ€ ••˜๋Š” ด๋Š” —†œผ๋ฆฌ๋ผ.:˜ˆ™ธ๋Š”   ˆ•œ ๊ณณ— ‘œ˜„๋˜–ด•ผ •œ๋‹ค. ๊ทธ๋“ค€ ฝ”๋“œ๋ฅผ ๋” ด•ด๊ฐ€๊ธฐ Žธ•˜๊ฒŒ ๋งŒ๋“ค–ด ค€๋‹ค. ™œ๋ƒ•˜๋ฉด •„๋งˆ ๋ช…‹œ œผ๋กœ ‘œ˜„๋œ ˜ˆ™ธ ƒƒœ๊ฐ€  „๋‹ฌ(๋˜ €:throw-ด•˜ ๋˜„๋‹ค๋Š” ‘œ˜„œผ๋กœ) ๋  ๊ฒƒด๊ธฐ ๋•Œ๋ฌธด๋‹ค. ๊ทธ๋ ‡ง€๋งŒ ˜ˆ™ธ๋Š” ฃผ„(comment)๋ณด๋‹ค๋Š” ๋ชจ˜ธ•˜๋‹ค. ปดŒŒผ๋Ÿฌ๋Š” ๋•Œ๋•Œ๋กœ ปดŒŒผค‘—  •™•žˆ ผน˜•˜ง€ •Š€ ˜ˆ™ธ๋“ค„ ๋ฐœ๊ฒฌ• ˆ˜๋„ žˆœผ๋ฉฐ, ๋งŒ•ฝ •จˆ˜๊ฐ€ ˜ˆ™ธ ŠคŽ™(๋ช…„ธ:ด•˜๋ช…„ธ)ƒ—  œ๋Œ€๋กœ ๋ช…๊ธฐ๋˜ง€ •Š€ ˜ˆ™ธ๋ฅผ  „๋‹ฌ(๋˜กŒ)๋‹ค๋ฉด ž˜๋ชป€ ‹ค–‰‹œ๊ฐ„(runtime)— ๋ฐœ๊ฒฌ๋œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  Šน๋ณ„•œ •จˆ˜ธ unexpected๋Š” ž๋™œผ๋กœ ๋ถˆ๋ฆฌ๊ฒŒ ๋œ๋‹ค. ด๋ ‡๋“  ˜ˆ™ธฒ˜๋ฆฌ๋Š” ƒ๋‹นžˆ ๋งค๋ ฅ ธ ๋ฉด„ ๊ฐ€ง€๊ณ  žˆ๋‹ค.

  • •˜ง€๋งŒ ๋ณด†ต •„๋ฆ„๋‹ค›€€ ‘œ๋ฉดด •„๋‹Œ ๋‚ด๋ฉด— กดžฌ•œ๋‹ค.
unexpected— ๊ด€๋ จ•œ ๊ธฐ๋ณธ ธ –‰๋™€ terminate๋ฅผ ˜ธถœ•ด„œ terminate๋‚ด—„œ abort๋ฅผ ˜ธถœ๋กœ ๊ฐ• œ๋กœ ”„๊ทธ๋žจ„ ๋ฉˆถ”๊ฒŒ •œ๋‹ค. ด ˜๋ฏธ๋Š” ๋ฐ”๋กœ abort๋Š” ”„๋กœ๊ทธ๋žจ„ ข…๋ฃŒ• ๋•Œ ๊นจ๋—ด ง€šฐ๋Š” ๊ณผ •„ ƒ๋žต•˜๊ธฐ ๋•Œ๋ฌธ— ™œ„™”๋œ Šคƒ ”„๋ ˆž„๋‚ด˜ ง€—ญ ๋ณ€ˆ˜๋Š” ŒŒ๊ดด๋˜ง€ •Š๋Š”๋‹ค.(ฆ‰, ”„๋กœ๊ทธ๋žจด ๋ฉˆถ”๊ณ  ๋””๋ฒ„๊ทธ‹œ ๊ทธ ƒ™ฉ— ˜„žฌ˜ ž๋ฃŒ ๊ฐ’„ กฐ‚ฌ• ˆ˜ žˆ๋‹ค๋Š” ˜๋ฏธ). ๊ทธ๋ž˜„œ ˜ˆ™ธ ฒ˜๋ฆฌ˜ ๋ช…„„ –ด๊ธด ๋ฌธ œ๋Š” ƒ๋‹นžˆ ‹ฌ๊ฐ•œ ƒ™ฉด๋‚˜, ๊˜ ๋ฐœƒ•˜ง€ •Š€ ƒ™ฉด๋‹ค. ๋ถˆ–‰žˆ๋„ ๊ทธ๋Ÿฐ ‹ฌ๊ฐ•œ ƒ™ฉ„ ด๋ฅด๊ฒŒ •˜๋Š” •จˆ˜ ž‘„ด šฉด•˜๋‹ค๋Š”๊ฒŒ ๋ฌธ œด๋‹ค. ปดŒŒผ๋Ÿฌ๋Š” ˜คง ˜ˆ™ธ ๋ช…„— ž…๊ฐ•œ๋Œ€๋กœ ๋ถ€๋ถ„ œผ๋กœ ˜ˆ™ธ ‚ฌšฉ— ๊ด€•œ ๊ฒ€‚ฌ๋ฅผ •œ๋‹ค. ˜ˆ™ธ๊ฐ€ žก„ˆ˜ —†๋Š”๊ฒƒ-–ธ–ด ‘œค€ ƒ—„œ ๊ฐ๋ถ€•˜๋Š”(๋น„๋ก ฃผ˜(wanning)ผง€๋ผ๋„) ๊ธˆง€•˜๋Š” ๊ฒƒ- € •จˆ˜๋ฅผ ˜ธถœ• ๋•Œ ˜ˆ™ธ ๋ช…„—„œ ๋ฒ—–ด๋‚˜๋Š” •จˆ˜ผ๊ฒƒด๋‹ค.

๋‹คŒ˜ f1•จˆ˜— ๊ฐ™ด •„๋ฌด๋Ÿฐ ˜ˆ™ธ๋ฅผ ๋ฐœƒ •ˆ‹œ‚ค๋Š” •จˆ˜— ๊ด€•ด„œ ƒ๊ฐ•ด ๋ณดž.  €๋Ÿฐ •จˆ˜๋Š” •„๋งˆ –ด๋– •œ ˜ˆ™ธ๋ผ๋„ ๋ฐœƒ‹œ‚ฌˆ˜ žˆ„ ๊ฒƒด๋‹ค.
~cpp 
    extern void f1();
ž ๊ทธ๋Ÿผ ˜ˆ™ธ ๋ช…„ด  šฉ๋œ f2๋ฅผ ๋ณดž. ๋‹คŒ€ ˜คง int๋งŒ„ ˜ˆ™ธ๋กœ ๋˜ˆ๊ฒƒด๋‹ค.
~cpp 
    void f2() throw(int);
f1ด f2˜ •จˆ˜ ๋ช…„ธ๊ณผ ๋‹ค๋ฅธ ˜ˆ™ธ๋ฅผ ๋˜ง€๋”๋ผ๋„, C++ƒ—„œ๋Š” f2—„œ f1๋ฅผ ๋ถ€๋ฅด๋Š”๊ฒƒ„ —ˆšฉ•œ๋‹ค.
~cpp 
    void f2() throw(int)
    {
        ...
        f1();
        ...
    }
ด๋Ÿฐ œ —ฐ•œ ๊ฒฝšฐ๋Š” ๋งŒ•ฝ ˜ˆ™ธ ๋ช…„— ๊ด€•œ ƒˆ๋กœšด ฝ”๋“œ๊ฐ€ ๊ณผ๊˜ ˜ˆ™ธ ๋ช…„ธ๊ฐ€ ๋ถ€•œ ฝ”๋“œ™€ ž˜ ๊ฒฐ•ฉ• ˆ˜ žˆŒ„ ๋ณดธ๋‹ค.

๋‹น‹ ˜ ปดŒŒผ๋Ÿฌ๊ฐ€ ˜ˆ™ธ ฒ˜๋ฆฌ๊ทœ •— ๋งŒ•˜ง€ •Š€ ๋ฃจ‹ด„ ๊ฐ€„ •จˆ˜˜ ฝ”๋“œ๋ฅผ ˜ธถœ•˜๋Š”๋ฐ ๋ณ„ ๋ฌด๋ฆฌ—†๋‹ค๊ณ , ๊ทธ๋Ÿฌ•œ ˜ธถœด •„๋งˆ ๋‹น‹ ˜ ”„๋กœ๊ทธ๋žจ—„œ ”„๋กœ๊ทธ๋žจ˜ ค‘ง€๋ฅผ œ ๋„•˜๊ธฐ ๋•Œ๋ฌธ— ๋‹น‹ € †Œ”„Šธ›–ด๋ฅผ ๋งŒ๋“ค๋•Œ ตœ๋Œ€•œ ๊ทธ๋Ÿฐ ๋งŒ๋˜ง€ •Š€ ˜ธถœ„ ตœ†Œ™” •˜๋„๋ก ๊ฒฐ๊ณผ๋ฅผ œ ๋„•ด•ผ • ๊ฒƒด๋‹ค. ‹œž‘‹œ ๊ฐ€žฅ ข‹€ ๋ฐฉ–ฅ€ …œ”Œ๋ฆฟƒ—„œ˜ ˜ˆ™ธ ŠคŽ™๋ฅผ ตœ๋Œ€•œ ”ผ•˜๋Š” ๊ฒƒด๋‹ค. ž ๋‹คŒ˜ –ด๋– •œ ˜ˆ™ธ๋„ ๋˜ง€ง€ •Š€ …œ”Œ๋ฆฟ„ ƒ๊ฐ•ด ๋ณดž.
~cpp 
    template<class T>
    bool operator==(const T& lhs, const T& rhs) throw()
    {
        return &lhs == &rhs;
    }
ด …œ”Œ๋ฆฟ€ oprator== •จˆ˜๋ฅผ ๋ชจ๋“  ˜•—  šฉ‹œ‚ค๋Š” ๊ฒƒด๋‹ค. •„๋งˆ ๊ฐ™€ ฃผ†Œ— ๊ฐ™€ ƒ€ž…ด๋ฉด true๋ฅผ ๋ฐ˜™˜•˜ง€๋งŒ •„๋‹ˆ๋ผ๋ฉด ๊ทธ๊ฒƒ€ false๋ฅผ ๋ฐ˜™˜•œ๋‹ค. ด๋Ÿฐ …œ”Œ๋ฆฟ€ •„๋ฌด๋Ÿฐ ˜ˆ™ธ๋„ ๋˜ง€ง€ •Š€ …œ”Œ๋ฆฟœผ๋กœ ๋ถ€„•จˆ˜๊ฐ€ ๋งŒ๋“ค–ดง€๋Š” ƒƒœ— ๋”ฐ๋ผ  •ฉ•œ ˜ˆ™ธ๊ฐ€ ฌ•จ๋œ๋‹ค. •˜ง€๋งŒ ๊ทธ๊ฒƒ€ ๊ผญ ‚ฌ‹คด •„๋‹ˆ๋‹ค. ™œ๋ƒ•˜๋ฉด operator&(ฃผ†Œ ๋ฐ˜™˜ operator)๊ฐ€๊ฐ€ ๊ผญ ๊ฐ™€ ๋ช‡๋ช‡˜ ˜•๋“ค„ œ„•ด„œ overload๋˜—ˆ๊ธฐ ๋•Œ๋ฌธด๋‹ค. ๋งŒ•ฝ ‚ฌ‹คด ๊ทธ๋Ÿฌ•˜๋‹ค๋ฉด operaotr&๊ฐ€ operator== •ˆชฝ—„œ ๋ถˆ๋ฆด๋•Œ ˜ˆ™ธ๋ฅผ ๋˜ˆ ๊ฒƒด๋‹ค. ๊ทธ๋ ‡๊ฒŒ ๋˜๋ฉด šฐ๋ฆฌ˜ ˜ˆ™ธ ๋ช…„ธ๋Š” ๊ฐ๋ถ€๋˜๊ณ , ๊ณงžฅ unexpected ๋กœ ง„•˜๊ฒŒ ๋˜๋Š”๊ฐ๋‹ค.

ด๋Ÿฌ•œ Šน๋ณ„๋‚œ ˜ˆ œ๋Š” ๋” ผ๋ฐ˜ ธ ๋ฌธ œ๋กœ, ๋‹ค‹œ ๋ง•˜ž๋ฉด …œ”Œ๋ฆฟ˜ ˜• ธž๋กœ  „๋‹ฌ๋˜๋Š” ˜ˆ™ธ— ๊ด€•œ  •๋ณด๋ฅผ •Œ•„๋‚ผ ๊ธธด —†๋‹ค๋Š”  ๋„ •œ๋ชซด๋‹ค. šฐ๋ฆฌ๋Š” ๊˜ …œ”Œ๋ฆฟ„ œ„•œ ˜๋ฏธžˆ๋Š” ˜ˆ™ธ ๋ช…„ธ๋ฅผ  œ๊ณต• ˆ˜ —†๋‹ค๋Š” ด•ผ๊ธฐ๋‹ค. ™œ๋ƒ•˜๋ฉด …œ”Œ๋ฆฟ€ ๊˜ ๋ณ€•จ—†ด ๊ทธ๋“คด ˜• ธž๋ฅผ ๋ช‡๊ฐ€ง€˜ ๋ฐฉ‹œผ๋กœ๋งŒ “ฐ๊ธฐ ๋•Œ๋ฌธด๋‹ค. ๊ฒฐ๋ก €? …œ”Œ๋ฆฟ๊ณผ ˜ˆ™ธ๋Š” –ดšธ๋ฆฌง€ •Š๋Š”๋‹ค.!

  • ๋‘๋ฒˆงธ๋กœ ๋‹น‹ € unexpected˜ธถœ„ ๋ง‰๊ธฐœ„•˜—ฌ ๋ถ€•œ ˜ˆ™ธ ๋ช…„˜ ๊ทœ •œผ๋กœ ธ•˜—ฌ ๋ถˆ๋ฆฌ๋Š” •จˆ˜ƒ—„œ ˜ˆ™ธ ๋ช…„ธ๋ฅผ ƒ๋žต• ˆ˜ žˆ๋‹ค.
ด๊ฒƒ€ ๊ฐ„๋‹จ•˜๊ณ  ผ๋ฐ˜ ธ ƒ๊ฐดง€๋งŒ, žƒ–ด๋ฒ„๋ฆฌ๊ธฐ ‰ฌšด ๊ฒฝšฐด๋‹ค. ๋‹คŒ˜ callback •จˆ˜ ๋“๋ก— ๊ด€•œ ˜ˆ œ๋ฅผ ๋ณดž
~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);
    }
ด ฝ”๋“œ—„œ makeCallBack—„œ func„ ˜ธถœ•˜๋Š”๊ฒƒ€ funcด ๋˜ง€๋Š” ˜ˆ™ธ— ๊ฒƒ„ •Œ๊ธธด —†–ด„œ ˜ˆ™ธ ๋ช…„— œ„๋ฐ˜•˜๋Š” œ„—˜•œ ƒ™ฉœผ๋กœ ๊ฐˆˆ˜ žˆ๋‹ค.

ด๋Ÿฐ ๋ฌธ œ๋Š” ๋‹คŒ๊ณผ ๊ฐ™ด CallBackPtrƒ˜ ˜ˆ™ธ ๋ช…„ธ๋ฅผ ข€๋” ๊ตฌฒด™” ‹œผœ„œ  œ๊• ˆ˜ žˆ๋‹ค.
~cpp 
typedef void (*CallBackPtr) (int eventXLocation, int event YLocation, void *dataToPassBack) throw();
๋‹คŒ๊ณผ ๊ฐ™ด ˜•ด „ –ธ๋˜—ˆœผ๋ฉด callback•จˆ˜ ๋“๋ก‹œ •„๋ฌด๊ฒƒ๋„ ๋˜ง€ง€ •Š๋Š”๋‹ค๋Š” กฐ๊ด๋ผ๋ฉด ˜ˆ™ธ๋ฅผ ๋ฐœƒ• ๊ฒƒด๋‹ค.
~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); // ๋ณด๋‹ค‹œ”ผ •Œ๋งž๋Š” ˜•ด๋‹ค.

ด๋Ÿฌ•œ •จˆ˜ ฌธ„ „๋‹ฌ‹œ ๊ด€๋ จ€ ตœ๊ทผ— ถ”๊ฐ€๋œ๊ฐ๋‹ˆ ๋งŒ•ฝ ปดŒŒผ๋Ÿฌ๊ฐ€ ง€› ๋ชป•œ๋‹ค๊ณ  •ด๋„ ๋†€๋ž„๊ฒƒ€ —†๋‹ค. (ด…€ 1996๋…„— ๋‚˜™”๋‹ค. •˜ง€๋งŒ ง€๊ธˆ๋„(2001๋…„ •๋„)  œ๋Œ€๋กœ ง€›•˜๋Š” ปดŒŒผ๋Ÿฌ๊ฐ€ ๋งŽง€ •Š€๊ธ๋กœ •ˆ๋‹ค.) ๋งŒ•ฝ ปดŒŒผ๋Ÿฌ๊ฐ€ ฒ˜๋ฆฌ ๋ชป•œ๋‹ค๋ฉด ด๋Ÿฐ ‹คˆ˜˜ ๋ฐฉง€๋Š” ๋‹น‹  ž‹ —๊ฒŒ ๋‹ฌ๋ ธ๋‹ค.

  • „ธ๋ฒˆงธ๋กœ ๋‹น‹ € "the system"ด •„๋งˆ ๋˜ง€๋Š” ˜ˆ™ธ๋ฅผ •ธ๋“ค๋ง•ด„œ unexcepted˜ ˜ธถœ„ ”ผ• ˆ˜ žˆ๋‹ค. ด๋Ÿฌ•œ ˜ˆ™ธ๋Š” ๋งŽ€ ๋ถ€๋ถ„ด new™€ new[]‹œ ๋ฉ”๋ชจ๋ฆฌ • ๋‹น ˜ˆ™ธ—„œ bad_allocด ๋ฐœƒ•˜—ฌ ๋ฐœƒ•œ๋‹ค. ๋งŒ•ฝ ๋‹น‹ ด new๋ฅผ –ด๋–ค •จˆ˜—„œ “ด๋‹ค๋ฉด šฐ—ฐด๋ผ๋„ bad_alloc ˜ˆ™ธ๋ฅผ ๋งŒ๋‚ ˆ˜ žˆ๋Š” ๊ฐ€๋Šฅ„„ ๋‚ดฌ•˜๋Š” …ˆด๋‹ค.

ž, ง€๊ธˆ 1˜จŠค˜ ˜ˆ๋ฐฉ๋Š” ฐจ›„ 1ŒŒšด๋“œ˜ ”ผ•ด๋ณด๋‹ค ๋‚ณง€๋งŒ ๋•Œ๋กœ๋Š” ˜ˆ๋ฐฉด –ด๋ ต๊ณ  ”ผ•ด๊ฐ€ ๋” ‰ฌšด ๊ฒฝšฐ๋„ žˆœผ๋ฆฌ๋ผ. –ธ๊ธ‰•œ ๊ฒƒฒ˜๋Ÿผ ๋•Œ๋•Œ๋กœ unexpected ˜ˆ™ธ ง ‘ ๋งž„œ๋Š” ๊ฒƒ€ ฒ˜Œ— ๊ทธ๊ฒƒ„ —๋ฐฉ•˜๋Š”๊ฒƒ ๋ณด๋‹ค ‰ฝ๋‹ค. ˜ˆ๋ฅผ๋“คž๋ฉด ๋งŒ•ฝ ๋‹น‹ ด ˜ˆ™ธ๋ช…„ธ๋ฅผ —„๊ฒฉ•˜๊ฒŒ ž‘„–ˆง€๋งŒ ๋‹น‹ € ˜ˆ™ธ ๋ช…„ธ๊ฐ€ ๋˜–ด žˆง€ •Š€ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ˜ •จˆ˜๋“ค„ ๊ฐ• œ๋กœ ๋ถ€๋ฅผˆ˜ žˆ๋‹ค. •จˆ˜ƒ—„œ ฝ”๋“œ๋“คด ๋ฐ”๋€Œ๋Š”  •ด๋ผ„œ unexpected˜ˆ™ธ๋ฅผ ๋ง‰๋Š”๊ฒƒ€ ๋น„‹คšฉ ด๋‹ค.

๋งŒ•ฝ unexpected˜ˆ™ธ๋ฅผ ๋ง‰๋Š”๊ฒƒด ‹คšฉ ดง€ ๋ชป•˜๋‹ค๋ฉด ๋‹น‹ € C++๊ฐ€ unexpected๋ฅผ ๋‹ค๋ฅธ ˜•‹œผ๋กœ ๋ฐ”๊พธ–ด ๋ฒ„๋ฆฌ๋Š” ๊ธฐ๋Šฅ„ ดšฉ•ด„œ ๊ทธ๋Ÿฌ•œ ๋น„‹คšฉ ธ ƒƒœ๋ฅผ ๋งŒšŒ• ˆ˜ žˆ๋‹ค. ๋‹คŒ ˜ˆ๋Š” unexpect™€ ๊ฐ™€ ˜ˆ™ธ๋ฅผ UnexpectedException ๊ฐฒด๋กœ ๋ฐ”๊พผ๊ฒƒ„ ƒ๊ฐ•ด ๋ณธ๋‹ค.
~cpp 
class UnexpectedException {};

void convertUnexpected()
{
    throw UnexpectedException();
}

๊ทธ๋ฆฌ๊ณ  unexpected •จˆ˜๋ฅผ convertUnexpected๋กœ ๊ตฒด•œ๋‹ค.
~cpp 
    set_unexpected(convertUnexpected);
ด๋ ‡๊ฒŒ •˜๋ฉด unexpected˜ˆ™ธ๋Š” convertUnexpected๋ฅผ ˜ธถœ•œ๋‹ค. ฆ‰, ƒˆ๋กœšด UnexpectedException ๊ฐฒด๋กœ ˜ˆ™ธ๊ฐ€ ๊ตฒด๋˜—ˆ๋‹ค. •˜ง€๋งŒ  œ๊ณต๋˜๋Š” ˜ˆ™ธ ๋ช…„—„œ unexpected๋ฅผ ๋ฐฉง€• ๋ ค๋ฉด UnexpectedException ˜ˆ™ธ๋ฅผ ฌ•จ•ด•ผ •œ๋‹ค. ˜ˆ™ธ๋ฅผ ๊ฐฒด๋กœ ๋˜กŒ๊ธฐ—.. (๋งŒ•ฝ ˜ˆ™ธ ๋ช…„— UnexpectedException„„ง€ •Š•˜๋‹ค๋ฉด unexpected๊ฐ€ ๊ตฒด๋˜ง€ •Š€ ๊ฒƒฒ˜๋Ÿผ terminate๊ฐ€ ๋ถˆ๋ฆด๊ฒƒด๋‹ค.)

๋˜ ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•€ unexpected ˜ˆ™ธ๋ฅผ ๊ทธ๋ƒฅ unexpected˜ —ญ• „ ˜„žฌ˜ ˜ˆ™ธ๋ฅผ ๊ณ„† ๋˜ง€๊ธฐ(rethrow)˜•ƒœ๋กœ ๋ฐ”๊พธ–ด ๋ฒ„๋ฆฌ๋Š” ๊ฒƒด๋‹ค. ด๋ ‡๊ฒŒ ๊ตฒด•˜๋ฉด ˜ˆ™ธ๋Š” •„๋งˆ ƒˆ๋กœšด ‘œค€˜ bad_exception „ ๋˜ง€๋Š” ˜•ƒœ๋กœ ๋ฐ”๋€๋‹ค. ( •๊ทœ C++๋ผด๋ธŒ๋Ÿฌ๋ฆฌ— ฌ•จ)
~cpp 
    void convertUnexpected()
    {
        throw()     // ด๊˜„ œ˜ ˜ˆ™ธ๋ฅผ ๊ณ„† ๋˜„๋‹ค๋Š” ˜๋ฏธ
    }

    set_unexpected(convertUnexpected);
๋งŒ•ฝ œ„™€ ๊ฐ™ด •˜๊ณ  bad_exception(‘œค€ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ ƒ˜ exception˜ ๊ธฐ๋ณธ ˜ˆ™ธ ด๋ž˜Šค)๋ฅผ ๋‹น‹ ˜ ๋ชจ๋“  ˜ˆ™ธ ๋ช…„— ฌ•จ‹œ‚ค๋ฉด ๋‹น‹ € ๊ฒฐฝ” ๋‹น‹ ใ„˜ ”„๋กœ๊ทธ๋žจด ๋ถˆ‹œ— ๋ฉˆถ”–ด ๋ฒ„๋ฆฌ๋Š”๊ฒƒ— ๋Œ€•œ ๊ •„ •  š”๋Š” —†„ ๊ฒƒด๋‹ค. ๊ฐ๊ธฐ๋‹ค๊ฐ€ ๊ทœ •— ๋งžง€•Š๋Š” ˜ˆ™ธ๋“ค๋„ bad_exceptionœผ๋กœ ๊ตฒด๋˜๊ณ  ˜ˆ™ธ๋Š” ๊ธฐ๋ณธ ˜ˆ™ธ ๋Œ€‹ — ๋‹ค‹œ ๋˜ € ผ„๋‹ค.(propagate)

--
ด œ ๋‹น‹ € ˜ˆ™ธ ๋ช…„ธ๊ฐ€ ๋งŽ€ ๋ฌธ œ๋ฅผ ๊ฐ€ง€๊ณ  žˆ„ˆ˜ žˆŒ„ ด•ด • ๊ฒƒด๋‹ค. ปดŒŒผ๋Ÿฌ๋Š” ๊ทธ๋“ค˜ ๋ถ€๋ถ„ ธ “ฐž„ƒˆ๋ฅผ ๊ฒ€‚ฌ•ด„œ …œ”Œ๋ฆฟ—„œ ๋ฌธ œ๋ฅผ ๋ฐœƒ•  †Œง€๋ฅผ •Šœผ๋ฉฐ, ปดŒŒผ๋Ÿฌ๋Š” ˜™ธ๋กœ ๊ทœน™œ„๋ฐ˜„ •˜๊ธฐ ‰ฝ๊ณ , ปดŒŒผ๋Ÿฌ๊ฐ€  œ๋Œ€๋กœ ๋˜ง€ •Šœผ๋ฉด ”„๋กœ๊ทธ๋žจ„ ๋ถˆ‹œ— ๋ฉˆถ”–ด ง€๋„๋ก œ ๋„• ๊ฒƒด๋‹ค. ˜ˆ™ธ ๋ช…„—ญ‹œ ๋˜๋‹ค๋ฅธ ๋ฌธ œ๋ฅผ •ˆ๊ณ  žˆ๋Š”๋ฐ, ˜ˆ™ธ๋ช…„ธ๋Š” ๋†’€ ˆ˜ค€˜ ˜ธถœž๊ฐ€ ˜ˆ™ธ ๋ฐœƒ„ ๋Œ€๋น„• ๋•Œ๋„ unexpected๋กœ˜ ๊ฒฐ๊ณผ๋ฌผ„ ๋งŒ๋“ค–ด ๋‚ธ๋‹ค.

ด•ผ๊ธฐ๋ฅผ œ„•ด Item 11˜ ˜ˆ œ๋ฅผ ๊ทธ๋Œ€๋กœ ๋ณดž
~cpp 
    class Session{
    public:
        ~Session();
        ...
    private:
        static void logDestuction(Session *objAddr) throw();
    };

    Session::~Session()
    {
        try{
            logDestruction(this);
        }
        catch ( ... ) {}
    }
Session˜ ŒŒ๊ดดž๋Š” logDestruction„ ˜ธถœ•œ๋‹ค. •˜ง€๋งŒ ๋ช…‹œž‘€ –ด๋– •œ ˜ˆ™ธ๋„ •ด๋‹น logDestruction—„œ ๋˜ง€ง€ ๋ชป•˜๋„๋ก ๋ง‰•„๋†“•˜๋‹ค. •œ๋ฒˆ logDestuctionด ‹คŒจ• ๋•Œ ๋ถˆ๋ฆฌ๋Š” •จˆ˜๋“ค— ๋Œ€•˜—ฌ ƒ๊ฐ•ด ๋ณดž. ด๊ฒƒ€ •„๋งˆ ผ–ด๋‚˜ง€ •Š„ ๊ฒƒด๋‹ค. šฐ๋ฆฌ๊ฐ€ ƒ๊ฐ•œ๋Œ€๋กœด๊ƒ๋‹นžˆ ˜ˆ™ธ ๋ช…„˜ ๊ทœ • œ„๋ฐ˜œผ๋กœ ธ๋„•˜๋Š” ฝ”๋“œด๋‹ค. ด๋Ÿฐ ˜ˆธก• ˆ˜ —†๋Š” ˜ˆ™ธ๊ฐ€ logDestructionœผ๋กœ ๋ถ€„ผˆ๋•Œ unexpected๊ฐ€ ’€๋ฆด ๊ฒƒด๋‹ค. ๊ธฐ๋ณธ œผ๋กœ ๊ทธ๊ฒƒ€ ”„๋กœ๊ทธ๋žจ„ ๋ฉˆถ˜๋‹ค. ด ˜ˆ œ๋Š” ๊ทธ๊ฒƒ˜ ˆ˜ • ๋ฒ„ „ดง€๋งŒ, ๊ทธ๋Ÿฐ ˆ˜–‰„ Session ŒŒ๊ดดž˜  œž‘ž๊ฐ€ ›• ๊นŒ? ž‘„ž๋Š” ๋ชจ๋“  ๊ฐ€๋Šฅ•œ ˜ˆ™ธ ๋ฅผ žกœผ๋ ค๊ณ  ๋…ธ๋ ฅ•œ๋‹ค. ๊ทธ๋ž˜„œ ๊ทธ๊ด Session ŒŒ๊ดดž˜ catch๋ธ”๋Ÿญ—„œˆ˜–‰๋˜๋Š” ๊ฒƒด ๋‹ค๋‹ค๋ฉด ๊ทธ๊ด ๋ถˆ๊ณต‰•œ ฒ˜‚ฌ๋ผ๊ณ  ๋ณดธ๋‹ค. ๋งŒ•ฝ logDestructionด •„๋ฌด๋Ÿฐ ˜ˆ™ธ ๋ช…„ธ๋ฅผ •˜ง€ •Š๋Š”๋‹ค๋ฉด, I'm-willing-to-catch-it-if-you'll-just-give-me-a-chance ‹œ๋‚˜๋ฆฌ˜ค๋Š” ๊ฒฐฝ” ผ–ด๋‚˜ง€ •Š„๊ฒƒด๋‹ค. (ด๋Ÿฐ ๋ฌธ œ˜ ˜ˆ๋ฐฉœผ๋กœ unexpected˜ ๊ตฒด— ๋Œ€•œ „ค๋ช…„ œ„•ด –ธ๊ธ‰•ด ๋‘—ˆ๋‹ค.)

˜ˆ™ธ ๋ช…„˜ ๊ท ˜•žˆ๋Š” ‹œ๊ฐ€ ค‘š”•œ๊ฒƒด๋‹ค. ๊ทธ๊ฒƒ€ ˜ˆ™ธ ๋ฐœƒ„ ˜ˆƒ•˜๋Š” •จˆ˜๋“ค˜ ˜ˆ™ธ ข…๋ฅ˜๋“ค„ ๋ณด๋ฉด ›Œ๋ฅญ•œ ๋ฌธ„œ™”๊ฐ€ ๋ ๊ฒƒด๊ณ , ž˜๋ชป๋œ ˜ˆ™ธ ๋ช…„˜ ƒ™ฉ•˜˜ ”„๋กœ๊ทธ๋žจ€ ๊ธฐ๋ณธ œผ๋กœ ฃผ–ดง€๋Š” ƒƒœ ฆ‰, ฆ‰‹œ ๋ฉˆถ”๋Š” ๊ฒƒ„  •๋‹น™”•  ๋งŒผ ž˜๋ชป๋œ ผด๋‹ค. ๊ฐ™€ ‹œ๊ฐœผ๋กœ ˜ˆ™ธ๋Š” ปดŒŒผ๋Ÿฌ— ˜•˜—ฌ ˜คง ๋ถ€๋ถ„ ธ  ๊ฒ€๋งŒ„ ๋‹น•˜๊ณ  ˜ˆ™ธ๋Š” ˜๋„•˜ง€ •Š€ ž˜๋ชป„ –‘‚ฐ•˜๊ธฐ ‰ฌšธ๊ฒƒด๋‹ค. ๊ฒŒ๋‹ค๊ฐ€ ˜ˆ™ธ๋Š” unexpected ˜ˆ™ธ—„œ ๋ฐœƒ•˜๋Š” ๋†’€ ๋ ˆ๋ฒจ˜ ˜ˆ™ธ žก๋Š” ๋ฌธ œ— ๋Œ€•˜—ฌ ˜ˆ๋ฐฉ• ˆ˜ žˆ๋‹ค.

ž ด๋Ÿฐ๊ฒƒ๋“คด ˜ˆ™ธ ๋ช…„ธ๋ฅผ ˜„๋ช…•˜๊ฒŒ ‚ฌšฉ•˜๋Š”๋ฐ ผกฐ•  ๊ฒƒด๋‹ค. ๋‹น‹ ˜ •จˆ˜— ˜ˆ™ธ๋ฅผ ๋”•˜๊ธฐ  „— ด๋Ÿฐ ‚ฌ•ญ— ๋Œ€•˜—ฌ •œ๋ฒˆฏค ƒ๊ฐ•ด ๋ณดž.

1.7. Item 15: Understand the costs of exception handling

  • Item 15: ˜ˆ™ธ •ธ๋“ค๋ง— ๋Œ€•œ ๋น„šฉ ง€๋ถˆ ๋Œ€•œ ด•ด

‹ค–‰‹œ๊ฐ„— ˜ˆ™ธ •ธ๋“ค๋ง„ œ„•˜—ฌ ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” •œŒ˜ ฝ”๋“œ๋ฅผ ž…๋ ฅ•ด•ผ •œ๋‹ค. ˜ˆ™ธ ค‘— ๊ฐž˜ ฌธŠธ— ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ๊ฐ try๋ธ”๋Ÿญ— ๋“ค–ด๊ฐ€๋Š” ๋ถ€๋ถ„๊ณผ ๋‚˜˜ค๋Š” ๋ถ€๋ถ„๋”ฐœ„˜ ˜ˆ™ธ๊ฐ€ ๋˜ €ˆ๋•Œ ๊ฐฒด ŒŒ๊ดด˜ •„š”„„ ™•ธ•ด•ผ๋งŒ •œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ฐ try ๋ธ”๋ก—„œ ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” catch๊ตฌ๋ฌธ˜ —ฐ๊ณ„™€ ๊ทธ๋“ค๊ณผ ๊ด€๊ณ„๋˜–ด žˆ๋Š” ˜ˆ™ธ ๊ฐฒด˜ ข…๋ฅ˜— ๋Œ€•˜—ฌ๋„ ƒ๊ฐ•ด ฃผ–ด•ผ •œ๋‹ค. ด๋Ÿฐ ๊ฒƒ๋“ค€ ๊ฒฐฝ” ๊ณตงœ๊ฐ€ •„๋‹ˆ๋‹ค. ‹ค–‰‹œ๊ฐ„๋™•ˆ— ˜ˆ™ธ ๋ช…„— ๋Œ€•œ ™•ธ ž‘—…๋„ ๊ทธ๋Ÿฌ๋ฉฐ, catch๊ตฌ๋ฌธ— ๊ฐฒด๊ฐ€ ๋˜ ธ ง”„๋•Œ ๊ฐฒด˜ ŒŒ๊ดด ๋ถ€๋ถ„— ๋Œ€•œ ผ๋„ —ญ‹œ ™•žฅ๋œ๋‹ค. •˜ง€๋งŒ, ๋งŒ•ฝ ๋‹น‹ ด try, throw, catch‚ค›Œ๋“œ๋ฅผ ‚ฌšฉ•˜ง€ •Š๋Š”๋‹ค๋ฉด ˜ˆ™ธ •ธ๋“ค๋ง—•ด๋‹จ ๋น„šฉ€ ๋ฐœƒ•˜ง€ •Š๊ณ , •ด๋‹น ‚ค›Œ๋“œ๋“ค— ๋Œ€•œ ๋น„šฉ ง€๋ถˆ๋„ ๋ฏธ๋ฏธ•œ –‘ด๋‹ค.

ž ๊ทธ๋Ÿผ  „˜€ ˜ˆ™ธ •ธ๋“ค๋ง„ •˜ง€ •Š•˜„๋•Œ˜ ง€๋ถˆ ๋น„šฉ„ ƒ๊ฐ•ด ๋ณดž, ๋‹น‹ € ๊ฐฒด๋“คด  žฌ๋˜๊ณ , œ ง€๋˜๋Š” Šธ๋ž™ด •„š”•œ ๋ฐด„ฐ ๊ตฌกฐ˜ ‚ฌšฉ„ œ„•ด ๊ณต๊ฐ„— ๋Œ€•œ ๋น„šฉ ง€๋ถˆ„ •œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋‹น‹ € ด๋Ÿฐ ๋ฐด„ฐ ๊ตฌกฐ๋“ค„ ๊ฐ‹ •˜๊ณ  œ ง€•˜๋Š”๋ฐ •„š”•œ ‹œ๊ฐ„— ๋Œ€•œ ๋น„šฉ„ ง€๋ถˆ•œ๋‹ค. ด๋Ÿฐ ๋น„šฉ๋“ค€ ผ๋ฐ˜ œผ๋กœ  •๋‹น•œ š”๊ตฌด๋‹ค. ๋ฐ˜๋ฉด— ”„๋กœ๊ทธ๋žจด ˜ˆ™ธ๋ฅผ œ„•œ ง€›ด —†ด ปดŒŒผ ๋œ๋‹ค๋ฉด ˜ˆ™ธ ง€›„ •˜๊ณ  ปดŒŒผ •˜๋Š” ๋ฐ˜๋Œ€˜ ๊ฒฝšฐ๋ณด๋‹ค ข€๋” ๋น ๋ฅด๊ณ , ข€๋” ž‘€ šฉ๋Ÿ‰„ ฐจง€•œ๋‹ค.

ด๋ก  œผ๋กœ ๋‹น‹ € ด๋Ÿฐ(˜ˆ™ธ) ๋น„šฉ˜ ง€ถœ(„ ƒ,select)ด —†–ด•ผ •œ๋‹ค.:C++˜ •œ ๋ถ€๋ถ„ธ ˜ˆ™ธ, ปดŒŒผ๋Ÿฌ๋Š” ˜ˆ™ธ๋ฅผ ง€›•ด•ผ•œ๋‹ค.

”„๋กœ๊ทธ๋žจ€ ผ๋ฐ˜ œผ๋กœ ๋…๋ฆฝ œผ๋กœ object ŒŒผ๋“คด ƒ„๋˜–ด ง€๊ณ , ๋‹จง€ •˜๋‚˜˜ ž‘„๋˜–ด ๋งŒ๋“ค–ด„ objectŒŒผ—„œ ˜ˆ™ธ ฒ˜๋ฆฌ๊ฐ€ —†๋‹ค๋ฉด ๋‹ค๋ฅธ ๊ฒƒ๋“คƒ˜ ˜ˆ™ธ ฒ˜๋ฆฌ๊ฐ€ •„๋ฌด๋Ÿฐ ˜๋ฏธ๊ฐ€ —†๊ธฐ๋•Œ๋ฌธ—, ๋‹น‹ ด ˜ˆ™ธฒ˜๋ฆฌฝ”๋“œ๋ฅผ ‚ฌšฉ•˜ง€ •Š๋Š”๋‹ค๋ฉด, ๋‹น‹ € ปดŒŒผ๋Ÿฌ  œž‘‚ฌ๋“คด ด๋Ÿฐ ˜ˆ™ธ๋“ค„ ง€›‹œ ผ–ด๋‚˜๋Š” ๋น„šฉ„ —†•จ ๊ฒƒด๋ผ๊ณ  ˜ˆƒ•œ๋‹ค. ๊ฒŒ๋‹ค๊ฐ€ objectŒŒผด ˜ˆ™ธ๋ฅผ ๋นผ๊ธฐœ„•ด •„๋ฌด๋Ÿฐ ƒ˜ธ๊ฐ„˜ ๋งฌ๊ฐ€ ๋˜ง€ •Š๋Š”๋‹ค๋ฉด ˜ˆ™ธ ฒ˜๋ฆฌ๊ฐ€ ๋“ค–ด๊ฐ„ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ™€˜ ๋งฌ๋Š” –ด๋–จ๊นŒ? ฆ‰, ”„๋กœ๊ทธ๋žจ˜ –ด๋–ค ๋ถ€๋ถ„ด๋ผ๋„ ˜ˆ™ธ๋ฅผ ‚ฌšฉ•œ๋‹ค๋ฉด ๋‚˜๋จธง€ ”„๋กœ๊ทธ๋žจ˜ ๋ถ€๋ถ„๋“ค๋„ ˜ˆ™ธ๋ฅผ ง€›•ด•ผ •œ๋‹ค. ด๋Ÿฐ ๋ถ€๋ถ„  ˜ˆ™ธ ฒ˜๋ฆฌ ƒ™ฉ€ ‹ค–‰‹œ๊ฐ„—  •™••œ ˜ˆ™ธ๋ฅผ žก๋Š” ˆ˜–‰ด ๋ถˆ๊ฐ€๋Šฅ •˜๊ฒŒ ๋งŒ๋“ค๊ฒƒด๋‹ค.

๋ฌผ๋ก   €๊ฒƒ€ ด๋ก ด๋‹ค. ‹คˆ œผ๋กœ ˜ˆ™ธ ง€› ๋ฐด๋”๋“ค€ ๋‹น‹ ด ˜ˆ™ธ ž‘„„ œ„•œ ฝ”๋“œ˜ ฒจ๊ฐ€๋ฅผ ๋‹น‹ ด ˜ˆ™ธ๋ฅผ ง€›•˜๋А๋ƒ ๋งˆ๋А๋ƒ— ๋”ฐ๋ผ กฐ •• ˆ˜ žˆ๋„๋ก ๋งŒ๋“ค–ด ๋†“•˜๋‹ค.(ž‘„žฃผ:ฆ‰ ˜ˆ™ธ ๊ด€๋ จ ฒ˜๋ฆฌ˜ on, off๊ฐ€ ๊ฐ€๋Šฅ•˜๋‹ค.) ๋งŒ•ฝ ๋‹น‹ ด ๋‹น‹ ˜ ”„๋กœ๊ทธ๋žจ˜ –ด๋– •œ ˜—ญ๊ณผ, —ฐ๊ณ„๋˜๋Š” ๋ชจ๋“  ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ—„œ try, throw, catch๋ฅผ ๋นผ๊ณ  ˜ˆ™ธ ง€› ‚ฌ•ญ„ ๋นผ๊ณ  ๋‹น‹  ŠคŠค๋กœ †๋„, ฌ๊ธฐ ๊ฐ™€ ˜ˆ™ธฒ˜๋ฆฌ‹œ ๋ฐœƒ•˜๋Š” ๋‹จ „  œ๊• ˆ˜ žˆ„ ๊ฒƒด๋‹ค. ‹œ๊ฐด ง€๋‚˜ ๊ฐ— ๋”ฐ๋ผ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ— ฐจšฉ๋˜๋Š” ˜ˆ™ธ˜ ฒ˜๋ฆฌ๋Š”    ๋Š˜–ด๋‚˜๊ฒŒ ๋˜๊ณ , ˜ˆ™ธ๋ฅผ  œ๊•˜๋Š” ”„๋กœ๊ทธ๋ž˜๋ฐ€ ๊ฐˆˆ˜๋ก ๋‚ด๊ตฌ„ด •ฝ•ด ˆ๊ฒƒด๋‹ค. •˜ง€๋งŒ, ˜ˆ™ธฒ˜๋ฆฌ๋ฅผ ๋ฐฐ œ•œ ปดŒŒผ„ ง€›•˜๋Š” ˜„žฌ˜ C++ †Œ”„Šธ›–ด ๊ฐœ๋ฐœƒ˜ ƒƒœ๋Š” ™•‹คžˆ ˜ˆ™ธฒ˜๋ฆฌ ๋ณด๋‹ค „๋Šฅ—„œ šฐœ„๋ฅผ  •œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ทธ๊ฒƒ€ ๋˜•œ ˜ˆ™ธ  „๋‹ฌ(propagate) ฒ˜๋ฆฌ™€, ˜ˆ™ธ๋ฅผ ƒ๊ฐ•˜ง€ •Š€ ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ๋“ค˜ ‚ฌšฉ— ๋ฌด๋ฆฌ—†๋Š” „ ƒด ๋ ๊ฒƒด๋‹ค.

๋‘๋ฒˆงธ๋กœ try ๋ธ”๋กœผ๋กœ๋ถ€„˜ ˜ˆ™ธ๋ฅผ žก๋Š”(exception-handling)— ๋Œ€•œ ๋น„šฉ„ ƒ๊ฐ•ด ๋ณดž ด๊ฒƒ€ ๋‹น‹ ด catch๋กœ ˜ˆ™ธ •˜๋‚˜๋ฅผ žก๊ธฐ๋ฅผ ›• ๋•Œ ๋งˆ๋‹ค š”๊ตฌ๋˜๋Š” ๋น„šฉด๋‹ค. ๊ฐ๊ธฐ ๋‹ค๋ฅธ ปดŒŒผ๋Ÿฌ๋“ค€ „œ๋กœ ๋‹ค๋ฅธ ๋ฐฉ‹œผ๋กœ try๋ธ”๋ก˜  šฉ„ •œ๋‹ค. ๊ทธ๋ž˜„œ •ด๋‹น ๋น„šฉ€ ๊ฐ ปดŒŒผ๋Ÿฌ๋งˆ๋‹ค ๋‹ค๋ฅด๋‹ค. ๊ทธ๋ƒฅ ๋Œ€ถฉ –ด๋ฆผžก•„„œ ˜ˆƒ•˜๋ฉด, ๋งŒ•ฝ try๋ธ”๋ก„ “ฐ๊ฒŒ๋˜๋ฉด, ๋‹น‹ ˜  „ฒด ธ ฝ”๋“œ ‚ฌดˆ๋Š” 5-10%๊ฐ€ ๋Š˜–ด๋‚˜๊ณ , ๋‹น‹ ˜ ‹ค–‰ ‹œ๊ฐ„ —ญ‹œ ๋น„Šท•œ ˆ˜ค€œผ๋กœ ๋Š˜–ด๋‚œ๋‹ค. ด œ •„๋ฌด๋Ÿฐ ˜ˆ™ธ๋ฅผ ๋˜ง€ง€ •Š๋Š”๋‹ค๊ณ  ƒ๊ฐ•˜ž;šฐ๋ฆฌ๊ฐ€ —ฌ๊ธฐ—„œ † ๋ก •˜๊ณ  žˆ๋Š”๊ฒƒ€ ๋‹จง€ ๋‹น‹ ˜ ”„๋กœ๊ทธ๋žจ๋‚ด—„œ try๊ฐ€ ๊ฐ€ง€๋Š” ๋น„šฉ๋งŒด •„๋‹ˆ๋‹ค. ด๋Ÿฐ ๋น„šฉ˜ ตœ†Œ™”๋ฅผ œ„•ด„œ •„๋งˆ ๋‹น‹ € •„š”•˜ง€ •Š๋Š” try๋ธ”๋Ÿญ€ ”ผ•ด•ผ๋งŒ • ๊ฒƒด๋‹ค.

ปดŒŒผ๋Ÿฌ๋Š” ˆ˜๋งฃ€ try ๋ธ”๋Ÿญ˜ ˜ˆ™ธ ŠคŽ™— ๋Œ€•œ ฝ”๋“œ๋ฅผ œ„•˜—ฌ ฝ”๋“œ๋ฅผ ๋งŒ๋“ค–ด๋‚ด•ผ •œ๋‹ค. ๊ทธ๋ž˜„œ ฝ”๋“œ ŠคŒฉ€ ผ๋ฐ˜ œผ๋กœ •˜๋‚˜˜ try๋ธ”๋Ÿญ๋‹น ๊ฐ™€ ˆ˜˜ ๋น„šฉ„ ง€ถœ•˜๊ฒŒ ๋œ๋‹ค. ž ๊น?(excuse me?) ๋‹น‹ € ˜ˆ™ธ ŠคŒฉด ๋‹จ‹œ ŠคŒฉธ, ฆ‰ ฝ”๋“œ๋ฅผ ๋งŒ๋“ค–ด ๋‚ด๋Š”๊ƒ๊ฐ•˜ง€ •Š๋Š”๋‹ค๊ณ  ๋ง•œ๋‹ค. ž, ๋‹น‹œ€ ๊ทธ๋Ÿฐ ƒ๊ฐ— ๊ด€•ด„œ กฐ๊ธˆ ƒˆ๋กœšด ๋ช‡๊ฐ€ง€๋ฅผ ๊ฐ•ˆ•ด ๋ดใ….

๋ฌธ œ˜ ˆ € ˜ˆ™ธ๊ฐ€ ๋˜ง€๋Š” ๋น„šฉด๋‹ค. ‚ฌ‹ค ˜ˆ™ธ๋Š” ฌ๊ท€•œ ๊ฒƒด๋ผ ๋ณด๊ธฐ ๋•Œ๋ฌธ— ๊ทธ๋ ‡๊ฒŒ ฌ๊ฒŒ ๊ฐ•ˆ•  ๋‚ดšฉด •„๋‹ˆ๋‹ค. ๊ทธ๋“คด ˜ˆ™ธ ธ(exceptional) ๋ฌธ œ˜(event) ๋ฐœƒ„ ง€นญ•จ—๋„ ๋ถˆ๊ตฌ•˜๊ณ  ๋งด๋‹ค. 80-20 ๊ทœน™€(Item 16—„œ –ธ๊ธ‰) šฐ๋ฆฌ—๊ฒŒ ๊ทธ๋Ÿฐ ด๋ฒคŠธ๋“ค€ ๊˜ ”„๋กœ๊ทธ๋žจ˜ ๋ถ€๊ณผ๋˜๋Š” „๋Šฅ— ปค๋‹ค๋ž€ ˜–ฅ„ ๋ฏธน˜ง€ •Š„ ๊ฒƒด๋ผ๊ณ  ๋ง•œ๋‹ค. ๊ทธ๋Ÿผ—๋„ ๋ถˆ๊ตฌ•˜๊ณ , ๋‚˜๋Š” ๋‹น‹ ด ด ๋ฌธ œ— ๊ด€•˜—ฌ ˜ˆ™ธ๋ฅผ ๋˜ง€๊ณ , ๋ฐ›๋Š” ๋น„šฉ— ๊ด€•œ ๋Œ€๋‹ต—„œ –ผ๋งˆ๋‚˜ ด๊นŒ๋ฅผ ๊ถ๊ธˆ• ๊ฒƒด๋ผ๊ณ  ƒ๊ฐ•œ๋‹ค. ๋Œ€๊ฐ• ผ๋ฐ˜ ธ •จˆ˜˜ ๋ฐ˜™˜—„œ ˜ˆ™ธ๋ฅผ ๋˜„๋‹ค๋ฉด ๋Œ€ถฉ „ธ๊ฐœ˜ ๋ช…๋ น–ด  •๋„ ๋” ๋А๋ คง€๋Š”(three order of magnitude) ๊ฒƒด๋ผ๊ณ  ๊ฐ€ •• ˆ˜ žˆ๋‹ค. •˜ง€๋งŒ ๋‹น‹ € ๊ทธ๊ฒƒ๋งŒด •„๋‹๊ฒƒด๋ผ๊ณ  ด•ผ๊ธฐ • ๊ฒƒด๋‹ค. ๋ฐ˜๋Œ€๋กœ ๋‹น‹ ด ด๋Ÿฐ ๋…ผŸ„ ๋ฐด„ฐ ๊ตฌกฐ๋‚˜ ๋ฃจ”„˜ ˆœšŒ ๊ตฌกฐ๋ฅผ šจœจ œผ๋กœ ๋งŒ๋“œ๋Š”๋ฐ ‹ ๊ฒฝ„ “ด๋‹ค๋ฉด ๋” ข‹€ ‹œ๊ฐ„„ ๋ณด๋‚ด๋Š” ๊ฒƒด๋ผ๊ณ  ƒ๊ฐ•œ๋‹ค.

๊ทธ๋ ‡ง€๋งŒ ž ๊น, ๋‚ด๊ฐ€ ด๋Ÿฐ๊ฒƒ— ๊ด€•ด„œ –ด๋–ป๊ฒŒ •„๋ƒ๊ตฌ? ๋งŒ•ฝ ˜ˆ™ธ๋ฅผ œ„•œ ง€›€ ตœ๊ทผ˜ ปดŒŒผ๋Ÿฌ™€ ใ„ปดŒŒผ๋Ÿฌ๊ฐ„— ๋‹ค๋ฅธ ๋ฐฉ‹œผ๋กœ „–‰๋œ๋‹ค๋ฉด„œ ๋น„šฉด 5-10%๋–จ–ดง€๊ณ  Šค”ผ๋“œ —ญ‹œ ๋น„Šท•˜๊ฒŒ ๋–จ–ดง€๊ณ  „ธ๊ฐœ ๋ช…๋ น–ด  •๋„ ๋Š˜–ด๋‚˜๋Š” ๊ฒƒ๊ณผ ๊ฐ™€ „๋Šฅ  €•˜— ๊ด€•œ œ„˜ –ธ๊ธ‰ ด๋Ÿฐ๊ฒƒ— ๊ด€•œ ถœฒ˜๋“ค? •„๋งˆ ๋‚ด๊ฐ€ •ด„ˆ˜ žˆ๋Š” ๋‹ต๋ณ€€ ๋‹ค†Œ ๋†€๋ž„๊ฒƒด๋‹ค.:๋‹น‹ ด try๋ธ”๋ก๊ณผ ˜ˆ™ธ ŠคŽ™„ ‚ฌšฉ„ •„š”•œ ๊ณณ๋งŒ ‚ฌšฉ•˜๋„๋ก  œ•œ•ด๋ผ;๊ทธ๋ฆฌ๊ณ  ปดŒŒผ •ด๋ด๋ผ, ๊ทธ๋ž˜๋„ „ค๊ณ„ƒ— ๋ฌธ œ๊ฐ€ žˆ๋‹ค๋ฉด ผ๋‹จ ž‹ ˜ „ค๊ณ„๋ฅผ ๋‹ค‹œ ๊ทธ๋ ค๋ณด๊ณ  ƒ๊ฐ•ด ๋ณด๋ผ, ๊ฐ๊ธฐ—๋‹ค, —ฌ๊ธฐ €๊ธฐ ๋‹ค๋ฅธ ๋ฒค๋”๋“ค˜ ปดŒŒผ๋Ÿฌ๋กœ ปดŒŒผ •ด๋ด๋ผ ๊ทธ๋Ÿผ •Œˆ˜ žˆ๋‹ค.

Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2021-02-07 05:23:49
Processing time 0.1133 sec