【C++】list的模拟实现【完整理解版】

目录

一、list的概念引入

1、vector与list的对比

 2、关于struct和class的使用

3、list的迭代器失效问题 

 二、list的模拟实现

1、list三个基本函数类

2、list的结点类的实现

3、list的迭代器类的实现 

3.1 基本框架

3.2构造函数 

3.3 operator*

3.4 operator->

3.5 operator前置++和--与后置++和-- 

3.5 operator==与operator!=

4、list类的实现

 4.1 基本框架

4.2 构造函数 

4.2 begin()和end()

4.3 拷贝构造

4.4  clear

4.5 operator=

4.6  析构函数

 4.7 insert

4.8 push_back 和 push_front

4.9 erase

4.10 pop_back 和 pop_front

三、完整源代码：

list.h:

 test.cpp:

一、list的概念引入

1、vector与list的对比

 两者的区别十分类似于顺序表和链表的区别

 2、关于struct和class的使用

C++中的struct和class的唯一区别在于默认访问限定符（即你不写public、private这种访问限定符）不同，struct默认为公有（public），而class默认为私有（private），一般情况，成员部分私有，部分共有，就用class，所有成员都开放或共有，就用struct

所以下文写的节点和迭代器类都用struct是因为，struct中的成员函数默认为公有了，也不用写public了，但是你用class就要写个public

3、list的迭代器失效问题 

 list本质：带头双向循环链表 

支持操作接口的角度分迭代器的类型：单向（forward_list）、双向（list）、随机（vector）

从使用场景的角度分迭代器的类型：（正向迭代器，反向迭代器）+const迭代器

 迭代器失效本质是内存空间的问题，失效原因：

1、增容完还指向旧空间

2、节点已经被释放（list里面）

list的erase迭代器失效

注意：删除不会报错，迭代器失效也不会报错，是删除以后迭代器失效了，是去访问失效的迭代器才会报错

插入知识点（库里面的find实现，可不看）

 二、list的模拟实现

1、list三个基本函数类

list本质是一个带头双向循环链表：

模拟实现list，要实现下列三个类：

①、模拟实现结点类
②、模拟实现迭代器的类
③、模拟list主要功能的类
list的类的模拟实现其基本功能（增删等操作）要建立在迭代器类和结点类均已实现好的情况下才得以完成。

2、list的结点类的实现

因为list的本质为带头双向循环链表，所以其每个结点都要确保有下列成员：

  1. 前驱指针
  2. 后继指针
  3. data值存放数据

而结点类的内部只需要实现一个构造函数即可。

//1、结点类
template<class T>
struct __list_node//前面加__是命名习惯,一般这么写表示是给别人用的
{//前驱指针和后驱指针__list_node<T>* _next;//C++中可不写struct，直接用名定义，但注意这里还要加类型__list_node<T>* _prev;T _data;//存节点的值//构造函数__list_node(const T& val = T())//给一个缺省值T():_next(nullptr), _prev(nullptr), _data(val){}
};

①、为什么是__list_node<T>？

首先，C++中用struct定义时可不加struct，重点是这里用了一个类模板，类模板的类名不是真正的类型，即__list_node不是真正的类型，定义变量时__list_node<T>这种才是真正的类型，也就是用类模板定义变量时必须 指定对应的类型 

3、list的迭代器类的实现 

因为list其本质是带头双向循环链表，而链表的物理空间是不连续的，是通过结点的指针顺次链接，我们不能像先前的string和vector一样直接解引用去访问其数据，结点的指针解引用还是结点，结点指针++还是结点指针，而string和vector的物理空间是连续的，所以这俩不需要实现迭代器类，可以直接使用。

为了能让list像vector一样解引用后访问对应节点中的值，++访问到下一个数据，我们需要单独写一个迭代器类的接口实现，在其内部进行封装补齐相应的功能，而这就要借助运算符重载来完成。 

注：迭代器封装后是想模拟指针的行为 

3.1 基本框架

template<class T,class Ref,class Ptr>
struct __list_iterator
{typedef __list_node<T> Node;typedef __list_iterator<T, Ref, Ptr> Self;Node* _node;
}

①、迭代器类模板为什么要三个参数？

若只有普通迭代器的话，一个class T参数就够了，但因为有const迭代器原因，需要加两个参数，两个参数名Ref（reference:引用）和Ptr（pointer:指针），名字怎么起都行，但这种有意义的名字是很推荐的，即这两个参数一个让你传引用，一个让你传指针，具体等下文讲到const迭代器再说

②、迭代器类到底是什么？

迭代器类就一个节点的指针变量_node，但是因为我们要运算符重载等一系列操作，不得不把list的迭代器写成类，完成那些操作，list的迭代器才能正确的++到下一位置，解引用访问节点的值

③、节点指针和迭代器的区别？

3.2构造函数 

	//迭代器的构造函数只需要一个指针构造__list_iterator (Node* node):_node(node){ }

3.3 operator*

//*it（调用的是函数，返回节点中的值）Ref operator*(){//出了作用域还在，引用返回return _node->_data;}

①、 返回值为什么是Ref？

Ref是模板参数，因为迭代器类的模板参数Ref传入的要么是T&要么是const T&，就是为了const迭代器和普通迭代器的同时实现，底层就是这么实现的，意义就是一个只读，一个可读可写 

注：比如之前讲的vector的迭代器，*it（假设it是迭代器变量）就是拿到对应的值，那么list的迭代器也要同理，解引用迭代器就是为了访问对应位置的值，那么list只要通过迭代器返回对应节点的值就好了（*it，我们是就想要对应的值）

3.4 operator->

Ptr operator->(){return &_node->_data;}

①、为什么需要operator->？

本质因为自定义类型需要，那需从list存的类型是个自定义类型说起，以Date类型为例

 若list存了个自定义类型的Date类，程序错误，因为我们并没有重载Date类的operator<<，若是内置类型的话才可以正常输出，那写一个operator<<重载吗？不，因为你无法确定要用哪些类，也不能每个类都写operator<<，那怎么办？我们访问Date类本质是想访问它内置类型（int）的_year、_month和_day吧，那我们不妨写个专属于自定义类型的operator->（因为内置类型只需要*it就可以直接输出了，但自定义类型不可以直接输出），利用operator->直接访问类的成员变量，而内置类型可以直接输出

故从根源上解决问题： 在迭代器中实现个operator->：

（Ptr是迭代器的模板参数，我们用来作为T*或const T*的）

3.5 operator前置++和--与后置++和-- 

//++it;（迭代器++本质就是指针往后移，加完后还应是个迭代器）Self& operator++(){_node = _node->_next;return *this;}//it++;Self operator++(int)//加参数以便于区分前置++{Self tmp(*this);//拷贝构造tmp_node = _node->_next;//直接让自己指向下一个结点即可实现++return tmp;//注意返回tmp，才是后置++}//--it;Self& operator--(){_node = _node->_prev;//让_node指向上一个结点即可实现--return *this;}//it--;Self operator--(int)//记得传缺省值以区分前置--{Self tmp(*this);//拷贝构造tmp_node = _node->_prev;return tmp;}

①、迭代器++对于list是什么意思？

迭代器++的意思就是想让其指向下一个节点，--正好相反，为了区分前置和后置++（--），我们会用函数重载，也就是多一个“没用的”参数：int，这个参数没什么用，只是为了区分++与--

3.5 operator==与operator!=

//it != end() bool operator!=(const Self& it){//迭代器是否相等只要判断对应节点地址是否相等即可return _node != it._node;}bool operator==(const Self& it){return _node == it._node;}

①、两个迭代器怎么比较的？

迭代器中就一个成员变量_node，节点指针，只要比较当前的节点指针是否相同即可，个人认为这个操作意义不大

4、list类的实现

 在结点类和迭代器类都实现的前提下，就可实现list主要功能：增删等操作的实现

 4.1 基本框架

//3、链表类
template<class T>
class list
{typedef __list_node<T> Node;
public:typedef __list_iterator<T,T&,T*> iterator;typedef __list_iterator<T,const T&,const T*> const_iterator;private:Node* _head;//头结点
}

①、const_iterator(const迭代器的介绍)

我们知道const_iterator在begin()和end()中的返回值是需要用到的，其主要作用就是当迭代器只读时使用， 因为普通迭代器和const迭代器的实现区别仅仅在于内部成员函数的返回值不同，难道重写一遍吗？不用，我们模板参数多两个就好了，一个是引用class Ref（T&或const T&），一个是指针class Ptr（T*或const T*），当Ref时const T&就是const迭代器的调用，当Ref时T& 时就是普通迭代器的调用，这就利用模板实现了两个迭代器的同时实现

4.2 构造函数 

//带头双向循环链表的构造函数
list()
{_head = new Node;_head->_next = _head;_head->_prev = _head;
}

解释：我们开辟一个头结点，然后使其处于一个对应的初始状态即可

4.2 begin()和end()

iterator begin()
{//第一个位置应该是头结点的下一个节点return iterator(_head->_next);//用匿名对象构造iterator类型的
}
iterator end()
{//最后一个数据的下一个位置应该是第一个节点，即头结点return iterator(_head);
}const_iterator begin()const
{return const_iterator(_head->_next);
}
const_iterator end()const
{return const_iterator(_head);
}

①、关于匿名构造的理解

比如 iterator(_head->_next); iterator是个类模板类型（它被typedef过的），那不应该实例化一个对象再构造吗？这里没有用是因为这里是匿名对象的构造，这里这么用比较方便

4.3 拷贝构造

//拷贝构造：传统写法
list(const list<T>& lt)
{_head = new Node;//开辟一样的头结点_head->_next = _head;_head->_prev = _head;//1、用迭代器遍历/*const_iterator it = lt.begin();while (it != lt.end()){push_back(*it);++it;}*///2、范围for遍历//遍历lt1，把lt1的元素push_back到lt2里头for (auto e : lt){push_back(e);//自动开辟新空间，完成深拷贝}
}

 解释：list的拷贝构造跟vector不同，它的拷贝是拷贝一个个节点（因为不连续的物理空间）， 那么我们可以用迭代器拿到list的一个个节点

①、为什么有的拷贝构造需初始化，operator=不需要？

以string的模拟实现为例

这里为什么s2要初始化？

是因为string的模拟实现有交换操作，而list的传统写法无需交换，开辟一个头结点即可

因为s2是要被拷贝构造出来的，没被拷贝构造前还没存在，然后s2要跟tmp交换，如果也就是tmp得到s2的数据，如果s2之前没初始化，析构销毁就出问题了，因为没初始化是随机值

但是赋值不一样，赋值是两个对象都存在，不存在随机值问题，所以不用一上来就初始化

还有一种现代写法先不介绍

4.4  clear

void clear()
{//clear不删除头结点，因为万一删除了头结点你还想插入数据怎么办iterator it = begin();while (it != end()){it = erase(it);}
}

①、 it = erase(it)什么意思?

防止迭代器失效，因为erase返回的是被删除位置的下一位置，比如删除pos位置的，pos位置被删除后，it都不用动，erase算自动指向下一位置了，故用it接收，若不接收，迭代器失效

4.5 operator=

        //赋值运算符重载（传统写法）//lt1 = lt3//list<T>& operator=(const list<T>& lt)//{//	if (this != &lt)//	{//		clear();//先释放lt1//		for (auto e : lt)//			push_back(e);//	}//	return *this;//}//赋值运算符重载（现代写法）//lt1 = lt3list<T>& operator=(list<T> lt)//套用传值传参去拷贝构造完成深拷贝{swap(_head,lt._head);//交换两个list的头结点即可//lt出了作用域，析构函数销毁lt1原来的链表，一举两得//swap(lt);return *this;}

注：传统写法要先把被赋值的对象先释放，然后利用push_bak尾插，push_back在下文说明

4.6  析构函数

//析构函数~list(){clear();//删除除头结点以外的节点delete _head;//删去哨兵位头结点_head = nullptr;}

 4.7 insert

//insert，插入pos位置之前
iterator insert(iterator pos, const T& x)
{Node* newnode = new Node(x);//创建新的结点Node* cur = pos._node; //迭代器pos处的结点指针Node* prev = cur->_prev;//prev newnode cur//链接prev和newnodeprev->_next = newnode;newnode->_prev = prev;//链接newnode和curnewnode->_next = cur;cur->_prev = newnode;//返回新插入元素的迭代器位置return iterator(newnode);
}

①、返回参数为什么是iterator？

本质是为了防止迭代器失效问题

注：insert指的是插入到指定位置的前面

4.8 push_back 和 push_front

//尾插
void push_back(const T& x)
{Node* tail = _head->_prev;//找尾Node* newnode = new Node(x);//创建一个新的结点//_head  tail  newnode//使tail和newnode构成循环tail->_next = newnode;newnode->_prev = tail;//使newnode和头结点_head构成循环newnode->_next = _head;_head->_prev = newnode;}
//头插
void push_front(const T& x)
{insert(begin(), x);
}

4.9 erase

//erase
iterator erase(iterator pos)
{assert(pos != end());Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;//prev cur next//链接prev和nextprev->_next = next;next->_prev = prev;//delete删去结点,因为每一个节点都是动态开辟出来的delete cur;//返回被删除元素后一个元素的迭代器位置//return next;return iterator(next);
}

①、 返回值问题

erase的返回值，返回的是被删除位置的下一位置

4.10 pop_back 和 pop_front

//尾删
void pop_back()
{erase(--end());//erase(iterator(_head->prev));//构造个匿名对象
}
//头删
void pop_front()
{erase(begin());
}

最后， list的排序意义不大，因为实际生活中我们都是对数组等排序

三、完整源代码：

list.h:

#pragma oncenamespace mz
{//1、结点类template<class T>struct __list_node//前面加__是命名习惯,一般这么写表示是给别人用的{//前驱指针和后驱指针__list_node<T>* _next;//C++中可不写struct，直接用名定义，但注意这里还要加类型__list_node<T>* _prev;T _data;//存节点的值//构造函数__list_node(const T& val = T())//给一个缺省值T():_next(nullptr), _prev(nullptr), _data(val){}};//2、迭代器类//__list_iterator<T,T&,T*>              -> iterator//__list_iterator<T,const T&,const T*>  -> const_iteratortemplate<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){ }//*it（调用的是函数，返回节点中的值）Ref operator*(){//出了作用域还在，引用返回return _node->_data;}Ptr operator->(){return &_node->_data;}//++it;（迭代器++本质就是指针往后移，加完后还应是个迭代器）Self& operator++(){_node = _node->_next;return *this;}//it++;Self operator++(int)//加参数以便于区分前置++{Self tmp(*this);//拷贝构造tmp_node = _node->_next;//直接让自己指向下一个结点即可实现++return tmp;//注意返回tmp，才是后置++}//--it;Self& operator--(){_node = _node->_prev;//让_node指向上一个结点即可实现--return *this;}//it--;Self operator--(int)//记得传缺省值以区分前置--{Self tmp(*this);//拷贝构造tmp_node = _node->_prev;return tmp;}//it != end() bool operator!=(const Self& it){//迭代器是否相等只要判断对应节点地址是否相等即可return _node != it._node;}bool operator==(const Self& it){return _node == it._node;}};//3、链表类template<class T>class list{typedef __list_node<T> Node;public:typedef __list_iterator<T,T&,T*> iterator;typedef __list_iterator<T,const T&,const T*> const_iterator;iterator begin(){//第一个位置应该是头结点的下一个节点return iterator(_head->_next);//用匿名对象构造iterator类型的}iterator end(){//最后一个数据的下一个位置应该是第一个节点，即头结点return iterator(_head);}const_iterator begin()const{return const_iterator(_head->_next);}const_iterator end()const{return const_iterator(_head);}//带头双向循环链表的构造函数list(){_head = new Node;_head->_next = _head;_head->_prev = _head;}//拷贝构造：传统写法list(const list<T>& lt){_head = new Node;//开辟一样的头结点_head->_next = _head;_head->_prev = _head;//1、用迭代器遍历/*const_iterator it = lt.begin();while (it != lt.end()){push_back(*it);++it;}*///2、范围for遍历//遍历lt1，把lt1的元素push_back到lt2里头for (auto e : lt){push_back(e);//自动开辟新空间，完成深拷贝}}//赋值运算符重载（传统写法）//lt1 = lt3//list<T>& operator=(const list<T>& lt)//{//	if (this != &lt)//	{//		clear();//先释放lt1//		for (auto e : lt)//			push_back(e);//	}//	return *this;//}//赋值运算符重载（现代写法）//lt1 = lt3list<T>& operator=(list<T> lt)//套用传值传参去拷贝构造完成深拷贝{swap(_head,lt._head);//交换两个list的头结点即可//lt出了作用域，析构函数销毁lt1原来的链表，一举两得//swap(lt);return *this;}//析构函数~list(){clear();//删除除头结点以外的节点delete _head;//删去哨兵位头结点_head = nullptr;}void clear(){//clear不删除头结点，因为万一删除了头结点你还想插入数据怎么办iterator it = begin();while (it != end()){it = erase(it);}}//尾插void push_back(const T& x){Node* tail = _head->_prev;//找尾Node* newnode = new Node(x);//创建一个新的结点//_head  tail  newnode//使tail和newnode构成循环tail->_next = newnode;newnode->_prev = tail;//使newnode和头结点_head构成循环newnode->_next = _head;_head->_prev = newnode;}//头插void push_front(const T& x){insert(begin(), x);}//insert，插入pos位置之前iterator insert(iterator pos, const T& x){Node* newnode = new Node(x);//创建新的结点Node* cur = pos._node; //迭代器pos处的结点指针Node* prev = cur->_prev;//prev newnode cur//链接prev和newnodeprev->_next = newnode;newnode->_prev = prev;//链接newnode和curnewnode->_next = cur;cur->_prev = newnode;//返回新插入元素的迭代器位置return iterator(newnode);}//eraseiterator erase(iterator pos){assert(pos != end());Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;//prev cur next//链接prev和nextprev->_next = next;next->_prev = prev;//delete删去结点,因为每一个节点都是动态开辟出来的delete cur;//返回被删除元素后一个元素的迭代器位置//return next;return iterator(next);}//尾删void pop_back(){erase(--end());//erase(iterator(_head->prev));//构造个匿名对象}//头删void pop_front(){erase(begin());}private:Node* _head;//头结点};void test1(){list<int>lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);//类外访问迭代器需要指定类域，类内访问可直接访问list<int>::iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";++it;}cout << endl;}struct Date{int _year = 0;int _month = 1;int _day = 1;};void test2(){Date* p2 = new Date;*p2;//取到的是Datep2->_year;//取到的是Date类中的成员变量list<Date>lt;lt.push_back(Date());lt.push_back(Date());//list存了个日期类(自定义类型)的类型list<Date>::iterator it = lt.begin();while (it != lt.end()){//cout << *it << " ";cout << it->_year << "-" << it->_month << "-" << it->_day << endl;++it;}cout << endl;}void print_list(const list<int>& lt){list<int>::const_iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";++it;}cout << endl;}void test3(){list<int>lt1;lt1.push_back(1);lt1.push_back(2);lt1.push_back(3);lt1.push_back(4);list<int> lt2(lt1);print_list(lt2);list<int>lt3;lt3.push_back(10);lt3.push_back(20);lt3.push_back(30);lt3.push_back(40);lt1 = lt3;print_list(lt1);}
}

 test.cpp:

#include<iostream>
#include<assert.h>
using namespace std;
#include"list.h"int main()
{//mz::test1();mz::test3();return 0;
}

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

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

相关文章

FFmpeg入门之Windows/Linux下FFmpeg源码编译

FFmpeg入门之Windows/Linux下FFmpeg源码编译

1.源码下载: git clone https://github.com/FFmpeg/FFmpeg.git windows : macos: ubuntu: 2.编译FFmpeg CompilationGuide – FFmpeg windows: 1.下载yasm并安装 : Download - The Yasm Modular Assembler Project 下载后复制到c:/windows 2.下载SDL 3.下载H264/265源码 git…
阅读更多...
Scrum敏捷开发流程及敏捷研发关键环节

Scrum敏捷开发流程及敏捷研发关键环节

Scrum是一个迭代式增量软件开发过程&#xff0c;是敏捷方法论中的重要框架之一。它通常用于敏捷软件开发&#xff0c;包括了一系列实践和预定义角色的过程骨架。Scrum中的主要角色包括Scrum主管&#xff08;Scrum Master&#xff09;、产品负责人&#xff08;Product Owner&…
阅读更多...
《C++ primer plus》精炼（OOP部分）——对象和类（5）

《C++ primer plus》精炼（OOP部分）——对象和类（5）

“学习是照亮心灵的火炬&#xff0c;它永不熄灭&#xff0c;永不止息。” 文章目录 类的自动和强制类型转换原始类型转换为自定义类型将自定义类型转换为原始类型 类的自动和强制类型转换 原始类型转换为自定义类型 可以用一个参数的构造函数来实现&#xff0c;例如&#xff…
阅读更多...
2023上半年软件设计师上午题目总结

2023上半年软件设计师上午题目总结

1 在计算机中系统总线用于连接 主存及外设部件 2 在由高速缓存、主存、硬盘构成的三级存储体系中&#xff0c;CPU执行指令时需要读取数据&#xff0c;DMA控制器和中断CPU发出的数据地址是 主存物理地址 。 DMA&#xff08;Direct Memory Access&#xff09;控制器是计算机硬…
阅读更多...
卡尔曼滤波（Kalman Filter）原理浅析-数学理论推导-1

卡尔曼滤波（Kalman Filter）原理浅析-数学理论推导-1

目录 前言数学理论推导1. 递归算法2. 数学基础结语参考 前言 最近项目需求涉及到目标跟踪部分&#xff0c;准备从 DeepSORT 多目标跟踪算法入手。DeepSORT 中涉及的内容有点多&#xff0c;以前也就对其进行了简单的了解&#xff0c;但是真正去做发现总是存在这样或者那样的困惑…
阅读更多...
Obsidian配置

Obsidian配置

插件 1&#xff1a;Annotator pdf批注插件&#xff0c;使用方法&#xff1a;新建一个markdown文件&#xff0c;在文件的头部必须时开头添加以下内容&#xff1a; --- annotation-target: xxx.pdf ---2&#xff1a;Hidden Folder 用正则表达式隐藏文件夹的&#xff0c;我的设…
阅读更多...
UART 协议

UART 协议

文章目录 电气层硬件拓扑基本原理协议空闲位起始位数据位奇偶校验位无校验奇校验偶校验mark parityparity 停止位 波特率优缺点优点缺点 参考 UART(universal asynchronous receiver-transmitter) 通用异步收发器 分类特点导线2速度9600&#xff0c; 19200&#xff0c; 38400&…
阅读更多...
Golang gorm manytomany 多对多 更新、删除、替换

Golang gorm manytomany 多对多 更新、删除、替换

Delete 移除 只删除中间表的数据 删除原有的 var a Article1db.Preload("Tag1s").Take(&a, 1)fmt.Printf("%v", a) {1 k8s [{1 cloud []} {2 linux []}]}mysql> select * from article1; ------------ | id | title | ------------ | 1 | k8s …
阅读更多...
VHOST-SCSI代码分析（1）VHOST SCSI设备模拟

VHOST-SCSI代码分析（1）VHOST SCSI设备模拟

VHOST SCSI设备的模拟是由QEMU和HOST共同实现的&#xff0c;QEMU模拟VHOST SCSI设备配置空间等&#xff0c;而对于虚拟机通知HOST和HOST通知虚拟机机制由HOST内核实现。 在QEMU中VHOST SCSI设备继承关系如下&#xff1a; 其它设备以及对应class_init函数和realize具现化实现与V…
阅读更多...
链表-真正的动态数据结构

链表-真正的动态数据结构

创建节点 public class Node {T val;Node next;public Node(T val, Node next) {this.val val;this.next next;}public Node() {this(null, null);}public Node(T val) {this(val, null);}} 创建一个空链表 //创建链表public Node header;private int size;public MyLinkedLi…
阅读更多...
做一个有灵魂的软件测试员

做一个有灵魂的软件测试员

有没有觉得自己每天的工作千篇一律&#xff0c;每天一上班就盼着下班&#xff1f; 一个月似乎能令自己开心的时间也就是发工资的那一天&#xff1f; 自己的工作生活总感觉被人牵着走&#xff0c;兜兜转转过了一年又一年&#xff1f; 测试员的工作性质决定了与重复、枯燥和乏…
阅读更多...
知识库管理工具哪个好？我建议你可以试一下这个！

知识库管理工具哪个好？我建议你可以试一下这个！

对于很多企业/用户来说&#xff0c;在职业成长和个人发展的过程中&#xff0c;是需要借助知识库管理工具来进行知识内容沉淀的。 随着工具市场的发展&#xff0c;各种知识库管理工具层出不穷&#xff0c;今天我就结合数据安全、知识管理体系、简单实用三个方面出发&#xff0c;…
阅读更多...
HTTP协议（超级详细）

HTTP协议（超级详细）

HTTP协议介绍 基本介绍&#xff1a; HTTP&#xff1a;超文本传输协议&#xff0c;是从万维网服务器传输超文本到本地浏览器的传送协议HTTP是一种应用层协议&#xff0c;是基于TCP/IP通信协议来传送数据的&#xff0c;其中 HTTP1.0、HTTP1.1、HTTP2.0 均为 TCP 实现&#xff0…
阅读更多...
Python之设计模式

Python之设计模式

一、设计模式_工厂模式实现 设计模式是面向对象语言特有的内容&#xff0c;是我们在面临某一类问题时候固定的做法&#xff0c;设计模式有很多种&#xff0c;比较流行的是&#xff1a;GOF&#xff08;Goup Of Four&#xff09;23种设计模式。当然&#xff0c;我们没有必要全部学…
阅读更多...
C#回调函数学习1

C#回调函数学习1

回调函数&#xff08;Callback Function&#xff09;是一种函数指针&#xff0c;它指向的是由用户自己定义的回调函数。我们将这个回调函数的指针作为参数传递给另外一个函数&#xff0c;在这个函数工作完成后&#xff0c;它将通过这个回调函数的指针来回调通知调用者处理结果。…
阅读更多...
MySQL--MySQL索引事务

MySQL--MySQL索引事务

事务的概念 事务指逻辑上的一组操作&#xff0c;组成这组操作的各个单元&#xff0c;要么全部成功&#xff0c;要么全部失败。 在不同的环境中&#xff0c;都可以有事务。对应在数据库中&#xff0c;就是数据库事务。 使用 &#xff08;1&#xff09;开启事务&#xff1a;start…
阅读更多...
【Flask】会话保持-API授权-注册登录

【Flask】会话保持-API授权-注册登录

http - 无状态-无法记录是否已经登陆过 #会话保持 – session cookie session – 保存一些在服务端 cookie – 保存一些数据在客户端 session在单独服务器D上保存&#xff0c;前面数个服务器A,B,C上去取就好了&#xff0c;业务解耦。—》》现在都是基于token的验证。 以上是基…
阅读更多...
logstash通过kafka通道采集日志信息

logstash通过kafka通道采集日志信息

1.修改文件/opt/app/elk/logstash-7.5.1/config.d/config1.conf&#xff0c;在input下添加kafka采集配置 #192.168.128.130:9103:kafka地址 #topics:主题 kafka {bootstrap_servers > ["192.168.128.130:9103"]group_id > "logstash"topics > [&…
阅读更多...
誉天在线项目~ElementPlus Tag标签用法

誉天在线项目~ElementPlus Tag标签用法

效果图 页面展现 <el-form-item label"课程标签"><el-tagv-for"tag in dynamicTags":key"tag"class"mx-1"closable:disable-transitions"false"close"handleClose(tag)"style"margin:5px;">…
阅读更多...
Attention is all you need 论文笔记

Attention is all you need 论文笔记

该论文引入Transformer&#xff0c;主要核心是自注意力机制&#xff0c;自注意力&#xff08;Self-Attention&#xff09;机制是一种可以考虑输入序列中所有位置信息的机制。 RNN介绍 引入RNN为了更好的处理序列信息&#xff0c;比如我 吃 苹果&#xff0c;前后的输入之间是有…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023