【C++】深入理解模板

1、简介

模板是一种代码复用方式，其它的代码复用方式还包括继承和组合。当我们使用模板时，参数由编译器来替换，这非常像原来的宏方法，但却更清晰、更容易使用。在C++中，模板实现了参数化类型的概念，放在一对尖括号中，通过template这个关键字，告诉编译器随后的定义将操作一个或更多未指明的类型，当由这个模板产生实际代码时，必须指定这些类型以使编译器能够替换它们。下面是一个简单的模板类。

template <class T> // 模板类 T为未知类型 其它的为模板相关的关键字和固定格式
class Object
{
public:
    T getValue() const { return mValue; } // 内联定义
    void setValue(T value);
private:
    T mValue;
};
template <class T> // 注意添加template声明及参数列表Object<T>
void Object<T>::setValue(T value) // 非内联定义
{
    mValue = value;
}
int main()
{
    Object<int> a; // 编译器用int类型扩展模板类Object并进行实例化
    a.setValue(100);
    a.getValue();
    return 0;
}

即使是在创建非内联函数定义时，我们还是通常把模板的所有声明和定义都放入一个头文件中，这似乎违背了通常的头文件规则，即不要放置分配存储空间的任何东西，这条规则是为了防止在链接期间的多重定义错误，但模板定义很特殊，在templage声明之后的任何东西都意味着在当时不为它分配存储空间，而是一直处于等待状态直到被一个模板示例告知。在编译器和链接器有机制能去掉同一模板的多重定义，所以为了使用方便，几乎总是在头文件中放置全部的模板声明和定义。

2、函数模板

除了上面提到的类模板，模板还可以应用于函数，见下面的例子。

template <class T>
void foo(T t) {}
int main()
{
    foo(100);
    return 0;
}

后面还会对函数模板作个详细的介绍。

3、无类型模板参数

模板参数并不局限于类定义的类型，可以使用编译器内置类型，这些参数值在编译期间变成模板的特定示例的常量。在类模板中，可以为模板参数提供默认参数，但是在函数模板中却不行，见下面的例子。

template <class T = int, int size = 100>
class Array
{
    T array[size];
};
int main()
{
    Array<int, 10> a;
    Array<int> b;
    Array<> c;
    return 0;
}

尽管不能在函数模板中使用默认的模板参数，却能够用模板参数作为普通函数的默认参数，见下面的例子。

template <class T>
T sum(T *b, T *e, T init = T())
{
    while (b != e) init += *b++;
    return init;
}
int main()
{
    int a[] = {1, 2, 3};
    int total = sum(a, a + sizeof a / sizeof a[0]); // total为6 init默认值为0
    return 0;
}

4、模板类型的模板参数

模板可以接受另一个类模板作为模板参数类型，如果想在代码中将一个模板类参数用作另一个模板，编译器首先需要知道这个参数是一个模板，见下面的例子。

template <class T>
class Array {};
template <class T, template<class> class Seq>
// template <class T, template<class U> class Seq> // U可省略
class Container
{
    Seq<T> seq;
};
int main()
{
    Conatiner<int, Array> container;
    return 0;
}

对于模板参数中的默认参数，必须在模板类作为模板参数类型时重复声明默认参数，见下面的例子，参数名同样不是必须的。

template <class T, int N = 100>
class Array {};
template <class T, template<class, int = 100> class Seq>
class Container
{
    Seq<T> seq;
};

5、typename与template

typename有两种作用，一是替代模板参数中的关键字class，二是声明模板参数类型中的嵌套类型，否则这个类型不能被识别，见下面的例子。

template <typename T>
class A
{
    typename T::Type type_t;
    type_t t; // 等同于typename T::Type t;
};

另外，在模板代码中，template关键字也能起到类似typename关键字的作用，用于提示编译器后面的符号为模板中的符号，例如尖括号解析为模板符号，而不是大于小于，见下面的例子。

template <class T, class traits, class Allocator>
basic_string<T, traits, Allocator> to_string() const;

template <class T, int size>
basic_string<T> bitsetToString(const bitset<size> &bs)
{
    return bs. template to_string<T, char_traits<T>, allocator<T> >();
}

6、成员模板

成员模板包括成员函数模板和成员类模板，在类中声明template，见下面的例子。

template<typename T>
class complext
{
public:
    template<class X> complex(const complex<X>&);
};

template<typename T>
template<class X>
complex<T>::complex(const complex<X> &r) {}

complex float x(1.2);
complex double y(x); // y的T为double y的X为float

template<class T>
class Outer
{
public:
    template<class R>
    class Inner
    {
    public:
        void foo();
    };
};

template<class T>
template<class R>
void Outer<T>::Inner<R>::void() {}

7、函数模板参数

函数模板可以像类模板一样，使用尖括号进行声明，见下面的例子，使用int类型进行特化。

template<typename T>
cont T& min(const T& a, const T& b)
{
    return (a>b) ? b : a;
}
int x = min<int>(i, j);

不使用尖括号时，可以让编译器推断出参数类型，见下面的例子，如果两个参数的类型相同，自然没有问题，但是对于一个由模板参数来限定类型的函数参数，C++系统不能提供标准转换，所以如果两个参数的类型不同时将出错，比如说一个int类型一个double类型，不能自动进行类型转换，一种解决方法是使用尖括号帮助类型转换，是int转换为double，另一种解决方法是干脆提供两个不同的模板参数，但此时的函数返回类型是个问题，不知道应该返回哪个类型是合适的。

int x = min(i, j);
int x = min<double>(i, j);

template<typename T, typename U>
cont T& min(const T& a, const U& b)
{
    return (a>b) ? b : a;
}

若一个函数模板的返回类型是一个独立的模板参数，当调用它的时候就一定要明确指定它的类型，因为这时已经无法从函数参数中推断它的类型了，见下面的例子。

template<typename T>
T fromString(const std::string& s)
{
    std::istringstream is(s);
    T t;
    is >> t;
    return t;
}
int i = fromString<int>(std::string("1234"));

结合上面提到的对函数模板的说明，如果有一个函数模板，它的模板参数既作为参数类型又作为返回类型，那么一定要首先声明函数的返回类型参数，否则就不能省略掉函数参数表中的任何类型参数，见下面的例子。

template<typename R, typename P>
R implicit_cast(cont R& p)
{
    return p;
}
int i = 1;
float f = implicit_cast<float>(i);
int j = implicit_cast<int>(f);
char *p = implicit_cast<char*>(i); // error 标准不支持这种转换

函数模板还可以取地址作为函数指针，传递给另一个函数作为参数，见下面的例子，g的参数为f时需至少指定它们中的一个的类型T，剩下的由编译器推断。

template<typename T> void f(T*) {}
template<typename T> void g(void (*pf)(T*)) {}
void h(void (*pf)(int*){) {}
int main()
{
    h(&f); // 编译器推断类型T为int
    h(&f<int>); // 明确指定T为int
    g<int>(&f<int>); 明确指定g和f的T为int
    g(&f<int>); 明确指定f的T为int 编译器推断g的T为int
    g<int>(&f); 明确指定g的T为int 编译器推断f的T为int
    return 0;
}

8、函数模板重载

函数模板可以像普通函数一样，用相同的函数名进行重载，见下面的例子，编译器会选择一个最佳匹配函数，首先是强制调用的模板函数，然后是没有进行任何类型转换的准确匹配的普通函数，然后是模板，最后是需要进行类型转换的普通函数。

template<typename T>
const T& min(const T& a, cont T& b) { return a > b ? b : a; }
template<typename T>
const T& min(const T& a, cont T& b, const T& c);
const char* min(const char* a, const char* b) { return (<strcmp(a, b) < 0) ? a : b; }
double min(double a, double b) { return a < b ? a : b; }
int main()
{
    const char* s2 = "say", s1 = "knights";
    min(1, 2); // template 没有template时将调用double版的min
    min(1,0, 2,0); // double 准确匹配
    min(1, 2.0); // double 1转换为1.0
    min(s1, s2); // const char*  准确匹配
    min<>(s1, s2); // template 尖括号强制使用template
    return 0;
}

对于重载的多个函数模板，当它们都满足调用请求时，编译器会选择一个模板特化度高的版本，见下面的例子，任何类型都可以匹配第一个模板，第二个模板比第一个模板的特化程度更高，因为只有指针类型才能够匹配它，第三个模板特化程度最高，仅仅能被指向const的指针匹配调用，如果特化程度不能进行区别对待，将带来二义性，编译器会报错，这种特征称为半有序，稍后还会详细介绍模板特化的内容。

template<class T> void f(T);
template<class T> void f(T*);
template<class T> void f(const T*);
int main()
{
    f(0); // T
    int i = 0;
    f(&i); // T*
    const int j = 0;
    f(&j); // const T*
    return 0;
}

9、模板特化

模板特化指的是指定模板参数的类型，包括显式指定的类型和编译器推断出来的类型，显式特化见下面的例子，用指定的类型替换T，并且注意尖括号中的内容。

template<class T>
const T& min(const T& a, const T& b) {}
template<>
const char* const& min<const char*>(const char* const& a, const char* const& b) {}

在标准库中也有显式特化的例子，如下。

template<class T, class Allocator = allocator<T> >
class vector {};
template<>
class vector<bool, allocator<bool> > {};

类模板也可以半特化，这意味着在模板特化的某些的方法中至少还有一个方法，其模板参数是开放的，上面例子的模板特化vector限定了T为bool类型，但没有指定参数allocator的类型，如下的例子是个半特化。

template<class Allocator>
class vector<bool, Allocator>;

上面提到了函数模板的半有序，同样，类模板也有半有序，见下面的例子，后面几个的用法中出现了二义性，因为找到了多个匹配的模板特化版本。

template<class T, class U>
class C { public: void foo(); }; // 无特化
template<class U>
class C<int , U> { public: void foo(); }; // T=int
template<class T>
class C<T, double> { public: void foo(); }; // U=double
template<class T, class U>
class C<T*, U> { public: void foo(); }; // T*
template<class T, class U>
class C<T, U*> { public: void foo(); }; // U*
template<class T, class U>
class C<T*, U*> { public: void foo(); }; // T* U*
template<class T>
class C<T, T> { public: void foo(); }; // U=T
void test()
{
    C<float, int>().foo(); // 无特化
    C<int, float>().foo(); // T=int
    C<float, doble>().foo(); // U=double
    C<float, float>().foo(); // U=T
    C<float*, float>().foo(); // T*
    C<float, float*>().foo(); // U*
    C<float*, int*>().foo(); // T* U*
    C<int, int>().foo(); // error 二义性
    C<double, double>().foo(); // error 二义性
    C<float*, float*>().foo(); // error 二义性
    C<int, int*>().foo(); // error 二义性
    C<int*, int*>().foo(); // error 二义性
}

10、模板和友元

在类模板中声明一个友元函数模板，见下面的例子，使用了前置声明，friend声明的foo使用了尖括号，这告诉编译器foo是个函数模板，模板参数依赖于类模板的参数T，当然也可以使用一个独立的不依赖于类模板参数的模板参数。

template<class T> class Friendly;
template<class T> void foo(const Friendly<T>&);
template<class T> class Friendly
{
    friend void foo<>(const Friendly<T>&);
};
template<class T>
void foo(const Friendly<T> &r) {}

11、模板和继承

见下面的例子，类Base定义了一个静态成员变量count，用于记录实例化的个数，构造函数中加1，拷贝构造函数中加1，析构函数中减1，类Child和类Child2是类Base的两个子类，然后对Child和Child2分别实例化时，发现它们共享一个静态成员变量count，这是合理的，因为它们共用一个基类，那么，每个子类独自使用一个静态成员变量count可以吗？

class Base
{
public:
    Base() { ++count; }
    Base(const Base&) { ++count; }
    ~Base() { -- count; }
    static int count;
};
int Base::count = 0;
class Child : public Base {};
class Child2: public Base {};
int main()
{
    Child c; // count=1
    Child c2; // count=2
    Child2 c3; // count=3
    return 0;
}

接着上面的问题，每个子类独自使用一个静态成员变量count是可以的，方法是使用模板，见下面的例子，因为基类为模板，所以，基类对模板参数进行了扩展，所有的子类实际上都是派生于不同的基类。

template<class T>
class Base
{
public:
    Base() { ++count; }
    Base(const Base<T>&) { ++count; }
    ~Base() { -- count; }
    static int count;
};
template<class T>
int Base<T>::count = 0;
class Child : public Base<Child> {};
class Child2: public Base<Child2> {};
int main()
{
    Child c; // count=1
    Child c2; // count=2
    Child2 c3; // count=1
    return 0;
}

12、模板元程序

模板元程序就是编译时编程，见下面的例子，用于求解斐波那契数列，是一个递归模板，模板特化提高了终止递归的条件，利用了模板的特性，所有结果都是在编译时完成的。

template<int n>
struct Fib
{
    enum { val = Fib<n - 1>::val + Fib<n - 2>::val };
};
template<>
struct Fib<1> { enum { val = 1 }; };
template<>
struct Fib<0> { enum { val = 0 }; };

13、模板编译

一般将模板的完整定义放在一个独立的头文件中，而普通函数的定义与它们的声明一般是分离的，分别放于源文件和头文件中，这样做可能是基于下面的原因。
1）头文件中的非内联函数体会导致函数多重定义，在链接时产生错误。
2）隐藏实现。
3）头文件越小，编译时间就越短。

对于模板来说，模板本质上不是代码，而是产生代码的指令，只有模板的实例化才是真正的代码。当一个编译器在编译期间已经看到了一个完整的模板定义，又在同一个翻译单元内碰到了这个模板实例化点的时候，它就必须涉及这样一个事实，一个相同的实例化点可能出现另一个翻译单元内，处理这种情况最普遍的方法，是在每一个翻译单元内都为这个实例化生成代码，让链接器清除这些副本，另一种特殊的方法也可以很好地处理这种情况，就是用不能被内联的内联函数和虚函数表，具体实现方式由编译器而定，这种模板编译方式称为模板的包含模型。包含模型的缺点是暴露了所有的代码实现，头文件比函数体分开编译时大多了，相比传统编译模型而言，大大增加了编译时间。

为了帮助减少包含模型所需要的大的头文件，C++提供了两种代码组织机制，使得模板可以将声明与实现分离，一种是显式实例化，手工实例化每一个模板特化，一种是使用导出模板，export关键字，支持最大限度的独立的编译。显式实例化见下面的例子，不使用显示实例化即min_instance.cpp时，由于模板的声明与实现分离，链接器不能找到min的int和double特化版本，将出错，解决办法是使用min_instance.cpp中的显式实例化方式，为了手工实例化一个特定的模板特化，可以在该特化的声明前使用template关键字，min_instance.cpp包含了min.cpp而非min.h是因为编译器需要用模板定义来进行实例化。

// min.h
#inndef MIN_H
#define MIN_H
template<typename T>
const T& min(const T&, const T&);
#endif

// min.cpp
#inndef MIN_CPP
#define MIN_CPP
#include "min.h"
template<typename T>
const T& min(const T& a, const T& b)
{
    return (a > b) ? b : a;
}
#endif

// min_instance.cpp
#include "min.cpp"
tempalte const int& min(const int&, const int&);
tempalte const double& min(const double&, const double&);

// min_int.cpp
#include "min.h"
void testmin_int()
{
    min(1, 2);
}

// min_double.cpp
#include "min.h"
void testmin_double()
{
    min(1.1, 2.2);
}

// main.cpp
void testmin_int();
void testmin_double();
int main()
{
    testmin_int();
    testmin_double();
    return 0;
}

我们还可以手工实例化类和静态成员变量，当显式实例化一个类时，除了一些之前可能已经显式实例化了的成员外，特化所需要的所有成员函数都要进行实例化，与隐式实例化相比，隐式实例化只有被调用的成员函数才进行实例化。

前面介绍了显式实例化，下面介绍导出模板。导出模板并不常见，可能只有部分编译器支持，使用export关键字，见下面的例子。

// min.h
#inndef MIN_H
#define MIN_H
export template<typename T>
const T& min(const T&, const T&);
#endif

// min.cpp
#include "min.h"
export template<typename T>
const T& min(const T& a, const T& b)
{
    return (a > b) ? b : a;
}

结束