标题:C++ : 模板初阶
@水墨不写bug
正文开始:
C语言的问题 :
写不完的swap函数
在学习C语言时,我们有一个经常使用的函数swap函数,它可以将两个对象的值交换。
我们通常这样实现它:
void swap(int t1,int t2)
{int tem = t1;t1 = t2;t2 = tem;
}
这是很简单的函数。如果我们想交换其他类型的对象,就需要用到函数重载:
void swap(int t1,int t2){int tem = t1;t1 = t2;t2 = tem;}
void swap(float t1, float t2){ float tem = t1;t1 = t2;t2 = tem;}
void swap(double t1, double t2){ double tem = t1;t1 = t2;t2 = tem;}
void swap(char t1, char t2){ char tem = t1;t1 = t2;t2 = tem;}
void swap(long t1, long t2){ long tem = t1;t1 = t2;t2 = tem;}
//...
但是,内置类型的指针理论上可以达到n级指针,n可以趋于无限大;除此之外,还有自定义类型。这样一来,你就会发现,类型是无法枚举的!一个swap函数需要实现一种类型的交换,那么swap函数是写不完的!
人工解决重复写同一个逻辑,仅仅是类型不同的代码是很低效的!为了解决这个问题,C++引入模板的概念:
顾名思义,模板就是模板,作用就是印出不同的东西,这个东西就是swap函数!
(一)模板简介
模板是C++相对于C的一个新的语法,他需要用到关键字template(模板),如果我们用模板来实现swap函数,就可这样写:
template <typename T>
void swap(T& t1, T& t2)
{T tem = t1;t1 = t2;t2 = tem;
}
template<typename或class 模板参数> + 模板主体 就是模板的基本形式。
要成功的调用模板函数,也需要特定的条件:
template <class T>
void swap(T& t1, T& t2)
{T tem = t1;t1 = t2;t2 = tem;
}
/*void swap(int t1,int t2){int tem = t1;t1 = t2;t2 = tem;}void swap(float t1, float t2){ float tem = t1;t1 = t2;t2 = tem;}void swap(double t1, double t2){ double tem = t1;t1 = t2;t2 = tem;}void swap(char t1, char t2){ char tem = t1;t1 = t2;t2 = tem;}void swap(long t1, long t2){ long tem = t1;t1 = t2;t2 = tem;}
*/
int main()
{int a = 1, b = 5;::swap(a, b);cout << a << " " << b << endl;return 0;
}
我们可以指定调用全局的swap模板函数,完成对象的值交换。
(1)为什么模板可行?模板的原理?
在编译时,编译器会 匹配 模板参数的类型,如上例,a,b的类型都是整形,所以编译器会根据根据函数的模板生成一份函数,这份函数仅仅将 T(模板参数 改成 匹配出的类型):
void swap(int t1,int t2)
{int tem = t1;t1 = t2;t2 = tem;
}
这样我们人工编写的工作量就减少了非常多,因为一个理论上模板可以生成n个函数(n可趋于无穷大)。
(2)匹配冲突
由于交换的是两个参数的值,当两个参数的类型不同时,理论上不能交换,此时编译器也会因为匹配类型冲突而报错:
如何解决这个问题:
i,再增加一个模板参数(推荐)
由于只有一个模板参数, 当推断类型既是int又是double时,一个参数就应付不过来了,所以需要再增加一个参数。两个模板参数,就可以进行两次参数类型匹配:
template <class T1,class T2>
void swap(T1& t1, T2& t2)
{auto tem = t1;t1 = t2;t2 = tem;
}
##如果你是看了后面两种处理方式后又回来的,那么你很敏锐,发现了本例的问题,其实本例也发生了类型转换:
由于t1,t2类型不一致,所以在下面赋值时,必然发生了类型转换,可能导致精度丢失。但是这并不影响我们解决匹配冲突的方法:因为在实际应用中,我们一般不会让模板参数之间进行运算。(这仅仅是本例的场景不太好,使用多个模板来解决匹配冲突仍然是推荐的) ##
ii,强制转换到一致
只能解决一些特例,就拿下面这个函数模板来说:
template<class T>
T Add(T t1,T t2)
{return t1 + t2;
}void test2()
{int a = 1;double b = 5.6;double ret = ::Add((double)a, b);cout << ret;
}
将a强制类型转换到double可以使编译器对a和b类型匹配都是double,这样是可以通过编译的,但是这样操作的结果是不稳定的。强制类型转换必然意味着精度或者符号的丢失,不到迫不得已,不要使用强制类型转换!
iii,显示实例化(不再推演参数)
只能解决一些特例,还是拿上面这个函数模板来说:
template<class T>
T Add(T t1,T t2)
{return t1 + t2;
}
void test2()
{int a = 1;double b = 5.6;double ret = ::Add<double>(a, b);cout << ret;
}
这也是可以通过编译的,在模板名称后面加上<参数类型>,意味着指定了生成的模板的匹配类型就是 这个指定的参数类型。由于指定了参数类型,其本质也是发生了类型转换,而类型转换是不推荐的。
总结:
解决匹配冲突的方法:
i,再增加一个模板参数(推荐)
ii,强制转换到一致
iii,显示实例化(不再推演参数)
(3)模板实例化的条件
当全局已经有一个匹配的函数时,模板就不会再生成新函数。
以这个例子来说:
void swap(double t1, double t2){ double tem = t1;t1 = t2;t2 = tem;}template <class T>
void swap(T& t1, T& t2)
{T tem = t1;t1 = t2;t2 = tem;
}
void test1()
{double a = 1;double b = 5;::swap(a, b);cout << a << " " << b << endl;
}
模板匹配的类型是double,由于全局已经有了类型是double的函数,所以编译器不会再通过函数模板再生成一份swap函数。
编译器会优先匹配最合适的模板:
template <class T1,class T2>
void swap(T1& t1, T2& t2)
{T1 tem = t1;t1 = t2;t2 = tem;
}
template <class T>
void swap(T& t1, T& t2)
{T tem = t1;t1 = t2;t2 = tem;
}
void test1()
{int a = 1;double b = 5;::swap(a, b);cout << a << " " << b << endl;
}
本例中,由于a,b两个变量的类型不同,所以编译器会优先选择两个模板参数的swap函数,而不是一个模板参数的swap。
在特殊情况也是可以编译通过的:
void swap(int t1, int t2)
{ int tem = t1; t1 = t2; t2 = tem;
}
void test1()
{int a = 1;double b = 5;::swap(a, b);cout << a << " " << b << endl;
}
总结:
1.全局有完全匹配的函数,编译器不再由模板生成函数;直接使用现成的函数。
2.如果有多个模板,编译器会选择最合适的模板来生成函数;
3.类型不匹配,没有模板,也可以编译通过,但是会发生类型转换,导致精度丢失。
其实模板远不止这些,本文仅仅是以函数模板为引子来讲解模板的语法,而模板还包括类模板,后者是实际中应用较多的。
类模板 就放 在将来为大家分享吧!
目录
(一)模板简介
(1)为什么模板可行?模板的原理?
(2)匹配冲突
i,再增加一个模板参数(推荐)
ii,强制转换到一致
iii,显示实例化(不再推演参数)
总结:
(3)模板的生成条件
总结:
~完
未经作者同意禁止转载