( w/ s0 t) L5 l" F/ s
* U  X/ K9 K9 Y# K' S  u/ A  E
& ^$ p  G6 v2 I

一、函数模板的引出：

1、c++中有几种交换变量的方法：

(1)定义宏代码块

(2)定义函数

代码版本一：

#include <iostream>
! z$ s  F+ F/ S3 l+ f#include <string>

. P% E$ L% j, y9 N) `. zusing namespace std;

7 m+ y( y3 Y1 c* C" _#define SWAP(t,a,b)   \
do                    \
* ~' L- q8 f5 a* h; m* g8 k{                     \
' Y) V, b+ P) x  O' Z# i     t c =a;          \
     a =b;            \
! Y( I: G# O! B% f1 C     b = c;           \
1 m! X3 T8 C1 M" C. L}while(0)
7 H5 i5 [" V3 k
int main()
{
5 t5 V. r  @; j0 X( w" x0 t     int a =2;
. U" N$ H5 {5 O. ~7 T1 {     int b =5;
  @& ~+ Q' p' H3 W5 H* Z0 m8 w: X
     SWAP(int , a , b );
     cout<<"a= "<<a<<endl;
     cout<<"b= "<<b<<endl;
0 O! [& Y2 ^+ Q$ a7 t
, U8 ?+ ]2 o1 [- H5 W4 v     double m =4;
     double n =6;
& G2 K: r( Y# O) V! [0 ~3 R1 R/ ]     cout<<"m = "<<m<<endl;
  z2 E" B5 u! C2 V1 v4 K4 b     cout<<"n= "<<n<<endl;
. W$ K: [8 u- g9 h# z: _% Q3 f
! N  m) R( ?/ \4 S: }     return 0;

/ P8 G3 V9 t- V3 y  K& I/ C$ U) L}
+ n- O2 ^" u% J% @# ~! D# B- T
3 O2 O# [& \3 x! B

输出结果：

root@txp-virtual-machine:/home/txp# ./a.out
, \1 P2 X2 I6 Q5 g) S2 W% c6 Pa= 5
b= 2
m = 4
n= 6
8 H% b: W! A5 f1 ]6 u6 x3 @- P

注解：我们看两个数值交换成功。

我们再用使用函数的方式来实现这个功能，当然以前我们在c语言里面使用指针传参方式来实现这种两个数值直接的交换，现在我们利用c++里面更加高级的方式来实现，就是使用引用来实现（不过它的本质还是指针来实现，只是我们只用引用再不用去考虑指针的细节了）

代码版本二：

#include <iostream>
#include <string>
3 L" ^5 {, A: s3 T5 ]9 Z8 @using namespace std;

( W! \+ i+ _# a3 @9 W
void Swap(int& a , int& b )//const int * a ,const int * b '
; a6 z8 C) U! n/ _3 V{
' s0 a5 l, ^) g$ R! I    int c =a;
0 v) ?9 H+ P) Z3 A    a=b;
! ]9 V7 Z! S! h7 V+ v0 P3 E    b=c;
3 |. t/ s1 w: \0 x, f}
3 [/ ^9 j0 o) s4 @/ yvoid Swap(double& a,double& b)
{
    double c =a;
1 }2 Z6 S" T- T3 Y+ |    a=b;
6 X+ w; C& v# e    b=c;
5 P8 C5 ?8 e$ e( R  p; }6 _}

void Swap( string& a, string& b)
) U+ p5 I. u' v{
    string c =a;
9 s( S7 f/ S* C) n% F    a=b;
    b=c;
}
int main()
{
  int a =2;
1 J; l' H1 I% d' \2 W  int b =5;

  Swap(a,b);
  cout<<"a= "<<a<<endl;
1 f  G1 \& s5 U5 e* M  cout<<"b= "<<b<<endl;

  double m =4;
' _; q2 v; r0 z& a0 Y% i  double n =6;
  cout<<"m= "<<m<<endl;
  cout<<"n= "<<n<<endl;

  string d = "Txp";
, Q5 b/ i. S% [2 E- q  string t = "xiaoping";

  cout<<"d= "<<d<<endl;
  cout<<"t= "<<t<<endl;

9 E' _# E( g  E  return 0;
}

输出结果：

root@txp-virtual-machine:/home/txp# ./a.out
( K* t3 p# F- @/ _) U0 sa= 5
b= 2
m= 4
n= 6
d= Txp
- {: R9 q3 v% |( k8 jt= xiaoping
  y: i, L- o: e3 V/ i4 n4 B

注解：同样实现了交换功能。

2、两种方法的优缺点：

定义宏代码块

-优点：代码复用，适合所有的类型

-缺点：编译器不知道宏的存在，缺少类型检查

定义函数

-优点：真正的函数调用，编译器对类型进行检查

-缺点：根据类型重复定义函数，无法diam复用，从上面的试验结果可以看出，我们每次都对Swap()函数进行重新定义，定参数的类型不一致的时候

二、泛型编程闪亮出场：

1、泛型编程的概念：

不考虑具体数据类型的编程方式，我们可以继续拿我们刚才的那个Swap函数进行改造，改成我们现在的泛型写过：

void Swap(T& a, T& b)
0 @( ]4 ]- `9 C4 D{
     T t =a;
- @8 a% B, v+ Y) R8 ^7 l3 {4 n* q4 U     a =b;
     b =t;
}

注解：Swap泛型写法中的T不是一个具体的数据类型，而是泛指任意的数据类型，这一点非常重要，明显有了很大提升。

2、C++中泛型编程

(1)函数模板：

• -一种特殊的函数可用不同类型进行调用
• -看起来和普通函数很相似，区别是类型可以被参数化
  
    j1 `, S% v4 \; g

template<typename T>
void Swap(T& a, T& b)
* U- ^* J$ z& T5 I2 O2 V" x- }{
   T t = a;
   a = b;
0 B& R" n% T  m% Y# S# w   b = t;
! m7 Z, n5 Z, P, s' P1 e}

(2)函数模板的语法规则：

• template关键字用于声明开始进行泛型编程
• template关键字用于声明泛指类型
  
  

(3)函数模板的使用

• 自动类型推导调用
• 具体类型显示调用
  
  

int a = 0;
int b =1;
Swap(a,b)//这里属于自动推导
( h& F/ ]" v. B& z/ w+ Z
2 t/ s/ C8 C, C0 \. ~float c =2;
float d =6;

Swap<float>(c,d);//这里属于显示调用
4 M: ], j6 Y( }' _% {3 y

代码实践：

#include <iostream>
3 [+ p8 w$ _/ h* @. x( P. @#include <string>
using namespace std;
3 P$ }( ~5 }- O( a1 M2 A; xtemplate < typename T >// 开始泛型编程，泛指类型是 T；在下面函数定义中用 T 可以代表类型；
. K: Z7 r# S1 _7 n7 yvoid Swap(T& a, T& b)
{
    T c =a;
  X) w& @, x; K# Y. V1 a    a=b;
    b=c;
}
) H7 q& {1 s+ o# s2 k
template < typename T >
6 K8 b# [& e' I( D! Ivoid Sort(T a[], int len)
{
+ N& T0 c3 @- q) @+ J- ?0 ~5 Q   for(int i=0;i<len;i++)
8 ~) f4 f* D2 g3 G1 J  k" j   {
      for(int j=i;j<len;j++)
      {
         if(a > a[j])
0 z* v, J% \3 \; b  O1 \# l0 `         {
             Swap(a,a[j]);
* s6 S$ N# J) \, z3 |. t         }
      }
   }
5 m3 O6 X* w2 D: _
}


template < typename T >
( K* o" X+ A  f# V/ pvoid Println(T a[], int len)
{
      for(int i=0;i<len;i++)
      {
           cout<<a<<",";
      }
      cout<<endl;
}

int main()
{

5 X6 ?' `8 ]# `$ l  int a=3;
4 V( _6 j( g. _1 o2 w' `# S( v   int b=5;

3 x" ^  T" T+ ^0 d9 q* \   Swap(a,b);//自动推导，等价于 Swap<int>(a, b);
2 d" J/ o% g" P  w6 w   cout<<"a= "<<a<<endl;
   cout<<"b= "<<b<<endl;
; j5 V% T. s% f& v4 v- j
* C5 J, Y( j8 [- o+ l. V3 z1 Z   double m =4;
# t& E* v6 t  W% |, U* f% |   double n=6;

   Swap(m,n);
9 O+ }- A% H# H. F   cout<<"m= "<<m<<endl;
7 @; U! P6 h6 q: l9 B3 K4 V0 U   cout<<"n= "<<n<<endl;


   string d = "Txp";
0 F5 W( O! |6 Z0 E: m   string t ="xiaoping";
- J' K& O- i& Y+ m. |6 J+ p
; C; E7 {+ V5 U: k0 E+ U   Swap<string>(d,t);//显示指定；将 T 替换成 string，然后进行调用；
* d' @" a  H- H! T) }   cout<<"d= "<<d<<endl;
   cout<<"t= "<<t<<endl;
+ M% P* j3 p2 g2 v& I: L- e
/ i5 s+ r. r" |4 r! ?8 ^
0 H5 j7 M2 V: Q% T$ M0 u; w
% M6 J, e! f$ `5 C
8 {( R( n. x9 D6 D6 W     /* 以下是选择排序算法测试代码 */
6 C: X1 {, B/ p  d3 e- V9 r/ r   int array[5]={3,5,6,4,9};
   Println(array,5);
  o, M7 \, u* h" S! ?( {2 y   Sort(array,5);
& {5 p% ~  F* Q6 ^! q7 \! j5 a. z   Println(array,5);
4 Y4 `2 H% |6 y5 O/ c
$ Z" g; o0 Q) C! |* p% Q   string s[5]={"c","c++","rust","golang","python"};
( U& F" ^# B& n$ O: C2 v
   Println(s,5);
   Sort(s,5);
   Println(s,5);


" {, x" _. {* H' t6 t" J
( o; R% w$ Y9 ]9 o7 ], }& g   return 0;
}

; \' f, g8 r" b6 l' J

输出结果：

vroot@txp-virtual-machine:/home/txp# ./a.out
0 K8 O: V2 o8 ]: C$ X7 j& Za= 5
! W( R: g/ w! T" L3 p& r: ob= 3
m= 6
, ?1 l4 n  q  p! dn= 4
d= xiaoping
t= Txp
7 m6 I, G" m1 n3,5,6,4,9,
3,4,5,6,9,
c,c++,rust,golang,python,
" I+ C$ [  g/ Z  B) Q$ ?c,c++,golang,python,rust,

) s" t, [4 }' G/ P3 Y' W

三、总结：

• 函数模板是泛型编程在c++中的应用方式之一
• 函数模板能够根据实参对参数类型进行推导
• 函数模板支持显示的指定参数类型
• 函数模板是C++中重要的代码复用方式
  
  

好了，今天的分享就到这里，如果文章中有错误或者不理解的地方，可以交流互动，一起进步。

' o' S2 t: V0 }) W! S* C) V4 Y