c++提供两种模板机制:函数模板和类模板
函数模板：具有自动推导类型
类模板：必须显示指定类型
函数模板：实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板,虚拟类型用关键字template<class T>或者template<typename T>来定义
代码如下：
#include<iostream>
using namespace std;
//函数模板
template<class T>//template<typename T>这两个声明模板是一样的
void myswap(T& a, T& b)
{
T tmp = a;
a = b;
b = tmp;
}
void testint()
{
int a = 10;
int b = 20;
myswap(a, b);
cout << "a=" << a<<"-----" << "b=" << b << endl;
}
void testchar()
{
char a = 'a';
char b = 'b';
myswap(a, b); //这里看出函数模板具有自动推导，传int就推导int，传char就推导为char
cout << "a=" << a <<"-----"<< "b=" << b << endl;
}
int main()
{
testint();
testchar();
system("pause");
}结果如下：
函数模板和普通函数的区别：
函数模板不允许自动类型转化
普通函数能够自动进行类型转化
代码如下
#include<iostream>
using namespace std;
template<class Plus>
Plus myplus(Plus a,Plus b)
{
cout << "调用函数模板" << endl;
Plus c = a + b;
return c;
}
int myplus(int a, int b)
{
cout << "调用普通函数" << endl;
int c = a + b;
return c;
}
void test()
{
int a = 10;
int b = 20;
char c = 'c';
char d = 'd';
cout << myplus(a, c) << endl;///普通函数可以进行自动类型转换
//cout << myplus<>(a, c) << endl;函数模板不能自动进行类型转换,必须严格匹配类型
}函数模板和普通函数在一起调用规则
1 函数模板可以像普通函数那样可以被重载
2 c++编译器优先考虑普通函数
3 如果函数模板可以产生一个更好的匹配，那么选择模板
4 可以通过空模板实参列表的语法限定编译器只能通过模板匹配
#include<iostream>
using namespace std;
template<class Plus>
Plus myplus(Plus a,Plus b)
{
cout << "调用函数模板" << endl;
Plus c = a + b;
return c;
}
int myplus(int a, int b)
{
cout << "调用普通函数" << endl;
int c = a + b;
return c;
}
void test()
{
int a = 10;
int b = 20;
char c = 'A';
char d = 'B';
cout << myplus(a, b) << endl;//如果函数模板和普通函数都匹配,c++编译器优先调用普通函数
cout << myplus<>(a, b) << endl;//如果指定要调用函数模板,可以通过空模板实参列表的语法限定编译器只能通过模板匹配
cout << myplus(c, d) << endl;//如果函数模板可以产生一个更好的匹配，那么选择模板
}
//函数模板重载
template<class Plus>
Plus myplus(Plus a, Plus b, Plus c)
{
cout << "调用重载的函数模板" << endl;
Plus d = a + b + c;
return d;
}
void test2()
{
int a = 10;
int b = 20;
int c = 30;
cout << myplus(a, b, c) << endl;
}
int main()
{
test();
test2();
system("pause");
}
编译器会对函数模板进行 两次编译 ，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译
类模板
类模板和函数模板类似，有时多个类有相同的功能，仅仅是数据类型不同就可以使用类模板了
类模板定义代码
#include<iostream>
#include<string>
using namespace std;
template<class NAME, class STR>
class person
{
public:
person(NAME name, STR age)
{
this->name = name;
this->age = age;
}
void Print()
{
cout << "name=" << this->name <<"----"<< "age=" << this->age << endl;
}
public:
NAME name;
STR age;
};
int main()
{
person<string, int> per("peter", 18);//类模板只能显示指定类型，不能做类型推导
per.Print();
system("pause");
}
#include<iostream>
#include<string>
using namespace std;
template<class NAME, class STR>
class person
{
public:
person(NAME name, STR age)
{
this->name = name;
this->age = age;
}
void Print()
{
cout << "name=" << this->name <<"----"<< "age=" << this->age << endl;
}
public:
NAME name;
STR age;
};
void Dofun(person<string,int>& p)
{
p.age += 10;
p.name += "make";
p.Print();
}
template<class T>
void Dof(T& p)//类模板做函数模板参数
{
cout << "name=" << p.name << "----" << "age=" << p.age << endl;
}
int main()
{
person<string, int> per("peter", 18);
//Dofun(per);//类模板做函数参数
Dof(per);//类模板做函数模板参数
system("pause");
}
#include<iostream>
#include<string>
using namespace std;
template<class T>
class parent
{
public:
parent(T age)
{
this->age = age;
}
public:
T age;
};
//子类实例化的时候需要具体化的父类，子类需要知道父类的具体类型是什么样的
//这样c++编译器才能知道给子类分配多少内存
class son :public parent<int>
{
public:
son(int Sage,int age) :parent<int>(age)
{
this->Sage = Sage;
}
void Print()
{
cout << "Son"<<Sage << endl;
cout << "继承的age" << age << endl;
}
public:
int Sage;
};
int main()
{
son S(10,20);
S.Print();
system("pause");
}类模板派生类模板
#include<iostream>
#include<string>
using namespace std;
template<class T2>
class parent
{
public:
parent(T2 age)
{
this->age = age;
}
public:
T2 age;
};
template<class T>
class son:public parent<T>//用子类指定父类类型
{
public:
son(T Sage, T age) :parent<T>(age)
{
this->Sage = Sage;
}
void Print()
{
cout << "son" << Sage << endl;
cout << "继承的age"<<age << endl;
}
public:
T Sage;
};
int main()
{
son<int> S(10,20);
S.Print();
system("pause");
}
#include<iostream>
#include<string>
using namespace std;
template<class T2>
class parent
{
template<class T2>friend ostream& operator<<(ostream& out, parent<T2>& p);//声明一个友元函数模板
friend ostream& operator<<(ostream& out, parent<T2>& p);//这只是声明一个友元普通函数
public:
parent(T2 age);
void printparent(parent<T2>& p);
public:
T2 age;
};
ostream& operator<<(ostream& out, parent<int>& p)//类外普通函数实现
{
cout << "普通输出函数" << endl;
out << p.age << endl;
return out;
}
template<class T2>//类外重载函数模板实现
ostream& operator<<(ostream& out, parent<T2>& p)
{
cout << "函数模板输出" << endl;
out << p.age << endl;
return out;
}
template<class T2>
parent<T2>::parent(T2 age)
{
this->age = age;
}
template<class T2>
void parent<T2>::printparent(parent<T2>& p)
{
cout << p.age << endl;
}
//类内实现
void test()
{
parent<int> p(100);
cout << p << endl;
p.printparent(p);
}
int main()
{
test();
system("pause");
}
类模板注意点：类模板不能分文件编译
代码如下
test.h
#pragma once
template<class T>
class test
{
public:
test(T age);
void Printtest();
public:
T age;
};test.cpp
#include"test.h"
template<class T>
test<T>::test(T age)
{
this->age = age;
}
template<class T>
void test<T>::Printtest()
{
cout <<age << endl;
}
main.cpp
#include<iostream>
#include"test.h"
using namespace std;
void fun()
{
test<int> Test(100);
Test.Printtest();
}
int main()
{
fun();
system("pause");
return 0;
}包含test.h的话会出现链接错误。如图：
链接错误的原因：
因为类模板需要编译两次，
1. 首先对模板本身进行编译
2. 根据具体的使用情况，产生具体的模板类，然后对具体的模板类再进行第二次编译
C++编译规则为独立编译（一个文件一个文件编译）
包含头文件的话.h文件是不会编译的（声明只是预处理），.cpp文件只编译了一次（对模板本身进行编译），因为.cpp文件中没有调用.cpp中的模板类，没有产生第二次编译，模板类没有编译成功，所以在调用的时候链接不到，如果包含.cpp文件的话，main文件中把cpp文件编译一次（对模板本身进行编译），main文件中有调用模板类代码，产生了第二次编译，模板类编译成功，所以在调用的没有问题
如果想要包含.h文件让模板类编译成功的话，加上调用模板类代码的话可以产生第二次编译
.cpp改为如下代码运行就可以，但是一般没有这种写法，一般都是把模板类放在一个文件中，命令为.hpp，我这样写只是为了好理解模板类二次编译机制
#include"test.h"
template<class T>
test<T>::test(T age)
{
this->age = age;
}
template<class T>
void test<T>::Printtest()//加上调用模板类的代码产生第二次编译
{
cout <<age << endl;
}
void tt()
{
test<int> Te(10);
Te.Printtest();
}
扫一扫
3434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
