【C++】模版初阶

• 目录

  前言

  一、泛型编程

  二、函数模版

  1.函数模版的概念：

  2.函数模版的格式：

  3.函数模版的原理：

  4.函数模版的实例化

  5.模版参数的匹配原则：

  6.补充：

  三、类模版

  1.类模版的定义格式

  2.演示

  3.类模版的示例化

  总结

---

前言

本文主要讲述C++模板初阶的知识，主要关于函数模板和类模板的用法教程。

---

一、泛型编程

• 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

**例：**如何实现一个通用的交换函数呢？

#include <iostream>
using namespace std;

//函数重载
void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

使用函数重载虽然可以实现，但是有一下几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增 加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

• 如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。

解决方法即C++中的模版：

---

二、函数模版

1.函数模版的概念：

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

---

2.函数模版的格式：

template<typename T1, typename T1, ...... typename Tn>

函数返回类型 函数名(参数列表)

{

//代码块；

}

• template：关键字，本意就是模版的意思
• typename：关键字，声明模版参数。

**例：**实现Swap的函数模版

#include <iostream>
using namespace std;

//函数模版
template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

**注意：**typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替 class)

#include <iostream>
using namespace std;

//函数模版
template<class T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

---

定义模版参数关键字使用 typename 和 class 的区别：

1. 最初 C++ 语言中只有 class 可以用于定义模板参数，随着 C++ 标准的发展，在 C++98/03 中引入了 typename，它也可以用来声明模板中的类型参数，并且具有更广泛的用途。
2. typename 和 class 在作为模板参数关键字时是可互换的，选择哪一个主要取决于个人或团队的编码风格。
3. 但在模板内部引用依赖于模板参数的类型时，则必须使用 typename。

例如：

// T 可以是任何类型
template <typename T> 
void function1(T param);

// T 同样可以是任何类型
template <class T> 
void function2(T param);

// 需要使用 typename 指定 T::iterator 是类型
template <typename T>
void function3(const typename T::iterator& it); 

// 错误的用法，当 T::iterator 是类型时，应该使用 typename
//template <typename T>
//void function4(const T::iterator& it);

---

3.函数模版的原理：

• 函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。 所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
• 使用函数模版与自己显示的把每个函数写出来效果是一样的

#include <iostream>
using namespace std;

//函数模版
template<class T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a1 = 1;
	int a2 = 2;
	Swap(a1, a2);

	double b1 = 3.3;
	double b2 = 4.4;
	Swap(b1, b2);

	char c1 = 'a';
	char c2 = 'b';
	Swap(c1, c2);

	return 0;
}

运行结果：

以上我们只写了一个模版函数，实际上编译器调用了不同的函数，这一点可以通过反汇编看到：

---

也就是说，函数模版会根据我们传入参数的类型，自动实例化出对应的函数：

• 在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演， 将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

---

模版参数可以有多个，例如我们想交换两个类型不同的数据：

#include <iostream>
using namespace std;

template<class T1, class T2>
void Swap(T1& left, T2& right)
{
	T1 temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a1 = 3;
	char c1 = 'h';
	Swap(a1, c1);

	return 0;
}

运行结果：

---

4.函数模版的实例化

• 用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
• 注意：函数模版的实例化是发生在编译阶段

1.隐式实例化：让编译器根据实参推演模板参数的实际类型

#include <iostream>
using namespace std;

template<class T>
T Add(T& left, T& right)
{
	return left + right;
}

int main()
{
	int a1 = 3, a2 = 4;
	double d1 = 6.1, d2 = 10.1;

	//隐式实例化，编译器根据传入变量类型自动推演生成函数
	cout << Add(a1, a2) << endl;
	cout << Add(d1, d2) << endl;

	return 0;
}

运行结果：

---

2. 显式实例化：在函数名后的<>中指定模板参数的实际类型

#include <iostream>
using namespace std;

template<class T>
T Add(T left, T right)
{
	return left + right;
}

int main()
{
	int a1 = 3, a2 = 4;
	double d1 = 6.1, d2 = 10.1;

	//显式实例化：使用<>指定实例化的模版参数类型
	cout << Add<int>(a1, a2) << endl;
	cout << Add<double>(d1, d2) << endl;

	//这样可以强制两种不同类型的变量相加，相当于传参时自动类型转化了
	cout << Add<int>(a1, d2) << endl;

	return 0;
}

运行结果：

当然以上并不是显示实例化的应用场景，毕竟类型转化会丢失数据，上述情况还是使用两个模版参数更好。

显示实例化的适用场景，例：

#include <iostream>
using namespace std;

template<class T>
T* Func(size_t n)
{
	return new T[n];
}

int main()
{
	//因为函数模版中的函数参数类型并不是模版参数类型，
	//所以编译器无法自动推演出函数，这时就必须显示实例化。
	int* arr = Func<int>(10);
	char* ch = Func<char>(6);

	delete[] arr;
	delete[] ch;

	return 0;
}

---

5.模版参数的匹配原则：

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而 不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

**例：**以下调用的Add函数是非模版函数，函数模版函数

#include <iostream>
using namespace std;

//非模版函数
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}

//函数模版
template<class T>
T Add(T left, T right)
{
	cout << "T Add(T left, T right)" << endl;
	return left + right;
}

int main()
{
	Add(2, 3);

	return 0;
}

运行结果：

解释：

1. 答案：无疑调用的是现成的非模板函数
2. 因此，对于已经存在可以直接使用的函数时，编译器不会去调用函数模板生成对应函数

当然我们可以使用显示实例化强制调用模板函数：

#include <iostream>
using namespace std;

//非模版函数
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}

//函数模版
template<class T>
T Add(T left, T right)
{
	cout << "T Add(T left, T right)" << endl;
	return left + right;
}

int main()
{
	//调用非模板函数
	Add(2, 3);

	//强制调用模版函数
	Add<int>(2, 3);

	return 0;
}

运行结果：

疑问：对于已经存在的函数，使用函数模板再次生成相同类型的同名函数不会产生冲突吗？

**答：**不会，函数模版生成的函数名相比于已经存在的函数，在名字上会有所不同，具体有什么不同取决于编译器。

可以通过查看反汇编验证：

---

**我们再看一种情况：**有两个同名的函数模版+一个同名的非模版函数，编译器会调用哪个函数？

#include <iostream>
using namespace std;

//非模版函数
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}

//函数模版1
template<class T>
T Add(T left, T right)
{
	cout << "T Add(T left, T right)" << endl;
	return left + right;
}

//函数模版2
template<class T1,class T2>
T1 Add(T1 left, T2 right)
{
	cout << "T1 Add(T1 left, T2 right)" << endl;
	return left + right;
}

int main()
{
	int a1 = 2, a2 = 3;
	double d1 = 10.1, d2 = 20.1;

	Add(a1, a2);
	Add(d1, d2);
	Add(d1, a2);

	return 0;
}

运行结果：

对于以上运行结果，我们可以总结一条规律：

• 模版函数的调用原则：优先调用最匹配的函数模版去生成对应模版函数

---

6.补充：

关于swap函数，在C语言中，我们需要的时候需要手动实现，但是在C++中，库里面其实已经实现了该函数，我们想用的时候可以直接使用：

我们可以发现，库里面的swap就是通过函数模版实现的。

#include <iostream>
using namespace std;

int main()
{
	int a = 3, b = 5;
	cout << "a=" << a << " " << "b=" << b << endl;
	swap(a, b);
	cout << "a=" << a << " " << "b=" << b << endl;

	return 0;
}

运行结果：

---

三、类模版

类模版与函数模版类似

1.类模版的定义格式

template<class T1, class T2 ,......, class Tn>

class 类模板名

{

//类内成员定义

};

关键字 class 与 typename 可以互换，关于这俩的区别在上文函数模版有讲。

---

2.演示

**例如：**模拟实现栈（非完整）

#include <iostream>
using namespace std;

//类模板
template<class T>
class Stack
{
public:
	//构造
	Stack(int n = 4)
		:_a(new T[n])
		, _capacity(n)
		, _top(0)
	{}

	//析构
	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _top = 0;
	}

	//打印
	void Print() const
	{
		for (int i = 0; i < _top; i++)
		{
			cout << _a[i] << " ";
		}
		cout << endl;
	}

	//入栈
	void Push(const T& x)
	{
		//...增容检查等省略
		_a[_top++] = x;
	}

private:
	T* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	//类模版必须显示实例化
	Stack<int> st1;
	st1.Push(1);
	st1.Push(2);
	st1.Print();

	//有了类模版就可以定义多个不同的类类型了
	Stack<double> st2(10);
	st2.Push(1.1);
	st2.Push(2.1);
	st2.Push(3.1);
	st2.Print();

	return 0;
}

运行结果：

---

注意：模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因在STL部分会详细说明

在一个文件中，类模板中的成员函数定义在类域外时，定义格式为：

#include <iostream>
using namespace std;

//类模板
template<class T>
class Stack
{
public:
	//构造
	Stack(int n = 4)
		:_a(new T[n])
		, _capacity(n)
		, _top(0)
	{}

	//析构
	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _top = 0;
	}

	//打印
	void Print() const;

	//入栈
	void Push(const T& x);

private:
	T* _a;
	size_t _capacity;
	size_t _top;
};

//类模版成员函数定义
template<class T>
void Stack<T>::Print() const
{
	for (int i = 0; i < _top; i++)
	{
		cout << _a[i] << " ";
	}
	cout << endl;
}

//类模版成员函数定义
template<class T>
void Stack<T>::Push(const T& x)
{
	//...增容等省略
	_a[_top++] = x;
}

---

3.类模版的示例化

• 类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
• 简述：类模板必须显示实例化

关于类名和类型：

// Stack是类名，Stack<int>才是类型
Stack<int> st1;    // int
Stack<double> st2; // double

---

总结

以上就是本文全部内容，感谢支持！