1. Operator ¶

• Item 5: 사용자 정의 형변환(conversion) 함수에 주의하라!
  
  
• C++는 타입간의 암시적 type casting을 허용한다. 이건 C의 유산인데 예를 들자면 char과 int 에서 short과 double 들이 아무런 문제없이 바뀌어 진다. 그런데 C++는 이것 보다 한수 더떠서 type casting시에 자료를 잃어 버리게 되는 int에서 short과 dougle에서 char의 변환까지 허용한다.
  
  

• 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"

~cpp 

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

Rational r(1,2);
cout << r;                // error!
cout << r.asDouble();     // double로의 전환의 의도가 확실히 전해 진다.

• single-argument constructor 는 더 어려운 문제를 제공한다. 게다가 이문제들은 암시적 형변환 보다 더 많은 부분을 차지하는 암시적 형변환에서 문제가 발생된다.
  

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

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

~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 {
        위의 조건을 만족하지 못하면 이 코드를 수행한다.;
    }

~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 의 형변환인데 역시나 다른사람이 열받는다.

~cpp 
static_cast< Array<int> >(b[p])

~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 );                      // 새로운 선언!
    ...
}

~cpp 
Array<int> a(10);

~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] ) 

• Item 6: prefix와 postfix로의 증감 연산자 구분하라!
  
  

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

~cpp 
    UPint i;
    i++++;                 

~cpp 
    i.operator++(0).operator++(0);

• Item 7: 절대로! &&, ||, ',' 이 연산자들을 overload 하지 말아라
  
  

~cpp 
    char *p;
    ...
    if ((p != 0) && (strlen(p) > 10) ) ...

~cpp 
    int rangeCheck( int index)
    {
        if ((index < lowerBound) || (index > upperBound)) ...
        ...
    }

~cpp 
    if (expression1 && expression2) ...

~cpp 
    1. if (expression1.operator&&(expression2))...   // when operator && is member function.
    2. if (operator&&(expression1 , expression2))... // global function

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

~cpp 
    .                .*                ::                ?:
    new              delete            sizeof            typeid
    static_cast      dynamic_cast      const_cast        reinterpret_cast

~cpp 
    operator new     operator delete
    operator new[]   operator delete[]
    +    -    *    /    %    ^    &    |    ~
    !    =    >    <    +=   -=   *=   /=   &=
    ^=   &=   |=   <<   >>   >>=  <<=  ==   !=
    <=   >=   &&   ||   ++   --   ,    ->*  ->
    ()   []

• Item 8: new와 delete가 쓰임에 따른 의미들의 차이를 이해하라.
  
  

~cpp 
    string *ps = new string("Memory Management");

~cpp 
    void * operator new(size_t size);

~cpp 
    void *rawMemory = operator new(sizeof(string));

~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
  

~cpp 
    cass Widget {
        public:
            Widget(int widgetSize);
            ...
    };
    Widget* constructWidgetInBuffer(void * buffer, int widgetSize)
    {
        return new(buffer) Widget(widgetSize);
    }

~cpp 
    return new (buffer) Widget(widgetSize);

~cpp 
    void* operator new(size_t, void *location)
    {
        return location;
    }

• new 결론!
  

• Deletion and Memory Deallocation
  

~cpp 
    string *ps;
    ...
    delete ps;      // delete operator 를 사용한다.

~cpp 
    void operator delete(void * memoryToBeDeallocated);

~cpp 
    delete ps;

~cpp 
    ps->~string();
    operator delete(ps);

~cpp 
    void * buffer = operator new(50*iszeof(char));
    ...
    operator delete(buffer);

~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
  

~cpp 
    string *ps = new string[10];
    delete [] ps;