文章目录
1 函数模板基本使用
1.1 template <class/typename T> 告诉编译器紧跟的代码里出现T不要报错
1.2 mySwap(T &a, T &b)类型也需要传入,类型参数化
1.3 mySwap(a, b) 自动类型推导 按照ab的类型 来替换T
1.4 mySwap<int>(a,b) 显示指定类型
1.5 实例
#include<iostream>
using namespace std;
// 类型参数化 泛型编程 -- 模板技术
template <class T> // 告诉编译器 下面如果出现了T不要报错,T是一个通用的类型
// template <typename T> 等价于 template <class T>
void mySwap(T &a, T&b)
{
T temp = a;
a = b;
b = temp;
}
void test()
{
int a = 10;
int b = 20;
// 自动类型推导,必须有参数类型才可以推导
mySwap(a, b);
// 显示指定类型
mySwap<int>(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
double c = 1.1;
double d = 1.2;
mySwap(c, d);
cout << "c = " << c << endl;
}
int main()
{
test();
return EXIT_SUCCESS;
}
输出:
a = 10
b = 20
c = 1.2
2 函数模板和普通函数的区别及调用规则
2.1 区别
普通函数可以进行隐式类型转换 模板不可以
2.2 调用规则
(1)C++编译器优先考虑普通函数
(2)可以通过空模板实参列表的语法限定编译器只能通过模板匹配
(3)函数模板可以像普通函数那样可以被重载
(4)如果函数模板可以产生一个更好的匹配,那么选择模板
2.3 实例
#include<iostream>
using namespace std;
template <class T>
void myPrint(T a, T b)
{
cout << "模板函数调用" << endl;
}
template <class T>
void myPrint(T a, T b, T c)
{
cout << "模板调用的myPrint" << endl;
}
void myPrint(int a, int b)
{
cout << "普通函数调用" << endl;
}
void test()
{
int a = 10;
int b = 20;
int c = 30;
// 1 如果出现重载,优先使用普通函数调用,如果没有实现,出现错误
myPrint(a, b);
// 2 如果想强制调用模板,那么可以使用空参数列表
myPrint<>(a, b);
// 3 函数模块可以发生重载
myPrint(a, b, c);
// 4 如果函数模板可以产生更好的匹配,那么优先调用函数模板
char c1 = 'c';
char d = 'd';
myPrint(c1, d);
}
int main()
{
test();
return EXIT_SUCCESS;
}
输出:
普通函数调用
模板函数调用
模板调用的myPrint
模板函数调用
2.4 模板的机制
(1)模板不是万能的,不能通用所有的数据类型
(2)模板不能直接调用,生成后的模板函数才可以调用
(3)二次编译,第一次对模板进行编译,第二次对替换T类型后的代码进行编译
比如说下面:
// 函数模板
template <class T>
void myPrint(T a, T b, T c)
{
cout << "模板调用的myPrint" << endl;
}
// 如果这时传递进来int类型数据,通过函数模板生成如下,也就是说通过模板生成的函数,叫模板函数
//void myPrint(int a, int b, int c)
//{...}
3 模板局限性
3.1 模板不能解决所有的类型
3.2 如果出现不能解决的类型,可以通过第三代具体化来解决问题
3.3 template<> 换回值 函数名<具体类型> (参数)
#include<iostream>
using namespace std;
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
template <class T>
bool myCompare(T &a, T &b)
{
if (a == b)
{
return true;
}
return false;
}
// 通过具体化自定义类型,解决上诉问题
// 如果具体化能够优先匹配,那么就选择具体化
// 语法 template<>换回值 函数名<具体类型>(参数)
template<>
bool myCompare<Person>(Person &a, Person &b)
{
if(a.m_Age == b.m_Age )
{
return true;
}
return false;
}
void test()
{
int a = 10;
int b = 20;
int ret = myCompare(a, b);
cout << "ret = " << ret << endl;
Person p1("Tom", 10);
Person p2("Jerry", 20);
int ret2 = myCompare(p1, p2);
cout << "ret = " << ret2 << endl;
}
int main()
{
test();
return EXIT_SUCCESS;
}
输出:
ret = 0
ret = 0
4 类模板
4.1 写法template<T…> 紧跟着是类
4.2 与函数模板区别,可以有默认类型参数
4.3 函数模板可以进行自动类型推导,而类模板不可以
4.4 实例
#include<iostream>
#include<string>
using namespace std;
// 类模板
template <class NameType,class AgeType=int> // 类模板可以有默认类型
class Person
{
public:
Person(NameType name, AgeType age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
void test()
{
// 自动类型推导,类模板不支持
// Person p("孙悟空",100);
// 显示指定类型
Person<string, int>p("孙悟空", 100);
p.showPerson();
}
int main()
{
test();
return EXIT_SUCCESS;
}
输出:
姓名:孙悟空年龄:100
5 类模板做函数参数
5.1 三种方式
(1)显示指定类型
(2)参数模板化
(3)整体模板化
5.2 查看类型的名称
typeid(类型).name()
5.3 实例
#include<iostream>
#include<string>
using namespace std;
template <class NameType,class AgeType=int>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "姓名:" << this->m_Name << "年龄" << this->m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
// 1 指定传入类型
void doWork(Person<string, int>&p)
{
p.showPerson();
}
void test()
{
Person<string, int>p("MT", 10);
doWork(p);
}
// 2 参数模板化
template<class T1,class T2>
void doWork2(Person<T1, T2>&P)
{
// 如何查看类型
cout << typeid(T1).name() << endl;
P.showPerson();
}
void test02()
{
Person<string, int> p("小王", 18);
doWork2(p);
}
// 3 整体模板化
template <class T>
void doWork3(T &p)
{
cout << typeid(T).name() << endl;
p.showPerson();
}
void test03()
{
Person<string, int> p("小张", 19);
doWork3(p);
}
int main()
{
test();
test02();
test03();
return EXIT_SUCCESS;
}
输出:
姓名:MT年龄10
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
姓名:小王年龄18
class Person<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>
姓名:小张年龄19
6 类模板碰到继承的问题
6.1 基类如果是模板类,必须让子类告诉编译器 基类中的T到底是什么类型
6.2 如果不告诉,那么无法分配内存,编译不过
6.3 利用参数列表class Child:public Base告诉基类中T是什么类型
6.4 实例
#include<iostream>
using namespace std;
template <class T>
class Base
{
public:
T m_A;
};
// child继承Base必须告诉base中的T的类型,否则T无法分配内存
class Child :public Base<int>
{
};
// child2也是模板类
template<class T1,class T2>
class Child2 :public Base<T2>
{
public:
Child2()
{
cout << typeid(T1).name() << endl;
cout << typeid(T2).name() << endl;
}
T1 m_B;
};
void test()
{
Child2<int, double>child;
}
int main()
{
test();
return EXIT_SUCCESS;
}
输出:
int
double
7 类模板的类外成员函数实现
#include<iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPerson();
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 test()
{
Person <string,int>p1("MT", 10);
p1.showPerson();
}
int main()
{
test();
return EXIT_SUCCESS;
}
输出:
姓名:MT年龄:10
8 类模板的分文件编写问题以及解决
8.1 .h .cpp分别写声明和实现
8.2 但是由于 类模板的成员函数运行阶段才去创建,导致包含.h头文件,不会创建函数的实现,就无法外部命令
8.3 解决方案 包含.cpp文件(不推荐)
8.4 不要进行分文件编写,写到同一个文件中,进行声明和实现,后缀名改为.hpp,这是约定俗成。
8.5 实例
下面演示.h.cpp分别写声明和实现
主文件:
#include "Person.h"
int main()
{
Person<string, int>p("小王",10);
p.showPerson();
return EXIT_SUCCESS;
}
Person.h声明文件:
#pragma once
#include<iostream>
#include<string>
using namespace std;
template <class T1,class T2>
class Person
{
public:
Person(T1 name,T2 age);
void showPerson();
T1 m_Name;
T2 m_Age;
};
Person.cpp实现文件:
#include "Person.h"
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_Age = age;
this->m_Name = name;
}
template<class T1,class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}
这样看是没有错误,其实是编译不通过的。
修改方案一(不推荐):
将主文件中包含的.h文件换成.cpp文件。因为在.cpp文件中有包含了.h文件还有模板成员函数的实现。
修改方案二(推荐):
将主文件中的.h文件改为.hpp文件。其实就是将原来的实现的文件和声明放在一个文件中,改名为.hpp文件。
如下:
#pragma once
#include<iostream>
#include<string>
using namespace std;
template <class T1,class T2>
class Person
{
public:
Person(T1 name,T2 age);
void showPerson();
T1 m_Name;
T2 m_Age;
};
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_Age = age;
this->m_Name = name;
}
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}
9 类模板碰到友元函数
9.1 友元函数类内实现
9.2 friend void printPerson(Person<T1,T2>&P)
9.3 实例
#include<iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person
{
// 友元函数类内实现
friend void printPerson(Person<string,int>&p)
{
cout << "姓名:" << p.m_Name << "年龄:" << p.m_Age <<endl;
}
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
void test()
{
Person<string, int> p("Tom", 10);
printPerson(p);
}
int main()
{
test();
return EXIT_SUCCESS;
}
输出:
姓名:Tom年龄:10
9.4 友元函数类外实现
friend void printPerson<>(Person<T1,T2>&P);没有<>普通函数声明 加上<>模板函数声明
让编译器看到函数并且看到这个Person类型
#include<iostream>
#include<string>
using namespace std;
// 让编译器提前看到printPerson声明
// 让编译器看到Person类的声明
template<class T1, class T2> class Person;
template<class T1,class T2> void printPerson(Person<T1, T2>&p);
template<class T1,class T2>
class Person
{
//friend void printPerson(Person<string, int>&p); // 普通函数 声明
// 利用空参数列表 告诉编译器 模板函数声明
friend void printPerson<>(Person<string, int>&p);
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
// 模板函数实现
template<class T1,class T2>
void printPerson(Person<T1, T2>&p)
{
cout << "姓名:" << p.m_Name << "年龄:" << p.m_Age << endl;
}
void test()
{
Person<string, int> p("Tom", 10);
printPerson(p);
}
int main()
{
test();
return EXIT_SUCCESS;
}
10 类模板应用
MyArray.hpp
#pragma once
#include<iostream>
#include<string>
using namespace std;
template<class T>
class MyArray
{
public:
explicit MyArray(int capacity) // 防止隐式类型转换 防止MyArray arr = 10;写法
{
this->m_Capacity = capacity;
this->m_Size = 0;
this->pAddress = new T[this->m_Capacity];
}
MyArray(const MyArray &array)
{
this->m_Capacity = array.m_Capacity;
this->m_Size = array.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < m_Size; i++)
{
this->pAddress[i] = array[i];
}
}
~MyArray()
{
if (this->pAddress != NULL)
{
delete[] this->pAddress;
this->pAddress = NULL;
}
}
// 赋值操作符重载
MyArray &operator=(MyArray arr)
{
// 先判断原始数据,有就清空
if (this->pAddress != NULL)
{
delete[] this->pAddress;
this->pAddress = NULL;
}
this->m_Capacity = array.m_Capacity;
this->m_Size = array.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < m_Size; i++)
{
this->pAddress[i] = array[i];
}
}
//[]重载
T & operator[](int index)
{
return this->pAddress[index];
}
// 尾插法
void push_Back(T val)
{
this->pAddress[this->m_Size] = val;
this->m_Size++;
}
// 获取大小
int getSize()
{
return m_Size;
}
// 获取容量
int getCapacity()
{
return this->m_Capacity;
}
private:
T *pAddress; // 指向堆区指针
int m_Capacity;
int m_Size;
};
主文件
#include"MyArray.hpp"
// 输出int类型数组
void printInArray(MyArray<int>&array)
{
for (int i = 0; i < array.getSize(); i++)
{
cout << array[i] << endl;
}
}
class Person
{
public:
Person()
{
cout << "默认构造" << endl;
}
Person(string name, int age)
{
this->m_Age = age;
this->m_Name = name;
}
string m_Name;
int m_Age;
};
// 输出Person类型数组
void printPersonArray(MyArray<Person>& array)
{
for (int i = 0; i < array.getSize(); i++)
{
cout << "姓名:" << array[i].m_Name << " 年龄:" << array[i].m_Age << endl;
}
}
int main()
{
MyArray <int>arr(10);
for (int i = 0; i < 10; i++)
{
arr.push_Back(i + 100);
}
printInArray(arr);
Person p1("A", 10);
Person p2("B", 12);
Person p3("C", 14);
Person p4("D", 15);
cout << "****************" << endl;
// 在创建MyArray时,调用Person类的构造函数
MyArray<Person>arr2(10);
cout << "*******" << endl;
arr2.push_Back(p1);
arr2.push_Back(p2);
arr2.push_Back(p3);
arr2.push_Back(p4);
printPersonArray(arr2);
return EXIT_SUCCESS;
}
输出:
100
101
102
103
104
105
106
107
108
109
****************
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
*******
姓名:A 年龄:10
姓名:B 年龄:12
姓名:C 年龄:14
姓名:D 年龄:15