[Effective C++] Chapter 1. C++에 왔으면 C++의 법을 따릅시다

// 헤더 파일

class CostEstimate
{
private:
    // static const 멤버의 선언과 초기화
    static const double FudgeFactor = 1.35;  
};

// 구현 파일

// 구식 컴파일러의 경우 정의에서 초기값을 준다. 
const double CostEstimate::FudgeFactor = 1.35;  

class GamePlayer
{
private:
    enum { NumTurns = 5; }  // 나열자 둔갑술
    int scores[NumTurns];   // (O)
};

int a = 5, b = 0;

CALL_WITH_MAX(++a, b);       // a가 두 번 증가힌다. 
CALL_WITH_MAX(++a, b + 10);  // a가 한 번 증가힌다. 

template<typename T>
inline void callWithMax(const T& a, const T& b)
{
    f(a > b ? a : b);
}

char greeting[] = "Hello";

char *p = greeting;               // 비상수

const char *p = greeting;         // 상수 데이터
char const *p = greeting;         // (이렇게 쓸 수도 있다)

char * const p = greeting;        // 상수 포인터

const char * const p = greeting;  // 상수 포인터, 상수 데이터

std::vector<int> vec;

// T * const와 같다. (상수 포인터)
const std::vector<int>::iterator iter = vec.begin();
*iter = 10;

// const T * 와 같다. (상수 데이터)
std::vector<int>::const_iterator iter = vec.begin();
++iter;

class Rational {};

const Rational operator*(const Rational& lhs, const Rational& rhs);
// 맨앞에 const는

Rational a, b, c;
(a * b) = c;  // (X)
// 이런 말도 안되는 상황을 막는다. 

class TextBlock
{
private:
    char* text;

public:
    // 비상수 객체에 대한 operator[]
    char& operator[](std::size_t position)
    {
        return text[position];
    }

    // 상수 객체에 대한 operator[]
    // 맨뒤의 const로 상수 객체에서 이 함수를 호출할 수 있게된다.
    //                또한 이 함수 내에서 객체를 변경할 수 없다. 
    // 맨앞의 const로 대입이 불가능하게 된다.
    //                ctb[0] = 'x'; 가 안 된다. 
    const char& operator[](std::size_t position) const
    {
        return text[position];
    }
};

void print(const TextBlock& ctb)
{
    cout << ctb[0];  // 상수 객체이므로, const 버전으로 호출한다.
}

class TextBlock
{
private:
    char* text;

    mutable std::size_t textLength;
    mutable bool lengthIsValid;

public:
    std::size_t length() const // const 멤버 함수지만
    {
        if (!lengthIsValid)
        {
            // mutable로 선언된 데이터 멤버들은 수정할 수 있다. 
            textLength = std::strlen(text);
            lengthIsValid = true;
        }

        return textLength;
    }
}

class TextBlock
{
private:
    char* text;

public:
    char& operator[](std::size_t position)
    {
        // const 버전을 호출한다. 
        return const_cast<char&>( static_cast<const TextBlock&>(*this)[position] );
    }

    const char& operator[](std::size_t position) const
    {
        // 여러가지 잡다한 작업들
        // ...

        return text[position];
    }
};

class PhoneNumber {};

class ABEntry
{
private:
    // 여기에 선언된 순서로 초기화된다. 
    std::string theName;
    std::string theAddress;
    std::list<PhoneNumber> thePhones;
    int numTimesConsulted;

public:
    ABEntry(const std::string& name, const std::string address,
        const std::list<PhoneNumber>& phones);
};

// 이것은 대입이다. 초기화가 아니다. 
ABEntry::ABEntry(const std::string& name, const std::string address,
    const std::list<PhoneNumber>& phones)
{
    theName = name;
    theAddress = address;
    thePhones = phones;
    numTimesConsulted = 0;
}

// 멤버 초기화 리스트를 사용해서 초기화한다. 
ABEntry::ABEntry(const std::string& name, const std::string address,
    const std::list<PhoneNumber>& phones)
        : theName(name), theAddress(address), thePhones(phones), numTimesConsulted(0)
{ }

class FileSystem
{
public:
    std::size_t numDisks() const;
};

// 사용자가 쓰게 될 객체이다. 
extern FileSystem tfs;

class Directory
{
public:
    Directory();
};

Directory::Directory()
{
    // tfs 객체를 사용한다.
    std::size_t disks = tfs.numDisks();
}

Directory tempDir();
// 만약 tfs가 먼저 초기화되지 않는다면 큰 문제가 발생할 것이다!

class FileSystem
{
public:
    std::size_t numDisks() const;
};

FileSystem& tfs()  // 클래스 안에 정적 멤버로 들어가도 된다. 
{
    // 지역 정적 객체를 정의한다. 
    static FileSystem fs;
    return fs;
}

class Directory
{
public:
    Directory();
};

Directory::Directory()
{
    // tfs가 tfs()로 바뀌었다. 
    std::size_t disks = tfs().numDisks();
}

Directory& tempDir()
{
    static Directory td;
    return td;
}