C++模版

一、C++函数模版的使用

首先我们来了解一下为什么要使用函数模版，在学习C语言的时候，我们会写一个相加的add函数，可是我们所写的函数只能满足一种类型的相加，不能满足其他类型的相加，如果要满足其他类型的相加，就只能再写一个函数，但函数的逻辑其实是一样的。

所以，在C++中引入了模版的概念，只需写一个函数，就能满足多种类型的相加。

模版的写法:

template <typename T>

T add(T x, T y)
{
}

下面我们来写一个相加函数模版:

#include<iostream>
using namespace std;


template <typename T>

T add(T x, T y)
{
	return x + y;
}

int main()
{
	cout << "add(1,2)=" << add(1, 2) << endl;
	cout << "add(1.1,2.2)=" << add(1.1, 2.2) << endl;
	return 0;
}

上面便是通过函数模版来实现不同类型的相加。

结果:

当然我们也可以定义多个类型，就像下面那样。

template <typename T1,typename T2>

 我们来看下面的代码:

#include<iostream>
using namespace std;

template <typename T1,typename T2>

void Print(T1 x, T2 y)
{
	cout << "" << x << endl;
	cout << "" << y << endl;
}


int main()
{
	Print(1, 3.14);
	Print(3.14, 1);
	return 0;
}

这就是多种类型模版的使用，编译器会根据你传的类型推导出形参的类型。

结果: 

在第一个Print中，T1的类型是int，T2的类型是double，而第二个Print中，T1的类型是double，T2的类型是int。

 这是编译器自动的类型推导，我们也可以进行显示的类型调用:

#include<iostream>
using namespace std;


template <typename T1,typename T2>

void Print(T1 x, T2 y)
{
	cout << "" << x << " " << y << endl;
}


int main()
{
	Print<int,double>(1, 3.14);
	Print<double,int>(3.14, 1);
	return 0;
}

在函数前加上<类型，类型>就能够显示的进行类型调用，第一个Print中，T1的类型是int，T2的类型是double，而第二个Print中，T1的类型是double，T2的类型是int。

 这里要注意的是，typename可以使用class进行替代，结果都是一样的。

1.1 函数模版的重载

函数模版是可以重载的，我们来看下面的代码:

template <typename T>
void Print(T a)
{
	cout<<a<<endl;
}

template <typename T>
void Print(T a,T b)
{
	cout<<a<<endl;
	cout<<b<<endl;
}

这便是函数模版的重载。

1.2函数模版和普通函数谁先调用

我们来看下面的代码:

#include<iostream>
using namespace std;

template <typename T>

T add(T x, T y)
{
	return x + y;
}

int add(int x, int y)
{
	return (x + y) * 10;
}

int main()
{
	cout << "" << add(1, 2) << endl;
	return 0;
}

结果:

 

从结果我们可以看出，编译器调用的是普通函数，毕竟有了现成的函数，谁还会去使用模版呢？

总之C++函数模板是一种用于创建通用函数的机制，可以让程序员编写一次函数，然后让它适用于多种类型，在实际编程中非常实用。 

二、C++类模版

C++ 类模板是一种用于创建通用类的机制，它可以让程序员编写一次类，然后让它适用于多种类型，在实际编程中非常实用。

类模板和函数模板的定义和使用类似。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，类模板用于实现类所需数据的类型参数化。

类模版的定义方式:

template <class T>
class MyStack {
public:
    // 构造函数、析构函数、入栈、出栈等函数
private:
    T* data;
    int top;
};

类模板的实例化方式与函数模板类似，可以通过显式实例化、隐式实例化和模板特化三种方式来实现。其中，显式实例化是指通过在代码中显式地指定模板参数类型来实例化类模板，隐式实例化是指通过创建类实例时传递的实参类型来自动确定模板参数类型，模板特化则是指为特定的模板参数类型提供特定的实现方式。

下面我们来看一段代码:

#include <iostream>
using namespace std;

// 类模板
template <class T1, class T2>
class Data {
private:
	T1 _a;
	T2 _b;
public:
	Data(T1 a, T2 b)
	{
		_a = a;
		_b = b;
		cout << "Data的有参构造" << endl;
	}
	void Print()
	{
		cout << _a << " " << _b << endl;
	}
};

int main()
{
	Data<int, int> d1(300, 400);
	d1.Print();

	Data<int, char> d2(100, 'A');
	d2.Print();

	return 0;
}

这便是类模版的使用， 在初始化时初始化不同类型的数据。

结果:

2.1 类模板的成员函数在类外实现

1.在每个成员函数前必须添加template<>。

2.作用域需要添加<>修饰。

我们来看下面的代码:

#include <iostream>
using namespace std;

// 类模板
template <class T1, class T2>
class Data {
private:
	T1 _a;
	T2 _b;
public:
	Data(T1 a, T2 b);

	void Print();
};


template <typename T1,typename T2>
Data<T1, T2>::Data(T1 a, T2 b)
{
	_a = a;
	_b = b;
	cout << "Data(T1 a,T2 b)" << endl;
}

template <typename T1, typename T2>
void Data<T1,T2>::Print()
{
	cout << _a << " " << _b << endl;
}

int main()
{
	Data<int, int> d1(300, 400);
	d1.Print();

	Data<int, char> d2(100, 'A');
	d2.Print();

	return 0;
}

这便是成员函数在类外的实现方法。

结果:

 三、总结

以上就是我对于模版的理解，希望以上所讲能够对你有所帮助，如果有帮助的话，记得一键三连，感谢各位。