• Item 16:80-20 규칙을 기억해라.
  
  

• Item 17:lazy evaluation의 쓰임에 대하여 생각해 보자.
  
  

• Item 18: 예상되는 연산의 값을 계산해 두어라.
  
  

~cpp 
    template<class NumericalType>
    class DataColletion {
    public:
        NumericalType min() const;
        NumericalType max() const;
        NumericalType avg() const;
        ...
    }

~cpp 
    int findCubicleNumber(const string& employeesName)
    {
        // static으로 map을 선언하는 과정 이 맵이 local cashe이다.
        typedef map<string, int> CubicleMap;
        static CubicleMap cubes;

        // 해당 직원 이름을 바탕으로 cache에서 찾는 과정
        // STL interator "it"은 해당 entry를 찾는다.
        CubicleMap::iterator it = cubes.find(employeeName);

        // 만약 아무런 entry를 찾을수 없다면, "it"의 값은 cubes.end이다.
        // 그런 경우에는 db에서 자료를 가지고 와야 한다.
        if(it == cubes.end()){
            int cubicle = 
                   직원 이름의 개인방 번호를 데이터 베이스에서 
                   얻어오는 과정
            
            cubes[employeeName] = cubicle;  // 추가
            return cubicle;
        }
        else {
            // "it" 포인터는 정확한 cache entry를 가리키며 cubicle번호는 두번째 인자라
            // 이런 방법으로 얻는다.
            return (*it).second;
        }
    }

~cpp 
    template<class T>           // 동적 배열 T에 관한 클래스 템플릿
    class DynArray { ... };

    DynArray<double> a;         // 이런 관점에서 a[0]은 합법적인 
                                // 배열 인자이다.
    a[22] = 3.5;                // a는 자동적으로 확장되었으며, 
                                // 현재는 0-22까지의 영역을 가진다.

    a[32] = 0;                  // 다시 확장되며 이제 0-32까지다.

~cpp 
templace<class T>
T& DynArray<T>::operator[](int index)
{
    if (index < 0) {
        예외를 던진다.;
    }
    if (index > 현재 인덱스의 최대값){
        new를 호출해서 충분한 메모리를 확보한다.  그렇게 해서 index를 활성화 시킨다.;
    }
    return 배열의 인덱스 인자를 반환한다.

~cpp 
    template<class T>
    T& DynArray<T>::operator[](int index)
    {
        if (index < 0) 예외를 던진다.;
        if (index > 현재 인덱스의 최대값){
            int diff = index - 현재 인덱스의 최대값;
            알맞은 메모리를 할당한다. 그래서 index+diff가 유효하게 한다.
        }
        return 현재 인덱스가 가리키는 인자;
    }

~cpp 
DynArray<double> a;     // 오직 a[0]만이 유효하다.
a[22] = 3.5;            // 현재 index 44정도의 저장 공간을 
                        // 할당하며 a의 논리적 공간은 23이다.
a[32] = 0;              // a의 논리적 공간은 이제 a[32]이다. 하지만 
                        // 44의 저장공간이 있기에 확장하지 않는다.

• Item 19:임시 객체들의 기본을 이해하자.
  
  

~cpp 
template<class T>
void swap(T& object1, T& object2)
{
    T temp = object;
    object1 = object2;
    object2 = temp;
}

~cpp 
    // 다음 함수는 str안에서 ch가 몇게 있는가 반환한다.
    size_t countChar(const string& str, char ch);
    char buffer[MAX_STRING_LEN];
    char c;
    // string과 char를 받아 들인다. setw 는 글자를 읽을때 
    // 오버 플로우(overflow)를 방지하는 목적으로 쓰인다.
    cin >> c >> setw(MAX_STRING_LEC) >> buffer;
    cout << "There are " << countChar(buffer, c)
         << " occurrences of the charcter " << c
         << " in " << buffer << endl;

~cpp 
    void uppercasify(string& str);      // str의 모든 글자를 대문자료 바꾼다.

~cpp 
    char subtleBookPlug[] = "Effective C++";
    uppercasify(subtleBookPlug);        // 에러다!

~cpp 
const Number operator+(const Number& lhs, const Number &rhs);

• Item 20: 반환되는 값을 최적화 하라
  
  

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

    // 반환 값이 왜 const 인지는 Item 6을 참고하라
    const Rational operator* (const Rational& lhs, const Rational& rhs);

~cpp 
    // 이러한 객체의 반환은 피해야할 방법이다.
    const Rational* operator* (const Rational& lhs, const Rational& rhs);
    const Rational a = 10;
    Rational b(1,2);
    Rational c = *(a * b);    // 이것이 "자연스러운" 것일까?

~cpp 
    // 객체의 반환을 피하기에는 위험하고 옳바르지 않은 방법이다.
    const Rational& operator* (const Rational& lhs, const Rational& rhs);
    const Rational a = 10;
    Rational b(1,2);
    Rational c = a * b;    // 보기에는 완전해 보인다.

~cpp 
    // 객체를 반환하는 또 다른 멍청하고 위험한 방법이다.
    const Rational& operator*(const Rational& lhs, const Rational& rhs)
    {
        Rational result(lhs.numerator() * rhs.numerator(), lhs.denominator(), rhs.denominator());
        return result;
    }

~cpp 
// 객체를 반환하는 함수에 관하여 효율적이고 정확한 적용을 위해 다음과 같이 한다.
const Rational operator*(const Rational& lhs, const Rational& rhs)
{
    return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
}

~cpp 
    Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());

~cpp 
    Rational a = 10;
    Rational b(1,2);
    Rational c = a * b;

~cpp 
    inline const Rational operator* (const Rational& lhs, const Rational& rhs)
    {
        return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
    }

• Item 21: 암시적(implicit) 형변환의 overload를 피하라
  
  

~cpp 
    class UPInt {
    public:
        UPInt();
        UPInt(int value);
        ...
    };
    const UPInt operator+( const UPInt& lhs, const UPInt& rhs);

    UPInt upi1, upi2;
    ...
    UPInt upi3 = upi1 + upi2;

• Item 22: 혼자 쓰이는 op(+,-,/) 대신에 op=(+=,-=,/=)을 쓰는걸 생각해 봐라.
  
  

~cpp 
    x = x + y;      x = x - y;

~cpp 
    x += y;         x -= y;

• Item 23: 라이브러리 교체에 관해서 생각해 봐라.
  
  

• Item 24: 가상 함수, 다중 상속, 가상 기초 클래스, RTTI(실시간 형 검사)에 대한 비용을 이해하라.