C++函数模板和类模板_小猿1024资源站

C++语言全盘继承了C语言的标准库，其中包含非常丰富的系统函数，例如输入/输出函数、数学函数、字符串处理函数和动态内存分配函数等。C++语言另外又增加了一些新的库，我们把C++语言新增的这部分库称为C++标准库。C++语言的模板技术包括函数模板和类模板。模板技术是一种代码重用技术，函数和类是C++语言中两种主要的重用代码形式。代码模板使源程序更加凝练。

一、函数模板

函数模板的基本原理是通过数据类型的参数化，将一组算法相同但所处理数据类型不同的重载函数凝练成一个函数模板。

1、函数模板的定义和使用

函数模板的定义语法形式：

template <类型参数列表>

函数类型函数名(形参参数列表)

{

函数体

}

函数模板的几点语法细则：

定义函数模板以关键字template开头
类型参数列表可以声明一个或多个类型参数，每个类型参数以”typename 类型参数名”或”class 类型参数名”的形式声明，类型参数之间用逗号”，“隔开。
函数模板的其余部分，包括函数类型、函数名、形式参数列表以及函数体，它们和普通函数的定义形式没有什么区别。
使用typename和class声明的类型参数可视为一种新的数据类型，可用来定义函数类型(即返回值类型)、形参类型和局部变量类型。类型参数是表示数据类型的参数，再实际调用时可被替换成任意数据类型

示例：

#include<iostream>
using namespace std;
template <typename T>  //定义函数模板Max，声明一个类型参数T
T Max(T x,T y)   //使用类型参数T定义函数类型和形参x和y的类型
{
    return(x>y?x:y);
}
int main()
{
    cout << Max(5,10) <<endl; //调用返回最大值10
    cout << Max(5.2,10.2) <<endl; //调用返回最大值10.2
    return 0;
}

函数模板可以像普通函数一样被调用。再调用者看来，函数模板的类型参数像是一种通用数据类型。

2、函数模板的编译原理

函数模板是具有类型参数的函数。类型参数是表示数据类型的参数，可指代任意一种实际数据类型。编译器再编译到函数模板的调用语句时，根据位置对应关系从实参数据类型推导出类型参数所指代的数据类型，然后按照函数模板自动生成一个该类型的函数定义代码。不同类型实参的函数模板调用语句将生成不同类型的重载函数。函数模板将数据类型参数化，调用时会呈现参数多态性。

3、函数模板的声明

跟普通函数一样函数模板也需要先定义后调用的原则。如果函数模板定义再调用后，或定义再其他程序文件中，则应先声明后调用。函数模板的声明语法形式为：

template <类型参数列表>

函数类型函数名(形参参数列表)；

或

template <类型参数列表> 函数类型函数名(形参参数列表)；

#include<iostream>
using namespace std;
template <typename T>  //函数模板Max定义声明
T Max(T x,T y);
int main()
{
    cout << Max(5,10) <<endl; //函数模板Max使用
    cout << Max(5.2,10.2) <<endl; 
    return 0;
}
template <typename T>  //函数模板Max定义
T Max(T x,T y)   
{
    return(x>y?x:y);
}

程序员再编程时可以灵活使用模板技术。在定义多个重载函数时可以考虑是否将他们定义成一个函数模板，这样可以凝练函数代码。再定义单个函数时也可以考虑定义成函数模板，这样可以提高函数代码的可重用性。对于调用函数模板的程序员而言，函数模板和普通函数没有什么区别。唯一不同的时函数模板可以处理不同类型的数据。

二、类模板

应用模板技术，也可以将一组功能相同但所处理数据类型不同的类凝练成一个类模板。编译时，再由编译器按照类模板自动生成针对不同数据类型的类定义代码。

1、类模板的定义和使用

定义类模板的语法形式：

template <类型参数列表>

class 类名 //类声明部分

{

类成员声明

}

//类实现部分：所有类外定义的函数成员，必须按如下的语法形式将它们定义成函数模板

template <类型参数列表>

函数类型类名<类型参数名列表>::函数名(形式参数列表)

{ 函数体 }

类模板的几点语法细则：

定义类模板以关键字template开头
类型参数列表可以声明一个或多个类型参数，每个类型参数以”typename 类型参数名”或”class 类型参数名”的形式声明，类型参数之间用逗号”，“隔开。
类模板定义的其余部分，包括类名、类成员声明以及类实现部分，它们和普通类的定义形式基本相同。
定义类模板的函数成员，如果再类内定义(内联函数),其语法形式和普通类的函数成员没区别；如果再类外(即类实现部分)定义，则必须按照函数模板的语法形式来定义，并且还要再函数名前面加“类名<类型参数名列表>::”限定。
使用typename和class声明的类型参数可视为一种新的数据类型，类型参数是表示数据类型的参数，再使用类模板时可被替换成任意数据类型。

定义好的类模板可以像普通类一样被用来定义对象。使用类模板定义对象时，需要明确给出类模板中类型参数所指代的实际数据类型。其语法形式如下：类模板名 <实际数据类型列表> 对象名1，对象名2 …..;

类模板语法示例：

在类内定义函数成员(内联) 在类外定义函数模板成员

#include<iostream>
using namespace std;
template <typename T> //类模板A
class A  //类声明部分
{
    private: //声明两个私有数据成员
        T a1;
        int a2;
    public:
        A(T p1,int p2) //定义构造函数
        { a1 = p1; a2 = p2}
        void Show() //显示数据成员
        { cout << a1 <<","<<a2 <<endl;}
        T Sum() //求数据成员的和
        {return (T)(a1+a2); }
};
//无类实现部分






int main()
{
    //用类模板定义对象
    A <double> o1(10.5,6); //double型对象
    o1.Show(); //显示：10.5，6
    cout<<o1.Sum()<<endl;//显示：16.5
    
    A <int> o2(10,6); //int型对象
    o2.Show(); //显示：10，6
    cout<<o1.Sum()<<endl;//显示：16
    return 0;
}

#include<iostream>
using namespace std;
template <typename T> //类模板A
class A  //类声明部分
{
    private: //声明两个私有数据成员
        T a1;
        int a2;
    public:
        A(T p1,int p2); //定义构造函数
        void Show(); //显示数据成员
        T Sum(); //求数据成员的和
};
//类实现部分
template <typename T>
A <T>::A(T p1,int p2) 
{ a1 = p1; a2 = p2}
template <typename T>
void A <T>::Show() 
{ cout << a1 <<","<<a2 <<endl;}
template <typename T>
T A <T>::Sum()
{return (T)(a1+a2); }
int main()
{
    //用类模板定义对象
    A <double> o1(10.5,6); //double型对象
    o1.Show(); //显示：10.5，6
    cout<<o1.Sum()<<endl;//显示：16.5
    
    A <int> o2(10,6); //int型对象
    o2.Show(); //显示：10，6
    cout<<o1.Sum()<<endl;//显示：16
    return 0;
}

2、类模板的编译原理

当定义到类模板定义对象语句时，编译器将根据所给出的实际数据类型来取代类型参数T。例如 A <double> o1(10.5,6); 编译时将类模板中类类型参数绑定到某个具体数据类型的过程，称为类模板的实例化。实例化所生成的类称为类模板的实例类。实例类是一个普通的类，可以用来定义对象。

类模板编译原理：类模板是具有类型参数的类。类型参数是表示数据类型的参数，可指代任意实际数据类型。编译器在编译到使用类模板定义对象语句时，将首先按照所给定的实际数据类型对类模板进行实例化，生成一个实例类。最终，编译器使用实例类来定义所需要的对象。

3、类模板的继承和派生

类模板可以被继承，派生出新类。以类模板为基类定义派生类，可以在派生时实例化，也可以继续定义派生类模板。

1、定义实例化派生类

定义实例化派生类就是在派生类继承基类的时候将类型参数赋值，此时派生类对基类进行实例化。

实例化派生类示例

#include<iostream>
using namespace std;
template <typename T> //类模板基类Base
class Base  //类声明部分
{
    private: //声明私有数据成员
        T a;
    public:
        Base(T x) { a=x; }
        void Show() { cout<< "a="<<a<<","; }
};
//无类实现部分

class Derived:public Base<double> //公有继承基类模板Base，派生时实例化
{
    private: //声明新增数据成员
        int b;
    public:
        //注意派生类构造函数写法
        Derived(double p1,int p2):Base<double>(p1) { b=p2; } 
        //新增函数成员Show
        void Show() { Base <double>::Show(); cout<< "b="<<b<<endl; }
};

int main()
{
    Derived obj(10.5,6);//定义派生类Derived对象obj
    obj.Show(); //显示结果：a=10.5,b=6
    return 0;
}

在编译到派生类Derived的定义代码时，编译器将按照所给定的实际数据类型double对类模板Base进行实例化，生成一个double型的实例类，最终派生类Derived继承的是该实例类。

2、定义派生类模板

定义派生类模板是派生类在继承类模板基类时不进行实例化，因此派生类仍然是一个类模板。

派生类模板示例

#include<iostream>
using namespace std;
template <typename T> //类模板基类Base
class Base  //类声明部分
{
    private: //声明私有数据成员
        T a;
    public:
        Base(T x) { a=x; }
        void Show() { cout<< "a="<<a<<","; }
};
//无类实现部分

//公有继承类模板Base，派生类仍为类模板
template <typename T,typename TT> //新增类型参数TT
class Derived:public Base<T> //公有继承基类模板Base,定义派生类模板
{
    private: //声明新增数据成员
        TT b;
    public:
        //注意派生类构造函数写法
        Derived(T p1,TT p2):Base<T>(p1) { b=p2; } 
        //新增函数成员Show
        void Show() { Base <T>::Show(); cout<< "b="<<b<<endl; }
};

int main()
{
    Derived<double,int> obj(10.5,6);//定义派生类Derived对象obj
    obj.Show(); //显示结果：a=10.5,b=6
    return 0;
}

和其他类模板一样，派生类模板Derived在定义对象时需要明确给出派生类模板中类型参数所指代的实际数据类型。程序员编程时，在定义多个功能相同但处理数据类型不同的类时应考虑是否可以将它们合并成一个类模板，这样可以凝练代码。再定义单个类时也可以考虑升级成类模板，这样可以提高函数代码的可重用性。对于调用类模板的程序员而言，类模板和普通类没有什么区别。只是在使用类模板时需要给出类型参数所指代的实际数据类型。

声明：本站所发布的一切破解补丁、注册机和注册信息及软件的解密分析文章仅限用于学习和研究目的；不得将上述内容用于商业或者非法用途，否则，一切后果请用户自负。本站信息来自网络，版权争议与本站无关。您必须在下载后的24个小时之内，从您的电脑中彻底删除上述内容。如果您喜欢该程序，请支持正版软件，购买注册，得到更好的正版服务。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

相关文章