list模拟实现【C++】

文章目录

  • 全部的实现代码放在了文章末尾
  • 准备工作
    • 包含头文件
    • 定义命名空间
    • 类的成员变量
      • 为什么节点类是用struct而不是class呢?
      • 为什么要写get_head_node?
  • 迭代器
    • 迭代器在list类里的实例化和重命名
    • 普通迭代器
      • operator->()的作用是什么?
    • const迭代器
    • 反向迭代器
    • 迭代器的获取
  • 构造函数
    • 默认构造
    • 使用n个val构造
    • 迭代器区间构造
    • 解决迭代器区间构造 和 用n个val构造的冲突
    • initializer_list构造
    • 拷贝构造
  • 析构函数
  • swap
  • 赋值运算符重载
  • erase
    • 删除pos迭代器指向的节点
      • 为什么要返回next?
    • 删除迭代器区间
  • insert
    • 在迭代器pos之前插入一个节点
    • 为什么要返回newnode?
    • 在迭代器pos之前插入一个迭代器区间的数据
  • push_back
  • push_front
  • pop_front
  • pop_back
  • size
  • empty
  • back
  • front
  • assign
  • resize
  • clear
  • 全部代码

全部的实现代码放在了文章末尾

准备工作

创建两个文件,一个头文件mylist.hpp,一个源文件test.cpp

【因为模板的声明和定义不能分处于不同的文件中,所以把成员函数的声明和定义放在了同一个文件mylist.hpp中】
mylist.hpp:存放包含的头文件,命名空间的定义,成员函数和命名空间中的函数的定义

test.cpp:存放main函数,以及测试代码


包含头文件

  1. iostream:用于输入输出

  2. assert.h:用于使用报错函数assert


定义命名空间

在文件mylist.hpp中定义上一个命名空间mylist
把list类和它的成员函数放进命名空间封装起来,防止与包含的头文件中的函数/变量重名的冲突问题


类的成员变量

参考了stl源码中的list的实现,stl中list的底层链表是双向带头循环链表
【可以看我这篇文章了解双向带头循环链表的实现:链表的极致——带头双向循环链表】
成员变量只有一个,就是指向双向带头循环链表的头节点的指针。

节点类:
在这里插入图片描述

为什么节点类是用struct而不是class呢?

因为节点类里面的成员变量在实现list的时候需要经常访问,所以需要节点类的成员变量是公有的【使用友元也可以,但是比较麻烦
struct的默认访问权限就是公有,不用加访问限定符了,stl中实现的节点类也是struct
class的默认访问权限是私有的


list类:
在这里插入图片描述

为什么要写get_head_node?

因为插入节点之前必须要有头节点
所以把创建初始头节点的操作写成了一个函数,用于
所有构造函数插入节点之前进行申请头节点


迭代器

因为list存储数据的方式是创建一个一个的节点存储数据
所以存储数据的空间不是连续的,所以不能直接用指针作为迭代器

因为指向一个节点的指针直接++,是不一定能指向下一个节点的

所以要把迭代器实现成一个类,这样才可以正确地支持++,- -,*等操作

迭代器在list类里的实例化和重命名

在这里插入图片描述

普通迭代器

template<class T, class R, class F>
struct Iterator
{把自己的类型重命名一下typedef Iterator<T, R, F> Self;成员变量的类型是 双向带头循环链表的节点类型listnode<T>* _n;Iterator(listnode<T>*l=nullptr) 构造函数{_n = l;}Self& operator++()前置++{++就是指向下一个节点_n = _n->_next;return *this;}Self operator++(int)  后置++{Self tmp =*this;  先记录一下++之前的值_n = _n->_next;++return tmp;}Self& operator--()  前置--{--就是指向上一个节点_n = _n->_prev;return *this;}Self operator--(int) 后置--{Self tmp = *this; 先记录一下--之前的值_n = _n->_prev;--return tmp;}R operator*()const{类比指针*就是获取  节点中存储的数据return _n->_data;}F operator->()const{返回  节点中 存储数据的成员变量的  地址return &(_n->_data);}bool operator!=(const Self&obj)const![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/f3d8c3b768b14a04a69d04a69c2d9829.png#pic_center){return _n != obj._n;}bool operator==(const Self& obj){return !(*this != obj);}
};

operator->()的作用是什么?

为了实现:
当节点中存储的数据是自定义类型的变量时,可以直接使用 迭代器->访问自定义类型中的成员
【原来访问需要调用两次->,为了可读性,省略了一个->


在这里插入图片描述


const迭代器

const迭代器与普通迭代器的区别是什么?
区别就只有==不能通过const迭代器改变节点中存储的数据==

转换一下就是:

  1. 不能使用迭代器的operator*()改变节点中存储的数据,即把operator*()的返回值改成const T&就可以了
  2. 不能使用迭代器的operator->()改变节点中存储的数据的成员,即把operator->()的返回值改成const T*就可以了

所以const迭代器与普通迭代器的区别就只有两个函数的返回值类型不同,所以增加两个模板参数:R和F

普通迭代器实例化时:R就是T&F就是T*
const迭代器实例化:R就是const T&F就是const T*


反向迭代器

反向迭代器与普通迭代器的实现上的区别就是:
普通迭代器++是指向下一个节点
反向迭代器++是指向上一个节点
普通迭代器- -是指向上一个节点
反向迭代器- -是指向下一个节点

template<class T, class R, class F>
struct Reverse_iterator
{把自己的类型重命名一下typedef Reverse_iterator<T, R, F> Self;成员变量的类型是 双向带头循环链表的节点类型listnode<T>* _n;Reverse_iterator(listnode<T>* l) 构造函数{_n = l;}Self& operator++(){反向迭代器++,是移动到  前  一个节点_n = _n->_prev;return *this;}Self operator++(int){Self tmp = *this;_n = _n->_prev;return tmp;}Self& operator--(){反向迭代器--,是移动到  后  一个节点_n = _n->_next;return *this;}Self operator--(int){Self tmp = *this;_n = _n->_next;return tmp;}R operator*()const{return _n->_data;}F operator->()const{return &(_n->_data) ;}bool operator!=(const Self& obj)const{return _n!=obj._n;}bool operator==(const Self& obj)const{return !(*this != obj);}
};

迭代器的获取

iterator begin()
{头节点的下一个节点 才是第一个节点return _head->_next;
}const修饰的对象只能调用const修饰的成员函数
const_iterator begin()const
{头节点的下一个节点 才是第一个节点return _head->_next;
}iterator end()
{最后一个节点的下一个节点是  头节点因为是循环链表return _head;
}const修饰的对象只能调用const修饰的成员函数
const_iterator end()const
{return _head;
}reverse_iterator rend()
{反向迭代器的rend返回的是第一个节点的   前一个节点return _head;
}const修饰的对象只能调用const修饰的成员函数
const_reverse_iterator rend()const
{return _head;
}
reverse_iterator rbegin()
{反向迭代器的rbegin()返回的是  最后一个节点最后一个节点是  头节点的前一个因为是循环链表return _head->_prev;
}const_reverse_iterator rbegin()const
{return _head->_prev;
}

构造函数

默认构造

在这里插入图片描述


使用n个val构造

在这里插入图片描述


迭代器区间构造

在这里插入图片描述


解决迭代器区间构造 和 用n个val构造的冲突

当重载了迭代器区间构造使用n个val构造的时候
如果传入的两个参数都是int类型的话就会报错

为什么?
因为在模板函数构成重载时,编译器会调用更合适的那一个
什么叫更合适?
就是不会类型转

如果传入的两个参数都是int类型,那么调用的应该是使用n个值构造,因为没有int类型的迭代器

但是使用n个值构造的第一个参数是size_t , int传进去要隐式类型转换
而调用迭代器区间构造,两个int的实参传进去,就会直接把InputIterator推导成int,不会发生类型转换,所以编译器会调用迭代器区间构造

解决方法:
再重载一个使用n个值构造的函数,把第一个参数改成int,这样根据模板偏特化,就会在都不类型转换时优先调用第一个参数特化成int的那个构造函数

在这里插入图片描述


initializer_list构造

写了这个构造函数,就可以支持直接使用{}初始化了

在这里插入图片描述

initializer_list是iostream库里面的自定义类型,它可以直接接收{ }里面的值 进行初始化,而且有迭代器

所以可以直接使用迭代器循环+尾插进行对list的构造
在这里插入图片描述


拷贝构造

在这里插入图片描述


析构函数

在这里插入图片描述


swap

只需要交两个list对象的头指针中存储的地址就可以了

因为两个list对象都有头结点,交换了头指针中存储的地址,就相当于把这两个对象的头指针的指向交换了,
而链表的所有节点都是由头节点出发去找到的

在这里插入图片描述

void swap(list& obj)
{调用库里面的swap,交换头指针std::swap(_head, obj._head);
}

赋值运算符重载

list& operator= (list obj)
{swap(obj);return *this;
}

为什么上面的两句代码就可以完成深拷贝呢?
这是因为:

使用了传值传参,会在传参之前调用拷贝构造,再把拷贝构造出的临时对象作为参数传递进去

赋值运算符的左操作数,*this再与传入的临时对象obj交换,就直接完成了拷贝

在函数结束之后,存储在栈区的obj再函数结束之后,obj生命周期结束

obj调用析构函数,把指向的从*this那里交换来的不需要的空间销毁


erase

删除pos迭代器指向的节点

在这里插入图片描述

在这里插入图片描述

为什么要返回next?

因为使用了erase之后的迭代器会失效,需要提供更新的方法

为什么使用了erase之后的迭代器会失效?

因为pos指向的节点erase之后,节点被释放了

stl库里面规定erase的返回值是指向删除数据的下一个数据的迭代器,下一个数据就是next指向的数据,所以返回next【没有接收返回值的迭代器,在检测较严格的编译器中,不管指向的位置是否正确,都会禁止使用,使用了就报错


删除迭代器区间

在这里插入图片描述


insert

在迭代器pos之前插入一个节点

在这里插入图片描述

在这里插入图片描述

为什么要返回newnode?

list的迭代器pos在使用完insert之后其实是不会失效

但是为了与其他容器的nsert的返回值进行统一,所以也返回了指向新插入的节点的迭代器


在迭代器pos之前插入一个迭代器区间的数据

在这里插入图片描述


push_back

复用insert即可

void push_back(const T&val)
{insert(end(), val);
}

push_front

复用insert即可

void push_front(const T& val)
{insert(begin(), val);
}

pop_front

复用erese即可

void pop_front()
{erase(begin());
}

pop_back

复用erese即可

void pop_back()
{erase(--end());
}

size

在这里插入图片描述


empty

在这里插入图片描述


back

在这里插入图片描述


front

在这里插入图片描述


assign

在这里插入图片描述


resize

在这里插入图片描述


clear

复用erase

在这里插入图片描述


全部代码

#include<iostream>
#include<assert.h>using namespace std;namespace mylist
{template<class T>struct listnode//双向带头循环链表的节点类{T _data;//节点存储的数据listnode* _next;//指向下一个节点的指针listnode* _prev;//指向前一个节点的指针};template<class T, class R, class F>struct Iterator{//把自己的类型重命名一下typedef Iterator<T, R, F> Self;//成员变量的类型是 双向带头循环链表的节点类型listnode<T>* _n;Iterator(listnode<T>*l=nullptr)//构造函数{_n = l;}Self& operator++()//前置++{//++就是指向下一个节点_n = _n->_next;return *this;}Self operator++(int)//后置++{Self tmp =*this;//先记录一下++之前的值_n = _n->_next;//再++return tmp;}Self& operator--()//前置--{//--就是指向上一个节点_n = _n->_prev;return *this;}Self operator--(int)//后置--{Self tmp = *this;//先记录一下--之前的值_n = _n->_prev;//再--return tmp;}R operator*()const{//类比指针//*就是获取  节点中存储的数据return _n->_data;}F operator->()const{//返回  节点中 存储数据的成员变量的  地址return &(_n->_data);}bool operator!=(const Self&obj)const{return _n != obj._n;}bool operator==(const Self& obj){return !(*this != obj);}};template<class T, class R, class F>struct Reverse_iterator{//把自己的类型重命名一下typedef Reverse_iterator<T, R, F> Self;//成员变量的类型是 双向带头循环链表的节点类型listnode<T>* _n;Reverse_iterator(listnode<T>* l)//构造函数{_n = l;}Self& operator++(){//反向迭代器++,是移动到  前  一个节点_n = _n->_prev;return *this;}Self operator++(int){Self tmp = *this;_n = _n->_prev;return tmp;}Self& operator--(){//反向迭代器--,是移动到  后  一个节点_n = _n->_next;return *this;}Self operator--(int){Self tmp = *this;_n = _n->_next;return tmp;}R operator*()const{return _n->_data;}F operator->()const{return &(_n->_data) ;}bool operator!=(const Self& obj)const{return _n!=obj._n;}bool operator==(const Self& obj)const{return !(*this != obj);}};template<class T>class list{//把双向带头循环链表的节点类型重命名成nodetypedef listnode<T> node;private:node* _head;//唯一的成员变量//获取初始头结点node* get_head_node(){//申请一个节点大小的空间node* tmp = new node;//最开始的头节点的prev和next都指向自己tmp->_next = tmp;tmp->_prev = tmp;return tmp;}public:typedef  Iterator<T, T&, T*> iterator;//普通迭代器typedef  Iterator<T, const T&, const T*>  const_iterator;//const迭代器typedef  Reverse_iterator<T, T&, T*>  reverse_iterator;//反向迭代器typedef  Reverse_iterator<T, const T&, const T*> const_reverse_iterator;//const反向迭代器list(){//获取头结点//为之后的插入操作做准备_head=get_head_node();}list(size_t n, const T& val=T()){//必须先获取头节点,才能进行插入数据_head = get_head_node();for (int i = 0; i < n; i++){push_back(val);//尾插n次}}template <class InputIterator>list(InputIterator first, InputIterator last){//必须先获取头节点,才能进行插入数据_head = get_head_node();while (first != last){//把解引用之后的值,一个一个尾插进去push_back(*first);first++;}}list(int n, const T& val = T()){//必须先获取头节点,才能进行插入数据_head = get_head_node();for (int i = 0; i < n; i++){push_back(val);}}list(initializer_list<T> il){//必须先获取头节点,才能进行插入数据_head = get_head_node();auto it = il.begin();while (it != il.end()){//把解引用之后的值,一个一个尾插进去push_back(*it);it++;}}list(const list& obj){//必须先获取头节点,才能进行插入数据_head = get_head_node();//使用const迭代器接收  const修饰的对象的迭代器const_iterator it = obj.begin();while (it != obj.end()){//把解引用之后的获得的值,一个一个尾插进去push_back(*it);it++;}}~list(){//先把list里面除了头结点//以外的节点全部删除clear();//再把头结点申请的空间释放delete _head;_head = nullptr;}list& operator= (list obj){swap(obj);return *this;}void swap(list& obj){//调用库里面的swap,交换头指针std::swap(_head, obj._head);}iterator begin(){//头节点的下一个节点 才是第一个节点return _head->_next;}//const修饰的对象只能调用const修饰的成员函数const_iterator begin()const{//头节点的下一个节点 才是第一个节点return _head->_next;}iterator end(){//最后一个节点的下一个节点是  头节点//因为是循环链表return _head;}//const修饰的对象只能调用const修饰的成员函数const_iterator end()const{return _head;}reverse_iterator rend(){//反向迭代器的rend返回的是第一个节点的   前一个节点return _head;}//const修饰的对象只能调用const修饰的成员函数const_reverse_iterator rend()const{return _head;}reverse_iterator rbegin(){//反向迭代器的rbegin()返回的是  最后一个节点//最后一个节点是  头节点的前一个//因为是循环链表return _head->_prev;}const_reverse_iterator rbegin()const{return _head->_prev;}void push_back(const T&val){/*node* tail = _head->_prev;node* newnode = new node;newnode->_data = val;newnode->_next = _head;newnode->_prev = tail;tail->_next = newnode;_head->_prev = newnode;*/insert(end(), val);}iterator erase(iterator pos){//不能  把 头节点 给删了assert(pos!=end());//记录pos的前一个节点(prev) // 和后一个节点(next)node* prev = pos._n->_prev;node* next = pos._n->_next;//让prev的下一个节点变成nextprev->_next = next;//让prev的上一个节点变成nextnext->_prev = prev;//释放pos指向的节点delete pos._n;//返回被删除的节点的下一个节点//用于更新迭代器return next;}iterator erase(iterator first, iterator last){iterator it = first;while (it != last){//删除it指向的节点//删除后让it接收返回值,进行更新it = erase(it);}//返回被删除的  最后一个节点  的下一个节点//用于更新迭代器return last;}bool empty() const{//size==0就   是空    返回true//size!=0就   不是空  返回falsereturn size() ==0 ;}size_t size()const {//用count记录节点个数size_t count = 0;//使用const迭代器接收  const修饰的对象的迭代器const_iterator it = begin();//遍历链表while (it != end()){count++;++it;}return count;}T& back(){//list不能为空,为空就报错assert(!empty());//end()返回的迭代器指向  头结点//头结点的上一个节点就是,最后一个节点//因为是循环链表return *(--end());}//const修饰的成员,只能调用const修饰的成员函数const T& back() const{assert(!empty());return *(--end());}T& front(){//list不能为空,为空就报错assert(!empty());//begin()返回的迭代器  就指向第一个节点return *begin();}//const修饰的成员,只能调用const修饰的成员函数const T& front()const{assert(!empty());return *begin();}template <class InputIterator>void assign(InputIterator first, InputIterator last){//先把数据现有的节点(除了头结点)都删除clear();//再循环把数据一个一个尾插进去while (first != last){//尾插push_back(*first);first++;}}void assign(size_t n, const T& val){clear();for (int i = 0; i < n; i++){push_back(val);}}void assign(int n, const T& val){clear();for (int i = 0; i < n; i++){push_back(val);}}iterator insert(iterator pos, const T& val){//记录指向 pos 前一个节点的指针node* prev = pos._n->_prev;//申请新节点的空间node* newnode = new node;//存储数据newnode->_data = val;newnode->_next = pos._n;newnode->_prev = prev;prev->_next = newnode;pos._n->_prev = newnode;//返回指向新插入的节点的迭代器//用于更新迭代器return newnode;}template <class InputIterator>void insert(iterator pos, InputIterator first, InputIterator last){while (first!=last){//循环插入即可//因为list的迭代器使用完insert之后 不会失效//所以不用接收返回值  也可以insert(pos,*first);first++;}}void push_front(const T& val){insert(begin(), val);}void pop_front(){erase(begin());}void pop_back(){erase(--end());}void resize(size_t n, const T& val = T()){//获取一下size,加快后续比较效率//因为获取size()的时间复杂度为  O(N)size_t size = this->size();if (n > size){//缺失的数据用val填上//填到size()==n为止while (size < n){push_back(val);++size;}}else {//把多出来的数据(节点)删除//删除到n==size()为止while (n < size){pop_back();n++;}}}void clear(){//[begin(),end())之间的数据//就是所有的有效数据(节点)//复用erase删除即可erase(begin(), end());}};
}

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

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

相关文章

tkinter-TinUI-xml实战(12)pip可视化管理器

引言 pip命令行工具在平常使用方面确实足够简单&#xff0c;本项目只是作为TinUI多界面开发的示例。 当然&#xff0c;总有人想用GUI版pip&#xff0c;实际上也有。不过现在&#xff0c;我们就来手搓一个基于python和TinUI&#xff08;tkinter&#xff09;的pip可视化管理器。…

Java SpringAOP简介

简介 官方介绍&#xff1a; SpringAOP的全称是&#xff08;Aspect Oriented Programming&#xff09;中文翻译过来是面向切面编程&#xff0c;AOP是OOP的延续&#xff0c;是软件开发中的一个热点&#xff0c;也是Spring框架中的一个重要内容&#xff0c;是函数式编程的一种衍生…

模块化和包管理工具

一&#xff0c;模块化 1.定义 将一个复杂的程序文件依据一定规则&#xff08;规范&#xff09;拆分成多个文件的过程称之为 模块化 其中拆分出的 每个文件就是一个模块 &#xff0c;模块的内部数据是私有的&#xff0c;不过模块可以暴露内部数据以便其他模块使用 2.模块化…

【React Hooks原理 - forwardRef、useImperativeHandle】

概述 上文我们聊了useRef的使用和实现&#xff0c;主要两个用途&#xff1a;1、用于持久化保存 2、用于绑定dom。 但是有时候我们需要在父组件中访问子组件的dom或者属性/方法&#xff0c;而React中默认是不允许父组件直接访问子组件的dom的&#xff0c;这时候就可以通过forwa…

如何通过网络快速搜寻到自己的STM32设备

目录 一、问题概述 二、解决思路 三、代码实现 1.创建任务 2.UDP广播接收 一、问题概述 以前一直用RS232串口修改设备配置信息&#xff0c;但是现场施工人员的232线太细&#xff0c;经常容易断掉&#xff0c;这次准备用网口去修改&#xff0c;遇到了一个问题&#xff0c;…

【简历】惠州某二本学院:前端简历指导,秋招面试通过率为0

注&#xff1a;为保证用户信息安全&#xff0c;姓名和学校等信息已经进行同层次变更&#xff0c;内容部分细节也进行了部分隐藏 简历说明 这是一份25届二本同学&#xff0c;投递前端职位的简历&#xff0c;那么在校招环节二本同学主要针对的还是小公司&#xff0c;这个学校因为…

【B树、B-树、B+、B*树】

目录 一、B-树&#xff08;即B树&#xff09;的定义及操作1.1、定义1.2、操作1.2.1、查找1.2.2、插入1.2.3、删除 二、B树的定义及操作2.1、定义2.2、操作2.2.1、查找2.2.2、插入2.2.3、删除 三、B*树 一、B-树&#xff08;即B树&#xff09;的定义及操作 1.1、定义 B-tree即…

18_Shell好用工具:sort

18_Shell好用工具&#xff1a;sort 选项说明-k指定要排序的列-nnumber&#xff0c;按照数值大小排序-rreverse&#xff0c;逆序-t分隔符-u去重-o保存排序到文件 一、数字升序 #sort1.txt文件纯数字 #升序 sort -n sort1.txt #降序 sort -nr sort1.txt二、数字升序去重 #数字…

框架设计MVC

重点&#xff1a; 1.用户通过界面操作&#xff0c;传输到control&#xff0c;control可以直接去处理View&#xff0c;或者通过模型处理业务逻辑&#xff0c;然后将数据传输给view。 2.control包含了model和view成员。 链接&#xff1a; MVC框架详解_mvc架构-CSDN博客 MVC架…

C语言------指针讲解(2)

目录 一、数组名的理解 二、使用指针访问数组 三、一维数组传参的本质 四、冒泡排序 五、二级指针 六、指针数组 七、指针数组模拟二维数组 一、数组名的理解 通过学习&#xff0c;我们知道&#xff1a;数组名和数组首元素的地址打印出来的结果一模一样&#xff0c;数组…

【STM32】RTT-Studio中HAL库开发教程三:IIC通信--AHT20

文章目录 一、I2C总线通信协议二、AHT20传感器介绍三、STM32CubeMX配置硬件IIC四、RTT中初始化配置五、具体实现代码六、实验现象 一、I2C总线通信协议 使用奥松的AHT20温湿度传感器&#xff0c;对环境温湿度进行采集。AHT20采用的是IIC进行通信&#xff0c;可以使用硬件IIC或…

顺序表的应用——通讯录

通讯录的实现分为五个文件分别进行编写&#xff0c;分别为&#xff1a;SeqList.c&#xff0c;SeqList.h&#xff0c;Contact.c&#xff0c;Contact.h&#xff0c;test.c 其中前两个文件为上一篇博客中的顺序表的操作&#xff0c;后三个文件为通讯录功能的实现。 SeqList.h #d…

jenkins系列-07.轻易级jpom安装

jpom是一个容器化服务管理工具&#xff1a;在线构建&#xff0c;自动部署&#xff0c;日常运维, 比jenkins轻量多了。 本篇介绍mac m1安装jpom: #下载&#xff1a;https://jpom.top/pages/all-downloads/ 解压&#xff1a;/Users/jelex/Documents/work/jpom-2.10.40 启动前修…

Ubuntu上安装配置samba服务

Ubuntu上安装配置samba服务 在Ubuntu中安装配置samba共享服务&#xff0c;可以让你在网络上共享文件和打印机。以下是一个相对详细的步骤指南&#xff0c;介绍如何在Ubuntu上安装和配置Samba。 1. 安装Samba 首先&#xff0c;需要安装Samba软件包。打开终端并运行以下命令&a…

在SpringCloud中如何轻松实现微服务间的通信

在Spring Cloud中&#xff0c;实现微服务间的通信非常简单。Spring Cloud提供了多种方式来进行微服务之间的通信&#xff0c;包括使用RestTemplate、Feign、Ribbon、Eureka等组件。下面我将详细介绍这些方式的使用方法。 使用RestTemplate进行通信&#xff1a; RestTemplate是S…

Qt 多语言

记录Qt多语言的实现过程 目录 1.项目配置文件.pro配置 2.程序中的字符串用tr()封装 3.生成翻译文件 4.使用Qt语言家修改翻译文件 4.1使用Qt语言家打开 4.2 .更改文件配置 5. 生成qm文件 6.代码执行切换语言 6.1入口处 6.2 事件执行 0.效果 1.项目配置文件.pro配置 T…

2024年【天津市安全员C证】免费试题及天津市安全员C证考试技巧

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 天津市安全员C证免费试题根据新天津市安全员C证考试大纲要求&#xff0c;安全生产模拟考试一点通将天津市安全员C证模拟考试试题进行汇编&#xff0c;组成一套天津市安全员C证全真模拟考试试题&#xff0c;学员可通过…

【C++刷题】[UVA 489]Hangman Judge 刽子手游戏

题目描述 题目解析 这一题看似简单其实有很多坑&#xff0c;我也被卡了好久才ac。首先题目的意思是&#xff0c;输入回合数&#xff0c;一个答案单词&#xff0c;和一个猜测单词&#xff0c;如果猜测的单词里存在答案单词里的所有字母则判定为赢&#xff0c;如果有一个字母是答…

docker安装nginx并配置https

参考 docker安装nginx并配置https-腾讯云开发者社区-腾讯云 (tencent.com) 证书的生成 参见&#xff1a;SpringBoot项目配置HTTPS接口的安全访问&#xff08;openssl配置&#xff09;_配置接口访问-CSDN博客 步骤 1: 拉取Nginx镜像 docker pull nginx 好使的镜像如下&#x…

「漏洞复现」同享人力资源管理系统-TXEHR V15 DownloadTemplate 文件读取漏洞

0x01 免责声明 请勿利用文章内的相关技术从事非法测试&#xff0c;由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c;作者不为此承担任何责任。工具来自网络&#xff0c;安全性自测&#xff0c;如有侵权请联系删…