[Effective C++] Chapter 6. 상속, 그리고 객체 지향 설계

int x; // 전역 변수 

void someFunc()
{
  double x; // 지역 변수
  // someFunc의 유효범위 안쪽에 있으므로 
  // int x를 가린다
  
  std::cout << x; 
}

class Base
{
private: 
  int x;
  
public:
  virtual void mf1() = 0;
  virtual void mf1(int);
  
  virtual void mf2();
  
  void mf3();
  void mf3(double);
};

class Derived : public Base
{
public:
  virtual void mf1(); // Base의 mf1을 다 가려버린다
  
  void mf3(); // Base의 mf3을 다 가려버린다
  
  void mf4();
};

// 클래스 유효범위에 대한 예시
void Derived::mf4()
{
  mf2();
  // 지역 유효범위(mf4)에 mf2를 찾는다.
  // 없다면 Derived 클래스 유효범위에서...
  // 없다면 Base 클래스 유효범위에서...
  // 없다면 Base를 둘러싼 네임스페이스를...
  // ...
}

int main()
{
  Derived d;
  int x;
  
  d.mf1();  // Derived::mf1 호출
  d.mf1(x); // 에러! 
  
  d.mf2();  // Base::mf2 호출
  
  d.mf3();  // Derived::mf3 호출
  d.mf3(x); // 에러!
}

class Derived : public Base
{
public:
  // using 선언으로 
  // Base에 있는 것들 중 mf1, mf3 이름을 가진 것들을 
  // Derived에서 볼 수 있도록 (public 멤버로) 만든다. 
  using Base::mf1;
  using Base::mf3;
  
  virtual void mf1();
  void mf3();
  void mf4();
};

int main()
{
  Derived d;
  int x;
  
  // 모두 다 잘 된다. 
  d.mf1();
  d.mf1(x); // Base::mf1 호출
  
  d.mf2();
  
  d.mf3();
  d.mf3(x); // Base::mf3 호출
}

class Derived : private Base
{
public:
  // 전달 함수
  virtual void mf1() { Base::mf1(); }
};

int main()
{
  Derived d;
  int x;
  
  d.mf1();  // Derived::mf1 호출
  d.mf1(x); // 에러! 
}

// 추상 클래스 
class Shape
{
public:
  // 순수 가상 함수 
  virtual void draw() = 0;
  // 비순수 가상 함수 
  virtual void error(const std::string& msg);
  // 비가상 함수 
  int objectID() const;
};

class Rectangle : public Shape {};
class Ellipse : public Shape {};

Shape *ps = new Shape;
Shape *ps1 = new Rectangle;
Shape *ps2 = new Ellipse;

// Shape::draw를 호출한다. 
ps1->Shape::draw();
ps2->Shape::draw();

class Airplane
{
public:
  virtual void fly(const Airport& destination);
};

void Airplane::fly(const Airport& destination)
{
  // 기본 날기 동작
}

class ModelA : public Airplane {};
class ModelB : public Airplane {};

class ModelC : public Airplane {};
// fly와 다른 날기 동작을 해야 하는 ModelC가 추가되었는데,
// 까먹고 fly를 재정의 하지 않았다면?

int main()
{
  Airport PDX;
  
  Airplane *pa = new ModelC;
  pa->fly(PDX);  // Airplane::fly가 호출되고 말았다!
}

class Airplane
{
public:
  virtual void fly(const Airport& destination) = 0;

protected:
  void defaultFly(const Airport & destination);
  // 파생 클래스에서 재정의하면 안되므로 비가상 함수이다. 
  // protected로 비행기류만 알고 있도록 한다. 
};

void Airplane::defaultFly(const Airport & destination)
{
  // 기본 날기 동작 
}

class ModelA : public Airplane
{
public:
  virtual void fly(const Airport& destination)
  {
    defaultFly(desination); // 기본 날기 동작
  }
};
// ModelB도 동일


class ModelC : public Airplane
{
public:
  virtual void fly(const Airport& destination)
  {
    // 새로운 날기 동작 
  }
};

class GameCharacter
{
private:
  // 파생 클래스가 이 가상 함수를 재정의 할 수 있다.
  virtual int doHealthValue() const;
  
public:
  // 비가상 함수 인터페이스 
  int healthValue() const
  {
    // ... 사전 작업
    int retVal = doHealthValue();
    // ... 사후 작업
    return retVal;
  }
};

class GameCharacter; // 전방선언

// 계산 함수 
int defaultHealthCalc(const GameCharacter& gc);

class GameCharacter
{
private:
  // 계산 함수를 포인터로 가지고 있다. 
  HealthCalcFunc healthFunc;

public:
  // HealthCalcFunc은
  // 반환타입이 int, 매개변수는 const GameCharacter&형인 함수에 대한 포인터를 나타낸다. 
  typedef int (*HealthCalcFunc)(const GameCharacter&);
  
  explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
    : healthFunc(hcf)
  {}
  
  int healthValue() const
  {
    return healthFunc(*this);
  }
};

class EvilBadGuy : public GameCharacter {};

// 다른 계산 함수들 
int loseHealthQuickly(const GameCharacter&);
int loseHealthSlowly(const GameCharacter&);

int main()
{
  // 객체 마다 다르게 함수를 지정할 수 있다. 
  // 런다임에 함수를 바꿀 수 있다. 
  EvilBadGuy ebg1(loseHealthQuickly);
  EvilBadGuy ebg1(loseHealthSlowly);
}

class GameCharacter
{
public:
  // HealthCalcFunc은
  // 반환타입이 int, 매개변수는 const GameCharacter&형인 함수에 대한 tr1::function 을 나타낸다. 
  typedef std::tr1::function<int (const GameCharacter&)> HealthCalcFunc;
};

// (1) 반환타입이 short인 함수이다. 
short calcHeatlh(const GameCharacter&);

// (2) 함수 객체를 만들기 위한 클래스이다. 
stuct HealthCalculator
{
  int operator()(const GameCharacter&) const {}
};

class GameLevel
{
public: 
  // (3) 반환타입이 float인 멤버 함수이다. 
  float health(const GameCharacter&) const;
}

int main()
{
  // (1)
  EvilBadGuy ebg1(calcHealth); 
  
  // (2)
  EvilBadGuy ebg2(HealthCalculator());
  
  // (3)
  GameLevel currentLevel;
  EvilBadGuy ebg3(std::tr1::bind(&GameLevel::health, currentLevel, _1));
  // GameLevel::health 함수를 사용하는데, 
  // GameLevel::health는 암시적으로 GameLevel 객체가 있어야 한다. 
  // 하지만 GameLevel::health의 매개변수는 GameCharacter 하나 뿐이다. 
  // 그래서 currentLevel를 계산할 때 함께 사용하도록 묶어주고 있다. 
  // _1은 첫 번째 자리의 매개변수가 자유 매개변수(free parameter)임을 나타내는 것이다. 
}

class GameCharacter; // 전방 선언

// 계산하는 함수를 나타내는 클래스를 따로 둔다. 
class HealthCalcFunc
{
public: 
  // 그 안에 가상 함수로 계산을 한다. 
  virtual int calc(const GameCharacter& gc) const {}
};

HealthCalcFunc defaultHealthCalc;

class GameCharacter
{
private:
  // 계산하는 클래스에 대한 포인터를 가지고 있다. 
  HealthCalcFunc *pHealthCalc;
  
public:
  explicit GameCharcter(HealthCalcFunc *phcf = &defaultHealthCalc)
    : pHealthCalc(phcf)
  {}
  
  int healthValue() const
  {
    return pHealthCalc->calc(*this);
  }
};

class Base 
{
public: 
  // 비가상 함수 
  void mf();
};

class Derived : public Base 
{
public:
  // 기본 클래스의 비가상 함수를 재정의 해버렸다. 
  // Base::mf를 가려버린다. 
  void mf();
};

int main()
{
  Derived d;
  
  // 포인터 형만 다를 뿐
  // 똑같이 d를 가리킨다. 
  Base *pB = &d;
  Derived *pD = &d;
  
  pB->mf(); // Base::mf 호출
  pD->mf(); // Derived::mf 호출
  // 일관성 없는 이상한 동작이다!
}

class Shape 
{
public:
  enum ShapeColor { Red, Green, Blue };
  
  // 기본 클래스의 가상 함수. 
  // 기본 매개변수가 있으며 Red이다. 
  virtual void draw(ShapeColor color = Red) const = 0;
};

class Rectangle : public Shape
{
public:
  // 기본 매개변수가 Green이다. 
  virtual void draw(ShapeColor color = Green) const;
};

int main()
{
  Shape * pr = new Rectangle;
  pr->draw(); // Rectangle::draw(Shape::Red) 를 호출해 버린다! 
}

class Shape 
{
public:
  virtual void draw(ShapeColor color = Red) const = 0;
};

class Rectangle : public Shape
{
public:
  virtual void draw(ShapeColor color = Red) const;
  // 코드 중복이다.
  // 게다가 Shape 클래스의 기본 매개변수가 변하면
  // 파생 클래스에서 일일히 다 바꿔줘야 한다. 
};

class Shape
{
private:
  virtual void doDraw(ShapeColor color) const = 0;
  
public: 
  // 비가상 함수
  void draw(ShapeColor color = Red) const
  {
    doDraw(color);
  }
};

class Rectangle : public Shape
{
private:
  virtual void doDraw(ShapeColor color) const;
}

class Person
{
private:
  // Person과 has-a 관계이다. 
  std::string name;
  Address address;
  PhoneNumber voiceNumber;
  PhoneNumber faxNumber;
};

template<class T>
class Set
{
private:
  // Set은 list 객체를 써서 구현된다.(is implemented in terms of) 
  std::list<T> rep;
  
public:
  bool member(const T& item) const;
  void insert(const T& item);
  void remove(const T& item);
  std::size_t size() const;
};

class Person {};

class Student : private Person {};

void eat(const Person& p);

int main()
{
  Person p;
  Student s;
    
  eat(p);
  eat(s); // 에러! Stduent는 Person이 아니다. 
}

class Timer
{
public:
  explicit Timer(int tickFrequency);
  
  // 이것을 재정의 해서 Widget 전용 타이머로 사용하고 싶다. 
  virtual void onTick() const;
};

class Widget : private Timer // private 상속 
{
private:
  // Widget 전용 기능들을 추가해서 재정의한다. 
  virtual void onTick() const;
};

class Widget
{
private:
  class WidgetTimer : public Timer
  {
  public:
    virtual void onTick() const;
  };
  
  WidgetTimer timer;
};

class Empty {};

class HoldsAnInt
{
private:
  int n;
  Empty e; // 크기가 0이 아니다.
};

class HoldsAnInt : private Empty
// 크기가 0이다. 
{
private:
  int n;
};

class BorrowableItem 
{
public: 
  void checkOut();
};

class ElectronicGadget 
{
private: 
  void checkOut();
};

class MP3Player : public BorrowableItem, public ElectronicGadget {};

int main()
{
  MP3Player mp;
  
  mp.checkOut(); // 에러!
  // BorrowableItem의 함수인가?
  // ElectronicGadget의 함수인가?
  // ElectronicGadget::checkOut 은 private이므로 
  // BorrowableItem::checkOut 이 불릴 것 같지만 아니다. 
  // 컴파일러는 최적 일치 함수를 찾은 후에 비로소 함수의 접근 가능성을 점검한다. 
  // 그래서 이 경우에는 먼저 최적 일치 함수를 결정할 수 없어서 에러가 난다. 
  
  // 이 모호성을 피하려면 아래와 같이 함수를 손수 지정해 주어야한다.
  mp.BorrowableItem::checkOut();
  // 하지만 private 멤버에 접근하려고 한다는 에러가 나올 뿐이다. 
  // 근본적으로 막을 수가 없다. 
}

class File 
{
private:
  std::string fileName;
};

class InputFile : public File {};
class OutputFile : public File {};

class IOFile : public InputFile, public OutputFile {};
// IOFile 클래스는 fileName이 두 개인가? 하나인가?

class File {};

class InputFile : virtual public File {};
class OutputFile : virtual public File {};

class IOFile : public InputFile, public OutputFile {};

// 인터페이스를 갖고 있다. 
class IPerson
{
public:
  virtual ~IPerson();
  
  virtual std::string name() const = 0;
  virtual std::string birthDate() const = 0;
};

// 사용하면 유용한 함수들이 있다. 
class PersonInfo
{
public:
  explicit PersonInfo(DatabaseID pid);
  virtual ~PersonInfo();
  
  virtual const char * theName() const;
  virtual const char * theBirthDate() const;
  virtual const char * valueDelimOpen() const;
  virtual const char * valueDelimClose() const;
};

// 다중 상속을 한다. 
class CPerson : public IPerson, private PersonInfo
{
private:
  const char * valueDelimOpen() const { return ""; }
  const char * valueDelimClose() const { return ""; }
  
public:
  explicit CPerson(DatabaseID pid) : PersonInfo(pid) {}
  
  virtual std::string name() const
  {
    return PersonInfo::theName();
  }
  
  virtual std::string brithDate() const
  {
    return PersonInfo::theBirthDate();
  }
};