|
1.模板的概念
模板就是建立通用的模具，大大提高复用性
特点：
模板不可以直接使用，它只是一个框架
模板的通用并不是万能的
2.1函数模板语法
函数模板作用
建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。
语法：
template<typename T>
函数声明或定义
template --- 声明创建模板
typename --- 表明其后面的符号是一种数据类型，可以用class代替
T --- 通用的数据类型，名称可以替换，通常为大写字母
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
template<typename T>
void mySwap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
int main(int argc,char**argv) {
int a = 10;
int b = 20;
cout << "交换前： " << "a= " << a << " b= " << b << endl;
//自动类型推导（编译器自己猜）
mySwap(a, b);
cout << "交换后： " << "a= " << a << " b= " << b << endl;
double c = 1.1;
double d = 2.2;
cout << "交换前： " << "c= " << c << " d= " << d << endl;
//显示类型推导（告诉编译器）
mySwap<double>(c, d);
cout << "交换后： " << "c= " << c << " d= " << d << endl;
system("pause");
return 0;
}
函数模板关键字template
目的是为了提高复用性，将类型参数化
2.2函数模板注意事项
自动类型推导，必须推导出一致的数据类型T才可以使用
模板必须要确定出T的数据类型，才可以使用
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
template<typename T>
void mySwap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
//模板必须要确定出T的数据类型才可以使用
template<typename T>
void func() {
cout << "函数调用" << endl;
}
void test01() {
func(); //报错 你把这个函数变成了函数模板，必须指定T的数据类型
func<int>(); //正确 其实你没用到int，但无所谓，你必须得指定一个数据类型
}
int main(int argc,char**argv) {
int a = 10;
int b = 20;
char c = 'c';
test01();
//自动类型推导必须推导出一致的数据类型T才可以使用
//mySwap(a,c); 报错
system("pause");
return 0;
}
2.3函数模板案例
利用函数模板封装一个排序的函数，可以对不同数据类型数组排序
规则从大到小，算法为选择排序
分别利用char数组和int数组测试?
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
//交换函数模板
template<typename T>
void mySwap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
//打印函数模板
template<typename T>
void printArray(T arr[], int len) {
for (int i = 0; i < len; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
//选择排序算法
template<typename T>
void mySort(T arr[], int len) {
for (int i = 0; i < len; i++) {
int max;
for (int j = i + 1; j < len; j++) {
max = i;
if (arr[max] < arr[j]) {
max = j;
}
mySwap(arr[max], arr[i]);
}
}
}
//char数组测试
void test01() {
char charArr[] = "badcfe";
int num = sizeof(charArr) / sizeof(char);
mySort(charArr, num);
printArray(charArr, num);
}
//int数组测试
void test02() {
int intArr[] = {4,1,3,6,9,5,7,2};
int num = sizeof(intArr) / sizeof(int);
mySort(intArr, num);
printArray(intArr, num);
}
int main(int argc,char**argv) {
test01();
test02();
system("pause");
return 0;
}
2.4普通函数与函数模板区别
普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显式指定类型的方式，可以发生隐式类型转换
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
//普通函数调用可以发生隐式类型转换
//函数模板 用自动类型推导 不可以发生隐式类型转换
//函数模板 用显示指定类型 则可以发生隐式类型转换
//普通函数
int myAdd(int a, int b) {
return a + b;
}
//函数模板
template<class T>
T myAdd01(T a, T b) {
return a + b;
}
void test01() {
int a = 10;
int b = 20;
char c = 'c';
cout << myAdd(a, c) << endl; //输出109，因为发生了隐式类型转换，c在ASCⅡ码里是99
cout << myAdd01(a, c) << endl; //报错
cout << myAdd01<int>(a, c) << endl; //输出109
}
int main(int argc,char**argv) {
test01();
system("pause");
return 0;
}
建议使用显示指定类型的方式调用函数模板
2.5 普通函数与函数模板的调用规则
1.如果函数模板和普通函数都可以实现，优先调用普通函数
2.可以通过空模板参数列表强制调用函数模板
3.函数模板也可以发生重载
4.如果函数模板可以产生更好的的匹配，优先调用函数模板
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
//1.如果函数模板和普通函数都可以实现，优先调用普通函数
//2.可以通过空模板参数列表强制调用函数模板
//3.函数模板也可以发生重载
//4.如果函数模板可以产生更好的的匹配，优先调用函数模板
//普通函数
void myPrint(int a, int b) {
cout << "调用的普通函数" << endl;
}
//函数模板
template<class T>
void myPrint(T a, T b) { //函数重载 允许同时存在 （注意这行是void不是T)
cout << "调用的模板" << endl;
}
template<class T>
void myPrint(T a, T b,T c) {
cout << "调用重载的模板" << endl;
}
void test01() {
int a = 10;
int b = 20;
//myPrint(a, b); 会优先调用普通函数，如果把普通函数里的语句删了将它变成声明，编译会报错
//myPrint<>(a, b); 空模板强制调用函数模板
//myPrint(a, b, 100); 很明显只能调用重载的34行函数
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2); //不会报错，因为普通函数也可以隐式类型转换 把char变为int，但明显用函数模板更好，所以会调用函数模板
}
int main(int argc,char**argv) {
test01();
system("pause");
return 0;
}
2.6模板的局限性
template<class T>
void f(T a, T b) {
a = b;
}
如果传入的a和b是数组，则无法实现
如果比较操作传入的是Person这种自定义数据类型，也无法正常运行
c++为此提供了模板的重载
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
class Person {
public:
Person(string name, int age) {
m_Age = age;
m_Name = name;
}
int m_Age;
string m_Name;
};
//对比两个数据是否相等
template<class T>
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;
}
else {
return false;
}
}
void test01() {
Person p1("Tom", 10);
Person p2("Tom", 10);
bool ret = myCompare(p1, p2);
if (ret) {
cout << "p1==p2" << endl;
}
else {
cout << "p1!=p2" << endl;
}
}
int main(int argc,char**argv) {
test01();
system("pause");
return 0;
}
总结：学习模板不是为了写模板，而是为了在STL中能够运用系统提供的模板
3.1类模板语法
类模板作用：建立一个通用类，类中的成员 数据类型可以不具体指定，用一个虚拟的类型来代表
语法：
template<class T>
类
示例：
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
//类模板
template<class NameType,class AgeType>
class Person {
public:
Person(NameType name, AgeType age) {
this->m_Age = age;
this->m_Name = name;
}
void show() {
cout << "姓名是： " << this->m_Name << " 年龄是： " << this->m_Age << endl;
}
AgeType m_Age;
NameType m_Name;
};
void test01() {
Person<string, int> p1("孙悟空", 99);
p1.show();
}
int main(int argc,char**argv) {
test01();
system("pause");
return 0;
}
3.2类模板与函数模板区别
1.类模板没有自动类型推导的使用方式
2.类模板在模板参数列表中可以有默认参数?
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
//类模板与函数模板区别
template<class NameType,class AgeType=int> //指定了默认参数，年龄就是int
class Person {
public:
Person(NameType name, AgeType age) {
this->m_Age = age;
this->m_Name = name;
}
void show() {
cout << "姓名是： " << this->m_Name << " 年龄是： " << this->m_Age << endl;
}
AgeType m_Age;
NameType m_Name;
};
//1.类模板没有自动类型推导使用方式
void test01() {
// Person p1("孙悟空", 99); 报错
Person<string,int> p1("孙悟空", 99); //正确 只能用显示指定类型
p1.show();
}
//2.类模板在模板参数列表中可以有默认参数
void test02() {
Person<string> p2("猪八戒",50); //指定了int，这里就不需要加int了，当然，37行里的int也可以删掉
p2.show();
}
int main(int argc,char**argv) {
test01();
test02();
system("pause");
return 0;
}
3.3类模板中成员函数创建时机
普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
class Person1 {
public:
void showPerson1(){
cout << "Person1 show" << endl;
}
};
class Person2 {
public:
void showPerson2() {
cout << "Person2 show" << endl;
}
};
template <class T>
class MyClass {
public:
T obj;
//类模板中的成员函数 不是一开始就创建的，而是模板调用时再生成
void func1() {
obj.showPerson1();
}
void func2() {
obj.showPerson2();
}
};
void test01() {
MyClass<Person1>m;
m.func1();
//m.func2(); 调用会出错 说明函数调用时才会去创建成员函数
}
int main(int argc,char**argv) {
test01();
system("pause");
return 0;
}
3.4.类模板对象做函数参数
类模板实例化出的对象，向函数传参的方式有三种
1.指定传入的类型? ---直接显示对象的数据类型
2.参数模板化? ? ? ? ?---将对象中的参数变为模板进行传递
3.整个类模板化? ? ?---将这个对象类型 模板化进行传递
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
template <class T1,class T2>
class Person {
public:
Person(T1 name, T2 age) {
this->m_Name = name;
this->m_Age = age;
}
void showPerson() {
cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//1.指定传入类型
void printPerson1(Person<string, int>&p) {
p.showPerson();
}
void test01() {
Person<string,int>p("孙悟空", 100);
printPerson1(p);
}
//2.参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2>&p) {
p.showPerson();
}
void test02() {
Person<string, int>p("猪八戒",90);
printPerson2(p);
}
//3.整个类模板化
template<class T>
void printPerson3(T &p) {
p.showPerson();
}
void test03() {
Person<string, int>p("唐僧", 30);
printPerson3(p);
}
int main(int argc,char**argv) {
test01();
test02();
test03();
system("pause");
return 0;
}
建议使用第一种：指定传入的类型
3.5类模板与继承
类模板碰见继承时，需要注意以下几点
当子类继承的父类是一个类模板时，子类在声明的时候，需要指出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需要变为类模板
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
template <class T>
class Base {
public:
T m;
};
//class Son : public Base 报错，必须要知道父类中的T类型 才能继承给子类
class Son : public Base<int> {
public:
};
void test01() {
Son s1; //正常 不会报错
}
//如果像灵活指定父类中的T类型，子类也需要变类模板
template<class T1,class T2> //你选择定义了两个T，T1用来定义，T2是从父类那里继承
class Son2 :public Base<T2> {
public:
T1 obj;
};
void test02() {
Son2<int, char> S2; //int指向T1，obj明确了是int类型，char指向T2，T2又继承自父类，即m的类型为char；
}
int main(int argc,char**argv) {
test01();
test02();
system("pause");
return 0;
}
总结：如果父类是类模板，子类需要指出父类中T的数据类型
3.6 类模板成员函数类外实现
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
template <class T1,class T2>
class Person {
public:
Person(T1 name, T2 age);
//{
// /*this->m_Name = name;
// this->m_Age = age;*/
//}
void showPerson();
//{
// /*cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;*/
//}
T1 m_Name;
T2 m_Age;
};
//正常情况下是上面那种代码，但我们要类外实现，所以将内容先注释掉,变成定义
//构造函数类外实现
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
this->m_Name = name;
this->m_Age = age;
}
//成员函数类外实现
template<class T1, class T2>
void Person<T1 ,T2>:: showPerson() {
cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}
void test01() {
Person<string, int> P("Tom", 20);
P.showPerson();
}
int main(int argc,char**argv) {
test01();
system("pause");
return 0;
}
总结：类模板中成员函数类外实现，需要加上模板参数列表
3.7类模板分文件编写
原因：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
1.直接包含.cpp源文件
2.将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制
第一种方法一般不用，用第二种：
将上述代码test01以上的全部添加在新建的头文件（命名为person.hpp）中，（当然还得添加#pragma once），然后剩下的.cpp文件头文件中加上”person.hpp“即可
3.8 类模板与友元
全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在
#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>
#include<fstream>
#include<string>
//通过全局函数 打印Person信息
//提前让编译器知道Person类的存在
template<class T1, class T2>
class Person;
//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2>&p) {
cout << "类外实现--姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}
template <class T1,class T2>
class Person {
//全局函数 类内实现
friend void printPerson(Person<T1,T2> &p) {
cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}
//全局函数 类外实现
//加空模板参数列表
//如果全局函数 是类外实现 需要让编译器提前知道这个函数的存在
friend void printPerson2<>(Person<T1, 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", 20);
printPerson2(p);
}
int main(int argc,char**argv) {
//test01();
test02();
system("pause");
return 0;
}
总结：建议类内实现，类外实现过于复杂
3.9类模板案例
实现一个通用的数组类 要求：
可以对内置数据类型以及自定义数据类型的数据进行存储
将数组中的数据存储到堆区
构造函数中可以传入数组的容量
提供对应的拷贝构造函数以及operator=防止浅拷贝问题
提供尾插法和尾删法对数组中的数据进行增加和删除
可以通过下标的方式访问数组中的元素
可以获取数组中当前元素个数和数组的容量
头文件 MyArray.hpp
//自己通用的数组类
#pragma once
#include<iostream>
using namespace std;
template<class T>
class MyArray {
public:
//有参构造 参数 容量
MyArray(int capacity) {
//cout << "MyArray有参构造调用" << endl;
this->m_Capacity = capacity;
this->m_Size = 0;
this->pAddress = new T[this->m_Capacity];
}
//拷贝构造
MyArray(const MyArray & arr) {
//cout << "MyArray拷贝构造调用" << endl;
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
//深拷贝
this->pAddress = new T[arr.m_Capacity];
//将arr中的数据都拷贝过来
for (int i = 0; i < this->m_Size; i++) {
this->pAddress[i] = arr.pAddress[i];
}
}
//operator=防止浅拷贝问题
MyArray& operator=(const MyArray& arr) {
//cout << "MyArray的operator=调用" << endl;
//先判断原来堆区是否有数据 如果有先释放
if (this->pAddress != NULL) {
delete[] this->pAddress;
this->pAddress = NULL;
this->m_Capacity = 0;
this->m_Size = 0;
}
//深拷贝
this->m_Capacity = arr.m_capacity;
this->m_Size = arr.m_Size;
this->pAddress = new T[arr.m_Capacity];
for (int i = 0; i < this->m_Size; i++) {
this->pAddress[i] = arr.pAddress[i];
}
return *this;
}
//尾插法
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--;
}
//通过下标方式访问数组中的元素 arr[0]=00
T& operator[](int index) {
return this->pAddress[index];
}
//返回数组容量
int getCapacity() {
return this->m_Capacity;
}
//返回数组大小
int getSize() {
return this->m_Size;
}
//析构函数
~MyArray() {
if (this->pAddress != NULL) {
//cout << "MyArray析构函数调用" << endl;
delete[] this->pAddress;
this->pAddress = NULL;
}
}
private:
T* pAddress; //指针指向堆区开辟的真实数组
int m_Capacity; //数组容量
int m_Size; //数组大小
};
源文件 数组类封装.cpp
#include<iostream>
using namespace std;
#include"MyArray.hpp"
#include<string>
void printArray(MyArray<int>&arr) {
for (int i = 0; i < arr.getSize(); i++) {
cout << arr[i] << endl;
}
}
void test01() {
MyArray<int>arr1(5);
for (int i = 0; i < 5; i++) {
//利用尾插法向数组中插入数据
arr1.Push_Back(i);
}
cout << "arr1的打印输出为: " << endl;
printArray(arr1);
cout << "arr1的容量为:" << arr1.getCapacity() << endl;
cout << "arr1的容量为:" << arr1.getSize() << endl;
MyArray<int>arr2(arr1);
cout << "arr2的打印输出为: " << endl;
printArray(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) {
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
void printPersonArray(MyArray<Person>& arr) {
for (int i = 0; i < arr.getSize(); i++) {
cout << "姓名：" << arr[i].m_Name << " 年龄： " << arr[i].m_Age << endl;
}
}
void test02() {
MyArray<Person> arr(10);
Person p1("孙悟空", 999);
Person p2("韩信", 59);
Person p3("妲己", 69);
Person p4("猪八戒", 79);
//将数据插入到数组中
arr.Push_Back(p1);
arr.Push_Back(p2);
arr.Push_Back(p3);
arr.Push_Back(p4);
//打印数组
printPersonArray(arr);
//输出容量
cout << "arr容量为：" << arr.getCapacity() << endl;
//输出大小
cout << "arr大小为： " << arr.getSize() << endl;
}
int main() {
//test01();
test02();
}
加油吧
|