C++ STL list

news2024/11/24 18:37:22

✅<1>主页：我的代码爱吃辣
📃<2>知识讲解：C++之 STL list介绍和模拟实现
☂️<3>开发环境：Visual Studio 2022
💬<4>前言：上次我们详细的介绍了vector，今天我们继续来介绍一下TSTL中的另外一个容器list。list在基础的功能和结构上就是一个双向带头的循环链表，实现起来基本不难，但是list迭代器的封装是非常值得学习的。

一.认识list

list - C++ Reference

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2.  list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
  3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
  4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
  5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)。

结构：list使用的是双向的循环带头结点的链表。

 

 二.list的使用

list的使用非常简单，有了我们之前vector和string的基础。上手list基本就是小菜一碟。

1.构造函数

构造函数（ (constructor)）接口说明
list (size_type n, const value_type& val = value_type())构造的list中包含n个值为val的元素
list()构造空的list
list (const list& x)拷贝构造函数
list (InputIterator first, InputIterator last)用[first, last)区间中的元素构造list

2.增删查改

	list<int> li;
	//尾插
	li.push_back(10);
	//头插
	li.push_front(20);
	//尾删
	li.pop_back();
	//头删
	li.pop_front();
	//迭代器位置插入数据
	li.insert(li.begin(), 100);
	//删除迭代器位置数据
	li.erase(li.begin());

3.list 迭代器

函数声明接口说明
begin +end返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
rbegin +
rend		返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的
reverse_iterator,即begin位置

list的迭代器使用与string和vector一模一样，在此不多介绍。

四.list 模拟实现

1.链表结点

template<class T>
struct _list_node
{
	_list_node( const T& val = T())
		:_val(val),
		_next(nullptr),
		_prev(nullptr)
	{
	}

	T _val;           //存储数据
	_list_node* _next;//后一个结点的指针
	_list_node* _prev;//前一个结点的指针
};

注意：我们在此处的struct定义了一个类，我们在定义_next和_prev的时候就不用像C语言那样加上struct。

例如：C语言写法

template<class T>
struct _list_node
{
	_list_node(const T& val = T())
		:_val(val),
		_next(nullptr),
		_prev(nullptr)
	{
	}

	T _val;           //存储数据
	struct _list_node* _next;//后一个结点的指针
	struct _list_node* _prev;//前一个结点的指针
};

2.list整体结构

template<class T>
class List
{
public:
    typedef _list_node<T> node;

    //...成员方法 增删查改
    
private:
	node* _head;//头节点
};

3.list构造函数

因为我们的list是一个带哨兵位的双向循环链表。所以这里我们将new出来的结点，设置为循环双向结构。

	List()
		:_head(new node)
	{
		_head->_next = _head;
		_head->_prev = _head;
	}

4.push_back（），pop_back（）

push_back（）尾插一个数据，pop_back（）尾删一个数据。

	//push_back
    void push_back(const T& val )
	{
        //创建结点
		node* newnode = new node(val);
		node* tail = _head->_prev;
        //改变指向
		tail->_next = newnode;
		newnode->_next = _head;
		_head->_prev = newnode;
		newnode->_prev = tail;
	}
	//pop_back
    void pop_back()
	{
		//判空
		assert(!empty());
		node* tail = _head->_prev;
		node* newtail = tail->_prev;
		//改变指向
		_head->_next = newtail;
		newtail->_prev = _head;
		//释放结点
		delete tail;
	}

5.迭代器

list的迭代器不同于string和vector，因为list的物理存储是不连续的，所以我们不能像list和vector一样仅仅使用原生指针来作为list的迭代器。

迭代器的实际就是一种模仿指针的行为来为容器提供一种通用的访问方法的设计。虽然list的迭代器不能使用原生指针来替代，但是我们可以对原生的指针进行类级别的封装来构造迭代器，并且使得迭代器具有指针的行为。

迭代器有两种实现方式，具体应根据容器底层数据结构实现：

  1.   原生态指针，比如：vector
  2.   将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法：
  • 指针可以解引用，迭代器的类中必须重载operator*()
  • 指针可以通过->访问其所指空间成员，迭代器类中必须重载oprator->()
  • 指针可以++向后移动，迭代器类中必须重载operator++()与operator++(int)
  • 至于operator--()/operator--(int)释放需要重载，根据具体的结构来抉择，双向链表可以向前移动，所以需要重载，如果是forward_list就不需要重载--
  • 迭代器需要进行是否相等的比较，因此还需要重载operator==()与operator!=()

 5.1迭代器结构

迭代器的整体结构如下。

template<class T>
class _list_iterator
{
public:
	typedef _list_node<T> node;    //结点类
	typedef _list_iterator<T> self;//迭代器本身

    //使用原生指针构造迭代器
	_list_iterator(node* n)
		:_node(n)
	{
	}
    
    //operator*()
    //operator++()
    //operator--()
    //operator->()
    //operator==()
    //operator!=()
	
private:
	node* _node;//迭代器是对原生指针的封装
};

5.2迭代器操作

5.2.1operator*（）

    T& operator*()
	{
		return _node->_val;
	}

返回该结点的值的引用。

5.2.2 operator ++（），operator --（）

++的操作其实就是让迭代器挪到下一个位置，--操作其实就是让迭代器挪到上一个位置。迭代器++或者--操作的返回值还是一个迭代器。

    //后置++
	self operator++(int)
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

    //前置++
	self operator++()
	{
		_node = _node->_next;
		return *this;
	}

    //前置--
    self operator--()
	{
		_node = _node->_prev;
		return *this;
	}

    //后置--
    self operator--(int)
	{
		self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}

5.2.3operator==（），operator！=（）

比较两个迭代器是否相等直接比较迭代器封装的两个指针是否相等就可以了。

	bool operator!=(const self& it)
	{
		return _node != it._node;
	}

	bool operator==(const self& it)
	{
		return _node == it._node;
	}

5.2.4operator->()

我们知道一般的结构体，类指针都是支持使用->访问一些成员的。当list存储的数据是结构体，或者是类试迭代器也应该支持->去访问。

    T*  operator->()
	{
		return &_node->_val;
	}

那么这样我们在外边的访问会不会很奇怪呢？


    struct AA
    {
    	AA(int aa = 10)
    		:_aa(aa)
    	{
    	}
        int _aa;
    };


    list<AA> lli(10, AA());	
    list<AA>::iterator lit = lli.begin();
    //1.调用:
    lit.operator->()->_aa;
    //2.调用:
    lit->_aa;

 在实际调用的时候我们可以直接写成调用2。

5.2.5begin（），end（）

	
    typedef _list_iterator<T> iterator;

    iterator begin()
	{
		//使用哨兵位的下一个结点指针，构造begin
		return iterator(_head->_next);
	}
	iterator end()
	{
		//使用哨兵位结点指针，构造end
		return iterator(_head);
	}

可以构成 [ begin，end ).这种左闭右开的结构。

5.3 const 迭代器

const迭代器与普通迭代器最大的不同，就是const迭代器不允许修改迭代器指向的数据。在整个迭代器操作中只有，operator* 和 operator->是对指向数据操作的。我们仅需要将普通迭代器的这两个函数返回值修改即可。并且区分开普通迭代器与const迭代器。

template<class T>
class const_list_iterator
{
public:
	typedef _list_node<T> node;
	typedef const_list_iterator self;

	const_list_iterator(node* n)
		:_node(n)
	{
	}

    //返回值加const，不允许修改
	const T& operator*()
	{
		return _node->_val;
	}

	self operator++(int)
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

	self operator++()
	{
		_node = _node->_next;
		return *this;
	}

	self operator--(int)
	{
		self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}

	self operator--()
	{
		_node = _node->_prev;
		return *this;
	}

	bool operator!=(const self& it)
	{
		return _node != it._node;
	}

	bool operator==(const self& it)
	{
		return _node == it._node;
	}

    //返回值加const，不允许修改
	const T*  operator->()
	{
		return &_node->_val;
	}

private:
	node* _node;
};

但是这种设计让人觉得很不舒服，代码的重复太多。从代码的角度来看，const和普通迭代器仅仅只是返回值不同而已。我们只要给在给迭代器不同的类型，我们只需要给模板多架两个参数，如果是 T& 和 T*就实例化出普通迭代器，如果是 const T& 和 const T*就实例化出const迭代器。

list类内部：

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;//const迭代器

	List()
		:_head(new node)
	{
		_head->_next = _head;
		_head->_prev = _head;
	}

	iterator begin()
	{
		//使用哨兵位的下一个结点指针，构造begin
		return iterator(_head->_next);
	}
	iterator end()
	{
		//使用哨兵位结点指针，构造end
		return iterator(_head);
	}

	const_iterator begin()const
	{
		return const_iterator(_head->_next);
	}

	const_iterator end()const
	{
		return const_iterator(_head);
	}

private:
	node* _head;
};

迭代器：

//T:数据类型，Ref:T&/const T&, Ptr: T*/const T*
template<class T,class Ref,class Ptr>
class _list_iterator
{
public:
	typedef _list_node<T> node;
	typedef _list_iterator<T,Ref,Ptr> self;

	_list_iterator(node* n)
		:_node(n)
	{
	}

	Ref operator*()
	{
		return _node->_val;
	}

	self operator++(int)
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

	bool operator!=(const self& it )
	{
		return _node != it._node;
	}

	bool operator==(const self& it)
	{
		return _node == it._node;
	}

    //返回迭代器内部的结点指针
	node* GetNodePtr()
	{
		return _node;
	}

private:
	node* _node;

};

根据不同的模板参数从而实例化出不同的代码。

5.4 insert（），erase（）

insert（）可以在某一迭代器位置插入数据，erase可以删除某一迭代器位置的数据。

    void insert(iterator pos,const T& val)
	{
        //创建结点
		node* newnode = new node(val);
		node* posnode = pos.GetNodePtr();
		node* prevnode = posnode->_prev;
        //改变指向
		newnode->_next = posnode;
		newnode->_prev = prevnode;
		prevnode->_next = posnode;
		posnode->_prev = newnode;
		
	}
    
    iterator erase(iterator pos)
	{
		node* posnode = pos.GetNodePtr();
		node* prevnode = posnode->_prev;
		node* nextnode = posnode->_next;
        //修改指向
		prevnode->_next = nextnode;
		nextnode->_prev = prevnode;
        //释放结点
		delete posnode;
        return iterator(nextnode);
	}

 erase在返回的删除位置的下一个结点的迭代器,也是为了绝迭代器失效的问题。

5.5 析构函数

    //清除数据，但是头节点需要保留
	void clear()
	{
		iterator it = begin();
		while (it != end())
		{
			erase(it++);
		}
	}

	~List()
	{
		//连同头节点一起释放
		clear();
		delete _head;
		_head = nullptr;
	}

5.6再看构造函数

迭代器初始化

   	void emptyInit()
	{
		_head->_next = _head;
		_head->_prev = _head;
	}

    template<class InputIterator>
	List(InputIterator frist, InputIterator lest)
		:_head(new node)
	{
		emptyInit();
		while (frist != lest)
		{
			push_back(*frist);
			frist++;
		}
	}

五.list模拟实现整体代码

#pragma once
#include<iostream>
#include<cassert>
using namespace std;

template<class T>
struct _list_node
{
	_list_node( const T& val = T())
		:_val(val),
		_next(nullptr),
		_prev(nullptr)
	{
	}

	T _val;           //存储数据
	_list_node* _next;//后一个结点的指针
	_list_node* _prev;//前一个结点的指针
};

/*
List 的迭代器
迭代器有两种实现方式，具体应根据容器底层数据结构实现：
  1. 原生态指针，比如：vector
  2. 将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法：
	 1. 指针可以解引用，迭代器的类中必须重载operator*()
	 2. 指针可以通过->访问其所指空间成员，迭代器类中必须重载oprator->()
	 3. 指针可以++向后移动，迭代器类中必须重载operator++()与operator++(int)
		至于operator--()/operator--(int)释放需要重载，根据具体的结构来抉择，双向链表可以向前移动，所以需要重载，如果是forward_list就不需要重载--
	 4. 迭代器需要进行是否相等的比较，因此还需要重载operator==()与operator!=()
*/

//普通迭代器1.0版本
//template<class T>
//class _list_iterator
//{
//public:
//	typedef _list_node<T> node;
//	typedef _list_iterator self;
//
//	_list_iterator(node* n)
//		:_node(n)
//	{
//	}
//
//	T& operator*()
//	{
//		return _node->_val;
//	}
//
//	self operator++(int)
//	{
//		self tmp(*this);
//		_node = _node->_next;
//		return tmp;
//	}
//
//	self operator++()
//	{
//		_node = _node->_next;
//		return *this;
//	}
//
//	self operator--(int)
//	{
//		self tmp(*this);
//		_node = _node->_prev;
//		return tmp;
//	}
//
//	self operator--()
//	{
//		_node = _node->_prev;
//		return *this;
//	}
//
//	bool operator!=(const self& it)
//	{
//		return _node != it._node;
//	}
//
//	bool operator==(const self& it)
//	{
//		return _node == it._node;
//	}
//
//	T*  operator->()
//	{
//		return &_node->_val;
//	}
//private:
//	node* _node;
//};


//const迭代器1.0版本
//template<class T>
//class const_list_iterator
//{
//public:
//	typedef _list_node<T> node;
//	typedef const_list_iterator self;
//
//	const_list_iterator(node* n)
//		:_node(n)
//	{
//	}
//
//	const T& operator*()
//	{
//		return _node->_val;
//	}
//
//	self operator++(int)
//	{
//		self tmp(*this);
//		_node = _node->_next;
//		return tmp;
//	}
//
//	self operator++()
//	{
//		_node = _node->_next;
//		return *this;
//	}
//
//	self operator--(int)
//	{
//		self tmp(*this);
//		_node = _node->_prev;
//		return tmp;
//	}
//
//	self operator--()
//	{
//		_node = _node->_prev;
//		return *this;
//	}
//
//	bool operator!=(const self& it)
//	{
//		return _node != it._node;
//	}
//
//	bool operator==(const self& it)
//	{
//		return _node == it._node;
//	}
//
//	const T*  operator->()
//	{
//		return &_node->_val;
//	}
//private:
//	node* _node;
//};

//迭代器2.0版本
//T:数据类型，Ref:T&/const T&, Ptr: T*/const T*
template<class T, class Ref, class Ptr>
class _list_iterator
{
public:
	typedef _list_node<T> node;
	typedef _list_iterator<T, Ref, Ptr> self;

	_list_iterator(node* n)
		:_node(n)
	{
	}

	Ref operator*()
	{
		return _node->_val;
	}

	self operator++(int)
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

	bool operator!=(const self& it)
	{
		return _node != it._node;
	}

	bool operator==(const self& it)
	{
		return _node == it._node;
	}

	node* GetNodePtr()
	{
		return _node;
	}
private:
	node* _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;

	void emptyInit()
	{
		_head->_next = _head;
		_head->_prev = _head;
	}

	List()
		:_head(new node)
	{
		emptyInit();
	}

	template<class InputIterator>
	List(InputIterator frist, InputIterator lest)
		:_head(new node)
	{
		emptyInit();
		while (frist != lest)
		{
			push_back(*frist);
			frist++;
		}
	}

	void push_back(const T& val )
	{
		node* newnode = new node(val);

		node* tail = _head->_prev;

		tail->_next = newnode;
		newnode->_next = _head;
		_head->_prev = newnode;
		newnode->_prev = tail;
	}

	bool empty()
	{
		return _head->_next == _head;
	}

	void pop_back()
	{
		//判空
		assert(!empty());
		node* tail = _head->_prev;
		node* newtail = tail->_prev;
		//改变指向
		_head->_next = newtail;
		newtail->_prev = _head;
		//释放结点
		delete tail;
	}

	void insert(iterator pos,const T& val)
	{
		node* newnode = new node(val);
		node* posnode = pos.GetNodePtr();
		node* prevnode = posnode->_prev;

		newnode->_next = posnode;
		newnode->_prev = prevnode;
		prevnode->_next = posnode;
		posnode->_prev = newnode;
		
	}

	iterator erase(iterator pos)
	{

		node* posnode = pos.GetNodePtr();
		node* prevnode = posnode->_prev;
		node* nextnode = posnode->_next;
		prevnode->_next = nextnode;
		nextnode->_prev = prevnode;
		delete posnode;
		return iterator(nextnode);
	}

	iterator begin()
	{
		//使用哨兵位的下一个结点指针，构造begin
		return iterator(_head->_next);
	}
	iterator end()
	{
		//使用哨兵位结点指针，构造end
		return iterator(_head);
	}

	const_iterator begin()const
	{
		return const_iterator(_head->_next);
	}
	const_iterator end()const
	{
		return const_iterator(_head);
	}

	//清除数据，但是需要保留
	void clear()
	{
		iterator it = begin();
		while (it != end())
		{
			it = erase(it);
		}
	}

	~List()
	{
		//连同头节点一起释放
		clear();
		delete _head;
		_head = nullptr;
	}

private:
	node* _head;
};

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

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

相关文章

某大厂笔试（小*的车站的最近距离）

某大厂笔试（小*的车站的最近距离）

有一个环形的公路&#xff0c;上面共有n站&#xff0c;现在给定了顺时针第i站到第i1站之间的距离&#xff08;特殊的&#xff0c;也给出了第n站到第1站的距离&#xff09;&#xff0c;小*想着沿着公路第x站走到第y站&#xff0c;她想知道最短的距离是多少&#xff1f; 输入描述…
阅读更多...
无涯教程-Perl - print函数

无涯教程-Perl - print函数

描述 此函数将LIST中的表达式的值打印到当前的默认输出文件句柄或FILEHANDLE指定的句柄中。 如果设置,则$\变量将添加到LIST的末尾。 如果LIST为空,则打印$_中的值。 print接受一个值列表,列表中的每个元素都将被解释为一个表达式。 语法 以下是此函数的简单语法- print…
阅读更多...
谷歌发布多平台应用开发神器：背靠 AI 编程神器 Codey，支持 React、Vue 等框架，还能代码补全

谷歌发布多平台应用开发神器：背靠 AI 编程神器 Codey，支持 React、Vue 等框架，还能代码补全

一、概述 8 月 8 日&#xff0c;谷歌宣布推出 AI 代码编辑器 IDX&#xff0c;旨在提供基于浏览器的人工智能开发环境&#xff0c;用于构建全栈网络和多平台应用程序。谷歌在创建 IDX 时并没有构建新的 IDE&#xff08;集成开发环境&#xff09;&#xff0c;而是使用 VS Code 作…
阅读更多...
网络安全（黑客）自学路线/笔记

网络安全（黑客）自学路线/笔记

想自学网络安全&#xff08;黑客技术&#xff09;首先你得了解什么是网络安全&#xff01;什么是黑客&#xff01; 网络安全可以基于攻击和防御视角来分类&#xff0c;我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术&#xff0c;而“蓝队”、“安全运营”、“安全…
阅读更多...
代码随想录算法训练营第55天｜动态规划part12｜309.最佳买卖股票时机含冷冻期、714.买卖股票的最佳时机含手续费、总结

代码随想录算法训练营第55天｜动态规划part12｜309.最佳买卖股票时机含冷冻期、714.买卖股票的最佳时机含手续费、总结

代码随想录算法训练营第55天&#xff5c;动态规划part12&#xff5c;309.最佳买卖股票时机含冷冻期、714.买卖股票的最佳时机含手续费、总结 309.最佳买卖股票时机含冷冻期 309.最佳买卖股票时机含冷冻期 思路&#xff1a; 区别在第i天持有股票的当天买入的情况&#xff0c…
阅读更多...
【Kubernetes】神乎其技的K8s到底是什么，为什么被越来越多人使用

【Kubernetes】神乎其技的K8s到底是什么，为什么被越来越多人使用

&#x1f680;欢迎来到本文&#x1f680; &#x1f349;个人简介&#xff1a;陈童学哦&#xff0c;目前学习C/C、算法、Python、Java等方向&#xff0c;一个正在慢慢前行的普通人。 &#x1f3c0;系列专栏&#xff1a;陈童学的日记 &#x1f4a1;其他专栏&#xff1a;CSTL&…
阅读更多...
户外骨传导耳机推荐，盘点最适合户外佩戴的五款耳机

户外骨传导耳机推荐，盘点最适合户外佩戴的五款耳机

现在天气越来越暖和了&#xff0c;很多人选择外出徒步、越野或者骑行&#xff0c;在这些活动中往往都会搭配一个骨传导耳机&#xff0c;来让运动过程变得更加有趣。在选购骨传导耳机时&#xff0c;人们通常会考虑音质、舒适性、价格等因素&#xff0c;为了让大家选到更适合自己…
阅读更多...
Kafka API与SpringBoot调用

Kafka API与SpringBoot调用

文章目录 首先需要命令行创建一个名为cities的主题&#xff0c;并且创建该主题的订阅者。 1、使用Kafka原生API1.1、创建spring工程1.2、创建发布者1.3、对生产者的优化1.4、批量发送消息1.5、创建消费者组1.6 消费者同步手动提交1.7、消费者异步手动提交1.8、消费者同异步手动…
阅读更多...
yolov5目标检测多线程Qt界面

yolov5目标检测多线程Qt界面

上一篇文章&#xff1a;yolov5目标检测多线程C部署 V1 基本功能实现 mainwindow.h #pragma once#include <iostream>#include <QMainWindow> #include <QFileDialog> #include <QThread>#include <opencv2/opencv.hpp>#include "yolov5.…
阅读更多...
phpspreadsheet excel导入导出

phpspreadsheet excel导入导出

单个sheet页Excel2003版最大行数是65536行。Excel2007开始的版本最大行数是1048576行。Excel2003的最大列数是256列&#xff0c;2007以上版本是16384列。 xlswriter xlswriter - PHP 高性能 Excel 扩展&#xff0c;功能类似phpspreadsheet。它能够处理非常大的文件&#xff0…
阅读更多...
056B R包ENMeval教程-基于R包ENMeval对MaxEnt模型优化调参和结果评价制图(更新)

056B R包ENMeval教程-基于R包ENMeval对MaxEnt模型优化调参和结果评价制图(更新)

056B-1 资料下载 056B-2 R包ENMeval在MaxEnt模型优化调参中的经典案例解读 056B-3 R软件和R包ENMeval工具包安装 056B-4 R软件和R包ENMeval安装报错解决办法 056B-5 环境数据格式要求和处理流程 056B-6 分布数据格式要求和处理流程 056B-7 基于R包ENMeval对MaxEnt模型优化…
阅读更多...
12.pod生命周期和存储卷

12.pod生命周期和存储卷

文章目录 pod生命周期pod启动阶段故障排除步骤&#xff1a; 存储卷emptyDir存储卷 hostPath存储卷nfs共享存储卷总结&#xff1a; pod生命周期 pod启动阶段 一般来说&#xff0c;pod 这个过程包含以下几个步骤&#xff1a; 调度到某台 node 上。kubernetes 根据一定的优先级算…
阅读更多...
【C#】静默安装、SQL SERVER静默安装等

【C#】静默安装、SQL SERVER静默安装等

可以通过cmd命令行来执行&#xff0c;也可以通过代码来执行&#xff0c;一般都需要管理员权限运行 代码 /// <summary>/// 静默安装/// </summary>/// <param name"fileName">安装文件路径</param>/// <param name"arguments"…
阅读更多...
Dubbo 2.7.0 CompletableFuture 异步

Dubbo 2.7.0 CompletableFuture 异步

了解Java中Future演进历史的同学应该知道&#xff0c;Dubbo 2.6.x及之前版本中使用的Future是在java 5中引入的&#xff0c;所以存在以上一些功能设计上的问题&#xff0c;而在java 8中引入的CompletableFuture进一步丰富了Future接口&#xff0c;很好的解决了这些问题。 Dubb…
阅读更多...
小内存嵌入式设备软件的差分升级设计（学习）

小内存嵌入式设备软件的差分升级设计（学习）

摘要 提出一种改进HDiffPatch算法并在复旦微单片机上实现小内存差分升级的方案&#xff0c;即使用单片机内的Flash空间替代算法占用的RAM空间&#xff0c;从而减少算法对单片机RAM空间的需求&#xff0c;以满足小内存微处理器的差分升级&#xff0c;同时对算法内存分配释放函数…
阅读更多...
HashMap源码探究之底“库”看穿

HashMap源码探究之底“库”看穿

前言&#xff1a; 本次的源码探究会以jdk1.7和jdk1.8对比进行探究二者在HashMap实现上有的差异性&#xff0c;除此之外&#xff0c;还会简单介绍HashMap的hash算法的设计细节、jdk1.8中HashMap添加功能的整个流程、什么情况下会树化等源码设计知识。 一、HashMap介绍 HashMap…
阅读更多...
SpringBoot3数据库集成

SpringBoot3数据库集成

标签&#xff1a;Jdbc.Druid.Mybatis.Plus&#xff1b; 一、简介 项目工程中&#xff0c;集成数据库实现对数据的增晒改查管理&#xff0c;是最基础的能力&#xff0c;而对于这个功能的实现&#xff0c;其组件选型也非常丰富&#xff1b; 通过如下几个组件来实现数据库的整合…
阅读更多...
Spring Cloud 智慧工地源码（PC端＋移动端）项目平台、监管平台、大数据平台

Spring Cloud 智慧工地源码（PC端＋移动端）项目平台、监管平台、大数据平台

智慧工地源码 智慧工地云平台源码 智慧建筑源码 “智慧工地”是利用物联网、人工智能、云计算、大数据、移动互联网等新一代信息技术&#xff0c;彻底改变传统建筑施工现场参建各方现场管理的交互方式、工作方式和管理模式&#xff0c;实现对人、机、料、法、环的全方位实时监…
阅读更多...
uniapp开发公众号，微信开发者工具进行本地调试

uniapp开发公众号，微信开发者工具进行本地调试

每次修改完内容都需要发行之后&#xff0c;再查看效果&#xff0c;很麻烦 &#xff01;&#xff01;&#xff01; 下述方法&#xff0c;可以一边在uniapp中修改内容&#xff0c;一边在微信开发者工具进行本地调试 修改hosts文件 在最后边添加如下内容 修改前端开发服务端口 …
阅读更多...
Android 第一行代码学习 -- 聊天界面小练习

Android 第一行代码学习 -- 聊天界面小练习

前言&#xff1a;最近在学习安卓&#xff0c;阅读入门书籍第一行代码&#xff0c;以后更新的知识可能大部分都会和安卓有关。 实现聊天界面 1.编写主界面 个人觉得界面编写刚开始学可能看着很乱&#xff0c;但是其中最重要的是层次&#xff0c;看懂了其中的层次&#xff0c;就…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023