C++ 之函数模板
C++ 之函数模板
函数的参数类型不确定，这样就可以使用泛型。
// 类型参数化 C++中称之为泛型编程--模板技术
template <class T > // 告诉编译器，下面如果出现T不要报错，T是一个通用类型 这里将class替换成typename是一样的
void mySwap(T &a, T &b) {
T tmp = a;
a = b;
b = tmp;
}
自动类型推导，函数必须有参数才可以推导
// 2.显示调用
mySwap<int>(a, b); // 这里指定T是int类型
cout << "a=" << a << "," << "b=" << b << endl;
// 模板必须可以推导出T才可以使用 ，要么直接显示指定T
template < typename T>
void mySwap1() {
}
mySwap1 < double >(); // 如果不能根据参数列表推出来，就得显示指定类型
mySwap(a,b) // 根据a,b的类型自动推导T的类型。
mySwap<int> // (a,b)直接指定T的类型是int
2 使用函数模板实现通用数组排序
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
// 使用通用类型 对int char类型的数组进行排序
// 排序的规则 降序 使用选择排序
// 选择排序 每1趟中从待排序中选择一个最小的放在已排序的右端
template<class T>
void mySort(T arr[],int len) {
for (int i = 0; i < len-1;i++) {
int max = i;
for (int j = i + 1; j < len;j++) {
if (arr[max] < arr[j]) {
// 交换下标
max = j;
}
}
if (max != i) {
// 交换数据
swap(arr[max],arr[i]);
}
}
}
//输出数组元素的模板
template<class T>
void printArray(T arr[],int len) {
for (int i = 0; i < len;i++) {
cout << arr[i] << "\t";
}
}
void test01() {
char arr[] = "chengluofei";
//int len = sizeof(arr) / sizeof(char);
mySort(arr,strlen(arr));
printArray(arr, strlen(arr));
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
3 普通函数与函数模板的区别以及调用规则
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
//1. 普通函数与函数模板的区别
template<class T>
T myPlus(T a,T b) {
return a + b;
}
int myPlus2(int a , int b) {
return a + b;
}
void test01() {
int a = 10;
int b = 20;
cout << myPlus(a, b) << endl;
cout << myPlus2(a, b) << endl;
int c = 'c';
//cout << myPlus(a, c) << endl; // 类型推导出错
// char类型自动转int 类型 1. 普通的函数可以隐式类型转换 函数模板不可以进行隐式类型转换
cout << myPlus2(a, c) << endl;
}
// 2. 普通函数和函数模板的调用规则
template<class T>
void myPrint(T a, T b)
{
cout << "模板调用的myPrint" << endl;
}
template<class T>
void myPrint(T a, T b,T c)
{
cout << "模板调用的myPrint(a,b,c)" << endl;
}
void myPrint(int a, int b)
{
cout << "函数调用的myPrint" << endl;
}
void test02() {
int a = 10;
int b = 20;
// 1.如果出现重载（普通函数和函数模板函数名与参数个数相同），优先调用普通的函数 如果没有实现普通函数 会出错
//myPrint(10,20);
// 2.如果想强制调用函数模板 可以使用空菱形列表
myPrint<>(10,20);
// 3.函数模板可以发生重载
myPrint<>(10, 20,30);
// 4. 如果函数模板可以优先产生更好的匹配，那么优先调用函数模板
char c = 'c', d = 'd';
myPrint(c,d);
}
int main()
{
test01();
test02();
system("pause");
return EXIT_SUCCESS;
}
4 模板机制
函数模板通过不同的类型产生不同的函数。 编译器会对函数模板进行两次编译。在声明的地方对模板本身进行编译， 在调用的时候对参数进行替换后再进行一次编译。 STL 90%以上都是使用模板来做的。 通过模板产生的函数就叫模板函数。（为函数模板传值时，会重新生成对应类型的函数。） 模板并不是万能的，不能通用所有的数据类型。 模板不能直接调用， 生成后的模板函数才可以调用。 二次编译，第一次对模板进行编译，第二次对替换T类型后的函数进行编译。5 函数模板的局限性
template < class T > void f(T a, T b){ …. } 如果T是数组的话， 就没办法使得a = b语句成立。if(a > b) 语句也不能成立。#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <string>
#include <vector>
class Person {
public:
Person(string name, int age) :m_Name(name), m_Age(age) {
}
string m_Name;
int m_Age;
};
template <class T>
bool myCompare(T &a ,T &b) {
if (a == b) {
return true;
}
else return false;
}
// 通过具体化自定义数据类型，解决上述问题
// 如果具体化能够优先匹配，那么就选择具体化
// 语法 template <> 函数的声明和实现 <具体类型>
template<> bool myCompare<Person>(Person &a, Person &b) {
if (a.m_Age == b.m_Age) {
return true;
}
else return false;
}
void test01() {
int a = 10;
int b = 20;
bool res = myCompare(a,b);
cout << res << endl;
Person p1("Tom",3);
Person p2("Jerry",4);
bool res2 = myCompare(p1, p2); // 匹配具体化的模板
cout << res2 << endl;
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
6 类模板的基本使用
// 类模板
template <class NameType,class AgeType>
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;
};
类模板支持默认参数的（默认的类型），函数模板不可以。
template <class NameType = string ,class AgeType= int>
如果这里声明了默认的类型，那么创建对象的时候，不需要在菱形中显示声明类型。
Person <> p("张三",12);
7 成员函数的创建时机
class Person1 {
public:
void showPerson1() {
cout << "Person1的调用" << endl;
}
};
class Person2 {
public:
void showPerson1() {
cout << "Person2的调用" << endl;
}
};
template <class T>
class Myclass {
public:
T obj;
void func1() {
obj.showPerson1();
}
void func2() {
obj.showPerson2();
}
};
// 成员函数一开始不会创建出来， 而是在运行时才去创建
void test02() {
Myclass<Person1> mc;
mc.func1();
mc.func2(); // 报错
}
8 类模板做函数的参数
// 1. 指定传入类型
void doWark(Person<string,int> &p) { // 指定传入类型
p.showPerson();
}
// 2.参数模板化
template<class T1,class T2>
void doWork2(Person<T1,T2> & p) {
// 如何查看类型
cout << typeid(T1).name() << endl;
cout << typeid(T2).name() << endl;
p.showPerson();
}
void test01() {
Person<string,int> p("张三",23);
doWark(p);
doWork2(p);
}
// 3 整体类型化
template <class T>
void doWork3(T &p) {
p.showPerson();
}
void test02() {
Person<> p("孙悟空",500);
doWork3(p);
}
9 类模板遇到继承问题以及解决办法
子类继承父类（此时父类是模板类）的时候，需要指定父类模板中的类型，不然创建子类对象的时候， 会默认调用父类的构造器，导致父类无法给未知类型的变量分配内存。
template <class T>
class Base {
public:
T m_A;
};
// 让child继承 必须告知base中的T类型 ， 否则T无法分配内存
class Child : public Base<int> {
};
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 test01() {
Child2<int, double> child; // 由用户指定类型
}
10 类模板类外实现成员函数
template <class T1,class T2>
class Person {
public:
Person(T1 name, T2 age);
void showPerson();
private:
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;
}
11 类模板分文件编写以及问题解决
运行后，保持解决方法： 将Person.h 改为 Person.cpp
分文件写的话，因为是模板函数，代码一开始并不成成模板函数，因为确定不了类型。（C++是采用单元编译的。）
Person.h文件：
#pragma once
#include <iostream>
using namespace std;
#include <string>
template <class T1, class T2>
class Person {
public:
Person(T1 name, T2 age);
void showPerson();
private:
T1 m_name;
T2 m_age;
};
编译的时候， 编译检查Person.h文件，语法没有任何问题。 接着，检查Person.cpp文件。
#include "Person.h"
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::showPerson() {
cout << "姓名：" << this->m_name << ", 年龄:" << this->m_age << endl;
}
因为Person.cpp文件里面全是函数目版，编译器不生成模板函数，所以对应的Person.h中的具体实现也就实现不了。所以 在主函数里面，直接导入对应的cpp文件就可解决上面问题。
建议模板不要做分文件编写，一般写到一个类即可，全写到一个文件Person.h文件中，类内声明，类内实现。再把.h后缀改为.hpp.
main.cpp文件：
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include "Person.hpp"
void test() {
Person<string, int> p1("张三",12);
p1.showPerson();
}
int main() {
test();
system("pause");
return EXIT_SUCCESS;
}
.hpp文件一般是写模板用的。
12 友元函数碰到类模板-友元函数类内实现
如果函数和普通函数都能匹配到的话，优先调用普通函数。
template <class T1, class T2>
class Person {
// 友元函数类内实现 默认是全局函数
friend void printPerson(Person<T1, T2> &p); // 普通函数的声明
public:
Person(T1 name, T2 age) {
this->name = name;
this->age = age;
}
private:
T1 name;
T2 age;
};
template <class T1, class T2>
void printPerson(Person<T1, T2> &p) {
cout << "姓名：" << p.name << "年龄" << p.age << endl;
}
void test() {
Person<string, int> p("张三", 12);
printPerson(p); // 报错 无法解析外部命令
}
解决方案： 在友元函数函数名处加上菱形括号，表示模板函数的声明。
// 让编译器提前看到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<T1, T2> &p); // 普通函数的声明
friend void printPerson<>(Person<T1, T2> &p); // 模板函数的声明
public:
Person(T1 name, T2 age) {
this->name = name;
this->age = age;
}
private:
T1 name;
T2 age;
};
template <class T1, class T2>
void printPerson(Person<T1, T2> &p) {
cout << "姓名：" << p.name << "年龄" << p.age << endl;
}
void test() {
Person<string, int> p("张三", 12);
printPerson(p);
}
int main()
{
test();
system("pause");
return EXIT_SUCCESS;
}
13 类模板的应用-数组类封装
MyArray.hpp文件
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 & arry) {
this->m_Capacity = arry.m_Capacity;
this->m_Size = arry.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < this->m_Size;i++) {
this->pAddress[i] = arry[i];
}
}
~MyArray() {
if (this->pAddress != NULL) {
delete[] this->pAddress;
this->pAddress = NULL;
}
}
// 赋值操作符重载
void operator=(MyArray & arry) {
// 先判断原始数据 有 就清空
if (this->pAddress != NULL) {
delete[] this->pAddress;
this->pAddress = NULL;
}
this->m_Capacity = arry.m_Capacity;
this->m_Size = arry.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < this->m_Size; i++) {
this->pAddress[i] = arry[i];
}
}
// [] 重载
T & operator[](int index){
return this->pAddress[index];
}
// 尾插法
void pushBack(T val) {
this->pAddress[this->m_Size] = val;
this->m_Size++;
}
// 获取大小
int getSize() {
return this->m_Size;
}
// 输出自身数据的方法
void printArry() {
for (int i = 0; i < this->m_Size;i++) {
cout << this->pAddress[i] << " ";
}
cout << endl;
}
private:
T * pAddress;
int m_Capacity;
int m_Size;
};
主函数.cpp文件：
class Person {
public:
Person() {
cout << "调用默认的构造函数" << endl;
}
Person(string name,int age) {
this->m_Name = name;
this->m_age = age;
}
~Person() {
cout << "调用析构函数" << endl;
}
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 test() {
//MyArray<int> arr(10);
//for (int i = 0; i < 10;i++) {
// arr.pushBack(i+100);
//}
//arr.printArry();
/*MyArray<float> arr(10);
for (int i = 0; i < 10;i++) {
arr.pushBack(0.1f+i);
}
arr.printArry();
cout << arr[5] << endl;*/
Person p1("张三",12);
Person p2("李四", 13);
Person p3("王五", 14);
Person p4("赵六", 15);
MyArray<Person> pArray(10);
pArray.pushBack(p1);
pArray.pushBack(p2);
pArray.pushBack(p3);
pArray.pushBack(p4);
printPersonArray(pArray);
}
int main()
{
test();
system("pause");
return EXIT_SUCCESS;
}
浙公网安备 33010602011771号