我是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函数。不会使用第二个模版函数产生新的实例。
三:非常重要的一点,使用指针的时候千万要注意不要返回临时变量的指针。参见我的另一篇笔记:
使用模板函数返回临时变量的指针的问题