【c++】list 模拟

 > 作者简介：დ旧言~，目前大二，现在学习Java，c，c++，Python等
> 座右铭：松树千年终是朽，槿花一日自为荣。

> 目标：能手撕list模拟

> 毒鸡汤：不为模糊不清的未来过分担忧，只为清清楚楚的现在奋发图强。

> 望小伙伴们点赞👍收藏✨加关注哟💕💕 

🌟前言

        前面我们已经学习了list的相关知识点，必然我们要简单的模拟一下，模拟list类比较复杂，里面掺杂了我们学习双链表的知识点，对模板的使用更加复杂，还有对c++类和对象的知识点使用起来更杂。对上面知识点忘了的小伙伴们大家先去巩固巩固，学习list那就更加轻松，那咱们走起。

 ⭐主体

这里我们就不分解成三文件啦，这里就创建两个文件List.h（头文件），Test.c（测试代码文件）

🌙list基本框架结构

list为任意位置插入删除的容器，底层为带头双向循环链表：

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

①、模拟实现结点类
②、模拟实现迭代器的类
③、模拟list主要功能的类

🌙list的结点的实现

list为任意位置插入删除的容器，底层为带头双向循环链表，所以每个结点都需有以下成员：

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

结点类本质上是一个初始化函数，在list类中只需要一个构造函数就行。

// 初始化（结点类）
template<class T> // 模板
struct ListNode
{// 定义两个指针ListNode<T>* _next;  // 前驱指针 ListNode<T>* _prev;  // 后驱指针// 存储节点值T _data; // 初始化列表(构造函数)ListNode(const T& x = T()):_next(nullptr),_prev(nullptr),_data(x){}
};

问题解剖：为什么是ListNode<T>？？？

首先，C++中用struct定义时可不加struct，重点是这里用了一个类模板，类模板的类名不是真正的类型且类模板不支持自动推类型，即ListNode不是真正的类型，定义变量时ListNode<T>这种才是真正的类型，也就是用类模板定义变量时必须 指定对应的类型 。 注：结构体模板或类模板在定义时可以不加 <T>，但使用时必须加 <T>。

🌙list的迭代器类的实现

  1. 链表的物理空间是不连续的，是通过结点的指针顺次链接。
  2. 不能像先前的string和vector一样直接解引用去访问其数据，
  3. 结点的指针解引用还是结点，结点指针++还是结点指针，
  4. 在string和vector的物理空间是连续的，所以这俩不需要实现迭代器类，可以直接使用。

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

💫基本框架

框架结构：

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

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

  1. 普通迭代器的话，一个class T参数就够了，由于const迭代器原因，需要加两个参数
  2. 两个参数名Ref（reference:引用）和Ptr（pointer:指针）

②、迭代器类是什么？

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

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

  1. Node* cur（节点指针）  和 iterator it（迭代器），它们指向同一个节点，它们的物理地址是一样的，但是它们的类型不同。
  2. *cur是一个指针的解引用，取到的值是节点。
  3. *it是去调用迭代器的operator*，返回值是节点中存的值。
  4. 类型决定了对空间的解释权。

💫构造函数

 迭代器的构造函数只需要一个指针构造就行：

// 构造函数（初始化）
_list_iterator(Node* x):_node(x)
{}

 💫operator*

*it（调用的是函数，返回节点中的值）：

// *it，返回节点的值
Ref operator*()
{return _node->_data;
}

问题解剖：返回值为什么是 Ref ???

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

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

 💫operator->

// 返回节点值
Ptr operator->()
{return &_node->data;
}

问题解剖：为什么需要operator->？

  •  list存了个自定义类型的Date类，程序错误，因为我们并没有重载Date类的operator<<

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

  • 利用operator->直接访问类的成员变量，而内置类型可以直接输出

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

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

 💫operator前置++--与后置++--

代码实现：

// ++it
self& operator++()
{_node = _node->_next;// 返回节点return *this;
}
// it++
self operator++(int)
{// 拷贝self tmp(*this);// 向后走一个节点_node = _node->_next;// 返回return tmp;
}// --it
self& operator--()
{_node = _node->_prev;// 返回节点return *this;
}
// it--
self operator--(int)
{// 拷贝self tmp(*this);// 向前走一个节点_node = _node->prev;// 返回return tmp;
}

问题解剖：迭代器++对于list是什么意思？？？

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

💫operator==和operator!=

代码实现：

// 判断
bool operator!=(const self& s)
{return _node != s._node;
}
// 判断
bool operator==(const self& s)
{return _node == s._node;
}

问题解剖：两个迭代器怎么比较的？？？

  1. 迭代器中就一个成员变量_node，节点指针，只要比较当前的节点指针是否相同即可
  2. 这个操作在判断迭代器是否走到头有用（比如 it != s.end()）

问题：迭代器的拷贝构造和赋值和析构函数需我们自己实现吗？

 答：不需要

  • 因为迭代器存的就是一个节点指针，而节点是属于链表list的，那么它的释放应由list来实现，那么迭代器的析构也无需我们自己写了。
  • 拷贝构造和赋值就是节点指针的拷贝和赋值，即使指向同一节点了，迭代器也不会析构，而list的析构到时候只会释放这个节点一次，不存在什么问题，即我们无需深拷贝，使用系统提供的浅拷贝即可。

🌙list类的实现

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

💫基本框架

框架结构：

//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迭代器的介绍)

  1. 我们知道const_iterator在begin()和end()中的返回值是需要用到的
  2. 其主要作用就是当迭代器只读时使用
  3. 普通迭代器和const迭代器的实现区别仅仅在于内部成员函数的返回值不同
  4. 一个是引用class Ref（T&或const T&），一个是指针class Ptr（T*或const T*）
  5. 当Ref时const T&就是const迭代器的调用，当Ref时T& 时就是普通迭代器的调用

💫构造函数

框架结构：

// 初始化函数
void empty_init()
{_head = new Node;_head->_next = _head;_head->_prev = _head;
}// 构造函数
list() // 1.
{empty_init();
}

解释：我们开辟一个头结点，这里就是一个循环双向链表。

💫begin和end

代码实现：

// 找头,这里有哨兵位
iterator begin()
{return _head->_next;
}
// 找尾，哨兵位就是尾
iterator end()
{return _head;
}//const类
const_iterator begin() const
{return _head->_next;
}
const_iterator end() const
{return _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);//自动开辟新空间，完成深拷贝}
}

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

现代写法：

template<class InputIterator>
list(InputIterator first, InputIterator last) {_head = new Node();_head->_next = _head;_head->_prev = _head;while (first != last) {push_back(*first);first++;}
}
/* 拷贝构造（现代写法）：L2(L1) */
list(const list<T>& L) {_head = new Node();_head->_next = _head;_head->_prev = _head;list<T> tmp(L.begin(), L.end());swap(_head, tmp._head);  // 交换两个结点的指针
}

💫clear函数

代码实现：

// 销毁函数
void clear()
{// 找头iterator it = begin();// 循环while (it != end()){it = erase(it);}
}

问题解剖：it = erase(it)什么意思？？？

防止迭代器失效，因为erase返回的是被删除位置的下一位置，比如删除pos位置的，pos位置被删除后，这个位置的迭代器就失效了，那就无法通过++找到后面的位置了，所以我们通过erase返回值来更新一下迭代器位置，即更新到被删除位置的下一位置

💫operator=

代码实现：

        //赋值运算符重载（传统写法）//lt1 = lt3//list<T>& operator=(const list<T>& lt)//{//	if (this != &lt)//	{//		clear();//先释放lt1//		for (auto e : lt)//			push_back(e);//	}//	return *this;//}//赋值运算符重载（现代写法）// 赋值运算重载list<T>& operator=(list<T> lt){swap(lt);return *this;}

注释：套用传值传参拷贝构造完成深拷贝

💫析构函数

代码实现：

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

💫insert函数

代码实现：

// insert插入函数
iterator insert(iterator pos, const T& x)
{Node* cur = pos._node; // 迭代器pos处的结点指针Node* prev = cur->_prev;Node* newnode = new Node(x); // 创建新的结点 // prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;//return iterator(newnode);return newnode;
}

问题解剖：返回参数为什么是iterator？？？本质是为了防止迭代器失效问题

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

💫push_back 和 push_front

代码实现：

// 调用插入函数，尾插
void push_back(const T& x)
{insert(end(), x);
}
// 调用插入函数，头插
void push_front(const T& x)
{insert(begin(), x);
}

这里的尾插和头插直接调用插入函数就可以了。

💫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的返回值，返回的是被删除位置的下一位置，库里面这么规定的，本质是因为删除元素一定会导致此位置的迭代器失效，故返回被删除位置的下一次位置可以更新迭代器。

💫pop_back 和 pop_front

代码实现：

// 调用删除函数，尾删
void pop_back()
{erase(--end());
}
// 调用删除函数，头删
void pop_front()
{erase(begin());
}

🌙完整源代码

list.h:

#pragma once#include<assert.h>
#include<iostream>namespace lyk
{// 初始化template<class T> // 模板struct ListNode{// 定义两个指针ListNode<T>* _next;  // 前驱指针 ListNode<T>* _prev;  // 后驱指针// 存储节点值T _data; // 初始化列表(构造函数)ListNode(const T& x = T()):_next(nullptr),_prev(nullptr),_data(x){}};// list迭代器template<class T,class Ref,class Ptr> // 第二个参数是引用，第三个参数是指针，防止迭代器失效struct _list_iterator{typedef ListNode<T> Node;typedef _list_iterator<T, Ref, Ptr> self;Node* _node; // 定义节点// 构造函数（初始化）_list_iterator(Node* x):_node(x){}// ++itself& operator++(){_node = _node->_next;// 返回节点return *this;}// it++self operator++(int){// 拷贝self tmp(*this);// 向后走一个节点_node = _node->_next;// 返回return tmp;}// --itself& operator--(){_node = _node->_prev;// 返回节点return *this;}// it--self operator--(int){// 拷贝self tmp(*this);// 向前走一个节点_node = _node->prev;// 返回return tmp;}// *it，返回节点的值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;}};// list的实现（包含各种函数实现）template<class T>class list{typedef ListNode<T> Node;public: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类const_iterator begin() const{return _head->_next;}const_iterator end() const{return _head;}// 初始化函数void empty_init(){_head = new Node;_head->_next = _head;_head->_prev = _head;}// 构造函数list() // 1.{empty_init();}list(list<T>& It) // 2.拷贝构造 传统写法{empty_init();// 尾插for (const auto& x : It){push_back(x);}}/* 拷贝构造（现代写法）：L2(L1) */list(const list<T>& L) {_head = new Node();_head->_next = _head;_head->_prev = _head;list<T> tmp(L.begin(), L.end());swap(_head, tmp._head);  // 交换两个结点的指针}// 销毁函数void clear(){// 找头iterator it = begin();// 循环while (it != end()){it = erase(it);}}// 析构函数~list(){clear();delete _head;_head = nullptr;}// 交换void swap(list<T>& tmp){std::swap(_head, tmp._head);}// 赋值运算重载list<T>& operator=(list<T> lt){swap(lt);return *this;}// 调用插入函数，尾插void push_back(const T& x){insert(end(), x);}// 调用插入函数，头插void push_front(const T& x){insert(begin(), x);}// 调用删除函数，尾删void pop_back(){erase(--end());}// 调用删除函数，头删void pop_front(){erase(begin());}// insert插入函数iterator insert(iterator pos, const T& x){Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(x);// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;//return iterator(newnode);return newnode;}// erase删除函数iterator erase(iterator pos){assert(pos != end());Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;prev->_next = next;next->_prev = prev;delete cur;return next;}private:Node* _head;  // 头节点};void test_list1(){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()){//*it += 10;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);for (auto e : lt){cout << e << " ";}cout << endl;lt.push_back(5);lt.push_front(0);for (auto e : lt){cout << e << " ";}cout << endl;lt.pop_back();lt.pop_front();for (auto e : lt){cout << e << " ";}cout << endl;lt.clear();for (auto e : lt){cout << e << " ";}cout << endl;lt.push_back(10);lt.push_back(20);for (auto e : lt){cout << e << " ";}cout << endl;}void test_list3(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);for (auto e : lt){cout << e << " ";}cout << endl;list<int> copy(lt);for (auto e : copy){cout << e << " ";}cout << endl;list<int> lt1;lt1.push_back(10);lt1.push_back(20);lt1.push_back(30);lt1.push_back(40);lt = lt1;for (auto e : copy){cout << e << " ";}cout << endl;}void print_list(const list<int>& lt){list<int>::const_iterator it = lt.begin();while (it != lt.end()){//*it += 10;cout << *it << " ";++it;}cout << endl;for (auto e : lt){cout << e << " ";}cout << endl;}void test_list4(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);print_list(lt);list<int>::iterator it = lt.begin();while (it != lt.end()){*it += 10;cout << *it << " ";++it;}cout << endl;}
}

 test.cpp:

#define _CRT_SECURE_NO_WARNINGS 1// 包含头文件
#include<iostream>
#include<list>
#include<vector>
#include<algorithm>
using namespace std;#include"List.h"int main()
{lyk::test_list4();return 0;
}

  🌟结束语

       今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小手给博主一键三连，有你们的支持是我最大的动力💞💞💞，回见。

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

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

相关文章

红队ATKCK|红日靶场Write-Up（附下载链接）

红队ATKCK|红日靶场Write-Up（附下载链接）

网络拓扑图 下载地址 在线下载&#xff1a; http://vulnstack.qiyuanxuetang.net/vuln/detail/2/ 百度网盘 链接&#xff1a;https://pan.baidu.com/s/1nlAZAuvni3EefAy1SGiA-Q?pwdh1e5 提取码&#xff1a;h1e5 环境搭建 通过上述图片&#xff0c;web服务器vm1既能用于外…
阅读更多...
Rust 学习笔记 - Hello world

Rust 学习笔记 - Hello world

前言 本文将讲解如何完成一个 Rust 项目的开发流程&#xff0c;从编写 “Hello, World!” 开始&#xff0c;到使用 Cargo 管理和运行项目。 编写 Hello world 开始一个新项目很简单&#xff0c;首先&#xff0c;创建一个包含 main.rs 文件的 hello_world 文件夹&#xff0c;…
阅读更多...
基于Doris构建亿级数据实时数据分析系统

基于Doris构建亿级数据实时数据分析系统

转载至我的博客 https://www.infrastack.cn &#xff0c;公众号&#xff1a;架构成长指南 背景 随着公司业务快速发展&#xff0c;对业务数据进行增长分析的需求越来越迫切&#xff0c;与此同时我们的业务数据量也在快速激增、每天的数据新增量大概在30w 左右&#xff0c;一年…
阅读更多...
BUUCTF misc 专题（47）[SWPU2019]神奇的二维码

BUUCTF misc 专题（47）[SWPU2019]神奇的二维码

下载附件&#xff0c;得到一张二维码图片&#xff0c;并用工具扫描&#xff08;因为图片违规了&#xff0c;所以就不放了哈。工具的话&#xff0c;一般的二维码扫描都可以&#xff09; swpuctf{flag_is_not_here}&#xff0c;&#xff08;刚开始出了点小差错对不住各位师傅&am…
阅读更多...
代码随想录第32天|● 122.买卖股票的最佳时机II ● 55. 跳跃游戏 ● 45.跳跃游戏II

代码随想录第32天|● 122.买卖股票的最佳时机II ● 55. 跳跃游戏 ● 45.跳跃游戏II

文章目录 买卖股票思路一&#xff1a;贪心代码&#xff1a; 思路&#xff1a;动态规划代码&#xff1a; 跳跃游戏思路&#xff1a;贪心找最大范围代码&#xff1a; 跳跃游戏②思路&#xff1a;代码&#xff1a; 方法二&#xff1a;处理方法一的特殊情况 买卖股票 思路一&#x…
阅读更多...
C++类和对象-多态-＞多态的基本语法、多态的原理剖析、纯虚函数和抽象类、虚析构和纯虚析构

C++类和对象-多态-＞多态的基本语法、多态的原理剖析、纯虚函数和抽象类、虚析构和纯虚析构

#include<iostream> using namespace std; //多态 //动物类 class Animal { public: //Speak函数就是虚函数 //函数前面加上virtual关键字&#xff0c;变成虚函数&#xff0c;那么编译器在编译的时候就不能确定函数调用了。 virtual void speak() { …
阅读更多...
鸿蒙（HarmonyOS）项目方舟框架（ArkUI）之NavRouter组件

鸿蒙（HarmonyOS）项目方舟框架（ArkUI）之NavRouter组件

鸿蒙&#xff08;HarmonyOS&#xff09;项目方舟框架&#xff08;ArkUI&#xff09;之NavRouter组件 一、操作环境 操作系统: Windows 10 专业版、IDE:DevEco Studio 3.1、SDK:HarmonyOS 3.1 二、NavRouter组件 导航组件&#xff0c;默认提供点击响应处理&#xff0c;不需要…
阅读更多...
微信公众号扫码登录

微信公众号扫码登录

1.设计 我们采用的是个人号登录方式&#xff0c;这样拿不到我们的userInfo用户信息&#xff0c;然后我们将用户发来的消息&#xff08;xml消息体&#xff09;中的FromUser作为我们唯一的openId 整体流程: 1.用户扫码公众号码&#xff0c;然后发一条消息&#xff1a;验证码&…
阅读更多...
2.13日学习打卡----初学RocketMQ（四）

2.13日学习打卡----初学RocketMQ（四）

2.13日学习打卡 目录&#xff1a; 2.13日学习打卡一.RocketMQ之Java ClassDefaultMQProducer类DefaultMQPushConsumer类Message类MessageExt类 二.RocketMQ 消费幂消费过程幂等消费速度慢的处理方式 三.RocketMQ 集群服务集群特点单master模式多master模式多master多Slave模式-…
阅读更多...
C语言希尔排序详解！！！速过

C语言希尔排序详解！！！速过

目录 希尔排序是什么&#xff1f; 关于时间复杂度 希尔排序的源代码 希尔排序源代码的详解 希尔排序是什么&#xff1f; 之前我们说了三个排序&#xff08;插入排序&#xff0c;选择排序&#xff0c;冒泡排序&#xff09;有需要的铁铁可以去看看之前的讲解。 但因为之前的…
阅读更多...
基于Python的信息加密解密网站设计与实现【源码+论文+演示视频+包运行成功】

基于Python的信息加密解密网站设计与实现【源码+论文+演示视频+包运行成功】

博主介绍&#xff1a;✌csdn特邀作者、博客专家、java领域优质创作者、博客之星&#xff0c;擅长Java、微信小程序、Python、Android等技术&#xff0c;专注于Java、Python等技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; …
阅读更多...
CSS 圆形的时钟秒针状的手柄绕中心点旋转的效果

CSS 圆形的时钟秒针状的手柄绕中心点旋转的效果

<template><!-- 创建一个装载自定义加载动画的容器 --><view class="cloader"><!-- 定义加载动画主体部分 --><view class="clface"><!-- 定义类似秒针形状的小圆盘 --><view class="clsface"><!-…
阅读更多...
docker （五）-docker存储-数据持久化

docker （五）-docker存储-数据持久化

将数据存储在容器中&#xff0c;一旦容器被删除&#xff0c;数据也会被删除。同时也会使容器变得越来越大&#xff0c;不方便恢复和迁移。 将数据存储到容器之外&#xff0c;这样删除容器也不会丢失数据。一旦容器故障&#xff0c;我们可以重新创建一个容器&#xff0c;将数据挂…
阅读更多...
Linux常见指令（一）

Linux常见指令（一）

一、基本指令 1.1ls指令 语法 &#xff1a; ls [ 选项 ][ 目录或文件 ] 功能&#xff1a;对于目录&#xff0c;该命令列出该目录下的所有子目录与文件。对于文件&#xff0c;将列出文件名以及其他信息。 常用选项&#xff1a; -a 列出目录下的所有文件&#xff0c;包括以 .…
阅读更多...
github Two-factor authentication (2FA)is required for your GitHub account

github Two-factor authentication (2FA)is required for your GitHub account

问题 github 2FA认证 详细问题 笔者使用GitKraken&#xff0c;使用github登录&#xff0c;github要去 Two-factor authentication (2FA)is required for your GitHub account&#xff0c;即进行2FA认证 解决方案 解决方案一、 微信 → \rightarrow →搜索腾讯身份验证器…
阅读更多...
css篇---移动端适配的方案有哪几种

css篇---移动端适配的方案有哪几种

移动端适配 移动端适配是指同一个页面可以在不同的移动端设备上都有合理的布局。主流实现的方案有 响应式布局通过rem或者vw,vh 等实现不同设备有相同的比例而实现适配 首先需要了解viewport 【视口】 视口代表了一个可看见的多边形区域&#xff08;通常来说是矩形&#xff0…
阅读更多...
【c++】vector的增删查改

【c++】vector的增删查改

1.先定义一个类对象vector 为了防止和库里面发生冲突&#xff0c;定义一个命名空间&#xff0c;将类对象放在命名空间 里面 #include<iostream> using namespace std; namespace zjw {class vector {public:private:}; }2.定义变量&#xff0c;需要一个迭代器&#xff…
阅读更多...
Android---DslTabLayout实现底部导航栏

Android---DslTabLayout实现底部导航栏

1. 在 Android 项目中引用 JitPack 库 AGP 8. 根目录的 settings.gradle dependencyResolutionManagement {...repositories {...maven { url https://jitpack.io }} } AGP 8. 根目录如果是 settings.gradle.kts 文件 dependencyResolutionManagement {...repositories {...…
阅读更多...
单片机学习笔记---LED呼吸灯直流电机调速

单片机学习笔记---LED呼吸灯直流电机调速

目录 LED呼吸灯 直流电机调速 模型结构 波形 定时器初始化函数 中断函数 主程序 上一节讲了电机的工作原理&#xff0c;这一节开始代码演示&#xff01; 我们上一篇说Ton的时间长Toff时间短电机会快&#xff0c;Ton的时间短Toff时间长电机会慢 并且我们还要保证无论Ton和…
阅读更多...
element-UI 组件 dialog 中 ref 获取不到元素

element-UI 组件 dialog 中 ref 获取不到元素

项目场景&#xff1a; vue3集成bpmn.js 渲染过程中&#xff0c;进行流程图查看 问题描述 dialog弹窗加载获取canvas中 加载不到&#xff0c;导致偶尔流程展示加载失败 原因分析&#xff1a; 提示&#xff1a;官方解释如下&#xff0c;主要就是获取的时候&#xff0c;组件没有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023