[Effective C++] Chapter 4. 설계 및 선언

class Date
{
public:
  Date(int month, int day, int year); 
};

int main()
{
  Date d(1, 30, 2023); // 저런, month와 day를 잘못 넣었다!
}

struct Day
{
  int val
  explicit Day(int v) : val(v)
};
// ... Month, Year ...

class Date
{
public:
  Date(const Month& m, const Day& d, const Year& y); 
};

int main()
{
  Date d(1, 30, 2023); // 컴파일 에러 
  Date d(Month(1), Day(30), Year(2023); // 컴파일 에러 
  Date d(Day(30), Month(1), Year(2023); // Okay
  Date d(Day(1), Month(30), Year(2023); // 악 안돼!
}

class Month
{
public:
  // 객체가 아닌, 함수를 사용하였다. 
  // 객체가 초기화 되기 전에 사용되면 위험하기 때문이다 (Item 4)
  static Month Jan() { return Month(1); }
  static Month Feb() { return Month(1); }
  //...

private:
  // Month 값이 새로 생성되지 않도록
  // 명시호출 생성자가 private 멤버이다. 
  explicit Month(int m); 
};

int main()
{
  Date d(Month::Jan(), Day(30), Year(2023)); // Good
}

Investment * createInvestment();
// 사용자가 자원을 만들어 놓고 삭제하는 걸 까먹으면 어떻하지?
// Investment를 스마트 포인터로 관리해야겠다. 
// 스마트 포인터 사용을 까먹으면 어떻하지?
// 차라리 스마트 포인터를 리턴하는 것이 좋겠다. 

std::shared_ptr<Investment> createInvestment();
// 이렇게

// 삭제자
void getRidOfInvestment(Investment * inv); 

std::shared_ptr<Investment> createInvestment()
{
  // 삭제가가 묶인 스마트 포인터를 리턴하므로
  // 이제 삭제 걱정도 안 해도 된다.
  
  std::shared_ptr<Investment> retVal(0, getRidOfInvestment);
  // (X) 이것은 널을 가리키는 스마트 포인터가 아니다. 
  // 0은 int이지 Investment* 타입이 아니다. 
  
  std::shared_ptr<Investment> retVal(static_cast<Investment *>(0), getRidOfInvestment);
  // 캐스트를 활용해서(Item 27 참고) 널 포인트를 가진 스마트 포인터를 생성한다.


  // 그리고 나중에 실제 데이터를 가리키도록 한다.
  // retVal = ...
  // 만약에 스마트 포인터를 생성하는 시점에 실제 데이터를 알 수 있다면, 생성자에 바로 넘겨주는게 좋겠다.

  return retVal;
}

class Investment {};
class Stock : public Investment {};

std::shared_ptr<Investment> createInvestment()
{
  return std::shared_ptr<Investment>(new Stock());
  // Investment형 shared_ptr이어도, 
  // Stock으로 생성한 걸 잊지 않고 그 DLL의 delete를 호출해준다. 
}

class Person {};
class Student : public Person {};

bool validateStudent(Student s);

int main()
{
  Student plato;
  
  validateStudent(plato);
  // Student의 복사 생성자가 호출된다. 
  // Person 객체가 먼저 만들어진다. 
  
  // 만약에 멤버로 string 객체가 있다면?
  // 그에 따른 생성자가 또 불릴 것이다. 
  
  // 삭제할 때는 생성한 만큼 더 불린다. 
  
  // 값에 의한 전달은 어마어마한 비용이 들게 되었다. 
}

bool validateStudent(const Student & s);
// const를 사용하므로써 변경을 방지한다. 

class Window
{
public:
  virtual void display() const;
};

class WindowWithScrollBars : public Window
{
public:
  virtual void display() const;
};

void displayWindow(Window w)
// WindowWithScrollBars 객체가 Window 객체로 복사되면서
// WindowWithScrollBars의 부분이 싹둑 잘려나간다. 
{
  w.display();
  // 이것은 Window::display()만 부를 것이다. 
  // 해결하려면 참조로 전달하면 된다. 
}

int main()
{
  WindowWithScrollBars wwsb;
  displayWindow(wwsb);
}

class Rational 
{
private:
  int n, d;
  
  // 두 유리수를 곱한다.
  friend const Rational operator*(const Rational& lhs, const Rational& rhs);
  // 값으로 반환하게 되어 있다. 그럼 객체의 생성과 소멸에 대한 비용이 들겠다.
  // 이것을 참조로 반환하면 비용이 덜 들지 않을까?

public: 
  Rational(int numerator = 0, int denominator = 1);
};

const Rational& operator*(const Rational& lhs, const Rational& rhs)
{
  // 이것은 지역객체이다. 
  Rational result(lhs.n * rhs.n, lhs.d * rhs.d);
  
  return result;
} // 블록이 끝나면 사라져버린다. 
// 따라서 반환된 참조는 필요없는 메모리 뭉치가 된다. 

const Rational& operator*(const Rational& lhs, const Rational& rhs)
{
  Rational * result = new Rational(lhs.n * rhs.n, lhs.d * rhs.d);
  
  return *result;
  // 근데 이 객체는 누가 delete 해주지?
} 

int main()
{
  Rational w, x, y, z;
  w = x * y * z;
  // operator* 호출이 두 번 일어나므로 new에 맞춰서 delete도 두 번 해줘야 한다. 
  // 하지만 반환되는 참조자에 대한 포인터를 알 수 있는 방법이 없다. 
}

const Rational& operator*(const Rational& lhs, const Rational& rhs)
{
  static Rational result; // 정적 객체를 반환한다. 
  
  // result = ...;
  
  return result;
}

bool operator==(const Rational& lhs, const Rational& rhs);

int main()
{
  Rational a, b, c, d;
  
  if ((a * b) == (c * d)) // 이것은 늘 true가 되버린다.
  // ...
}

const Rational operator*(const Rational& lhs, const Rational& rhs)
{
  return Rational(lhs.n * rhs.n, lhs.d * rhs.d);
}

class WebBrowser
{
public:
  void clearCache();
  void clearHistory();
  void removeCookies();
  
  // 위의 세가지를 한 번에 하는 함수를 만들고 싶다. 
  
  // 이것을 멤버 함수로 제공할 것인가?
  void clearEverything();
};

// 아니면 비멤버 비프렌드 함수로 제공할 것인가?
void clearBrowser(WebBrowser& wb)
{
  wb.clearCache();
  wb.clearHistory();
  wb.removeCookies();
}

// "webbrowser.h" 
namespace WebBrowserStuff // 같은 네임스페이스 안에 둔다. 
{
  // 핵심 관련 기능들...
  
  class WebBrowser {};
  
  void clearBrowser(WebBrowser& wb);
}

// "webbrowserbookmarks.h" 
namespace WebBrowserStuff 
{
  // 즐겨 찾기 관련 편의 함수들...
}

// "webbroswercookies.h"
namespace WebBrowserStuff 
{
  // 쿠기 관련 평의 함수들...
}

class Rational
{
public:
  // 생성자를 explicit(명시 호출)로 선언하지 않았다. 
  // 따라서 암시적 타입 변환이 가능해진다. 
  Rational(int numerator = 0, int denominator = 1);
  
  int numerator();
  int denominator();

  // operator*를 멤버 함수로 두었다. 
  const Rational operator*(const Rational& rhs) const;
};

int main()
{
  Rational oneEighth(1, 8);
  Rational oneHalf(1, 2);
    
  Rational result = oneHalf * oneEighth;
    
  // 암시적 타입 변환으로 2가 Rational 객체가 되었기에 가능하다 
  result = oneHalf * 2; // oneHalf.operator*(2)
  
  // 컴파일 에러!
  result = 2 * oneHalf; // 2.operator*(oneHalf) 
}

class Rational {};

// 비멤버 함수로 두었다. 
const Rational operator*(const Rational& lhs, const Rational& rhs)
{
  return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
}

int main()
{
  Rational oneHalf(1, 2);
  Rational result;

  result = oneHalf * 2; // OK
  result = 2 * oneHalf; // OK!
}

namespace std
{
  template<typename T>
  void swap(T& a, T& b)
  {
    T temp(a);
    a = b;
    b = temp;
  }
}

class WidgetImpl
{
private:
  int a, b, c;
  std::vector<double> v; // 복사 비용이 높겠다.
};

class Widget
{
private:
  // 포인터가 주성분이다. 
  WidgetImpl * pImpl;
    
public:
  // 복사 생성자와 복사 대입 연산자를 제공한다. 
  Widget(const Widget& rhs);
  Widget& operator=(const Widget& rhs)
  {
    *pImpl = *(rhs.pImpl);
    // ...
  }

  void swap(Widget& other)
  {
    using std::swap;
    
    // 객제가 아니라 포인터를 맞바꾼다. 
    swap(pImpl, other.pImpl);
  }
};

namespace std
{
  // 명시적 특수화 : 
  // 다른 swap 템플릿을 사용하지 말고, 주어진 형에 맞게 특별히 명시적으로 정의된 이 함수 정의를 사용해라.
  template<>
  void swap<Widget>(Widget& a, Widget& b)
  {
    // Widget에서 swap()을 제공한다.  
    // 굳이 freind로 해서 pImpl에 직접 접근할 필요가 없다. 
    a.swap(b);
  }
}

// 클래스 템플릿 -> std::swap의 부분 특수화가 필요해졌다. 
template<typename T>
class WidgetImpl {};

template<typename T>
class Widget {};

namespace std
{
  // (X) C++은 함수 템플릿의 부분 특수화는 허용하지 않는다. 
  template<typename T>
  void swap<Widget<T>>(Widget<T>& a, Widget<T>& b)
  {
    a.swap(b);
  }
}

namespace WidgetStuff // std가 아니므로 오버로딩 버전이 아니다. 
{
  template<typename T>
  class Widget {};
  
  // 비멤버 swap
  template<typename T>
  void swap(Widget<T>& a, Widget<T>& b)
  // swap 뒤에 <...>가 없으므로 특수화 버전이 아니다. 
  {
    a.swap(b);
  }
}

template<typename T>
void doSomething(T& obj1, T& obj2)
{
  swap(obj1, obj2);
  // 어떤 버전의 swap을 호출해야 할까?
  // (1) T 타입 전용 버전
  // (2) std::swap을 특수화한 버전
  // (3) std::swap
}

template<typename T>
void doSomething(T& obj1, T& obj2)
{
  using std::swap; // std::swap을 이 함수 안으로 끌어온다. 
  swap(obj1, obj2);
}