C++模板简介与使用_c++ template <typename t1,typename t2,typename t >-CSDN博客

本文链接：https://blog.csdn.net/weixin_43690795/article/details/107078252

模板的出现意味着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<typename T1, typename T2,…,typename Tn>
返回值类型函数名(参数列表){}

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

template<typename T>
void Swap(T& x, T& y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

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

函数模板的实例化：用不同类型的参数使用函数模板时。
模板参数实例化分为：隐式实例化和显式实例化。
隐式实例化：让编译器根据实参推演模板参数的实际类型
显式实例化：在函数名后的<>中指定模板参数的实际类型

    double a = 1.0, b = 2.2;
    Swap(a, b); //隐式实例化
    Swap<double>(a, b); //显式实例化

类模板

类模板格式：

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

利用类模板实现一个简单的 vector：

#include <iostream>
#include <cassert>
#include <cstring>
using namespace std;

template<class T>
class Vector
{
public:
	Vector()
		: _arr(nullptr)
		, _size(0)
		, _capacity(0)
	{}

	~Vector()
	{
		if (_arr)
		{
			_arr = nullptr;
			_size = _capacity = 0;
		}
	}

	void PushBack(const T& val)
	{
		//扩容
		if (_size == _capacity)
		{
			size_t new_capacity = _capacity == 0 ? 2 : _capacity * 2;
			Reserve(new_capacity);
		}

		_arr[_size++] = val;
	}

	T& operator[](size_t index)
	{
		assert(index < _size);
		return _arr[index];
	}

	const T& operator[](size_t index) const
	{
		assert(index < _size);
		return _arr[index];
	}

	size_t Size()
	{
		return _size;
	}

	size_t Capacity()
	{
		return _capacity;
	}
private:
	void Reserve(size_t new_capacity)
	{
		if (_arr)
		{
			T* tmp = new T[new_capacity];
			memcpy(tmp, _arr, sizeof(T) * _size);
			delete[] _arr;
			_arr = tmp;
		}
		else
		{
			_arr = new T[new_capacity];
		}
	}
private:
	T* _arr;
	size_t _size;
	size_t _capacity;
};

模板的实际意义好处？如果我们用C实现一个栈，可能会出现以下问题：

忘记初始化和销毁
没有封装，任何人都可以修改结构体内的数据
如果想同时定义两个栈，一个存int型，一个存double型做不到

C++很好的解决了上述问题：

构造函数+析构函数
类+访问限定符
模板

类型模板参数

如果我们想定义不同大小的数组，就需要去修改N的值，很麻烦。

#define N 100
template <class T>
class A
{
private:
	T _arr[N];
};

int main()
{
	A<int> a1;
	return 0;
}

非类型模板参数

模板参数分类类型形参与非类型形参
类型形参：出现在模板参数列表中，跟在class或者typename之后的参数类型名称。
非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

template <class T, int N = 10>
class A
{
private:
	T _arr[N];
};

int main()
{
	A<int, 100> a1;
	A<int, 1000> a2;
	A<int> a3;
	return 0;
}

注意：

浮点数、类对象以及字符串是不允许作为非类型模板参数的。
非类型模板参数为常量，不可修改。

模板的特化

首先我们来看一个问题：

#include <iostream>
#include <string>
using namespace std;

template<class T>
bool IsEqual(T& left, T& right)
{
    return left == right;
}

void Test()
{
    char str1[] = "hello";
    char str2[] = "hello";
    char* p1 = str1;
    char* p2 = str2;
    if (IsEqual(p1, p2))
    {
        cout << "equal" << endl;
    }
}

int main()
{
    Test();
    return 0;
}

如上代码就是错误的用法，本意是想比较字符串内容的；但是事实在用p1和p2两个指针作比较。p1和p2为指针类型，导致输出结果是不相等。
模板的特化可以很好的解决上述问题。模板特化中分为函数模板特化与类模板特化。

函数模板的特化步骤：

必须要先有一个基础的函数模板
关键字template后面接一对空的尖括号<>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

#include <iostream>
#include <string>
using namespace std;

template<class T>
bool IsEqual(T& left, T& right)
{
    return left == right;
}

template<>
bool IsEqual<char*>(char*& left, char*& right)
{
    return strcmp(left, right) == 0;
}

void Test()
{
    char str1[] = "hello";
    char str2[] = "hello";
    char* p1 = str1;
    char* p2 = str2;
    if (IsEqual(p1, p2))
    {
        cout << "equal" << endl;
    }
}

int main()
{
    Test();
    return 0;
}

全特化和偏特化

全特化：将模板参数列表中所有的参数都确定化。
偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

#include <iostream>
using namespace std;

template<class T1, class T2>
class Data
{
public:
    Data() { cout << "原模板类:Data<T1, T2>" << endl; }
private:
    T1 _d1;
    T2 _d2;
};

template<>
class Data<int, char>
{
public:
    Data() { cout << "全特化:Data<int, char>" << endl; }
private:
};

template<class T2>
class Data<int, T2>
{
public:
    Data() { cout << "偏特化:Data<int, T2>" << endl; }
private:
};

template<class T1, class T2>
class Data<T1*, T2*>
{
public:
    Data() { cout << "偏特化:Data<T1*, T2*>" << endl; }
private:
};

template<class T1, class T2>
class Data<T1&, T2&>
{
public:
    Data() { cout << "偏特化:Data<T1&, T2&>" << endl; }
private:
};

int main()
{
    Data<int, int> d1; //偏特化Data<int, T2>
    Data<int, char> d2; //全特化Data<int, char>
    Data<double, double> d3; //原模板类Data<T1, T2>
    Data<char*, char*> d4; //偏特化Data<T1*, T2*>
    Data<int*, char*> d5; //偏特化Data<T1*, T2*>
    Data<char&, char&> d6; //偏特化Data<T1&, T2&>
    Data<int&, char&> d7; //偏特化Data<T1&, T2&>
    return 0;
}