[Effective C++] Chapter 5. 구현

std::string encryptPassword(const std::string& password)
{
  using namespace std;
  
  // 이 변수는 
  string encrypted; 
  
  // 여기서 에러가 발생하면 전혀 쓰이지 않고, 괜히 생성자와 소멸자만 더 불린다. 
  if (password.length() < MinimumPasswordLength)
    throw logic_error("Password is too short");

  // 따라서 실제로 쓰일 때까지 늦춰서, 이곳에 선언하는 게 좋겠다. 
  // ... encrypted 변수를 설정한다 ...
    
  return encrypted;
}

void encrypt(std::string& s);

std::string encryptPassword(const std::string& password)
{
  // (BAD)
  std::string encrypted; // 쓸데없이 기본 생성자가 불린다. 
  encrypted = password;  // 그리고 대입한다. 
  
  // (GOOD) 정의를 최대한 늦춰서, 정의와 동시에 초기화한다. 
  std::string encrypted(password); 
  
  encrypt(encrypted);
    
  return encrypted;
}

// (1) 루프 바깥쪽에 정의한다. 
// 생성자 1번 + 소멸자 1번 + 대입 n번

Widget w; // w의 접근 범위가 (2)보다 넓다. 
for (int i = 0; i < n; i++)
{
  w = i에 따라 달라지는 값;
}

// (2) 루프 안쪽에 정의한다. 
// 생성자 n번 + 소멸자 n번

for (int i = 0; i < n; i++)
{
  Widget w(i에 따라 달라지는 값);
}

int x, y;

double d = static_cast<double>(x) / y;
// 대부분의 컴퓨터 아키텍쳐에서 int와 double의 표현구조가 아예 다르기 때문에
// int 타입을 double 타입으로 캐스팅한 부분에서 코드가 만들어진다. 

class Base {};
class Derived {};

Derived d;

// Derived* -> Base* 의 암시적 변환이 이루어진다. 
Base * pb = &d;
// 두 포인터의 값이 같지 않을 때도 있는데, 이럴 때는
// 포인터의 변위(offset)를 Derived* 포인터에 적용하여 Base* 포인터 값을 구하게 된다. 
// 이런 과정이 런타임에 일어난다!

class Window
{
public:
  virtual void onResize();
};

class SpecialWindow : public Window
{
public:
  virtual void onResize()
  {
    // 기본 클래스의 onResize를 먼저 호출해야 한다면?
  
    // 이 코드는 *this의 사본을 생성하고 그 사본의 함수를 호출하게 된다. 
    static_cast<Window>(*this).onResize();
    
    // 이렇게 해야 *this의 기본 클래스의 함수를 호출하는 것이다. 
    Window::onResize();
  }
}

// 기본 클래스 객체에 대한 포인터를 가지고 있다. 
typedef std::vector<std::shared_ptr<Window>> VPW;

int main()
{
  VPW winPtrs;
  
  for (VPW::iterator iter = windPtrs.begin(); iter != winPTrs.end(); ++iter)
    if (SpecialWindow *psw = dynamic_cast<SpecialWindow*>(iter->get()))
    // 런타임에 dynamic_cast로 캐스팅해서 파생클래스의 함수를 호출한다.  
      psw->blink();
}

// 애초에 파생 클래스 객체에 대한 포인터를 가지고 있다면
// 런타임에 캐스팅이 필요없다. 
typedef std::vector<std::shared_ptr<SpecialWindow>> VPSW;

int main()
{
  VPSW winPtrs;
  
  for (VPSW::iterator iter = windPtrs.begin(); iter != winPTrs.end(); ++iter)
    (*iter)->blink();
}

class Window
{
public:
  // 빈 가상 함수 제공 
  virtual void blick() {} 
}

class SpecialWindow
{
public:
  virtual void blick() 
  { 
    // ... 
  }
}

typedef std::vector<std::shared_ptr<Window>> VPW;

int main()
{
  VPW winPtrs;
  
  for (VPW::iterator iter = windPtrs.begin(); iter != winPTrs.end(); ++iter)
    (*iter)->blink();
}

// 이런 코드는 어떤 방식으로든지 바꿔놓아야 할 것이다. 

for (VPW::iterator iter = windPtrs.begin(); iter != winPTrs.end(); ++iter)
{
  if (SpecialWindow1 * psw1 = dynamic_cast<SpecialWindow1*>(iter->get()))
  {
    // ...  
  }
  else if (SpecialWindow2 * psw2 = dynamic_cast<SpecialWindow1*>(iter->get()))
  {
    // ...  
  }
  else if (SpecialWindow3 * psw3 = dynamic_cast<SpecialWindow1*>(iter->get()))
  {
    // ...  
  }
}

class Point
{
public:
  Point(int x, int y);
  void setX(int x);
  void setY(int y);
};

struct RectData
{
  Point ulhc; // upper left-hand corner
  Point lrhc; // lower right-hand corner
};

class Rectangle
{
private:
  // 메모리 부담을 줄이려고 포인터로 사각형을 표현한다. 
  std::shared_ptr<RectData> pData;
  
public:
  // 객체 내부의 데이터에 대한 참조자를 리턴하고 있다. 
  Point& upperLeft() const { return pData->ulhc; }
  Point& lowerRight() const { return pData->lrhc; }
};

int main()
{
  Point coord1(0, 0);
  Point coord2(100, 100);
  
  // 상수 Rectangle 객체의
  const Rectangle rec(coord1, coord2);
  
  // 내부 데이터에 접근해서 값을 바꿀 수 있게 되어버렸다!
  rec.upperLeft().setX(50);
}

class Rectangle
{
public:
  // const를 붙였으므로 위와 같이 값을 바꾸는 것은 허용되지 않는다. 
  const Point& upperLeft() const { return pData->ulhc; }
  const Point& lowerRight() const { return pData->lrhc; }
};

class GUIObject {};

// GUIObject를 Rectangle로 바꾼다. 
const Rectangle boundingBox(const GUIObject& obj);

int main()
{
  GUIObject * pgo;
  
  // ...
  
  // 하지만 무효참조 핸들이 될 문제가 있다. 
  const Point * pUpperLeft = &(boundingBox(pgo).upperLeft());
  // boundingBox를 호출해서 Rectangle 임시 객체가 만들어진다. 
  // 이것에 대해 upperLeft가 호출된다. 
  // 이 문장이 끝나면 boundingBox의 반환값이 소멸된다. 
  // 그 안에 있던 Point 객체들도 소멸된다. 
  // 따라서 pUpperLeft 포인터가 가리키는 객체는 이제 날아가고 없다. 
}

class PrettyMenu
{
private:
  Mutex mutex;
  Image * bgImage;
  int imageChanges;
  
public:
  void changeBackground(std::istream& imgSrc);
};

// 위험천만한 함수 
void PrettyMenu::changeBackground(std::istream& imgSrc)
{
  lock(&mutex);
  
  delete bgImage;
  ++imageChanges; // (2) 자료구조가 이상해진다. 
  bgImage = new Image(imgSrc); // 여기서 예외가 발생하면 
    
  unlock(&mutex); // (1) 자원이 새어나가고 
}

class PrettyMenu
{
private:
  // 자원관리 전담 포인터를 사용 -> 알아서 delete 되도록 한다 (Item 13)
  std::shared_ptr<Image> bgImage; 
};

void PrettyMenu::changeBackground(std::istream& imgSrc)
{
  // 자원관리 전담 포인터를 사용 -> 알아서 unlock 되도록 한다 (Item 14)
  Lock m1(&mutex);
  
  bgImage.reset(new Image(imgSrc));
  
  // 진짜 그림이 바뀌면 증가시키기로 한다. 
  ++imageChanges;
}

// 이 전략은 보통 데이터를 모두 별도의 구현 객체에 넣어두고 
struct PrettyMenuImpl
{
  std::shared_ptr<Image> bgImage;
  int imageChanges;
};

class PrettyMenu
{
private:
  // 그 구현 객체를 가리키는 포인터를 진짜 객체가 물고 있게 한다. (Item 31)
  // 이런 패턴을 pimpl 관용구라고 한다. 
  std::shared_ptr<PrettyMenuImpl> pImpl;
};

void PrettyMenu::changeBackground(std::istream& imgSrc)
{
  using std::swap;

  Lock m1(&mutex);
  
  // 사본을 생성한다. 
  std::shared_ptr<PrettyMenuImpl> pNew(new PrettyMenuImpl(*pImpl));
  
  // 사본을 수정한다. 
  pNew->bgImage.reset(new Image(imgSrc));
  ++pNew->imageChanges;
  
  // 사본과 진짜 객체를 맞바꾼다. 
  swap(pImpl, pNew);
}

void someFunc()
{
  // ... 사본을 만든다. 
  
  f1(); 
  f2();
  // f1, f2에서 강력한 예외 안전성을 보장하지 않는다면?
  // someFunc 역시 강력한 예외 안전성을 보장할 수 없다. 
  // 특히 f1, f2에서 자신에만 국한되는 것들의 상태를 바꾸는게 아니라, 
  //   비지역 데이터(ex. 데이터베이스 변경)에 대해 부수효과(side effect)를 준다면,
  //   someFunc쪽에서는 어쩔 도리가 없다. 
  
  // ... 사본과 진짜 객체를 맞바꾼다. 
}

class Person
{
private:
  int theAge;
  
public:
  // 클래스 정의 안에 함수를 바로 정의한다. 
  int age() const
  {
    return theAge;
  }
}

// 함수 정의 앞에 inline 키워드를 붙인다. 
// (표준 라이브러리의 max 템플릿)
template<typename T>
inline const T& std::max(const T& a, const T& b)
{
  return a < b ? b : a;
}

inline void f() {} // 인라인 요청

void (*pf)() = f; // 함수 포인터 

f();  // 인라인화 될 것이다. 

// 있지도 않은 함수에 대한 포인터를 가져올 수 없으므로..
pf(); // 인라인되지 않을 것이다. 

// Person의 구현 세부사항에 속하는 std::string, Date, Address가 
// 어떻게 정의됐는지 알아야 컴파일이 가능하므로
// 아래 헤더 파일들을 포함시켜야만 한다. 
#include <string>
#include "date.h"
#include "address.h"

class Person
{
private:
  std::string theName; // std::string 구현 세부사항을 알아야 한다. 
  Date theBirthDate;   // Date 구현 세부사항을 알아야 한다. 
  Address theAddress;  // Address 구현 세부사항을 알아야 한다. 
  
public:
  Person(const std::string& name, const Date& birthday, const Address& addr);
  std::string name() const;
  std::string birthDate() const;
  std::string address() const;
};

// Person.h

// 헤더 파일이 줄었다. 
#include <string> // 표준 라이브러리는 전방선언을 하면 안된다. 
#include <memory>
// 이렇게 되면 Person을 사용하는 사용자 입장에서는 
// Date, Address가 바뀌었다고 해서 컴파일을 다시할 필요가 없어진다. 

// 전방 선언 
class PersonImpl;
class Date;
class Address;

class Person
{
private:
  // 주 클래스에서는 구현 클래스인 PersonImpl에 대한 포인터만 가지고 있다. 
  // 그래서 세부 구현 사항을 몰라도 된다. 
  std::shared_ptr<PersonImpl> pImpl;
  
public:
  Person(const std::string& name, const Date& birthday, const Address& addr);
  std::string name() const;
  std::string birthDate() const;
  std::string address() const;
};

// Person.cpp

#include "Person.h"
#include "PersonImpl.h"

Person::Person(const std::string& name, const Date& birthday, const Address& addr)
  : pImpl(new PersonImpl(name, birthday, addr)
  // 핸들 클래스 Person에 대응되는 구현 클래스 PersonImpl 쪽으로 함수 호출을 전달한다. 
  // 실제 작업은 PersonImpl이 수행한다. 
{}

std::string Person::name() const
{
  return pImpl->name();
}

// 클래스 선언 
class Date; // 굳이 정의를 몰라도 된다. 

// 함수 선언 -> 가능 
Date today();
void clearAppointments(Date d);

// 추상 기본 클래스 
class Person
{
public:
  virtual ~Person();
  virtual std::string name() const = 0;
  virtual std::string birthDate() const = 0;
  virtual std::string address() const = 0;
  
  // 객체를 생성하는 팩토리 함수
  static std::shared_ptr<Person> create(const std::string& name, const Date& birthday, const Address& addr);
};

// 인터페이스 클래스 Person으로부터 인터페이스를 물려받은 다음,
// 가상 함수들을 구현한다. 
// (혹은 다중 상속을 사용할 수도 있다 - Item 40)

class RealPerson : public Person
{
private:
  std::string theName; 
  Date theBirthDate;  
  Address theAddress; 

public:
  RealPerson(const std::string& name, const Date& birthday, const Address& addr)
    : theName(name), theBirthDate(birthday), theAddress(addr)
  {}
  
  virtual ~RealPerson() {}
  std::string name() const;
  std::string birthDate() const;
  std::string address() const;
};

// 팩토리 함수는 이렇게 구현할 수 있겠다. 
std::shared_ptr<Person> Person::create(const std::string& name, const Date& birthday, const Address& addr)
{
  return shared_ptr<Person>(new RealPerson(name, birthday, addr));
}

// 사용자는 이렇게 사용하면 되겠다.

std::string name;
Date dateOfBirth;
Address address;

std::shared_ptr<Person> pp(Person::create(name, dateOfBirth, address));

std::cout << pp->name() << " " << pp->birthDate() << " " << pp->address() << endl;