U E D R , A S I H C RSS

More EffectiveC++/Basic

1. Basic

1.1. Item 1: Distinguish between pointers and references.

  • Item 1: Pointer™€ Reference๊ตฌ๋ณ„•ด๋ผ.
    Pointers use the "*" and "->" operators, references use "."

๋А๋‚Œด ˜ค๋Š” ˜ˆ œ๋“ค[[BR]]
~cpp 
    char *pc = 0;
    char& rc = *pc;
”„๋กœ๊ทธ๋ž˜๋จธ ˆ๊ธ‰ž๋ฉด •Œˆ˜ žˆ๋Š” ๋ฐ”๋ณด ง“ด๋‹ค. •˜ง€๋งŒ ๋ฒ”•˜๊ธฐ ‰ฌšด๊ฒŒ ๋ฌธ œ๋‹ค.
~cpp 
    string& rs;        // Reference(ฐธกฐ)๊ฐ€ ˆ๊ธฐ™”๊ฐ€ ๋˜ง€ •Š•„„œ —๋Ÿฌ

    string s("xyzzy"); // ด๊ด ๋œ๋‹ค ‹ ๊ธฐ•˜๋„ค 
    string& rs = s;
•„ง stringจ๋ณธ  •œ๋ฒˆ๋„ —†๋‹ค. ๋ฐ˜„..
~cpp 
    void printDouble(const double& rd)
    {
        cout << rd;    // rd— ๊ด€•œ Šน๋ณ„•œ ๊ฒ€‚ฌ •„š” —†๋‹ค. reference๋‹ˆ๊นŒ.
    }
    ////////////////////////////////////////////////////////////////////
    void printDouble (const double* pd)
    {
        if (pd){
            cout << *pd    // pd๊ฐ€ nullธง€ ๊ฒ€‚ฌ •ด•ผ •œ๋‹ค. pointer๋‹ˆ๊นŒ.
        }
    }
pointer˜ œ ˜ ‚ฌ•ญธ null— ๊ด€•œ ๋‚ดšฉ„ ๋‹ค‹œ •Œ๋ คค€๋‹ค.
~cpp 
    string s1("Nancy");    // ด œ๋Š” ๋ฌดŠจ €ดˆ ๊ฐ™๋‹ค.
    string s2("Clancy");   
    string& rs = s1;
    string* ps = &s1;
    rs = s2;               // s1˜ ธž๊ฐ€ "Clancy" ๋กœ ๋ฐ”๋€๋‹ค๋Š” ˜๋ฏธ๋‹ค.
    ps = &s2;              // ๊ทธ๋ƒฅ ฌธ„ฐ๋งŒ „Œ…•˜๋Š” ๊ฐ๋‹ค. 
                           // ด๊ธ๋กœ ps๋Š” s2๋ฅผ ๊ฐ€๋ฆฌ‚ค๊ณ  s1—๋Š” •„๋ฌด๋Ÿฐ ˜–ฅ„ ๋ผน˜ง€ •Š๋Š”๋‹ค.
‚ฌ๊ฒฌ: Call by Value ๋ณด๋‹ค Call by Reference™€ Const˜ กฐ•ฉ„ „ ˜ธ•˜ž.  €ž˜ Effective C++—  „๋ฐ˜ œผ๋กœ –ธ๊ธ‰๋˜–ด žˆ๊ณ , ”„๋กœ๊ทธ๋ž˜๋ฐ„ •ด๋ณด๋‹ˆ ๊ดœฐฎ€ Žธด—ˆ๋‹ค. ๋‹จ return—„œ ๋งฝด ƒ๊ธฐ๋Š”๋ฐ, ˜„žฌ ๋‚ด ƒ๊ฐ€ return— ๋Œ€•ด„œ šŒ˜ ด๋‹ค. ๊ทธ๋ž˜„œ ๋‚˜๋Š” COM‹ ‘œ˜„ธ in, out  ‘๋‘–ด๋ฅผ ‚ฌšฉ•ด„œ •„˜ˆ ธž๋ฅผ ๋„˜๊ฒจ„œ ๊ด€๋ฆฌ•œ๋‹ค. C++˜ ๊ฒฝšฐ return— ˜•ด ๊ฐฒด๋ฅผ Call by Reference•˜๋ฉด {} ๋ฅผ ๋ฒ—–ด๋‚˜๋Š” …ˆด ๋˜๋Š”๋ฐ –ด๋””„œ ŒŒ๊ดด๋˜๋Š” ๊ฒƒธ๊ฐ€. ๋‹ค ๊ณต๋ถ€๊ฐ€ ๋ถ€•ด„œ•ผ ฉ --;
ง€—ญ•จˆ˜ •ˆ—„œ ง€—ญ ๊ฐฒด๋ฅผ ƒ„•˜—ฌ Reference๋กœ ๋ฆฌ„•  ๊ฒฝšฐ ง€—ญ •จˆ˜๊ฐ€ ๋ฐ˜•œ๋˜๋ฉด ง€—ญ ๊ฐฒด๋Š” —†–ดˆ ๊ฒƒด๊ณ , ๋ฆฌ„ด๋˜๋Š” Reference๋Š” กดžฌ•˜ง€ •Š๋Š” ๊ฐฒด— ๋Œ€•œ ๋‹ค๋ฅธ ด๋ฆ„ด ๋  ๊ฒƒด๋ฉฐ, ๊ฒฝšฐ— ๋”ฐ๋ผ„œ ปดŒŒผ€ ๋ ง€๋ชจ๋ฅด๋‚˜ ๋‚˜œ ฝ”๋“œ๋ผ๊ณ  •˜๋„š”.-ฐจ„ญ-
˜ค•ด˜ †Œง€๊ฐ€ žˆ๋„๋ก ๊ธ€„  –ด ๋†จ๊ตฐš”. in, out  ‘๋‘–ด๋ฅผ ดšฉ•ด„œ reference๋กœ ๋„˜๊ธธ ธž๋“ค—„œ๋Š” in— •œ•˜—ฌ reference, out€ pointer๋กœ new, delete๋กœ ๋™ œผ๋กœ ๊ด€๋ฆฌ•˜๋Š”๊ฒƒ„ ˜๋„•œ ๋งด—ˆŠต๋‹ˆ๋‹ค.  „— ”„๋กœ Šธ— ด๋Ÿฐ‹˜ ”„๋กœ๊ทธ๋ž˜๋ฐ„  šฉ ‹œผฐ๋Š”๋ฐ, •จˆ˜ ๋‚ด๋ถ€—„œ ฌธ„ฐ๋กœ ‚ฌšฉ•˜๋Š” ๊ฒƒ๋ณด๋‹ค in— •ด๋‹น•˜๋Š” ๊ฐฒด ‚ฌšฉ ฝ”๋”ฉด Žธ•˜๋”๊ตฐš”. ๊ทธ๋ฆฌ๊ณ  ๋ง”€•˜‹ ๋Œ€๋กœ, MEC++  „๋ฐ˜— ง€—ญ๊ฐฒด๋กœ ƒ„•œ Refernece๋ฌธ œ— ๊ด€•œ –ธ๊ธ‰ด žˆ๋Š”๋ฐ, ด๊ฒƒ˜ ๊ด€๋ฆฌ๊ฐ€ C++˜ ๊ฐ€žฅ ฐ ๋ฒฝœผ๋กœ ž‘šฉ•˜๋Š” ๊ฒƒด •„๋‹๊นŒ ƒ๊ฐด ๋ฉ๋‹ˆ๋‹ค. OOP  ด๋ ค๋ฉด ๋ฐ˜™˜„ ๊ฐฒด๋กœ •ด•ผ •˜๋Š”๋ฐ, ด๋ฅผ ฌธ„ฐ๋กœ ๋„˜๊ธฐ๋Š” ๊ฒƒ€ ›น™ œผ๋กœ ๊ฐฒด๋ฅผ ๋„˜๊ธด๋‹ค๊ณ  ๋ณผˆ˜ —†๊ณ , •ด œ ๋ฌธ œ๊ฐ€ ๋ฐœƒ•˜๋ฉฐ, reference๋กœ ๋„˜๊ธฐ๋ฉด ๋ง”€•˜‹ ๋ฐ๋กœ, •ด๋‹น scope๊ฐ€ ๋ฒ—–ด๋‚˜๋ฉด –ธ–ดƒ˜ lifetimeด ๋๋‚œ ๊ฒƒด๋ฏ€๋กœ ˜—ญ— ๋Œ€•œ ๋ฉ”๋ชจ๋ฆฌ  ‘๊ทผ„ OS—„œ ๋ง‰„ง€๋„ ๋ชจ๋ฆ…๋‹ˆ๋‹ค. ๋‹จ, inline— •œ•˜—ฌ๋Š” ด•ผ๊ธฐ๊ฐ€ ๋‹ฌ๋ผง‘๋‹ˆ๋‹ค. (inline˜ ฝ”๋“œ ๊ตฒด๊ฐ€ compiler— ˜•˜—ฌ ๊ฒฐ •๋˜๋ฏ€๋กœ ด๊ฒƒ๋„ —ญ‹œ ๋ชจ˜ธ•ด ง‘๋‹ˆ๋‹ค.) •„˜ˆ COM—„œ๋Š” OOP—„œ ๋ฒ—–ด ๋‚˜๋”๋ผ๋„, ๋ฒ”šฉ œผ๋กœ “ฐผˆ˜ žˆ๋„๋ก CŠคŽ™˜ •จˆ˜™€ ๊ฐ™ด in, out ˜  ‘๋‘–ด™€ •ด๋‹น  ‘๋‘–ด๋Š” pointer๋กœ •˜๋Š” ๊ทœน™„ „›Œ๋†“•˜ง€š”. ด „ค๊ณ„๊ฐ€ C#—„œ buil-in type˜ scalar˜•— •ด๋‹น•˜๋Š” ๊ฒƒ๊นŒง€ ๋ฐ˜˜๋œ ๊ฒƒด ธƒ ด —ˆŠต๋‹ˆ๋‹ค.(MS๊ฐ€ ˆ๊ธฐ .net„ธ๋ฏธ๋‚˜—„œ ด ๋•Œ๋ฌธ— String —ฐ‚ฐ ฐจด๊ฐ€ 10~20๋ฐฐ  •๋„ ๋‚œ๋‹ค๊ณ  ๊ด‘๊ณ •˜๊ณ  ๋‹ค๋…”—ˆ๋Š”๋ฐ, ง€๊ธˆ ƒ๊ฐ•ด ๋ณด๋ฉด ๋‹ค ๋ถ€ˆ—†๋Š” ด•ผ๊ธฐ ๊ฐ™Šต๋‹ˆ๋‹ค.) -ƒ๋ฏผ

1.2. Item 2 : Prefer C++ style casts.

  • Item 2 : C++ Šคƒ€ผ˜ ˜•๋ณ€™˜„ ๊ถŒžฅ•œ๋‹ค.
C style cast ๋ฐฉ๋ฒ•
~cpp 
(type) expression 
C++ style cast
~cpp 
static_cast<type>(expression) 

const_cast<type>(expression)

dynamic_cast<type>(expression)

reinterpret_cast<type>(expression)

  • static_cast<type>(expression)๋Š” ๊ธฐกด˜ C style—„œ ‚ฌšฉ•˜๋Š” (type)expression ™€ ๋™ผ•˜๋‹ค.

๋‹ค๋ฅธ cast ๋ฌธ๋ฒ•€ const™€ class๊ฐ€ ๊ณ ๋ ค๋œ C++ style cast—ฐ‚ฐž ด๋‹ค.

  • const_cast<type>(expression)˜ˆ œ

~cpp 
class Widget{ ...}
class SpecialWidget:public Widget{...}
void update( SpecialWidget *psw);
SpecialWidget sw;
const SpecialWidget& csw = sw;

update(&csw);	// ๋‹น—ฐžˆ •ˆ๋จ constธžด๋ฏ€๋กœ ๋ณ€™˜(’€–ดฃผ๋Š” ผ) ‹œผœ ฃผ–ด•ผ •œ๋‹ค.

update(const_cast<SpecialWidget*>(&csw));	// ˜ณƒ€ฟ ๋‚˜ 
update((SpecialWidget*)&csw);        // C styleธ๋ฐ ž˜ ๋Œ•„๊ฐ„๋‹ค. 
                                     // C++๋Š” C™€˜ ˜ธ™˜„ ๊ณ ๋ ค๋ฅผ œ„•œ ๊ฒƒด๋ฏ€๋กœ œ„™€ ๊ฐ™ด
                                     // ๋™ž‘ •˜ง€๋งŒ ๋ช…‹œ ดง€ ๋ชป•œ๋ฉดด ง€ ๋œ๋‹ค.


Widget *pw = new SpecialWidget;
update(pw);

update(const_cast<SpecialWidget*>(pw));       // error!
                                              // const_cast<type>(expression) ๋Š” 
                                              // ˜คง ƒˆ˜(constness)๋‚˜ ๋ณ€ˆ˜(volatileness)— ˜–ฅ„ ๋ฏธนœ๋‹ค.
                                              // ด๋Ÿฐ๋ง •˜๋ฉด ๋‹ค ๊ฐ€๋Šฅ•œ ๋“ฏ ‹ถ๊ณ  static_cast ™€ ฐจด๊ฐ€ —†๋Š” ๊ฒƒ
                                              // ๊ฐ™€๋ฐ ˜†˜ †ŒŠค ฒ˜๋Ÿผ down cast๊ฐ€ ๋ถˆ๊ฐ€๋Šฅ•˜๋‹ค. 


œ„— ˜ˆ œ ด–ด„œ ƒ๊ฐ

  • dynamic_cast<type>(expression) ˜ˆ œ

~cpp 
Widget *pw
...
update( dynamic_cast<SpecialWidget*>(pw));    // ˜ณ๋‹ค. 
                                              // const_cast ๊ฐ€ down cast๊ฐ€ ๋ถˆ๊ฐ€๋Šฅ •œ ๋Œ€‹ — dynamic_cast ๋Š” ๋ง๊ทธ๋Œ€๋กœ
                                              // •ด๋‹น ๋ถ€๋ชจ ๊ฐฒด˜ ฌธ„— ž‹ ๊ฐฒด๊ฐ€ ๊ฐ€๋ฅดผœ žˆœผ๋ฉด ˜•๋ณ€™˜ด ๊ฐ€๋Šฅ•˜๋‹ค.
                                              // ๋ถˆ๊ฐ€๋Šฅ •˜๋ฉด null „ ๋ฐ˜™˜•ดฃผ๋Š” ๊ธฐŠน•œ —ญ• ด •ต‹ฌด๋‹ค.

void updateViaRef(SpecialWidget& rsw);
updateViaRef(dynamic_cast<SpecialWidget&>(*pw)); // ˜ณ๋‹ค.
                                                 // reference—„œ๋„ ‚ฌšฉ ๊ฐ€๋Šฅ•˜๋‹ค? ๊ทธ๋Ÿผ ๋ถˆ๊ฐ€๋Šฅ • ‹œ˜ ฒ˜๋ฆฌ๋Š”?
                                                 // ด๋Ÿด๋•Œ๋Š” ˜ˆ™ธ(exception)„ ๋ฐœƒ‹œผœ ค€๋‹ค.

  • reinterpret_cast<type>(expression) € ฐจ›„ ๋‹ค‹œ ฝ€๋’ค  •๋ฆฌ•œ๋‹ค.

  • C —„œ ง€›•˜ง€ •Š„ ๊ฒฝšฐ ๋‹คŒ ๋งคฌ๋กœ๋ฅผ ‚ฌšฉ•˜—ฌ

~cpp 
#define static_cast(TYPE, TEXPR)           ((TYPE) (EXPR))
#define const_cast(TYPE, TEXPR)            ((TYPE) (EXPR))
#define reinterpret_cast(TYPE, TEXPR)      ((TYPE) (EXPR))
ด๋ ‡๊ฒŒ ๊ตฌ˜„ •ด„œ ๋Œ€๋น„•˜๋Š”๊ถ”ฒœ•œ๋‹ค. (dynamic_cast ๋Š” C˜  ˆฐจ  ”„๋กœ๊ทธ๋ž˜๋ฐ—„œ ๋“žฅ ๋ถˆ๊ฐ€)

~cpp 
    double result = static_cast(double, firstNumber)/ secondNumber;
    update(const_cast(SpecialWidget*, &sw));
    funcPtrArray[0] = reinterpret_cast(FuncPtr, &doSomething);

1.3. Item 3: Never treat arrays polymorphically

  • Item 3:  ˆ๋Œ€๋กœ! ด๋ž˜Šค ๊ฐ„˜ ๋‹ค˜•„„ †ต•œ ๋ฐฐ—ด ทจ๊ธ‰„ •˜ง€ ๋ง๋ผ

๋‹ค๋ฅธ๊•„š” —†๋‹ค ด ˜ˆ œ ๋ณด๋ฉด •„ฐจ ‹ถ๋‹ค.
~cpp 
class BST { ... };
class BalancedBST : public BST { ... };
ด๋Ÿฐ ด๋ž˜Šค๋ฅผ „ –ธ–ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋‹คŒ๊ณผ ๊ฐ™€ •จˆ˜๋กœ •ด๋‹น ด๋ž˜Šค˜ ๋ฐฐ—ด„ ‚ฌšฉ•œ๋‹ค๊ณ  ๊ฐ€ ••˜ž
~cpp 
void printBSTArray( ostream& s, const BST array[], int numElements)
{
    for ( int i = 0; i < numElements; ++i ){
        s << array[i]; 
    }
}
๊ทธ๋ฆฌ๊ณ  ๋‹คŒ๊ณผ ๊ฐ™ด ‚ฌšฉ•œ๋‹ค.
~cpp 
    BST BSTArray[10];
    ...
    printBSTArray(cout, BSTArray, 10);    // ˜ฌ๋ฐ”๋ฅด๊ฒŒ ž‘๋™•œ๋‹ค. •„๋ฌด ๋ฌธ œ —†๋‹ค.

    //////////////////////////////////////

    BalancedBST bBSTArray[10];
    ...
    printBSTArray(cout, bBSTArray, 10);   // ๊ณผ—ฐ ˜ฌ๋ฐ”๋ฅด๊ฒŒ ž‘๋™•˜๋Š”๊ฐ€?

œ„˜ ๋‘๋ฒˆงธ ˜ธถœ˜ ด๋ž˜Šค ƒ†˜ ๋‹ค˜•  „ˆ„ ดšฉ•œ •จˆ˜ ดšฉ ฆ‰
~cpp 
   printBSTArray( cout, bBSTArray, 10 );
€  •๋ง ตœ•…˜ ๊ฒฐ๊ณผ๋ฅผ ๋ถˆ๋Ÿฌ ๋“คธ๋‹ค.

C++—„œ˜ ๋ฐฐ—ด€ arrayi ˜ ˜๋ฏธ๋Š” *(array+i) ธ๋ฐ ด๊ฒƒ˜ ฃผ†Œ ถ” „ œ„•ด„œ —„๋ฐ€žˆ ๋”ฐง€๋ฉด

*(array+ ( i *sizeof(an object in the array) )

๋กœ ‚ฌšฉ•œ๋‹ค. ๋А๋‚Œด ˜ค๊ฒ ง€! ๋‹น—ฐžˆ ƒ†‹œ child๋Š” parent๋ณด๋‹ค ฐ ๊ฒฝšฐ๊ฐ€ ๋‹ค๋ฐ˜‚ฌด๊ณ  ๋ฐฐ—ด˜ œ„น˜ ถ” ด —‰๋ง „ฐฝด ๋˜–ด ๋ฒ„๋ฆฐ๋‹ค.

* ๊ฐฒด˜ ผ๊ด€ ธ ‚ญ œ— ๊ด€•ด„œ๋„ •Œ•„ ๋ณด๋ฉด
~cpp 
    void deleteArray( ostream& logStream, BST array[])
    {
        logStream << "Deleting array at address " 
                  << static_cast<void*>(array) << '\n';
        delete [] array;
    }

    BalanceBST *balTreeArray = new BalancedBST[50];
    ...
    deleteArray(cout, balTreeArray);  // ด๊ฒƒ —ญ‹œ  œ๋Œ€๋กœ ง€›Œง€๋ฆฌ๊ฐ€ —†๋‹ค.
ž œ„™€ ๊ฐ™ด ๊ฐฒด˜ ง€›€„ ๋‹ด๋‹น•˜๋Š” •จˆ˜๋ฅผ ž‘„–ˆ„๋•Œ —ญ‹œ ๋ฌธ œ๊ฐ€ žˆ๋‹ค.
~cpp 
    delete [] array
๋Š” ๋‹คŒ๊ณผ ๊ฐ™€ ฝ”๋“œ๋กœ ๊ตฒด๋˜๋Š”๊ฒƒ๊ณผ ๊ฐ™๋‹ค.
~cpp 
    for( int i = the number of elements in the array -1; i>0; --i)
    {
        array[i].BST::~BST();
    }
๋ถ€๋ชจ ๊ฐฒด˜ ŒŒ๊ดดž๋งŒ ๋ถ€๋ฅด๋ฏ€๋กœ —ญ‹œ memory leak ˜„ƒ„ ผœผ‚จ๋‹ค.

1.4. Item 4: Avoid gratuitous default constructors.

  • Item 4: •”‹œ œผ๋กœ  œ๊ณต๋˜๋Š” ๊ธฐ๋ณธ ƒ„ž๋ฅผ ”ผ•˜๋ผ. ˜น€ ๊ธฐ๋ณธ ƒ„ž˜ ๋ชจ˜ธ„„ ŒŒ•…•˜๋ผ.

C++—„œ class templete๋ฅผ ๋งŒ๋“œ๋Š” ค‘ ƒ„ž๋ฅผ ๋นผ๋จนœผ๋ฉด compiler—„œ ๊ธฐ๋ณธ ธ ƒ„ž๋ฅผ ๋งŒ๋“ค–ด ƒ„•ด ค€๋‹ค. —ญ‹œ, ๋‹น—ฐžˆ ˆ๊ธฐ™”˜ ๋ฌธ œ๊ฐ€ ๋ฐœƒ•  ๊ฒƒด๋‹ค. —ฌ๊ธฐ—„œ๋Š” •ฝ๊ฐ„ ž„•œ ๋ถ€๋ถ„„ –ธ๊ธ‰•œ๋‹ค.

˜ˆ œ—„œ ‹œž‘•˜ž
~cpp 
    class EquipmentPiece {
        public:
            EquipmentPiece(int IDNumber);
            ...
    }

•ด๋‹น EquipmentPiece ๋Š” ๊ธฐ๋ณธ ƒ„ž๊ฐ€ ๋ถ€‹ค(?) •˜๋‹ค. ด๊ฌ๊ฒŒ 3๊ฐ€ง€˜ ฃผ œ๋กœ „ค๋ช…• ˆ˜ žˆ๋‹ค.

  • ฒซ๋ฒˆงธ ๋ฌธ œ๋Š” •ด๋‹น ด๋ž˜Šค๋ฅผ ดšฉ•˜—ฌ ๋ฐฐ—ด„ ƒ„ • ๋•Œด๋‹ค. . ( The first is the creation of arrays )


~cpp 
    EquipmentPiece bestPieces[10];  
    EquipmentPiece bestPieces = new EquipmentPiece[10]; 
// ๋‘๊ฒฝšฐ ˆ๊ธฐ™” •ด„ ๋ฐฉ๋„๊ฐ€ —†–ด„œ —๋Ÿฌด๋‹ค.
ด๊ด๋ ‡๊ฒŒ ’€–ด ๋ณดž
~cpp 
    int ID1, ID2, ID3, ... ID10;
    ...
    EquipmentPiece bestPiece[] = {
    EquipmentPiece(ID1),
    EquipmentPiece(ID2),
    EquipmentPiece(ID3),
    ...,
    EquipmentPiece(ID10),
}
•˜ง€๋งŒ ด๋Ÿด ๊ฒฝšฐ—๋Š” array๋ฅผ heap arrays(heap˜—ญ ‚ฌšฉ array๋ผ๋Š” ˜๋ฏธ๋กœ ๋ฐ›•„๋“คž„)๋กœ˜ ™•žฅด ๋ถˆ๊ฐ€๋Šฅ•œ ๊ณ  •๋œ ๋ฐฉ๋ฒ•ด๋‹ค.

กฐ๊ธˆ ๋” ผ๋ฐ˜ ธ ๋ฐฉ๋ฒ•€ ๋‹คŒ๊ณผ ๊ฐ™ด pointer๋ฅผ ดšฉ•œ  ‘๊ทผ„  œ‹œ•œ๋‹ค.
~cpp 
    typedef EquipmentPiece* PEP;
    PEP bestPieces[10];
    PEP *bestPieces = new PEP[10];

    for ( int i = 0; i< 10; ++i)
        bestPiece[1] = new EquipmentPiece( ID Number );
•˜ง€๋งŒ ด๋Ÿฌ•œ ๋ฐฉ๋ฒ•€ •œ๋ˆˆ— ๋ด๋„ ๋ฌธ œ๊ฐ€ ˜ˆƒ๋œ๋‹ค. ๋ฐ”๋กœ delete๋ฌธ œ

๋‘๊ฐ€ง€๋ฅผ ๊ตฌฒด œผ๋กœ ด•ผ๊ธฐ •ด๋ณด๋ฉด, ฒซ๋ฒˆงธ๋กœ for ๋ฌธ‹œ—„œ • ๋‹น๋˜๋Š” ๊ฐฒด˜ ˆž๋ฅผ ๊ธฐ–ต•˜๊ณ  žˆ–ด•ผ •œ๋‹ค. žƒ–ด๋ฒ„๋ฆฌ๋ฉด ฐจ›„ resouce leakด ๋ฐœƒ • ๊ฒƒด๋‹ค. ๋‘๋ฒˆงธ๋กœ๋Š” pointer๋ฅผ œ„•œ ๊ณต๊ฐ„ • ๋‹นœผ๋กœ ‹ค œ •„š”•œ memory šฉ๋Ÿ‰๋ณด๋‹ค ๋” “ด๋‹ค.


๊ทธ๋Ÿผ ๋” ›ƒ๊ธฐ๋Š” ๋ฐฉ๋ฒ•„  œ‹œ•ด ๋ณดž. (ด …„ ๋ณด๊ณ  žˆ๋…ธ๋ผ๋ฉด, ด๋ ‡๊ฒŒ๋„ “ธˆ˜ žˆ๋‹ค๋ž€๊ธ ๋ณด—ฌฃผ๋Š”๊ฐ ๊ฐ™๋‹ค.)
~cpp 
    void *rawMemory = operator new[](10*sizeof(EquipmentPiece));
    EquipmentPiece *bestPieces = static_cast<EquipmentPiece*>(rawMemory);
    for ( int i = 0; i< 10; ++i)
        new (bestPieces+1) EquipmentPiece ( ID Number );  // ด๊ด placement new ๋ผ๊ณ  •˜—ฌ Item 8 —„œ –ธ๊ธ‰•œ๋‹ค. 
                                                          // ฒ˜Œ ๋ณด๊ณ  ๋†€๋ž๋‹ค. –ด„œ ‚ฌ๊ธฐ•ผ •˜๋ฉด„œ --;;
                                                          // ด … ฃผŠน๊ธฐ๋‹ค. ๋’ค— „ค๋ช…•˜๋‹ˆ๊นŒ ๊ทธ๋ƒฅ ๋„˜–ด๊ฐ€ •˜๋Š”๊ฐ
                                                          // •”Šผ ˜๋ฏธ๋Š” ด•ด ๊ฐˆ๊ฒƒด๋‹ค.
ฐธ ๊ง€ ๊ฐ™€ ง“ ž˜•ด ๋†“๋Š”๋‹ค.

ผ๋‹จ ™•๋ณด•œ ˜—ญ„ ง€šฐ๊ธฐ๋Š” ‰ฝ๋‹ค. ด๋ ‡๊ฒŒ
~cpp 
    delete [] rawMemory;
—ญ‹œ๋‚˜ ด๊ฒƒ๋„ delete— ๊ด€•œ ๋ชจ˜ธ„„  œ๊ณต•œ๋‹ค. ๋ฌธ œ‹œ ๋˜๋Š”  € rawMemoryƒ— ๋ฐฐน˜๋œ EquipmentPiece˜ destructor ˜ธถœ œ ๋ฌดด๋‹ค. ˜ˆƒ๋Œ€๋กœ destructor๋ฅผ ๊ฐ• œ ˜ธถœ•ด ค˜•ผ •œ๋‹ค. ๊ทธ๋ž˜„œ œ„๊ฐ€ •„๋‹ˆ๋ผ, ด๋Ÿฐ‹˜ ‚ญ œ๊ฐ€ ๋œ๋‹ค.
~cpp 
    for ( int i = 9; i>= 0; --i)
        bestPieces[i].~EquipmentPiece();    // –ธ œ๋‚˜ ๋А๋ผ๋Š” ๊ง€๋งŒ C++„ ๋ฐฉข…„ ๊ฐ€ ธ๋‹ค „ˆ˜ žˆ๋‹ค.
    operator delete[](rawMemory);
ฐธ๊ณ ๋กœ
~cpp 
    delete [] bestPieces; // ด๋ ‡๊ฒŒ ง€šฐ๋Š”๊ด new operator๊ฐ€ ๊ด๋“คง€ •Š•„„œ ๋ถˆ๊ฐ€๋Šฅ•˜๋‹ค.

  • ๋‘๋ฒˆงธ ๋ฌธ œ๋Š” ๋งŽ€ template class(Šนžˆ STL—„œ) ๋“ค—๊ฒŒ •„””„ •ˆ๊ฒจค€๋‹ค.
•„๋ž˜™€ ๊ฐ™€ template class ๋ฅผ „ –ธ–ˆ๋‹ค๊ณ  ๊ฐ€ ••˜๋ฉด,
~cpp 
template<class T>
class Array{
public:
    Array(int size);
    ...
private:
    T *data;
};
template<class T>
Array<T>::Array(int size)
{
    data = new T[size];
    ....
}
ฒซ๋ฒˆงธ—„œ  œ๊ธฐ๋œ ๋ฌธ œ๊ฐ€ ด๋ฒˆ—๋Š” template class ๋‚ด๋ถ€—„œ ผ–ด ๋‚˜๊ณ  žˆ๋Š” …ˆด๋‹ค. ๊ฐธ •”๋‹ด•œ ๊ฒฐ๊ณผ๋ฅผ ˆ๋ก€•œ๋‹ค. ๋ฌธ œ๋Š” ด๋Ÿฌ•œ template class ๊ฐ€ ด œ๋Š” •„˜ˆ STL๊ฐ™€ library๋กœ ๊ตฌถ•๋˜—ˆ๋‹จ ‚ฌ‹ค. •Œ•„„œ ž˜ ๊ธฐ๋ณธ ƒ„ž ๋งŒ๋“ค–ด  šฉ•˜‹œ๋ผ. ๋‹ค๋ฅธ ๋ฐฉ๋„ —†๋‹ค.

DeleteMe ด ๋ถ€๋ถ„ด ๋ถ€‹ค•˜๋‹ค ฐจ›„ ๋ณด๊ฐ• •„š”
  • „ธ๋ฒˆงธ(๋งˆง€๋ง‰) ๋ฌธ œ๋Š” virtual base class™€ ๊ฐ™ด ๊ธฐ๋ณธ ƒ„ž๋ฅผ ๊ฐ€ ธ•ผ •˜๋‚˜ ๋ง•„•ผ •˜๋‚˜ ๋ฏธ๋ฌ˜•œ ๋”œ๋ ˆ๋งˆ˜ —ฐถœด๋‹ค.
ƒ๊ฐ•ด ๋ณด๋ผ Virtual base class๊ฐ€ ™œ ๊ธฐ๋ณธ ƒ„ž๋ฅผ •„š”๋กœ •˜๋Š”๊ฐ€. ƒ„ž๋ฅผ ๋งŒ๋“ค–ด ๋†“œผ๋ฉด ƒ†•˜๋Š” ด›„ ๋ชจ๋“  ด๋ž˜Šค๋“ค—๊ฒŒ ๋กœ๋“œ๊ฐ€ ๊ธ๋ฆฌ๋Š” …ˆด ๋œ๋‹ค. ๊ทผ›ด ”๋“ค๋ ค ๋ชจ๋‘๊ฐ€ ˜–ฅ„ ๋ฐ›๋Š” ‚ฌƒœด๋‹ค. ๋งŒ•ฝ? ˆ˜๋งŒ๊ฐœ˜ ๊ฐฒด ƒ„ด๋ผ๋ฉด ด๊ด ๊ต‰žฅ•œ ๋ฌธ œ๊ฐ€ ๋ ˆ˜ žˆ๋‹ค.


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