参考比特就业课的资料：
Lesson06---模板初阶
泛型编程；
模板函数的写法；
//专门处理int的加法函数
int Add(int left,int right){
return left + right;
}
//通用加法函数
template<class T1,class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test(){
Add(1,2);//与非函数模板类型完全匹配，不需要函数模板实例化
Add(1,2.0);//函数模板可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
//模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
}类模板：
//template<class T1,class T2,...,class Tn>
// class 类模板名
// {
// 类内成员定义
// }
//动态顺序表
//注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:
Vector(size_t _capacity = 10)
:_pData(new T[capacity])
,_size(0)
,_capacity(capacity)
{}
//使用析构函数演示：在类中声明，在类外定义
~Vector();
void PushBack(const T& data);
void PopBack();
//...
size_t Size(){return _size;}
T& operator[](size_t pos){
assert(pos < _size);
return _pData[pos];
}
private:
T* _pData;
size_t _size;
size_t _capacity;
};
//注意：类模板中函数放在类外定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
if(_pData)
delete[] _pData;
_size=_capacity=0;
}
int main(){
//类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，
//然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类
Vector<int> s1;
//Vector类名 Vector<int>才是类型
cout<< "hellp world"<<endl;
return 0;
}Lesson07---STL简介
STL六大组件：仿函数（greater、less...）;算法（find、swap、reverse、sort、merge...）;
迭代器（iterator、const_iterator、reverse_iterator、const_reverse_iterator）;
空间配置器（allocator）;容器（string、vector、list、deque、map、set、multimap、multiset）；
配接器（stack、queue、priority_queue）
Lesson08---string
class String
{
public:
String(const char* str = "")
{
//构造String类对象时，如果传递nullptr指针，可以认为程序非
if(nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str)+1];
strcpy(_str,str);
}
String(const String& s)
: _str(new char[strlen(s._str)+1])
{
strcpy(_str,s._str);
}
String& operator=(const String& s)
{
if(this != &s)
{
char* pStr = new char[strlen(s._str) + 1];
strcpy(pStr,s._str);
delete[] _str;
_str = pStr;
}
return *this;
}
~String()
{
if(_str)
{
delete[] _str;
_str =nullptr;
}
}
private:
char* _str;
};现代版写法的String类
class String
{
public:
String(const char* str="")
{
if(nullptr==str)
{
assert(false);
return;
}
_str = new char[strlen(str)+1];
strcpy(_str,str);
}
String(const String& s)
:_str(nullptr)
{
String strTmp(s._str);
swap(_str,strTmp._str);
}
//对比下和上面的赋值那个比较好？
String& operator=(String s)
{
swap(_str,s._str);
return *this;
}
// String& operator=(const String& s)
// {
// if(this != &s)
// {
// char* pStr = new char[strlen(s._str) + 1];
// strcpy(pStr,s._str);
// delete[] _str;
// _str = pStr;
// }
// return *this;
// }
~String()
{
if(_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};Lesson09---vector
1.vector是表示可变大小数组的序列容器，和数组一眼，vector也采用的连续存储空间来存储元素，意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态变化的，而且它的大小会被容器自动处理。
vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的储存空间更大。不同的库采用不同的策略。但是重新分配都是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。与其他动态容器比（deque list forward_list），vector在访问元素时、末尾增删元素相对高效。对于其他不在末尾的插入和删除，效率更低。
vector()无参构造
vector（size_type n, const value_type val = value_type()）构造并初始化n个val
vector(const vector& x) 拷贝构造
vector(InputIterator first, InputIterator last) 使用迭代器进行初始化构造
size 获取数据个数； capacity 获取容量大小； empty 判断是否为空；
resize 改变vector的size； reserve 改变vector的capacity
vs下capacity是按1.5倍增长的，g++是按2倍增长的。(vs是PJ版本STL, g++是SGI版本STL).
reserve 只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代码缺陷问题。
resize 在开空间的同时还会初始化，影响size.
//测试vector的默认扩容机制
void TestVectorExpand()
{
size_t sz;
vector<int> v;
sz=v.capacity();
cout<<"making v grow:\n";
for(int i=0;i<100;i++)
{
v.push_back(i);
if(sz!=v.capacity())
{
sz=v.capacity();
cout<<"capacity changed: "<< sz<<'\n';
}
}
}vs运行结果：vs下使用的STL基本是按照1.5倍方式扩容
1 2 3 4 6 9 13 19 28 42 63 94 141
g++运行结果：linux下使用的STL基本是按照2倍方式扩容
1 2 4 8 16 32 64 128
如果已经确定vector中药存储元素大概个数，可以提前将空间设置足够，就可以避免边插入边扩容导致效率低下的问题了
void TestVectorExpandOP()
{
vector<int> v;
size_t sz=v.capacity();
v.reserve(100);//提前将容量设置好，可以避免一边插入一边扩容
cout<<"making bar grow:\n";
for(int i=0;i<100;i++)
{
v.push_back(i);
if(sz!=v.capacity())
{
sz=v.capacity();
cout<<"capacity changed: "<< sz << '\n';
}
}
}vector增删查改： push_back() ---- 尾插； pop_back(); ----尾删； find ---查找（这个是算法模块实现，不是vector的成员接口； insert ----在position之前插入val;
erase ---删除position位置的数据； swap --交换两个vector的数据空间；
operator[] -----像数组一样访问
1.2.4 vector迭代器失效问题
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T*. 迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃（如果继续使用已经失效的迭代器，程序可能会崩溃）
对于vector可能导致迭代器失效的操作有：
1.会引起其底层空间改变的操作，都有可能使迭代器失效 。比如：resize 、revserve 、insert、assign、push_back等。
#include<iostream>
using namespace std;
#include<vector>
int main()
{
vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
//将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
//v.resize(100,8)；
//reserve的作用就是改变扩容大小但是不改变有效元素个数，操作期间可能会引起底层容量改变
//v.reserve(100);
//插入元素期间，可能会引起扩容，而导致原空间被释放
//v.insert(v.begin(),0);
//v.push_back(8);
//给vector重新赋值，可能会引起底层容量改变
v.assign(100,8);
/*
出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之前的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
*/
while(it ! = v.end())
{
cout << *it<< " ";
it++;
}
cout<<endl;
return 0;
}
2.指定位置元素的删除操作--erase
#include<iostream>
using namespace std;
#include<vector>
int main()
{
int a[] = {1,2,3,4};
vector<int> v(a,a+sizeof(a)/sizeof(int));
//起始地址，末尾的下一个地址， v将包含从数组a开始的所有元素，直到数组的末尾
//使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(),v.end(),3);
//删除pos位置的数据，导致pos迭代器失效
v.erase(pos);
cout<<*pos<<endl;
return 0;
}int main(){
vector<int> v{1,2,3,4};
auto it = v.begin();
while(it !=v.end()){
// 错误做法如下：
// if(*it %2 == 0 )
// v.erase(it);
// ++it;
//正确做法为：
if(*it %2 == 0)
it = v.erase(it);
else
++it;
}
}3.Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没用vs下极端
//1.扩容之后，迭代器已经失效，程序虽然可以运行，但是运行结果已经不对来
int main(){
vector<int> v{1,2,3,4,5};
for(size_t i=0;i<v.size();i++)
cout<<v[i]<<" ";
cout<<endl;
auto it = v.begin();
cout<<"扩容之前,vector的容量为: "<<v.capacity()<<endl;
//通过reserve将底层空间设置为100，目的是为了让vector迭代器失效
v.reserve(100);
cout<<"扩容之后,vector的容量为: "<<v.capacity()<<endl;
//经过上述reserve之后，it迭代器肯定会失效，在VS下程序就直接崩溃了，但是linux下不会
//虽然可以运行，但是输出结果是不对的
while(it!= v.end())
{
cout<<*it<<" ";
it++;
}
cout<<endl;
return 0;
}
程序输出：
1 2 3 4 5
扩容之前，vector的容量为： 5
扩容之后，vector的容量为： 100
0 2 3 4 5 409 1 2 3 4 5
//2.erase删除任意位置代码后，Linux下迭代器并没有失效
//因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
#include<vectro>
#include<algorithm>
int main()
{
vector<int> v{1,2,3,4,5};
vector<int>::iterator it = find(v.begin(),v.end(),3);
v.erase(it);
cout<< *it <<endl;
while(it !=v.end())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
return 0;
}
程序可以正常运行，并打印
4
4 5
//3.erase删除的迭代器如果是最后一个元素，删除之后it已经超过end
//此时迭代器无效，++it导致程序崩溃
int main()
{
vector<int> v{1,2,3,4,5};
//vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
while(it !=v.end())
{
if(*it %2 == 0)
v.erase(it);
++it;
}
for(auto e:v)
cout<< e <<" ";
cout<<endl;
return 0;
}
使用第一组数据时，程序可以运行
1 3 5
使用第二组数据时，程序最终会崩溃从上述三个例子中可以看到：SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的
4.与vector类似，String在插入+扩容操作+erase之后，迭代器也会失效
#include<string>
void TestString()
{
string s("hello");
auto it =s.begin();
//放开之后代码会崩溃，因为resize到20string会进行扩容
//扩容之后，it指向之前旧空间已经被释放掉，该迭代器就失效了
//后续打印时，再访问it指向的空间程序就是崩溃
//s.resize(20,'!');
while(it !=s.end())
{
cout<<*it;
++it;
}
cout<<endl;
it=s.begin();
while(it!=s.end())
{
it=s.erase(it)
//按照下面方式写，运行程序就会崩溃，因为earse(it)之后
//it位置的迭代器就失效了
//s.erase(it);
++it;
}
}迭代器解决办法：在使用前，对迭代器重新赋值即可。
class Solution{
public:
int singleNumber(vector<int>& nums){
int value = 0;
for(auto e:nums){value^=e; }
return value;
}
};
//异或运算满足交换律和结合律。
//任何数和0进行异或运算，结果仍然是原数，即 x ^ 0 = x。
//任何数和其自身进行异或运算，结果是0，即 x ^ x = 0。杨辉三角OJ
//涉及resize / operator[]
//核心思想：找出杨辉三角的规律，发现每一行头尾都是1，中间第[j]个数等于上一行[j-1]+[j]
class Solution{
public:
vector<vector<int>> generate(int numRows){
vector<vector<int>> vv(numRows);
for(int i=0;i<numRows;++i)
{
vv[i].resize(i+1,1);
}
for(int i=2;i<numRows;++i)
{
for(int j=1;j<i;++j)
{
vv[i][j] = vv[i-1][j] + vv[i-1][j-1];
}
}
return vv;
}
};总结：通过上面的练习我们发现vector常用的接口更多是插入和遍历。遍历更喜欢用数组operator[i]的形式访问，因为这样便捷。
2.vector深度剖析及模拟实现
memcpy: 如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。
Lesson10---list
1.list的介绍及使用
list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代
list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素
list与forward_list相似：只是forward_list是单链表，只能朝前迭代，以让其更简单高效
与其他序列式容器相比（array，vector，deque）,list通常在任意位置进行插入、移除元素的执行效率更好，但是list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，就必须从已知的位置（比如头部或者尾部）迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息
构造函数
list(size_type n,const value_type& val = value_type()) 构造的list中包含n个值为val的元素
list() 构造空的list
list(const list& x) 拷贝构造函数
list(InputIterator first,InputIterator last) 用 [first,last)区间中的元素构造list
list iterator 可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。
list capacity
empty: 检测list是否为空，是返回true，否则返回false
size: 返回list中有效节点的个数
list element access
front: 返回list的第一个节点中值的引用
back: 返回list的最后一个节点中值的引用
list modifiers
push_front: 在list首元素前插入值为val的元素 pop_front: 删除list中第一个元素
push_back: 在list尾部插入值为val的元素 pop_bakc: 删除list中最后一个元素
insert: 在list position位置中插入值为val的元素 erase: 删除list position位置的元素
swap: 交换两个list中的元素 clear: 清空list中的有效元素
1.2.6 list的迭代器失效
#include<bits/stdc++.h>
using namespace std;
void TestListIterator1()
{
int array[] = {1,2,3,4,5,6,7,8,9,0};
list<int> l(array,array+sizeof(array)/sizeof(array[0]));
auto it = l.begin();
while(it != l.end())
{
//erase()函数执行后，it所指向的节点已被删除，因此it无效，
//在下一次使用it时，必须先给其赋值
l.erase(it);
++it;
}
}
//改正
void TestListIterator()
{
int array[] = {1,2,3,4,5,6,7,8,9,0};
list<int> l(array,array+sizeof(array)/sizeof(array[0]));
auto it = l.begin();
while(it != l.end())
{
l.erase(it++); // it=l.erase(it);
}
//使用 list.erase(it++)：
// 这种方法使用了后置递增运算符 it++。
// 当 erase 被调用时，它删除 it 当前指向的元素。
// 由于是后置递增，it 在 erase 调用执行完毕后递增，因此 it 将指向下一个元素。
// 使用 it = list.erase(it);：
// 这种方法在删除元素后，将 erase 返回的迭代器赋值给 it。
// erase 函数返回指向被删除元素之后元素的迭代器。
// 然后将这个返回的迭代器赋给 it，确保 it 指向正确的下一个元素。
}list的反向迭代器
template<class Iterator>
class ReverseListIterator
{
//注意：此处typename的作用是明确告诉编译器，Ref是Iterator类中的类型，而不是静态成员变量
//否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量
//因为静态成员变量也是按照 类名：：静态成员变量名 的方式访问的
public:
typedef typename Iterator::Ref Ref;
typedef typename Iterator::Ptr Ptr;
typedef ReverseListIterator<Iterator> Self;
private:
//
// 构造
ReverseListIterator(Iterator it):_it(it){}
//
// 具有指针类似行为
Ref operator*(){
Iterator temp(_it);
--temp;
return *temp;
}
Ptr operator->(){ return &(operator*());}
//
// 迭代器支持移动
Self& operator++(){
--_it;
return *this;
}
Self operator++(int){
Self temp(*this);
--_it;
return temp;
}
Self& operator--(){
++_it;
return *this;
}
Self& operator--(int){
Self temp(*this)
++_it;
return temp;
}
// 迭代器支持比较
bool operator!=(const Self& l)const{ return _it != l.it;}
bool operator==(const Self& l)const{ return _it == l.it;}
Iterator _it;
};
前置形式（++it）
先递增迭代器，然后返回递增后的迭代器
后置形式（it++）
先创建当前迭代器的一个副本，然后递增副本中的迭代器。
返回的是迭代器副本，而不是原始迭代器
假设有一个迭代器 it 指向数组中的元素3：使用++it 后，it将指向下一个元素4，并且 it仍然是同一个迭代器； 使用temp = it++;后，temp将保存it 递增前的副本，即指向元素3，而it 本身将指向元素4。
Ref 这是迭代器指向元素的引用类型。在C++中，但*iter 就是元素的引用。如果iter指向一个int类型的数组，那么Ref 就是 int& 类型
Ptr 迭代器指向元素的指针类型，&*iter获取迭代器指向元素的地址，就是Ptr类型。Ptr是 Ref的指针版本
_it 是反向迭代器，它实际上指向的是容器末尾之后的某个位置（在标准库中，反向迭代器通常指向它们所基于的迭代器之后的位置）。因此，如果我们直接解引用
_it，我们会得到末尾元素之后的元素，这显然是错误的。所以operator*()中要前移一个位置
//假设我们有一个ReverseListIterator的实例revIter,指向一个列表的末尾：
ReverseListIterator<SomeIterator> revIter(end);
//Ref: 如果SomeIterator指向一个 int 类型的元素，那么Ref就是 int&类型
//相应的 Ptr将是int*类型，即指向 int的指针
//Self就是ReverseListIterator<SomeIterator>的类型
//this :如果我们在ReveserListIterator的成员函数内部，this将指向revIter本身
//it: revIter的一个私有成员，存储了迭代器当前的位置与vector相比：
Lesson11---stack和queue
1.stack的介绍和使用
stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，删除只能从容器的一端进行元素的插入与提取操作。（容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出）。
stack的底层容器可以使任何标准的容器类模板或者一起其他特定的容器类，这些容器类应该支持以下操作：empty(判空） back(获取尾部元素) push_back(尾部插入元素) pop_back(尾部删除元素)
标准容器vector\deque\list 均符合这些要求，默认情况下，如果没有为stack指定特定的底层容器，使用deque
stack() 构造空的栈； empty() 检测stack是否为空； size() 返回stack中元素的个数
top() 返回栈顶元素的引用； push() 将元素val压入stack中； pop() 将stack中尾部元素弹出
最小栈
class MinStack
{
public:
void push(int x)
{
//只要是压栈，先将元素保存到_elem中
_elem.push(x);
//如果x < _min中栈顶的元素，将x再压入_min中
if(_min.empty() || x<=_min.top())
_min.push(x);
}
void pop()
{
//如果_min栈顶的元素等于出栈的元素，_min顶的元素要移除
if(_min.top() == _elem.top())
_min.pop();
_elem.pop();
}
int top(){return _elem.top();}
int getMin(){return _min.top();}
private:
//保存栈中的元素
std::stack<int> _elem;
//保存栈中的最小值
std::stack<int> _min;
};栈的弹出压入序列
class Solution{
public:
bool IsPopOrder(vector<int> pushV,vector<int> popV){
//入栈和出栈的元素个数必须相同
if(pushV.size() != pop.size())
return false;
//用s来模拟入栈和出栈的过程；
int outIdx = 0;
int inIdx = 0;
stack<int> s;
while(outIdx < popV.size()) //使用一个循环来遍历 popV，直到所有元素都被检查完毕
{
//如果s是空，或者栈顶元素与出栈元素不相等，就入栈
while(s.empty() || s.top() != popV[outIdx])
{
if(inIdx < pushV.size())//
s.push(pushV[inIdx++]);
// 如果 inIdx 还没有到达 pushV 的末尾，
// 将 pushV 中的当前元素压入栈 s，并将 inIdx 向前移动
else
return false;
// 如果 inIdx 已经到达 pushV 的末尾，
// 但栈顶元素与 popV 中的当前元素还不匹配，说明序列不匹配，返回 false。
}
//栈顶元素与出栈元素相等，出栈
s.pop();
outIdx++;
}
return true;
}
};逆波兰表达式求值：
class Solution{
public:
int evalRPN(vector<string>& tokens){
stack<int> s;
for(size_t i=0;i<tokens.size();++i)
{
string& str = tokens[i];
//str为数字
if(!("+"==str || "-"==str || "*"==str || "/"==str))
{
s.push(atoi(str.c_str()));
//atoi 是一个 C 语言标准库函数，用于将字符串转换为整数。它读取一个以空字符终
//止的字符数组（即 C 风格的字符串），并返回一个整数值。
}
else{
//str为操作符
int right = s.top();
s.pop();
int left=s.top();
s.pop();
switch (str[0])
{
case '+'/* constant-expression */:
s.push(left+right);/* code */
break;
case '-':
s.push(left-right);
break;
case '*':
s.push(left*right);
break;
case '/':
s.push(left/right);
break;
}
}
}
return s.top();
}
};stack的模拟实现
从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack
#include<vector>
namespace bite
{
template<class T>
class stack
{
public:
stack(){}
void push(const T& x){ _c.push_back(x);}
void pop(){ _c.pop_back();}
T& top() {return _c.back();}
const T& top()const {return _c.back();}
size_t size()const {return _c.size();}
bool empty()const {return _c.empty();}
private:
std::vector<T> _c;
};
}2.queue的介绍和使用
和stack一样，也是容器适配器，专门用于FIFO上下文（先进先出）中操作，从容器一端插入元素，另一端提取元素。
容器适配器即将特定容器类封装作为其底层容器类。queue元素从队尾入队列，从队头出队列。
标准容器类deque和list 满足queue接口的要求，默认情况下，使用deque
queue() 构造空的队列； empty() 检测队列是否为空，是返回true，否则返回false
size() 返回队列中有效元素的个数； front() 返回队头元素的引用； back()返回队尾元素引用
push() 在队尾将元素val入队列; pop(); 将队头元素除队列
queue的模拟实现
#include<list>
namespace bite
{
template<class T>
class queue
{
public:
queue() {}
void push(const T& x) {_c.push_back(x);}
void pop(){_c.pop_back();}
T& back(){return _c.back();}
const T& back()const{return _c.back();}
T& front(){return _c.front();}
const T& front()const{return _c.front();}
size_t size()const{return _c.size();}
bool empty()const {return _c.empty();}
private:
std::list<T> _c;
}
};3.priority_queue的介绍和使用
优先队列是一种容器适配器，根据严格的弱排序标准，第一个元素综述最大的。
此上下文类似堆stack，在堆中可以随时插入元素，并且只能检索最大堆元素（优先队列中位于顶部的元素）。元素从特定容器的“尾部”弹出，气层为优先队列的顶部
标准容器类vector和deque满足，默认情况下，使用vector
需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来完成此操作。
priority_queue() /priority_queue() 构造一个空的优先级队列；
empty() 检测优先级队列是否为空； top() 返回优先级队列中最大（最小元素），即堆顶元素
push(x) 在优先级队列中插入元素x pop() 删除优先级队列中最大（最小）元素，即堆顶元素
1.默认情况下，priority_queue是大堆
#include<vector>
#include<queue>
#include<functional> // greater算法的头文件
using namespace std;
void TestPriorityQueue()
{
//默认情况下，创建的是大堆，其底层按照小于号比较
vector<int> v{3,2,7,6,0,4,1,9,8,5};
priority_queue<int> q1;
for(auto& e:v){
q1.push(e);}
cout<<q1.top()<<endl;
//如果要创建小堆，将第三个模板参数改成greater比较方式
priority_queue<int,vector<int>,greater<int>> q2(v.begin(),v.end());
cout<<q2.top()<<endl;
}2.如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供>或者<的重载。
class Date
{
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);
}
friend ostream& operator<<(ostream& _cout, const Date& d)
{
_cout<<d._year<<"-"<<d._month<<"-"<<d._day;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
void TestPriorityQueue()
{
//大堆，需要用户在自定义类型中提供<的重载
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;
//如果要创建小堆，需要提供 >号的重载
priority_queue<Date,vector<Date>,greater<Date>> q2;
q2.push(Date(2018,10,29));
q2.push(Date(2018,10,28));
q2.push(Date(2018,10,30));
cout<<q2.top()<<endl;
}
3.3 在OJ中使用
数组中第K个大的元素：优先级队列，然后将前k-1个元素删除掉
4.容器适配器
想象一下，你有一个电器，它的插头是三脚的，但你的插座是两脚的。为了让这个电器能够在你的插座上工作，你需要一个适配器，它可以把三脚插头转换成两脚插头。在软件设计中，适配器模式扮演着类似的角色，它"适配"一个接口，使其能够与另一个接口兼容。
STL标准库中的stack和queue的底层结构
虽然stack和queue也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为“容器适配器”，这是因为stack queue只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque,比如：
deque（双端队列）：是一种 双开口的“连续”空间的数据结构，即可以在头尾两端进行插入和删除操作，且时间复杂度为O(1),与vector比较，头插效率高，不需要搬移元素；与list相比，空间利用率比较高。
deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组。
与vector相比，deque的优势在于：头插和头删，不需要搬移元素，效率特别高，而且在扩容时也不需要搬移大量的元素，移除效率比vector高
与list相比，其底层是连续空间，空间利用率高，不需要存储额外字段
但是，deque不适合遍历：因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际时，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。
除了deque有stack和queue需要操作的线性结构外，STL中对stack和queue默认选择deque作为其底层容器主要是因为：
1.stack和queue不需要遍历（因此stack和queue没有迭代器），只需要在固定的一段或者两端操作
2.在stack中元素增长时，deque比vector的效率高（扩容时不需要大量搬移）；queue中元素增长时，deque不仅效率高，而且内存使用率高
模拟实现：
#include<deque>
namespace bite
{
template<class T,class Con=deque<T>>
// template<class T,class Con=vector<T>>
// template<class T,class Con=list<T>>
class stack
{
public:
stack(){}
void push(const T& x){_c.push_back(x);}
void pop(){_c.pop_back();}
T& top(){return _c.back();}
const T& top()const{return _c.back();}
size_t size()const{return _c.size();}
bool empty()const{return _c.empty();}
private:
Con _c;
};
template<class T,class Con=deque<T>>
// template<class T,class Con=vector<T>>
// template<class T,class Con=list<T>>
class queue
{
public:
queue(){}
void push(const T& x){_c.push_back(x);}
void pop(){_c.pop_back();}
T& back(){return _c.back();}
const T& back()const{return _c.back();}
T& front(){return _c.front();}
const T& front()const{return _c.front();}
size_t size()const{return _c.size();}
bool empty()const{return _c.empty();}
private:
Con _c;
};
}Lesson12---模版进阶
1.非类型模版参数
模板参数分 类型形参与非类型形参
类型形参：出现在模版参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参：就是用一个常量作为类（函数）模版的一个参数，在类（函数）模版中可将该参数当成常量来使用。
namespace bite
{
template<class T, size_t N =10>
class array
{
public:
T& operator[](size_t index){return _array[index];}
const T& operator[](size_t index)const{return _arary[index];}
size_t size()const{return _size;}
bool empty()const{return 0==_size;}
private:
T _array[N];
size_t _size;
};
}注意：1.浮点数、类对象以及字符串不允许作为非类型模版参数
2,非类型的模版参数必须在编译期就能确认结果
2.模板的特化
通常情况下，使用模版可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结论，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模版
//函数模版 -- 参数匹配
template<class T>
bool Less(T left,T right)
{
return left<right;
}
int main(){
cout<<Less(1,2)<<endl;//可以比较，结果正确
Date d1(2022,7,7);
Date d2(2022,7,8);
cout<<Less(d1,d2)<<endl;//可以比较，结果正确
Date* p1=&d1;
Date* p2=&d2;
cout<<Less(p1,p2)<<endl;//可以比较，但是结果错误
return 0;
}可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。
此时，就需要对模版进行特化，即：在原模版类的基础上，针对特殊类型所进行特殊化的实现方式
模版特化中分为函数模版特化与类模版特化
2。函数模版特化
函数模板的特化步骤：
1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
//函数模版 -- 参数匹配
template<class T>
bool Less(T left,T right)
{
return left<right;
}
//对Less函数模版进行特化
template<>
bool Less<Date*>(Date* left,Date* right)
{
return *left < *right;
}
int main(){
cout<<Less(1,2)<<endl;
Date d1(2022,7,7);
Date d2(2022,7,8);
cout<<Less(d1,d2)<<endl;
Date* p1=&d1;
Date* p2=&d2;
cout<<Less(p1,p2)<<endl;//调用特化之后的版本，而不走模版生成了
return 0;
}注意：一般情况下如果函数模版遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。
bool Less(Date* left,Date* right)
{
return *left<*right;
}这种思想简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模版，特化时特别给出，因此函数模版不建议特化。
3.类模版特化
3.1 全特化：即是将模版参数列表中所有的参数都确定化。
template<class T1,class T2>
class Data
{
public:
Data(){cout<<"Data<T1,T2>" <<endl;}
private:
T1 _d1;
T2 _d2;
};
template<>
class Date<int, char>
{
public:
Data(){cont<<"Data<int, char>"<<endl;}
private:
int _d1;
char _d2;
};
void TestVector()
{
Data<int, int>d1;
Data<int, char>d2;
}3.2.偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。
比如对于上述class T1,class T2的模板类
偏特化有以下两种表现方式：
·部分特化：将模版参数类表中的一部分参数特化
//将第二个参数转换为int
template<class T1>
class Data<T1,int>
{
public:
Data(){cout<<"Data<T1, int>"<<endl;}
private:
T1 _d1;
int _d2;
};·参数更进一步的限制：
偏特化并不仅仅是指特化部分参数，而是针对模版参数更进一步的条件限制所设计出来的一个特化版本。
//两个参数偏特化为指针类型
template<typename T1,typename T2>
class Data<T1*,T2*>
{
public:
Data(){cout<<"Data<T1*, T2*>"<<endl;}
private:
T1 _d1;
T2 _d2;
};
//两个参数偏特化为引用类型
template<typename T1,typename T2>
class Data<T1&,T2&>
{
public:
Data(const T1& d1, const T2& d2)
: _d1(d1)
, _d2(d2)
{cout<<"Data<T1&, T2&>"<<endl;}
private:
const T1& _d1;
const T2& _d2;
};
void test2()
{
Data<double, int>d1;//调用特化的int版本
Data<int,double>d2;//调用基础的版本
Data<int *,int*>d3;//调用特化的指针版本
Data<int&,int&>d4(1,2);//调用特化的引用版本
}3.3.类模版特化应用示例
有如下专门用来按照小于比较的类模版Less:
#include<vector>
#include<algorithm>
template<class T>
struct Less
{
bool operator()(const T& x,const T& y)const
{
return x<y;
}
};
int main()
{
Date d1(2022,7,7);
Date d2(2022,7,6);
Date d3(2022,7,8);
vector<Date> v1;
v1.push_back(d1);
v1.push_back(d2);
v1.push_back(d3);
//可以直接排序，结果是日期升序
sort(v1.begin(),v1.begin(),Less<Date>());
vector<Date*> v2;
v2.push_back(&d1);
v2.push_back(&d2);
v2.push_back(&d3);
//可以直接排序，但结果错误 日期不是升序，而v2中放的地址是升序
//此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
//但是走Less模版，sort在排序是实际比较的是v2中指针的地址，因此无法达到预期
sort(v2.begin(),v2.begin(),Less<Date>());
return 0;
}通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题:
template<>
struct Less<Date*>
{
bool operator()(Date* x,Date* y)const{
return *x < *y;
}
};3.模版分离编译：一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所以目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：
//a.h
template<class T>
T Add(const T& left, const T& right);
//a.cpp
template<class T>
T Add(const T& left, const T& right)
{
return left+right;
}
//main.cpp
#include"a.h"
int main()
{
Add(1,2);
Add(1.0,2.0);
return 0;
}分析：
推荐解决方法：将声明和定义放到一个文件"xxx.hpp"里面或者xxx.h其实也可以。
4.模版总结
优点：
1.模版复用了代码，节省资源，更快的迭代开发，C++的标准模版库(STL)因此而产生
2.增强了代码的灵活性
缺点：
1.模版会导致代码膨胀问题，也会导致编译时间变长
2.出现模版编译错误时，错误信息非常凌乱，不易定位错误
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
