Coursera Cpp程序设计 week 6 Part 2

这一部分主要介绍函数模板和类模板。

课程地址:

coursera:C++程序设计

https://www.coursera.org/learn/cpp-chengxu-sheji

中国大学MOOC:程序设计与算法(三)C++面向对象程序设计

程序设计与算法(三)C++面向对象程序设计

函数模板和类模板

函数模板

函数模板样式:

1
2
3
4
5
template <class 类型参数1,class 类型参数2,……>
返回值类型 模板名 (形参表)
{
函数体
};

函数模板中可以有不止一个类型参数:

1
2
3
4
5
6
template <class T1, class T2>
T2 print(T1 arg1, T2 arg2)
{
cout<< arg1 << " "<< arg2<<endl;
return arg2;
}

不通过参数实例化函数模板:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
using namespace std;
template <class T>
T Inc(T n)
{
return 1 + n;
}
int main()
{
cout << Inc<double>(4)/2; //输出 2.5
return 0;
}
函数模板的重载

函数模板可以重载,只要它们的形参表或类型参数表不同即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<class T1, class T2>
void print(T1 arg1, T2 arg2) {
cout<< arg1 << " "<< arg2<<endl;
}

template<class T>
void print(T arg1, T arg2) {
cout<< arg1 << " "<< arg2<<endl;
}

template<class T,class T2>
void print(T arg1, T arg2) {
cout<< arg1 << " "<< arg2<<endl;
}
函数模板和函数的次序

在有多个函数和函数模板名字相同的情况下,编译器如下处理一条函数调用语句

1) 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。

2) 再找参数完全匹配的模板函数。

3) 再找实参数经过自动类型转换后能够匹配的普通函数。

4) 上面的都找不到,则报错。

来看一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
template <class T>
T Max( T a, T b) {
cout << "TemplateMax" <<endl; return 0;
}

template <class T,class T2>
T Max( T a, T2 b) {
cout << "TemplateMax2" <<endl; return 0;
}

double Max(double a, double b){
cout << "MyMax" << endl;
return 0;
}

int main() {
int i=4, j=5;
Max( 1.2,3.4); // 输出MyMax
Max(i, j); //输出TemplateMax
Max( 1.2, 3); //输出TemplateMax2
return 0;
}

注意匹配模板函数时,不进行类型自动转换:

1
2
3
4
5
6
7
template<class T>
T myFunction( T arg1, T arg2)
{ cout<<arg1<<" "<<arg2<<"\n"; return arg1;}
……
myFunction( 5, 7); //ok:replace T with int
myFunction( 5.8, 8.4); //ok: replace T with double
myFunction( 5, 8.4); //error,no matching function for call to 'myFunction(int, double)'

类模板

类模板:在定义类的时候,加上一个/多个类型参数。在使用类模板时,指定类型参数应该如何替换成具体类型,编译器据此生成相应的模板类。

1
2
3
4
5
template <class 类型参数1,class 类型参数2,……> //类型参数表
class 类模板名
{
成员函数和成员变量
};

类模板里成员函数的写法:

1
2
3
4
5
template <class 类型参数1,class 类型参数2,……> //类型参数表
返回值类型 类模板名<类型参数名列表>::成员函数名(参数表)
{
……
}

来看一个具体例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
template <class T1,class T2>
class Pair
{
public:
T1 key; //关键字
T2 value; //值
Pair(T1 k,T2 v):key(k),value(v) { };
bool operator < ( const Pair<T1,T2> & p) const;
};

template<class T1,class T2>
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const
//Pair的成员函数 operator <
{
return key < p.key;
}

int main()
{
Pair<string,int> student("Tom",19);
//实例化出一个类 Pair<string,int>
cout << student.key << " " << student.value;
return 0;
}
//输出:
//Tom 19
用类模板定义对象

编译器由类模板生成类的过程叫类模板的实例化。 由类模板实例化得到的类,叫模板类。注意同一个类模板的两个模板类是不兼容的。

1
2
3
Pair<string,int> * p;
Pair<string,double> a;
p = & a; //wrong
类模板与非类型参数

类模板的“<类型参数表>”中可以出现非类型参数:

1
2
3
4
5
6
7
8
9
10
11
12
template <class T, int size>
class CArray{
T array[size];
public:
void Print( )
{
for( int i = 0;i < size; ++i)
cout << array[i] << endl;
}
};
CArray<double,40> a2;
CArray<int,50> a3; //a2和a3属于不同的类

类模板与静态成员变量

类模板中可以定义静态成员,那么从该类模板实例化得到的所有类, 都包含同样的静态成员。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
using namespace std;
template <class T>
class A
{
private:
static int count;
public:
A() { count ++; }
~A() { count -- ; };
A( A & ) { count ++ ; }
static void PrintCount() { cout << count << endl; }
};

template<> int A<int>::count = 0;
template<> int A<double>::count = 0;
int main()
{
A<int> ia;
A<double> da;
ia.PrintCount();
da.PrintCount();
return 0;
}

//输出:
//1 1