模板的注意事项

目录

swap函数：

模板不支持分离编译

声明和定义分离的好处

---

swap函数：

#include
using namespace std;
template <class T>
void swap(T&left, T&right)
{
	T temp = right;
	right = left;
	left = temp;
}
int main()
{
	int a = 10, b = 20;
	swap(a, b);
	return 0;
}

进行运行会报错：

 

如果我们要调用自己写的函数：

#include
using namespace std;
 
namespace sk
{
	template <class T>
	void swap(T&left, T&right)
	{
		T temp = right;
		right = left;
		left = temp;
	}
}
int main()
{
	int a = 10, b = 20;
	sk::swap(a, b);
	return 0;
}

模板不支持分离编译

我们可以在头文件中直接定义模板类，这样使用没有问题：

#include
using namespace std;
template<class T>
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (T*)malloc(sizeof(T)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	void Push(const T& x)
	{
		_a[_top++] = x;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	T*_a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack<int> st;
	st.Push(1);
	st.Push(2);
	return 0;
}

假如我们要分离编译：

 

链接错误。

 

 错误原因：

 简而言之：

模板需要实例化，我们在实例化时只有函数的声明，函数的定义没有实例化，所以找不到对应函数的地址。

 解决方法就是在模板函数定义的位置显示实例化

#include"Stack.h"
template<class T>
Stack::Stack(int capacity = 4)
{
	_a = (T*)malloc(sizeof(T)*capacity);
	if (_a == nullptr)
	{
		perror("malloc fail");
		exit(-1);
	}
	_top = 0;
	_capacity = capacity;
}
template<class T>
void Stack::Push(const T& x)
{
	_a[_top++] = x;
}
template<class T>
Stack::~Stack()
{
	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}
template
class Stack<int>;

假如我们再创建一个double类型的对象：

我们还需要在定义的地方再显示实例化一个double类型的。

template
class Stack<int>;
template
class Stack<double>;

每次加一个不同的类型的对象，就需要显示实例化一个，很麻烦，所以模板最好不要使用分离编译。

我们可以把声明和定义写在同一个文件里

#include
using namespace std;
template<class T>
class Stack
{
public:
	Stack(int capacity = 4);
	void Push(const T& x);
	~Stack();
private:
	T*_a;
	size_t _capacity;
	size_t _top;
};
template<class T>
Stack::Stack(int capacity = 4)
{
	_a = (T*)malloc(sizeof(T)*capacity);
	if (_a == nullptr)
	{
		perror("malloc fail");
		exit(-1);
	}
	_top = 0;
	_capacity = capacity;
}
template<class T>
void Stack::Push(const T& x)
{
	_a[_top++] = x;
}
template<class T>
Stack::~Stack()
{
	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}

声明和定义分离的好处

1：方便保护源码

2：阅读方便。