泛型编程是C++继面向对象编程之后的又一个重点，是为了编写与具体类型无关的代码。而模板是泛型编程的基础。模板简单来理解，可以看作是用宏来实现的，事实上确实有人用宏来实现了模板类似的功能。模板，也可以理解为模具行业的模型。根据分类，有函数模板和类模板。根据传入的不同模板参数，函数模板会生成不同模板函数。类模板则生成不同的模板类。

模板参数

1.    概念

模板定义以关键字template开始，<>中是模板参数列表(template parameter list)，模板参数列表即表示可以是一个或多个模板参数(template parameter)。

模板实参则是在实例化函数模板或是类模板时的类型或值。

 模板形参是通过模板实参推导出来的或是直接显式指定。

 模板参数和普通函数参数一样，可以有默认值参数。

2.    模板形参分类

类型参数(type parameter)

　　表明这个模板参数是一个类型。

　　template<class/typename T, ……>

非类型参数(nontype parameter)

　　表明这个模板参数不是一个类型，而是常量数值，只能是整形、指针和引用。

template<int N, ……>  template<class/typename T, int N, ……>  // 例  template<const int* pM>  void Test1(){}  template<const char M>  void Test2()  {  int nArr[M] = {0};  }    class A{};  template<A& AA>  void Test3(){}  const int n = 4;  extern const int arr[] = {1, 2, 3};          A a;    int _tmain(int argc, _TCHAR* argv[])  {  Test1<arr>();    Test2<n>();    Test3<a>();    return 0;  }

3.    模板实参

模板实参推断(template argument deduction)

　　编译器使用函数调用中的实参类型来推断出模板实参，然后用这些实参生成对应的函数。

显式模板实参(explicit template argument)

　　类模板生成具体的模板类，都是显式模板实参来实现的。

MyClass<int> myClass;  Set<int>(4);

有些模板函数没有实参，这时就必须通过显式模板实参来生成对应的模板函数。

　　模板函数有实参，但是类型可能无法正确推导，这时也可以加上显式模板实参的。

　　模板函数有实参，并且能够正确推导类型，这个时加与不加显式模板实参均可。

函数模板

1.    概念

　　函数模板，就是根据模板形参的不同，生成不同的模板函数。

　　有些模板函数没有实参，这时就必须通过显式模板实参来生成对应的模板函数。

　　模板函数有实参，但是类型可能无法正确推导，这时也可以加上显式模板实参的。

　　模板函数有实参，并且能够正确推导类型，这个时加与不加显式模板实参均可。

函数模板

1.    概念

　　函数模板，就是根据模板形参的不同，生成不同的模板函数。

template<class/typename T, ……>retType FunctionName(parameter)  {// Function Body}

class和typename在此处意义一样，只是用class容易被人误解为后面的形参T是类。

　　函数模板在没有实例化时，只是一个生成函数的模板。

　　而在具体的实例化之后，即指明具体的形参，就生成了一个具体的模板函数。

2.    声明和定义

　　函数模板与普通函数一样，声明与定义可以分开，也可以一起。

声明

template<typename T>  bool Compare(T t1, T t2);

 定义

template<typename T>  bool Compare(T t1, T t2)  {return (t1 > t2);  }

类模板

1.    概念

　类模板根据模板形参的不同，生成不同的模板类。

template<class/typename T, ……>class ClassName  {// Class definition};

类模板，在没有实例化之前，只是一个生成类的模板。

而在具体的实例化之后，其实就生成了一个具体的模板类。

2.    声明与定义

声明

template<class/typename T>  class ClassName  {  　　// Class Declaration  　　void Test();  };

定义

　　直接在类模板内部定义成员函数，也可以在模板类的外部定义成员函数。

template<class/typename T>void ClassName<T>::Test()  {  }

前置声明

　　和普通的函数声明一样，参数指明与不指明均可。

template<class/typename T> class ClassName;  template<class/typename> class ClassName;

             类的类型成员

1.     概念

　　T::size_type *p;

　　编译器无法识别上面是定义一个指针变量p，还是一个T中的一个静态成员变量size_type与变量p相乘。

　　所以引入了typename来标识后面T::后面的类型，而不是变量。注意此处只能用typename，不能用class。

struct NEW_TYPE  {  public:  typedef int n_size;  };    template<typename T>  typename T::n_size Set(typename T::n_size _n)  {  　　typename T::n_size m = 2;  　　T::n_size n = 3;  　　T::n_size* p;  　　return n;  }

VS编译器不能识别T::n_size是一个静态常量还是一个类型，所以这个时候需要用typename来标识它是一个类型。VS编译器能够识别T::n_size* p;经测试返回类型以及形参类型时必须用typename指定其为类型。

模板编译与链接

1.    编译

　　C++是采用声明和实现分在两个文件中，因为这样可以使用分离编译。编译每个cpp文件，如果遇上外部函数只需要记录其名字即可。模板代码，一般放在hpp文件中，即声明和实现代码在一起。因为C++是编译型语言而不是解释型语言，所以模型的具体实现代码编译时必须确定下来。模板在某种程度上，类似于宏，甚至有人用宏实现类似模板的功能。很多时候一个类模板会包括很多功能，为了防止代码膨胀，编译模板时编译器会自动识别用到的函数，用到的类，也就是只编译用到的。也就是我们模板中，有一些函数如果没有用一以，哪怕其中有语法错误，也不会被编译到，自然也就不会报错了。

　　那么在多个CPP文件中用到了相同形参的函数模板，因为CPP是分离编译的，所以每个CPP文件中都会编译出一个相同的模板函数

2.    链接

　　每个Cpp编译之后，生成一个obj的目标文件，然后链接器链接这些目标文件生成DLL或exe。链接的过程中，链接器会检查是否有重复定义，抑或库冲突之类的。链接的时候，链接器会使用前面已经生成的模板函数，自动放弃后面生成的模板函数，这样能够防止重复定义以及可能避免代码膨胀导致的exe增大。这种方式导致的一个坏处是，大幅增加编译时间，因为用到的模板都会实例化并进行编译。

模板能不能使用分离编译呢？网上基本上都说不能，理由是模板实现代码放在CPP中时，并不知道具体的模板参数类型，所以无法编译。既然无法知道模板的具体形数，那么就解决这个问题,告诉编译器具体的形参。

显式实例化

1.    概念

　　显式实例化(explicit instantiation)，就是显式地告诉编译器模板形参的类型或值。

extern template declaration;          // 外部实例化声明  template declaration;                  // 实例化定义  extern template void Test<int>(const int& _t);  template void Test<int>(const int& _t);  extern template class Ctest<char*>;  template class Ctest<char*>;

extern在修饰模板声明时的作用与声明全局变量的作用一样，就是告诉编译器，当前修饰的声明已经在其他CPP文件中定义。

实例化定义，一种是直接显式实例化，另一种是隐式实例化即编译器识别到CPP中有模板的实例化代码也同样会实例化。

外部实例化声明是为了解决重复实例化，提升编译效率。但是习惯了声明和定义分开的编程习惯。我们同样可以用显式实例化来分离编译。函数模板和类模板的显式实例化方法一样的。

2.    实例

　　h文件只用来存放模板声明

// fun.h file  template<typename T>  void Test(const T& _t);  // cpp文件存放定义及具体的实例化定义，即显式实例化。这样实例化肯定只有一次，并且结构清晰。这种方式适用于模板实例化的具体类型不多的情况。因为如果模板是库文件，不停修改是不方便的。    // fun.cpp file  template void Test<int>(const int& _t);  template void Test<float>(const float& _t);    template<typename T>  void Test(const T& _t)  {      T t = _t;  }

尾置返回类型

1.    概念

　　尾置返回类型(trailing return type)是在形参列表后面以->符号开始标明函数的返回类型，并在函数返回类型处用auto代替。尾置返回类型即可以直接指明类型，也可以用decltype推出出类型

2.    实例

auto Function(int i)->int  auto Fun3(int i)->int(*)[5]          // 返回指定数组的指针  int n = 10;  auto Function(int i)->decltype(n)  template<class T, class W>  auto Function(T t, W w)->decltype(t+w)  {  return t +w;    }  // 如果是自定义类型,则应该重载+实现t+w

3.    备注

　　注：C++14中，已经将尾置返回类型去掉了，可以直接用auto推导出类型。

　　参考：msdn.microsoft.com/en-us/library/dd537655(v=vs.100).aspx

函数模板指针

1.    普通函数指针

　　因为C++要兼容C，所以函数名加&与不加都表示函数指针。

实例化的模板函数的指针

template<typename T>  void Test(const T& _t)  {      T t = _t;  }    typedef void (*pTest)(const int& _t);  pTest p = Test<int>;  pTest pT = &Test<float>;  p(3);

用模板参数来指代函数指针

template <typename T, typename NAME_TYPE>    void TestFun(T fun, NAME_TYPE n)  {      fun(n);  }    TestFun(Test<int>, 4);  TestFun(&Test<double>, 4.0); // 用&与否均可

2.    类成员函数指针

类静态成员函数指针

　　和普通函数指针一样，都是__cdecl的调用方式，只能直接调用。

　　CMyClass<int>::pFunCalc pCalc = CMyClass<int>::Calc;

　　pCalc();

 类成员函数指针

　　成员函数指针声明时必须是&ClassName::,这是自VS2005之后就必须要求，以前类名加与不加&均可。其实不加&不规范，因为函数名并不是指针。函数名是对象，取地址是才是指针。自VS2005之后，类函数名指针必须加&。并且类函数指针调用时，必须指明调用对象标明是__thiscall的调用方式(这是类函数特有的调用方式，因为它会将类指针作为参数传递进去)。

CMyClass<int> myClass;  CMyClass<int>::pFunSetValue pSet = &CMyClass<int>::SetValue;  myClass.SetValue(4);  (myClass.*(&CMyClass<int>::SetValue))(4);  (myClass.*pSet)(4);  myClass.TestFun(pSet, 4);  myClass.TestFun(&CMyClass<int>::SetValue, 4);     // 模板代码  template<typename T>  class CMyClass  {  public:      // 普通函数的参数传递方式,默认可以不加__cdecl      typedef int (__cdecl *pFunCalc)();           // 标识这是一种__thiscall的参数传递方式,类成员函数特有的      typedef void (CMyClass::*pFunSetValue)(const T& _t);  public:        void TestFun(pFunSetValue _pFun, const T& _t)      {          // 成员函数指针必须指明调用对象标明是__thiscall的调用方式         (this->*_pFun)(_t);         (this->*(&CMyClass<T>::SetValue))(4);    // 静态函数和普通一样,不用指明调用对象,表明__cdecl的调用方式           (*(&CMyClass<T>::Calc))();                          }        void SetValue(const T& _t)      {          m_t = _t;      }        static int Calc()      {          T t = 2;          return t*2;      }    private:      T m_t;  };    // 在另外的类中使用成员函数指针  template<typename T>  class CMyTest  {  public:       typedef void (CMyClass <T>::*pFunSet)(const T& t);         void TestFun(MyClass<T>* p, pFunSet fun, T t)       {                (p->*fun)(t);       }         void Test(MyClass<T>* p, typename CMyClass <T>:: pFunSetValue fun, T t)       {                (p->*fun)(t);       }    };

模板特化与偏特化

1.    概念

模板的特化

　　即模板的特殊化，即模板的通胀算法不能满足特殊实例。那么即需要单独的代码来处理特殊的实例。而实例是根据不同的形参类型决定的。特化就是处理模板的某一特殊模板形参。形式：

template<typename T1, typename T2> class Test{};  template<typename T1, typename T2> void Set(T1 t1, T2 t2){}  // specialization  template<> class Test<int, int>{};  template<> void Set(int t1, int t2){}  // call the special function  Test<int, int> test;  Set(4, 3);  Set<int, int>(4, 3);

模板的偏特化

　　模板的偏特化只能用于类模板，不能用于函数模板，函数模板只有重载。

template<typename T1, typename T2> class Test{};  template<typename T1, int N> class TestNon{};  // partial specialization  template<typename T1> class Test<T1, int>{};  template<typename T1> class TestNon<T1, 5>{};  Test<char*, int> test;  TestNon<int, 5> testNon;

2.    应用

　　因为特化和偏特化均是在编译时实现的。所以我们能够将一些逻辑判断移到编译期来做。这样能够提前测试代码，因为编译期发现错误比运行过程中容易。模板元编程就是这样实现的。另外我们可以用特化来处理一些异常。将异常情况移到特化代码中处理，这样主代码的逻辑就会更简单清晰。

类型模板形参

// Boost中一个例子。   template< typename T >   struct is_pointer  {        static const bool value = false;   };     template< typename T >   struct is_pointer< T* >  {        static const bool value = true;   };

这样我就可以通过is_pointer<T>::value来判断当前类型是否为指针类型。

非类型模板形参

Template<bool b>  Struct algo_sort  {  　　Template<typename T>  　　Static void sort(T& obj)  　　{  　　　　Quick_sort(obj);  　　}  }    Template<>  Struct algo_sort<true>  {  　　Template<typename T>  　　Static void sort(T& obj)  　　{  　　　　Select_sort(obj);  　　}  }

这样就能够通过模板形参的不同调用不同的排序方法。

仿函数

 1.    概念:

　　仿函数(functor)，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

// alg_for_each.cpp  // compile with: /EHsc  #include <vector>  #include <algorithm>  #include <iostream>    // The function object multiplies an element by a Factor  template <class Type>  class MultValue  {  private:     Type Factor;   // The value to multiply by  public:     // Constructor initializes the value to multiply by     MultValue ( const Type& _Val ) : Factor ( _Val )       {     }       // The function call for the element to be multiplied     void operator ( ) ( Type& elem ) const     {        elem *= Factor;     }  };    int main( )  {     std::vector <int> v1;     std::vector <int>::iterator Iter1;       // Constructing vector v1     for ( int i = -4 ; i <= 2 ; i++ )     {        v1.push_back(  i );     }       // Using for_each to multiply each element by a Factor     std::for_each ( v1.begin ( ) , v1.end ( ) , MultValue<int> ( -2 ) );    }

2.    解析

　　上面标注为红色的代码，因为类MultValue重载了括号运算符，光看代码，很容易将这里理解成了括号运算。但这是错误的理解。首先我们回到for_each这个函数本身的理解上来，MSDN对第三个参数给出的解释：User-defined function object that is applied to each element in the range. 可以知道，第三个参数是一个函数对象。

　　 这里就需要我们有这样一个概念，如果一个类重载了括号运算符，那么这个类建立的对象就具有类似函数的功能。这样的话，那么第三个参数就可以是一个重载了括号的对象了。

MultiValue<int> & mValue =  MultValue<int> ( -2 );  for_each ( v1.begin ( ) , v1.end ( ) , mValue);                          // 1                                 for_each ( v1.begin ( ) , v1.end ( ) , MultValue<int> ( -2 ) );               // 2

直接用上面这种方式来写会好理解多了。再来理解MultValue<int> (-2)这样一句代码，它直接生成了一个无名的临时对象，然后初始化一个引用。MultValue<int> (-2)；这样的一句话，将直接调用构造函数生成一个无名的临时对象。这样看来，上面的语句1和语句2其实是一个意思。

　　for_each函数的第三个函数本来可以直接用一个用户定义的函数来完成，但是为什么MSDN中多用重载类的括号运算符来完成这样的功能呢？通过上面的例子，我们可以发现，主要表现类的构造函数上，可以初始化不同的参数，这一点是自定义的函数所不具备的。另外，利用结构体还能把可能用到的函数封装到一个结构体中，便于管理。

 　　这样回头看以前常用的sort函数。

vector<int> vInt;  sort(vInt.begin(), vInt.end(), greater<int> ());  sort(vInt.begin(), vInt.end(), less<int> ());    // STL中的less<int>的代码.  // TEMPLATE STRUCT less  template<class _Ty>  struct less  : public binary_function<_Ty, _Ty, bool>  {        // functor for operator<    　　bool operator()(const _Ty& _Left, const _Ty& _Right) const  　　{        // apply operator< to operands  　　　　return (_Left < _Right);  　　}  };  // 在C++中struct基本上和class一个意思

greater<int>()和less<int>()也是直接构建一个无名对象，然后调用重载的括号运算符。

其他

函数模板可以重载，和普通函数重载类似，函数模板重载某些时候能也达到特化的效果。

　　template<typename M, typename N>  void TestSpec(M m, N n){}

　　template<typename M>  void TestSpec(M m, int n){}

　　void TestSpec(int m ,int n){}

类模板中，还可以添加成员模板函数。

友元模板类需要前到前置声明。

派生类只能从模板类派生(类模板的一个实例化)。

原文链接：https://www.qiquanji.com/post/7502.html

本站声明:网站内容来源于网络,如有侵权,请联系我们,我们将及时处理。