U E D R , A S I H C RSS

More EffectiveC++/Operator

1. Operator

1.1. Item 5: Be wary of user-defined conversion functions.

  • Item 5: ‚ฌšฉž  •˜ ํ˜•€ํ™˜(conversion) ํ•จˆ˜— ˜ํ•˜!

  • C++Š” ํƒ€ž…„˜ •”‹œ  type casting„ ํ—ˆšฉํ•œ‹ค. ดด C˜ œ ‚ฐธฐ ˜ˆ “คžฉด char int —„œ short double “คด •„ฌดŸฐ ฌธ œ—†ด ฐ”€Œ–ด „‹ค. ทธŸฐฐ C++Š” ดฒƒ ณด‹ค ํ•œˆ˜ ”– „œ type casting‹œ— žฃŒ žƒ–ด „ฆฌฒŒ ˜Š” int—„œ short dougle—„œ char˜ €ํ™˜Œ€ ํ—ˆšฉํ•œ‹ค.

‹จ ดŸฐ ธฐณธ €ํ™˜— Œ€ํ•ด„œ ฐœฐœžŠ” –ดฐŒ €—ฌ ํ• ˆ˜ —†‹ค. ํ•˜€งŒ, C++—„œ class˜ ํ˜•€ํ™˜€ ฐœฐœž€ ํ˜•€ํ™˜— €ํ•˜—ฌ €—ฌํ• ˆ˜ žˆ‹ค. €ํ™˜— €ํ•˜—ฌ …ํ•œ‹ค.

  • C++—„œŠ” ํฌฒŒ ‘€€ ฐฉ‹˜ ํ•จˆ˜กœ ํ˜•€ํ™˜„ ปดํŒŒŸฌ—ฒŒ ˆ˜ํ–‰ ‹œํ‚คํ‚จ‹ค:
    single-argument constructors ™€ implicit type conversion operators ด ทธฒƒด‹ค.
  • single-argument constructors € ธž ํ•˜‚˜˜ ธžงŒœกœ „ธํŒ… ˆ˜ žˆŠ” ƒ„žด‹ค. —ฌธฐ ‘€€˜ ˜ˆ ณดž

~cpp 
class Name {
public:
    Name( const string& s);
    ...
};
class Rational {
public:
    Rational( int numerator = 0, int denominator = 1);
    ...
};

  • implicit type conversion operator € ํดž˜Šคกœ ํ•˜—ฌธˆ ํ•ด‹ ํƒ€ž…œกœ return „ ›ํ• •Œ •”‹œ ธ €ํ™” €›ํ•˜ธฐ œ„ํ•œ operatorด‹ค. •„ž˜Š” doubleกœ˜ ํ˜•€ํ™˜„ œ„ํ•œ ฒƒด‹ค.

~cpp 
class Rational{
public:
    ...
    operator double() const;
};

Rational r(1,2);
dougle d = 0.5 * r;
ฐธ ดœฐฎ€ ฐฉฒ•ด‹ค. ํ•˜€งŒ ด ฐฉฒ•€ ฐœฐœž€ ˜„ํ•˜€ •Š€ ํ˜•€ํ™˜งˆ ธ ‹œํ‚คŠ” ฒƒ•Œฌธ— ฌธ œ€ ฐœƒํ•œ‹ค. ‹คŒ„ ณดž
~cpp 
Rational (1,2);
cout << r;      // should print "1/2"
operator<<Š” ฒ˜Œ Raional ดŠ” ํ˜•— Œ€ํ•œ ž‹ ˜ Œ€‘„ ฐพ€งŒ —†ณ , ดฒˆ—Š” r„ operator<<€ ฒ˜ฆฌํ• ˆ˜ žˆŠ” ํ˜•œกœ €ํ™˜‹œํ‚ค คŠ” ž‘—…„ ํ•œ‹ค. ทธŸฌŠ” ™€ค‘— r€ doubleกœ •”‹œ  €ํ™˜ด ดฃจ–ด €ณ  ฒฐ double ํ˜•œกœ ถœ ฅด œ‹ค.

ญ ดŸฐ •”‹œ  ํ˜•€ํ™˜„ ง‰„ คฉด, ํ˜• „ํ™˜ ‹œํ‚คณ  ํ•˜Š” •”‹œ  ‚ฌšฉ„ ํ•˜€ •Šณ , ‹คฅธ ํ•จˆ˜กœ ช…‹œ œกœ ํ•ด „ˆ˜ žˆ‹ค.
~cpp 

class Raional{
public:
    ...
    double asDouble() const;
};

Rational r(1,2);
cout << r;                // error!
cout << r.asDouble();     // doubleกœ˜  „ํ™˜˜ ˜„€ ํ™•‹คํžˆ  „ํ•ด „‹ค.

ดŸฐ ˜ˆกœ C++ std library— žˆŠ” stringด char*กœ •”‹œ  ํ˜•€ํ™˜ด —†ณ  c_str˜ ช…‹œ  ํ˜•€ํ™˜ ‹œํ‚จ‹ค.

  • single-argument constructor Š” ” –ด คšด ฌธ œ  œณตํ•œ‹ค. ฒŒ‹ค€ ดฌธ œ“ค€ •”‹œ  ํ˜•€ํ™˜ ณด‹ค ” งŽ€ €„„ ฐจ€ํ•˜Š” •”‹œ  ํ˜•€ํ™˜—„œ ฌธ œ€ ฐœƒœ‹ค.

~cpp 
template<class T>
class Array{
public:
    Array ( int lowBound, int highBound );
    Array ( int size )

    T& operator[] (int index)
    ...
};

ฒซฒˆงธ ƒ„žŠ” ฐฐ—ด˜ lowBound~highBound ‚ฌดกœ˜ ํฌธฐ  œํ•œžดณ , ‘ฒˆงธ ƒ„žŠ” ํ•ด‹ ํฌธฐกœ ฐฐ—ด ณต„ ƒ„ธฐ, ด ‘ฒˆงธ˜ ƒ„ž€ ํ˜•€ํ™˜„ €Šฅํ•˜ฒŒ งŒ“ค–ด„œ ฌดํ•œํ•œ ‚ฝงˆ— „„— ‹‹ „ ดˆŒ€ํ•œ‹ค. (‹ค œกœ ดŸฐ ˜กœ จžˆ‹ค. --ƒ)

˜ˆ “ค–ด„œ ‹คŒ„ ณดž
~cpp 
bool operator==( const Array< int >& lhs, const Array<int>& rhs);

Array<int> a(10);
Array<int> b(10);
...
for ( int i = 0; i<10; ++i)
    if( a == b[i] ) {           // ํ—‰Šค! ดŸฐ "a"Š” "a[i]" จ• ํ•  ฝ”“œ˜€‹ค!. (ฐœฐœž˜ ‹คˆ˜ ˜ธ, ํ•œ–‘ตญ—„œ ฐ™€ ฐœŒ˜ oops! --;;  --ƒ)
        a[i]™€ b[i]€ ฐ™„•Œ ด ฝ”“œ ˆ˜ํ–‰ํ•œ‹ค.;
    }
    else {
        œ„˜ กฐ„ งŒํ•˜€ ชปํ•˜ฉด ด ฝ”“œ ˆ˜ํ–‰ํ•œ‹ค.;
    }
7„ if ( a == bi ) €„˜ ฝ”“œ—„œ ํ”„กœทธž˜จธŠ” ž‹ ˜ ˜„™€Š” ‹คฅธ ฝ”“œ ž‘„ํ–ˆ‹ค. ดŸฐ ฌธฒ• ž˜ชป€ ‹—ฐํžˆ! ปดํŒŒŸฌ€ •Œ คค˜• ฐœฐœž˜ ‹œ„„ •„‚„ˆ˜ žˆœฆฌ, ํ•˜€งŒ ดŸฐ ˜ˆ œ€ ทธ ‡€งŒ€ •Š‹ค. ด ฝ”“œŠ” ปดํŒŒŸฌ ž…žฅ—„œ ณดฉด ˜ณ€ ฝ”“œ€  ˆ˜ žˆŠ” ฒƒด‹ค. ฐ”กœ Array class—„œ  •˜ ํ•˜ณ  žˆŠ” single-argument constructor — ˜ํ•˜—ฌ ปดํŒŒ‹œ ดŸฐ ฝ”“œกœ˜ €ํ™˜˜ €Šฅ„ด žˆ‹ค.

~cpp 
for ( int i = 0; i < 10; ++i)
    if ( a == static_cast< Array<int> >(b[i]) )...
bi Š” intํ˜•„ ฐ˜ํ™˜ํ•˜ธฐ •Œฌธ— ด ‡ฒŒ ฆ‰„—„œ งžถค ƒ„žกœ type casting(ํ˜•€ํ™˜)„ ปดํŒŒŸฌ€ •”‹œ œกœ ํ•ด„ˆ˜ žˆ‹ค. ด œ ‚ฌํƒœ˜ ‹ฌฐ„„ •Œฒ Š”€?

  • explicit
ดŸฐ • งคํ•œ ƒํ™ฉ„ ํ”ํ• ˆ˜ žˆŠ” €žฅ ํšจ ธ ฐฉฒ•€ C++—„œ “žฅํ•œ ƒˆกœšด ํ‚ค›Œ“œธ explicit ˜ ‚ฌšฉด‹ค. ด ํ‚ค›Œ“œ€ ถ™€ ƒ„žกœ˜ ํ˜•€ํ™˜—„œŠ” ฐ˜“œ‹œ ช…‹œ ธ „ –ธด žˆ–ด• €Šฅํ•˜‹ค. ฆ‰ œ„˜ ฝ”“œ ‹ค‹œ ž‘„ํ•˜—ฌ explicit˜ ‚ฌšฉ„ •Œ•„ณดณ  ฌธฒ•ƒ œ ˜ ‚ฌํ•ญ„ •Œ•„ ณดž

~cpp 
template<class T>
class Array{
public:
    ...
    expicit Array ( int size )   
    ...
};

Array<int> a (10); 
Array<int> b (10);       // ‘ฐœ ชจ‘ ƒ„ €Šฅํ•˜‹ค

if ( a == Array<int>(b[p])) ...                  // ด ฝ”“œ —ญ‹œ ˜ฌฐ”ฅด‹ค. 
                                                 // ํ•˜€งŒ ‹คฅธ ฐœฐœž€ ํ•ด„— ‚ฌšฉž˜ ˜„€ •ฝ„ ˜ฌธด „‹ค.
if ( a == static_cast< Array<int> >(b[p])) ...   // งž‹ค. œ„™€ งˆฐฌ€€กœ ‹คฅธ ‚ฌžŒด •€ํ˜ฆฐ‹ค
if ( a == (Array<int>) b[i] )                    // C-style ˜ ํ˜•€ํ™˜ธฐ —ญ‹œ‚˜ ‹คฅธ‚ฌžŒด —ดฐ›Š”‹ค.
ด ‡ฒŒ explicit ‚ฌšฉํ•˜ฉด ช…‹œ œกœงŒ ํ˜•€ํ™˜ด €Šฅํ•˜‹ค. ํ•˜€งŒ ˜ ํ•˜‚˜ ฌธฒ•ƒ œ ˜ ํ•ด• ํ• ‚ฌํ•ญ€
~cpp 
static_cast< Array<int> >(b[p])
ด ตฌ„—„œ > > ด ‘ฐœ ถ™—ฌ“ฐฉด >> operatorกœ ํ•ด„ํ•˜‹ˆ œ ˜ํ•ด

—ฌธฐ— ํ•œ€€ ” ƒฐํ•ด ณดž.

งŒ•ฝ ‹‹ ˜ ปดํŒŒŸฌ€ —„ฒญ ‚ก€ ‚˜  œž‘ž€ œกํ•ด„œ, ํ˜€ explicit ฃฝ–ด„ „ธฐ ‹ซ‹คณ  ํ• •Œ—Š”?

—ฌธฐ— ‚˜˜จ Array ˜ˆ œ ํ•œฒˆ ณ ณ„œ งˆ˜ explicit “ดฒƒฒ˜Ÿ ํ•ดณดž
~cpp 
template<class T>
class Array{
public:
    class ArraySize{
    public:
        ArraySize(int numElements):theSize(numElements){}
        int size() const { return theSize; }
    private:
        int theSize;
    }
    Array( int lowBound, int highBound);
    Array( ArraySize size );                      // ƒˆกœšด „ –ธ!
    ...
}

ด ‡ฒŒ Array •ˆชฝ— ArraySize „ –ธํ•˜ณ  publicœกœ ถˆ–ด„œ ด ‡ฒŒ ƒ„ํ•˜ฉด
~cpp 
Array<int> a(10);

ปดํŒŒŸฌ ‹จ—„œ aƒ„žธ Array( ArraySize size) —„œ ArraySize กœ˜ single-argument constructor ํ˜ธถœํ•˜ธฐ •Œฌธ— „ –ธด €Šฅํ•˜€งŒ
~cpp 
bool operator==( const Array< int >& lhs, const Array<int>& rhs);

Array<int> a(10);
Array<int> b(10);
...
for ( int i = 0; i<10; ++i)
    if( a == b[i] ) 
ดŸฐ ฒฝšฐ— operator==˜ ˜คฅธชฝ— žˆŠ” ธžŠ” int€ single-argument constructor—  ˆ˜ —†ธฐ •Œฌธ— —Ÿฌ ฐท–ด ‚ธ‹ค.

*ํ›„ธฐ:ดฒˆ€ „ˆฌด ธธ‹ค. ‹คฅธ— ‘ฐฐ— ํ•ด‹ํ•˜Š”ฐ™€ฐ ‹คŒ€„Š” ”ดฒญ ํ”šฐ€ งณ  ํ•ด•€ --ƒ

1.2. Item 6: Distinguish between prefix and postfix forms of increment and decrement operators.

  • Item 6: prefix™€ postfixกœ˜ ฆฐ —ฐ‚ฐž ตฌ„ํ•˜!

šฐฆฌŠ” ++™€ --—ฐ‚ฐž(ดํ•˜ €€ฐ —ฐ‚ฐž) ฆฒจ “ด‹ค. ด —ฐ‚ฐž —ญ‹œ ํดž˜Šค—„œ  •˜ํ•ด„œ ‚ฌšฉํ• ˆ˜ žˆ‹ค.
ํ•˜€งŒ ด €ฐ —ฐ‚ฐžŠ” ‘€€กœ ‚˜‰œ‹คŠ” ‚ฌ‹ค„ ƒฐํ•˜ฉด ฐ‘žธฐ ‚œฐํ•ด „‹ค. „งˆ „„ž€ ทธŸฐ ‹จ!ˆœ!ํ•œ! ฌธ œ „ํ• ฆฌ —†‹ค.

~cpp 
class UPInt{  //ฌดํ•œ  •ˆ˜ํ˜•
public:
    UPInt& opertrator++(int);         // prefix++
    const UPInt operator++(int);      // postfix++

    UPInt& opertrator--(int);         // prefix--
    const UPInt operator--(int);      // postfix--

    UPInt& operator+=(int);           // a += operator Š” UPInt™€ ints ถ”€ œ„ํ•ด
...
};
UPInt i;

++i;        // i.operator++();
i++;        // i.operator++(0);

--i;        // i.operator--();
i--;        // i.operator--(0);

ณดณ  žˆžฉด  •ง •„ด””–ด ดœฐฎ€“ ทธŸ ตฌฒด ธ ตฌํ˜„€— €ํ•ด„œ „‹จํžˆ …ํ•œ‹ค.
~cpp 
// prefix ฆ€ —ฐ‚ฐž €„ fetch
UPInt& UPInt::operator++()
{
    *this += 1;       // ฆ€
    return *this      // fetch!
}

// postfix ฆ€ —ฐ‚ฐž €„ fetch
const UPInt& UPInt::operator++(int)
{
    UPInt oldValue = *this;             // fetch
    ++(*this);                          // prefix ฆ€ ‹œํ‚จ‹ค.
    return oldValue;
}

*ž‘„ž ‚ฌ„ค: •„ ‚˜Š”  •ง ดŸฐ ฆฌํ„ด ดํ•ด€ •ˆ„‹ค. ฐธกฐกœ „˜ฒจ „ฆฌฉด Œ€ฒด ปดํŒŒŸฌŠ” –ดŠ ‹œ —„œ oldValue˜ ํŒŒดด ํ•˜ƒ” งด‹ค. C++ด reference countingœกœ ž› €ฆฌ ”ฐกœ ํ•ดŠ” ฒƒ„ •„‹ŒŒ€ งด‹ค. 1ํ•™…„•Œ €„˜ ณ ด‹จ งด‹ค. € ช…พŒํ•œ „ช…„ ˆ„€ ํ•ดคฌœฉด..

•”ํŠ  € œ„™€ ฐ™ด ํ•˜ฉด ดํ•ด€ ฐˆฒƒด‹ค. ํ•˜€งŒ ดŸด ฒฝšฐ š” ง“ฆฌ ชปํ•œ‹ค.

~cpp 
    UPint i;
    i++++;                 
ด ˜Š”
~cpp 
    i.operator++(0).operator++(0);
ฐ™‹ค. ‹—ฐํžˆ •ˆ˜ฒ €?

  • ž‘„ž ‚ฌ„ค:ณธฌธ—„œŠ” ทธ ’ค€„Š” •„˜ˆ ดŸฐ“ฐ€ งžŠ” ํ•„š”„˜ –ธธ‰‹ˆ‹ค. ฐจํ›„ ถ”€˜ ํ•„š”„ด žˆ„•Œ ถ”€ํ•ฉ‹ˆ‹ค.
    ทธƒฅ i++ ‘ฒˆ “ฐณ  ง€..

1.3. Item 7: Never overload &&, ||, or ,.

  • Item 7:  ˆŒ€กœ! &&, ||, ',' ด —ฐ‚ฐž“ค„ overload ํ•˜€ ง•„


~cpp 
    char *p;
    ...
    if ((p != 0) && (strlen(p) > 10) ) ...
œ„˜ ฝ”“œ—„œŠ” strlen() ํ•จˆ˜‚ด€—„œ p— € จํ•œ null pointer €‚ฌ€ ํ•„š”ํ•˜€ •Š‹ค. ™œƒํ•˜ฉด && —„œŠ” •ž˜ กฐด € • ฆ‰, ( false && anything ) ˜ ฒฝšฐ—Š” ’ค˜ กฐด(anything)€ ˆ˜ํ–‰กฐฐจ •ˆํ•˜ธฐ •Œฌธด‹ค. operator ||˜ ฒฝšฐ„ ํŠ • กฐ—„œ,(true || anything) ’ค— ฝ”“œ ˆ˜ํ–‰ํ•˜€ •Š€‹คŠ” ฒƒ€ „Šทํ•˜‹ค.
~cpp 
    int rangeCheck( int index)
    {
        if ((index < lowerBound) || (index > upperBound)) ...
        ...
    }

ˆ˜งŽ€ ฐœฐœž“คด ดŸฐ ‹จˆœํ•œ ›ฆฌ ํ”„กœทธžจ ƒ—„œ˜ งง€ „ํ–‰(short-circuit)„ ถ”ตฌํ•˜Š”ฐ ‚ฌšฉํ•˜˜€‹ค. ทธ ‡‹คฉด C++—„œ˜ ฐฒด“ค—ฒŒ operator ||, && overload ‹œํ‚คฉด งง€ „ํ–‰„ ถ”ตฌํ•˜Š”ฐ „›€ด ˜€ •Š„Œ? ทธŸฐฐ ํ•˜€ ง‹ˆ ™œŒ?

‹จ operator &&, ||Š” ด ‡ฒŒ ‘€€˜ ฒฝšฐกœ ‘˜ฆดˆ˜ žˆ‹ค.
~cpp 
    if (expression1 && expression2) ...
ด ฌธžฅ˜ ํ•ด„„ ปดํŒŒŸฌŠ” ด ‡ฒŒ ฐ›•„ “คธ‹ค.
~cpp 
    1. if (expression1.operator&&(expression2))...   // when operator && is member function.
    2. if (operator&&(expression1 , expression2))... // global function

ž ด ‘ฒฝšฐ ชจ‘ ƒฐํ•ด ณดฉด 1,2 –‘ชฝ ‹ค expression1, expression2 ˜ ฒฐ ฐ’ด ํ•„š”ํ•œ ƒํ™ฉด‹ค. ฆ‰, operator && ‚˜ operator || ˜ ฒฝšฐ –‘ชฝด classธž“ , –ด–ค ํ˜•ํƒœด“  ฐ˜“œ‹œ ฒฐ ฐ’ด ํ•„š”ํ•˜‹ค. œ„—„ –ธธ‰ํ–ˆ€งŒ, ดงŽ€ ฐœฐœž“คด &&™€ ||˜ ํŠ„„ ž˜ •Œณ  ‚ฌšฉํ•˜ณ  žˆœฉฐ, operator &&, ||˜ overloadŠ” ตฌ™˜€ ง•„•ํ•  ฝ”“œ€ ตฌ™˜Š” ˜„ํ•˜€ •Š€ ˜คฅ˜€ ฐœƒ †Œ€€ žˆ‹ค.

"comma operator" —ญ‹œ งˆฐฌ€€‹ค. comma operator€ Œ€ฒด ญƒณ ?

comma operatorŠ” ํ‘œํ˜„(form expression)— ‚ฌšฉœ‹ค. •„ž˜ ณดž
~cpp 
void reverse(char s[])
{
    for (int i = 0, j = strlen(s)-1;
        i < j;
        ++i, --j)                   // ด…€„“คด ฐ”กœ comma operator“คด‹ค. ธฐ€ ง‰ํ˜€..
    {
        int c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}
ฒฐก € overloadกœ –ธ–ดƒ˜ ด…€„“ค ›ž˜˜ Šฅ ฅ ฐœํœ˜ํ•˜ธฐ€ ํž˜“ค‹ค. ดŸฐ œ„ํ—˜€ ฐˆ˜ํ•  ํ•„š” —†€ •Š€€? ฐธณ กœ ‹คŒ„ •Œž

overloadํ• ˆ˜ —†Š” operator
~cpp 
    .                .*                ::                ?:
    new              delete            sizeof            typeid
    static_cast      dynamic_cast      const_cast        reinterpret_cast
overlod ํ• ˆ˜ žˆŠ” operator
~cpp 
    operator new     operator delete
    operator new[]   operator delete[]
    +    -    *    /    %    ^    &    |    ~
    !    =    >    <    +=   -=   *=   /=   &=
    ^=   &=   |=   <<   >>   >>=  <<=  ==   !=
    <=   >=   &&   ||   ++   --   ,    ->*  ->
    ()   []

1.4. Item 8: Understand the differend meanings of new and delete

  • Item 8: new™€ delete€ “ฐž„— ”ฐฅธ ˜“ค˜ ฐจด ดํ•ดํ•˜.

ณดํ†ต C++—„œ šฉ–ด“ค„  •ํ™•ํžˆ ดํ•ด ชปํ•  ฒฝšฐ€ žˆ‹ค. ฐ”กœ newoperator™€ operator new€ ทธ Œ€ํ‘œ ธ ˜ˆ€  ˆ˜žˆ„ ฒƒด‹ค. ‹คŒ˜ ฝ”“œ ณดž
~cpp 
    string *ps = new string("Memory Management");

ด ฝ”“œŠ” new operator ‚ฌšฉํ•œ ฒƒด‹ค. new operatorŠ” sizeof ฒ˜Ÿ –ธ–ด ƒ— ํฌํ•จ˜–ด žˆœฉฐ, ฐœฐœž€ ” ดƒ ทธ ˜˜ €ฒฝด ถˆ€Šฅํ•˜‹ค. ด‘€€˜ —ญํ• „ ํ•˜Š”ฐ, ฒซงธกœ ํ•ด‹ ฐฒด€ “ค–ดฐˆ งŒํ•œ ฉ”ชจฆฌ ํ• ‹ํ•˜Š” ฒƒดณ , ‘˜งธกœ ํ•ด‹ ฐฒด˜ ƒ„ž ถˆŸฌŠ” —ญํ• ด‹ค. new operatorŠ” ํ•ญƒ ด ‘€€˜ ˜ ž‘™ํ•˜ฉฐ •ž—„œ –ธธ‰ํ•œ“ €ฒฝ€ ถˆ€Šฅํ•˜‹ค.

ณดํ†ต operator newŠ” ด ‡ฒŒ „ –ธ˜–ด žˆ‹ค.
~cpp 
    void * operator new(size_t size);
ดฐ C—„œ˜ mallocฒ˜Ÿ ดˆธฐํ™” ˜€ •Š€ sizeงŒํ˜ ฉ”ชจฆฌ ํ• ‹ํ•ด„œ ทธ€ฆฌํ‚คŠ” voidํ˜•˜ pointer Œ คŠ” ฒƒดณ  ˜ˆธกํ• ˆ˜ žˆฒ ‹ค.(งž‹ค) ฐœฐœžŠ” operator new overloadํ• ˆ˜ žˆ€งŒ ฒซฒˆงธ ธžŠ” ํ•ญƒ size_t€ ˜–ด• ํ•œ‹ค.

•„งˆ —ฌŸฌ„€ operator new ง ‘ €ฅดŠ”ฒฐฝ” ›ํ•˜€ •Šฒ €งŒ(ƒ„ž, ํŒŒดดž ƒฐํ•ด ณดฉด งด€), จ„ˆ˜ žˆŠ”ฐ ํ•œฒˆ ํ•ดณดž.
~cpp 
    void *rawMemory = operator new(sizeof(string));

string ฐฒด€ ํ•„š”กœ ํ•˜Š” ฉ”ชจฆฌ งŒํด ํ• ‹œ‹ค. ํ•˜€งŒ œ„˜ ˜ฒ˜Ÿ malloc, operator newŠ” ƒ„ž ํ˜ธถœํ•˜€Š” •–Š”‹ค. ƒ„ž˜ ํ˜ธถœ€ new operator ชซด‹ค.

new operator ณดฉด
~cpp 
    string *ps = new string("Memory Management");
‹คŒ ฐ™€ ฝ”“œŠ” ปดํŒŒŸฌ ‹จ—„œ ด ‡ฒŒ ตฒดœ‹คณ  ˆ˜ žˆ‹ค.
~cpp 
    void *memory = operator new(sizeof(string));

    call string::string("Memory Management") on *memory;

    string *ps = static_cast<string*>(memory);

ํ•ด‹ ฝ”“œ ‘ฒˆงธ €„˜ ƒ„ž ํ˜ธถœ„ ˆˆ—ฌฒจ ด.

  • Placement new
‹‹ € ƒ„ž ง ‘ ํ˜ธถœํ•˜ธฐ ›ํ• •Œ€ žˆ„ ฒƒด‹ค. ํ•˜€งŒ ƒ„žŠ” ฐฒด(object) ดˆธฐํ™” ‹œํ‚คณ , ฐ œ(object)Š” ˜คง ฒ˜Œ –ด€Š” ‹จ ํ•œฒˆ˜ ฐ’œกœ ดˆธฐํ™” ˜–ด งˆˆ˜žˆธฐ •Œฌธ— (˜ˆ-const ธˆ˜“ค ดˆธฐํ™”— ดˆธฐํ™” ฆฌŠคํŠธ “ฐŠ” ฒฝšฐ) ƒ„ž ดกดžฌํ•˜ณ  žˆŠ” ฐฒด— ํ˜ธถœํ•œ‹คŠ”ƒฐ˜ —ฌ€€ —†„ ฒƒด‹ค.

ทธ ‡€งŒ —ฌŸฌ„ด raw memoryกœ ฐฒด ํ• ‹ํ•œ‹คฉด ดˆธฐํ™” ฃจํ‹ดด ํ•„š”ํ•˜‹ค.

(—ฌ‹ด-ํ›„ํ›„ ‚˜„ ƒ‹จ˜ operator new ณดŠ” ˆœ„ ด ƒฐํ–ˆ‹ค.)

ฐ”กœ operator new˜ ํŠํ™” „ „ธ placement newกœ ํ• ˆ˜ žˆ‹ค.

‹คŒ€ placement new ‚ฌšฉํ•œ ˜ˆ œด‹ค.
~cpp 
    cass Widget {
        public:
            Widget(int widgetSize);
            ...
    };
    Widget* constructWidgetInBuffer(void * buffer, int widgetSize)
    {
        return new(buffer) Widget(widgetSize);
    }

ํ•ด‹ ํ•จˆ˜(construcWidgetInBuffer())Š” „ํ— งŒ“ค–ด„ Widget ฐฒด˜ ํฌธํ„ ฐ˜ํ™˜ํ•˜—ฌ €‹ค. ด ‡ฒŒ ํ˜ธถœํ•  ฒฝšฐ ฐฒด ž„˜ œ„˜— ํ• ‹ํ• ˆ˜ žˆŠ” Šฅ ฅ •Œฌธ— shared memory‚˜ memory-mapped I/O ตฌํ˜„— šฉดํ•˜‹ค constructorWidget— ณดดŠ”ฐ”กœ
~cpp 
    return new (buffer) Widget(widgetSize);
ด ฌธธฐ , •„งˆ ฒ˜Œ ณดธฐ— ƒ†Œํ•  ฒƒด‹ค. ž„ธํžˆ œ–ด ณดฉด, (buffer)— ˜ํ•ด„œ •”‹œ œกœ newŠ” operator newกœ ํ˜ธถœ˜–ด „‹ค. งถ™—ฌ, •„ž˜˜ void*Š” ฉ”ชจฆฌ ƒ˜ œ„˜ size_tŠ” ฉ”ชจฆฌƒ ฐฒด€ ฐจ€ํ•˜Š” ˜—ญด‹ค. ž, œ„™€ „ตํ•ด ณด ด operatorŠ” new overloadํ•œ „ „ด‹ค.
~cpp 
    void* operator new(size_t, void *location)
    {
        return location;
    }

ด„‹จํžˆ ณดด€งŒ placement new˜  „€ด‹ค. operator new˜ —ญํ• € ํ•ด‹ ฐฒด œ„ํ•œ ฉ”ชจฆฌ ฐพณ (ํ• ‹), ํ•ด‹ ํฌธํ„˜ ฐ˜ํ™˜ดณ  placement new˜ ฒฝšฐ—Š” ํ˜ธถœž€ ดฉ”ชจฆฌ ํ™•ณดํ•˜˜€ณ , ‹จˆœํžˆ ํฌธํ„ฐ˜ํ™˜งŒ ํ•ด€‹ค. ชจ“  placement new€ ฐ˜“œ‹œ ดŸฐ pointer˜  „‹ฌ —ญํ• „ ํ•œ‹ค. ทธฆฌณ  size_t ธž€ •„ฌดŸฐ ด„ด —†–ด„ ฐ˜ํ•ญ •ˆํ•œ‹ค. ž„ธํ•œด Item 6„ ณดฉด ดํ•ด€ ฐˆฒƒด‹ค.

ดŸฐ placement newŠ” C++ ํ‘œ€ ดธŒŸฌฆฌ˜ ํ•œ €„œกœ placement new “ฐณ ž ํ•œ‹คฉด #include<new> ํ•ดฉด œ‹ค.

  • new ฒฐก !
žž new ฒฐก ด‹ค.

the new operator : heap ฉ”ชจฆฌ ํ™•ณด™€ ƒ„ž ํ˜ธถœ ™‹œ—

operator new : ํ•ด‹ ฐฒด˜ ฉ”ชจฆฌ ํ™•ณดงŒ

placement new : ดธ ํ™•ณด ฉ”ชจฆฌ€ กดžฌํ•˜ณ  ฐฒด ดˆธฐํ™” ›ํ•œ‹คฉด

ด‹ค –ด„คํ”„ฒŒ  •ฆฌํ–ˆณ  ฐจํ›„ ถ”€ ํ• ฒƒด‹ค.

  • Deletion and Memory Deallocation
™  ํ• ‹— Œ€ํ•˜—ฌ ฆฌ†ŒŠค ƒˆŠ”ฐฉ€ํ•  คฉด ํ•ด‹ ™  ํ• ‹— ƒ‘ํ•˜Š” ‘ง•(?)ด ํ•„š”ํ•  ฒƒด‹ค. ˜ˆ“ค–ด„œ new‚˜ operator new—Š” ดŸฐ
~cpp 
    string *ps;
    ...
    delete ps;      // delete operator  ‚ฌšฉํ•œ‹ค.
‹‹ ด “ฐณ  žˆŠ” ปดํŒŒŸฌŠ” ฐฒด ps point ํŒŒดดํ•˜ณ  ฐฒด€ €€ณ  žˆŠ” ฉ”ชจฆฌ ํ•ด œํ•œ‹ค.

ฉ”ชจฆฌ ํ•ด œ(deallocaion)€ operator deleteํ•จˆ˜— ํ–‰ํ•ด€Š”ฐ ฐ˜ œกœ ด ‡ฒŒ „ –ธ˜–ด žˆ‹ค.
~cpp 
    void operator delete(void * memoryToBeDeallocated);
ทธŸฌ€กœ
~cpp 
    delete ps;
Š” ดŸฐ ฝ”“œ€ ˆ˜ํ–‰œ‹คณ  ณดฉด œ‹ค.
~cpp 
    ps->~string();
    operator delete(ps);
(ž‘„ž : ดกœ new™€ delete˜ ํ™˜ƒ,‹ „„ด กŒ‹ค. )

ทธฆฌณ  ดฒƒ˜ ˜Š” ‹‹ ด ดˆธฐํ™” ˜€ •Š€ rawกœ˜ ‚ฌšฉ˜ ฒฝšฐ—Š” new™€ delete operatorกœ ทธƒฅ „˜ฒจ• ํ•œ‹คŠ” ˜€ œ‹ค. ฆ‰ ดฝ”“œ Œ€‹ — ‹คŒ˜ ˜ˆ ˆ˜ žˆ„ ฒƒด‹ค.
~cpp 
    void * buffer = operator new(50*iszeof(char));
    ...
    operator delete(buffer);
œ„˜ ฝ”“œŠ” C++ƒ—„œ malloc free ํ˜ธถœ ฒƒ ™ํ•œ —ญํ• „ ํ•œ‹ค.

ทธ ‡‹คฉด, ดฒˆ— ‹‹ € placement new ‚ฌšฉํ•ด„œ ฉ”ชจฆฌƒ— ฐฒด งŒ“ค—ˆ‹คฉด delete ‚ฌšฉํ• ˆ˜ —†„ Š” ˜ˆธก„ ํ• ˆ˜ žˆ„ ฒƒด‹ค. ž ‹คŒ ฝ”“œ ณดฉด„œ ช…‹œ ธ delete ํ–‰ํ•˜Š” ฝ”“œ“ค„ ณดž
~cpp 
    void * mallocShared(size_t size);
    void freeShared(void *memory);

    void *shareMemory = mallocShared(sizeof(Widget));
    Widget *pw = constructWidgetInBuffer(shareMemory, 10);  // placement newด‹ท!

    ...
    delete pw;  // ด ‡ฒŒ ํ•ด„œŠ” •ˆœ‹ค. sharedMemoryŠ” mallocShared—„œ ํ• ‹˜Š”ฐ –ดฐŒ ํ• ˆ˜ žˆœฆฌš”.
                // ทธ ‡‹คฉด ‹คŒ ฐ™€ ฝ”“œกœ ํ•ด• ํ•œ‹ค.

    pw->~Widget();  //  € ž„˜กœ ํŒŒดดž ํ˜ธถœํ•œ‹ค. ด ‡ฒŒ ํ•˜ฉด pw € จœ ž›„ ฐ˜ํ™˜ํ• ฒƒดณ .
    freeShared(pw); // ตœข… œกœ pw€ ํ• ‹œ ฉ”ชจฆฌ ˜—ญ„ ํ•ด œ ‹œํ‚จ‹ค.

  • Arrays
„‹คฅธ ํŠ„ํ•œ € ‚ฌํ•ญด —†‹ค. —ฌํƒœ Œ€˜ —ฐžฅ„ ดณ  ‹จ new ดšฉํ•œ ฐฐ—ด ํ• ‹„ ‚ญ œํ•  ฒฝšฐ
~cpp 
    string *ps = new string[10];
    delete [] ps;
™€ ฐ™ด ง„ งžถ”–ด –ด• ํ•œ‹ค. placementŠ” ‹ œ„˜ €‹œ ‚ฌํ•ญ— ”ฐฅดŠ” ฒƒดณ  operator deleteŠ” item 6—„œ™€ ฐ™ด forฌธœกœ ˆœํšŒํ•˜ฉด„œ €›Œ –ด• ํ•œ‹ค.

งˆ€ง‰œกœ —ฌธฐ„œ ณด‹ค ‹œํ” new™€ delete งŒ“œŠ” žฒดŠ” ‹‹ ด กฐ • ํ• ˆ˜ —†Š” ˜—ญ— กดžฌํ•˜€งŒ ฉ”ชจฆฌ ํ• ‹€ ‹‹ ˜ †•„ž˜ žˆ‹ค. new™€ delete ตœ ํ™”‚˜ ˆ˜ • ํ• •Œ ธฐ–ตํ•ด ‹‹ ด  •งกœ ทธธ ํ• ˆ˜ —†Š”€— €ํ•ด„œ งด‹ค. ‹‹ € ทธฒƒ“ค˜ ฐฉฒ•(new,deleteฉ”ชจฆฌ ํ• ‹ ฐฉฒ•)€ €ฒฝํ• ˆ˜ žˆ‹ค. ทธŸฌ‚˜ ทธ“ค€ –ธ–ด— ˜ํ•ด„œ ทœ •˜–ด  ธ žˆŠ” ˜—ญด‹ค.


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