函数模板与类模板
前言
C++提供了模板(template)编程的概念。所谓模板,实际上是建立一个通用函数或类,其类内部的类型和函数的形参类型不具体指定,用一个虚拟的类型来代表。这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。
为什么要使用函数模板
这里用返回两数最大值做示列
使用一个函数用来实现多个函数返回两个数的最大值,要求支持多种类型变量
一、函数模板语法与定义
所谓函数模板,实际上是建立一个通用函数,其函数类型和形参类型不具体指定,用一个虚拟的类型来代表。这个通用函数就称为函数模板。
凡是函数体相同的函数都可以用这个模板来代替,不必定义多个函数,只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型,从而实现了不同函数的功能。
函数模板定义形式
由以下三部分组成: 模板说明 + 函数定义 + 函数模板调用
template < 类型形式参数表>
类型 函数名 (形式参数表)
{
//语句序列
}
1. 模板说明
template < 类型形式参数表>
类型形式参数的形式:
typename T1 , typename T2 , …… , typename Tn
或 class T1 , class T2 , …… , class Tn
(注:typename 和 class 的效果完全等同)
- 函数定义
类型 函数名 (形式参数表)
{
}
注意: 模板说明的类属参数必须在函数定义中出现一次
函数参数表中可以使用类属类型参数,也可以使用一般类型参数
- 函数模板调用
函数名<类型>( 变量a, 变量b ); //显式类型调用
函数名(a, b); //自动数据类型推导
4.模板函数示列:
二、函数模板与重载函数
思考一下:
1. 如果有函数模板和重载函数,编译器将会调用什么?
2.不存在普通函数,函数模板会隐式数据类型转换吗?
1.问题1
代码如下:
#include <iostream>
using namespace std;
template <typename T>
void Swap(T &a, T &b){
T t;
t = a;
a = b;
b = t;
cout<<"Swap 模板函数被调用了"<<endl;
}
void Swap(char &a, int &b){
int t;
t = a;
a = b;
b = t;
cout<<"Swap 普通函数被调用了"<<endl;
}
void main(void){
char cNum = 'c';
int iNum = 65;
Swap(cNum, iNum);
system("pause");
return ;
}
结论: 第一种情况,模板函数和普通函数并存,参数类型和普通重载函数更匹配将会调用普通函数
2.问题2
代码如下:
#include <iostream>
using namespace std;
template <typename T>
void Swap(T &a, T &b){
T t;
t = a;
a = b;
b = t;
cout<<"Swap 模板函数被调用了"<<endl;
}
void main(void){
char cNum = 'c';
int iNum = 65;
Swap(cNum, iNum);
system("pause");
return ;
}
结论: 第二种情况 不存在普通函数,函数模板会隐式数据类型转换嘛?
不提供隐式的数据类型转换,必须是严格的匹配
类模板
前言
为什么需要类模板
类模板与函数模板的定义和使用类似,有时,有两个或多个类,其功能是相同的,仅仅是数据类型不同
代码示列:
template <typename T>
class A
{
public:
A(T t)
{
this->t = t;
}
T &getT()
{
return t;
}
public:
T t;
};
得出结论:
类模板用于实现类所需数据的类型参数化
类模板在表示支持多种数据结构显得特别重要,这些数据结构的表示和算法不受所包含的元素类型的影响
类模板定义
类模板由模板说明和类说明构成模板说明同函数模板,如下:
template <类型形式参数表>
类声明
代码示列:
template <typename Type>
class ClassName
{
private :
Type DataMember;
}
模板类的使用
代码示列:
#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
//函数的参数列表使用虚拟类型
A(T t=0)
{
this->t = t;
}
//成员函数返回值使用虚拟类型
T &getT()
{
return t;
}
private:
//成员变量使用虚拟类型
T t;
};
void printA(A<int> &a){
cout<<a.getT()<<endl;
}
int main(void){
A<int> a(666);
cout<<a.getT()<<endl;
//模板类做为函数参数
printA(a);
system("pause");
return 0;
}
得出结论:
- 类模板定义对象,必须显示指定类型
- 模板种如果使用了构造函数,则遵守以前的类的构造函数的调用规则
继承中类模板怎么使用
首先思考
1. 父类一般类,子类是模板类
2. 子类是一般类,父类是模板类
3. 父类和子类都时模板类时
问题1
代码示列:
#include <iostream>
using namespace std;
class B
{
public:
B(int b)
{
this->b = b;
}
private:
int b;
};
template <typename T>
class A:public B
{
public:
//函数的参数列表使用虚拟类型
A(T t):B(0)
{
this->t = t;
}
//成员函数返回值使用虚拟类型
T &getT()
{
return t;
}
private:
//成员变量使用虚拟类型
T t;
};
问题1结论
父亲一般类,子类是模板类,和普通继承的玩法类似
问题2
代码示列:
#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
//函数的参数列表使用虚拟类型
A(T t)
{
this->t = t;
}
//成员函数返回值使用虚拟类型
T &getT()
{
return t;
}
private:
//成员变量使用虚拟类型
T t;
};
//需具体化模板
class B : public A<int> //A<int>参数列表初始化
{
public: //需具体化模板
B(Tb b) :A<int>(b) //初始化父类
{
this->b = b;
}
private:
int b;
};
问题2结论
子类是一般类,父类是模板类,继承时必须在子类里实例化父类的类型参数
问题3
代码示列:
#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
//函数的参数列表使用虚拟类型
A(T t)
{
this->t = t;
}
//成员函数返回值使用虚拟类型
T &getT()
{
return t;
}
private:
//成员变量使用虚拟类型
T t;
};
template <typename Tb>
class B: public A<int>
{
public:
B(Tb b):A<Tb>(b)
{
this->b = b;
}
private:
Tb b;
};
void printA(A<int> &a){
cout<<a.getT()<<endl;
}
int main(void){
//1.模板类定义类对象,必须显示指定类型
//2.模板种如果使用了构造函数,则遵守以前的类的构造函数的调用规则
A<int> a(666);
cout<<a.getT()<<endl;
B<int> b(888);
cout<<"b(888): "<<b.getT()<<endl;
//模板类做为函数参数
printA(a);
system("pause");
return 0;
}
问题3结论
父类和子类都时模板类时,子类的虚拟的类型可以传递到父类中
类模板的四种写法
上边的代码都是类内写的,列如文件分离的情况下,怎么写出类模板函数
第一种情况在cpp文件类内部
上面代码已实现,已讲解
第二种情况在cpp文件类外部
代码示例:
#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
A(T t=0);
T &getT();
A operator +(const A &other);
void print();
private:
T t;
};
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
A<T>::A(T t)
{
this->t = t;
}
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
T &A<T>::getT()
{
return t;
}
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
A<T> A<T>::operator+(const A<T> &other){
A<T> tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
void A<T>::print(){
cout<<this->t<<endl;
}
int main(void){
A<int> a(666), b(888);
A<int> tmp = a + b;
tmp.print();
system("pause");
return 0;
}
第三种情况文件分离
代码示例:
.h文件
#pragma once
template <typename T>
class A
{
public:
A(T t=0);
T &getT();
A operator +(const A &other);
void print();
private:
T t;
};
.cpp文件
#include "demo.h"
#include <iostream>
using namespace std;
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
A<T>::A(T t)
{
this->t = t;
}
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
T &A<T>::getT()
{
return t;
}
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
A<T> A<T>::operator+(const A<T> &other){
A<T> tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}
//需声明类型,告诉编译器将进行泛型编程
template <typename T>
void A<T>::print(){
cout<<this->t<<endl;
}
int main(void){
A<int> a(666), b(888);
A<int> tmp = a + b;
tmp.print();
system("pause");
return 0;
}
第四种情况main函数分离
main函数是独立.cpp文件时:
main函数代码示例:
cout << "示例:这样运行会直接报错,无法解析的外部符号" << endl;
/*
int main(void){
A<int> a(666), b(888);
A<int> tmp = a + b;
tmp.print();
system("pause");
return 0;
}*/
解决方案: 需要包含类模板实现的 .cpp文件
总结
在第二种情况需注意:
在同一个cpp 文件中把模板类的成员函数放到类的外部,需要注意以下几点
函数前声明 template <类型形式参数表>
类的成员函数前的类限定域说明必须要带上虚拟参数列表
返回的变量是模板类的对象时必须带上虚拟参数列表
成员函数参数中出现模板类的对象时必须带上虚拟参数列表
成员函数内部没有限定
在第三种情况需注意:
注意:当类模板的声明(.h文件)和实现(.cpp 或.hpp文件)完全分离,因为类模板的特殊实现,我们应在使用类模板时使用#include 包含 实现部分的.cpp 或.hpp文件。
特殊情况!!! 类模板与友元函数
代码示例:
#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
A(T t=0);
//声明一个友元函数,实现对两个A类对象进行加法操作
template <typename T>
friend A<T> addA(const A<T> &a, const A<T> &b);
T &getT();
A operator +(const A &other);
void print();
private:
T t;
};
template <typename T>
A<T>::A(T t)
{
this->t = t;
}
template <typename T>
T &A<T>::getT()
{
return t;
}
template <typename T>
A<T> A<T>::operator+(const A<T> &other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}
template <typename T>
void A<T>::print(){
cout<<this->t<<endl;
}
//A 类的友元函数,就是它的好朋友
template <typename T>
A<T> addA(const A<T> &a, const A<T> &b){
A<T> tmp;
cout<<"call addA()..."<<endl;
tmp.t = a.t + b.t;
return tmp;
}
int main(void){
A<int> a(666), b(888);
A<int> tmp = a + b;
A<int> tmp1 = addA<int>(a, b);
tmp.print();
tmp1.print();
system("pause");
return 0;
}
类模板友元结论
-
类内部声明友元函数,必须写成一下形式
template<typename T>
friend A <T> addA (A<T> &a, A<T> &b); -
友元函数实现 必须写成
template<typename T>
A< T> add(A< T> &a, A< T> &b)
{
//…
} -
友元函数调用 必须写成
A< int> c4 = addA< int>(c1, c2);
类模板与static成员
代码示例:
#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
A(T t=0);
T &getT();
A operator +(const A &other);
void print();
public:
static int count;
private:
T t;
};
template <typename T> int A<T>::count = 666;
template <typename T>
A<T>::A(T t)
{
this->t = t;
}
template <typename T>
T &A<T>::getT()
{
return t;
}
template <typename T>
A<T> A<T>::operator+(const A<T> &other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}
template <typename T>
void A<T>::print(){
cout<<this->t<<endl;
}
int main(void){
A<int> a(666), b(888);
A<int> tmp = a + b;
A<float> c(777), d(999);
a.count = 888;
cout<<"b.count:"<<b.count<<endl;
cout<<"c.count:"<<c.count<<endl;
cout<<"d.count:"<<d.count<<endl;
c.count = 1000;
cout<<"修改后, d.count:"<<d.count<<endl;
system("pause");
return 0;
}
类模板static总结
- 从类模板实例化的每个模板类有自己的类模板数据成员,该模板类的所有对象共享一个static数据成员
- 和非模板类的static数据成员一样,模板类的static数据成员也应该在文件范围定义和初始化
- static 数据成员也可以使用虚拟类型参数T