C++ ------>模板（T）进阶

//测试环节
//
#include <iostream>
#include <vector>
#include <list>

using std :: cout;
using std :: endl;
using std :: vector;
using std :: list;

//第一种写法
template<class Container>
void Print(const Container& v)
{
	typename Container :: const_iterator it = v.begin();
  
  while(it != v.end())
  {
  	cout << *it << " ";
    ++it;
  }
  cout <<endl;
}

//第二种写法 ----->推荐
template<class Container>
void Print(const Container& v)
{
	auto it = v.begin();
  
  while(it != end())
  {
  	cout << *it << " ";
    ++it;
  }
  cout << endl;
}

int main()
{
  //遍历 vector(容器)
	vector<int> v;
  
  v.push_back(12);
  v.push_back(16);
  v.push_back(17);
  
  v.push_back(21);
  v.push_back(23);
  
  for(auto e : v)
  {
  	cout << e << " ";
  }
  cout << endl;
  
  Print(v);
  
  //遍历 List(链表)
  list<int> It;
  
  It.push_back(32);
  It.push_back(36);
  It.push_back(38);
  
  It.push_back(38);
  It.push_back(40);
  
  for(auto e : It)
  {
  	cout << e << " ";
  }
  cout << endl;
  
  Print(It);
	return 0;
}

//定义静态栈区
#define N 10
template<class T, size_t N>
class stack
{
public:
  void func()
  {
  	N = 0; 
  }
  
private:
  T _a[N];
	int _top;
};

int main()
{
  stack<int， 10> T1; 
  
  stack<int， 100> T2; //容量为 100 
	return 0;
}

//函数 模板 特化
//
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

//全特化
template<>
bool Less<int*>(int* left, int* right)
{
	return *left < *right;
}

bool Less(int* left, int* right)
{
	return *left < *right;
}

//推荐写法
template<class T>
bool Less(T* left, T* right)
{
	return *left < *right;
}

//测试环节
int main()
{
  cout << "" << Less(1, 2) << endl;
  
  int a = 1,  b = 2;
  cout << "" << Less(&a, &b) << endl;
  
  double c = 1.1, d = 2.2;
  cout << "" << Less(&c, &d) << endl;
	return 0;
}

//类模板 特化
template<class T1, class T2>
class Date
{
public:
  Date() {cout << "Date<T1, T2>" << endl << endl;}  
private:
  T1 _d1;
  T2 _d2;
};

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

//部分特化
template<class T>
class Date<T, double>
{
public:
	Date() {cout << "Date<T, double>" << endl << endl;}
private:
};

//限制性 特化
template<class T1, class T2>
class Date<T1*, T2*>
{
public:
	Date() {cout << "Date<T1*, T2*>" << endl << endl;}
private:
};
template<class T1, class T2>
class Date<T1&, T2&>
{
public:
	Date() {cout << "Date<T1&, T2&>" << endl << endl;}
private:
};

//测试__类模板特化
//
int main()
{
  Date<int, int> d1;
  Date<int, double> d2;
  
  Date<int*, double> d3;
  Date<double, double> d4;
  
  Date<double*, double*> d5;
  Date<void*, int*> d6;
  Date<int&, double&> d7;
	return 0;
}

// "Priorioty.h" ---->部分代码
#include <iostream>
#include <vecor>
#include <list>

using std :: cout;
using std :: endl;
using std :: vector;
using std :: list;
using std :: Container;

template<class T>
class Less
{
	public:
  	bool operator()(const T& left, const T& right)
    {
    	return left < right;
    }
}

//全特化
template<>
class Less<Date*>
{
	bool operator()(const Date* left, const Date* right)
  {
  	return *left < *right;
  }
}

void Test_Temp()
{
  //使用了 Less<Date>模板
	priority_queue<Date, vector<Date>, Less<Date>> pq1;
  
  pq1.push(Date(2023, 6, 7));
  pq1.push(Date(2023, 6, 8));
  pq1.push(Date(2023, 6, 13));
  
  while(!pq1.empty())
  {
  	cout << pq1.top() << " ";
    pq1.pop();
  }
  cout << endl << endl;
  
  //使用了 Less<Date*>模板
  priority_queue<Date*, vector<Date*>, Less<Date*>> pq2;
  
  pq2.push(new Date(2023, 11, 10));
  pq2.push(new Date(2023, 11, 11));
  pq2.push(new Date(2023, 11, 12));
  
  while(!pq2.empty())
  {
  	cout << *pq2.top() << " ";
    pq2.pop();
  }
  cout << endl;
}

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