2015年2月11日 周三晴
有一段时间没有更新博客了,这几天在整理前段时间所学的c++知识点就没有更新了。最近开始研究c++的模板的STL,于是开始继续写下自己的一点所得吧。
模板和STL都是c++中比较实用的东西,能把我们省下很多事情(简化编码)。今天作为模板的第一讲,今天讲的模板其实主要是介绍函数模板。模板还有类模板(我们明天介绍)。
————————————————————分割线——————————————————————
一、为什么需要函数模板?
#include <stdio.h>
#include <string.h>
int max_int(int a,int b){
return a > b ? a : b;
}
double max_double(double a,double b){
return a > b ? a : b;
}
const char* max_char(const char* a,const char* b){
return strcmp(a,b) > 0 ? a : b;
}
int main()
{
printf("%d\n",max_int(100,200));
printf("%f\n",max_double(1.2,2.2));
printf("%s\n",max_char("hello","world"));
return 0;
}
#include <stdio.h>
#include <string.h>
#define Max(a,b) ((a) > (b) ? (a) : (b))
int main()
{
printf("%d\n",Max(100,200));
printf("%f\n",Max(1.2,2.2));
printf("%s\n",Max("hello","world"));
return 0;
}
函数宏的原理就是,在预编译时所有Max(a,b) 都会自动被替换为((a) > (b) ? (a) : (b))。所以我们可以看到答案基本正确。但是请仔细看第三个答案,为什么“hello”比“world”大!按照字符串比较原则, 明明“world”大啊!
#include<iostream>
using namespace std;
int Max(int a,int b){
return a>b?a:b;
}
double Max(double a,double b){
return a>b?a:b;
}
string Max(string a,string b){
return a>b?a:b;
}
int main()
{
cout<<Max(100,200)<<endl;
cout<<Max(1.2,2.2)<<endl;
cout<<Max("hello","world")<<endl;
return 0;
}
在c++中我们用string类取代了c语言中的字符串数组(char*),直接使用“>”去比较两个字符串就更安全了。
二、模板的定义和使用
1.定义语法:
返回类型 函数模板名 (调用形参表) {
template<typename T>
T Max(T a,T b){
return a>b?a:b;
}
我们的函数体,就浓缩为这四行了。这就是模板的魅力之处——可通用所有的类型!这里你需要特别注意这个typename关键字定义的T,它代表的是任何合法的数据类型,无论是系统定义的(int、double之类的)或者是你自己定义的结构体或类类型都可以的!
2.模板的使用
#include<iostream>
using namespace std;
template<typename T>
T Max(T a,T b){
return a>b?a:b;
}
int main()
{
cout<<Max<int>(100,200)<<endl;
cout<<Max<double>(1.2,2.2)<<endl;
cout<<Max<string>("hello","world")<<endl;
return 0;
}
Max<int>(100,200),我们是在告诉编译器,100和200是int类型的,你用int类型去使用模板就好了!函数模板中的T就会自动变成int类型啦。
3.模板的实现
模板是如何做到这样强大的功能的呢?很简单,就四个字: 二次编译!2)第二次编译,是编译器针对函数模板的 调用所做的编译,用所提供的类型实参结合其内部表示中的类型形参,做类型相关性检查,生成针对 具体函数的机器指令。
4.隐式推断
#include<iostream>
using namespace std;
template<typename T>
T Max(T a,T b){
return a>b?a:b;
}
int main()
{
cout<<Max(100,200)<<endl;
cout<<Max(1.2,2.2)<<endl;
cout<<Max("hello","world")<<endl;
return 0;
}
#include <iostream>
#include <typeinfo>
using namespace std;
template<typename T>
T Max(T a,T b){
cout<<typeid(T).name()<<": ";
return a>b?a:b;
}
int main()
{
cout<<Max(100,200)<<endl;
cout<<Max(1.2,2.2)<<endl;
cout<<Max("hello","world")<<endl;
return 0;
}
A.模板参数与调用参数的类型无关
B.隐式推断不允许隐式类型转换
#include <iostream>
using namespace std;
void show(i a){
cout<<a<<endl;
}
int main()
{
char ch='a';
show(ch);
return 0;
}
#include <iostream>
using namespace std;
template<typename T>
void show(T a,T b){
cout<<a<<" "<<b<<endl;
}
int main()
{
show(10,(int)'a');
show<int>(10,(int)'a');
return 0;
}
C.返回类型不能隐式推断。
三、函数模板的重载
1.定义:
template<typename T>
T Max(T a,T b){
return a > b ? a : b;
}
const char* Max(const char& a,const char* b){
return strcmp(a,b) > 0 ? a : b;
}
template<typename T>
T Max(T a,T b,T c){
return Max(Max(a,b),c);
} 第一和第三个是函数模板,第二个是普通函数。我们可以发现三者的函数名皆相同,他们构成了重载关系。
那么我问你一个问题哦:如果我们调用Max("hello","world"),你说编译器会调用第几个函数?这就牵涉到了模板重载的问题了。我们一起往下看重载的一些原则:
2.重载的规则:
#include <iostream>
#include <cstring>
using namespace std;
template<typename T>
T Max(T a,T b){
cout<<"T Max(T,T): ";
return a > b ? a : b;
}
const char* Max(const char* a,const char* b){
cout<<"const char* Max(const char*,const char*): ";
return strcmp(a,b) > 0 ? a : b;
}
int main()
{
cout<<Max("hello","world")<<endl;
cout<<Max(100,200)<<endl;
return 0;
}
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
cout<<"T Max(T,T): ";
return a > b ? a : b;
}
int Max(int a,double b){
cout<<"int Max(int,double): ";
return a > b ? a : b;
}
int main()
{
cout<<Max(1.23,(double)4)<<endl;
cout<<Max(1.23,4)<<endl;
return 0;
}
在上面我们说隐式推断的时候,提到了:隐式推断不允许隐式类型转换。如这个程序一样,一旦发生了隐式类型转换,编译器会调用普通函数,而非模板函数。
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
cout<<"T Max(T,T): ";
return a > b ? a : b;
}
template<typename T>
T* Max(T* a, T* b){
cout<<"T* Max(T*,T*): ";
return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
cout<<"const char* Max(const char*,const char*): ";
return a > b ? a : b;
}
int main()
{
const char* ch1 = "hello";
const char* ch2 = "world";
cout<<Max<>(ch1,ch2)<<endl;
return 0;
}
这里有两个函数模板,一个普通函数构成重载。如果我们调用调用Max<>(ch1,ch2)你说编译器会调用哪个函数?
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
cout<<"T Max(T,T): ";
return a > b ? a : b;
}
template<typename T>
T* Max(T* a, T* b){
cout<<"T* Max(T*,T*): ";
return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
cout<<"const char* Max(const char*,const char*): ";
return a > b ? a : b;
}
int main()
{
const char* ch1 = "hello";
const char* ch2 = "world";
cout<<Max<>(&ch1,&ch2)<<endl;
return 0;
}
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
cout<<"T Max(T,T): ";
return a > b ? a : b;
}
template<typename T>
T* Max(T* a, T* b){
cout<<"T* Max(T*,T*): ";
return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
cout<<"const char* Max(const char*,const char*): ";
return a > b ? a : b;
}
int main()
{
const char* ch1 = "hello";
const char* ch2 = "world";
cout<<Max<const char*>(ch1,ch2)<<endl;
return 0;
}
奇怪,显示的指定模板参数类型是const char*之后,它居然不调用针对指针版本的了!按道理,指针版本的更适合调用函数的指针类型啊?
#include <iostream>
#include <cstring>
using namespace std;
template<typename T>
T Max(T a, T b){
cout<<"T Max(T,T): ";
return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
cout<<"const char* Max(const char*,const char*)"<<endl;
return strcmp(a,b)>0?a:b;
}
template<typename T>
T Max(T a,T b,T c){
cout<<"T Max(T,T,T)"<<endl;
return Max(Max(a,b),c);
}
int main()
{
const char* ch1 = "123";
const char* ch2 = "12";
const char* ch3 = "1";
cout<<Max<const char*>(ch1,ch2,ch3)<<endl;
return 0;
}
#include <iostream>
#include <cstring>
using namespace std;
template<typename T>
T Max(T a, T b){
cout<<"T Max(T,T)"<<endl;
return a > b ? a : b;
}
template<typename T>
T Max(T a,T b,T c){
cout<<"T Max(T,T,T)"<<endl;
return Max(Max(a,b),c);
}
const char* Max(const char* a, const char* b){
cout<<"const char* Max(const char*,const char*)"<<endl;
return strcmp(a,b)>0?a:b;
}
int main()
{
const char* ch1 = "123";
const char* ch2 = "12";
const char* ch3 = "1";
cout<<Max<const char*>(ch1,ch2,ch3)<<endl;
return 0;
}
你会发现,它不再去调用普通函数了。这是因为,普通函数在该函数模板之后,在第一次编译时,函数模板发现不了这个普通函数(无法完成静态的关联)。
3491



被折叠的 条评论
为什么被折叠?



