模板（C++）-优快云博客

本文链接：https://blog.youkuaiyun.com/xb1132/article/details/145497556

1 模板

1.1 模板的概念

模板就是建立通用的摸具，大大提高复用性

1.2 函数模板

c++另一种编程思想称为泛型编程，主要利用的技术就是模板

c++提高两种模板机制：函数模板和类模板

1.2.1 函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
函数声明或定义

解释：

template --- 声明创建模板

typename --- 表面其后面的符号是一种数据类型，可以用class代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

示例：

#include<iostream>
#include<string.h>
using namespace std;

template<typename T>
void swap1(T& a, T& b) {
	T temp = a;
	a = b;
	b = temp;
}

int main() {
	int a = 10;
	int b = 20;
	swap1(a, b);
	//或者swap1<int>(a,b)
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	system("pause");
	return 0;
}

运行结果：

1.2.2 函数模板注意事项

注意事项：

自动类型推导，必须推导出一致的数据类型T，才可以使用

模板必须要确定出T的数据类型，才可以使用

1.2.3 普通函数于模板函数的区别

1.普通函数调用可以发生隐式类型的转换（ACSLL表）

2.函数模板用自动类型推导，不可以发生隐式类型转换

3.函数模板用显示指定类型，可以发送隐式类型转换

1.2.4 普通函数与函数模板的调用规则

调用规则如下：

1.如果函数模板和普通函数都可以实现，优先调用普通函数

2.可以通过空模板参数列表来强制调用函数模板

3.函数模板也可以发送重载

4.如果函数模板可以产生更好的匹配，优先调用函数模板

1.2.4 模板的局限性

局限性：

模板的通用性不是万能的

例如赋值操作：

template<class T>
void func(T a,T b){
    a= b;
}

如果传入的a和b是一个数组，就无法实现了

再例如：

template<calss T>
void func(T a,T b){
    if(a>b){...}
{

如果传入的是一个结构体或自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

给特定的函数开后门，例如上面的例子，若是我们想要单独增加一个Person类型的自定义函数进行使用，可以对模板函数进行重载

template<calss T>
void func(T a,T b){
    if(a=b){
        cout<<"相等"<<endl;
    }
}

template<> void func(Person a,Person b){
    if(a=b){
        cout<<"相等"<<endl;
    }
}

1.3 类模板

1.3.1 类模板语法

类模板作用：

建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表

语法：

template<typename T>
类

解释：

template -- 声明创建模板

typaname -- 表明其后面的符号是一种数据类型，可以用class代替

T --- 常用的数据类型，名称可以替换，通常为大

1.3.2 类模板与函数模板的区别

类模板与函数模板区别主要有两点：

1.类模板没有自动类型推导的使用方式

2.类模板在模板参数列表中可以有默认参数

#include<iostream>
#include<string.h>
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 << endl << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;

};

//1.类模板没有自动类型推导的使用方式
void test01() {
	//Person p("孙悟空", 1000);错误，不能自动推导类型
	Person<string, int>p("孙悟空", 1000);
	p.showPerson();
}

//2.类模板在模板参数列表中可以有默认参数
void test02() {
	Person<string>p("猪八戒", 9999);
	p.showPerson();
}

int main() {
	test01();
	system("pause");
	return 0;
}

1.3.3 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

普通类中的成员函数一开始就可以创建

类模板中的成员函数在调用时才创建

1.3.4 类模板对象做函数参数

一共有三种传入方式：

1.指定传入的类型 ---直接显示对象的数据类型

2.参数模板化 ---将对象中的参数变为模板进行传递

3.整个类模板化 ---将这个对象类型模板化进行传递

1.3.5 继承中类模板的使用

父类是一般类，子类是模板类

class A {
public:
	A(int temp = 0) {
		this->temp = temp;
	}
	~A(){}
private:
	int temp;
};
 
template <typename T>
class B :public A{
public:
	B(T t = 0) :A(666) {
		this->t = t;
	}
	~B(){}
private:
	T t;
};

子类是一般类，父类是模板类

template <typename T>
class A {
public:
	A(T t = 0) {
		this->t = t;
	}
	~A(){}
private:
	T t;
};
 
 
class B:public A<int> {
public:
    //也可以不显示指定，直接A(666)
	B(int temp = 0):A<int>(666) {
		this->temp = temp;
	}
	~B() {}
private:
	int temp;
};

父类和子类都是模板类

父类和子类都时模板类时，子类的虚拟的类型可以传递到父类中。

结论：

子类从模板类继承的时候,需要让编译器知道父类的数据类型具体是什么

1.父类一般类，子类是模板类, 和普通继承的玩法类似

2.子类是一般类，父类是模板类,继承时必须在子类里实例化父类的类型参数

3.父类和子类都时模板类时，子类的虚拟的类型可以传递到父类中