函数 / 类模板--模板2

这样N开20000满足st2但是对st1太大,st1只需要100则st1会浪费很多空间

#include <iostream>
#include <array>
#include <vector>
#include <queue>
#include <functional>
using namespace std;
// 静态的栈--不需要capacity
#define N 20000
template<class T>
class Stack
{
private:
	T _a[N];
	size_t _top;
};
int main()
{
	Stack<int> st1;  // 100
	Stack<int> st2;  // 20000
	return 0;
}

解决：使用非类型模板参数

// T是类型模板参数
// N是非类型模板参数，N是一个常量
template<class T, size_t N>
class Stack
{
private:
	T _a[N];
	size_t _top;
};
template<class T, size_t N>
class Array
{
private:
	T _a[N];
};
int main()
{
	Stack<int, 100> st1;  // 100
	Stack<int, 20000> st2;  // 20000
  //err下面三行
	//static int n;
	//cin >> n;
	//Stack<int, n> st2;  // 20000

	// 不建议用它，因为如果数据量大，可能会引发栈不够用--一般情况下不在栈上开过大的空间
	array<int, 100000> a1; // 400000byte都在栈上

	// 建议用vector
	vector<int> v;        // 12byte在栈上
	v.resize(100000);      // 400000byte都在堆上
	return 0;
}

模板参数可以给缺省值

• 模板参数给缺省值跟函数参数给缺省值是完全类似的
• 可以给全缺省、 半缺省 – 必须从右往左连续缺省

template<class T = int, size_t N = 10>
class Array
{
private:
	T _a[N];
};
//deque做它的默认容器
template <class T, class Container = deque<T> >
class stack;
int main()
{
	Array<> a0;//全缺省
	Array<int> a1;
	Array<int, 100> a2;
	priority_queue<int, vector<int>, greater<int>> pq;
	return 0;
}

函数模板的特化

匹配类型可以使用特化和匹配原则
1

//模板匹配
// 模板的特化，针对某些类型进行特殊化处理
template<class T>
bool IsEqual(const T& left, const T& right)
{
	return left == right;
}
//left是p1的别名，前面的const是修饰*left,因为p1是const类型，所以left不能扩大功能必须为const类型，在&前又加了一个const来修饰left
bool IsEqual(const char* const & left, const char* const & right)
{
	return strcmp(left, right) == 0;
}
//p1直接拷贝值给left,因为不是别名所以left的改变不会影响p1所以不需要加left不需要const
//bool IsEqual(const char* left, const char* right)
//{
//	return strcmp(left, right) == 0;
//}
int main()
{
	cout << IsEqual(1, 2) << endl;
	char p1[] = "hello";//数组名不允许修改，p1、p2为const的属性
	char p2[] = "hello";
	cout << IsEqual(p1, p2) << endl;;
	return 0;
}

2

template<class T>
void Swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}
// 模板匹配原則--进行特殊化处理--推荐这种
void Swap(vector<int>& a, vector<int>& b)
{
	a.swap(b);//交换vector里的三个指针(start、finish、endofstorage)
}
// 函数模板的特化
//template<>
//void Swap<vector<int>>(vector<int>& a, vector<int>& b)
//{
//	a.swap(b);
//}
//不支持下面这样任意的类型，必须给出具体的类型
//template<class T>
//void Swap<vector>(vector<T>& a, vector<T>& b)
//{
//	a.swap(b);
//}
int main()
{
	int x = 1, y = 2;
	Swap(x, y);
	vector<int> v1 = { 1, 2, 3, 4 };
	vector<int> v2 = { 10, 20, 30};
	Swap(v1, v2);
	return 0;
}

类模板的特化

匹配类型只能使用特化不能写匹配类型

template<class T1, class T2>
class Data
{
public:
	//原类型
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
// 全特化
template<>
class Data<double, double>
{
public:
	Data() { cout << "Data<double, double>" << endl; }
private:
};
// 偏特化/半特化
template<class T1>
class Data <T1, char>
{
public:
	Data() { cout << "Data<T1, char>" << 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:
};
template<class T1, class T2>
class Data < T1&, T2* >
{
public:
	Data() { cout << "Data<T1&, T2*>" << endl; }
private:
};
int main()
{
	Data<int, int> d1;//没有特化走原类型
	Data<double,double> d2;//有特化走特化
	Data<double,char> d3;
	Data<int, char> d4;
	Data<int*, char*> d5;
	Data<int*, int*> d6;
	Data<int&, int&> d7;
	Data<int&, char&> d8;
	Data<int&, char*> d9;
	return 0;
}

模板不支持分离编译

分离：在.h中放声明，在.cpp中放定义

解决分离出现问题(F)方法

• 方法1
  
• 方法2
  

栈–模板不能分离编译

1、栈实例化方法
test.c

#include "Func.hpp"
#include "Func.h"
int main()
{
	Stack<int> st1;
	Stack<double> st2;
	return 0;
}

Func.cpp

#include "Func.h"
template<class T>
Stack<T>::Stack()
{
	_a = new T[10];
	_top = 0;
	_capacity = 10;
}
template<class T>
Stack<T>::~Stack()
{
	delete[] _a;
	_a = nullptr;
}
// 解决方案一：
// 显示指定实例化,缺陷：用一个类型就得显示实例化一个，非常麻烦
template
class Stack < int > ;
template
class Stack < double > ;

Func.h

#pragma once
#include <iostream>
using namespace std;
template<class T>
class Stack
{
public:
	Stack();
	~Stack();
	void Push(const T& x);
private:
	T* _a;
	int _top;
	int _capacity;
};

2、栈部分编译方法
test.c

#include "Func.hpp"
#include "Func.h"
int main()
{
	F(1);
	F(1.11);
	Print();
	Stack<int> st1;
	Stack<double> st2;
	st1.Push(1);
	return 0;
}

Func.h

#pragma once
#include <iostream>
using namespace std;
// 解决方案2：不分离编译。声明和定义或者直接定义在.h中
template<class T>
class Stack
{
public:
	Stack();
	~Stack();
	void Push(const T& x);
private:
	T* _a;
	int _top;
	int _capacity;
};
template<class T>
Stack<T>::Stack()
{
	_a = new T[10];
	_top = 0;
	_capacity = 10;
}
template<class T>
Stack<T>::~Stack()
{
	delete[] _a;
	_a = nullptr;
}
// Push有语法问题，没有被检查出来，编译不报错
// 原因，模板如果没有实例化，编译器不会去检查模板内部语法错误
// 我们实例化了栈这个类，对类模板是按需实例化，调用了哪个成员函数就实例化谁
template<class T>
void Stack<T>::Push(const T& x)
{
	_a[_top] = x
		++_top;
}

模板的优缺点