深度解析C++的函数模板与类模板
导读：收集整理的这篇文章主要介绍了深度解析C++的函数模板与类模板，觉得挺不错的，现在分享给大家，也给大家做个参考。一、函数模板1、定义 template <class 类型参数1，class 类型参数2,……> 返回值类型...
收集整理的这篇文章主要介绍了深度解析C++的函数模板与类模板，觉得挺不错的，现在分享给大家，也给大家做个参考。一、函数模板
1、定义
template class 类型参数1，class 类型参数2,……>
返回值类型 模板名 (形参表){
函数体
}
;
template class T1, class T2>
T2 PRint(T1 arg1, T2 arg2){
cout arg1 " " arg2endl;
return arg2;
}
2、不通过参数实例化函数模板
#include iostream>
using namespace std;
template class T>
T Inc(T n){
return 1 + n;
}
int main(){
cout Incdouble>
(4)/2;
//输出 2.5 return 0;
}
3、函数模板可以重载，只要它们的形参表或类型参数表不同即可
templateclass T1, class T2>
void print(T1 arg1, T2 arg2) {
cout arg1 " " arg2endl;
}
templateclass T>
void print(T arg1, T arg2) {
cout arg1 " " arg2endl;
}
templateclass T,class T2>
void print(T arg1, T arg2) {
cout arg1 " " arg2endl;
}
4、函数模板和函数的次序
在有多个函数和函数模板名字相同的情况下，编译器如下处理一条函数调用语句
先找参数完全匹配的普通函数(非由模板实例化而得的函数)。
再找参数完全匹配的模板函数。
再找实参数经过自动类型转换后能够匹配的普通函数。
上面的都找不到，则报错。
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() {
Max( 1.2,3.4);
// 输出MyMax Max(4, 5);
//输出TemplateMax Max( 1.2, 3);
//输出TemplateMax2 return 0;
}
5、匹配模板函数时，不进行类型自动转换
templateclass T>
T myFunction( T arg1, T arg2){
coutarg1" "arg2"\n";
return arg1;
}
……myFunction( 5, 7);
//ok ：replace T wITh intmyFunction( 5.8, 8.4);
//ok： ： replace T with doublemyFunction( 5, 8.4);
//error ，no matching function for callto 'myFunction(int, double)'二、类模板
1、定义
在定义类的时候，加上一个/多个类型参数。在使用类模板时，指定类型参数应该如何替换成具体类型，编译器据此生成相应的模板类。
template class 类型参数1，class 类型参数2，……>
//类型参数表
class 类模板名{
成员函数和成员变量
}
;
（1）类模板里成员函数的写法：
template class 类型参数1，class 类型参数2，……>
//类型参数表
返回值类型 类模板名类型参数名列表>
::成员函数名（参数表）{
……
}
（2）用类模板定义对象的写法：
类模板名 真实类型参数表>
对象名(构造函数实参表);
// Pair类模板template class T1,class T2>
class Pair{
public: T1 key;
//关键字 T2 value;
//值 Pair(T1 k,T2 v):key(k),value(v) {
}
;
bool operator ( const PairT1,T2>
&
p) const;
}
;
templateclass T1,class T2>
bool PairT1,T2>
::oPErator ( const PairT1,T2>
&
p) const{
//Pair的成员函数 operator return key p.key;
}
int main(){
Pairstring,int>
student("Tom",19);
//实例化出一个类 Pairstring,int>
cout student.key " " student.value;
return 0;
}
//输出：Tom 192、用类模板定义对象
编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。
同一个类模板的两个模板类是不兼容的。
3、函数模版作为类模板成员
template class T>
class A{
public: templateclass T2>
void Func( T2 t) {
cout t;
}
//成员函数模板}
;
4、类模板与非类型参数：类模板的“类型参数表> ”中可以出现非类型参数
template class T, int size>
class CArray{
T array[size];
public: void Print(){
for( int i = 0;
i size;
++i) cout array[i] endl;
}
}
;
CArraydouble,40>
a2;
CArrayint,50>
a3;
//a2和a3属于不同的类5、类模板与派生
（1）类模板从类模板派生
template class T1,class T2>
int main() {
class A {
Bint,double>
obj1;
T1 v1;
T2 v2;
Cint>
obj2;
}
;
return 0;
template class T1,class T2>
}
class B:public AT2,T1>
{
class Bint,double>
: T1 v3;
T2 v4;
public Adouble,int>
{
}
;
int v3;
double v4;
template class T>
}
;
class C:public BT,T>
{
T v5;
}
;
（2）类模板从模板类派生
template class T1,class T2>
class A {
T1 v1;
T2 v2;
}
;
template class T>
class B:public Aint,double>
{
T v;
}
;
int main() {
Bchar>
obj1;
//自动生成两个模板类 ：Aint,double>
和 Bchar>
return 0;
}
（3）类模板从普通类派生
class A {
int v1;
}
;
template class T>
class B:public A {
//所有从B实例化得到的类 ，都以A为基类 T v;
}
;
int main() {
Bchar>
obj1;
return 0;
}
（4）普通类从模板类派生
template class T>
class A {
T v1;
int n;
}
;
class B:public Aint>
{
double v;
}
;
int main() {
B obj1;
return 0;
}
6、类模板与友员函数
（1）函数、类、类的成员函数作为类模板的友元
void Func1() {
}
class A {
}
;
class B{
public: void Func() {
}
}
;
template class T>
class tmpl{
friend void Func1();
friend class A;
friend void B::Func();
}
;
//任何从Tmp1实例化来的类 ，都有以上三个友元（2）函数模板作为类模板的友元
#include iostream>
#include string>
using namespace std;
template class T1,class T2>
class Pair{
private: T1 key;
//关键字 T2 value;
//值 public: Pair(T1 k,T2 v):key(k),value(v) {
}
;
bool operator ( const PairT1,T2>
&
p) const;
template class T3,class T4>
friend ostream &
operator ( ostream &
o,const PairT3,T4>
&
p);
}
;
template class T1,class T2>
bool PairT1,T2>
::operator ( const PairT1,T2>
&
p) const{
//"小"的意思就是关键字小 return key p.key;
}
template class T1,class T2>
ostream &
operator (ostream &
o,const PairT1,T2>
&
p){
o "(" p.key "," p.value ")" ;
return o;
}
int main(){
Pairstring,int>
student("Tom",29);
Pairint,double>
obj(12,3.14);
cout student " " obj;
return 0;
}
//输出：(Tom,29) (12,3.14)任意从 template class T1,class T2>
ostream &
operator (ostream &
o,const PairT1,T2>
&
p)生成的函数，都是任意Pair摸板类的友元（3）函数模板作为类的友元
#include iostream>
using namespace std;
class A{
int v;
public: A(int n):v(n) {
}
template class T>
friend void Print(const T &
p);
}
;
template class T>
void Print(const T &
p){
cout p.v;
}
int main() {
A a(4);
Print(a);
return 0;
}
//输出：4（4）类模板作为类模板的友元
template class T>
class B {
T v;
public: B(T n):v(n) {
}
template class T2>
friend class A;
}
;
template class T>
class A {
public: void Func( ) {
Bint>
o(10);
cout o.v endl;
}
}
;
7、类模板与静态成员变量
类模板中可以定义静态成员 ，那么从该类模板实例化得到的所有类 ，都包含同样的静态成员 。
#include iostream>
using namespace std;
template class T>
class A{
private: @R_304_2358@ic int count;
public: A() {
count ++;
}
~A() {
count -- ;
}
;
A( A &
) {
count ++ ;
}
static void PrintCount() {
cout count endl;
}
}
;
template>
int Aint>
::count = 0;
template>
int Adouble>
::count = 0;
int main(){
Aint>
ia;
Adouble>
da;
ia.PrintCount();
da.PrintCount();
return 0;
}
//输出：1 1相关推荐：
用C++对C++语法格式进行分析
c++11 - C++中如何定义一个指向函数的智能指针？
以上就是深度解析C++的函数模板与类模板的详细内容，更多请关注其它相关文章！
声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！
若转载请注明出处： 深度解析C++的函数模板与类模板
本文地址： https://pptw.com/jishu/593170.html