More EffectiveC++/Techniques2of3

~cpp 
class String {
public:
    ...                         // String member들 ������
private:
    struct StringValue { ... }; // ������를 ���는 ���������, String��� 값��� ������.
    StringValue *value;         // ������ 구��������� 값
};

~cpp 
class String {
private:
    struct StringValue {
        int refCount;       // ������를 ���기������ ���������
        char *data;         // 값 ���������

        StringValue(const char *initValue);
        ~StringValue();
    };
    ...
};
// StringValue��� 복��� ���������, ���기��� 목록���로 refCount ������ 1로 ���기���
String::StringValue::StringValue(const char *initValue): refCount(1)
{
    data = new char[strlen(initValue) + 1];     // ���로��� 값 ���당(������ ���������기 ������ x
    strcpy(data, initValue);                    // ������링 복���
}
// StringValue��� ���괴���
String::StringValue::~StringValue()
{
    delete [] data;     // ������링 ������
}

~cpp 
class String {
public:
    String(const char *initValue = "");
    String(const String& rhs);
  ...
};

~cpp 
// String��� 복��� ���������, ���기��� 목록���로 StringValue��� 값��� ���당���다.
String::String(const char *initValue): value(new StringValue(initValue))
{}

~cpp 
String s("More Effective C++");

~cpp 
String s1("More Effective C++");
String s2("More Effective C++");

~cpp 
// String ���래������ 복��� ���������, ���기��� 목록���로 StringValue��� ���������를 ���������다.
String::String(const String& rhs): value(rhs.value)
{
    ++value->refCount;  // ������ ���������를 ���린다.
}

~cpp 
String s1("More Effective C++");
String s2 = s1;

~cpp 
class String {
public:
    ~String();
    ...
};
String::~String()
{
    if (--value->refCount == 0) delete value;   // ������ ���������가 1��� ������
}

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

~cpp 
s1 = s2;

~cpp 
String& String::operator=(const String& rhs)
{
    if (value == rhs.value) {           // ���미 두 객���가 같��� 값��� 가리���다면,
        return *this;                   // �������� ��������� ���다.
    }                                     

    if (--value->refCount == 0) {       // ������ 값��� ������ ������ ���무�� ���������고
        delete value;                   // ������ ���다면 ������ ���다.
    }
    value = rhs.value;                  // ���료를 공������다.
    ++value->refCount;                  // ������ ���������를 ���린다.
    return *this;                       // ������ ��������� --+
}

~cpp 
String s1 = "Hello";
char *p = &s1[1];

~cpp 
String s2 = s1;

~cpp 
p = 'x';                     // ��� 것��� s1, s2를 모두 변경!

~cpp 
class String {
private:
    struct StringValue {
        int refCount;
        bool shareabl;              // ��� ������가 더��� ���다.
        char *data;
        StringValue(const char *initValue);
        ~StringValue();
    };
    ...
};
String::StringValue::StringValue(const char *initValue)
:   refCount(1),
    shareable(true)                 // ���기���������는 공���를 ���락���다.
{
    data = new char[strlen(initValue) + 1];
    strcpy(data, initValue);
}
String::StringValue::~StringValue()
{
    delete [] data;
}

~cpp 
String::String(const String& rhs)
{
  if (rhs.value->shareable) {       // 공���를 ���락��� 경���
    value = rhs.value;
    ++value->refCount;
  }
  else {                            // 공���를 ���부��� 경���
    value = new StringValue(rhs.value->data);
  }
}

~cpp 
char& String::operator[](int index)
{
    if (value->refCount > 1) {
        --value->refCount;
        value = new StringValue(value->data);
    }
    value->shareable = false;           // ������ ���료��� 공���를 ��������다.
    return value->data[index];
}

~cpp 
class RCObject {
public:
    RCObject();
    RCObject(const RCObject& rhs);
    RCObject& operator=(const RCObject& rhs);
    virtual ~RCObject() = 0;

    void addReference();
    void removeReference();
    void markUnshareable();
    bool isShareable() const;
    bool isShared() const;
private:
    int refCount;
    bool shareable;
};

~cpp 
RCObject::RCObject()
: refCount(0), shareable(true) {}

RCObject::RCObject(const RCObject&)
: refCount(0), shareable(true) {}

RCObject& RCObject::operator=(const RCObject&)
{ return *this; }

RCObject::~RCObject() {}                // ���괴���는 그것��� ������ 가��� ������라��
                                        // ������ 구���되��� ��������� ���다.

void RCObject::addReference() { ++refCount; }

void RCObject::removeReference()
{   if (--refCount == 0) delete this; }

void RCObject::markUnshareable()
{ shareable = false; }

bool RCObject::isShareable() const
{ return shareable; }

bool RCObject::isShared() const
{ return refCount > 1; }

~cpp 
sv1 = sv2;          // ���떻게 sv1과 sv2��� ������ ���������가 ������ �����까?

~cpp 
class String {
private:
  struct StringValue: public RCObject {
    char *data;

    StringValue(const char *initValue);
    ~StringValue();

  };

...

};

String::StringValue::StringValue(const char *initValue)
{
  data = new char[strlen(initValue) + 1];
  strcpy(data, initValue);
}

String::StringValue::~StringValue()
{
  delete [] data;
}

~cpp 
class String {
private:
  struct StringValue: public RCObject { ... };
  StringValue *value;                // ��� String��� 값
  ...
};

~cpp 
// T 객���를 가리���기 ������ �������� ��������� ���래��� ������릿
// ���기������ T는 RCObject나, ���것��� ������ ��는 ���래������다.
template<class T>
class RCPtr {
public:
    RCPtr(T* realPtr = 0);
    RCPtr(const RCPtr& rhs);
    ~RCPtr();
    RCPtr& operator=(const RCPtr& rhs);
    T* operator->() const;              // Item 28 ���고
    T& operator*() const;               // Item 28 ���고
private:
    T *pointee;                         // ���래��� ���������를 가리���기������
                                        // 더미(dumb) ��������� pointer this
    void init();                        // 보������ ���기��� 루���
};

~cpp 
template<class T>
RCPtr<T>::RCPtr(T* realPtr): pointee(realPtr)
{
    init();
}
template<class T>
RCPtr<T>::RCPtr(const RCPtr& rhs): pointee(rhs.pointee)
{
    init();
}
template<class T>
void RCPtr<T>::init()
{
    if (pointee == 0) {                // 만��� 더미(dumb)���������가 null���라면
        return;                          
    }
    if (pointee->isShareable() == false) {      // 공���를 ������������ ������면
        pointee = new T(*pointee);              // 복���를 ���다.     
    }
    pointee->addReference();             // ���로��� ������ ���������를 ���린다.
}

~cpp 
pointee = new T(*pointee);

~cpp 
class String {
private:
    struct StringValue: public RCObject {
        StringValue(const StringValue& rhs);
        ...
    };
    ...
};
String::StringValue::StringValue(const StringValue& rhs)
{
    data = new char[strlen(rhs.data) + 1];      // ��� 부����� deep copy��� 
    strcpy(data, rhs.data);                     // ������ 부�����다.
}

~cpp 
class String {
private:
  struct StringValue: public RCObject { ... };
  struct SpecialStringValue: public StringValue { ... };
  ...
};

~cpp 
pointee = new T(*pointee);      // T 는 StringValue���다, ������만 
                                // pointee가 가리���는��� SpecialStringVale���다.

~cpp 
template<class T>
RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs)
{
    if (pointee != rhs.pointee) {       // 둘��� 같��� 객���를 공������면 
                                        // ���당��� ���략���다.
        if (pointee) {
            pointee->removeReference(); // ������ ������ 객��� ������ ��������� 감��� or ���괴
        }
        pointee = rhs.pointee;          // 가리���는 ������를 ���긴다.
        init();                         // 공���가 ��가능 ���경���는 ���료를 
                                        // ���������고, ������되���든 ������를 ���가
    }
    return *this;
}

~cpp 
template<class T>
RCPtr<T>::~RCPtr()
{
    if (pointee)pointee->removeReference(); // ��������� ���괴됨
}

~cpp 
template<class T>
T* RCPtr<T>::operator->() const { return pointee; }
template<class T>
T& RCPtr<T>::operator*() const { return *pointee; }

~cpp 
template<class T>
class RCIPtr {
public:
    RCIPtr(T* realPtr = 0);
    RCIPtr(const RCIPtr& rhs);
    ~RCIPtr();

    RCIPtr& operator=(const RCIPtr& rhs);

    const T* operator->() const;                // ���명과 구��� ���드를 보���.
    T* operator->();                            //  ''
    const T& operator*() const;                 //  ''
    T& operator*();                             //  ''

private:
    struct CountHolder: public RCObject {
        ~CountHolder() { delete pointee; }
        T *pointee;
    };

    CountHolder *counter;

    void init();
    void makeCopy();                                // 구��� ���드를 보���.
};

template<class T>
void RCIPtr<T>::init()
{
    if (counter->isShareable() == false) {
        T *oldValue = counter->pointee;
        counter = new CountHolder;
        counter->pointee = new T(*oldValue);
    }

    counter->addReference();
}

template<class T>
RCIPtr<T>::RCIPtr(T* realPtr)
: counter(new CountHolder)
{
    counter->pointee = realPtr;
    init();
}

template<class T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs)
: counter(rhs.counter)
{ init(); }

template<class T>
RCIPtr<T>::~RCIPtr()
{ counter->removeReference(); }

template<class T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs)
{
    if (counter != rhs.counter) {
        counter->removeReference();
        counter = rhs.counter;
        init();
    }
    return *this;
}

template<class T>
void RCIPtr<T>::makeCopy()                 // copy-on-write ��������� 구���
{
    if (counter->isShared()) {
        T *oldValue = counter->pointee;
        counter->removeReference();
        counter = new CountHolder;
        counter->pointee = new T(*oldValue);
        counter->addReference();
    }
}

template<class T>                           // const ���근;
const T* RCIPtr<T>::operator->() const      // copy-on-write를 ��감������
{ return counter->pointee; }

template<class T>                           // non-const ���근
T* RCIPtr<T>::operator->()                  // copy-on-write 감���
{ makeCopy(); return counter->pointee; }

template<class T>                           // const ���근;
const T& RCIPtr<T>::operator*() const       // copy-on-write를 ��감������
{ return *(counter->pointee); }

template<class T>                           // non-const ���근
T& RCIPtr<T>::operator*()                   // copy-on-write 감���
{ makeCopy(); return *(counter->pointee); }

~cpp 
class Widget {
public:
    Widget(int size);
    Widget(const Widget& rhs);
    ~Widget();
    Widget& operator=(const Widget& rhs);
    void doThis();
    int showThat() const;
};

~cpp 
class RCWidget {
public:
    RCWidget(int size): value(new Widget(size)) {}
    void doThis() { value->doThis(); }                  // delegate������ ���다.
    int showThat() const { return value->showThat(); }  // delegate������ ���다.
private:
    RCIPtr<Widget> value;
};