More EffectiveC++/Miscellany

~cpp 
class B { ... };	// 가상 파괴자가 없다.
class D: public B { ... } 
    B *pb = new D;

~cpp 
delete pb;	// 자, 당신은 B에서 가상 생성자가 필요하다. 안그런가?

~cpp 
class String {
public:
    ~string();
};
class B { ... }

~cpp 
class D: public B{
    string name;
};

~cpp 
auto_ptr<String> ps(String::makeString("Future tense C++"));
...	// 이제 해당 객체는 포인터처럼 다룬다. 하지만 delete를 부르지 말아야 한다.

~cpp 
String s("Future tense C++");

~cpp 
 class Animal {
public:
	Animal& operator=(const Animal& rhs);
	...
};

class Lizard: public Animal {
public:
	Lizard& operator=(const Lizard& rhs);
	...
};

class Chicken: public Animal {
public:
	Chicken& operator=(const Chicken& rhs);
	...
};

~cpp 
    Lizard liz1;
    Lizard liz2;
    Animal *pAnimal1 = &liz1;
    Animal *pAnimal2 = &liz2;
    ...
    *pAnimal1 = *pAnimal2;

~cpp 
class Animal {
public:
    virtual Animal& operator=(const Animal& rhs);
    ...
};
class Lizard: public Animal {
public:
    virtual Lizard& operator=(const Animal& rhs);
    ...
};
class Chicken: public Animal {
public:
    virtual Chicken& operator= (const Animal& rhs);
    ...
};

~cpp 
Lizard liz;
Chicken chick;

Animal *pAnimal1 = & liz;
Animal *pAnimal2 = & chick;
...
*pAnimal1 = *pAnimal2;  // chicken을 lizard에 할당한단 말이다.!

~cpp 
Animal *pAnimal1 = &liz1;
Animal *pAnimal2 = &liz2;
...
*pAnimal1 = *pAnimal2;      // 통과를 원해요! 같은 형이므로

~cpp 
Animal *pAnimal1 = &liz;
Animal *pAnimal2 = &chick;
...
*pAnimal1 = *pAnimal2;      // 안되길 원해요~

~cpp 
Lizard& Lizard::operator=(const Animal& rhs)
{
    // lizard가 진짜 rhs가 맞는가?
    const Lizard& rhs_liz = dynamic_cast<const Lizard&>(rhs);

    *this에 rhs_liz의 일반적인 할당과정 수행을 한다.
}

~cpp 
Lizard liz1, liz2;
...
liz1 = liz2;    // dynamic_cast가 필요로 하지 않다. 이건 반드시 옳다.

~cpp 
class Lizard: public Animal {
public:
    virtual Lizard& operator=(const Animal& rhs);
    Lizard& operator=(const Lizard& rhs);           // 더한 부분
    ...
};

Lizard liz1, liz2;
...
liz1 = liz2;                    // const Lizard&를 인자로 하는 operator= 호출

Animal *pAnimal1 = &liz1;
Animal *pAnimal2 = &liz2;
...
*pAnimal1 = *pAnimal2;      // const Ainmal&인자로 가지는 operator= 연산자 호출

~cpp 
Lizard& Lizard::operator=(const Animal& rhs)
{
    return operator=(dynamic_cast<const Lizard&>(rhs));
}

~cpp 
class Animal {
private:
    Animal& operator=(const Animal& rhs);       // 사역(private)이다.
    ...
};

class Lizard: public Animal {
public:
    Lizard& operator=(const Lizard& rhs);
    ...
};

class Chicken: public Animal {
public:
    Chicken& operator=(const Chicken& rhs);
    ...
};

Lizard liz1, liz2;
...
liz1 = liz2;                    // 옳바르다.

Chicken chick1, chick2;
...
chick1 = chick2;                // 역시 옳바르다.

Animal *pAnimal1 = &liz1;
Animal *pAnimal2 = &chick1;
...
*pAnimal1 = *pAnimal2;          // 에러! Animal::operator=가 사역이라 에러난다.

~cpp 
Animal animal1, animal2;
...
animal1 = animal2;      // 에러! Animal::operator=가 사역(private)이다.

~cpp 
Lizard& Lizard::operator=(const Lizard& rhs)
{
    if (this == &rhs) return *this;

    Animal::operator=(rhs);     // 에러! 사역(private) 인자의 함수를 호출하는 시도를 한다.
                                // 하지만 Lizard::operator=는 반드시 이 함수를 Animal 부분
                                // 의 할당을 위해 호출해야 한다.
    ...
}    

~cpp 
class AbstractAnimal {
protected:
    AbstractAnimal& operator=(const AbstractAnimal& rhs);
public:
    virtual ~AbstractAnimal() = 0;        // 이에 관해서는 설명에 자세히
    ...
};

class Animal: public AbstractAnimal {
public:
    Animal& operator=(const Animal& rhs);
    ...
};

class Lizard: public AbstractAnimal {
public:
    Lizard& operator=(const Lizard& rhs);
    ...
};

class Chicken: public AbstractAnimal {
public:
    Chicken& operator=(const Chicken& rhs);
    ...
};

~cpp 
typedef basic_string<char> string;

~cpp 
template<class charT,
        class traits = string_char_traits<charT>,
        class Allocator = allocator>
    class basic_string;