模 板 --函数模板与类模板
1.模板
模板的概念
模板就是建立通用的模具，大大提高复用性
模板的特点:
摸板不可以直接使用。它只是一个框架
模板的通用并不是万能的
2.函数模板
C++另一种编程思想称泛型编程,主要利用的技术就是模板。
C++提供两种模板机制: 函数模板 和 类模板
函数模板语法
函数模板作用:
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。
语法：
template
函数声明或定义
解释:
template ---声明创建模扳
typename ---表面其后面的符号是一种数据类型，可以用class代替
T---通用的数据类型,名称可以替换,通常为大写字母
//函数模板
template
void mySwap(T &a, T &b) {
T temp = a;
a = b;
b = temp;
}
void test99() {
double a = 12;
double b = 34;
//利用函数模板交换
//两种方式使用函数模板
//1、自动类型推导
//mySwap(a, b);
//2、显示指定类型
mySwap
cout << "a= " << a << endl;
cout << "b=" << b << endl;
}
函数模板注意事项
注意事项:
·自动类型推导，必须推导出一致的数据类型T,才可以使用
int a = 10;
char c = 'd';
mySwap(a, c);
·模板必须要确定出T的数据类型,才可以使用
template
void func() {
cout << "func using" << endl;
}
void test923() {
func
}
3.普通函数与函数模板的区别
普通函数与函数模板区别:
普通函数调用时可以发生自动类型转换 (隐式类型转换)
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式,可以发生隐式类型转换
建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T
//普通函数
int myAdd01(int a, int b) {
return a + b;
}
template
T myAdd02(T a,T b) {
return a + b;
}
void test876() {
//普通函数
int a = 34;
int b = 7;
char c = 'a'; //转成ASCII码 a = 97
cout << myAdd01(a, c) << endl;
//自动类型推导
cout << myAdd02(a, b) << endl;
//显示指定类型
cout << myAdd02
}
3.普通函数与函数模板的调用规则
调用规则如下:
1.如果函荻模板和普通函数都可以实现,优先调用普通函教
2.可以通过空模板参数列表来强制调用函教模板
3.函数模板也可以发生重载
4.如果函数模板可以产生更好的匹配 优先调用函数模板
总结: 既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性
void print( int a,int b)
{
cout << "普通函数的调用" << endl;
}
template
void print(T a, T b) {
cout << "调用的模板函数" << endl;
}
//模板函数重载
template
void print(T a, T b,T c)
{
cout << "调用的重载模板函数" << endl;
}
void test78()
{
int a = 23;
int b = 34;
//通过空模板参数列表，强制调用函数模板
print<>(a, b);
//调用的重载模板函数
print<>(a, b,100);
char c1 = 'a';
char c2 = 'b';
print(c1, c2);
}
4.模板的局限性
局限性: 模板的通用性并不是万能的
利用具体化的模板，可以解决自定义类型的通用化I
学习模板并不是为了写模板,而是在STL能够运用系统提供的模板
class Person {
public :
//姓名
string m_Name;
int m_Age;
Person(string name, int age) {
this->m_Age = age;
this->m_Name = name;
}
};
template
bool myCompare(T &a, T &b) {
if (a == b) {
return true;
}
else {
return false;
}
}
//利用具体化Person的版本实现代码，具体化优先调用
template<> bool myCompare(Person &p1, Person &p2)
{
if ((p1.m_Name == p2.m_Name) && (p1.m_Age == p2.m_Age))
{
return true;
}
return false;
}
void test033()
{
Person p1("tom", 18);
Person p2("tom", 18);
bool ret = myCompare(p1, p2);
if (ret) {
cout << " p1 == p2" << endl;
}
else {
cout << " p1 ！= p2" << endl;
}
}
5.类模板
类模板作用:
建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。
语法：
template
类
解释:
template ---声明创建模板
typename ---表面其后面的符号是一种数据类型，可以用class代替
T---通用的教据类型，名称可以替换,通常为大写字母
//类模板
template
class People {
public :
NameType m_Name;
AgeType m_Age;
People(NameType name, AgeType age) {
this->m_Name = name;
this->m_Age = age;
}
void showPerson() {
cout << "name: " << this->m_Name << " age:" << this->m_Age << endl;
}
};
void test986() {
People
p1.showPerson();
}
6.类模板与函数模板区别
类模板与函数模板区别主要有两点:
1.类模板没有自动类型推导的使用方式
People p("dd", 234);//错误, 无法用自动类型推导
2.类模板在模板参数列表中可以有默认参数
template
7.类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数
创建时机是有区别的:
普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建
8.类模板对象做函数参数
类模板实例化出的对象,向函教传参的方式
—共有三种传入方式:
1.指定传入的类型---直接显示对象的数据类型
2参数模板化-一将对象中的参数变为模板进行传递
3.整个类模板化-将这个对象类型模板化进行传递
9.类模板与继承
当类模板碰到继承时，需要注意一下几点:
当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定,编译器无法给子类分配内存
如果想灵活指定出父类中T的类型,子类也需变为类模板
总结:如果父类是类模板，子类需要指定出父类中T的数据类型
//类模板与继承
template
class Base
{
T t;
};
//class Son : public Base //错误，必须要知道父类的T类型，才能继承给子类
class Son : public Base
{
};
//如果想灵活指定父类中T类型，子类也需要变类模板
template
class Son2: public Base
{
public:
Son2()
{
cout << "T1的类型为：" << typeid(T1).name() << endl;
cout << "T2的类型为：" << typeid(T2).name() << endl;
}
T1 obj;
};
void test01()
{
Son s1;
Son2
}
10.类模板成员函数类外实现
//类模板成员函数类外实现
template
class Person
{
public :
T1 m_Name;
T2 m_age;
Person(T1 name, T2 age);
/* {
this->m_Name = name;
this->m_age = age;
}*/
void showPerson();
/* {
cout << "姓名：" << this->m_Name << "年龄：" << this->m_age << endl;
}*/
};
//构造函数类外实现
template
Person< T1,T2>::Person(T1 name, T2 age) {
this->m_Name = name;
this->m_age = age;
}
template
void Person< T1, T2>:: showPerson() {
cout << "姓名：" << this->m_Name << "年龄：" << this->m_age << endl;
}
void test02()
{
Person
P.showPerson();
}
11.类模板分文件编写学习目标
问题:
类模板中成员函数创建时机是在调用阶段。导致分文件编写时链接不到
解决:
解决方式1: 直接包含.cpp源文件
解决方式2∶ 将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制
总结:主流的解决方式是第二种，将类模板成员函教写到一起，并将后缀名改为.hpp I
person.h
#pragma once
#include
#include
using namespace std;
//类模板分文件编写问题以及解决
template
class People
{
public:
T1 m_Name;
T2 m_age;
People(T1 name, T2 age);
void showPerson();
};
person.cpp
#include "person.h"
//构造函数类外实现
template
People< T1, T2>::People(T1 name, T2 age) {
this->m_Name = name;
this->m_age = age;
}
template
void People< T1, T2>::showPerson() {
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_age << endl;
}
y77cpp.cpp
#include "person.cpp"
//第一种解决方式,直接包含源文件
// #include "person.cpp"
//第二种解决方式，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
//#include "person.hpp"
void test03()
{
People
P.showPerson();
}
int main()
{
test03();
system("pause");
return 0;
}
12.类模板与友元
全局函数类内实现--直接在类内声明友元即可
全局函数类外实现--需要提前让编译器知道全局函数的存在
#include
#include
using namespace std;
//提前让编译器知道Person类存在
template
class Peo;
//类外实现
template
void printPerson2(Peo
cout << "类外--姓名：" << p.m_Name << "年龄：" << p.m_age << endl;
}
template
class Peo
{
//全局函数 类内实现
friend void printPerson(Peo
{
cout << "姓名：" << p.m_Name << "年龄：" << p.m_age << endl;
}
//全局函数 类外实现
//加空模板参数列表
//如果全局函数 是类外实现，需要让编译器提前知道这个函数的存在
friend void printPerson2<> (Peo
public:
T1 m_Name;
T2 m_age;
Peo(T1 name, T2 age)
{
this->m_Name = name;
this->m_age = age;
}
};
void test023()
{
Peo
printPerson(P);
printPerson2(P);
}
int main()
{
test023();
system("pause");
return 0;
}
上一篇：【算法】分治法详解和汇总