1.堆的相关操作
is_heap()函数需要指向首尾的指针，可以判断对象是否是一个堆结构，返回一个bool值，make_heap可以把对象变成堆结构，sort_heap是堆排序，但是用堆排序函数需要的前提是对象是堆结构，不然会报错。(物理空间连续，则原生指针是天然的迭代器)
int main()
{int myints[] = { 10,20,30,5,15 };sort(myints, myints + 5);std::vector<int> v(myints, myints + 5);cout << is_heap(v.begin(), v.end()) << endl;cout << is_heap(myints, myints + 5) << endl;make_heap(v.begin(), v.end());cout << is_heap(v.begin(), v.end()) << endl;std::sort_heap(v.begin(), v.end());for (auto e : v){cout << e << " ";}cout << endl;return 0;
}2.仿函数
第一个测试是放三个类为Date对象，然后取出堆顶的元素，在这过程中会有对象的比较，然后会先去仿函数那里，然后会去到重载的>和<的函数比较大小。(优先级队列代码在最后面)，第二个是测试new的Date，这是后就是里面就是一个地址了，地址对应的是Date的空间，但是地址是随机生成的，所以每次的结果不一样，这时就需要改变一下仿函数，把x<y变成*x<*y，这样子就是比较Date的对象了。
class Date
{friend ostream& operator<<(ostream& _cout, const Date& d);
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}bool operator<(const Date& d)const{return (_year < d._year) ||(_year == d._year && _month < d._month) ||(_year == d._year && _month == d._month && _day < d._day);}bool operator>(const Date& d)const{return (_year > d._year) ||(_year == d._year && _month > d._month) ||(_year == d._year && _month == d._month && _day > d._day);}
private:int _year;int _month;int _day;
};ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout;
}class DateLess
{
public:bool operator()(Date* p1, Date* p2){return *p1 < *p2;}
};
class DateLess1
{
public:bool opertor()(Date* p1,Date* p2){return *p1<*p2;}};
#include"priority_queue.h"int main()
{bit::priority_queue<Date> q1;q1.push(Date(2018, 10, 29));q1.push(Date(2018, 10, 28));q1.push(Date(2018, 10, 30));cout << q1.top() << endl;q1.pop();cout << q1.top() << endl;q1.pop();cout << q1.top() << endl;q1.pop();cout << endl;// 1、类类型不支持比较大小// 2、支持比较大小，但是比较的逻辑不是你想要的// 需要自己实现仿函数//bit::priority_queue<Date*, vector<Date*>, DateLess> q2;bit::priority_queue<Date*> q2;q2.push(new Date(2018, 10, 29));q2.push(new Date(2018, 10, 28));q2.push(new Date(2018, 10, 30));cout << *q2.top() << endl;q2.pop();cout << *q2.top() << endl;q2.pop();cout << *q2.top() << endl;q2.pop();bit::priority_queue<int*> q3;q3.push(new int(2));q3.push(new int(1));q3.push(new int(3));cout << *q3.top() << endl;q3.pop();cout << *q3.top() << endl;q3.pop();cout << *q3.top() << endl;q3.pop();return 0;
}3.非类型模板参数
非类型形参，用常量作为类模板的一个参数，宏是写死的，而这个可以传参改变这个常量，只能用整型，后面的版本可以支持double。下面就是给N赋值为10，然后在类里面创建数组a，有N也就是10个。在主函数创建类型a时需要用<>尖括号，里面可以写参数，不写就是默认参数。(bool也是整型)
template<size_t N=10>
class a
{int a[N];
};int main()
{a<> v;a<1> a;return 0;
} 
3.array，静态数组和vector
静态数组越界读不会出问题，int arr[10]={0}，则10和11是判断释放越界的(10和11是索引)，如果改变了这俩个就会报错，但如果是后面的12 13 14等就写就不会报错了，因为标志位只有那俩个C++提供的array有强制检查，写和读都不可以，例如[]重载时，会检查是否越界了。区别：array数据在栈上，vector是在堆上，栈开空间比堆效率高。对比静态数组有强制检查，对比vector则是数据在栈上。（数据结构的栈跟栈(栈区 堆区)的工作原理一样，后进先出）
int main()
{// 栈array<int, 10> a1;array<int, 100> a2;int a3[10];// 越界检查的问题// 静态数组，抽查// 越界读不检查，越界写抽查cout << a3[10] << endl;//a3[10] = 10;//a3[11] = 10;a3[12] = 10;a3[20] = 10;// array越界读写都可以检查//a1[10];//a1[12] = 10;// 堆vector<int> v(100, 1);cout << sizeof(a2) << endl;cout << sizeof(v) << endl;//不管v的元素多少，大小都是固定的，私有成员变量都是迭代器指向头和尾巴还有容量大小return 0;
}
4.模板的特化
概念：通常情况下，使用模板参数可以实现一些与类型无关的代码，但对于一些特殊类的可能会得到一些错误的结果，这些需要特殊处理，写一个专门的应对这些。
函数模板特化步骤
1.必须要有一个基础的函数模板
2.关键字template后面接一个空的<>
3.函数名后面跟一个<>，<>里面是需要特化的类型
3.函数形参表：必须要和模板函数的基础参数类型完全相同
在下面的比较中，比较大小只有不是指针时才可以得到准确的答案，而参数为指针时就比较不出来，所以需要写一个特殊的函数来，因此需要特化一个出来，当为指针时要比较的是指针指向的对象的大小，所以要在写个*x<*y的。还需要知道的是，如果有const的存在时需要判断在T为实例化时const修饰的是哪一个对象，因为const Date* x则const修饰的是x指针指向的内容，Date* const x则const修饰的是x这个指针而不是指向的内容，比如const T& left在未实例化时，T const& left与const T& left是一样的，这时候const修饰的是left(前一局话和这句没有关系，顺便提一下而已),所以在下面特化时也要把这个"天生的const"去修饰x，有时候特化的类型也会带const，只要记住这点就不会因为多加的const而混淆，要区分天生的和外加的const。
// 函数模板 -- 参数匹配
template<class T>
//bool LessFunc(T const & left, T const & right)
bool LessFunc(const T& left, const T& right)
{return left < right;
}// 特化
//template<>
//bool LessFunc<const Date*>(const Date* const& left, const Date* const& right)
//{
// return *left < *right;
//}
//
//template<>
//bool LessFunc<Date*>(Date* const& left, Date* const& right)
//{
// return *left < *right;
//}// 推荐
//bool LessFunc(const Date* left, const Date* right)
//{
// return *left < *right;
//}
//
//bool LessFunc(Date* left, Date* right)
//{
// return *left < *right;
//}int main()
{cout << LessFunc(1, 2) << endl; // 可以比较，结果正确Date d11(2022, 7, 7);Date d22(2022, 7, 8);cout << LessFunc(d11, d22) << endl; // 可以比较，结果正确Date* p1 = &d11;Date* p2 = &d22;cout << LessFunc(p1, p2) << endl; // 可以比较，结果错误const Date* p3 = &d11;const Date* p4 = &d22;cout << LessFunc(p3, p4) << endl; // 可以比较，结果错误const int i = 0;int const j = 0;const int& rx = i;int const& ry = i;return 0;
}
2.特化的其它应用
全特化以及半特化
全特化是把参数全部确定好
半特化是有确定的也有为确定的
先创建一个模板有俩个参数，然后把俩个参数确定为int和char，第二个是第一个不确定要接受，而第二个确定为char。第三个比较特殊，是半特化，只要是指针就会走这个，引用也可以实用性高于前面几个，注意当面对符合半特化和全特化的要求时，会优先去走全特化的而不是半特化。
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 T1>
class Data<T1, char>
{
public:Data() { cout << "Data<T1,char>" << endl; }};
template<typename T1,typename T2>
class Data<T1*, T2*>
{
public:Data(){cout << "Data<T1*,T2*>" << endl;}
3.特化类型是原类型
比如Data(int*,int&)，那么T1是int*，T2是int&吗？其实不是，这里T1是原类型也就是int，T2也是原类型int，下面代码可以测试，当写T1 x=&x是会报错的，因为int x=&x是不对的，剩下的可以自行测试。
template <typename T1, typename T2>
class Data <T1&, T2*>
{
public:Data(){cout << "Data<T1&, T2*>" << endl;int a = 0;T1& x = a;T2* y = &a;T1 z = a;cout << typeid(x).name() << endl;cout << typeid(y).name() << endl;}void Push(const T1& x){}
};int main()
{Data<int, int> d1;Data<int, char> d2;Data<int, double> d3;Data<char, double> d4;Data<char, char> d5;Data<char*, char*> d6;Data<int*, char*> d7;Data<int&, char&> d8;//Data<int&, double&> d9;Data<int&, int*> d10;return 0;
}5.模板定义和声明不能分离
预处理会把报的头文件都展开，定义的宏都替换掉，编译会去检查代码的语法，然后生成汇编代码，汇编是会把代码转成二进制机器码以便CPU识别和执行，最后链接会把目标文件集合在一起生成可执行程序，并把需要的函数地址都链接上，所有函数会会都记录在一个表上，当在其它地方声明时链接会到这里去找到对应的函数来匹配。
模板不可以是因为在未实例化时它是不会生成地址的，声明了模板后前面不会出问题，但到了链接就会报错了，因为要去符号表找对应函数但是因为没有实例化是没有地址找不到对应的函数，则就报错了，所以写模板定义和声明就写在头文件就可以了。
6.总代码
test.cpp
#include<iostream>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<algorithm>
#include<array>
using namespace std;template<size_t N=10>
class a
{int a[N];
};
class Date
{friend ostream& operator<<(ostream& _cout, const Date& d);
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}bool operator<(const Date& d)const{return (_year < d._year) ||(_year == d._year && _month < d._month) ||(_year == d._year && _month == d._month && _day < d._day);}bool operator>(const Date& d)const{return (_year > d._year) ||(_year == d._year && _month > d._month) ||(_year == d._year && _month == d._month && _day > d._day);}
private:int _year;int _month;int _day;
};ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout;
}class DateLess
{
public:bool operator()(Date* p1, Date* p2){return p1 < p2;}
};#include"priority_queue.h"//int main()
//{
// bit::priority_queue<Date> q1;
// q1.push(Date(2018, 10, 29));
// q1.push(Date(2018, 10, 28));
// q1.push(Date(2018, 10, 30));
// cout << q1.top() << endl;
// q1.pop();
//
// cout << q1.top() << endl;
// q1.pop();
//
// cout << q1.top() << endl;
// q1.pop();
//
// cout << endl;
//
// // 1、类类型不支持比较大小
// // 2、支持比较大小，但是比较的逻辑不是你想要的
// // 需要自己实现仿函数
//
// //bit::priority_queue<Date*, vector<Date*>, DateLess> q2;
// bit::priority_queue<Date*> q2;
// q2.push(new Date(2018, 10, 29));
// q2.push(new Date(2018, 10, 28));
// q2.push(new Date(2018, 10, 30));
// cout << *q2.top() << endl;
// q2.pop();
//
// cout << *q2.top() << endl;
// q2.pop();
//
// cout << *q2.top() << endl;
// q2.pop();
//
// bit::priority_queue<int*> q3;
// q3.push(new int(2));
// q3.push(new int(1));
// q3.push(new int(3));
//
// cout << *q3.top() << endl;
// q3.pop();
//
// cout << *q3.top() << endl;
// q3.pop();
//
// cout << *q3.top() << endl;
// q3.pop();
//
//
// return 0;
//}// 函数模板 -- 参数匹配
template<class T>
//bool LessFunc(T const & left, T const & right)
bool LessFunc(const T& left, const T& right)
{return left < right;
}// 特化
//template<>
//bool LessFunc<const Date*>(const Date* const& left, const Date* const& right)
//{
// return *left < *right;
//}
//
//template<>
//bool LessFunc<Date*>(Date* const& left, Date* const& right)
//{
// return *left < *right;
//}// 推荐
//bool LessFunc(const Date* left, const Date* right)
//{
// return *left < *right;
//}
//
//bool LessFunc(Date* left, Date* right)
//{
// return *left < *right;
//}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 T1>
class Data<T1, char>
{
public:Data() { cout << "Data<T1,char>" << endl; }};
template<typename T1,typename T2>
class Data<T1*, T2*>
{
public:Data(){cout << "Data<T1*,T2*>" << endl;}};
int main()
{cout << LessFunc(1, 2) << endl; // 可以比较，结果正确Date d11(2022, 7, 7);Date d22(2022, 7, 8);cout << LessFunc(d11, d22) << endl; // 可以比较，结果正确Date* p1 = &d11;Date* p2 = &d22;cout << LessFunc(p1, p2) << endl; // 可以比较，结果错误const Date* p3 = &d11;const Date* p4 = &d22;cout << LessFunc(p3, p4) << endl; // 可以比较，结果错误const int i = 0;int const j = 0;const int& rx = i;int const& ry = i;return 0;
}int main()
{Data<int, int> d1;Data<int, char> d2;Data<int, double> d3;Data<char, double> d4;Data<char, char> d5;Data<char*, char*> d6;Data<int*, char*> d7;Data<int&, char&> d8;Data<int&, double&> d9;Data<int&, int*> d10;return 0;
}priority_queue
#pragma once#pragma once#include<vector>template<class T>
class Less
{
public:bool operator()(const T& x, const T& y){return x < y;}
};// 特化
//template<>
//class Less<Date*>
//{
//public:
// bool operator()(Date* const & x, Date* const& y)
// {
// return *x < *y;
// }
//};template<class T>
class Less<T*>
{
public:bool operator()(T* const& x, T* const& y){return x < y;}
};template<class T>
class Greater
{
public:bool operator()(const T& x, const T& y){return x > y;}
};namespace bit
{// 默认是大堆template<class T, class Container = vector<T>, class Compare = Less<T>>class priority_queue{public:void AdjustUp(int child){Compare com;int parent = (child - 1) / 2;while (child > 0){//if (_con[parent] < _con[child])if (com(_con[parent], _con[child])){swap(_con[child], _con[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}void push(const T& x){_con.push_back(x);AdjustUp(_con.size() - 1);}void AdjustDown(int parent){// 先假设左孩子小size_t child = parent * 2 + 1;Compare com;while (child < _con.size()) // child >= n说明孩子不存在，调整到叶子了{// 找出小的那个孩子//if (child + 1 < _con.size() && _con[child] < _con[child + 1])if (child + 1 < _con.size() && com(_con[child], _con[child + 1])){++child;}//if (_con[parent] < _con[child])if (com(_con[parent], _con[child])){swap(_con[child], _con[parent]);parent = child;child = parent * 2 + 1;}else{break;}}}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();AdjustDown(0);}const T& top(){return _con[0];}size_t size() const{return _con.size();}bool empty() const{return _con.empty();}private:Container _con;};
}
