【C++】stack、queue、priority_queue的模拟实现

目录

一、stack

🌟stack的简单介绍

🌟stack的基本使用

🌟stack的模拟实现

🌟stack模拟实现的完整代码

🌟容器适配器 

二、queue

🌟queue的简单介绍 

🌟queue的基本使用

🌟queue的模拟实现

🌟deque的简单介绍

<1> deque原理介绍

<2>deque的缺陷

<3>为什么选择deque作为stack和queue的底层默认容器？

三、priority_queue

🌟priority_queue的简单介绍

🌟priority_queue的使用

🌟priority_queue的模拟实现

 ✨push(const T& x)

✨pop()

✨top() / size() / empty()

✨区间迭代器priority_queue(InputIterator first, InputIterator last)

🌟仿函数 

我们可以使用仿函数来模拟实现 priority_queue ：

🌟仿函数的使用：

一、stack

🌟stack的简单介绍

 1、堆栈是一种容器适配器，专门设计1用于LIFO环境（后进先出），其中元素仅从容器的一端插入和提取；

2、队长被实现为容器适配器，这些类使用特定容器类的封装对象作为其底层容器，提供一组特定的成员函数来访问其元素。元素从特定容器的“背面”推/弹出，这被称为堆栈的顶部。

3、底层容器可以是任何标准容器类模板或一些其他专门设计的容器类。

🌟stack的基本使用

函数说明接口说明
stack()构造空的栈
empty()检测stack是否为空
size()返回satck中元素的个数
top()返回栈顶元素的引用
push()将元素val压入stack中
pop()将stack中国尾部的元素弹出
void test_stack0()
{stack<int> s1;s1.push(1);s1.push(2);s1.push(3);s1.push(4);cout << s1.size() << endl;while (!s1.empty()){cout << s1.top() << " ";s1.pop();}cout << endl;
}int main()
{test_stack0();return 0;
}

🌟stack的模拟实现

基本框架：

namespace xlf
{template<class T>class stack{public:stack(){}private:std::vector<T> _v;};
}

 •  namespace xlf  取一个命名空间，对标识符的名称进行本地化，以避免命名冲突或名字污染；

 •  template<class T>  模板，这里用的是类模板来进行模拟实现；

 •  stack() {}   无参构造；

 •  public、private  访问限定符；

 •  std::vector<T> _v;  成员变量，这里成员变量的类型 vector 和 list 都可以使用，因为stack是在栈顶 出/入 栈，所以可以使用vector、list的一些函数接口来实现。

成员函数的模拟实现：

		stack(){}void push(const T& x){_v.push_back(x);}void pop(){_v.pop_back();}T& top(){return _v.back();}const T& top() const{return _v.back();}size_t size() const{return _v.size();}bool empty() const{return _v.empty();}

 • push 可以使用 vector 的 push_back() 函数接口来实现，stack 的入栈即为 vector 的尾插；

其他成员函数的模拟实现同理。

🌟stack模拟实现的完整代码

namespace xlf
{template<class T>class stack{public:stack(){}void push(const T& x){_v.push_back(x);}void pop(){_v.pop_back();}T& top(){return _v.back();}const T& top() const{return _v.back();}size_t size() const{return _v.size();}bool empty() const{return _v.empty();}private:std::vector<T> _v;};
}

🌟容器适配器 

 <1> 适配器是一种设计模式（设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结），该种模式是将一个类的接口转换成客户希望的另外一个接口。

<2> STL标准库中 stack 和 queue 的底层结构

      虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，比如：

 此时stack 的模拟实现可以写为：

namespace xlf
{template<class T, class Container = deque<T>>class stack{public://构造stack(){}void push(const T& x){_con.push_back(x);}void pop(){_con.pop_back();}const T& top(){return _con.back();}size_t size(){return _con.size();}bool empty(){return _con.empty();}private:Container  _con;};}

适配器模式---转换

迭代器模式---封装统一访问方式

•    template<class T, class Container = deque<T>>  使用适配器

•    Container  _con;   适配器成员变量

stack、queue 不提供迭代器，容器适配器是用这些容器转换出来的（适配器通常不提供迭代器），stack后进先出，如果提供迭代器，就达不到原本的性质了。 

二、queue

🌟queue的简单介绍 

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元
素，另一端提取元素。
2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供
一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少
支持以下操作:
  • empty：检测队列是否为空
  • size：返回队列中有效元素的个数
  • front：返回队头元素的引用
  • back：返回队尾元素的引用
  • push_back：在队列尾部入队列
  • pop_front：在队列头部出队列
4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器
类，则使用标准容器deque。

🌟queue的基本使用

void test_queue1()
{queue<int> q;q.push(1);q.push(2);q.push(3);q.push(4);q.push(5);while (!q.empty()){cout << q.front() << " ";q.pop();}cout << endl;
}int mian()
{test_queue1();return 0;
}

🌟queue的模拟实现

 只能用 deque、list 适配，因为queue不支持头删，没有直接支持的，可以用erase，这时就可以支持使用vector，但是效率就很低。

成员函数的模拟实现和stack类似：

namespace xlf
{//只能用deque list适配//用vector会报错，队尾插入，队头删除，//queue不支持头删（先进先出）（没有直接支持，可以用erase）template<class T, class Container = deque<T>>class queue{public://构造queue(){}void push(const T& x){_con.push_back(x);}void pop(){//这样就可以支持vector了，但是效率就很低了//_con.erase(_con.begin());_con.pop_front();}const T& front(){return _con.front();}const T& back(){return _con.back();}size_t size(){return _con.size();}bool empty(){return _con.empty();}private:Container  _con;};}

🌟deque的简单介绍

<1> deque原理介绍

 • deque(双端队列)：是一种双开口的“连续”空间的数据结构；

 • 双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)；

 • 与vector比较，头插效率高，不需要搬移元素；

 • 与list比较，空间利用率比较高;

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态二位数组： 

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”，以及随机访问的假象，落在了deque的迭代器身上 ：

<2>deque的缺陷

（1）与vector比较，deque 的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必 vector 高的。

（2）与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。 但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

<3>为什么选择deque作为stack和queue的底层默认容器？

（1） stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性 结构，都可以作为stack的底层容器，比如vector和list都可以；

（2）queue是先进先出的特殊线性数据 结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如 list。

（3）但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

         • stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进 行操作。

         • 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的 元素增长时，deque不仅效率高，而且内存使用率高。

结合了deque的优点，而完美的避开了其缺陷。

三、priority_queue

🌟priority_queue的简单介绍

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素
中最大的。（默认是大堆）
2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶
部的元素)。
3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue
提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的
顶部。
4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过
随机访问迭代器访问，并支持以下操作：
      • empty()：检测容器是否为空
      • size()：返回容器中有效元素个数
      • front()：返回容器中第一个元素的引用
      • push_back()：在容器尾部插入元素
      • pop_back()：删除容器尾部元素
5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue
类实例化指定容器类，则使用vector。
6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用
算法函数make_heap、push_heap和pop_heap来自动完成此操作。

🌟priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue就是大堆。

函数声明接口说明

priority-queueu()

priority_queue(first,last)

构造一个空的优先队列
empty()检测优先级队列是否为空，是返回true,否则返回false
top()返回优先级队列中最大（最小）元素，即堆栈元素
push(x)在优先级队列中插入元素x
pop()删除优先级队列中最大（最小）元素，即堆顶元素
#include<iostream>
using namespace std;
#include<queue>int main()
{int a[] = { 1,5,6,8,4,9,7,3,2,0 };priority_queue<int> q1(a, a + sizeof(a) / sizeof(int));while (!q1.empty()){cout << q1.top() << " ";q1.pop();}cout << endl;return 0;
}

🌟priority_queue的模拟实现

基本框架：

namespace xlf //命名空间
{template<class T, class Container = vector<T>>  //类模板class priority_queue{public://成员函数private:Container _con;//成员变量};}

•  namespace xlf  命名空间，防止命名冲突；

•  template<class T, class Container = vector<T>>  模板，容器适配器；

 ✨push(const T& x)

//用 < 实现大堆
void adjust_up(int child)
{int parent = (child - 1) / 2; //计算父节点的位置while (child > 0) //循环结束条件：到堆顶结束{if (_con[parent] < _con[child]) //如果父节点小于孩节点就交换{swap(_con[parent], _con[child]);child = parent;parent = (child - 1) / 2;//继续计算父节点的位置}else //父节点大于孩节点就结束循环{break;}}}//堆的插入
void push(const T& x)
{_con.push_back(x);//由这个函数进行扩容//向上调整adjust_up(_con.size() - 1);//排序的区间长度
}

 priority_queue底层是一个堆，在堆后中插入数据，数据就乱了，因此要向上调整堆的数据。

✨pop()

void adjust_down(size_t parent)
{size_t child = parent * 2 + 1;//左孩子while (child < _con.size()){//假设法//选择左右孩子大的那个if (child + 1 < _con.size() && _con[child] < _con[child + 1])//判断是否有右孩子              如果右孩子大就选择右孩子{++child;}if (_con[parent] < _con[child])//孩节点大就交换{swap(_con[parent], _con[child]);parent = child;child = parent * 2 + 1;}else{break;}}
}//堆的删除
void pop()
{swap(_con[0], _con[_con.size() - 1]);//首尾交换_con.pop_back();//删除尾部数据adjust_down(0);//向下调整
}

堆的删除要交换首尾的一个数据，接着删除尾部的数据，最后堆顶的数据就要向下调整大小。

✨top() / size() / empty()

const T& top()
{return _con[0];
}size_t size()
{return _con.size();
}bool empty()
{return _con.empty();
}

直接返回相应的数据。

✨区间迭代器priority_queue(InputIterator first, InputIterator last)

		template<class InputIterator>priority_queue(InputIterator first, InputIterator last){while (first != last){_con.push_back(*first);++first;}//直接建堆//向下调整for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--){adjust_down(i);}}

我们也可以选择向上调整建堆，但是向下直接建堆的时间复杂度更好哦

🌟仿函数 

• 仿函数/函数对象：重载了 operator() 的类，类的对象可以像函数一样使用。 

•  仿函数：根据需求来实现，并没有规定返回值是什么，返回值也是根据需求来返回的，很灵活，只有 operator() 是固定的；

• 特点：参数个数和返回值根据需求确定，不固定，很灵活；

仿函数的使用：

//仿函数/函数对象：重载operator()的类，类的对象可以像函数一样使用
class Func
{
public:void operator()(int n){while (n--){cout << "Func调用" << endl;}cout << endl;}
};template<class T>
class myless
{
public:bool operator()(const T& x, const T& y){return x < y; }
};int main()
{Func f1;f1(10);f1.operator()(20);//仿函数：根据你的需求，只有operator()是固定的，并没有规定返回值是什么，返回值也是根据你的需求来返回的，更灵活；//特点：参数个数和返回值根据需求确定，不固定，很灵活。myless<int> lessFunc1;cout << lessFunc1(1, 2) << endl;//lessFunc1.operator()(1,2);myless<string> lessFunc2;cout << lessFunc2("1.1","2.2") << endl;return 0;
}

我们可以使用仿函数来模拟实现 priority_queue ：

//仿函数的使用场景
namespace xlf
{template<class T>class myless{public:bool operator()(const T& x, const T& y){return x < y;}};template<class T>class mygreat{public:bool operator()(const T& x, const T& y){return x > y;}};//通过外部来改变排序的规则，而不是在内部改变 >  < 的符号来控制 template<class T, class Container = vector<T>,class Comapre=myless<int>>class priority_queue{public://强制编译器生成默认构造priority_queue() = default;template<class InputIterator>priority_queue(InputIterator first, InputIterator last){while (first != last){_con.push_back(*first);++first;}//直接建堆//向下调整for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--){adjust_down(i);}}//用 < 实现大堆void adjust_up(int child){Comapre comfunc;int parent = (child - 1) / 2;while (child > 0){//if (_con[parent] < _con[child])if (comfunc(_con[parent] , _con[child]))//if (Comapre.operator()(_con[parent] , _con[child])){swap(_con[parent], _con[child]);child = parent;parent = (child - 1) / 2;}else{break;}}}//堆的插入void push(const T& x){_con.push_back(x);//由这个函数进行扩容//向上调整adjust_up(_con.size() - 1);//排序的区间长度}void adjust_down(size_t parent){Comapre comfunc;size_t child = parent * 2 + 1;//左孩子while (child < _con.size()){//假设法//选择左右孩子大的那个//if (child + 1 < _con.size() && _con[child] < _con[child + 1])if (child + 1 < _con.size() && comfunc(_con[child] , _con[child + 1])){++child;}//if (_con[parent] < _con[child])if (comfunc(_con[parent] , _con[child])){swap(_con[parent], _con[child]);parent = child;child = parent * 2 + 1;}else{break;}}}//堆的删除void pop(){swap(_con[0], _con[_con.size() - 1]);//首尾交换_con.pop_back();//删除尾部数据adjust_down(0);//向下调整}const T& top(){return _con[0];}size_t size(){return _con.size();}bool empty(){return _con.empty();}private:Container _con;};}

此时使用了仿函数，就不用在堆的内部改变 大于/小于  的符号，可以直接在外部的函数直接修改。

🌟仿函数的使用：

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);private:int _year;int _month;int _day;
};ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout;
}//自己写一个仿函数改变比较大小的方式struct PDateLess{bool operator()(Date* p1, Date* p2){return *p1 > *p2;}};void TestPriorityQueue()
{//优先级里面放自定义类型// 大堆，需要用户在自定义类型中提供<的重载//priority_queue<Date> q1;//q1.push(Date(2018, 10, 29));//q1.push(Date(2018, 10, 28));//q1.push(Date(2018, 10, 30));//while (!q1.empty())//{//	cout << q1.top() << " ";//	q1.pop();//}//cout << endl;// 大堆，需要用户在自定义类型中提供<的重载//存日期类的指针，此时结果很混乱//原因：Date*是按地址比较大小，// 并不是说先new的地址小，后new的地址大，地址带有随机性//我们要的并不是按地址比较大小，所以：自己写一个仿函数PDateLess//priority_queue<Date*> q1;//自己写的仿函数(显示传PDateLess)xlf::priority_queue<Date*, vector<Date*>, PDateLess> q1;q1.push(new Date(2018, 10, 29));q1.push(new Date(2018, 10, 28));q1.push(new Date(2018, 10, 30));while (!q1.empty()){cout << *q1.top() << " ";q1.pop();}cout << 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;
}int main()
{TestPriorityQueue();return 0;
}

如若对你有帮助，记得点赞、收藏、关注哦！

若有误，望各位，在评论区留言或者私信我 指点迷津！！！谢谢^ ^ ~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/53412.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

828华为云征文｜Flexus云服务器X实例快速部署在线测评平台,适用各种信息学教学

828华为云征文｜Flexus云服务器X实例快速部署在线测评平台,适用各种信息学教学

文章目录 如何选配Flexus云服务器X实例服务器HydroOJHOJ 服务器资源的选取基础配置实例规格镜像、存储、网络弹性公网IP云服务器名称 部署HydroOJ1.设置安全组、开放端口2.部署HydroOJ回到控制中心&#xff0c;远程登录 部署HOJ安装docker# 安装docker-compose部署HOJ 本篇幅为…
阅读更多...
Git 使用指南 --- 版本管理

Git 使用指南 --- 版本管理

序言 Git 是一个开源的 分布式版本控制系统&#xff0c;可以有效、高速地处理从很小到非常大的项目版本管理。对一个程序员来说&#xff0c;掌握 Git 的使用是必要的。  在这个系列中&#xff0c;将详细的介绍 Git 的使用和原理&#xff0c;话不多说&#xff0c;让我们开始吧。…
阅读更多...
【C++ 面试 - STL】每日 3 题（四）

【C++ 面试 - STL】每日 3 题（四）

✍个人博客&#xff1a;Pandaconda-CSDN博客 &#x1f4e3;专栏地址&#xff1a;http://t.csdnimg.cn/fYaBd &#x1f4da;专栏简介&#xff1a;在这个专栏中&#xff0c;我将会分享 C 面试中常见的面试题给大家~ ❤️如果有收获的话&#xff0c;欢迎点赞&#x1f44d;收藏&…
阅读更多...
qiankun微前端

qiankun微前端

qiankun微前端踩坑指南&#xff1a; 上图原因子项目未启动 上图使用$tqiankun微前端中未引用i18n插件解决方案如下&#xff1a; 子项目main.js中加上i18n: 一些坑忘记截图复现会继续更新....... 配置正文开始------> 主项目 子项目 1.名字需要与子项目跳转后缀一致 2.v…
阅读更多...
景联文科技：提供高质量多模态数据标注，推动智能化转型

景联文科技：提供高质量多模态数据标注，推动智能化转型

随着人工智能技术的快速发展&#xff0c;多模态数据标注成为推动智能系统更深层次理解和应用的关键技术之一。 作为行业领先的多模态数据标注服务商&#xff0c;景联文科技凭借其在技术、流程和人才方面的综合优势&#xff0c;推出了全面的多模态标注解决方案&#xff0c;助力…
阅读更多...
Python | Leetcode Python题解之第392题判断子序列

Python | Leetcode Python题解之第392题判断子序列

题目&#xff1a; 题解&#xff1a; class Solution:def isSubsequence(self, s: str, t: str) -> bool:n, m len(s), len(t)f [[0] * 26 for _ in range(m)]f.append([m] * 26)for i in range(m - 1, -1, -1):for j in range(26):f[i][j] i if ord(t[i]) j ord(a) el…
阅读更多...
【5G PHY】5G循环前缀（CP）设计思路简述

【5G PHY】5G循环前缀（CP）设计思路简述

博主未授权任何人或组织机构转载博主任何原创文章&#xff0c;感谢各位对原创的支持&#xff01; 博主链接 本人就职于国际知名终端厂商&#xff0c;负责modem芯片研发。 在5G早期负责终端数据业务层、核心网相关的开发工作&#xff0c;目前牵头6G技术研究。 博客内容主要围绕…
阅读更多...
将语义分割的标签转换为实例分割（yolo）的标签

将语义分割的标签转换为实例分割（yolo）的标签

语义分割的标签&#xff08;目标处为255&#xff0c;其余处为0&#xff09; 实例分割的标签&#xff08;yolo.txt&#xff09;,描述边界的多边形顶点的归一化位置 绘制在原图类似蓝色的边框所示。 废话不多说&#xff0c;直接贴代码&#xff1b; import os import cv2 imp…
阅读更多...
监控平台总结之面试常问答案

监控平台总结之面试常问答案

思路 延伸的面试题总结及答案&#xff1a; 1.说说前端监控平台/监控SDK架构设计和难点亮点&#xff1f; 架构设计 数据采集层: SDK: 在前端集成的 SDK 负责采集数据&#xff0c;包括性能指标、用户行为、错误日志等。 数据收集: 实现高效的数据采集机制&#xff0c;支持实时…
阅读更多...
分类任务实现模型集成代码模版

分类任务实现模型集成代码模版

分类任务实现模型&#xff08;投票式&#xff09;集成代码模版 简介 本实验使用上一博客的深度学习分类模型训练代码模板-CSDN博客&#xff0c;自定义投票式集成&#xff0c;手动实现模型集成&#xff08;投票法&#xff09;的代码。最后通过tensorboard进行可视化&#xff0…
阅读更多...
傅里叶变换家族

傅里叶变换家族

禹晶、肖创柏、廖庆敏《数字图像处理&#xff08;面向新工科的电工电子信息基础课程系列教材&#xff09;》 禹晶、肖创柏、廖庆敏《数字图像处理》资源二维码
阅读更多...
java设计模式（行为型模式：状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式、解释器模式）

java设计模式（行为型模式：状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式、解释器模式）

6&#xff0c;行为型模式 6.5 状态模式 6.5.1 概述 【例】通过按钮来控制一个电梯的状态&#xff0c;一个电梯有开门状态&#xff0c;关门状态&#xff0c;停止状态&#xff0c;运行状态。每一种状态改变&#xff0c;都有可能要根据其他状态来更新处理。例如&#xff0c;如果…
阅读更多...
太细了有手就行，SpringCloud Alibaba+Nacos+Dubbo整合

太细了有手就行，SpringCloud Alibaba+Nacos+Dubbo整合

SpringCloud AlibabaNacosDubbo&#xff0c;文末有完整项目代码链接 前言一、这几者之间关系二、准备工作1.Nacos2.SpringCloud Alibaba4.SpringCloud5.Dubbo项目中层级关系 三、代码调用逻辑1.dubbo-api模块2.account-api模块3.api-service模块4.逻辑梳理 四、Maven和配置1.pa…
阅读更多...
尽快更新！Zyxel 路由器曝出 OS 命令注入漏洞，影响多个版本

尽快更新！Zyxel 路由器曝出 OS 命令注入漏洞，影响多个版本

近日&#xff0c;Zyxel 发布安全更新&#xff0c;以解决影响其多款商用路由器的关键漏洞&#xff0c;该漏洞可能允许未经认证的攻击者执行操作系统命令注入。 该漏洞被追踪为 CVE-2024-7261&#xff0c;CVSS v3 得分为 9.8&#xff0c;是一个输入验证故障&#xff0c;由用户提…
阅读更多...
了解PD快充协议和QC快充协议

了解PD快充协议和QC快充协议

PD快充协议的实现依赖充电器与设备之间的通信协议&#xff0c;这种通信协议确保了充电器能够提供设备所需要的特定电压和电流。在快充技术中快充协议起到关键角色。 现在市面上最常见的快充协议有PD、QC、华为FCP/SCP、三星AFC协议 、VOOC闪充。PD和QC 协议属于公用协议 。华…
阅读更多...
CSS 高级区块效果——WEB开发系列25

CSS 高级区块效果——WEB开发系列25

CSS提供了多种工具和属性&#xff0c;使我们能够创建视觉上引人注目的效果。今天我们继续将深入了解几种高级CSS效果&#xff1a;盒子阴影、滤镜、混合模式和文本背景裁剪&#xff0c;提升网页设计的质感和深度。 一、盒子阴影&#xff08;Box Shadow&#xff09; 对于盒子元素…
阅读更多...
学会这2招，让你轻松提取长视频中的文案！

学会这2招，让你轻松提取长视频中的文案！

在当今数字化时代&#xff0c;短视频已成为备受欢迎的内容形式&#xff0c;众多品牌和营销人员借助短视频推广宣传产品。 短视频文案作为短视频内容的关键部分&#xff0c;能够在极短时间内向受众传达品牌信息和产品特点。 不过&#xff0c;短视频文案的提取和创作确实极具挑…
阅读更多...
ceph中pg与pool关系

ceph中pg与pool关系

在Ceph中&#xff0c;PG&#xff08;Placement Group&#xff09;和Pool是非常重要的概念&#xff0c;它们在Ceph的存储架构中扮演着关键角色。理解这些概念有助于更好地管理和优化Ceph集群。下面详细介绍这两个概念及其相互关系。 Pool&#xff08;存储池&#xff09; 定义&am…
阅读更多...
【重学 MySQL】十二、SQL 语言的规则与规范

【重学 MySQL】十二、SQL 语言的规则与规范

【重学 MySQL】十二、SQL 语言的规则与规范 基本规则注释语法规则命名规则基本命名规则具体命名规范其他注意事项 数据导入指令 SQL&#xff08;Structured Query Language&#xff0c;结构化查询语言&#xff09;的规则与规范是确保SQL语句能够正确执行、提高代码可读性和可维…
阅读更多...
【2024数模国赛赛题思路公开】国赛C题第三套思路丨无偿自提

【2024数模国赛赛题思路公开】国赛C题第三套思路丨无偿自提

C题参考思路 C题是一道优化问题&#xff0c;目的是根据题目所给的种植限制条件以及附件数据建立目标条件优化模型&#xff0c;优化种植策略&#xff0c;有利于方便田间管理&#xff0c;提高生产效益&#xff0c;减少各种不确定因素可能造成的种植风险。整个题目最重要的问题在…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023