C++模版

• • 模版的特点
  • 函数模版
  • • 函数模板的注意事项：
    • 普通函数与函数模板的区别：
    • 普通函数和函数模版调用的规则：
  • 模版的局限性
  • 总结
  • 类模版
  • • 类模版实例
    • 类模版对象做函数参数
    • 类模版与继承
    • 构造函数的类外实现

模版的特点

• 模版不可以直接使用，只是作为一个框架
• 模版的通用并不是万能的

函数模版

建立一个通用函数，其函数返回值类型和形参类型可以不具*定，用一个虚拟的类型来代表
语法：template <typename T>
声明一个模版，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型

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

void test01()
{
	int a = 10;
	int b = 20;
	//利用函数模版交换
	//1、自动类型推导
	mySwap(a, b);
	//2、显示指定类型
	mySwap<int>(a, b);
}

函数模板的注意事项：

• 自动类型推导，必须推导出一致的数据类型T才可以使用
• 模板必须要确定出T的数据类型，才可以使用

普通函数与函数模板的区别：

• 普通函数调用时可以发生自动类型转换（隐式类型转换）
• 函数模版调用时，如果利用自动类型推导，不会发生隐式类型转换
• 如果利用显示指定类型的方式，可以发生隐式类型转换

普通函数和函数模版调用的规则：

• 如果普通函数和函数模版都可以实现，优先调用普通函数
• 可以通过空模版参数列表来强调调用函数模版myPrint<>(a, b);
• 函数模版也可以发生重载
• 如果函数模版可以产生更好的匹配，优先调用函数模版

模版的局限性

模版并不是万能的，有些特定的数据类型，需要用具体化的方法去做特殊实现

总结

既然选择使用了函数模版，就不要写普通函数，避免二义性

类模版

类模版实例

#include <iostream>
#include <string.h>
using namespace std;
//类模版
template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	NameType m_name;
	AgeType m_age;
}
//调用
void test01()
{
	Person<string,int>p1("ljw",20);
}

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

类模版中的成员函数并不是一开始就创建的，而是在调用的时候才创建

类模版对象做函数参数

//1、指定传入类型
void PrintPerson1(Person<string,int>&p)
{
	p.showPerson();
}

void test01()
{
	Person<string,int>p1("ljw",20);
	PrintPerson1(p1);
}

//2、参数模版化
template<class T1, class T2>
void PrintPerson2(Person<T1, T2>&p);
{
	p.showPerson();
}

void test02()
{
	Person<string,int>p2("Jeffrey",19);
	PrintPerson2(p2);

//3、整个类模版化
template<class T>
void PrintPerson3(T &p)
{
	p.showPerson();
)

void test03()
{
	Person<string,int>p3("Jeffrey",19);
	PrintPerson3(p3);
}

类模版与继承

当类模版碰到继承时，应该注意以下几点：

• 当子类继承父类的一个类模版时，子类在声明的时候，要指定出父类中T的类型
• 如果不指定，编译器无法给子类分配内存
• 如果想灵活指定出父类T的类型，子类也需要变为类模版

template<class T>
class Base
{
	T m;
};
class Son:public Base<int>//必须指定一个类型
{};
template<class T1, class T2>
class Son2:public Base<T2>
{
};

void test02()
{
	Son2<int, char> child1;
}

构造函数的类外实现

template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	T1 name;
	T2 age;
}

template<class T1, class T2>
Person<T1,T2>::Person(T1 name, T2 age)
{
	this->name=name;
	this->age=age;
}