一：什么是容器适配器;
二：通过适配器模式来实现stack(栈),queue（队列）;
三：STL库中的容器适配器（deque）;
四：优先级队列（priority_queue）;
五：仿函数（比较）;
//////
一：什么是容器适配器：
含义：适配器是一种设计模式；
(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，
该种模式是将一个类的接口转换成客户希望的另外一个接口；
比如：实现一个栈，但是栈又分为数组栈和链式栈，那么如何只用一个类，且只是轻微的改动 就能在两种栈之间来回转换呢？那么实现这种转换功能就是适配器模式存在的意义！
//////
二：通过适配器模式来实现stack(栈),queue（队列）：
如上述所言，栈分两种（数组栈与链式栈），那么我们如何来实现呢？
具体代码如下所示：
//通过vector/list实现栈：
namespace MKL
{
//通过适配器模式实现，模板给个容器名称，容器名称可以任意，给缺省值，缺省值是容器，在此默认实现数组形式的栈：
template<class T,class container=vector<T>>
class stack
{
public:
void push(const T& x)//进栈：
{
_st.push_back(x);//调用模板中的容器的尾插接口，
}
void pop()//出栈：
{
_st.pop_back();//调用模板中的容器的尾删接口，
}
const T& top()//获取栈顶元素：
{
return _st.back();//调用模板中的容器的尾获取尾部元素接口，
}
size_t size()//栈中元素个数;
{
return _st.size();//调用模板中的容器的获取元素个数接口；
}
bool empty()//判断栈是否为空：
{
return _st.empty();//调用模板中的容器的是否为空接口；
}
private:
//通过模板中的容器来定义一个栈，此时，实现的是数组栈，所以是通过缺省值vector来定义的
//但是当模板中的容器发生改变时，调用不同的容器来定义，这个栈的性质就发生了根本变化;
container _st;
};
void test_stack1()
{
//数组栈：
//stack<int> st;//因为有缺省值vector，不写也不会报错，正常运行；
//stack<int, vector<int>> st;//也可以显示的写成所使用的容器；
//链式栈：
//只需要改变模板中的容器，那么栈的性质将发生改变改变;
stack<int, list<int>> st;//此时模板中的容器是list,所以实现的是链式栈；
st.push(1);
st.push(2);
st.push(3);
st.push(4);
st.push(5);
while (!st.empty())
{
cout << st.top() << " ";
st.pop();
}
cout << endl;
}
}为便于理解，调试观察，如下图所示：
//
由于队列需要队尾入，队头出，涉及头插头删，此时就不适合使用数组（vector）来实现，队列我们优先使用list来实现，具体代码如下所示：
//通过list实现队列
namespace MKL
{
template<class T,class container=list<T>>
class queue
{
public:
void push(const T& x)//进队列：
{
_qu.push_back(x);//调用模板中的容器的尾插接口，
}
void pop()//出队列
{
_qu.pop_front();调用模板中的容器的头删接口，
}
const T& top()//获取队头元素：
{
return _qu.front();//调用模板中的容器的获取头部元素接口，
}
const T& back()//获取队尾元素
{
return _qu.back();//调用模板中的容器的获取尾部元素接口，
}
bool empty()//判断队列是否为空：
{
return _qu.empty();//调用模板中的容器的是否为空接口；
}
private:
container _qu;//主要用容器list定义，
};
void test_queue1()
{
//因为队列需要队头出数据，所以vector就不适应于实现queue,
//实现queue主要靠list，list头插头删，任意地方插入删除效率高；
queue<int, list<int>> qu;
qu.push(1);
qu.push(2);
qu.push(3);
qu.push(4);
qu.push(5);
while (!qu.empty())
{
cout << qu.top() << " ";
qu.pop();
}
cout << endl;
}
}//////
三：STL库中的容器适配器（deque）：
虽然
stack
和
queue
中也可以存放元素，但在
STL
中并没有将其划分在容器的行列，而是将其称为
容器适配
器
，这是因为
stack
和队列只是对其他容器的接口进行了包装，
STL
中
stack
和
queue
默认使用
deque，
那么什么是deque, deque又是怎样实现的呢？他存在的意义又是是什么呢？
//
3.1deque定义：
众所周知
vector: 1：优点：尾插尾删效率高，支持下标访问
2：缺点：头插头删效率低，需要挪动，
list: 1：优点：任意地方插入删除效率高，不需要挪动数据
2：缺点：不支持下标的随机访问
我们如果即想拥有vector与list的优点,又想克服他们的缺点，那么此时，deque随之孕育而生，
deque就像vector与list的结合体，
定义：deque(双端队列)：是一种双开口的"连续"空间的数据结构，
双开口的含义是：可以在
头尾两端进行插入和 删除操作，且时间复杂度为O(1)，
与vector比较：头插效率高，不需要搬移元素；任意地方插入删除效率高；
与list比较，空间利用率比较高，但是能像vector一样通过下标访问；
//
3.2deque底层结构：
deque
并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际
deque
类似于一个动态的二维
数组
，其底层结构如下图所示：
双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此，deque的迭代器会有点复杂，如下图所示：
//
3.3deque的缺陷：
1：
与
vector
比较
，
deque
的优势是：头部插入和删除时，
不需要搬移元素，效率特别高
，而且在
扩容时，也不
需要搬移大量的元素
，因此其效率是必
vector
高的。
2：
与
list
比较
，其底层是连续空间，
空间利用率比较高
，有机会可以通过下标访问，不需要存储额外字段。
【N】:
deque有一个致命缺陷：不适合遍历，因为在遍历时，deque
的迭代器要频繁的去检测其是否移动到
某段小空间的边界，导致效率低下
，而序列式场景中，可能需要经常遍历，因此
在实际中，需要线性结构
时，大多数情况下优先考虑
vector
和
list;
总而言之：deque确实结合了vector与list的优点，但是它却不能如vector，list在一方面做到极致，总是顾头不顾尾，需要舍弃一些性能而成全另一些性能；
///
///
四：优先级队列（priority_queue）
4.1：文档定义：
1.
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
2.
此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素
(
优先队列中位于顶部的元 素)
。
3.
优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，
queue
提供一组特 定的成员函数来访问其元素。元素从特定容器的“
尾部
”
弹出，其称为优先队列的顶部。
4.
底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭 代器访问，并支持以下操作：
1.empty()
：检测容器是否为空
2.size()
：返回容器中有效元素个数
3.front()
：返回容器中第一个元素的引用
4.push_back()
：在容器尾部插入元素
5.pop_back()：删除容器尾部元素
5.
标准容器类
vector
和
deque
满足这些需求。默认情况下，如果没有为特定的
priority_queue
类实例化指 定容器类，则使用vector
。
6.
需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数 make_heap、
push_heap
和
pop_heap
来自动完成此操作
///
4.2：大致结构：
优先级队列默认使用
vector
作为其底层存储数据的容器，在
vector
上又使用了堆算法将
vector
中元素构造成
堆的结构，因此
priority_queue就是堆，
所有需要用到堆的位置，都可以考虑使用
priority_queue
。注意：
默认情况下
priority_queue
是大堆
。具体代码如下所示：
template<class T, class container = vector<T>>
class priority_queue
{
public:
//向上调整建大堆：
void adjust_up(int child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
if (_pq[child] > _pq[parent])
{
swap(_pq[child], _pq[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)//插入：
{
_pq.push_back(x);
adjust_up(_pq.size() - 1);
}
//向下调整保持堆形：
void adjust_down(int parent)
{
size_t child = parent * 2 + 1;
while (child < _pq.size())
{
if (child + 1 < _pq.size() && (_pq[child] < _pq[child + 1]))
{
++child;
}
if (_pq[parent]<_pq[child])
{
swap(_pq[child], _pq[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()//删除：
{
swap(_pq[0], _pq[_pq.size() - 1]);
_pq.pop_back();
adjust_down(0);
}
const T& top()//获取堆顶元素
{
return _pq[0];
}
size_t size()//堆内元素个数
{
return _pq.size();
}
bool empty()//判空：
{
return _pq.empty();
}
private:
container _pq;
};
void test_priority_queue()
{
priority_queue<int, vector<int>> pq;//默认排的降序，
pq.push(1);
pq.push(12);
pq.push(3);
pq.push(10);
pq.push(21);
pq.push(5);
pq.push(9);
while (!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
cout << endl;
}由程序知，priority_queue默认是大堆，排降序，那么如何能排升序呢？大概有两种方法：
1：改变堆的形状，建小堆，这样默认排序时就是升序；
2：通过重载"()"，引入仿函数，；
第一种情况我们需要改变类中的结构，破坏了封装，所以我们舍弃，我们主要利用重载“（）”，利用仿函数（比较）来实现排序自由，由我们自己决定排序的方式！
那么什么是仿函数呢？
///
///
五：仿函数（比较）
仿函数，也叫做函数对象。
就其意义而言：“函数对象”较为合适，一种具有函数特性的对象，但是其实际却是一个类；
就使用而言：“仿函数”更贴切：这种东西可以像函数一样被调用，通过function可以调用，也可以通过operator重载，重载形式是“operator（）”；仿函数有多种分类。多种功能。这里只使用其比较功能
5.1：内置类型实现比较自由
具体代码如下所示：
template <class T>//仿函数，排降序
struct less
{
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template <class T>
struct greater//仿函数，排升序；
{
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
template<class T, class container = vector<T>, class compare = less<T>>//默认降序
class priority_queue
{
public:
compare com;
//向上调整建大堆：
void adjust_up(int child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
//if (_pq[child] > _pq[parent])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)
{
_pq.push_back(x);
adjust_up(_pq.size() - 1);
}
//向下调整保持堆形：
void adjust_down(int parent)
{
size_t child = parent * 2 + 1;
while (child < _pq.size())
{
//if (child + 1 < _pq.size() && (_pq[child] < _pq[child + 1]))
if (child + 1 < _pq.size() && com(_pq[child], _pq[child + 1]))
{
++child;
}
//if (_pq[parent]<_pq[child])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()
{
swap(_pq[0], _pq[_pq.size() - 1]);
_pq.pop_back();
adjust_down(0);
}
const T& top()
{
return _pq[0];
}
size_t size()
{
return _pq.size();
}
bool empty()
{
return _pq.empty();
}
private:
container _pq;
};
void test_priority_queue()
{
priority_queue<int, vector<int>> pq;//默认排降序
//priority_queue<int, vector<int>, greater<int>> pq;//指定greater仿函数，排升序;
pq.push(1);
pq.push(12);
pq.push(3);
pq.push(10);
pq.push(21);
pq.push(5);
pq.push(9);
while (!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
cout << endl;
}///
5.2：自定义类型实现比较自由：
因为是自定义类型，所以只有在自定义类型中重载">" "<" 号才能使用仿函数比较：
具体代码如下所示：
template<class T, class container = vector<T>, class compare = less<T>>
class priority_queue
{
public:
compare com;
//向上调整建大堆：
void adjust_up(int child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
//if (_pq[child] > _pq[parent])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)
{
_pq.push_back(x);
adjust_up(_pq.size() - 1);
}
//向下调整保持堆形：
void adjust_down(int parent)
{
size_t child = parent * 2 + 1;
while (child < _pq.size())
{
//if (child + 1 < _pq.size() && (_pq[child] < _pq[child + 1]))
if (child + 1 < _pq.size() && com(_pq[child], _pq[child + 1]))
{
++child;
}
//if (_pq[parent]<_pq[child])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()
{
swap(_pq[0], _pq[_pq.size() - 1]);
_pq.pop_back();
adjust_down(0);
}
const T& top()
{
return _pq[0];
}
size_t size()
{
return _pq.size();
}
bool empty()
{
return _pq.empty();
}
private:
container _pq;
};
//自定义类型日期类
class data
{
public:
data(int year = 1900,int month = 4,int day = 3)
:_year(year)
, _month(month)
, _day(day)
{
}
重载'<'与'>'
bool operator<(const data& d1)const
{
return (_year < d1._year) ||
(_year == d1._year && _month < d1._month) ||
(_year == d1._year && _month == d1._month && _day < d1._day);
}
bool operator>(const data& d1)const
{
return (_year > d1._year) ||
(_year == d1._year && _month > d1._month) ||
(_year == d1._year && _month == d1._month && _day > d1._day);
}
friend ostream& operator<<(ostream& _cout, const data& d1)
{
_cout << d1._year << "-" << d1._month << "-" << d1._day << endl;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
struct dataless//自定义类型仿函数，排降序；
{
public:
bool operator()(const data* p1, const data* p2)
{
return *p1 < *p2;
}
};
struct datagreater//自定义类型仿函数，排升序；
{
public:
bool operator()(const data* p1, const data* p2)
{
return *p1 > *p2;
}
};
void test_priority_queue2()
{
//priority_queue<data> pq1;//默认排降序，拿到最大的日期
priority_queue<data,vector<data>,greater<data>> pq1;//指定排升序，拿到最小的日期
pq1.push(data(2023, 4, 1));
pq1.push(data(2023, 4, 2));
pq1.push(data(2023, 4, 3));
pq1.push(data(2023, 4, 4));
cout << pq1.top() << endl;
}///
5.3：自定义类型的指针类型：
当我们比较的不是单纯的日期类时，变成日期类的指针时，此时需要通过泛型模板将比较控制在自己手中；
template<class T, class container = vector<T>, class compare = less<T>>
class priority_queue
{
public:
compare com;
//向上调整建大堆：
void adjust_up(int child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
//if (_pq[child] > _pq[parent])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)
{
_pq.push_back(x);
adjust_up(_pq.size() - 1);
}
//向下调整保持堆形：
void adjust_down(int parent)
{
size_t child = parent * 2 + 1;
while (child < _pq.size())
{
//if (child + 1 < _pq.size() && (_pq[child] < _pq[child + 1]))
if (child + 1 < _pq.size() && com(_pq[child], _pq[child + 1]))
{
++child;
}
//if (_pq[parent]<_pq[child])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()
{
swap(_pq[0], _pq[_pq.size() - 1]);
_pq.pop_back();
adjust_down(0);
}
const T& top()
{
return _pq[0];
}
size_t size()
{
return _pq.size();
}
bool empty()
{
return _pq.empty();
}
private:
container _pq;
};
class data
{
public:
data(int year = 1900,int month = 4,int day = 3)
:_year(year)
, _month(month)
, _day(day)
{
}
bool operator<(const data& d1)const
{
return (_year < d1._year) ||
(_year == d1._year && _month < d1._month) ||
(_year == d1._year && _month == d1._month && _day < d1._day);
}
bool operator>(const data& d1)const
{
return (_year > d1._year) ||
(_year == d1._year && _month > d1._month) ||
(_year == d1._year && _month == d1._month && _day > d1._day);
}
friend ostream& operator<<(ostream& _cout, const data& d1)
{
_cout << d1._year << "-" << d1._month << "-" << d1._day << endl;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
struct dataless
{
public:
template<class T>//泛型模板仿函数，排降序；
bool operator()(const T* p1, const T* p2)
{
return *p1 < *p2;
}
};
struct datagreater
{
public:
template<class T>//泛型模板仿函数，排升序；
bool operator()(const T* p1, const T* p2)
{
return *p1 > *p2;
}
};
void test_priority_queue3()
{
//priority_queue<data*,vector<data*>,dataless> pq2;//默认排降序，拿到最大的；
priority_queue<data*, vector<data*>, datagreater> pq2;//指定排升序，拿到最小的
pq2.push(new data(2023, 4, 1));
pq2.push(new data(2023, 4, 2));
pq2.push(new data(2023, 4, 3));
pq2.push(new data(2023, 4, 4));
cout << *(pq2.top()) << endl;
}//////
至此，这是我对容器的相关概念的一些理解与使用，同时也是对优先级队列（priority_queue）的实现与如何控制排序的理解与使用，我将全部代码放到下方，请各位大佬指正！
#pragma once
#include <iostream>
#include <vector>
#include <list>
using namespace std;
//通过vector/list实现栈：
namespace MKL
{
//通过适配器模式实现，模板给个容器名称，容器名称可以任意，给缺省值，缺省值是容器，在此默认实现数组形式的栈：
template<class T,class container=vector<T>>
class stack
{
public:
void push(const T& x)//进栈：
{
_st.push_back(x);//调用模板中的容器的尾插接口，
}
void pop()//出栈：
{
_st.pop_back();//调用模板中的容器的尾删接口，
}
const T& top()//获取栈顶元素：
{
return _st.back();//调用模板中的容器的获取尾部元素接口，
}
size_t size()//栈中元素个数;
{
return _st.size();//调用模板中的容器的获取元素个数接口；
}
bool empty()//判断栈是否为空：
{
return _st.empty();//调用模板中的容器的是否为空接口；
}
private:
//通过模板中的容器来定义一个栈，此时，实现的是数组栈，所以是通过缺省值vector来定义的
//但是当模板中的容器发生改变时，调用不同的容器来定义，这个栈的性质就发生了根本变化;
container _st;
};
void test_stack1()
{
//数组栈：
//stack<int> st;//因为有缺省值vector，不写也不会报错，正常运行；
//stack<int, vector<int>> st;//也可以显示的写成所使用的容器；
//链式栈：
//只需要改变模板中的容器，那么栈的性质将发生改变改变;
stack<int, list<int>> st;//此时模板中的容器是list,所以实现的是链式栈；
st.push(1);
st.push(2);
st.push(3);
st.push(4);
st.push(5);
while (!st.empty())
{
cout << st.top() << " ";
st.pop();
}
cout << endl;
}
}
//通过list实现队列
namespace MKL
{
template<class T,class container=list<T>>
class queue
{
public:
void push(const T& x)//进队列：
{
_qu.push_back(x);//调用模板中的容器的尾插接口，
}
void pop()//出队列
{
_qu.pop_front();调用模板中的容器的头删接口，
}
const T& top()//获取队头元素：
{
return _qu.front();//调用模板中的容器的获取头部元素接口，
}
const T& back()//获取队尾元素
{
return _qu.back();//调用模板中的容器的获取尾部元素接口，
}
bool empty()//判断队列是否为空：
{
return _qu.empty();//调用模板中的容器的是否为空接口；
}
private:
container _qu;//主要用容器list定义，
};
void test_queue1()
{
//因为队列需要队头出数据，所以vector就不适应于实现queue,
//实现queue主要靠list，list头插头删，任意地方插入删除效率高；
queue<int, list<int>> qu;
qu.push(1);
qu.push(2);
qu.push(3);
qu.push(4);
qu.push(5);
while (!qu.empty())
{
cout << qu.top() << " ";
qu.pop();
}
cout << endl;
}
}
namespace MKL
{
template <class T>//仿函数，排降序
struct less
{
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template <class T>
struct greater//仿函数，排升序；
{
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
template<class T, class container = vector<T>, class compare = less<T>>
class priority_queue
{
public:
compare com;
//向上调整建大堆：
void adjust_up(int child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
//if (_pq[child] > _pq[parent])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)
{
_pq.push_back(x);
adjust_up(_pq.size() - 1);
}
//向下调整保持堆形：
void adjust_down(int parent)
{
size_t child = parent * 2 + 1;
while (child < _pq.size())
{
//if (child + 1 < _pq.size() && (_pq[child] < _pq[child + 1]))
if (child + 1 < _pq.size() && com(_pq[child], _pq[child + 1]))
{
++child;
}
//if (_pq[parent]<_pq[child])
if (com(_pq[parent], _pq[child]))
{
swap(_pq[child], _pq[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()
{
swap(_pq[0], _pq[_pq.size() - 1]);
_pq.pop_back();
adjust_down(0);
}
const T& top()
{
return _pq[0];
}
size_t size()
{
return _pq.size();
}
bool empty()
{
return _pq.empty();
}
private:
container _pq;
};
void test_priority_queue()
{
priority_queue<int, vector<int>> pq;//默认排降序
//priority_queue<int, vector<int>, greater<int>> pq;//指定greater仿函数，排升序;
pq.push(1);
pq.push(12);
pq.push(3);
pq.push(10);
pq.push(21);
pq.push(5);
pq.push(9);
while (!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
cout << endl;
}
class data
{
public:
data(int year = 1900,int month = 4,int day = 3)
:_year(year)
, _month(month)
, _day(day)
{
}
bool operator<(const data& d1)const
{
return (_year < d1._year) ||
(_year == d1._year && _month < d1._month) ||
(_year == d1._year && _month == d1._month && _day < d1._day);
}
bool operator>(const data& d1)const
{
return (_year > d1._year) ||
(_year == d1._year && _month > d1._month) ||
(_year == d1._year && _month == d1._month && _day > d1._day);
}
friend ostream& operator<<(ostream& _cout, const data& d1)
{
_cout << d1._year << "-" << d1._month << "-" << d1._day << endl;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
struct dataless
{
public:
template<class T>
bool operator()(const T* p1, const T* p2)
{
return *p1 < *p2;
}
};
struct datagreater
{
public:
template<class T>
bool operator()(const T* p1, const T* p2)
{
return *p1 > *p2;
}
};
//struct dataless
//{
//public:
// bool operator()(const data* p1, const data* p2)
// {
// return *p1 < *p2;
// }
//};
//struct datagreater
//{
//public:
// bool operator()(const data* p1, const data* p2)
// {
// return *p1 > *p2;
// }
//};
void test_priority_queue2()
{
//priority_queue<data> pq1;
priority_queue<data,vector<data>,greater<data>> pq1;
pq1.push(data(2023, 4, 1));
pq1.push(data(2023, 4, 2));
pq1.push(data(2023, 4, 3));
pq1.push(data(2023, 4, 4));
cout << pq1.top() << endl;
}
void test_priority_queue3()
{
//priority_queue<data*,vector<data*>,dataless> pq2;
priority_queue<data*, vector<data*>, datagreater> pq2;
pq2.push(new data(2023, 4, 1));
pq2.push(new data(2023, 4, 2));
pq2.push(new data(2023, 4, 3));
pq2.push(new data(2023, 4, 4));
cout << *(pq2.top()) << endl;
}
}
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
