1. Techniques ¶

~cpp 
class NLComponent{
public:
    // operator<<의 가상 함수
    virtual ostream& operator<<(ostream& str) const = 0;
    ...
};
class TextBlock:public NLComponent{
public:
    virtual ostream& operator<<(ostream& str) const;
};
class Graphic:public NLComponent{
public:
    virtual ostream& operator<<(ostream& str) const;
};

TextBlock t;
Graphic g;
...
t << cout;

g << cout;

~cpp 
class NLComponent {
public:
  virtual ostream& print(ostream& s) const = 0;
  ...
};

class TextBlock: public NLComponent {
public:
  virtual ostream& print(ostream& s) const;
  ...
};

class Graphic: public NLComponent {
public:
  virtual ostream& print(ostream& s) const;
  ...
};

inline
ostream& operator<<(ostream& s, const NLComponent& c)
{
  return c.print(s);
}

~cpp 
class ColorPrinter: public Printer {
  ...
};

~cpp 
Printer p;
ColorPrinter cp;

~cpp 
class CPFMachine {                           // copy, print, fax 전부 할수 있는 기계
private:                                     
  Printer p;                                 // 프리터 기능의 인자.
  FaxMachine f;                              // 팩스 기능의 인자
  CopyMachine c;                             // 복사기 기능의 인자.

  ...

};

CPFMachine m1;                               // 여기 까지는 잘된다.

CPFMachine m2;                               // TooManyObjects 예외를 발생 시킨다.

~cpp 
class FSA {
public:
  // 가짜 생성자들
  static FSA * makeFSA();   // 생성자
  static FSA * makeFSA(const FSA& rhs); // 복사 생성자
  ...

private:
  FSA();
  FSA(const FSA& rhs);
  ...
};

FSA * FSA::makeFSA()
{ return new FSA(); }

FSA * FSA::makeFSA(const FSA& rhs)
{ return new FSA(rhs); }

~cpp 
// 기본 생성자
auto_ptr<FSA> pfsa1(FSA::makeFSA());

// 복사 생성자
auto_ptr<FSA> pfsa2(FSA::makeFSA(*pfsa1));

...                            // 자 이제 해당 영역을 벗어나면 객체는 자동 파괴된다.

~cpp 
template<class BeingCounted>
class Counted {
public:
    class TooManyObjects{};        // 던질 예외

    static int objectCount() { return numObjects; }

protected:
    Counted();
    Counted(const Counted& rhs);

    ~Counted() { --numObjects; }

private:
    static int numObjects;
    static const size_t maxObjects;

    void init();          // 생성자에 코드 중복을 피한다.(어차피 같은 코드 쓰니까.)
};                                            

template<class BeingCounted>
Counted<BeingCounted>::Counted()
{ init(); }

template<class BeingCounted>
Counted<BeingCounted>::Counted(const Counted<BeingCounted>&)
{ init(); }

template<class BeingCounted>
void Counted<BeingCounted>::init()
{
    if (numObjects >= maxObjects) throw TooManyObjects();
    ++numObjects;
}

~cpp 
class Printer: private Counted<Printer> {
public:
    static Printer * makePrinter();     // 가짜 생성자(pseudo-constructors)
    static Printer * makePrinter(const Printer& rhs);

    ~Printer();

    void submitJob(const PrintJob& job);
    void reset();
    void performSelfTest();
    ...

    using Counted<Printer>::objectCount;     // 왜 사용하는지 아래 참고
    using Counted<Printer>::TooManyObjects;  // 마찬가지~
private:
    Printer();
    Printer(const Printer& rhs);
};

~cpp 
class Printer: private Counted<Printer> {
public:
    ...
    using Counted<Printer>::objectCount;  // 이 함수로 현재 객체의 숫자를 알수 있다.
    ...                                   // 이거 함수다. 착각 마시길. Counted 클래스를 한번 살펴보라.
};

~cpp 
class Printer: private Counted<Printer> {
public:
    ...
    Counted<Printer>::objectCount;  // 이 함수로 현재 객체의 숫자를 알수 있다.
    ...                                   // 이거 함수다. 착각 마시길. Counted 클래스를 한번 살펴보라.
};

~cpp 
Printer::Printer()
{
    일반적인 생성자 과정
}

~cpp 
template<class BeingCounted>                 
int Counted<BeingCounted>::numObjects;  // 객체의 선언과, 자동으로 0으로 초기화가 된다.

~cpp 
const size_t Counted<Printer>::maxObjects = 10;

~cpp 
const size_t Counted<FileDescriptor>::maxObjects = 16;

~cpp 
class UPNumber {
public:
    UPNumber();
    UPNumber(int initValue);
    UPNumber(double initValue);
    UPNumber(const UPNumber& rhs);

    // 가짜 파괴자(pseudo-destructor) 상수 멤버 메소드, 
    // 상수 객체를 제거 할수 있게 하기 때문에
    void destroy() const { delete this; }
    ...
private:
    ~UPNumber();    // 파괴자가 사역(private)으로 선언되었다.
};

~cpp 
UPNumber n;                          // 에러! 파괴자 사역(private)이라 작동 할수 없다.
UPNumber *p = new UPNumber;          // 통과
...
delete p;                            // 에러! 역시 파괴자 사역(private) 이유
p->destroy();                        // 통과

~cpp 
class UPNumber { ... };             // 생성자와 파괴자 모두 사역(private)로 
                                    //선언되었다고 가정한다.

class NonNegativeUPNumber: 
    public UPNumber { ... };        // 에러! 생성자와 파괴자를 컴파일 못한다.

class Asset {
private:
    UPNumber value;                 // 에러! 생성자와 파괴자를 컴파일 못한다.
    ...      
};

~cpp 
class UPNumber { ... };             // 파괴자를 보호(protected)로 설정한다.
                                    // 대신 생성자는 공역(public)으로 설정한다. 
                                    // 기능상 상관 없으므로

class NonNegativeUPNumber:
    public UPNumber { ... };        // 이제는 유도되는 데는 지장 없다.
                                    // 유도되는 클래스들은 protected인자는
                                    // 접근하는데 문제가 없다.

class Asset {
public:
    Asset(int initValue);
    ~Asset();
    ...
private:
    UPNumber *value;                // 위에서의 객체 선언을 포인터로 바꾸었다.
};

Asset::Asset(int initValue)
: value(new UPNumber(initValue))    // 다음과 같이 초기화 리스트로 객체를 만들고
{ ... }

Asset::~Asset()
{ value->destroy(); }                 // 파괴시에 신경써준다.(resource leak방지)

~cpp 
class UPNumber {
private:
    static void *operator new(size_t size);     // 자 이렇게 operator new를
                                                // 사역(private)인자로 만들어 버린다.
    static void operator delete(void *ptr);     // operator delete 역시 마찬가지이다.
    ...
};

~cpp 
UPNumber n1;                         // 맞다.

static UPNumber n2;                  // 이상 없다.

UPNumber *p = new UPNumber;          // 사역(private)인자인 opreator new가 불려서
                                     // 에러가 발생한다.

~cpp 
class UPNumber { ... };             // 위와 같은 코드

class NonNegativeUPNumber:          // 이 클래스에서는 operator new에대한 
    public UPNumber {               // 선언이 없다.
    ...
};

NonNegativeUPNumber n1;             // 이상 없다.

static NonNegativeUPNumber n2;      // 역시 이상 없다.

NonNegativeUPNumber *p =            // 사역(private)인자인 opreator new가 불려서
    new NonNegativeUPNumber;        // 에러가 발생한다.

~cpp 
class Asset {
public:
  Asset(int initValue);
  ...

private:
  UPNumber value;
};

Asset *pa = new Asset(100);     // 맞다.
                                // 이경우 Asset::operator new 나 
                                // ::operator new는 불리지만 
                                // UPNumber::operator new는 불리지 않으므로 올바르게 작동한다.

~cpp 
template<class T>
class auto_ptr {
public:
    auto_ptr(T *ptr = 0): pointee(ptr) {}
    ~auto_ptr() { delete pointee; }         // 가리키는 객체를 파괴한다.
    ...

private:
    T *pointee;
};

~cpp 
auto_ptr<TreeNode> ptn1(new TreeNode);

auto_ptr<TreeNode> ptn2 = ptn1;      // 복사 생성자를 호출했다. 어떤 일이 일어날까?

auto_ptr<TreeNode> ptn3;

ptn3 = ptn2;                         // operator=를 호출했다. 어떤 일이 일어날까?

~cpp 
template<class T>
class auto_ptr {
public:
    ...
    auto_ptr(auto_ptr<T>& rhs);         // 복사 생성자
    auto_ptr<T>&  operator=(auto_ptr<T>& rhs);       // 할당(assignment) 연산자
    ...
};

template<class T>
auto_ptr<T>::auto_ptr(auto_ptr<T>& rhs)
{
    pointee = rhs.pointee;              // 소유권(ownership)을 이양하는 작업
    rhs.pointee = 0;                    // rhs의 소유권(ownership)을 박탈한다.
}

template<class T>
auto_ptr<T>& auto_ptr<T>::operator=(auto_ptr<T>& rhs)
{
    if (this == &rhs)                   // 같은 객체를 가리키는건 1=1 같은 경우밖에 
                                        // 없다. 그러므로 아무런 작업을 하지 않는다.

    delete pointee;                     // 해당 더미(dumb) 포인터가 가리키는 객체를
                                        // 삭제한다.

    pointee = rhs.pointee;              // 소유권(ownership)을 이양한다.
    rhs.pointee = 0;                    // rhs의 소유권(ownership)을 박탈한다.

    return *this;
}

~cpp 
// 값에 의한 전달(by value)로 auto_ptr을 넘긴다.
void printTreeNode(ostream& s, auto_ptr<TreeNode> p)
{ s << *p; }

int main()
{
    auto_ptr<TreeNode> ptn(new TreeNode);
    ...
    printTreeNode(cout, ptn);          // 값에 의한 전달(pass auto_ptr by value)
    ...
}

~cpp 
// 직관적인 예제이다. auto_ptr<TreeNode>를 상수 참조 전달(Pass-by-reference-to-const)하였다.
void printTreeNode(ostream& s, const auto_ptr<TreeNode>& p)
{ s << *p; }

~cpp 
template<class T>
SmartPtr<T>::~SmartPtr()
{
    if (*this 가 가지고 있는 *pointee) {
        delete pointee;
    }
}

~cpp 
SmartPtr<TreeNode> ptn;

...
if (ptn == 0) ...                    // 에러!
if (ptn) ...                         // 에러!
if (!ptn) ...                        // 에러!

~cpp 
template<class T>
class SmartPtr {
public:
    ...
    operator void*();               // 스마트 포인터가 null이면 0를 반환하고returns 0 if the smart
    ...                             // 아니면 0가 아닌 값을 반환한다.
};                                   

SmartPtr<TreeNode> ptn;

...

if (ptn == 0) ...                   // 올바르다.
if (ptn) ...                        // 역시나
if (!ptn) ...                       // 좋왔어! ^^

~cpp 
ifstream inputFile("datafile.dat");

if (inputFile) ...                  // inputFile이 잘 열렸는가에 관해서
                                    // 확인해 본다.

~cpp 
SmartPtr<Apple> pa;
SmartPtr<Orange> po;
...
if (pa == po) ...                   // 이게 컴파일이 된단 말이다!

~cpp 
template<class T>
class SmartPtr {
public:
    ...
    bool operator!() const;            // 스마트 포인터가 null일때 returns true if and only
    ...                                // if the smart ptr is null
};

{{{~c