目录

1.模板 

1.1模板概念

1.2.函数模板

 1.2.1函数模板语法，函数模板的调用--1.自动类型推导，2.显示指定类型

1.2.2函数模板注意事项 

​编辑

 1.2.3函数模板的案例，选择排序，字符数组，字符串

1.2.4普通函数与函数模板的区别

 1.2.5普通函数和函数模板的调用规则，函数模板也可以发生重载

 1.2.6模板的局限性，模板的重载,j具体化模板

1.3类模板

1.3.1类模板语法 ，类模板创建对象必须用显式指定类型

1.3.2类模板与函数模板的区别，类模板创建对象必须用显式指定类型

 1.3.3类模板中成员函数创建时机--类模板中成员函数在调用时才去创建

1.3.4类模板对象做函数参数，用typeid可以查看模板推出的T的数据类型

 1.3.5类模板与继承

 1.3.6类模板成员函数类外实现

1.3.7类模板分文件编写

 1.3.8类模板与友元，全局函数类内实现，类外实现

 1.3.9类模板案例，如果函数调用想作为左值存在，我们要返回引用

1.模板 

1.1模板概念

 模板不可以直接使用比如一寸照，不能直接不p照片就用。不是万能的，不如不能把小狗的照片p到刚刚一寸照上。

1.2.函数模板

写了模板，下面紧跟了一个函数，这个函数就称为函数模板 

 1.2.1函数模板语法，函数模板的调用--1.自动类型推导，2.显示指定类型

#include
using namespace std;//交换两个整型的函数
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;
}//函数模板
//template告诉编译器我要开始写一个模板了,typename可以替换为class
//typename表明后面的符号是一种通用的数据类型，T名称可以替换，一般都用T表示
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型
template
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.显示指定类型mySwap(a, b);//指定T是int型cout << "a = " << a << " b = " << b << endl;double c = 1.1;double d = 2.2;swapDouble(c, d);cout << "c = " << c << " d = " << d << endl;
}
int main()
{test01();system("pause");//按任意键继续return 0;
}

1.2.2函数模板注意事项 

#include
using namespace std;//函数模板注意事项template//typename可以替换成class
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);//正确//mySwap(a, c);//报错,一个int 一个char 推导不出一致的T类型cout << "a = " << a << " b = " << b << endl;
}
//2.模板必须要确定出T的数据类型才可以使用
template
void func()
{//是一个函数模板//写了一个模板，下面紧跟了一个函数，是函数模板cout << "func 调用" << endl;
}
void test02()
{//func();//报错,没有给出T的数据类型func();//显示指定类型调用，因为咱的函数体内也没用到T,但是又不能不给T的数据类型//随便给一个T的类型就好
}int main()
{test01();test02();system("pause");//按任意键继续return 0;
}

 1.2.3函数模板的案例，选择排序，字符数组，字符串

#include
using namespace std;//实现通用的对数组进行排序的函数
//规则 从大到小
//算法 选择排序//交换函数模板
template
void mySwap(T& a, T& b)
{T temp = a;a = b;b = temp;
}
template
void mySort(T a[],int len)
{int max = 0;for (int i = 0; i < len; i++){max = i;//认定最大值的下标for (int j = i + 1; j < len; j++){//认定的最大值 比 遍历出的数组 要小 说明j下标的元素才是真正的最大值if (a[max] < a[j]){max = j;//更新最大值下标}}if (max != i){//交换max和i下标的元素mySwap(a[i], a[max]);}}
}//提供打印数组的模板
template
void printArray(T* arr, int len)
{for (int i = 0; i < len; i++){cout << arr[i] << " ";}cout << endl;
}
void test01()
{int a[5] = { 1,2,3,4 };//int a[] = { 1,2,3,4,0 };char b[5] = { 'a','b','c','d','e' };//char b[] = { 'a','b','c','d','e' };mySort(a, sizeof(a) / sizeof(a[0]));printArray(a, sizeof(a) / sizeof(a[0]));mySort(b, sizeof(b) / sizeof(b[0]));printArray(b, sizeof(b) / sizeof(b[0]));char ch[] = "badcfe";mySort(ch, sizeof(ch) / sizeof(ch[0]));cout << ch << endl;char ch1[] = { 'b','a','d','c','f','e',0 };mySort(ch, sizeof(ch1) / sizeof(char));cout << ch1 << endl;
}
int main()
{test01();system("pause");//按任意键继续return 0;
}

1.2.4普通函数与函数模板的区别

#include
using namespace std;//普通函数与函数模板的区别
//1.普通函数调用可以发生隐式类型转换（自动类型转换）
//2.函数模板 用自动类型推导调用时，不会发生隐式类型转换
//3.函数模板 用显示指定类型调用时，会发生隐式类型转换//普通函数
int myAdd01(int a, int b)
{return a + b;
}template
T myAdd02(T a, T b)
{return a + b;
}
void test01()
{int a = 10;int b = 20;char c = 'c';//ASCII c:99cout << myAdd01(a, b) << endl;cout << myAdd01(a, c) << endl;//把字符型c转换成了整型//自动类型推导 不会发生隐式类型转换cout << myAdd02(a, b) << endl;//cout << myAdd02(a, c) << endl;//报错,a int c char 没办法推导出一致的T//显示指定类型cout << myAdd02(a, c) << endl;//已经明确告诉T就是int，如果不是int的你就给我转成int
}int main()
{test01();system("pause");//按任意键继续return 0;
}

 1.2.5普通函数和函数模板的调用规则，函数模板也可以发生重载

#include
using namespace std;//普通函数与函数模板的调用规则
//1.如果函数模板和普通函数都可以调用，即就是你写的这句话可以调用函数模板
//也可以调用普通函数，哪调用哪一个呢？优先调用普通函数
//2.可以通过空模板参数列表 强制调用 函数模板
//3.函数模板也可以发生函数重载
//4.如果函数模板可以产生更好的匹配，优先调用函数模板void myPrint(int a, int b)
{cout << "调用的普通函数" << endl;
}template
void myPrint(T a, T b)
{cout << "调用的模板" << endl;
}
//函数模板也可以发生重载
template
void myPrint(T a, T b,T c)
{cout << "调用的重载模板" << endl;
}void test01()
{int a = 10;int b = 20;myPrint(a, b);//普通函数和函数模板都可以调用，优先调用普通函数//通过空模板的参数列表，强制调用函数模板myPrint<>(a, b);//<>这个里面什么都不要写，模板的参数列表就是<>,//如果是空模板的参数列表，那么<>里面就什么都不要写//3.函数模板也可以发生函数重载myPrint(a, b,100);//4.如果函数模板可以产生更好的匹配，优先调用函数模板char c1 = 'a';char c2 = 'b';myPrint(c1, c2);//普通函数和函数模板都可以调用，//因为普通函数是可以发生强制类型转换(隐式类型转换)的，此时调用的时模板//编译器认为调用普通函数需要把char转成int ,太麻烦了//不如直接推导出T就是char//也就是如果模板不发生隐式类型转换就优先调用模板}int main()
{test01();system("pause");//按任意键继续return 0;
}

实际上代码里的普通函数没有必要写，因为你的T可以是int,实际开发中我们也没不会这样写 

 1.2.6模板的局限性，模板的重载,j具体化模板

 运算符重载版本

#include
using namespace std;//模板局限性
//模板不是万能的，有些特定数据类型，需要用具体化方式做特殊实现class Person
{
public:Person(string name, int age){m_Name = name;m_Age = age;}bool operator==(Person& p){if (this->m_Name == p.m_Name && this->m_Age == p.m_Age){return true;}return false;}//姓名string m_Name;//年龄int m_Age;
};
//对比两个数据是否相等
template
bool myCompare(T& a, T& b)
{if (a == b){return true;}else{return false;}
}
void test01()
{int a = 10;int b = 20;bool ret = myCompare(a, b);if (ret == 1){cout << "a==b" << endl;}else{cout << "a!=b" << endl;}
}
void test02()
{Person p1("Tom", 10);Person p2("Tom", 10);bool ret = myCompare(p1, p2);if (ret == 1){cout << "p1==p2" << endl;}else{cout << "p1!=p2" << endl;}//第一种解决方法，运算符重载}
int main()
{test01();test02();system("pause");//按任意键继续return 0;
}

具体化的模板

#include
using namespace std;//模板局限性
//模板不是万能的，有些特定数据类型，需要用具体化方式做特殊实现class Person
{
public:Person(string name, int age){m_Name = name;m_Age = age;}//姓名string m_Name;//年龄int m_Age;
};
//对比两个数据是否相等
template
bool myCompare(T& a, T& b)
{if (a == b){return true;}else{return false;}
}
//利用具体化Person版本实现代码，具体化优先调用
//以后遇到Person会走下面的代码而不是走上面的
//template<>告诉编译器是模板的重载版本template<> bool myCompare(Person& a, Person& b)
{if (a.m_Name == b.m_Name && a.m_Age == a.m_Age){return true;}else{return false;}
}}
void test01()
{int a = 10;int b = 20;bool ret = myCompare(a, b);if (ret == 1){cout << "a==b" << endl;}else{cout << "a!=b" << endl;}
}
void test02()
{Person p1("Tom", 10);Person p2("Tom", 10);bool ret = myCompare(p1, p2);if (ret == 1){cout << "p1==p2" << endl;}else{cout << "p1!=p2" << endl;}//第一种解决方法，运算符重载}
int main()
{test01();test02();system("pause");//按任意键继续return 0;
}

1.3类模板

1.3.1类模板语法 ，类模板创建对象必须用显式指定类型

#include
using namespace std;//类模板
template
//因为类中两个变量的类型不一样，所以不能像以前一样template
//只有一个T,如果类型一样可以用一个T
class Person
{
public:Person(NameType name, AgeType age){m_Name = name;m_Age = age;}void showPerson(){ cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;}NameType m_Name;AgeType m_Age;
};
void test01()
{Personp1("孙悟空", 18);//模板的参数列表,不写会报错p1.showPerson();
}
int main()
{test01();system("pause");//按任意键继续return 0;
}

1.3.2类模板与函数模板的区别，类模板创建对象必须用显式指定类型

函数模板与类模板在 C++98 一起被引入，因种种原因，类模板可以拥有默认模板参数，而函数模板不可以。从 C++11 开始，这个限制被解除了，即函数模板同样可以拥有默认模板参数。

 (3条消息) C++11 函数模板的默认模板参数_恋喵大鲤鱼的博客-CSDN博客

#include
using namespace std;//类模板与函数模板的区别
template
//<>里面是模板参数列表
class Person
{
public:Person(NameType name, AgeType age){m_Name = name;m_Age = age;}void showPerson(){cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;}NameType m_Name;AgeType m_Age;
};
//1.类模板没有自动类型推导的使用方式
void test01()
{//Person p("孙悟空", 1000);//报错，无法用自动类型推导Personp("孙悟空", 1000);//只能用显示指定类型p.showPerson();
}//2.类模板在模板参数列表中可以有默认参数
void test02()
{Personp("猪八戒", 999);//虽然没指定年龄的类型，但是我们已经默认是int//传了就是传入的类型，没传就是默认的类型 p.showPerson();Person<>p1("沙和尚", 998);//即使都用默认也要写<>,不写<>又是自动类型推导了，不能用p1.showPerson();
}int main()
{test01();test02();system("pause");//按任意键继续return 0;
}

 1.3.3类模板中成员函数创建时机--类模板中成员函数在调用时才去创建

#include
using namespace std;//类模板中成员函数创建时机
//类模板中成员函数在调用时才去创建
class Person1
{
public:void showPerson1(){cout << "Person1 show" << endl;}
};
class person2
{
public:void showPerson2(){cout << "Person2 show" << endl;}
};
template
class MyClass
{
public:T obj;//类模板中的成员函数void func1(){obj.showPerson1();}void func2(){obj.showPerson2();}//可以编译成功，这俩个成员函数只要不调用就不会创建，为什么不创建？//因为没办法确定obj的类型
};
void test01()
{MyClassm;m.func1();
}
int main()
{test01();system("pause");//按任意键继续return 0;
}

1.3.4类模板对象做函数参数，用typeid可以查看模板推出的T的数据类型

#include
using namespace std;//类模板对象做函数参数
template
class Person
{
public:Person(T1 name, T2 age){m_Name = name;m_Age = age;}void showPerson(){cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;}T1 m_Name;T2 m_Age;
};
//1.指定传入类型
//常用
void printPerson1(Person&p1)//&不用拷贝出来一个副本，直接拿到p的本体
{p1.showPerson();
}
void test01()
{Personp("孙悟空", 18);printPerson1(p);
}//2.参数模板化
template
void printPerson2(Person&p)//将Person中的参数模板化
{p.showPerson();cout << "T1 的类型为:" << typeid(T1).name() << endl;cout << "T2 的类型为:" << typeid(T2).name() << endl;
}
void test02()
{Personp("猪八戒", 20);printPerson2(p);
}//3.整个类模板化
template
void printPerson3(T &p)//将整个Person类模板化
{p.showPerson();cout << "T 的类型为:" << typeid(T).name() << endl;
}
void test03()
{Personp("唐僧", 40);printPerson3(p);
}
int main()
{test01();test02();test03();system("pause");//按任意键继续return 0;
}

 1.3.5类模板与继承

#include
using namespace std;//类模板与继承
template
class Base
{T m;
};
//class Son:public Base//报错，必须要知道父类中T的类型，才能继承给子类
class Son :public Base//告诉父类中T的数据类型
{};//如果想灵活指定父类中T的类型，子类也需要变成类模板
template
class Son2 :public Base//T2指定出父类中的模板到底是什么数据类型
{
public:Son2(){cout << "T1的类型为：" << typeid(T1).name() << endl;cout << "T2的类型为：" << typeid(T2).name()<< endl;//创建对象的时候会调用构造函数}T1 obj;
};
void test01()
{Son2 s;//类模板创建对象必须用显式指定类型}
int main()
{test01();system("pause");//按任意键继续return 0;
}

 1.3.6类模板成员函数类外实现

#include
using namespace std;//类模板成员函数类外实现
template
class Person
{
public:Person(T1 name, T2 age);/*{m_Name = name;m_Age = age;}*/void showPerson();/*{cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;}*/T1 m_Name;T2 m_Age;
};//构造函数的类外实现
template
Person::Person(T1 name, T2 age)//Person作用域下的构造函数,Person类模板的类外实现
{m_Name = name;m_Age = age;
}
//成员函数的类外实现
template
void Person::showPerson()
{cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
}
void test01()
{Personp("Tom", 20);p.showPerson();
}
int main()
{test01();system("pause");//按任意键继续return 0;
}

1.3.7类模板分文件编写

下面图片左边第一张会报错，解决办法如右边图片所示 

 解决方式1

#include
using namespace std;
//第一种解决方式 直接包含源文件
//一般没这样做的
#include"person.cpp"
//类模板分文件编写问题及解决
void test01()
{Personp("Jarry", 18);p.showPersson();
}
int main()
{test01();system("pause");//按任意键继续return 0;
}
//这是因为类模板中的成员函数一开始是不会创建的
//当写#include"person.h"时，编译器看到.h中类里面的
//成员函数是不会创建的，.cpp中的内容编译器看不到
//但是如果写.cpp，编译器会看到cpp中的内容
//#include"person.h"又让编译器看到了.h中的内容

 解决方式2

#pragma once
#include
using namespace std;
template
class Person
{
public:Person(T1 name, T2 age);void showPersson();T1 m_Name;T2 m_Age;
};
//声明实现都在一个文件中
template
Person::Person(T1 name, T2 age)
{m_Name = name;m_Age = age;
}
template
void Person::showPersson()
{cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
}

#include
using namespace std;#include"person.hpp"
//第二种解决办法，将.h和.cpp中的内容写到一起，
// 将后缀名改为.hpp文件
//也就是不要把声明和实现分开去写
// 只要一写.hpp大家约定俗成的就知道这是一个类模板
// hpp不是必须的名称，只不过大家都这样写
//类模板分文件编写问题及解决
void test01()
{Personp("Jarry", 18);p.showPersson();
}
int main()
{test01();system("pause");//按任意键继续return 0;
}

 1.3.8类模板与友元，全局函数类内实现，类外实现

上图是类外实现为什么会报错 

#include
using namespace std;
//通过全局函数打印Person信息//提前让编译器知道Person类的存在
template
class Person;//因为printPerson2(Person p)出现了Person,所以还要声明一下Perosn
//告诉编译器有Person这个类，而且还是模板类
//类外实现
template
void printPerson2(Person p)//参数模板化
{//首先要不要告诉一下是Person作用域下的？//没必要加作用域，因为这是一个全局函数，没必要多此一举cout << "类外实现-----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
template
class Person
{//全局函数 类内实现friend void printPerson(Person &p)//类模板做函数参数，参数模板化{cout << "类内实现----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;}//全局函数 类外实现//类内需要声明friend void printPerson2<>(Person p);//参数模板化//这是一个普通函数的声明//而下面是一个函数模板的实现//所以会报错//修改方法就是加一个空模板参数列表//如果全局函数是类外实现 需要让编译器提前知道这个函数的存在//1.第一种方法就是把实现写在类前面//2.
public:Person(T1 name, T2 age){m_Name = name;m_Age = age;}
private:T1 m_Name;T2 m_Age;
};//1.全局函数在类内实现测试
void test01()
{Personp("Tom", 20);printPerson(p);
}
//2.全局函数 类外实现测试
void test02()
{Personp2("Jerry", 20);printPerson2(p2);
}
int main()
{test01();test02();system("pause");//按任意键继续return 0;
}

#include
using namespace std;
//通过全局函数打印Person信息//提前让编译器知道Person类的存在
template
class Person;//因为printPerson2(Person p)出现了Person,所以还要声明一下Perosn
//告诉编译器有Person这个类，而且还是模板类
template
void printPerson2(Person p);template
class Person
{//全局函数 类内实现friend void printPerson(Person p)//类模板做函数参数，参数模板化{cout << "类内实现----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;}//全局函数 类外实现//类内需要声明friend void printPerson2<>(Person p);//参数模板化//这是一个普通函数的声明//而下面是一个函数模板的实现//所以会报错//修改方法就是加一个空模板参数列表//如果全局函数是类外实现 需要让编译器提前知道这个函数的存在//1.第一种方法就是把实现写在类前面//2.第二种方法先声明
public:Person(T1 name, T2 age){m_Name = name;m_Age = age;}
private:T1 m_Name;T2 m_Age;
};
//类外实现
template
void printPerson2(Person p)//参数模板化
{//首先要不要告诉一下是Person作用域下的？//没必要加作用域，因为这是一个全局函数，没必要多此一举cout << "类外实现-----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
//1.全局函数在类内实现测试
void test01()
{Personp("Tom", 20);printPerson(p);
}
//2.全局函数 类外实现测试
void test02()
{Personp2("Jerry", 20);printPerson2(p2);
}
int main()
{test01();test02();system("pause");//按任意键继续return 0;
}

 1.3.9类模板案例，如果函数调用想作为左值存在，我们要返回引用

#pragma once
//自己通用的数组类
//因为是模板类所以分文件编写时写成.hpp
#include
using namespace std;
template
class MyArray
{
public://有参构造MyArray(int capacity){cout << "MyArray有参构造调用" << endl;m_Capcity = capacity;m_Size = 0;pAddress = new T[capacity];}//拷贝构造MyArray(const MyArray& arr){cout << "MyArray拷贝构造调用" << endl;m_Capcity = arr.m_Capcity;m_Size = arr.m_Size;//pAddress = arr.pAddress;//浅拷贝//深拷贝pAddress = new T[arr.m_Capcity];//将arr中的数据都拷贝过来for (int i = 0; i < arr.m_Size; i++){pAddress[i] = arr.pAddress[i];}}//operator= 防止浅拷贝问题MyArray& operator=(const MyArray &arr){cout << "MyArray operator=调用" << endl;//先判断原来堆区是否有数据，如果有先释放if (pAddress != NULL){delete[] pAddress;pAddress = NULL;}m_Capcity = arr.m_Capcity;m_Size = arr.m_Size;//深拷贝pAddress = new T[arr.m_Capcity];//将arr中的数据都拷贝过来for (int i = 0; i < arr.m_Size; i++){pAddress[i] = arr.pAddress[i];}return *this;}//析构函数//堆区数据手动开辟 手动释放~MyArray(){if (pAddress != NULL){cout << "MyArray 析构函数调用" << endl;delete[] pAddress;pAddress = NULL;//防止野指针}}
private:T* pAddress;//指针指向堆区开辟的真实数组int m_Capcity;//数组容量int m_Size;//数组大小
};

 测试

#include
using namespace std;
#include"MyArray.hpp"void test01()
{MyArrayarr1(5);MyArrayarr2(arr1);//拷贝构造MyArrayarr3(100);arr3 = arr1;
}
int main()
{test01();//局部变量，放在栈上，test01执行完之后会调用析构system("pause");//按任意键继续return 0;
}

#include
using namespace std;
#include"MyArray.hpp"void printIntArray(MyArray& arr)
{for (int i = 0; i < arr.getSize(); i++){cout << arr[i]<<" ";//等价于arr.[](i)}cout << endl;
}
void test01()
{MyArrayarr1(5);//arr1[0];//报错，这是我们自己写的类哪有[]for (int i = 0; i < 5; i++){//利用尾插法向数组中插入数据arr1.Push_Back(i);}cout << "arr1的打印输出：" << endl;printIntArray(arr1);cout << "arr1容量：" << arr1.getCapacity() << endl;cout << "arr1大小：" << arr1.getSize() << endl;MyArrayarr2(arr1);cout << "arr2的打印输出：" << endl;printIntArray(arr2);//尾删arr2.Pop_Back();cout << "arr2尾删后：" << endl;cout << "arr2容量：" << arr2.getCapacity() << endl;cout << "arr2大小：" << arr2.getSize() << endl;}//测试自定义的数据类型
class Person
{
public:Person(){}Person(string name,int age){m_Name = name;m_Age = age;}string m_Name;int m_Age;
};
void printPerson(MyArray& arr)
{for (int i = 0; i < arr.getSize(); i++){cout << "姓名：" << arr[i].m_Name << " 年龄：" << arr[i].m_Age<< endl;}
}
void test02()
{MyArray arr2(10);Person p1("孙悟空", 999);Person p2("猪八戒", 888);Person p3("沙和尚", 777);Person p4("唐僧", 1000);//将数据插入到数组中arr2.Push_Back(p1);arr2.Push_Back(p2);arr2.Push_Back(p3);arr2.Push_Back(p4);//打印数组printPerson(arr2);//输出容量cout << "arr2容量：" << arr2.getCapacity() << endl;//输出大小cout << "arr2大小：" << arr2.getSize() << endl;}
int main()
{test01();test02();system("pause");//按任意键继续return 0;
}