[Effective C++] Chapter 2. 생성자, 소멸자 및 대입 연산자

// 이것은
class Empty {};  

// 다음과 같다. 
class Empty
{
public:
  Empty() { ... }                            // 기본 생성자
  Empty(const Empty& e) { ... }              // 복사 생성자
  ~Empty() { ... }                           // 소멸자
  Empty& operator=(const Empty& e) { ... }   // 복사 대입 연산자
};

template<class T>
class NamedObject
{
private:
  std::string& namedValue;  // 참조자
  const T objectValue;      // const

public:
  NamedObject(std::string& name, const T& value);
};

int main()
{
  std::string newDog("Persephone");
  std::string oldDog("Satch");
  
  NamedObject<int> p(newDog, 2);
  NamedObject<int> s(oldDog, 36);
  
  p = s;    // 컴파일 에러! 복사 대입 연산자 정의 필요!
}

class Uncopyable
{
protected:
  Uncopyable() {}
  ~Uncopyable() {}

// 선언만 하고 정의는 하지 않는다. 
private:
  Uncopyable(const Uncopyable&);
  Uncopyable& operator=(const Uncopyable&);
};

// 복사 생성자도, 복사 대입 생성자도 선언되지 않는다. 
class HomeForSale : private Uncopyable { };

class TimeKeeper
{
public:
  TimeKeeper();
  virtual ~TimeKeeper();  // 가상 소멸자
};

class AtomicClock: public TimeKeeper { ... };
class WaterClock: public TimeKeeper { ... };
class WristClock: public TimeKeeper { ... };

int main()
{
  TimeKeeper* t = getTimeKeeper(); // 생성된 파생 클래스의 기본 클래스 포인터를 반환하는 팩토리 함수이다. 
  delete t; // 파생 클래스의 소멸자 -> TimeKeeper의 소멸자
}

class AbstractWithVirtual
{
public:
  virtual ~AbstractWithVirtual() = 0; // 순수 가상 소멸자
};

AbstractWithVirtual::~AbstractWithVirtual() {}; // 꼭 정의를 두어야 한다. 

class DBConnection()
{
public:
  static DBConnection Create();
  
  // 연결을 닫을 때 실패하면 예외를 던진다. 
  // 소멸자가 아닌 다른 함수에서 예외가 발생하도록 했다. 
  void Close(); 
};

class DBHandler
{
private:
  DBConnection db;
  
public:
  // 데이터베이스 연결이 항상 닫히도록 소멸자에서 Close해준다. 
  ~DBHandler()
  {
    db.Close();
    // 하지만 여기서 예외가 발생했을 때 어떤 조취를 취해야 할까?
    // (1) 프로그램을 바로 종료하거나 (2) 아무일 없었던 듯 무시한다
    // 단순히 위와같은 조치를 바로 취하는 건 좋지 않겠다. 
    // 그렇다면 사용자가 직접 예외에 대처할 수 있게 하는 것이 좋겠다. 
  }
};

// 유저가 이렇게 사용할 수 있겠다. 
int main()
{
  DBHandler h(DBConnection::Create());
}

class DBHandler
{
private:
  DBConnection db;
  bool closed;
  
public:
  // 사용자가 처리할 수 있도록 책임을 전가한다. 
  void Close()
  {
    db.Close();
    closed = true;
  }

  ~DBHandler()
  {
    // 만약 사용자가 Close를 안 했을 때만 여기서 Close해본다. 
    if (closed == false)
    {
      try
      {
        db.Close();
      }
      catch (...)
      {
        // Close 호출이 실패했다는 로그를 작성한다. 
        // (1) 프로그램을 바로 종료하거나 (2) 아무일 없었던 듯 무시한다
      }
    }
  }
};

class Transaction
{
public:
  Transaction()
  {
    // 생성자에서 가상 함수를 호출해버렸다. 
    LogTransaction(); 
    // 하지만 파생 클래스의 멤버들은 아직 초기화가 안 되었으므로
    // 이 시점에서 b의 타입은 Transaction이다. 
    // (2) 따라서 Transaction의 LogTransaction()이 호출된다. 
  }
  
  virtual void LogTransaction() const = 0;
};

class Buy : public Transaction
{
public:
  virual void LogTransaction() const;
};

class Sell : public Transaction
{
public:
  virual void LogTransaction() const;
};

int main()
{
  // 이 코드가 실행되면 어떻게 될까?
  Buy b; 
  // 가장 먼저 Buy의 기본 클래스인 (1) Transaction의 생성자가 호출될 것이다. 
}

class Transaction
{
public:
  explicit Transaction(const str::string logInfo)
  {
    LogTransaction(logInfo); 
  }
  
  // 비가상 함수이다. 
  // 매개변수로 필요한 정보를 받는다. 
  void LogTransaction(const str::string logInfo) const;
};

class Buy : public Transaction
{
public:
  // 매개변수로 필요한 정보를 넘긴다. 
  Buy() : Transaction(createLogString()) 
  {
    // ...
  }
 
private:
  static std::string createLogString();
};

class Widget
{
public:
  // 단순 대입 연산자
  Widget& operator=(const Widget& rhs)
  {
    // ...
    return *this; // 참조자를 반환한다. 
  }
  
  // 다른 대입 연산자도 마찬가지이다. 
  Widget& operator+=(const Widget& rhs)
  {
    // ...
    return *this;
  }
};

int main()
{
  Widget a, b, c;
  
  // 대입이 사슬처럼 이루어진다. 
  a = b = c; 
  // 이것은 다음과 같이 우측 연관 연산(right-associative)으로 진행된다. 
  // (a = (b = c))
}

class Widget {};

Widget w;
w = w;  // 자기 자신에 대해 대입 연산자를 적용하는 것을 말한다.  

class Bitmap {};

class Widget 
{
private:
  Bitmap * pb;
  
public:
  Widget& operator=(const Widget& rhs);
};

Widget& Widget::operator=(const Widget& rhs) // 만약 rhs가 자기 자신이라면?
{
  delete pb; // 자기자신의 데이터를 지웠기 때문에
  pb = new Bitmap(*rhs.pb); // rhs.pb는 이미 삭제된 상태가 된다. 아뿔싸!

  return *this;
}

Widget& Widget::operator=(const Widget& rhs) 
{
  // 객체가 같은지 확인해서 같으면 아무것도 하지 않는다. 
  if (this == &rhs) return *this;

  delete pb; 
  pb = new Bitmap(*rhs.pb); 
  return *this;
}

Widget& Widget::operator=(const Widget& rhs) 
{
  Bitmap * pOrig = pb;      // 원래의 pb를 복사한다. 
  pb = new Bitmap(*rhs.pb); // 새로운 값을 대입한다. 
  delete pOrig;             // 원래의 pb를 삭제한다.
  
  return *this; 
}

class Widget 
{
private:
  Bitmap * pb;
  void swap(Widget& rhs); // *this와 rhs의 데이터를 맞바꾼다. Item 28에서 자세히 설명한다.  

public:
  Widget& operator=(const Widget& rhs);
};

Widget& Widget::operator=(const Widget& rhs)
{
  Widget temp(rhs); // rhs의 사본을 만든다. 
  swap(temp);       // *this와 사본을 맞바꾼다. 
 
  return *this;
}

Widget& Widget::operator=(Widget rhs) // 사본이 전달된다. 
{
  swap(rhs); // *this와 사본을 맞바꾼다. 
     
  return *this;
}

void logCall(const std::string& funcName);

class Customer
{
private:
  std::string name;
  
public:
  // 복사 생성자
  Customer(const Customer& rhs) : name(rhs.name)
  {
    logCall("Customer copy constructor");
  }
  
  // 복사 대입 연산자
  Customer& operator=(const Customer& rhs)
  {
    logCall("Customer copy assignment operator");
      
    name = rhs.name;
    return *this;
  }
};

class PriorityCustomer : public Customer
{
private:
  int priority;
  
public:
  PriorityCustomer(const PriorityCustomer& rhs);
  PriorityCustomer& operator=(const PriorityCustomer& rhs);
};

// 파생 클래스의 복사 생성자에서
// 기본 클래스의 멤버 데이터를 복사하지 않고 있다!
PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs) : priority(rhs.priority)
{
  logCall("PriorityCustomer copy constructor");
}

// 파생 클래스의 복사 대입 연산자에서도 마찬가지다!
PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs)
{
  logCall("PriorityCustomer copy assignment operator");
  
  priority = rhs.priority;
  return *this;
}

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs) 
  : Customer(rhs), // 기본 클래스의 복사 생성자를 호출한다. 
  priority(rhs.priority)
{
  logCall("PriorityCustomer copy constructor");
}

PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs)
{
  logCall("PriorityCustomer copy assignment operator");
  
  priority = rhs.priority;
  Customer::operator=(rhs); // 기본 클래스 부분을 대입한다. 
  return *this;
}