C++ Templates学习笔记之：函数模板

我是C/C++的新手。这篇文章介绍了在看《C++ Templates》第二章时的一点读后笔记。记下来，以便将来忘了能很快的回忆起来。期待高手的指教。

一：模板参数的推导。
简单的说，可以把模板看作一种类型，函数模板也不例外。既然是类型，那么我们在使用模板函数的时候就应该是使用它的一个实例。既然是类型与实例的关系，那么就应该有一个类型的实例化的问题。我们对普通类型进行实例化的时候通常需要提供必要的参数以，模板函数也不例外。只是模板函数的参数不是普通的参数，而是特定的类型。也就是说在实例化一个函数模板的时候需要以类型作为参数。通常，模板的参数分为模板参数和调用参数。例如：

1  template  < typename T 1, typename T2, typename RT>
2  inline RT  const &  max(T1 const &  a, T2 const &  b)
3  {
4      //TODO: 代码实现
      ........
5  }

其中，第一行定义了函数模板参数；第二行的函数参数则定义了调用参数，需要注意的是返回值并不属于函数模板的调用参数。

在调用一个模板的时候，最重要的是在调用的时候能正确的推导出模板参数。这里有几点要注意的：
  1：显示的实例化函数模板。例如：    

 1  template  < typename T >
 2  inline T  const &  max(T  const &  a, T  const &  b)
 3  {
 4       return  a  <  b  ?  b : a;
 5  }
 6 
 7 
 8 
 9  //  实例化并调用一个模板
10  max < double > ( 4 ,  4.2 );

     第十行，通过显示的指定模板参数为double而实例化了一个模板。
  2：隐式的实例化一个函数模板。例如：

1  template  < typename T >
2  inline T  const &  max(T  const &  a, T  const &  b)
3  {
4       return  a  <  b  ?  b : a;
5  }
6 
7  //  隐式的实例化并调用一个函数模板
8  int  i  =  max( 42 ,  66 );

     第8行，我们没有显示的指定函数模板参数，但它能自动的去推导出函数模板参数为int。
     这里可能有个问题。如果非模板函数它的定义和推导后的模板函数实例一样，会产生什么结果呢？例如：

 1  inline  int   const &  max( int   const &  a,  int   const &  b)
 2  {
 3       //  为了便于区分，让返回结果＋100
 4       return  a  <  b  ?  a + 10  : b + 100 ;
 5  }
 6 
 7  template  < typename T >
 8  inline T  const &  max(T  const &  a, T  const &  b)
 9  {
10      return  a  <  b  ?  b : a;
11  }
12 
13  //  这里调用的究竟是模板函数还是非模板函数？
14  int  i  =  max( 42 ,  66 );

实际上，第14行的代码首先回去查看是否有满足要求的非模板函数；如果没有，再根据参数去匹配并实例化相应的模板函数。所以，它调用的应该是非模板的max函数。

  3： 也可以使用部分缺省的模板参数。你不用指定全部的模板参数，比如，你可以从左到右的，指定一部分参数。例如：

 1  //  从左至右定义了三个参数
 2  1  template  < typename RT, typename T1, typename T2 >
 3  2  inline RT  const &  max(T1  const &  a, T2  const &  b)
 4  3  {
 5  4       // TODO: 代码实现
 6        ..
 7  5  }
 8 
 9  //  可以只指定第一个返回参数。即，要求返回double类型
10  max < double > ( 4 ,  4.2 );

上面的代码中，由于返回参数类型不属于调用参数，所以必须明确的指定它为double类型。而T1和T2属于调用参数，能从函数调用中推导出来。

二：模板函数的重载。
通普通函数一样，模版函数也可以重载。只是注意两点。
  1：实例化后的模版函数如果和某个非模版函数的调用一样的情况，会调用非模版函数。但也可以指定调用模版函数，如：

 1  inline  int   const &  max( int   const &  a,  int   const &  b)
 2  {
 3       //  为了便于区分，让返回结果＋100
 4       return  a  <  b  ?  a + 10  : b + 100 ;
 5  }
 6 
 7  template  < typename T >
 8  inline T  const &  max(T  const &  a, T  const &  b)
 9  {
10      return  a  <  b  ?  b : a;
11  }
12 
13  //  这里模版函数实例化后的形式和一个非模版函数一致。可以使用下面的方法指定调用模版函数
14  int  i  =  max<>( 42 ,  66 );

  2：由于模版函数的参数是类型，因此它不支持类型转化。但非模版函数支持类型转换：

 1  inline  int   const &  max( int   const &  a,  int   const &  b)
 2  {
 3       return  a  <  b  ?  b : a;
 4  }
 5 
 6  template < typename T >
 7  inline T  const &  max(T  const &  a, T  const &  b)
 8  {
 9       return  a  <  b  ?  b : a;
10  }
11 
12  //  由于模版函数不支持类型转换，这里将调用非模版的max函数
13  max( ' c ' ,  42.2 );

试想上面的代码中，如果max('c', 42.2)要调用模板的max函数，它必须满足两个参数和返回值都是同一类型的条件。而给定的两个参数类型不一致，模板函数又不支持类型转换。因此，它找不到相匹配的模板函数，将会调用非模板的max函数。而如果我们强制使用max<>('c', 42.2)调用模板函数的话将会出现编译错误。

  3：和指针有关的重载。

 1  #include  " stdafx.h "
 2  #include  < iostream >
 3  #include  < string >
 4 
 5  template < typename T >
 6  inline T  const &  max(T  const &  a, T  const &  b)
 7  {
 8       return  a  <  b  ?  b : a;
 9  }
10 
11  //  求两个指针所指值的最大者
12  template < typename T >
13  inline T   const &  max(T *   const &  a, T *   const &  b)
14  {
15       return   * a  <   * b  ?  *b : *a;
16  }
17 
18  //  求两个字符串的最大者
19  inline  char   const *   const &  max( char   const *   const &  a,  char   const *   const &  b)
20  {
21       return  strcmp(a, b)  <   0   ?  b : a;
22  }
23 
24  int  _tmain( int  argc, _TCHAR *  argv[])
25  {
26       //  比较两个int的最大值，将调用第一个max模版
27       int  a  =   7 ;
28       int  b  =   42 ;
29      std::cout << " max(a, b)==> " << ::max(a, b) << std::endl;
30 
31       //  比较两个string的最大值，将调用第一个max模版
32      std:: string  s  =   " hey " ;
33      std:: string  t  =   " you " ;
34      std::cout << " max(s, t)==> " << ::max(s, t) << std::endl;
35 
36       //  比较两个指针所指内容的最大值，将调用第二个max模版
37       int *  p1  =   & a;
38       int *  p2  =   & b;
39      std::cout << " max(p1, p2)==> " << ::max(p1, p2) << std::endl;
40 
41       //  比较两个c字符串的最大值，将调用第三个非模版max函数
42       char   const *  s1  =   " David " ;
43       char   const *  s2  =   " Nico " ;
44      std::cout << " max(s1, s2)==> " << ::max(s1, s2) << std::endl;
45 
46       return   0 ;
47  }
48 

上面的代码有需要注意：1)：max(a, b)和max(s, t)调用的是同一个max模版函数。因为他们满足第一个模版函数的定义，只是类型不一样而已。
2)：max(p1, p2)的调用有点玄乎。可以参照我的另一篇笔记：指针作为模板参数时参数类型的推导问题
3)：max(s1, s2)会调用第三个非模版的max函数。不会使用第二个模版函数产生新的实例。

三：非常重要的一点，使用指针的时候千万要注意不要返回临时变量的指针。参见我的另一篇笔记：
     使用模板函数返回临时变量的指针的问题

转载于:https://www.cnblogs.com/zhaoxb1982/archive/2009/07/30/1534885.html