Template basic

A simple way to simulate template is typedef int Item; But when you change the data type, you need to change header file, and you can’t have int and double to template class at the same programme. so C++ introduces a better method: template<typename T>.

Use typename, not class. At the same time. simple names, such as T.

template<typename T> swap(T& a, T&b){
.........
}

You should use templates if you need functions or container class(act likes) that apply the same algorithm to a variety of types. Templates are frequently used for container classes because the idea of type parameters matches well with the need to apply a common storage plan to a variety of types.

template class can be used as base class and used as a component class

template< typename Type>
class SpecialStack: public Stack<Type>{
Array<Type> array;
}

You can use more than one type parameter, or Default Type Template Parameters

template <typename T1, typename T2>
class Pair{ }
Pair<double, int> pair1;

template <typename T1, typename T2=int>
class Pair{ }
Pair<double> pair2;

you can use Non-Type Argument in a template

template <typename T, int n>
class ArrayTP{
T ar[n];
......
}

Class templates can be partially specialized, and the resulting class is still a template. Partial specialization allows template code to be partially customized for specific types in situations, such as:

A template has multiple types and only some of them need to be specialized. The result is a template parameterized on the remaining types.
A template has only one type, but a specialization is needed for pointer, reference, pointer to member, or function pointer types. The specialization itself is still a template on the type pointed to or referenced.

template can’t be compiled. only when you declare a variable, It will instantiation. (It will make compiling time longer). So all the template definition must be put in head file.

C++ use implicit or explicit instantiation to generate a specialized class or function definition from template For implicit, you have to declare an obj, but for explicit, you don’t need to declare an obj;

ArrayTP<int, 100> stuff //implicit instantiation
// you have to declare obj stuff.

template ArrayTP<string, 100>;
//generate a specialized class even you don’t declare an obj

Explicit Specialization: Because for char *, you can’t use > , but use strcmp. So you need to build explicit Specialization Version. The prototype and definition of an explicit spcialization should be preceded by template<> and should mention the specialized type by name.

Template<typename T>
void sortedArrary(T) {...};

template<> void sortedArray<const char *>(){...}

Explicit include complete specialization and partial specialization.

template<> class Pair<int,int>{...}; //complete specialization
template<typename T1> class Pair<T1, int>{...}; //Partial

Non type argument and default type argument only define one template body(only one recipe). But Specialization need to define a generic template body(one recipe), For another type, It need to define a different template body(another recipe), because the code will be different with generic one.

Instantiation is different with specialization. For instantiation, it will use template function to produce function body, but for specializaiton, you have to redefine you own function body

Template<typename T>
void sortedArrary (T) {...};

template void sortedArray<Person>(Person) // instantiation
template<> void sortedArray<Person>(Person){ // specialization.
.... //give you own definition of fun body.
};

keep the design of a template in mind and not use it blindly. When you input pointer as typename, you should be on high alert.

Some explicit specification syntax.

template<typename T>
void fof(T param);

//syntax 1: not a specialization, it is an overload
void foo(int param);

//syntax 2: ill-formed, not recommend
void foo<int>(int param);

//syntax 3: normal explicit specialization, specify T directly
template <> void foo<int>(int param);

//syntax4: same as above, but use template argument deduction
template <> void foo(int param);

//syntax5: same as above, but use template argument deduction
template void foo(int param);

If you want to customize a function base template and want that customization to participate in overload resolution (or, to always be used in the case of exact match), make it a plain old function, not a specialization. And, if you do provide overloads, avoid also providing specializations. Detail you can google" Why Not Specialize Function Templates?"

Explicit specification need define all the implementation in it. Avoiding code duplication in a specialized template. The only solution to this is to have as much code as possible in a base class.

template<typename T1>
struct foo_base {
    T1 m_t1;
    explicit foo_base(T1 t1) : m_t1(t1) {}
    T1 t1() const { return m_t1; }
};

template<typename T1, typename T2=void>
struct foo : foo_base<T1> {
    T2 m_t2;
    foo(T1 t1, T2 t2) : foo_base<T1>(t1), m_t2(t2) {}
    T2 t2() const { return m_t2; }
};

template<typename T1>
struct foo<T1,void> : foo_base<T1> {
    explicit foo(T1 t1) : foo_base<T1>(t1) {}
};

decltype and Trailing Return type(C++11 new feature)

template<typename T1, typename T2>
void f(T1 x, T2 y){
decltype(x+y) xpy = x+y;
}

//with return value;
template<typename T1, typename T2>
auto f(T1 x, T2 y) ->decltype(x+y)
{
x+y;
}

C++ Coding standars 65 states customization of point. In order to understand it. You need to understand two some basic conception: "two phases lookup" and "dependent name". two phase lookup can see "Dependent name lookup for C++ templates" in the ref. and "Two-Phase or Not Two-Phase: The Story of Dependent Names in Templates" in the ref.

How to make your template class has more generic use for client, "exceptional C++" item 5 introduces more idea in this topics.

1.3.1 Template basic