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.0325 sec