C++-list实现相关细节和问题

       前言：C++中的最后一个容器就是list，list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。下面我们就来模仿官方库中的list，自行实现一个list，并从中总结实现细节和经验。

目录

1.基本节点类和链表类的框架

数据节点类

list节点类

尾插函数

2.迭代器类的实现

迭代器的分类及实现

为什么不用析构函数和深拷贝？

为什么能使用前置++就不用后置++？

怪异的" -> "?地址解引用重载

如何在list类中使用迭代器

3.插入删除函数

4.const迭代器和拷贝赋值函数

const iterator和const_iterator？......有区别吗？

实现const_iterator

模板参数列表泛式编程

迭代器类终极版

拷贝构造和赋值函数

5.必须采用typename格式的场景

6.源码看这里

list.h

test.cpp

 

1.基本节点类和链表类的框架

数据节点类

        list的实现不同于其他的容器，比如vector等，list的底层是一个双向链表结构，每一个节点都由三部分组成，分别是数据，上一个节点和下一个节点，所以，对于list所存储的数据成员，我们需要单独开一个结构体来表示链表中的每一个数据成员，

template<class T>struct list_node //链表的数据成员结构{T _data;list_node<T>* _next;list_node<T>* _prev;list_node(const T& x = T())//给一个匿名对象:_data(x), _next(nullptr), _prev(nullptr){}};

list节点类

接着就是list类的创建，我们知道，双线链表大致的结构如下所示，我们list的设计也基本遵循这个框架，

template<class T>class list {typedef list_node<T> Node;public:void empty_init()//空list初始化{_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_init();}size_t size(){return _size;}private:Node* _head;//虚拟的头结点，实际上第一个节点在该节点的下一个位置上，而尾结点end就是头结点的位置，这样，方便我们构成双向链表size_t _size;//链表长度，因为遍历一遍链表需要花费大量的时间，所以建议当做数据成员存储};

尾插函数

在上面功能的基础上，我们就可以实现简易的push_back函数了，这里就不再赘述，

void push_back(const T& x){//此时我们的最后一个元素是头结点的上一个元素，因为我们是一个双向循环链表,现在head和end都指向哨兵节点Node* tail = _head->_prev;Node* newnode = new Node(x);tail->_next = newnode;newnode->_prev = tail;newnode->_next = _head;_head->_prev = newnode;}

2.迭代器类的实现

迭代器的分类及实现

list官方库中对迭代器的要求：

       对于我们的list中的迭代器来说，我们常见的迭代器的使用需要满足，比如取数据，修改数据等，但是我们的list存储的实际上是一个个结构体，对结构体解引用编译器不认识，并且我们的链表存储并不是顺序表的顺序结构，而是随机存储结构，简单的对于迭代器地址增加并不能找到下一个数据，而且还涉及多种迭代器类型的使用，比如反向迭代器等，所以，list的迭代器需要具备取数据，++或者--自动到目标节点等等的功能，涉及重载函数等功能，因此，为了方便我们的使用，我们便让迭代器自成一个类，采用封装加重载的方式，这样我们就可以创建迭代器对象来更加方便地访问数据成员和其他操作。

为什么不用析构函数和深拷贝？

         迭代器本身作为一个链表的访问工具，但是如果写析构函数，在迭代器对象析构时，因为迭代器本身是指向链表节点的一个指针，释放指针必然会导致节点被影响，这是我们不允许的，所以不能写析构函数，采用默认的空操作的析构函数即可。

       而对于迭代器的深浅拷贝问题，迭代器本质上是节点的指针，但是并不是迭代器所指向的资源就归迭代器管理，我们只是把迭代器作为遍历和修改的工具，本质上就是让迭代器移动遍历，因此只需要浅拷贝链表节点即可。

为什么能使用前置++就不用后置++？

        我们看见上面的前置和后置++的区别在于一个返回本对象，另一个则返回本对象的拷贝，返回对象的拷贝的后置++在返回时返回的是临时对象tmp的拷贝，也就需要再次调用我们自定义的拷贝构造函数，在时间上不如前置++效率高。

怪异的" -> "?地址解引用重载

我们在上面的函数中有这样一个函数重载：

     当数据存在自定义对象时，比如我们的数据成员就是一个结构体，我们链表的节点保存的是结构体指针，那么我们如何取获得结构体中的数据成员的值呢，我们需要对迭代器进行解引用操作才能获取具体的元素的值，除了直接用（*it).xx来访问，我们还经常采用一种方式，就是it->xx的方式，上面这个函数就是我们需要采用该解引用方法时所需要重载的->运算符，重载完后即可正常使用地址解引用操作。

 

如何在list类中使用迭代器

         现在我们的迭代器自成一个类，但是我们需要在list类中使用它，我们就可以将迭代器定义在我们的类域内即可调用：

 

3.插入删除函数

      在官方库的inert和erase函数中，更加推荐使用迭代器作为返回值，在容器中，我们选择元素一般都会以迭代器的位置为基准，对于insert函数，因为不会涉及扩容问题，也就不存在迭代器失效问题，所以，我们可以返回插入元素位置的迭代器，方便对迭代器的再使用，同时对于erase函数，删除迭代器位置上的元素，节点删除必然会导致节点空间的释放，将必然导致迭代器失效，所以我们根据官方的文档中的解决方法，索性直接返回被删除元素的下一个位置的迭代器即可。

iterator insert(iterator pos,const T&x)//我们和官方文档的函数保持一致，返回新插入元素的迭代器(在pos位置之前插入){Node* newnode = new Node(x);//因为不存在扩容，所以不存在迭代器失效问题Node* prev = (pos._node)->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = pos._node;(pos._node)->_prev = newnode;++_size;return iterator(newnode);//类型转换}iterator erase(iterator pos)//返回删除元素的下一个位置{Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;delete cur;//释放掉后迭代器失效prev->_next = next;next->_prev = prev;--_size;return iterator(next);}

因为迭代器的使用，我们就可以顺势写出一下的常用函数接口：

~list()
{clear();//不释放头结点delete _head;_head = nullptr;
}void clear()
{iterator it = begin();while (it != end()){it = erase(it);}
}
void push_back(const T& x)
{insert(end(), x);//优化
}void push_front(const T& x)
{insert(begin(), x);
}void pop_front()
{erase(begin());
}void pop_back()
{erase(--end());
}

4.const迭代器和拷贝赋值函数

const iterator和const_iterator？......有区别吗？

      首先，我们要知道，const迭代器是修饰迭代器所指向的元素本身不能被改变而不是修饰迭代器本身的指向不能被改变，const迭代器的类型相当于const T*而不是T*const，而const iterator相当于直接修饰了迭代器，相当于定死了迭代器就是指向某一个元素，这违背了我们使用迭代器作为遍历工具的原则，const迭代器产生就是为了遍历只读元素使用，而const_iterator就是这样一种特定的迭代器类型，这一点要做好区分。

实现const_iterator

     要实现const迭代器，我们就要知道，在原迭代器类中，哪些函数时能够影响到修改数据成员的，显然，只有对迭代器进行解引用才会影响数据修改，所以，我们只需要在原来的迭代器类的基础上，限定重载的解引用运算符即可，

当然，我们需要在list类中引入const迭代器类到类域中去：

模板参数列表泛式编程

     上面的const迭代器虽然实现了，但是我们要写两个迭代器类，而且两个迭代器类只有重载解引用操作时才会有不同的行为，而我们为了这个要多些一个类，实在是太麻烦了，我们就来看一看C++祖师爷是如何解决的吧，

        

       这也太香了，相当于模板参数列表里增加了两个模板参数，返回值根据参数来影响重载运算符的返回值类型，不愧是祖师爷，这也是泛式编程的思想，封装屏蔽了底层的实现细节，提供统一的访问方式。

不多说了，拿来吧你~~

迭代器类终极版

template<class T,class Ref,class Ptr>struct __list_iterator  //我们尽量与官方文档的保持一致{typedef list_node<T> Node;typedef __list_iterator<T,Ref,Ptr> self;//迭代器对象起别名Node* _node;__list_iterator(Node* node)//节点的指针可以隐式类型转换成迭代器:_node(node){}//对迭代器需要进行++和解引用操作，注意，迭代器的解引用应该是得到数据本身，所以我们的解引用也需要重载self operator++()//前置++{_node = _node->_next;return *this;}self& operator--()//前置--{_node = _node->_prev;return *this;}self& operator++(int)//后置++{self temp(*this);_node = _node->_next;return temp;}self& operator--(int)//后置++{self temp(*this);_node = _node->_prev;return temp;}//对于影响const迭代器调用的功能的函数传不同的返回值类型时使用Ref operator*(){return _node->_data;}Ptr operator->(){return &(_node->_data);}bool operator!=(const self& s)//迭代器比较结束条件判断{return _node != s._node;}bool operator==(const self& s){return _node == s._node;}};

拷贝构造和赋值函数

       之所以把这一个知识放在迭代器实现完全之后再将，是因为我们在拷贝和赋值时经常需要传递const对象，而我们前面的迭代器是非const版本，无法对const对象进行解引用操作，也就导致了无法拷贝const对象，所以放在这里进行讲解，但是此时这两个函数用我们自己提供的接口完全可以实现，这里也不涉及深浅拷贝的问题，就直接给出了，

//拷贝构造list(const list<T>& lt){empty_init();for (auto e : lt)//迭代器重载后取得是数据元素，故可以使用push_back(e);}//赋值操作list& operator=(const list<T>& lt)//返回值也可以写list类型，类内均正确,但是为规范不建议{if (this != &lt){clear();//先清空原来的链表,但头结点还在for (auto e : lt)push_back(e);}return *this;}

5.必须采用typename格式的场景

基于以上的代码，我们来运行下面的测试样例：

template<class T>void print_list(const list<T>& lt){list<T>::const_iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";it++;}cout << endl;}void test_list4(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);print_list(lt);list<string> lt2;lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");print_list(lt2);}

看上去没什么问题吧，我们也用了类模板，应该是能跑起来的，但是实际上，

这上面说，让我们在迭代器类型前面加一个typename，这是为什么呢？

     在编译阶段，编译器只能看到我们的list是list<T>类型的，模板还没有被实例化，导致编译器无法在对应的类中找到类域下的成员，向上面的const_iterator，编译器因为list<T>是未实例化的模板，所以也无法在确定的类域内找到const_iterator相应的实现和功能，所以编译器不认识这个变量是什么，也就导致了出错，前面加一个typename是告诉编译器，这里是一个类型，等list<T>实例化再去类里面去取。

void test_list4(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);print_container(lt);list<string> lt2;lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");print_container(lt2);vector<string> v;v.push_back("222222222222");v.push_back("222222222222");v.push_back("222222222222");v.push_back("222222222222");v.push_back("222222222222");print_container(v);}

6.源码看这里

list.h

#pragma once
#include <vector>
namespace my_std
{template<class T>struct list_node //链表的数据成员结构{T _data;list_node<T>* _next;list_node<T>* _prev;list_node(const T& x = T())//给一个匿名对象:_data(x), _next(nullptr), _prev(nullptr){} };template<class T,class Ref,class Ptr>struct __list_iterator  //我们尽量与官方文档的保持一致{typedef list_node<T> Node;typedef __list_iterator<T,Ref,Ptr> self;//迭代器对象起别名Node* _node;__list_iterator(Node* node)//节点的指针可以隐式类型转换成迭代器:_node(node){}//对迭代器需要进行++和解引用操作，注意，迭代器的解引用应该是得到数据本身，所以我们的解引用也需要重载self operator++()//前置++{_node = _node->_next;return *this;}self& operator--()//前置--{_node = _node->_prev;return *this;}self& operator++(int)//后置++{self temp(*this);_node = _node->_next;return temp;}self& operator--(int)//后置++{self temp(*this);_node = _node->_prev;return temp;}//对于影响const迭代器调用的功能的函数传不同的返回值类型时使用Ref operator*(){return _node->_data;}Ptr operator->(){return &(_node->_data);}bool operator!=(const self& s)//迭代器比较结束条件判断{return _node != s._node;}bool operator==(const self& s){return _node == s._node;}};template<class T>class list {public:typedef list_node<T> Node;typedef __list_iterator<T,T&,T*> iterator;typedef __list_iterator<T, const T&,const T*> const_iterator;iterator begin(){return _head->_next;}iterator end(){return _head;}const_iterator begin()const {return const_iterator(_head->_next);//含隐式类型转换，自己写转不转换都行}const_iterator end()const{return _head;}void empty_init()//空list初始化{_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_init();}//拷贝构造list(const list<T>& lt){empty_init();for (auto e : lt)//迭代器取得是数据元素，故可以使用push_back(e);}//赋值操作list& operator=(const list<T>& lt)//返回值也可以写list类型，类内均正确,但是为规范不建议{if (this != &lt){clear();//先清空原来的链表,但头结点还在for (auto e : lt)push_back(e);}return *this;}~list(){clear();//不释放头结点delete _head;_head = nullptr;}void clear(){iterator it = begin();while (it != end()){it = erase(it);}}void push_back(const T& x){//此时我们的最后一个元素是头结点的上一个元素，因为我们是一个双向循环链表,现在head和end都指向哨兵节点/*Node* tail = _head->_prev;Node* newnode = new Node(x);tail->_next = newnode;newnode->_prev = tail;newnode->_next = _head;_head->_prev = newnode;*/insert(end(), x);}void push_front(const T& x){insert(begin(), x);}void pop_front(){erase(begin());}void pop_back(){erase(--end());}iterator insert(iterator pos,const T&x)//我们和官方文档的函数保持一致，返回新插入元素的迭代器(在pos位置之前插入){Node* newnode = new Node(x);//因为不存在扩容，所以不存在迭代器失效问题Node* prev = (pos._node)->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = pos._node;(pos._node)->_prev = newnode;++_size;return iterator(newnode);//类型转换}iterator erase(iterator pos)//返回删除元素的下一个位置{Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;delete cur;//释放掉后迭代器失效prev->_next = next;next->_prev = prev;--_size;return iterator(next);}size_t size(){return _size;}private:Node* _head;//虚拟的头结点，实际上第一个节点在该节点的下一个位置上，而尾结点end就是头结点的位置，这样，方便我们构成双向循环链表size_t _size;//链表长度，因为遍历一遍链表需要花费大量的时间，所以建议当做数据成员存储};void test_list1(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);// 封装屏蔽底层差异和实现细节// 提供统一的访问修改遍历方式list<int>::iterator it = lt.begin();//迭代器需要单独编写迭代器类，以供应需求，说清楚为什么需要编写(迭代器的种类)，重载哪些运算符等while (it != lt.end()){*it += 20;cout << *it << " ";it++;}cout << endl;for (auto e : lt){cout << e << " ";}cout << endl;}void test_list2(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);list<int> lt1(lt);for (auto e : lt){cout << e << " ";}cout << endl;for (auto e : lt1){cout << e << " ";}cout << endl;list<int> lt2;lt2.push_back(10);lt2.push_back(20);lt2.push_back(30);lt2.push_back(40);lt2.push_back(50);lt1 = lt2;for (auto e : lt1){cout << e << " ";}cout << endl;for (auto e : lt2){cout << e << " ";}cout << endl;}struct AA{AA(int a1 = 0, int a2 = 0):_a1(a1), _a2(a2){}int _a1;int _a2;};void test_list3(){list<AA> lt;lt.push_back(AA(1, 1));lt.push_back(AA(2, 2));lt.push_back(AA(3, 3));list<AA>::iterator it = lt.begin();while (it != lt.end()){//cout << (*it)._a1<<" "<<(*it)._a2 << endl;cout << it->_a1 << " " << it->_a2 << endl;//本来应该是it->->_a1,编译器特殊处理，省略了一个->cout << it.operator->()->_a1 << " " << it.operator->()->_a1 << endl;//显式调用运算符重载函数++it;}cout << endl;}//typename场景template<class T>void print_list(const list<T>& lt){typename list<T>::const_iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";it++;}cout << endl;}//再抽象，我们可以将类型再抽象为容器，这样就可以打印list之外的容器的元素template<typename Container>void print_container(const Container& lt){typename Container::const_iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";it++;}cout << endl;}void test_list4(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);print_container(lt);list<string> lt2;lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");lt2.push_back("1111111111111");print_container(lt2);vector<string> v;v.push_back("222222222222");v.push_back("222222222222");v.push_back("222222222222");v.push_back("222222222222");v.push_back("222222222222");print_container(v);}
}

test.cpp

#include<iostream>
using namespace std;
#include"list.h"int main()
{my_std::test_list4();return 0;
}

        当你越来越专注，越来越自律，顺其自然得社交，随时随地地启程，开始爱惜自己，不在意他人的议论揣测，拿得起放得下，你就成为了很棒的自己。 

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

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

相关文章

方面级别情感分析之四元组预测

方面级别情感分析之四元组预测

情感四元组预测现有方法 阅读本文之前我们默认你对情感分析有基本的认识。 如果没有请阅读文章(https://tech.tcl.com/post/646efb5b4ba0e7a6a2da6476) 情感分析四元组预测涉及四个情感元素: 方面术语a&#xff0c;意见术语(也叫观点术语)o&#xff0c; 方面类别ac&#xff0c…
阅读更多...
0基础学习VR全景平台篇 第93篇：智慧景区教程

0基础学习VR全景平台篇 第93篇：智慧景区教程

一、上传素材 1.上传全景素材 第一步&#xff1a;进入【素材管理】 第二步&#xff1a;选择【全景图智慧景区】分类 第三步&#xff1a;选择相对景区作品分组&#xff0c;上传全景素材 2.素材标注 第一步&#xff1a;选择上传成功后素材&#xff0c;点击【未标注】 第二步&…
阅读更多...
15-数据结构-二叉树的遍历，递归和非递归

15-数据结构-二叉树的遍历，递归和非递归

简介&#xff1a; 本文主要是代码实现&#xff0c;二叉树遍历&#xff0c;递归和非递归&#xff08;用栈&#xff09;。主要为了好理解&#xff0c;直接在代码处&#xff0c;加了详细注释&#xff0c;方便复习和后期默写。主要了解其基本思想&#xff0c;为后期熟练应用…
阅读更多...
VMware 设置仅主机模式无法访问外网的问题说明

VMware 设置仅主机模式无法访问外网的问题说明

参考链接 VMware仅主机模式访问外网 如果根据以上参看仍旧无法访问物理机网段其他设备以及无法访问外网&#xff0c;可以尝试在虚拟机上根据 vmnet1 网卡设置的 ip 地址添加默认路由&#xff0c;如下图所示&#xff1a; 首先查看对应网卡设置的 ip 地址 然后在虚拟机上执行如…
阅读更多...
为什么别的职业都是越老越值钱，唯独程序员越老越容易失业？

为什么别的职业都是越老越值钱，唯独程序员越老越容易失业？

因为其他职业都是技术稀缺型产业&#xff0c;而程序员却是技术密集型产业。 那些越老越值钱的职业有一个特征&#xff1a;越资深越稀缺&#xff0c;靠技术经验积累或是人脉资源吃饭&#xff0c;如医生、律师、老师等&#xff0c;而程序员这一职业的技术经验、人脉资源的积累相对…
阅读更多...
git-tf clone 路径有空格处理方案

git-tf clone 路径有空格处理方案

git-tf clone 路径存在空格情况下&#xff0c;运行命令报错&#xff1b; 需要对路径进行双引号处理
阅读更多...
应用TortoiseSVN的SubWCRev管理VisualStudio C#项目编译版本号

应用TortoiseSVN的SubWCRev管理VisualStudio C#项目编译版本号

首先要安装 TortoiseSVN, 并确保TortoiseSVN的bin目录被加入到系统环境变量Path中。 1、拷贝Porperties目录下的文件AssemblyInfo.cs生成副本AssemblyInfo.template, 作为版本管理的模板文件。 2、修改模板文件中的想要管理的版本号信息 // [assembly: AssemblyVersion(&quo…
阅读更多...
MySQL 日期格式 DATETIME 和 TIMESTAMP

MySQL 日期格式 DATETIME 和 TIMESTAMP

MySQL日期格式介绍 存储日期的方式mysql中存储日期的格式datetimetimestampDatetime和Timestamp的比较相同点&#xff1a;不同点&#xff1a; 数值型时间戳&#xff08;INT&#xff09;DATETIME vs TIMESTAMP vs INT&#xff0c;怎么选&#xff1f; 存储日期的方式 字符串Date…
阅读更多...
EasyAVFilter的初衷：把ffmpeg.c当做SDK来用，而不是当做EXE来用

EasyAVFilter的初衷：把ffmpeg.c当做SDK来用，而不是当做EXE来用

之前我们做一个视频点播的功能&#xff0c;大概的流程就是将上传上来的各种格式的视频&#xff0c;用FFmpeg统一进行一次转码&#xff0c;如果probe到视频的编码格式是H.264就调用-vcodec copy&#xff0c;如果probe到视频的编码格式不是H.264就调用-vcodec libx264&#xff0c…
阅读更多...
SSH远程连接macOS服务器：通过cpolar内网穿透技术实现远程访问的设置方法

SSH远程连接macOS服务器：通过cpolar内网穿透技术实现远程访问的设置方法

文章目录 前言1. macOS打开远程登录2. 局域网内测试ssh远程3. 公网ssh远程连接macOS3.1 macOS安装配置cpolar3.2 获取ssh隧道公网地址3.3 测试公网ssh远程连接macOS 4. 配置公网固定TCP地址4.1 保留一个固定TCP端口地址4.2 配置固定TCP端口地址 5. 使用固定TCP端口地址ssh远程 …
阅读更多...
kali的学习

kali的学习

网络配置 1.kali的网络设置 首先我们了解kali的网络设置 DHCP&#xff1a;动态主机配置协议 是一个局域网的协议 使用UDP 协议工作静态IP&#xff1a;用于大部分的中小型网络 通过网络管理员手动分配IP原理进程 /etc 系统大部分服务启动过程都要访问该目录 我们直接去看看…
阅读更多...
算法笔记：球树

算法笔记：球树

1 KD树的问题 算法笔记&#xff1a;KD树_UQI-LIUWJ的博客-CSDN博客 在kd树中&#xff0c;导致性能下降的最核心因素是因为kd-tree中被分割的子空间是一个个的超方体&#xff0c;而求最近邻时使用的是欧式距离&#xff08;超球&#xff09;。超方体与超球体相交的可能性是极高…
阅读更多...
keepalived + lvs (DR)

keepalived + lvs (DR)

目录 一、概念 二、实验流程命令 三、实验的目的 四、实验步骤 一、概念 Keepalived和LVS&#xff08;Linux Virtual Server&#xff09;可以结合使用来实现双机热备和负载均衡。 Keepalived负责监控主备服务器的可用性&#xff0c;并在主服务器发生故障时&#xff0c;将…
阅读更多...
maven可用的插件列表

maven可用的插件列表

maven可用的插件列表&#xff1a;https://maven.apache.org/plugins/ 在插件列表页面找到自己想要了解的插件&#xff0c;点击进去&#xff0c;可以看到插件的详细信息&#xff0c;例如这个插件有哪些goals&#xff0c;goal的参数、用法、样例等&#xff0c;还是很有用的。 B…
阅读更多...
​LeetCode解法汇总57. 插入区间

​LeetCode解法汇总57. 插入区间

目录链接&#xff1a; 力扣编程题-解法汇总_分享记录-CSDN博客 GitHub同步刷题项目&#xff1a; https://github.com/September26/java-algorithms 原题链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 描述&#xff1a; 给你一个 …
阅读更多...
自动化测试之unittest框架

自动化测试之unittest框架

unittest 1、什么是Unittest框架&#xff1f; python自带一种单元测试框架 2、为什么使用UnitTest框架&#xff1f; >批量执行用例 >提供丰富的断言知识 >可以生成报告 3、核心要素 1).TestCase&#xff08;测试用例&#xff09; 2).TestSuite(测试套件)…
阅读更多...
用Idea把SpringBoot项目打包镜像上传至docker

用Idea把SpringBoot项目打包镜像上传至docker

1、设置docker把2375端口开起来 命令查看docker装在哪里 vim docker.service 新增 -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock 2、配置Dockerfile 我在跟pom同一层 3、配置docker-maven-plugin <plugin><groupId>com.spotify</groupId><arti…
阅读更多...
大数据项目实战（Sqoop安装）

大数据项目实战（Sqoop安装）

一&#xff0c;搭建大数据集群环境 1.4 Sqoop安装 1.sqoop安装 &#xff08;1&#xff09;上传安装包 &#xff08;2&#xff09;解压安装包 tar -zxvf sqoop-1.4.6.bin__hadoop-2.0.4-alpha.tar.gz -C /export/servers &#xff08;3&#xff09;重命名 mv sqoop-1.4.6.b…
阅读更多...
IntelliJ IDEA 2023.2.1使用Git时弹出“使用访问令牌登录”问题解决

IntelliJ IDEA 2023.2.1使用Git时弹出“使用访问令牌登录”问题解决

这里写目录标题 一、内网Git环境GitLabGogsGitea 二、外网Git环境GitHubGitee 升级为IntelliJ IDEA 2023.2.1后&#xff0c;使用Git时弹出“使用访问令牌登录”的窗口&#xff0c;习惯使用Git帐号密码登录的用户&#xff0c;面对这个突如其来的弹窗真的很懵。 一、内网Git环境 …
阅读更多...
RabbitMQ快速上手及讲解

RabbitMQ快速上手及讲解

前言&#xff1a;在介绍RabbitMQ之前&#xff0c;我们先来看下面一个场景&#xff1a; 1.1.1.1 异步处理 场景说明&#xff1a; 用户注册后&#xff0c;需要发注册邮件和注册短信&#xff0c;传统的做法有两种 1.串行的方式 (1)串行方式&#xff1a;将注册信息写入数据库后&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023