feng

started from 11.28.2025

首页·个人博客

模板

为了实现一个通用的交换函数,我们需要把每一种类型都进行重载C++入门

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<class T>
void Swap(T& x1, T& x2)
{
	T x = x1;
	x1 = x2;
	x2 = x;
}

模板的作用在于写与类型无关的代码。模板提出了一个概念叫做泛型编程,这样的编程方式适用于所有类型,它是一种代码复用的手段。
模板分为函数模板和类模板,它的语法格式为

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

typename也可以换成class.

模板的原理

首先有一个问题,在使用不同类型的Swap时,调用的到底是不是同一个函数?实际上不是,因为我们写的

template<class T>
void Swap(T& x1, T& x2)
{
	T x = x1;
	x1 = x2;
	x2 = x;
}

实际上不是一个真正的函数,而是一个模板函数,编译器会根据我们的代码按照模板推演,如果我传入两个int类型,编译器会推演出T是int型.也就是说调用函数的时候调用的不是模板函数,而是根据模板生成的函数,这个过程叫做模板的实例化.而这个过程发生在编译前的预处理过程.

Pasted image 20251002104650.png

进入汇编就可以看到,调用了多个函数而并非同一个

Pasted image 20251002104934.png

所以实际上该写的函数并没有少,只是不需要你去一个一个写了.

类模板

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

我们在C语言中实现栈的时候,为了能够让栈存储不同类型的东西,我们的做法是

typedef int STDataType
struct Stack
{
	STDataType* _a;
	int _top;
	int _capacity;
};

这样每次要修改类型的时候只需要改定义.然后使用前要进行初始化,使用后要进行销毁.
C中可能出现的问题是:
1.忘记初始化和销毁 2.没有封装. 3.不能同时定义两个类型的栈.
而在C++中

template<class T>
class Stack
{
public:
	Stack()//自动初始化
	{};
	~Stack()//自动销毁
	{};
	//其他功能函数
private:
	T* _a;
	int _top;
	int _capacity;
}

利用模板类,C++解决了不能同时定义两个类型的栈的问题

Stack<int> s1;
Stack<double> s2;

现在我们尝试用模板实现一个顺序表

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);
private:
	T* _a;
	size_t _size;
	size_t _capacity;
};

为什么push_back要传引用?如果传入引用,可以减少一次拷贝构造,能够提高效率.
假设我们的写法是在类中声明,在类外定义

void push_back(const T& x)//在类外定义
{
}

那么问题来了,第一:T是啥?,第二,怎么指定这个函数是vector中的.正确道写法是这样的

template<class T>
void vector<T>::push_back(const T& x)//在类外定义
{
}

首先要重新说明模板,然后这个函数是属于vector<T>的,因此要加上vector<T>::
vector本质上是一个动态增长的数组,数组是支持随机访问的,比方说arr[10],为了能够让我的顺序表也能够随机访问,我需要重载[]这个运算符.

T operator [](size_t i)
{
	assert(i < _size);
	return _a[i];
}

但是这样重载出来的只能读不能写,因为operator返回的是一个临时对象,临时对象具有常性.解决这个问题的方式很简单,使用引用返回就行.

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

汇总如下

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();
	T& operator [](size_t i)
	{
		assert(i < _size);
		return _a[i];
	}
	size_t size()
	{
		return _size;
	}
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 newcapacity = _capacity == 0 ? 2 : _capacity * 2;
		T* tmp = new T[newcapacity];
		if (_a)
		{
			memcpy(tmp, _a, sizeof(T) * _size);
			delete _a[];
			_a = tmp;
		}
		_capacity = newcapacity;
	}
	_a[_size] = x;
	_size++;
}
template <class T>
void vector<T>::pop_back()
{
	assert(_size > 0);
	_size--;
}

假设我们利用模板实现一个加法,则

template<class T>
T Add(const T& left,const T&right)
{
	return left+right;
}
int main()
{
	int a1=1,a2=2;
	double d1=1.0,d2=2.0;
	Add(a1,a2);
	Add(d1,d2);	
	return 0;
}

这个过程叫做隐式实例化,我们没有定义好T的类型,而是由编译器自己推导。假设我们这样调用

int main()
{
	Add(a1,d1);
	return 0;
}

此时就会报错,因为T是一个类型,不可能同时是int和double,此时我们可以显式实例化,阻止了推导的进行

int main()
{
	Add(a1,(int)d1);
	Add<int>(a1,d1);
	return 0;
}

如果我们还写了一个

int Add(int left,int right)
{
	return left+right;
}

那么在传入int类型变量的时候调用会优先调用上面这个,但是如果是调用Add<int>,依然会调用模板函数.

非类型模板参数

假设现在有这样一段代码,实现了一个定长数组

#define N 100
template<class T>
class array
{
public:
private:
	T _array[N];
}

那么我调用的时候如果想要创建几个大小不同的数组,就需要去实现多个不同的类,但是如果我把N当作模板参数传入,就解决了这个问题

template<class T,int N=100>
class array
{
public:
private:
	T _array[N];
}

这样的模板参数就叫做非类型模板参数,N会被认为是一个常量.
特别注意:浮点,类对象以及字符串是不允许作为非类型模板参数的

模板的特化

特化,即特殊化,针对某一种具体类型进行特殊处理

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

现在我要比较

int main()
{
    char p1[] = "hello";
    char p2[] = "world";
    isEqual(p1, p2);
    return 0;
}

我本身希望它比较的是两个字符串,但是实际上它比较的是p1和p2两个指针,此时我们就可以针对char类型进行特殊化处理.

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

下面这个模板就叫做上面这个模板的特化.
对于类模板而言,在类名后面进行指定类型

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:
	int _d1;
	char _d2;
};

特化分为全特化和偏特化,全特化就像上面一样,两个参数都进行了特化,偏特化则是只有部分参数进行特化,比如

template<class T2>
class Data<int,T2>
{
public:
	Data() {cout<<"Data<int, T2>" <<endl;}
private:
	int _d1;
	T2 _d2;
};

此外,还可以

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

这样如果传入的参数是两个指针就会匹配到这个模板上,这也是一种偏特化.

Pasted image 20260214110949.png

模板的分离编译

在项目工程中,一般将函数或者类的声明放到.h文件,定义放到.cpp文件,以便于查看和维护.但是,模板不允许分离编译.

//Func.c:
template<class T>
void F2(const T& x)
{
	cout << "F2" << endl;
}
//Func.h
template<class T>
void F2(const T& x);
//main.c
#include "Func.h"
int main()
{
	F2(10);
	return 0;
}//err
Pasted image 20260214120148.png

可以发现报了链接错误.为什么同样是分离编译,普通函数/类可以,但是函数模板/类模板却不行?
我们现在有3个文件
Func.c,Func.h,main.c
首先在预处理阶段,会展开头文件和宏替换,进行条件编译和去除注释,得到Func.i和main.i
然后是编译,会进行检查语法,生成汇编代码,生成Func.s和main.s
之后是汇编,机器只认识机器码,所以需要把汇编代码改为机器码,这就是汇编做的事情,最终得到Func.o和main.o.
最后是链接,链接过程中会有一个符号表,这个符号表存储了各种函数的地址,通过链接把Func.o和main.o合并生成a.out,即可执行文件.
我们在调用函数的时候,会变成

call F2(?)

而我们在main.c中进行调用的时候,由于只包了头文件,并找不到F2的定义,所以就要一直等到链接过程才能把地址填进来.
但是真正链接的时候F2报错了,F2的地址并没有被找到,原因是在调用

F2(10)

之前,Func.o并不知道T就是int类型,编译器认为没有用到这个模板函数,所以没有对其进行实例化,导致F2找不到,最终报链接错误.解决这个问题的方式有:
1.由于问题在于Func.o中不知道要对这个模板函数进行实例化,所以我们可以进行显示实例化,告诉编译器需要实例化为int类型.

//Func.c
template<class T>
void F2(const T& x)
{
	cout << "F2" << endl;
}
template
void F2<int>(const int& x);

但是这样的处理很不好,因为显式实例化了int类型就只能传int进去,模板就失去了意义,很不方便.
2.不要分离编译模板,因为这个问题并没有什么很好的解决方法.用到模板的地方直接声明和定义写一起就好

//Func.h
//声明
template<class T>
void F2(const T& x);
//定义
template<class T>
void F2(const T& x)
{
	cout << "F2" << endl;
}

总结

模板为我们实现了复用,由于仿函数的存在Stack&Queue,极大程度提高了我们的灵活性,但是同时编译的代码量也会变大导致编译速度变慢

← 上一篇:
下一篇: →