c++的模板

我们首先看看这个例子：

 

#include <iostream> 
 
using namespace std; 
 
int int_maxVal(int val1,int val2,int val3) 
{ 
        int max=val1; 
        if(val2>max) 
        max=val2; 
        if(val3>max) 
        max=val3; 
        return max; 
} 
 
int double_maxVal(double val1,double val2,double val3) 
{ 
        double max=val1; 
        if(val2>max) 
        max=val2; 
        if(val3>max) 
        max=val3; 
        return max; 
} 
 
//... 
 
int main(int argc,char* argv[]) 
{ 
        //int整数比较 
        int a,b,c; 
        cout << "请输入3个用于比较的整数:" ; 
        cin>>a>>b>>c; 
        cout<<"最大的整数是:"<<int_maxVal(a,b,c)<<endl; 
 
        //double小数比较 
        float d1,d2,d3; 
        cout << "请输入3个用于比较的浮点数:"; 
        cin>>d1>>d2>>d3; 
        cout<<"最大的浮点数是:"<<double_maxVal(d1,d2,d3)<<endl; 
 
        return 0; 
}

 

这个大家并不陌生，这里为了简单只是实现了int和double，实际中我们可能的类型很多，于是每种类型都重新定义一个函数，这里我们的函数每一个的名字不相同。

 

难道我们为了实现一个求3个值得最大值，就需要记住这么多函数名字？

 

于是函数重载，使得我们可以重复使用相同的函数名字，编译器来根据不同的类型调用对应的函数，算是改进了一步。

 

但是对于这个问题，具体的实现却有着众多的相似之处，我们发现除了参数类型的不同，我们并没有发现其他差别。

 

于是聪明的程序员们发现了使用宏来解决我们这个问题。

 

在模板之前，早期的c的程序员可能不会忘记使用宏来满足我们实现下面这样的要求:定义一系列的具有相同逻辑，但是处理不同类型这样的函数或类。

 

宏其实并没有根本改变我们的问题，由预处理器展开宏后的代码和上面又有什么区别呢，只是宏代替我们，实现代码定义的自动化而已。

 

模板为我们提供了更好的解决方案：

 

模板其实好比一个模子，可以复印出我们所需要的模板函数。

想看看函数模板:

 

functpl.cpp

 

//函数模板 
#include <iostream> 
 
using namespace std; 
 
template <class T> 
T maxVal(T val1,T val2,T val3) 
{ 
        T max=val1; 
        if(val2>max) 
        max=val2; 
        if(val3>max) 
        max=val3; 
        return max; 
} 
 
int main() 
{ 
        //int整数比较 
        int a,b,c; 
        cout << "请输入3个用于比较的整数:" ; 
        cin>>a>>b>>c; 
        cout<<"最大的整数是:"<<maxVal(a,b,c)<<endl; 
 
        //double小数比较 
        float d1,d2,d3; 
        cout << "请输入3个用于比较的浮点数:"; 
        cin>>d1>>d2>>d3; 
        cout<<"最大的浮点数是:"<<maxVal(d1,d2,d3)<<endl; 
 
        return 0; 
} 

 

注意模板形式参数T

有点像我们的函数定义，

template <typename T>或template <class T>(早期编译器可能认得这个class)

 

这样程序调用maxVal时时可以根据不同的函数参数，如果int整型时，则int替代这里的T,也就是说调用的对应int的那个模板函数。

 

如果double就调用double那个，可以根据这个类型参数决定调用哪个(可以这样理解，好比我们定义了不同的函数).

 

当然了也可以是我们自定义的类型。

 

 

类模板：

可以定义一些类似逻辑机构的类，比如我们测试程序时，常用的一些

class X,class Y,class Z我们初学c++时常常定义一些这样的类，可能实际这些类没有什么意义，用类模板可以简化我们定义这些相似的类的定义。

 

classtpl.cpp

 

//类模板 
#include <iostream> 
 
using namespace std; 
 
template <class T> 
class MyTpl 
{ 
private: 
        T val; 
public: 
        MyTpl(T val){this->val=val;}; 
        void setVal(T val); 
        T getVal(); 
}; 
 
template <class T> 
void MyTpl<T>::setVal(T val) 
{ 
        this->val=val; 
} 
 
template <class T> 
T MyTpl<T>::getVal() 
{ 
        return val; 
} 
 
int main(int argc,char* argv[]) 
{ 
        MyTpl<int> a(10); 
        cout<<a.getVal()<<endl; 
 
        MyTpl<double> b(1.233); 
        cout<<b.getVal()<<endl; 
 
        return 0; 
} 
 

 

MyTpl<int>,MyTpl<double>这样的就是我们根据我们的类模板生成的模板类。

 

   本文转自 xcf007 51CTO博客，原文链接：http://blog.51cto.com/xcf007/105231，如需转载请自行联系原作者