[C++] template

개요

• template <typename T1, typename T2> class Test
• 특수화
  • template <typename T1, typename T2> class Test<T1 *, T2 *> {
• 부분 특수화
  • template <typename T2> class Test<int, T2> {
• 함수 템플릿
  • template <typename T1, typename T2> void func(T1 t1, T2 t2)
• 함수 템플릿 특수화
  • 특수화를 지원하지 않고 오버로딩으로 해결
  • template <> void func(char t1, string t2) {
• 논타입 템플릿 인자
  • template <typename T1, int add>
• 디폴트 템플릿 인자
  • template <typename T = int>
  • template <typename T1, int add = 5>
• 가변인자 템플릿
  • template <typename Type, typename... Types>
• fold expression
  • C++17
  • ‘…’ 위치에 따라 ‘()’의 위치를 결정
  • template <typename... Types> void func7(Types... ts) { cout << (... + ts) << endl; }
  • (E op …)
    • (E1 op (… op (EN-1 op EN)))
  • (… op E)
    • (((E1 op E2) op …) op EN)
  • (E op … op I)
    • (E1 op (… op (EN?1 op (EN op I))))
  • (I op … op E)
    • ((((I op E1) op E2) op …) op EN)
• 템플릿 메타 프로그래밍(Template Meta Programming)
  • 템플릿을 사용하여 컴파일 타임에 생성되는 코드를 이용하는 프로그래밍 기법
  • 장점
    • 컴파일 타임에 연산을 처리하므로 실행 속도 증가
  • 단점
    • 구현이 복잡
    • 코드 가독성 저하
    • 컴파일 타임에 연산을 처리하므로 디버깅 불가

예제

• 코드

   #include <functional>
   #include <iostream>
   #include <typeinfo>
      
   using namespace std;
      
   template <typename T1, typename T2> class Test {
       public:
           Test() { cout << "main" << endl; }
   };
   template <typename T1, typename T2> class Test<T1*, T2*> {
       public:
           Test() { cout << "specialization" << endl; }
   };
   template <typename T2> class Test<int, T2> {
       public:
           Test() { cout << "partial specialization 1" << endl; }
   };
   template <> class Test<int, double> {
       public:
           Test() { cout << "partial specialization 2" << endl; }
   };
      
   template <typename T1, typename T2> void func1(T1 t1, T2 t2) {
       cout << "main : " << typeid(t1).name() << ", " << typeid(t2).name() << endl;
   }
   template <typename T1, typename T2> void func1(T1* t1, T2* t2) {
       cout << "specialization" << endl;
   }
   template <typename T2> void func1(int t1, T2 t2) {
       cout << "partial specialization 1" << endl;
   }
   template <> void func1(int t1, double t2) { cout << "partial specialization 2" << endl; }
   template <int i> void func1() { cout << i << endl; }
      
   template <typename T = int> void func2(T t) { cout << typeid(t).name() << endl; }
      
   template <typename T, int add> void func3(T t, int i) { t(i + add); }
      
   template <typename T, int add = 5> void func4(T t, int i) { t(i + add); }
      
   template <typename Type> void func5(Type t) { cout << t << endl; }
   template <typename Type, typename... Types> void func5(Type t, Types... ts) {
       cout << t << ", ";
       func5(ts...);
   }
      
   template <typename... Types> void func6(Types... ts) { cout << sizeof...(ts) << endl; }
      
   template <typename Type, typename... Types> void func7(Type t, Types... ts) {
       cout << (... + ts) << endl;
       cout << (ts - ...) << endl;
       cout << (t + ... + ts) << endl;
      
       auto f = [](int i) { cout << i << endl; };
       (f(ts), ...);
   }
      
   int factorial_recursion(int n) {
       if (n == 0) {
           return 1;
       }
      
       return n * factorial_recursion(n - 1);
   }
      
   template <int N> struct Factorial_TMP {
           enum { value = N * Factorial_TMP<N - 1>::value };
   };
   template <> struct Factorial_TMP<0> {
           enum { value = 1 };
   };
      
   int main() {
       Test<char, int>();
       Test<int*, char*>();
       Test<int, char>();
       Test<int, double>();
      
       cout << "------" << endl;
      
       func1('c', 1);
       func1(new int(1), new char('c'));
       func1(1, 'c');
       func1(1, 1.1);
       func1<5>();
      
       cout << "------" << endl;
      
       func2(1);
       func2<double>(1);
      
       cout << "------" << endl;
      
       function<void(int)> f = [](int i) { cout << i << endl; };
       func3<function<void(int)>, 1>(f, 1);
       func3<function<void(int)>, 2>(f, 1);
       func4(f, 1);
      
       cout << "------" << endl;
      
       func5(1, 'a');
       func5("abc", 1.1, "!");
      
       cout << "------" << endl;
      
       func6(1);
       func6(1, 'a');
      
       cout << "------" << endl;
      
       func7(1, 2, 3);
      
       cout << "------" << endl;
      
       cout << factorial_recursion(10) << endl;
       cout << Factorial_TMP<10>::value << endl;
      
       return 0;
   }
  

• 실행 결과

  main
  specialization
  partial specialization 1
  partial specialization 2
  ------
  main : c, i
  specialization
  partial specialization 1
  partial specialization 2
  5
  ------
  i
  d
  ------
  2
  3
  6
  ------
  1, a
  abc, 1.1, !
  ------
  1
  2
  ------
  5
  -1
  6
  2
  3
  ------
  3628800
  3628800