C++
템플릿

소개

통사론

• 템플릿 < template-parameter-list > 선언
• C ++ 11까지 템플릿 < template-parameter-list > 선언 / * 내보내기 * /
• 템플릿 <> 선언
• 템플릿 선언
• extern 템플릿 선언 / * C ++ 11 이후 * /
• template < template-parameter-list > 클래스 ... ( opt ) 식별자 ( opt )
• template < template-parameter-list > 클래스 식별자 ( opt ) = id-expression
• template < template-parameter-list > typename ... ( opt ) 식별자 ( opt ) / * 이후 C ++ 17 * /
• template < template-parameter-list > typename 식별자 ( opt ) = id-expression / * 이후 C ++ 17 * /
• postfix-expression . 템플릿 ID 표현
• postfix-expression -> template id-expression
• 중첩 이름 지정자 template simple-template-id ::

비고

#ifndef FOO_H
#define FOO_H
export template <class T> T identity(T x);
#endif

#include "foo.h"
template <class T> T identity(T x) { return x; }

#include "foo.h"
int main() {
    const int x = identity(42); // x is 42
}

함수 템플릿

템플릿은 동일한 효과로 함수 (더 전통적인 구조)에도 적용될 수 있습니다.

// 'T' stands for the unknown type
// Both of our arguments will be of the same type.
template<typename T>
void printSum(T add1, T add2)
{
    std::cout << (add1 + add2) << std::endl;
}

그런 다음 구조 템플릿과 동일한 방식으로 사용할 수 있습니다.

printSum<int>(4, 5);
printSum<float>(4.5f, 8.9f);

이 두 경우 모두 템플리트 인수는 매개 변수 유형을 대체하는 데 사용됩니다. 결과는 일반 C ++ 함수처럼 작동합니다 (매개 변수가 컴파일러가 표준 변환을 적용하는 템플릿 유형과 일치하지 않는 경우).

템플리트 함수 (템플리트 클래스와 달리)의 또 다른 특성은 컴파일러가 함수에 전달 된 매개 변수를 기반으로 템플리트 매개 변수를 유추 할 수 있다는 것입니다.

printSum(4, 5);     // Both parameters are int.
                    // This allows the compiler deduce that the type
                    // T is also int.

printSum(5.0, 4);   // In this case the parameters are two different types.
                    // The compiler is unable to deduce the type of T
                    // because there are contradictions. As a result
                    // this is a compile time error.

이 기능을 사용하면 템플릿 구조와 함수를 결합 할 때 코드를 단순화 할 수 있습니다. 표준 라이브러리에는 make_X() 도우미 함수를 사용하여 template structure X 를 만들 수있는 공통 패턴이 있습니다.

// The make_X pattern looks like this.
// 1) A template structure with 1 or more template types.
template<typename T1, typename T2>
struct MyPair
{
    T1      first;
    T2      second;
};
// 2) A make function that has a parameter type for
//    each template parameter in the template structure.
template<typename T1, typename T2>
MyPair<T1, T2> make_MyPair(T1 t1, T2 t2)
{
    return MyPair<T1, T2>{t1, t2};
}

어떻게 도움이됩니까?

auto val1 = MyPair<int, float>{5, 8.7};     // Create object explicitly defining the types
auto val2 = make_MyPair(5, 8.7);            // Create object using the types of the paramters.
                                            // In this code both val1 and val2 are the same
                                            // type.

참고 : 이것은 코드를 단축하도록 설계되지 않았습니다. 이는 코드를보다 강력하게 만들어줍니다. 여러 위치가 아닌 단일 위치에서 코드를 변경하여 유형을 변경할 수 있습니다.

인수 전달

템플릿은 전달 참조를 사용하여 lvalue 및 rvalue 참조를 모두 허용 할 수 있습니다.

template <typename T>
void f(T &&t);

이 경우 실제 유형 t 는 컨텍스트에 따라 추론됩니다.

struct X { };

X x;
f(x); // calls f<X&>(x)
f(X()); // calls f<X>(x)

첫 번째 경우에 유형 T 는 X ( X& )에 대한 참조로 추론되고 t 유형은 X 대한 좌변 값 참조 이고 두 번째 경우에는 T 유형이 X 로 추론되고 t 유형 참조 의 유형 ~ X ( X&& ).

주의 : 첫 번째 경우에 decltype(t) 는 T 와 같지만 두 번째 경우에는 그렇지 않다는 점에 주목할 필요가 있습니다.

lvalue 또는 rvalue 레퍼런스인지 여부에 관계없이 t 를 다른 함수로 완벽하게 전달하려면 std::forward 사용해야 std::forward .

template <typename T>
void f(T &&t) {
    g(std::forward<T>(t));
}

전달 참조는 가변 템플릿과 함께 사용할 수 있습니다.

template <typename... Args>
void f(Args&&... args) {
    g(std::forward<Args>(args)...);
}

참고 : 전달 참조는 예를 들어 다음 코드에서와 같이 템플릿 매개 변수에만 사용할 수 있습니다. v 는 전달 참조가 아닌 rvalue 참조입니다.

#include <vector>

template <typename T>
void f(std::vector<T> &&v);

기본 클래스 템플릿

클래스 템플릿의 기본 아이디어는 템플릿 매개 변수가 컴파일 타임에 유형으로 대체된다는 것입니다. 결과적으로 동일한 클래스가 여러 유형에 대해 재사용 될 수 있습니다. 사용자는 클래스의 변수가 선언 될 때 사용할 유형을 지정합니다. 세 가지 예제는 main() :

#include <iostream>
using std::cout;

template <typename T>         // A simple class to hold one number of any type
class Number {
public:
    void setNum(T n);         // Sets the class field to the given number
    T plus1() const;          // returns class field's "follower"
private:
    T num;                    // Class field
};

template <typename T>         // Set the class field to the given number
void Number<T>::setNum(T n) {
    num = n;
}

template <typename T>         // returns class field's "follower"
T Number<T>::plus1() const {
    return num + 1;
}

int main() {
    Number<int> anInt;        // Test with an integer (int replaces T in the class)
    anInt.setNum(1);
    cout << "My integer + 1 is " << anInt.plus1() << "\n";     // Prints 2

    Number<double> aDouble;   // Test with a double
    aDouble.setNum(3.1415926535897);
    cout << "My double + 1 is " << aDouble.plus1() << "\n";    // Prints 4.14159

    Number<float> aFloat;     // Test with a float
    aFloat.setNum(1.4);
    cout << "My float + 1 is " << aFloat.plus1() << "\n";      // Prints 2.4

    return 0;  // Successful completion
}

템플릿 전문화

템플릿 클래스 / 메소드의 특정 인스턴스화에 대한 구현을 정의 할 수 있습니다.

예를 들면 :

template <typename T>
T sqrt(T t) { /* Some generic implementation */ }

다음과 같이 작성할 수 있습니다.

template<>
int sqrt<int>(int i) { /* Highly optimized integer implementation */ }

그런 다음 sqrt(4.0) 를 쓰는 사용자는 일반 구현을 얻지 만 sqrt(4) 는 특수 구현을 가져옵니다.

부분 템플릿 전문화

전체 템플릿 특수화 부분 템플릿 전문화와 달리 일부 기존 템플릿 고정 인수를 사용하여 템플릿을 도입 할 수 있습니다. 부분 템플릿 전문화는 템플릿 클래스 / 구조체에서만 사용할 수 있습니다.

// Common case:
template<typename T, typename U>
struct S {
    T t_val;
    U u_val;
};

// Special case when the first template argument is fixed to int
template<typename V>
struct S<int, V> {
    double another_value;
    int foo(double arg) {// Do something}
};

위에 표시된 것처럼 부분 템플릿 전문화는 완전히 다른 데이터 및 기능 멤버 집합을 도입 할 수 있습니다.

부분적으로 특수화 된 템플릿이 인스턴스화되면 가장 적합한 전문화가 선택됩니다. 예를 들어 템플릿과 두 가지 부분 특수화를 정의 해 보겠습니다.

template<typename T, typename U, typename V>
struct S {
    static void foo() {
        std::cout << "General case\n";
    }
};

template<typename U, typename V>
struct S<int, U, V> {
    static void foo() {
        std::cout << "T = int\n";
    }
};

template<typename V>
struct S<int, double, V> {
    static void foo() {
        std::cout << "T = int, U = double\n";
    }
};

이제 다음 호출 :

S<std::string, int, double>::foo();
S<int, float, std::string>::foo();
S<int, double, std::string>::foo();

인쇄 할 것이다.

General case
T = int
T = int, U = double

함수 템플릿은 완전히 전문화되어있을 수 있습니다.

template<typename T, typename U>
void foo(T t, U u) {
    std::cout << "General case: " << t << " " << u << std::endl;
}

// OK.
template<>
void foo<int, int>(int a1, int a2) {
    std::cout << "Two ints: " << a1 << " " << a2 << std::endl;
}

void invoke_foo() {
    foo(1, 2.1); // Prints "General case: 1 2.1"
    foo(1,2);    // Prints "Two ints: 1 2"
}

// Compilation error: partial function specialization is not allowed.
template<typename U>
void foo<std::string, U>(std::string t, U u) {
    std::cout << "General case: " << t << " " << u << std::endl;
}

기본 템플릿 매개 변수 값

함수 인수처럼 템플릿 매개 변수의 기본값을 가질 수 있습니다. 템플릿 매개 변수 목록의 끝에는 기본값이있는 모든 템플릿 매개 변수를 선언해야합니다. 기본 개념은 템플릿 인스턴스화 중에 기본값을 사용하는 템플릿 매개 변수를 생략 할 수 있다는 것입니다.

기본 템플릿 매개 변수 값 사용의 간단한 예 :

template <class T, size_t N = 10>
struct my_array {
    T arr[N];
};

int main() {
    /* Default parameter is ignored, N = 5 */
    my_array<int, 5> a;

    /* Print the length of a.arr: 5 */
    std::cout << sizeof(a.arr) / sizeof(int) << std::endl;

    /* Last parameter is omitted, N = 10 */
    my_array<int> b;

    /* Print the length of a.arr: 10 */
    std::cout << sizeof(b.arr) / sizeof(int) << std::endl;
}

별칭 템플릿

template<typename T> using pointer = T*;

pointer<int> p = new int; // equivalent to: int* p = new int;

template<typename T>
 struct nonconst_pointer_helper { typedef T* type; };

template<typename T>
 struct nonconst_pointer_helper<T const> { typedef T* type; };

template<typename T> using nonconst_pointer = nonconst_pointer_helper<T>::type;

템플릿 템플릿 매개 변수

때로는 값을 수정하지 않고 템플리트 유형을 템플리트에 전달하려고합니다. 이것은 템플릿 템플릿 매개 변수가 생성되는 것입니다. 매우 간단한 템플릿 템플릿 매개 변수 예제 :

template <class T>
struct Tag1 { };

template <class T>
struct Tag2 { };

template <template <class> class Tag>
struct IntTag {
   typedef Tag<int> type;
};

int main() {
   IntTag<Tag1>::type t;
}

#include <vector>
#include <iostream>

template <class T, template <class...> class C, class U>
C<T> cast_all(const C<U> &c) {
   C<T> result(c.begin(), c.end());
   return result;
}

int main() {
   std::vector<float> vf = {1.2, 2.6, 3.7};
   auto vi = cast_all<int>(vf);
   for(auto &&i: vi) {
      std::cout << i << std::endl;
   }
}

자동으로 non-type 템플릿 인자 선언하기

C ++ 17 이전에는 템플릿이 아닌 형식 매개 변수를 작성할 때 형식을 먼저 지정해야했습니다. 따라서 일반적인 패턴은 다음과 같이 작성됩니다.

template <class T, T N>
struct integral_constant {
    using type = T;
    static constexpr T value = N;
};

using five = integral_constant<int, 5>;

그러나 복잡한 표현식의 경우 이와 같은 것을 사용하려면 템플릿을 인스턴스화 할 때 decltype(expr), expr 을 써야합니다. 해결책은이 관용구를 단순화하고 auto 허용하는 것입니다.

template <auto N>
struct integral_constant {
    using type = decltype(N); 
    static constexpr type value = N;
};

using five = integral_constant<5>;

template <auto DeleteFn>
struct FunctionDeleter {
    template <class T>
    void operator()(T* ptr) const {
        DeleteFn(ptr);
    }
};

template <T, auto DeleteFn>
using unique_ptr_deleter = std::unique_ptr<T, FunctionDeleter<DeleteFn>>;

unique_ptr_deleter<std::FILE, std::fclose> p;

형식이 아닌 템플릿 매개 변수

템플릿 매개 변수와 같은 유형 외에도 다음 기준 중 하나를 충족시키는 상수 표현식의 값을 선언 할 수 있습니다.

• 정수형 또는 열거 형,
• 객체에 대한 포인터 또는 함수에 대한 포인터,
• lvalue 객체에 대한 참조 또는 함수에 대한 lvalue 참조,
• 멤버에 대한 포인터,
• std::nullptr_t .

모든 템플릿 매개 변수와 마찬가지로 형식이 아닌 템플릿 매개 변수는 템플릿 인수 공제를 통해 명시 적으로 지정되거나, 기본값으로 설정되거나, 암시 적으로 파생 될 수 있습니다.

유형이 아닌 템플릿 매개 변수 사용의 예 :

#include <iostream>

template<typename T, std::size_t size>
std::size_t size_of(T (&anArray)[size])  // Pass array by reference. Requires.
{                                        // an exact size. We allow all sizes
    return size;                         // by using a template "size".
}

int main()
{
    char anArrayOfChar[15];
    std::cout << "anArrayOfChar: " << size_of(anArrayOfChar) << "\n";

    int  anArrayOfData[] = {1,2,3,4,5,6,7,8,9};
    std::cout << "anArrayOfData: " << size_of(anArrayOfData) << "\n";
}

유형 및 비 유형 템플릿 매개 변수를 명시 적으로 지정하는 예 :

#include <array>
int main ()
{
    std::array<int, 5> foo; // int is a type parameter, 5 is non-type
}

비 형식 템플릿 매개 변수는 템플릿 반복을 달성하는 방법 중 하나이며 메타 프로그래밍 을 수행 할 수 있습니다.

가변성 템플릿 데이터 구조

template<typename ... T>
struct DataStructure {};

template<typename T, typename ... Rest>
struct DataStructure<T, Rest ...>
{
    DataStructure(const T& first, const Rest& ... rest)
        : first(first)
        , rest(rest...)
    {}
    
    T first;                                
    DataStructure<Rest ... > rest;
};

DataStructure<int, float>
   -> int first
   -> DataStructure<float> rest
         -> float first
         -> DataStructure<> rest
              -> (empty)

template<typename T, typename ... Rest>
struct DataStructure<T, Rest ...>
{
    ...
    template<size_t idx>
    auto get()
    {
        return GetHelper<idx, DataStructure<T,Rest...>>::get(*this);
    }
    ...
};

template<size_t idx, typename T>
struct GetHelper;

template<typename T, typename ... Rest>
struct GetHelper<0, DataStructure<T, Rest ... >>
{
    static T get(DataStructure<T, Rest...>& data)
    {
        return data.first;
    }
};

template<size_t idx, typename T, typename ... Rest>
struct GetHelper<idx, DataStructure<T, Rest ... >>
{
    static auto get(DataStructure<T, Rest...>& data)
    {
        return GetHelper<idx-1, DataStructure<Rest ...>>::get(data.rest);
    }
};

#include <iostream>

template<size_t idx, typename T>
struct GetHelper;

template<typename ... T>
struct DataStructure
{
};

template<typename T, typename ... Rest>
struct DataStructure<T, Rest ...>
{
    DataStructure(const T& first, const Rest& ... rest)
        : first(first)
        , rest(rest...)
    {}
    
    T first;
    DataStructure<Rest ... > rest;
    
    template<size_t idx>
    auto get()
    {
        return GetHelper<idx, DataStructure<T,Rest...>>::get(*this);
    }
};

template<typename T, typename ... Rest>
struct GetHelper<0, DataStructure<T, Rest ... >>
{
    static T get(DataStructure<T, Rest...>& data)
    {
        return data.first;
    }
};

template<size_t idx, typename T, typename ... Rest>
struct GetHelper<idx, DataStructure<T, Rest ... >>
{
    static auto get(DataStructure<T, Rest...>& data)
    {
        return GetHelper<idx-1, DataStructure<Rest ...>>::get(data.rest);
    }
};

int main()
{
    DataStructure<int, float, std::string> data(1, 2.1, "Hello");
        
    std::cout << data.get<0>() << std::endl;
    std::cout << data.get<1>() << std::endl;
    std::cout << data.get<2>() << std::endl;
    
    return 0;
}

명시 적 인스턴스화

명시 적 인스턴스화 정의는 템플릿을 사용하지 않고 구체적인 클래스, 함수 또는 변수를 만들고 선언합니다. 다른 번역 단위에서 명시 적 인스턴스화를 참조 할 수 있습니다. 이것은 유한 인수 세트로만 인스턴스화 될 경우 헤더 파일에 템플릿을 정의하는 것을 피하기 위해 사용할 수 있습니다. 예 :

// print_string.h
template <class T>
void print_string(const T* str);

// print_string.cpp
#include "print_string.h"
template void print_string(const char*);
template void print_string(const wchar_t*);

print_string<char> 및 print_string<wchar_t> 은 print_string.cpp 에서 명시 적으로 인스턴스화되기 때문에 링커는 print_string 템플리트가 헤더에 정의되지 않은 경우에도이를 찾을 수 있습니다. 이러한 명시 적 인스턴스화 선언이 없으면 링커 오류가 발생할 수 있습니다. 헤더 파일에 템플릿 만 구현할 수있는 이유는 무엇입니까?를 참조하십시오 .

#ifndef FOO_H
#define FOO_H
template <class T> void foo(T x) {
    // complicated implementation
}
#endif

#include "foo.h"
// explicit instantiation definitions for common cases
template void foo(int);
template void foo(double);

#include "foo.h"
// we already know foo.cpp has explicit instantiation definitions for these
extern template void foo(double);
int main() {
    foo(42);   // instantiates foo<int> here;
               // wasteful since foo.cpp provides an explicit instantiation already!
    foo(3.14); // does not instantiate foo<double> here;
               // uses instantiation of foo<double> in foo.cpp instead
}