1.函数模板
#include <iostream>
using namespace std;
//int类型的数据交换
void testInt(int& a,int& b)
{
int tem = a;
a = b;
b = tem;
}
//double类型的数据交换
void testDouble(double& a, double& b)
{
double tem = a;
a = b;
b = tem;
}
//模板技术 类型参数化 编写代码可以忽略类型
//模板函数的写法:
template<typename T>//这里可以有T1,T2...
void testTemplate(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
int main()
{
//有两种写法
//
//
//1.自动类型推导
int a = 10, b = 20;
cout << "a = " << a << "b= " << b << endl;
testTemplate(a,b);
//2.显示的指定类型
testTemplate<int>(a,b);
cout << "a = " << a << "b= " << b << endl;
return 0;
}
1.1函数模板和普通函数区别
1.函数模板不允许自动类型转换
2.普通函数能够进行类型转换
1.2函数模板和普通函数一起调用的规则
1.函数模板可以像普通函数那样被重载
2.C++优先考虑普通函数
int MyAdd(int a,int b){return a +b}
template<typename T>
int MyAdd(T a,T b){return a +b}
优先调用普通函数
3.如果函数模板可以产生一个更好的匹配,那么选择模板
4.可以通过空模板实参列表的语法限定编译器只能通过模板匹配
MyAdd<int>(a,b);
1.3 C++编译器模板机制
1.编译器(编译原理)工作流程
2.函数模板实现原理
函数模板通过具体的使用情况生成模板函数,编译器在编译的时候会自动帮我们生成模板函数
编译器或有两次编译,函数模板声明的时候编译一次,程序中函数调用此情况会再次编译一次
2.类模板
1.实例
#include <iostream>
using namespace std;
template<class T>
class Person {
public:
Person(T id, T age) {
this->mage = age;
this->mid = id;
};
void Show() {
cout << "ID " << mid << "Age" << mage <<endl;
}
public:
T mid;
T mage;
};
void test() {
Person<int>p(10, 20);
p.Show();
}
int main()
{
test();
return 0;
}
2.模板类的案例:对char类型和int类型数组进行排序
#include <iostream>
using namespace std;
//打印函数
template<class T>
void printArray(T* arr, int len) {
for (int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
//排序
template<class T>
void mySort(T* arr, int len) {
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
//从大到小
if (arr[i] < arr[j])
{
T temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
void test(int* arr,int len) {
mySort(arr, len);
}
int main()
{
//定义一个数组
int arr[] = { 2,6,1,8,9,2 };
//数组长度
int length = sizeof(arr) / sizeof(int);
printArray(arr, length);
//进行排序
mySort(arr,length);
printArray(arr, length);
char arrChar[] = { 'a','b','e','c','d'};
//数组长度
int len = sizeof(arrChar) / sizeof(char);
printArray(arrChar,len);
//进行排序
mySort(arrChar, len);
printArray(arrChar, len);
return 0;
}
3.类模板派生普通类
#include <iostream>
using namespace std;
template<class T>
class Person {
public:
Person(T id, T age) {
this->mage = age;
this->mid = id;
};
void Show() {
cout << "ID " << mid << "Age" << mage <<endl;
}
public:
T mid;
T mage;
};
//要指定分配空间
class sonPerson : public Person<int>{
}
//这种写法直接加T就可以
template<class T>
class sonPerson : public Person<T>{
}
类模板在类内实现,声明和实现放在一起
类模板在类外实现,实现放在外面
#include <iostream>
using namespace std;
template<class T>
class Person {
public:
//重载左移操作符
template<class T>
friend ostream& operator<<(ostream& os,Person<T>& p)
Person(T id, T age);
void Show() ;
public:
T mid;
T mage;
};
template<class T>
Person<T>::Perdon(T age,T id){
this->mid = id;
this->mage = age;
}
template<class T>
void Person<T>::Show(){
}
//重载左移运算操作符
template<class T>
ostream& operator<<(ostream& os,Person<T>& p){
os<<"Age"<<p,mage<<"ID"<<p.mid<<endl;
}
}