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