【C++进阶之路】模板

编程语言 2023-09-13 17:41:41 阅读次数: 0

前言

假如需要你写一个交换函数，交换两个相同类型的值，这时如果交换的是int 类型的值，你可能会写一个Swap函数，其中参数是两个int类型的，假如再让你写一个double类型的呢？你可能又要写一个Swap的函数重载，参数是两个类型double的，假如再让你写一个char类型的呢？你可能……这样会有尽头吗？没有，因为还有自定义类型呢！那我们如何解决这样的问题呢？——模板（主要功能是实现通用）

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

一. 函数模板

基本用法

①定义模板参数类型名

template<typename T1, typename T2,......,typename Tn>
//这里的typename也可以换为class
template<class T1, class T2,......,class Tn>
  • 切记： 不能换为struct

②函数模板的实现

  • 比如我们实现一个交换函数的模板
template<typename T>
void Swap(T& n1, T& n2)
{
    
    
	T tmp = n1;
	n1 = n2;
	n2 = tmp;
}

用如下几个例子实验一下：
例1：

class Date
{
    
    
public:

	void Print()
	{
    
    
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{
    
    

	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
    
    
	int x = 0,y = 1;
	double x1 = 1.1, y1 = 2.2;
	Date x2(1949, 10, 1), y2(2023, 5, 23);
	Swap(x, y);
	Swap(x1, y1);
	Swap(x2, y2);
	x2.Print();
	y2.Print();
	cout << "x:" << x << " y:" << y << endl;
	cout << "x1:" << x1 << " y1:" << y1 << endl;
	return 0;
}

运行结果：
在这里插入图片描述

  • 可以看到这是交换了。

到这里我们又有一个疑问——调用的是一个函数吗？
继续分析——转到反汇编。
在这里插入图片描述

  • 可以看到——调用的Swap的地址是不一样的！
  • 因此：调用的不是一个函数。
  • 如何解释呢？

换汤不换药，换的是类型，不变的交换的思想。
图解：
在这里插入图片描述

其实我们也跟根本不用自己实现交换函数，直接用库里的就行了。在这里插入图片描述

  • 不过库里的是全小写，我们平常实现的是首字母大小。

③模板的实例化

隐式实例化

  • 让编译器根据实参推演模板参数的实际类型。
template <typename T>
T Func(const T& n1, const T& n2)
{
    
    
	return n1 + n2;
}
int main()
{
    
    
	int x = 0,y = 1;
	Func(x, y);
	return 0;
}
  • 就好比这里传参并没有明确的说明x的类型，但是编译器会自动推导实参的类型。

显示实例化

  • 在函数名后的<>中指定模板参数的实际类型
template <typename T>
T Func(const T& n1, const T& n2)
{
    
    
	return n1 + n2;
}

int main()
{
    
    
	int x = 0,double y = 1;
	Func<int>(x, y);
	//这里会将y强制类型转换为一个double类型的常量，因此函数参数的const不可省去。
	return 0;
}
  • 像这样如果，编译器推导不出来类型，这时就需要我们显示声明一下，其中的类型是什么，否则编译器会直接报错。
  • 那除了显示示例化还有什么办法么？——强制类型转换。
template <typename T>
T Func(const T& n1, const T& n2)
{
    
    
	return n1 + n2;
}

int main()
{
    
    
	int x = 0,double y = 1;
	Func(x, (int)y);
	//这里会将y强制类型转换为一个double类型的常量，因此函数参数的const不可省去。
	return 0;
}
  • 强转的结果必然是使两个参数类型保持一致，如果强转后的参数类型不一致，那么编译器还是会报错。

还有一种情况是我们必须显示示例化的——模板参数做返回值。
示例：

template <typename T>
T Func(int x, int y)
{
    
    
	return x + y;
}

int main()
{
    
    
	int x = 0;
	int y = 1;
	Func<int>(x,y);
	return 0;
}
  • 这就好比你要使用函数模板，得先让编译器知道或者能推导出模板参数的类型，那么返回值写上模板参数的话，编译器是无从下手的，那么只有显式实例化了，编译器才知道返回类型，才会给你生成指定类型的函数。

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

1.能用普通函数就用普通函数，用不了再用函数模板。

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

template <typename T1,typename T2>
int add(T1 x, T2 y)
{
    
    
	return x + y;
}

int main()
{
    
    
	add(1, 2);//这里调用的非模板
	add(1.0, 1);//这里使用的是模板生成的函数
	return 0;
}

看反汇编：
在这里插入图片描述

2.非模板函数与模板部分重复都可以使用。

int add(int x, int y)
{
    
    
	return x + y;
}
template <typename T1,typename T2>
int add(T1 x, T2 y)
{
    
    
	return x + y;
}
int main()
{
    
    
	add(1, 2);//这里是调用add函数，因为能用普通函数就用普通函数
	add<int>(1, 1);这里是用的add模板函数实例化生成的函数。
	//这样也可以
	add<>(1, 1);//这算是空模板，只是为了调用模板而已。
	return 0;
}

3.普通函数支持类型转换，而模板要严格按照类型。

template<typename T>
int myAdd(T a, T b)
{
    
    
	cout << "template function" << endl;
	return a + b;
}

int myAdd(char a, char b)
{
    
    
	cout << "normal function" << endl;
	return a + b;
}
void test()
{
    
    
	int a = 10;
	int b = 20;
	char c1 = 'a';
	char c2 = 'b';

	myAdd(a, c1);//这里调用的是函数，这里的a会自动转换为char类型的
	myAdd(a, b);//两个都是int类型的调用模板函数
	myAdd(c1, b);//这里会发生类型转换，b的int类型会转换为char类型的
	myAdd(c1, c2);
	myAdd<>(c1, c2);//这里是显示实例化，自然会调用函数模板
}
int main()
{
    
    
	test();
	return 0;
}
  • 总结：

1.普通函数优先调用
2.普通函数支持类型转换
3.模板必须严格的类型匹配
4.如果函数模板可以产生一个更好的匹配，那么选择模板。
5.可以用空模板或者模板实例化让编译器只调用模板

二. 类模板

  • 简而言之就是类是通用的，比如一个栈既要存int类型的，又要存double类型等等。
  • 说明：类模板不是具体的类，是用来生成类对象的模具。
  • 补充：template定义的模板参数只在最近的一个大括号内有效。
#include<iostream>
using namespace::std;
template <typename T>
class Stack
{
    
    
public:
	Stack(int capacity = 4)
	{
    
    
		cout << "Stack()" << endl;
		T* tmp = new T[capacity];
		_arr = tmp;
		_top = 0;
		_capacity = capacity;
	}
	void PushBack(T x);

private:
	T* _arr;
	int _top;
	int _capacity;
};
//这里放在类外进行定义。
template <typename T>
//这里要说明的是必须写Stack<T>这是具体的类，而不能只写Stack。
void Stack<T>::PushBack(T x)
{
    
    
	if (_top == _capacity)
	{
    
    
		T* tmp = (T*)realloc(_arr, sizeof(T) * _capacity * 2);
		if (tmp == NULL)
		{
    
    
			perror("realloc fail");
			exit(-1);
		}
		else
		{
    
    
			_arr = tmp;
			_capacity *= 2;
		}
	}
	_arr[_top++] = x;
}
int main()
{
    
    
	Stack<int> stack1;//这要说明使用的数据类型，也就是类模板示例化。
	return 0;
}

// 注意：类模板
//1.类名——Stack
//2.类型 ——Stack<T>
  • 由类模板实例化得到的类叫模板类

三、 进阶知识

①typename的特殊用法

在大多情况下，class和typename的用处相同，下面是不同的一点。

//typename的作用——避免二义性

//const_iterator是静态变量
//struct A
//{
    
    
//	static int const_iterator;
//};
//int A::const_iterator = 1;

template<typename Container>
void Print(const Container& ret)
{
    
    
	typename Container::const_iterator it = ret.begin();
	//主要为Container::const_iterator可能是类型，也可能是一个静态变量。
	//可以替换为
	//auto it = ret.begin();
	for (auto e : ret)
	{
    
    
		cout << e << " ";
	}
	cout << endl;
}
  • 这里的const_iterator可能是静态变量，也可能是类型，具有二义性。
  • 因此这里加上 typename即可声明类型。

②静态栈

代码1：


#define N 100
	template<class T>
	class stack
	{
    
    
	public:
		T arr[N];//这样N是固定的
	};
  • N在使用时不能修改，除非修改源代码。

代码2:

	template<class T, size_t N = 100>
					//这里只能是 char、short、int、size_t类型的
	class stack
	{
    
    
	public:
		T arr[N];//这样N可以通过传参进行控制
	};
  • N可以通过传参进行控制，不过这里的类型必须为整形家族里面的。

库里的arry就是这样的实现的：

array<int,10> a;
//说明初始化10个元素，每个元素为int类型
int arr[10];

//唯一的区别：array进行强制了越界检查。
a[10] = 1;
arr[10] = 1;
//arr不一定会报错，可能会在某一段进行报错。
  • 这个容器比较鸡肋，唯一比较好的就是这里的越界检查非常的严格！而数组不一定会报错。

③模板的特化

  • 前提：得有模板，才能对该模板进行特化。

1.仿函数模板的特化

#include<vector>
#include<iostream>
using namespace std;
template<class T>
struct less
{
    
    

	bool operator()(T n1, T n2)
	{
    
    
		return n1 < n2;
	}
};

struct A
{
    
    
	A(int a = 0)
		:_a(a)
	{
    
    }
	int _a;
};
//对A*进行特化
template<>
struct less<A*>
{
    
    

	bool operator()(A* n1, A* n2)
	{
    
    
		return n1->_a < n2->_a;
	}
};
int main()
{
    
    
	vector<A*> v;
	v.push_back(new A(5));
	v.push_back(new A(4));
	v.push_back(new A(3));
	v.push_back(new A(2));
	v.push_back(new A(1));
	
	sort(v.begin(), v.end(),less<A*>());
	
	for (auto e : v)
	{
    
    
	
		cout << e->_a << " ";
	}
	cout << endl;
	return 0;
}
  • 这里对less进行特化，可以达到符合我们要求的功能。
  • 这里就达成了对指针指向的内容进行排序的功能。

2.类的特化

template<class T1, class T2>
class Data
{
    
    
public:
	Data()
	{
    
    
		cout << "Data<T1,T2>" << endl;
	}
private:
	T1 n1;
	T2 n2;
};

半特化

template<class T1>
class Data<T1*,char>
{
    
    
public:
	Data()
	{
    
    
		cout << "Data<T1,T2>" << endl;
	}
	T1* n1;
	char n2;
};

全特化

template<class T1, class T2>
class Data<T1*,T2*>
{
    
    
public:
	Data()
	{
    
    
		cout << "Data<T1,T2>" << endl;
	}
	T1* n1;
	T2* n2;
};

template<>
class Data<int,double>
{
    
    

public:
	Data()
	{
    
    
		cout << "Data<int,double>" << endl;
	}
private:
	int n1 = 1;
	double n2 = 1.0;
};
  • 总结：特化主要是为了满足一些特殊场景的需要。

④模板的声明与定义分离

  • stack.h
#include<iostream>
#include<deque>
using namespace std;
namespace my_STL
{
    
    
	template<class T ,class Con = deque<T>>
	class stack
	{
    
    
	public:

		void push(const T& val);
		void pop()
		{
    
    
			_st.pop_back();
		}
		T& top()
		{
    
    
			return _st[_st.size() - 1];
		}
		size_t size()
		{
    
    
			return _st.size();
		}
		bool empty()
		{
    
    
			return _st.empty();
		}
	private:
		Con _st;
	};
}
  • stack.cpp
#include"stack.h"
namespace my_STL
{
    
    
	template<class T, class Con>
	void stack<T,Con>::push(const T& val)
	{
    
    
		_st.push_back(val);
	}


}
  • test.cpp
void test4()
{
    
    
	my_STL::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	//链接找不到，地址，因为在.cpp的文件的模板函数没有实例化！

	while (!st.empty())
	{
    
    
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}

再链接时会发生：
在这里插入图片描述
这是为啥呢？

答：因为push没有实例化，所以找不到对应的地址。

如何解决：在test.cpp进行显示实例化

	template
		class stack<int>;

当然这是治标不治本的，因此我们一般还是放在同一个文件里。

库里有的文件声明与定义会放在.hpp为后缀的文件中，就是为了防止此问题。

模板将发生两次编译，分别在：

1.实例化前，先检查模板代码本身，查看语法是否正确。

2.实例化期间，检查模板代码，查看是否所有的调用都有效。

总结

  • 优点
  1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。
  2. 增强了代码的灵活性
  • 缺陷
  1. 模板会导致代码膨胀问题，也会导致编译时间变长（不可避免）
  2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误（主要问题）。

猜你喜欢

转载自blog.csdn.net/Shun_Hua/article/details/130822089
今日推荐
周排行
8种防盗链的方法
php的序列化和反序列化
Java 8：CompletableFuture
Android版本差异适配方案(5.0-9.0)
makedownpad使用
Spring Boot 使用AOP切面实现后台日志管理模块
实战SSM_O2O商铺_44【DES加密】 关键配置信息进行DES加密
ACM排行榜说明
【转】SQL重复记录查询
板球和秃子威力那个大
每日归档
更多
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)
2024-09-08(0)
2024-09-07(0)
2024-09-06(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022