C++ 模板初阶

最新推荐文章于 2024-05-20 22:11:41 发布

插衣袖里

最新推荐文章于 2024-05-20 22:11:41 发布

阅读量33

点赞数

分类专栏： C++ 文章标签： c++ 算法数据结构

本文链接：https://blog.csdn.net/m0_66409987/article/details/130494379

版权

C++ 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

第三章 STL

泛型编程

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

重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。所以这里引入了模本。

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

模板又有函数模板和类模板

函数模板

语法

模板关键字为 template

形式为 template <class T> 或者 template <typename T>

其中的T是模板中的参数名，我们可以自定义

// 函数模板
template<class T>
T Add(T& left,T& right)
{
	return left + right;
}

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

模板函数传入的参数类型不同

不同类型的参数，我们在调用函数之前就会出错

Add(a1, d2); // a1 -> 10 , d2 -> 20.0

因为d2类型不匹配，因此会发生隐式类型转换，但由于隐式类型转换的变量具有常性，也就是const int类型，传入就会涉及权限的放大，故即便不经过推演也会出错。

实例化时进行改变

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

int main() {
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	// 隐式实例化(T的类型是编译器自己推导)
	Add(a1, a2);
	Add(d1, d2);

	Add(a1, (int)d2);
	// 显示实例化。(指定T的类型)
	Add<int>(a1, d1);

	return 0;
}

模板参数个数改变

template<class T1, class T2>  
T1 Add(const T1& left, const T2& right)   //  多个模板参数
{
  return left + right;
}

匹配规则

//专门处理int的加法函数
int Add(int x, int y)
{
  return x + y;
}

//通用加法函数
template<class T>
T Add(T left, T right) 
{
  return left + right;
}

int main()
{
  int a = 1, b = 2;
  cout << Add(a, b) << endl;
  return 0;
}

这样是不会报错的，会优先调用int类型的函数

类模板

类模板和函数模板有些不同，类模板只能显示实例化

 // 类模板
#include <assert.h>
template<class T>
class vector // 动态增长的数组
{
public:
	vector()
		:_a(nullptr)
		, _size(0)
		, _capacity(0)
	{}
	~vector()
	{
		delete[] _a;
		_a = nullptr;
		_size = _capacity = 0;
	}
	void push_back(const T& x);
	void pop_back();
	size_t size() {
		return _size;
	}

	T& operator[](size_t i) {
		assert(i < _size);
		return _a[i];
	}
private:
	T* _a;
	size_t _size;
	size_t _capacity;
};

// 类外面定义
template<class T> // 定义函数时，每次都要写这个
void vector<T>::push_back(const T& x) {
	// 如果空间不够，增容
	if (_size == _capacity)
	{
		size_t newcapatity = _capacity == 0 ? 2 : _capacity * 2;
		T* tmp = new T[newcapatity];
		if (_a) {
			memcpy(tmp, _a, sizeof(T) * newcapatity);
			delete[] _a;
		}
		_a = tmp;
		_capacity = newcapatity;
	}
	_a[_size] = x;
	++_size;
}
template<class T> 
void vector<T>::pop_back() {
	assert(_size > 0);
	_size--;
}

int main() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	for (size_t i = 0; i < v.size(); i++)
	{
		// 在重载[]的时候返回引用就可以了。
		v[i] *= 2;
	}
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i]  << " ";
	}
	return 0;
}

类模板使用时需要注意一些问题：

模板类中的函数在定义时，如果没有在类域中，就需要通过类模板+ 类域访问的方式定义

类模板不支持声明与定义分开在两个文件中实现，因为会出现链接错误