C++ 函数重载、函数模板，类模板

1.函数重载

相同作用域下，有多个函数名相同，但形参列表不同的函数，常用于处理功能相同但数据类型不同的问题

函数重载的规则：

函数名必须相同

函数形参列表必须不同(可以是参数个数不同，或者数据类型不同，或者参数排列顺序不同)

返回值可以相同也可以不同

注意：如果函数名相同，函数形参列表也相同，只有返回值不同，属于函数重定义

 1 int GetMax(int a, int b)
 2 {
 3     return a>b ? a:b;
 4 }
 5 //函数名相同，形参数据类型和返回值不同
 6 float GetMax(float a, float b)
 7 {
 8     return a>b ? a:b;
 9 }
10 //函数名相同，形参数据类型和返回值不同
11 char GetMax(char a, char b)
12 {
13     return a>b ? a:b;
14 }
15 //函数名和返回值相同，形参数据类型相同，但个数不同
16 int GetMax(char a, char b, char c)
17 {
18     int nMax = a>b ? a:b;
19     return nMax>c ? nMax:c;
20 }
21 //Error:函数重定义，和int GetMax(int a, int b)相比只有返回值不同
22 /*
23 bool GetMax(int a, int b)
24 {
25     return a>b ? true:false;
26 }
27 */
28 int _tmain(int argc, _TCHAR* argv[])
29 {
30     int nMax = GetMax(1, 2);  //int GetMax(int a, int b) nMax = 2
31     float fMax = GetMax(1.2f, 1.36f); //float GetMax(float a, float b) fMax = 1.36f
32     char cMax = GetMax('z', 'a');//char GetMax(char a, char b) cMax ='z'
33     int nMaxThree = GetMax(5, 4, 7);//int GetMax(char a, char b, char c) nMaxThree = 7
34 
35     return 0;
36 }

2.函数模板

建立一个通用函数，其函数类型和形参类型用一个虚拟的类型来代表，在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，这个通用函数就称为函数模板。

和上面的函数重载相比好处在于不必为每个不同的数据类型编写单独的函数，只需在模板中定义一次即可。

template<typename 类型参数1 , typename 类型参数2 , …>

前缀以关键字 template 开始，接下来是一组尖括号，里面包含一个或多个在模板中使用的通用数据类型, 多个通用类型之间加上逗号分隔

 1 //函数模板
 2 template<typename T>
 3 T GetMax(T a, T b)
 4 {
 5     return a>b ? a:b;
 6 }
 7 
 8 int _tmain(int argc, _TCHAR* argv[])
 9 {
10     int nMax = GetMax(3,6);        //nmax = 6
11     float fMax = GetMax(1.25f,1.2f); //fmax = 1.25
12     char cMax = GetMax('a','g'); //cMax = 'g'
13 
14     return 0;
15 }

3.类模板

和函数模板相似，也是为了数据类型参数化，不同在于类模板在实例化时必须显式地指明数据类型，编译器不能根据给定的数据推演出数据类型。

如果在类外定义成员函数，必须重新再声明一次类模板

template<class 类型参数1 , class 类型参数2 , …>

前缀以关键字 template 开始，接下来是一组尖括号，里面包含一个或多个在模板中使用的通用数据类型, 多个通用类型之间加上逗号分隔

 1 //类模板
 2 template<class TT>
 3 class CMax
 4 {
 5 public:
 6     CMax(){}
 7     CMax(TT a, TT b) : m_a(a), m_b(b){}
 8     TT GetMax()
 9     {
10         return m_a>m_b ? m_a:m_b;
11     }
12     void SetValue(TT a, TT b);
13 private:
14     TT m_a;
15     TT m_b;
16 };
17 //注意：类外定义成员函数还需要声明一次类模板
18 template<class TT>
19 void CMax<TT>::SetValue(TT a, TT b)
20 {
21     m_a = a;
22     m_b = b;
23 }
24 
25 int _tmain(int argc, _TCHAR* argv[])
26 {
27     CMax<int> maxA(3,6);   
28     int nMaxA = maxA.GetMax();  //nMaxA = 6
29     CMax<float> maxB(1.25f,1.2f);
30     float fMaxB = maxB.GetMax(); //fMaxB = 1.25
31     CMax<char> maxC('a','g');
32     char cMaxB = maxC.GetMax();  //cMaxB = 'g'
33     CMax<int> maxD;
34     maxD.SetValue(10,5);
35     int nMaxdD = maxD.GetMax(); //nMaxD = 10
36     return 0;
37 }

原文地址：https://www.cnblogs.com/fzxiaoyi/p/11918818.html