C++模板初阶

最新推荐文章于 2023-12-17 20:32:53 发布

七天七月七年_J

最新推荐文章于 2023-12-17 20:32:53 发布

阅读量286

点赞数 4

分类专栏： C++入门文章标签： c++ 开发语言算法

本文链接：https://blog.csdn.net/JJR_YZ/article/details/127656555

版权

C++入门专栏收录该内容

11 篇文章 0 订阅

订阅专栏

🚀有时候，人的自信和自卑可能都只源于他人的一句评价。所以做好自己，不要太在意流言。

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

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

Ⅴ模板参数的匹配原则

①一个非模板函数可以和一个同名的函数模板同时存在

一、泛型编程

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

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;
}
......

之前C++引入了函数重载，相同用处函数的命名问题得到了解决，方便了很多。但是我们如果想写一个通用的交换函数，是非常麻烦的，每一个类型的都要重载，还是不太方便。而且函数重载也有不少缺陷：

🖊重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型的出现，就需要用户增加对应的函数。

🖊代码的可维护性比较低，一个重载出错可能所有的重载都会出错。

那我们能不能使用一个模板，这类模板专门用于解决这一类问题，它允许所有的数据类型呢？这就要引入泛型编程这个概念：

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

二、函数模板

Ⅰ函数模板概念

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

Ⅱ函数模板格式

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

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

这里的T1，T2，...，Tn名字是自己定义的，没有要求。

template<typename T>
void Swap( T& left, T& right)
{
 T temp = left;
 left = right;
 right = temp;
}

注意：typename是用来定义模板参数关键字，也可以使用class

Ⅲ函数模板的原理

函数模板的原理是什么？编译器具体是怎么处理的？

其实函数模板是一个模子，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

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

也就是说，其实我们自己写三份重载，和编译器使用模板推演三种类型函数没有什么本质区别，只不过这些交给了编译器，我们不需要再写了。实例化的个数根据我们使用的情况，用的越多，实例化越多。

Ⅳ 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例化。

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

上面我们写的Swap模板就是我们给值，让编译器根据实参推演模板参数的典型例子。

template<typename Ad>
Ad Add(const Ad& a, const Ad& b)
{
	return a + b;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 6.4, d2 = 4.8;
	Add(a1, a2);
	Add(d1, d2);
	return 0;
}

这里我写的两个数相加，它们是相同类型的，如果我把a1和d1相加是否可以呢？

很显然被禁止了，我们看到这里的报错信息是模板参数"Ad"不明确，这是很好理解的，因为我们传了一个a1，类型是int；d1类型是double，编译器在根据模板推演时遇到了问题，a和b的类型都是Ad，但是我们上传的一个是int，一个是double。编译器就无法判断Ad到底是int还是double。

可能有的老铁还有问题，难道不会隐式类型转换吗？要知道如果我们自己写一个函数：

它自己进行了隐式类型转换，那么模板为什么不行呢？

这和模板的底层逻辑有关，首先我们自己写的明确了上传的类型，编译器有了明确的隐式类型转换的方向，比如这里就是double类型的d1转换为int；而模板上传了a1(int)，d1(double)，那么你让编译器把a1转换为double，还是d1转换为int呢？产生了二义性。而且我们知道隐式类型转换发生在类型转换赋值和传参的时候，这里在进行到Ad为int和Ad为double类型时就已经判定无法确定Ad类型，不会再发生后续的类型转换赋值和传参。

那么我们想要解决这样的问题，有两种处理方式：

1、用户自己来强制转化。

2、使用显式实例化

用户自己强制转换：

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

template<typename Ad>
Ad Add(const Ad& a, const Ad& b)
{
	return a + b;
}

int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 6.4, d2 = 4.8;
	Add<int>(a1, d1);//我们帮助编译器明确类型
	return 0;
}

我们帮助模板明确推演类型。

Ⅴ模板参数的匹配原则

①一个非模板函数可以和一个同名的函数模板同时存在

//通用加法函数
template<typename Ad>
Ad Add(const Ad& a, const Ad& b)
{
	return a + b;
}
//专门处理int的加法函数
int Add(const int& a, const int& b)
{
	return a + b;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 6.4, d2 = 4.8;
	Add<int>(a1, a2);//我们帮助编译器明确类型
	return 0;
}

我想在这里问一个问题，我们调用int类型的加法函数时，编译器会自己类型推演int还是直接用现成的int加法函数呢？

编译器也会偷懒，如果这里有现成的，编译器是不会自己推演化实现的！！！

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

那这里还有一个问题，我们难道不能实现不同类型的加法吗？其实是可以的，我们想一下函数模板类型是可以定义多个的：

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

我们给两个函数模板类型就好了。

三、类模板

Ⅰ类模板的定义格式

template<class T1,class T2,...class Tn>
class 类模板名
{
    //类成员定义
};

类模板实例化只能显式实例化，需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;

s1和s2是同一个类模板实例化出来的，但是模板参数(一个是int，一个是double)不同，那么s1和s2就是不同的类型。

①为什么要有类模板？

typedef int T;
//template<typename T> 
class Stack
{
public:
	void Init()
	{
		_array = (T*)malloc(sizeof(T) * 3);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = 3;
		_size = 0;
	}
	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			T* temp = (T*)realloc(_array, newcapacity *
				sizeof(T));
			if (temp == NULL)
			{
				perror("realloc申请空间失败!!!");
				return;
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}
private:
	T* _array;
	int _capacity;
	int _size;
};

比如说一个栈，我们想要数据类型是int，就typedef为int，我们想要数据类型为double，就typedef为double。好像类模板没有啥用处，我们typedef也可以做到不同的数据类型处理。但是typedef解决不了什么问题？比如说：我同时需要两个栈，第一个栈数据类型为double，第二个数据类型为int。那么我们这时typedef为哪种类型呢？如果typedef两个，那么类也需要拷贝两份，显然比较不合适。所以typedef它解决的是可维护性，不是所谓的泛型编程。

②类模板不支持分离编译

我们之前写类的时候，为了代码的可读性和可维护性常常定义和声明分离。那么我们在写类模板的时候是否可以呢？

/*Stack.hpp*/
#pragma once

#include<iostream>
using namespace std;

template<typename T>
class Stack
{
public:
	Stack(int capacity = 4);
	~Stack();
	void Push(const T& x);

private:
	T* _a;
	int _top;
	int _capacity;
};
/*Stack.cpp*/
#include "Stack.hpp"

template<class T>
Stack<T>::Stack(int capacity)
{
	cout << "Stack(int capacity = )" << capacity << endl;

	_a = (T*)malloc(sizeof(T)*capacity);
	if (_a == nullptr)
	{
		perror("malloc fail");
		exit(-1);
	}

	_top = 0;
	_capacity = capacity;
}

template<class T>
Stack<T>::~Stack()
{
	cout << "~Stack()" << endl;

	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}

template<class T>
void Stack<T>::Push(const T& x)
{
	// ....
	// 扩容
	_a[_top++] = x;
}
/*test.cpp*/
#include"Stack.hpp"
int main()
{
	Stack<int> st1;
	st1.Push(1);

	return 0;
}

🖊这里需要注意，类模板中函数放在类外进行定义时，需要加模板参数列表。

我们就写了Stack类的定义和声明分离，然后我们可以运行测试一下就会发现：

它会报链接错误，为什么会报链接错误呢？我不是包了头文件吗？这是因为，头文件在函数实现里面展开，也就是定义的地方展开，但是它没有实例化！也就是它没有收到main函数传的推演类型，所以函数实现的文件里面还是模板，没有生成函数放进符号表。所以会链接错误。

能解决吗？可以！我们需要在函数文件里告诉它我们想让它推演的类型！

/*Stack.cpp*/
.
.
.
.


// 显示实例化
template 
class Stack<int>;

这样就解决了，但是我这只是传一个类型int，如果我还想推演实例化double类型还需要再写这样一个到函数文件。所以，很不爽。

③声明和定义都放在.h或者.hpp文件

.hpp文件是专供模板类的文件，它是.cpp和.h的结合。

#pragma once

#include<iostream>
using namespace std;

template<typename T>
class Stack
{
public:
	Stack(int capacity = 4);
	~Stack();
	void Push(const T& x);

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


template<class T>
Stack<T>::Stack(int capacity)
{
	cout << "Stack(int capacity = )" << capacity << endl;

	_a = (T*)malloc(sizeof(T)*capacity);
	if (_a == nullptr)
	{
		perror("malloc fail");
		exit(-1);
	}

	_top = 0;
	_capacity = capacity;
}

template<class T>
Stack<T>::~Stack()
{
	cout << "~Stack()" << endl;

	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}

template<class T>
void Stack<T>::Push(const T& x)
{
	// ....
	// 扩容
	_a[_top++] = x;
}