土建找工作去哪个网站,好分数的开发公司,自己建的网站无法打开,移动网站建设厂家这里写目录标题 1 模板的概念2 函数模板2.1 函数模板语法2.2 函数模板注意事项2.3 函数模板案例2.4 普通函数与函数模板的区别2.5 普通函数与函数模板的调用规则2.6 模板的局限性 3 类模板3.1 类模板语法3.2 类模板与函数模板区别3.3 类模板中成员函数创建时机3.4 类模板对象做… 这里写目录标题 1 模板的概念2 函数模板2.1 函数模板语法2.2 函数模板注意事项2.3 函数模板案例2.4 普通函数与函数模板的区别2.5 普通函数与函数模板的调用规则2.6 模板的局限性 3 类模板3.1 类模板语法3.2 类模板与函数模板区别3.3 类模板中成员函数创建时机3.4 类模板对象做函数参数3.5 类模板与继承3.6 类模板成员函数类外实现3.7 类模板分文件编写3.8 类模板与友元3.9 类模板案例案例描述: 实现一个通用的数组类要求如下 1 模板的概念
模板就是建立通用的模具大大提高复用性
模板的特点
模板不可以直接使用它只是一个框架模板的通用并不是万能的
2 函数模板 C另一种编程思想称为 泛型编程 主要利用的技术就是模板 C提供两种模板机制:函数模板和类模板
2.1 函数模板语法
函数模板作用
建立一个通用函数其函数返回值类型和形参类型可以不具体制定用一个虚拟的类型来代表。
语法
templatetypename T
函数声明或定义解释
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型可以用class代替
T — 通用的数据类型名称可以替换通常为大写字母
示例 //交换整型函数
void swapInt(int a, int b) {int temp a;a b;b temp;
}//交换浮点型函数
void swapDouble(double a, double b) {double temp a;a b;b temp;
}//利用模板提供通用的交换函数
templatetypename T
void mySwap(T a, T b)
{T temp a;a b;b temp;
}void test01()
{int a 10;int b 20;//swapInt(a, b);//利用模板实现交换//1、自动类型推导mySwap(a, b);//2、显示指定类型mySwapint(a, b);cout a a endl;cout b b endl;}int main() {test01();system(pause);return 0;
}总结
函数模板利用关键字 template使用函数模板有两种方式自动类型推导、显示指定类型模板的目的是为了提高复用性将类型参数化
2.2 函数模板注意事项
注意事项 自动类型推导必须推导出一致的数据类型T,才可以使用 模板必须要确定出T的数据类型才可以使用
示例
//利用模板提供通用的交换函数
templateclass T
void mySwap(T a, T b)
{T temp a;a b;b temp;
}// 1、自动类型推导必须推导出一致的数据类型T,才可以使用
void test01()
{int a 10;int b 20;char c c;mySwap(a, b); // 正确可以推导出一致的T//mySwap(a, c); // 错误推导不出一致的T类型
}// 2、模板必须要确定出T的数据类型才可以使用
templateclass T
void func()
{cout func 调用 endl;
}void test02()
{//func(); //错误模板不能独立使用必须确定出T的类型funcint(); //利用显示指定类型的方式给T一个类型才可以使用该模板
}int main() {test01();test02();system(pause);return 0;
}总结
使用模板时必须确定出通用数据类型T并且能够推导出一致的类型
2.3 函数模板案例
案例描述
利用函数模板封装一个排序的函数可以对不同数据类型数组进行排序排序规则从大到小排序算法为选择排序分别利用char数组和int数组进行测试
示例
//交换的函数模板
templatetypename T
void mySwap(T a, Tb)
{T temp a;a b;b temp;
}templateclass T // 也可以替换成typename
//利用选择排序进行对数组从大到小的排序
void mySort(T arr[], int len)
{for (int i 0; i len; i){int max i; //最大数的下标for (int j i 1; j len; j){if (arr[max] arr[j]){max j;}}if (max ! i) //如果最大数的下标不是i交换两者{mySwap(arr[max], arr[i]);}}
}
templatetypename T
void printArray(T arr[], int len) {for (int i 0; i len; i) {cout arr[i] ;}cout endl;
}
void test01()
{//测试char数组char charArr[] bdcfeagh;int num sizeof(charArr) / sizeof(char);mySort(charArr, num);printArray(charArr, num);
}void test02()
{//测试int数组int intArr[] { 7, 5, 8, 1, 3, 9, 2, 4, 6 };int num sizeof(intArr) / sizeof(int);mySort(intArr, num);printArray(intArr, num);
}int main() {test01();test02();system(pause);return 0;
}总结模板可以提高代码复用需要熟练掌握
2.4 普通函数与函数模板的区别
普通函数与函数模板区别
普通函数调用时可以发生自动类型转换隐式类型转换函数模板调用时如果利用自动类型推导不会发生隐式类型转换如果利用显示指定类型的方式可以发生隐式类型转换
示例
//普通函数
int myAdd01(int a, int b)
{return a b;
}//函数模板
templateclass T
T myAdd02(T a, T b)
{return a b;
}//使用函数模板时如果用自动类型推导不会发生自动类型转换,即隐式类型转换
void test01()
{int a 10;int b 20;char c c;cout myAdd01(a, c) endl; //正确将char类型的c隐式转换为int类型 c 对应 ASCII码 99//myAdd02(a, c); // 报错使用自动类型推导时不会发生隐式类型转换myAdd02int(a, c); //正确如果用显示指定类型可以发生隐式类型转换
}int main() {test01();system(pause);return 0;
}总结建议使用显示指定类型的方式调用函数模板因为可以自己确定通用类型T
2.5 普通函数与函数模板的调用规则
调用规则如下
如果函数模板和普通函数都可以实现优先调用普通函数可以通过空模板参数列表来强制调用函数模板函数模板也可以发生重载如果函数模板可以产生更好的匹配,优先调用函数模板
示例
//普通函数与函数模板调用规则
void myPrint(int a, int b)
{cout 调用的普通函数 endl;
}templatetypename T
void myPrint(T a, T b)
{ cout 调用的模板 endl;
}templatetypename T
void myPrint(T a, T b, T c)
{ cout 调用重载的模板 endl;
}void test01()
{//1、如果函数模板和普通函数都可以实现优先调用普通函数// 注意 如果告诉编译器 普通函数是有的但只是声明没有实现或者不在当前文件内实现就会报错找不到int a 10;int b 20;myPrint(a, b); //调用普通函数//2、可以通过空模板参数列表来强制调用函数模板myPrint(a, b); //调用函数模板//3、函数模板也可以发生重载int c 30;myPrint(a, b, c); //调用重载的函数模板//4、 如果函数模板可以产生更好的匹配,优先调用函数模板char c1 a;char c2 b;myPrint(c1, c2); //调用函数模板
}int main() {test01();system(pause);return 0;
}总结既然提供了函数模板最好就不要提供普通函数否则容易出现二义性
2.6 模板的局限性
局限性
模板的通用性并不是万能的
例如 templateclass Tvoid f(T a, T b){ a b;}在上述代码中提供的赋值操作如果传入的a和b是一个数组就无法实现了
再例如 templateclass Tvoid f(T a, T b){ if(a b) { ... }}在上述代码中如果T的数据类型传入的是像Person这样的自定义数据类型也无法正常运行
因此C为了解决这种问题提供模板的重载可以为这些特定的类型提供具体化的模板
示例
#includeiostream
using namespace std;#include stringclass Person
{
public:Person(string name, int age){this-m_Name name;this-m_Age age;}string m_Name;int m_Age;
};//普通函数模板
templateclass T
bool myCompare(T a, T b)
{if (a b){return true;}else{return false;}
}//具体化显示具体化的原型和定意思以template开头并通过名称来指出类型
//具体化优先于常规模板
template bool myCompare(Person p1, Person p2)
{if ( p1.m_Name p2.m_Name p1.m_Age p2.m_Age){return true;}else{return false;}
}void test01()
{int a 10;int b 20;//内置数据类型可以直接使用通用的函数模板bool ret myCompare(a, b);if (ret){cout a b endl;}else{cout a ! b endl;}
}void test02()
{Person p1(Tom, 10);Person p2(Tom, 10);//自定义数据类型不会调用普通的函数模板//可以创建具体化的Person数据类型的模板用于特殊处理这个类型bool ret myCompare(p1, p2);if (ret){cout p1 p2 endl;}else{cout p1 ! p2 endl;}
}int main() {test01();test02();system(pause);return 0;
}总结
利用具体化的模板可以解决自定义类型的通用化学习模板并不是为了写模板而是在STL能够运用系统提供的模板
3 类模板
3.1 类模板语法
类模板作用
建立一个通用类类中的成员 数据类型可以不具体制定用一个虚拟的类型来代表。
语法
templatetypename T
类解释
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型可以用class代替
T — 通用的数据类型名称可以替换通常为大写字母
示例
#include string
//类模板
templateclass NameType, class AgeType
class Person
{
public:Person(NameType name, AgeType age){this-mName name;this-mAge age;}void showPerson(){cout name: this-mName age: this-mAge endl;}
public:NameType mName;AgeType mAge;
};void test01()
{// 指定NameType 为string类型AgeType 为 int类型Personstring, intP1(孙悟空, 999);P1.showPerson();
}int main() {test01();system(pause);return 0;
}总结类模板和函数模板语法相似在声明模板template后面加类此类称为类模板
3.2 类模板与函数模板区别
类模板与函数模板区别主要有两点
类模板没有自动类型推导的使用方式类模板在模板参数列表中可以有默认参数
示例
#include string
//类模板
templateclass NameType, class AgeType int
class Person
{
public:Person(NameType name, AgeType age){this-mName name;this-mAge age;}void showPerson(){cout name: this-mName age: this-mAge endl;}
public:NameType mName;AgeType mAge;
};//1、类模板没有自动类型推导的使用方式
void test01()
{// Person p(孙悟空, 1000); // 错误 类模板使用时候不可以用自动类型推导Person string ,intp(孙悟空, 1000); //必须使用显示指定类型的方式使用类模板p.showPerson();
}//2、类模板在模板参数列表中可以有默认参数
void test02()
{Person string p(猪八戒, 999); //类模板中的模板参数列表 可以指定默认参数p.showPerson();
}int main() {test01();test02();system(pause);return 0;
}总结
类模板使用只能用显示指定类型方式类模板中的模板参数列表可以有默认参数
3.3 类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数创建时机是有区别的
普通类中的成员函数一开始就可以创建类模板中的成员函数在调用时才创建
示例
class Person1
{
public:void showPerson1(){cout Person1 show endl;}
};class Person2
{
public:void showPerson2(){cout Person2 show endl;}
};templateclass T
class MyClass
{
public:T obj;//类模板中的成员函数并不是一开始就创建的而是在模板调用时再生成void fun1() { obj.showPerson1(); }void fun2() { obj.showPerson2(); }};void test01()
{MyClassPerson1 m;m.fun1();//m.fun2();//编译会出错说明函数调用才会去创建成员函数
}int main() {test01();system(pause);return 0;
}总结类模板中的成员函数并不是一开始就创建的在调用时才去创建
3.4 类模板对象做函数参数
学习目标
类模板实例化出的对象向函数传参的方式
一共有三种传入方式
指定传入的类型 — 直接显示对象的数据类型参数模板化 — 将对象中的参数变为模板进行传递整个类模板化 — 将这个对象类型 模板化进行传递
示例
#include string
//类模板
templateclass NameType, class AgeType int
class Person
{
public:Person(NameType name, AgeType age){this-mName name;this-mAge age;}void showPerson(){cout name: this-mName age: this-mAge endl;}
public:NameType mName;AgeType mAge;
};//1、指定传入的类型
void printPerson1(Personstring, int p)
{p.showPerson();
}
void test01()
{Person string, int p(孙悟空, 100);printPerson1(p);
}//2、参数模板化
template class T1, class T2
void printPerson2(PersonT1, T2p)
{p.showPerson();cout T1的类型为 typeid(T1).name() endl;cout T2的类型为 typeid(T2).name() endl;
}
void test02()
{Person string, int p(猪八戒, 90);printPerson2(p);
}//3、整个类模板化
templateclass T
void printPerson3(T p)
{cout T的类型为 typeid(T).name() endl;p.showPerson();}
void test03()
{Person string, int p(唐僧, 30);printPerson3(p);
}int main() {test01();test02();test03();system(pause);return 0;
}总结
通过类模板创建的对象可以有三种方式向函数中进行传参使用比较广泛是第一种指定传入的类型
3.5 类模板与继承
当类模板碰到继承时需要注意一下几点
当子类继承的父类是一个类模板时子类在声明的时候要指定出父类中T的类型如果不指定编译器无法给子类分配内存如果想灵活指定出父类中T的类型子类也需变为类模板
示例
templateclass T
class Base
{T m;
};//class Son:public Base //错误c编译需要给子类分配内存必须知道父类中T的类型才可以向下继承
class Son :public Baseint //必须指定一个类型
{
};
void test01()
{Son c;
}//类模板继承类模板 ,可以用T2指定父类中的T类型
templateclass T1, class T2
class Son2 :public BaseT2
{
public:Son2(){cout typeid(T1).name() endl;cout typeid(T2).name() endl;}
};void test02()
{Son2int, char child1;
}int main() {test01();test02();system(pause);return 0;
}总结如果父类是类模板子类需要指定出父类中T的数据类型
3.6 类模板成员函数类外实现
学习目标能够掌握类模板中的成员函数类外实现
示例
#include string//类模板中成员函数类外实现
templateclass T1, class T2
class Person {
public://成员函数类内声明Person(T1 name, T2 age);void showPerson();public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
templateclass T1, class T2
PersonT1, T2::Person(T1 name, T2 age) {this-m_Name name;this-m_Age age;
}//成员函数 类外实现
templateclass T1, class T2
void PersonT1, T2::showPerson() {cout 姓名: this-m_Name 年龄: this-m_Age endl;
}void test01()
{Personstring, int p(Tom, 20);p.showPerson();
}int main() {test01();system(pause);return 0;
}总结类模板中成员函数类外实现时需要加上模板参数列表
3.7 类模板分文件编写
学习目标
掌握类模板成员函数分文件编写产生的问题以及解决方式
问题
类模板中成员函数创建时机是在调用阶段导致分文件编写时链接不到
解决
解决方式1直接包含.cpp源文件解决方式2将声明和实现写到同一个文件中并更改后缀名为.hpphpp是约定的名称并不是强制
示例
person.hpp中代码
#pragma once
#include iostream
using namespace std;
#include stringtemplateclass T1, class T2
class Person {
public:Person(T1 name, T2 age);void showPerson();
public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
templateclass T1, class T2
PersonT1, T2::Person(T1 name, T2 age) {this-m_Name name;this-m_Age age;
}//成员函数 类外实现
templateclass T1, class T2
void PersonT1, T2::showPerson() {cout 姓名: this-m_Name 年龄: this-m_Age endl;
}类模板分文件编写.cpp中代码
#includeiostream
using namespace std;//#include person.h
#include person.cpp //解决方式1包含cpp源文件//解决方式2将声明和实现写到一起文件后缀名改为.hpp
#include person.hpp
void test01()
{Personstring, int p(Tom, 10);p.showPerson();
}int main() {test01();system(pause);return 0;
}总结主流的解决方式是第二种将类模板成员函数写到一起并将后缀名改为.hpp
3.8 类模板与友元
学习目标
掌握类模板配合友元函数的类内和类外实现
全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在
示例
#include string//2、全局函数配合友元 类外实现 - 先做函数模板声明下方在做函数模板定义在做友元
templateclass T1, class T2 class Person;//如果声明了函数模板可以将实现写到后面否则需要将实现体写到类的前面让编译器提前看到
//templateclass T1, class T2 void printPerson2(PersonT1, T2 p); templateclass T1, class T2
void printPerson2(PersonT1, T2 p)
{cout 类外实现 ---- 姓名 p.m_Name 年龄 p.m_Age endl;
}templateclass T1, class T2
class Person
{//1、全局函数配合友元 类内实现friend void printPerson(PersonT1, T2 p){cout 姓名 p.m_Name 年龄 p.m_Age endl;}//全局函数配合友元 类外实现friend void printPerson2(PersonT1, T2 p);public:Person(T1 name, T2 age){this-m_Name name;this-m_Age age;}private:T1 m_Name;T2 m_Age;};//1、全局函数在类内实现
void test01()
{Person string, int p(Tom, 20);printPerson(p);
}//2、全局函数在类外实现
void test02()
{Person string, int p(Jerry, 30);printPerson2(p);
}int main() {//test01();test02();system(pause);return 0;
}总结建议全局函数做类内实现用法简单而且编译器可以直接识别
3.9 类模板案例
案例描述: 实现一个通用的数组类要求如下
可以对内置数据类型以及自定义数据类型的数据进行存储将数组中的数据存储到堆区构造函数中可以传入数组的容量提供对应的拷贝构造函数以及operator防止浅拷贝问题提供尾插法和尾删法对数组中的数据进行增加和删除可以通过下标的方式访问数组中的元素可以获取数组中当前元素个数和数组的容量
示例
myArray.hpp中代码
#pragma once
#include iostream
using namespace std;templateclass T
class MyArray
{
public://构造函数MyArray(int capacity){this-m_Capacity capacity;this-m_Size 0;pAddress new T[this-m_Capacity];}//拷贝构造MyArray(const MyArray arr){this-m_Capacity arr.m_Capacity;this-m_Size arr.m_Size;this-pAddress new T[this-m_Capacity];for (int i 0; i this-m_Size; i){//如果T为对象而且还包含指针必须需要重载 操作符因为这个等号不是 构造 而是赋值// 普通类型可以直接 但是指针类型需要深拷贝this-pAddress[i] arr.pAddress[i];}}//重载 操作符 防止浅拷贝问题MyArray operator(const MyArray myarray) {if (this-pAddress ! NULL) {delete[] this-pAddress;this-m_Capacity 0;this-m_Size 0;}this-m_Capacity myarray.m_Capacity;this-m_Size myarray.m_Size;this-pAddress new T[this-m_Capacity];for (int i 0; i this-m_Size; i) {this-pAddress[i] myarray[i];}return *this;}//重载[] 操作符 arr[0]T operator [](int index){return this-pAddress[index]; //不考虑越界用户自己去处理}//尾插法void Push_back(const T val){if (this-m_Capacity this-m_Size){return;}this-pAddress[this-m_Size] val;this-m_Size;}//尾删法void Pop_back(){if (this-m_Size 0){return;}this-m_Size--;}//获取数组容量int getCapacity(){return this-m_Capacity;}//获取数组大小int getSize(){return this-m_Size;}//析构~MyArray(){if (this-pAddress ! NULL){delete[] this-pAddress;this-pAddress NULL;this-m_Capacity 0;this-m_Size 0;}}private:T * pAddress; //指向一个堆空间这个空间存储真正的数据int m_Capacity; //容量int m_Size; // 大小
};类模板案例—数组类封装.cpp中
#include myArray.hpp
#include stringvoid printIntArray(MyArrayint arr) {for (int i 0; i arr.getSize(); i) {cout arr[i] ;}cout endl;
}//测试内置数据类型
void test01()
{MyArrayint array1(10);for (int i 0; i 10; i){array1.Push_back(i);}cout array1打印输出 endl;printIntArray(array1);cout array1的大小 array1.getSize() endl;cout array1的容量 array1.getCapacity() endl;cout -------------------------- endl;MyArrayint array2(array1);array2.Pop_back();cout array2打印输出 endl;printIntArray(array2);cout array2的大小 array2.getSize() endl;cout array2的容量 array2.getCapacity() endl;
}//测试自定义数据类型
class Person {
public:Person() {} Person(string name, int age) {this-m_Name name;this-m_Age age;}
public:string m_Name;int m_Age;
};void printPersonArray(MyArrayPerson personArr)
{for (int i 0; i personArr.getSize(); i) {cout 姓名 personArr[i].m_Name 年龄 personArr[i].m_Age endl;}}void test02()
{//创建数组MyArrayPerson pArray(10);Person p1(孙悟空, 30);Person p2(韩信, 20);Person p3(妲己, 18);Person p4(王昭君, 15);Person p5(赵云, 24);//插入数据pArray.Push_back(p1);pArray.Push_back(p2);pArray.Push_back(p3);pArray.Push_back(p4);pArray.Push_back(p5);printPersonArray(pArray);cout pArray的大小 pArray.getSize() endl;cout pArray的容量 pArray.getCapacity() endl;}int main() {//test01();test02();system(pause);return 0;
}总结
能够利用所学知识点实现通用的数组
