[Effective C++] Chapter 7. 템플릿과 일반화 프로그래밍

class Widget
{
public:
  Widget();
  virtual ~Widget();
  virtual std::size_t size() const;
  virtual void normalize(); 
  void swap(Widget& other);
};

void doProcessing(Widget& w)
// w는 Widget 타입이므로 Widget 인터페이스를 지원해야 한다. 
// 그리고 이 인터페이스는 Widget 소스 코드를 보면 알 수 있다. (명시적 인터페이스)
// Widget 타입 인터페이스를 지원하지 않으면 컴파일이 안된다. 
{
  if (w.size() > 10 && w != someNastyWidget)
  {
    Widget temp(w);
    
    temp.normalize();
    // Widget의 멤버 함수 중 몇 개는 가상 함수이다. 
    // 그래서 런타임에 w의 동적 타입을 기반으로 해서 
    // 특정 함수 호출이 이루어진다. (런타임 다형성)
    
    temp.swap(w);
  }
}

template<typename T>
void doProcessing(T& w)
{
  // w는 T 타입이다. 
  // 아래 if문의 결과를 bool로 낼 수 있어야 하며,
  // normalize, swap 멤버 함수를 지원해야 하는 타입이다. (암시적 인터페이스)
  // 이것들을 T 타입이 지원하지 않으면 컴파일이 안된다. 
  if (w.size() > 10 && w != someNastyWidget)
  // 또한 컴파일 도중에 템플릿이 인스턴스화된다. 
  // 호출되는 함수는 인스턴스화된 함수 템플릿에 어떤 템플릿 매개변수가 들어가느냐에 따라 달라진다. (컴파일 타임 다형성)
  {
    T temp(w);
    temp.normalize();
    temp.swap(w);
  }
}

template<class T> class Widget;
template<typename T> class Widget;

template<typename C>
void print2nd(const C& container)
{
  if (container.size() >= 2)
  {
    // iter는 C::const_iterator 타입이다. 
    // 따라서 템플릿 매개변수인 C에 따라서 iter의 타입이 달라진다. (의존 이름)
    C::const_iterator iter(container.begin());  
    // 에러!
    
    ++iter;
    
    // value는 템플릿 매개변수 C와 상관없이 int인 타입이다. (비의존 이름)
    int value = *iter;
    
    std::cout << value;
  }
}

template<typename C>
void print2nd(const C& container)
{
  C::const_iterator * x;
  // C::const_iterator가 타입이 아니면 어떻게 될까?
  // 예를 들면 const_iterator라는 이름을 가진 정적 데이터 멤버가 C에 들어있을 수도 있다. 
  // 그러면 위 식은 곱셈이 될 수도 있다. 
  // 그래서 C++은 이 모호성을 해결하기 위해 중접 의존 이름은 기본적으로 타입이 아닌 것으로 본다. 
}

template<typename C>
void print2nd(const C& container)
{
  if (container.size() >= 2)
  {
    // typename을 붙인다. 
    typename C::const_iterator iter(container.begin());  
    
    ++iter;
    int value = *iter;
    std::cout << value;
  }
}

template<typename T>
class Derived : public Base<T>::Nested // 기본 클래스 리스트 
{
public:
  explicit Derived(int x) : Base<T>::Nested(x) // 멤버 초기화 리스트 내의 기본 클래스 식별자 
  {
    typename Base<T>::Nested temp;
  }
}

template<typename IterT>
void workWithIterator(IterT iter)
{
  typedef typename std::iterator_traits<IterT>::value_type value_type;
  // (특성 정보 클래스에 속한 value_type 등의 멤버 이름은 
  // 그 멤버 이름과 똑같이 typedef 이름을 짓는게 관례이다.)
}

class CompanyA
{
  void sendClearText();
  void sendEncrypted();
};

template<typename C>
class MsgSender
{
public:
  void sendClear()
  {
    C c;
    c.sendClearText();
  }
  
  void sendSecret()
  {
    C c;
    c.sendEncrypted();
  }
};

template<typename C>
class LoggingMsgSender : public MsgSender<C>
{
public: 
  void sendClearMsg()
  {
    sendClear();
    // 컴파일 에러! 
    // LoggingMsgSender는 
    // MsgSender의 어떤 인스턴스에서 파생되었는지를 모른다. 
    // 즉, C가 무엇인지 모르므로
    // MsgSender<C>가 어떤 형태인지 알 방법이 없다. 
  }
};

class CompanyB
{
  void sendEncrypted();
};
// CompanyB가 LoggingMsgSender의 템플릿 매개변수 C가 되면 어떻게 되겠는가?
// sendClear에서는 CompanyB의 sendClearText를 부를텐데
// CompanyB는 sendClearText 함수가 없다. 
// 따라서 컴파일 에러가 옳은 판단을 한 것이라 볼 수 있겠다. 

template<>
class MsgSender<CompanyB>
// MsgSender 템플릿이 CompanyB 타입에 대해 특수화되었고, 
// 이 템플릿의 매개변수들이 하나도 빠짐없이 구체적인 타입으로 정해진다. 
{
public:
  void sendSecret()
  {
    // ...
  }
};

template<typename C>
class LoggingMsgSender : public MsgSender<C>
{
public: 
  void sendClearMsg()
  {
    this->sendClear();
    // sendClear 함수가 상속되는 것으로 가정한다. 
  }
};

template<typename C>
class LoggingMsgSender : public MsgSender<C>
{
public: 
  using MegSender<C>::sendClear;
  // 컴파일러에게 sendClear 함수가 기본 클래스에 있다고
  // 가정하라고 알려준다. 
  
  void sendClearMsg()
  {
    sendClear();
  }
};

template<typename C>
class LoggingMsgSender : public MsgSender<C>
{
public: 
  void sendClearMsg()
  {
    MsgSender<C>::sendClear();
    // sendClear 함수가 상속되는 것으로 가정한다. 
  }
};

template<typename T, std::size_t n>
// 비타입 템플릿 매개변수인 n이 있다. 
class SquareMatrix
{
public:
  void invert();
};

int main()
{
  SquareMatrix<double, 5> sm1;
  // n이 5인 SquareMatrix 인스턴스가 만들어진다. 
  sm1.invert();
  
  SquareMatrix<double, 10> sm2;
  // n이 10인 SquareMatrix 인스턴스가 만들어진다. 
  sm2.invert();
}

// 독립적인 기본 클래스를 만들어 둔다. 
template<typename T>
class SquareMatrixBase
{
private:
  std::size_t size;
  T * pData;  // 데이터를 포인터로 가리킨다.
   
protected:
  SquareMatrixBase(std::size_t n, T * pMem) : size(n), pData(pMem) {}
  void setDataPtr(T * ptr) { pData = ptr; }
  void invert(std::size_t matrixsize);
};

template<typename T, std::size_t n>
class SquareMatrix: private SquareMatrixBase<T>
{
private:
  using SquareMatrixBase<T>::invert;
  T data[n * n]; // 실제 데이터 

public:
  SquareMatrix : SquareMatrixBase<T>(n, data) {} // 기본 클래스에 데이터에 대한 포인터를 보낸다. 
  
  void invert() { this->invert(n); }
  // 기본 클래스를 호출한다. 
  // 이렇게 하면 n이 달라도 오직 한 가지의 SquareMatrixBase 클래스를 공유하게 된다. 
};

class Top {};
class Middle : public Top {};
class Bottom : public Middle {};

int main()
{
  // 이렇게 호환되는 모든 타입끼지 변환되도록 하고 싶다. 
  Top * pt1 = new Middle; // Middle* -> Top*
  Top * pt2 = new Bottom; // Bottom* -> Top*
  const Top * pct = pt1;  // Top* -> const Top*
}

template<typename T>
class SmartPtr
{
private:
  T * heldPtr;
  
public: 
  // 이렇게 같은 템플릿을 써서 인스턴스화되지만
  // 타입이 다른 객체로부터 원하는 객체를 만들어주는 생성자를
  // (SmartPtr<U>로 부터 SmartPtr<T>를 만들어내는)
  // 일반화 복사 생성자라고 한다. 
  template<typename U>
  SmartPtr(const SmartPtr<U>& other) : heldPtr(other.get()) {}
  // other의 포인터로 이 포인터를 초기화한다.
  // 따라서 U*에서 T*로 암시적 변환이 가능할 때만 컴파일 에러가 나지 않는다. 
  
  T * get() const { return heldPtr; }
};

int main()
{
  SmartPtr<Top> pt1 = SmartPtr<Middle>(new Middle);
  SmartPtr<Top> pt2 = SmartPtr<Bottom>(new Bottom);
  SmartPtr<const Top> pct = pt1;
}

template<class T> class shared_ptr
{
public:
  // 보통의 복사 생성자
  shared_ptr(shared_ptr const & r);

  // shared_ptr로부터 shared_ptr 생성자 호출이 가능하다. 
  template<class Y>
  shared_ptr(shared_ptr<Y> const & r);

  // 모든 기본 제공 포인터로부터 shared_ptr 생성자 호출이 가능하다. 
  template<class Y>
  explicit shared_ptr(Y * p);
  // 암시적 변환을 허용하지 않기 위해 explicit이 붙었다. 
  
  // weak_ptr로부터 shared_ptr 생성자 호출이 가능하다. 
  template<class Y>
  explicit shared_ptr(weak_ptr<Y> const & r);
  
  // auto_ptr로부터 shared_ptr 생성자 호출이 가능하다. 
  template<class Y>
  explicit shared_ptr(auto_ptr<Y>& r);
  // auto_ptr은 const가 없다.
  // 왜냐하면 복사연산으로 객체가 수정되면 복사된 쪽 하나만 유효해야 되기 때문이다. 
  
  
  // 보통의 복사 대입 연산자 
  shared_ptr& operator=(shared_ptr cosnt & r);
  
  // shared_ptr에서 shared_ptr로 대입이 가능하다. 
  template<class Y>
  shared_ptr& operator=(shared_ptr<Y> const & r);
  
  // auto_ptr에서 shared_ptr로 대입이 가능하다. 
  template<class Y>
  shared_ptr& operator=(auto_ptr<Y>& r);
};

template<typename T>
class Rational
{
public:
  Rational(const T & numerator = 0, const T & denominator = 1);
  
  const T numerator() const;
  const T denominator() const;
};

template<typename T>
const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs)
{
  // ...
}

int main()
{
  Rational<int> oneHalf(1, 2);
  
  Rational<int> result = oneHalf * 2; // 컴파일 에러!
  // 컴파일러는 2의 T가 무엇인지 알 방도가 없다. 
  // 왜냐하면 템플릿 인자 추론과정에서는 
  // 암시적 타입 변환이 고려되지 않기 때문이다. 
}

template<typename T>
class Rational
{
public:
  // 프렌드 함수
  friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs)
  {
    return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
    // 클래스 안에서 정의가 되었으므로 암시적으로 인라인 함수가 된다. 
  }
};

template<typename T>
class Rational
{
public:
  // 위 코드와 같은 코드이다. 
  friend const Rational operator*(const Rational& lhs, const Rational& rhs)
  {
    return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
  }
};

template<typename T>
class Rational; // 전방 선언 

// 도우미 함수 템플릿 선언 
template<typename T>
const Rational<T> doMultiply(const Rational<T>& lhs, const Rational<T>& rhs);

template<typename T>
class Rational
{
public:
  friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs)
  {
    return doMultiply(lhs, rhs);
    // 도우미 함수만 호출한다. 
  }
};

// 도우미 함수 템플릿 정의 
template<typename T>
const Rational<T> doMultiply(const Rational<T>& lhs, const Rational<T>& rhs)
{
  return Rational<T>(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
}

struct input_iterator_tag();
struct output_iterator_tag();
struct forward_iterator_tag() : public input_iterator_tag;
struct bidirectional_iterator_tag() : public forward_iterator_tag;
struct random_access_iterator_tag() : public bidirectional_iterator_tag;

template < ... >
class deque 
{
public: 
  // deque의 이터레이터는 임의 접근 반복자이다. 
  class iterator 
  {
  public:
    // (1) 사용하는 반복자 타입을 iterator_category라는 이름의 typedef로 한다.  
    typedef random_access_iterator_tag iterator_category;
  }
};

// 특성정보 클래스 
template<typename IterT>
struct iterator_traits
{
  // (1) 그리고 똑같이 재생한다. 
  typedef typename IterT::iterator_category iterator_category;
}

// (2)포인터 타입을 따로 처리하기위해
// 부분 템플릿 특수화 버전을 제공한다. 
template<typename IterT*>
struct iterator_traits<IterT*>
{
  typedef random_access_iterator_tag iterator_category;
}

// 임의 접근 반복자의 경우 사용하는 doAdvance 구현 
template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::random_access_iterator_tag)
{
  iter += d;
}

// 양방향 반복자의 경우 사용하는 doAdvance 구현 
template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::bidirectional_iterator_tag)
{
  if (d >= 0) { while(d--) ++iter; }
  else        { while(d++) --iter; }
}

// 입력 반복자의 경우 사용하는 doAdvance 구현 
template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::input_iterator_tag)
{
  if (d < 0) { throw std::out_of_range("Negative distance"); }
  while(d--) ++iter;
}

// 그러면 advance는 위의 오버로딩 함수들을 사용하면 된다. 
template<typename IterT, typename DistT>
void advance(IterT& iter, DistT d)
{
  doAdvance(iter, d, typename std::iterator_traits<IterT>::iterator_category());
  // iter의 반복자 범위에 적합한 doAdvance의 오버로딩 버전을 호출한다. 
}

template<typename IterT, typename DistT>
void advance(IterT& iter, DistT d)
{
  if (typeid(typename std::iterator_traits<IterT>::iterator_category) == 
      typeid(std::random_access_iteratortag))
  {
    iter += d; // 컴파일 에러!
    // iter가 std::list<int>::iterator 이라면
    // list는 std::bidirectional_iterator_tag이므로
    // 애초에 +=를 지원하지 않아서 컴파일 자체가 안 된다. 
  }
  else
  {
    if (d >= 0) { while(d--) ++iter; }
    else        { while(d++) --iter; }
  }
}

int main()
{
  std::list<int>::iterator iter;
  advance(iter, 10);
}

template<unsigned n>
struct Factorial
{
  enum { value = n * Factorial<n-1>::value };
};

template<0>
struct Factorial
{
  enum { value = 1 };
};

int main()
{
  std::cout << Factorial<5>::value;
  // 120을 런타임 계산 없이 출력 
}