[C++初阶]list的模拟实现

news2024/9/20 20:35:31

一、对于list的源码的部分分析

1.分析构造函数

首先，我们一开始最先看到的就是这个结点的结构体，在这里我们可以注意到这是一个双向链表。有一个前驱指针，一个后继指针。然后在有一个存储数据的空间

其次它的迭代器是一个自定义类型，而非原生指针。这里我们先不管，我们接着往下看。

我们继续找成员变量，在这里我们就找到了成员变量，但是这个类型我们看不懂，于是我们先略过。

通过对定义的查找，可以看到这个实际上还是一个指针。但是这个指针我们还是看不懂。

于是我们继续去速览定义，于是就找到了这里

这里我们可以注意到这个结点的类型其实就是一个类模板，这个模板正好就是我们一开始就看到的用结构体定义的一个结点。因此我们可以知道，这个成员变量实际就是一个指针，这个指针指向一个结点。这样一想象，就有点像我们在c语言使用链表时候的头节点了。

那么接下来，我们应该分析一下构造函数是什么样子的。
不难发现，就在成员变量的下方，正好就是一个无参的构造函数。也就是默认构造函数

但是在这里它又封装了一层函数，于是乎我们继续深入查看

如下所示，我们看到了具体的函数内容，从名字上来看，get_node 我们挺名字就知道开空间的。也就是得到一个结点，然后返回这个结点指针。这样一来，我们的成员变量就获取的实际的一个结点，然后让它的next和prev都指向自己，这样一来这个结点形成一个自循环。现在就能看出来这是一个带头双向循环链

我们也可以继续深入

如上图所示，这里的allocated设计到空间配置器。这里我们就先不做了解了。之后在学习中我们详细介绍。

我们往下看会看到put_node，这个函数其实就是释放结点的。在后面还有这样一个函数，这个函数是create_node不难理解，这个就是获取一个结点，先给这个结点开空间，然后调用构造函数。等一系列操作。既然这里涉及到一个构造，那么我们可以继续深入，看看这个构造里面是什么东西？但是这里涉及到了C++11的内容了，这边我们就先不管它了，我们只需要知道这里的空间能new出来就行。

2.对于头尾插的分析

作为链表，我们知道除了构造最重要的，肯定是头尾插，这里我们先找到头尾插的对应的函数

我们发现头尾插都调用了insert这个函数，因此我们需要先找到这个函数，

这里我们也是能大概理解的，先创造一个结点，然后进行连接。现在我们也基本读懂了这个大体的框架了，但是这里还需要注意的是：由于一开始的结点里面的指针都是空指针，导致后面需要经历很多的强制类型转化。所以这里我们如果一开始就定义好指针的类型是最好的。

二、list的模拟实现

1.list的节点声明

为了不和标准库中的list类冲突，我们可以开一个自己的命名空间，

其次，C++中对结点进行定义的时候可以只写类名，这与class是一样的。注意不要忘记带上模板参数T，因为我们写的结点也只是一个模板。因为类名不是类型，他实例化以后可以有各种各样的结点类型

	template<class T>
	struct list_node
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _val;
	};

2.list类的成员变量

由于我们的结点是一个模板，对于它而言，它的类型就比较繁琐，我们可以在list类里面使用typedef进行一次重命名。然后再私有里面再定义一个指针，这个指针就是一个结点指针。

	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:

	private:
		Node* _head;
	};

3.list类的默认构造函数

如下所示，我们定义好了成员变量以后，我们就写一个默认构造函数，当我们对这个链表类进行实例化的时候，自动调用这个默认构造函数，这个默认构造函数会为成员变量的头节点指针分配实际的空间，在new Node空间的时候，会调用它Node（即list_node<T>）类的默认构造函数函数。从而成功的开辟好这块空间。
 

		list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}

4.list类的尾插

如下所示，我们的尾插逻辑也是比较简单的，先利用我们传过来的val去开辟一个新的结点，注意这里开辟新结点的时候使用new的话可以直接带一个括号去调用它的构造函数

		void push_back(const T& val)
		{
			Node* newnode = new Node(val);
			Node* tail = _head->_prev;

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

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

5.结点的默认构造函数

有了上面的分析之后，我们现在缺的是一个结点的默认构造函数，我们直接给一个缺省值，使用T()就是一个匿名对象来初始化，对于内置类型也是同样适用的。然后我们使用初始化列表即可。

		list_node(const T& val = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_val(val)
		{}

6.list类的迭代器

首先我们思考一下，可否像vector一样直接在类里面typedef 一个迭代器？

显然是不行的,因为链表不支持下标随机访问,list是不连续的，指针加1后，地址早已不知道跑到哪个结点去了。其次这里仅仅只是结点的指针，解引用后，找到的仅仅只是结点，我们还需要进一步解引用才能找到对应的真正的值。

直接typedef的话，会使得迭代器的++和解引用操作均失效了，这时候我们只能使用运算符重载了。才能解决这个问题。既然要运算符重载，这里我们最好再次封装一个类出来。因为如果不封装一个类出来的话，我们无法完成此处的运算符重载。

如下所示，是我们实现的iterator的类

	template<class T>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		Node* _node;

		__list_iterator(Node* node)
			:_node(node)
		{}

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

		__list_iterator<T>& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		bool operator!=(const __list_iterator<T>& it)
		{
			return _node != it._node;
		}

	};

这个类我们使用了一个结构体去封装，在这个结构体中，我们只有一个成员变量，这个成员变量是结点类的指针，用于指向某一个结点， 在我们一开始定义出迭代器的时候，我们需要先写一个构造函数，用于迭代器的初始化。即需要传一个参数node来控制。

与之对应的，我们在list中就需要写出对应的begin和end函数，来返回迭代器。

		typedef __list_iterator<T> iterator;
		iterator begin()
		{
			//return _head->_next //单参数的构造函数支持隐式类型转换
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

下面我们这里将迭代器的基本操作写的稍微完善一些

	template<class T>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		Node* _node;

		__list_iterator(Node* node)
			:_node(node)
		{}

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

		__list_iterator<T>& operator++()
		{
			_node = _node->_next;
			return *this;
		}

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

		bool operator!=(const __list_iterator<T>& it)
		{
			return _node != it._node;
		}

		bool operator==(const __list_iterator<T>& it)
		{
			return _node == it._node;
		}
	};

7.const迭代器

我们可以拷贝一份原来的迭代器，然后改变一下类名和解引用这个成员函数的返回值即可

	template<class T>
	struct __list_const_iterator
	{
		typedef list_node<T> Node;
		Node* _node;

		__list_const_iterator(Node* node)
			:_node(node)
		{}

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

		__list_const_iterator<T>& operator++() 
		{
			_node = _node->_next;
			return *this;
		}

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

		bool operator!=(const __list_const_iterator<T>& it) 
		{
			return _node != it._node;
		}

		bool operator==(const __list_const_iterator<T>& it) 
		{
			return _node == it._node;
		}
	};

即如上代码所示，但是这样设计太过于冗余了。不过这个也是可以正常运行的，我们先补两个接口

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

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

其实我们可以通过一个类型去控制这个返回值，而要控制这个类型，就需要增加一个模板参数即可

在迭代器类中添加一个Ref参数,然后让*的运算符重载返回这个模板参数,最后代码如下：

	template<class T, class Ref>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref> self;

		Node* _node;

		__list_iterator(Node* node)
			:_node(node)
		{}

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

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

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

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

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

当然现在还没完，还有时候，我们可能会写出这样的代码

	struct A
	{
		A(int a = 0, int b = 0)
			:_a(a)
			,_b(b)
		{}
		int _a;
		int _b;
	};
	void test2()
	{
		list<A> lt;
		lt.push_back(A(1, 1));
		lt.push_back(A(2, 2));
		lt.push_back(A(3, 3));
		lt.push_back(A(4, 4));
		lt.push_back(A(5, 5));


		list<A>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << it->_a << " ";
			it++;
		}
		cout << endl;
	}

我们显然发现是无法正常运行的。由于迭代器是类似于指针的操作，我们有时候就需要->操作符去解引用。所以,我们需要加上一个->的运算符重载。

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

如上所示，是写在迭代器里面的operator运算符重载,

然而当我们细心的话，我们会发现这个运算符重载是比较怪异的。哪里怪异呢？

首先我们这个运算符重载返回的是什么呢？是A*，也就是说它还需要一次->解引用才能找到真正的值。那么我们这里为什么可行呢？

严格来说，it->->_a，才是符合语法的。
因为运算符重载要求可读性，那么编译器特殊处理，省略了一个->

上面这个运算符重载仅仅只是针对于普通对象的，如果是const对象的话，那么我们只能使用跟*运算符重载一样的处理方法，多传一个参数，才可以解决这个问题。也就是我们需要三个模板参数才可以。
最终我们的迭代器代码如下所示

	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)
		{}

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

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

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

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

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

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

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

8.插入和删除接口

整体简单,这里直接展示源码:

		void push_back(const T& val)
		{

			//insert(end(), val);
			Node* newnode = new Node(val);
			Node* tail = _head->_prev;

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

			newnode->_next = _head;
			_head->_prev = newnode;
		}
		void push_front(const T& val)
		{
			insert(begin(), val);
		}

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

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

		iterator insert(iterator pos, const T& val)
		{
			Node* newnode = new Node(val);
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;

			return newnode;
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			cur = nullptr;

			prev->_next = next;
			next->_prev = prev;

			return next;
		}

9.size

这个不难,我可以通过遍历解决得出size,但是这样子的时间复杂度可能有点高,

		size_t size()
		{
			size_t sz = 0;
			iterator it = begin();
			while (it != end())
			{
				it++;
				sz++;
			}
			return sz;
		}

这里我们也可以用第二种方法,多加一个成员变量存储节点数量,每次插入节点时++,删除节点时--,这里我就不多做解释了

10.clear

这个就是遍历释放空间就行

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

11.析构函数

析构函数也是很简单的，析构和clear的区别就是析构会删除头节点，而clear不会删除头节点。

		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

12.拷贝构造函数

这里设计空间的开辟,所以需要深拷贝,代码如下:

		list(const list<T>& lt)
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;

			for (auto& e : lt)
			{
				push_back(e);
			}
		}

当然在这里我们发现拷贝构造和默认构造有点重复了。我们可以对前面重复的部分在封装一个函数，从而简化代码:

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		list()
		{
			//_head = new Node;
			//_head->_next = _head;
			//_head->_prev = _head;
			//_size = 0;
			empty_init();
		}

		list(const list<T>& lt)
		{
			//_head = new Node;
			//_head->_next = _head;
			//_head->_prev = _head;
			//_size = 0;
			empty_init();

			for (auto& e : lt)
			{
				push_back(e);
			}
		}

13.赋值运算符重载

如下所示，这个也是比较简单，我们直接使用现代写法吧:

		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

同时我们需要注意库里面的函数返回值和形参写的是类名，而不是类型,

这是因为在类模板里面写成员函数的时候，是允许用类名代替类型的。即我们的代码下面这些部分可以直接换为类名，但是呢，这里不建议使用，因为这种行为会降低可读性。

三、模拟list类的全部代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<list>
#include<assert.h>

using namespace std;

namespace Sim
{
	template<class T>
	struct list_node
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _val;

		list_node(const T& val = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_val(val)
		{}
	};

	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)
		{}

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

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

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

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

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

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

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

		bool operator==(const self & it) const
		{
			return _node == it._node;
		}
	};
	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:

		typedef __list_iterator<T, T&, T*> iterator;
		//typedef __list_const_iterator<T> const_iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;
		iterator begin()
		{
			//return _head->_next //单参数的构造函数支持隐式类型转换
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}
		const_iterator begin() const
		{
			//return _head->_next //单参数的构造函数支持隐式类型转换
			return const_iterator(_head->_next);
		}

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

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		list()
		{
			//_head = new Node;
			//_head->_next = _head;
			//_head->_prev = _head;
			//_size = 0;
			empty_init();
		}

		list(const list<T>& lt)
		{
			//_head = new Node;
			//_head->_next = _head;
			//_head->_prev = _head;
			//_size = 0;
			empty_init();

			for (auto& e : lt)
			{
				push_back(e);
			}
		}
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		void push_back(const T& val)
		{

			insert(end(), val);
			//Node* newnode = new Node(val);
			//Node* tail = _head->_prev;

			//tail->_next = newnode;
			//newnode->_prev = tail;

			//newnode->_next = _head;
			//_head->_prev = newnode;
		}
		void push_front(const T& val)
		{
			insert(begin(), val);
		}

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

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

		iterator insert(iterator pos, const T& val)
		{
			Node* newnode = new Node(val);
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;

			++_size;

			return newnode;
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			cur = nullptr;

			prev->_next = next;
			next->_prev = prev;

			--_size;

			return next;
		}

		size_t size()
		{
			//size_t sz = 0;
			//iterator it = begin();
			//while (it != end())
			//{
			//	it++;
			//	sz++;
			//}
			//return sz;
			return _size;
		}

		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

	private:
		Node* _head;
		size_t _size;
	};

	}
}

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

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

相关文章

【Python游戏】编程开发贪吃蛇游戏（第一期）

【Python游戏】编程开发贪吃蛇游戏（第一期）

本文收录于 《一起学Python趣味编程》专栏&#xff0c;从零基础开始&#xff0c;分享一些Python编程知识&#xff0c;欢迎关注&#xff0c;谢谢&#xff01; 文章目录 一、前言二、贪吃蛇游戏开发简介2.1 贪吃蛇游戏规则2.2 贪吃蛇游戏开发步骤 三、贪吃蛇游戏开发实战四、总结…
阅读更多...
13 个最受欢迎的技术写作工具

13 个最受欢迎的技术写作工具

13 个最受欢迎的技术写作工具 在我的职业生涯中&#xff0c;我作为技术作家工作了大约 10 年&#xff0c;根据需要使用了各种文档工具。作为技术作家&#xff0c;主要工作职责是提供正确的内容。 使用正确的技术写作工具可以使技术作家的生活变得轻松。有多种工具可用于不同的…
阅读更多...
【Vue】Vue3 安装 Tailwind CSS 入门

【Vue】Vue3 安装 Tailwind CSS 入门

初始化 Vue 3 项目 npm install -g vue/cli vue create my-project安装 Tailwind CSS 进入你的项目目录&#xff0c;然后安装 Tailwind CSS 和其依赖项&#xff1a; npm install -D tailwindcss postcss autoprefixer配置 PostCSS Tailwind CSS 需要通过 PostCSS 进行处理。…
阅读更多...
Linux发行版CentOS 8 利用Docker安装应用

Linux发行版CentOS 8 利用Docker安装应用

目录 一、什么是Docker&#xff1f; 主要功能&#xff1a; 二、安装Docker 1.安装yum配置工具 2.配置docker的yum源 3.安装 4.测试 5.启动&#xff0c;关闭&#xff0c;开机自启动 三、卸载Docker 1.停止服务 2.卸载 3.删除文件 四、Docker配置镜像源 1.在etc下创建docker…
阅读更多...
【大模型时代的PDF解析工具】

【大模型时代的PDF解析工具】

去年&#xff08;2023年&#xff09;是大模型爆发元年。但是大模型具有两个缺点&#xff1a;缺失私有领域知识和幻觉。缺失私有领域知识是指大模型训练时并没有企业私有数据/知识&#xff0c;所以无法正确回答相关问题。并且在这种情况下&#xff0c;大模型会一本正经地胡说八道…
阅读更多...
JavaEE--JavaWeb服务器的安装配置(Tomcat服务器安装配置)

JavaEE--JavaWeb服务器的安装配置(Tomcat服务器安装配置)

前言: 本文介绍了 Java Web 服务器 Tomcat 的安装配置&#xff0c;并详细说明了如何在 IntelliJ IDEA 中配置服务器&#xff0c;创建 JavaEE 项目&#xff0c;并发布文章。文章首先解释了前端程序如何访问后端程序以及 Web 服务器的概念&#xff0c;然后详细介绍了安装 Tomcat…
阅读更多...
VirtualBox虚拟机与主机互传文件的方法

VirtualBox虚拟机与主机互传文件的方法

建立共享文件夹 1.点击设置&#xff0c;点击共享文件夹&#xff0c;添加共享文件夹路径&#xff0c;保存 2.启动虚拟机&#xff0c;点击设备&#xff0c;点击安装增强功能&#xff0c;界面会出现一个光碟图标&#xff0c;点击光碟图标 3.打开光碟图标&#xff0c;出现一个目…
阅读更多...
Vue3渐变文字（GradientText）

Vue3渐变文字（GradientText）

效果如下图&#xff1a;在线预览 APIs GradientText 参数说明类型默认值必传gradient文字渐变色参数string | Gradientundefinedfalsesize文字大小&#xff0c;不指定单位时&#xff0c;默认单位 pxnumber | string14falsetype渐变文字的类型‘primary’ | ‘info’ | ‘succ…
阅读更多...
【大模型】FAISS向量数据库记录：从基础搭建到实战操作

【大模型】FAISS向量数据库记录：从基础搭建到实战操作

文章目录 文章简介Embedding模型BGE-M3 模型亮点 FAISS是什么FAISS实战安装faiss加载Embedding模型创建FAISS数据库搜索FAISS数据删除FAISS数据保存、加载FAISS索引 总结 本人数据分析领域的从业者&#xff0c;拥有专业背景和能力&#xff0c;可以为您的数据采集、数据挖掘和数…
阅读更多...
Java语言程序设计基础篇_编程练习题**14.29（游戏：豆机）

Java语言程序设计基础篇_编程练习题**14.29（游戏：豆机）

第十四章第二十九题 **14.29 (游戏&#xff1a;豆机) 请写一个程序&#xff0c;显示编程练习题 7.21 中介绍的豆机&#xff0c;如图 14-52c 所示 代码展示 package chapter_14;import javafx.application.Application; import javafx.scene.Scene; import javafx.scene.layou…
阅读更多...
易保全参与起草的两项区块链全国团体标准正式发布

易保全参与起草的两项区块链全国团体标准正式发布

在数字化转型浪潮席卷全球的今天&#xff0c;区块链技术以其去中心化、透明性、不可篡改等独特优势&#xff0c;正逐步成为重塑各行各业信任机制与业务流程的关键力量。 近日&#xff0c;中国通信工业协会正式发布了《区块链服务 基于区块链的去中心化标识符技术要求》与《区块…
阅读更多...
什么是反向代理？

什么是反向代理？

这里写目录标题 一、什么是反向代理&#xff1f;二、反向代理的工作原理三、使用反向代理的好处四、反向代理的风险 在网络领域中&#xff0c;代理服务器是一种常见的技术&#xff0c;用于转发客户端和服务器之间的请求和响应。代理服务器又可以分为反向代理和正向代理两种类型…
阅读更多...
QT实现图片开关控件-自定义控件

QT实现图片开关控件-自定义控件

开关按钮大家应该很熟悉&#xff0c;在设置里面经常遇到&#xff0c;切换时候的滑动效果比较帅气。通常说的开关按钮&#xff0c;有两个状态&#xff1a;on、off。大部分的开关按钮控件&#xff0c;基本上有两大类&#xff0c;第一类是纯代码绘制&#xff0c;这种对代码的掌控度…
阅读更多...
SD-WAN组网搭建5G备份方案实现方式

SD-WAN组网搭建5G备份方案实现方式

SD-WAN&#xff08;Software-Defined Wide Area Network&#xff0c;软件定义广域网&#xff09;结合5G作为备份链路是现代企业网络弹性策略的一部分&#xff0c;尤其是在需要高可用性和快速故障切换的场景下。以下是实现SD-WAN组网并集成5G备份方案的一般步骤&#xff1a; 1. …
阅读更多...
Spring完整知识点汇总一

Spring完整知识点汇总一

Spring简介 额外知识点 在之前的学习中我们在Service业务层创建Dao/Mapper数据访问层&#xff08;持久层&#xff09;的对象是通过工具类来获取对应Dao/Mapper数据访问层&#xff08;持久层&#xff09;的接口代理对象在此处我们不用工具类来获取对应Dao/Mapper数据访问层&…
阅读更多...
WebPack5.0 快速入门

WebPack5.0 快速入门

前端工程化WebPack5️⃣ 前置知识&#xff1a; 此文章属于前端——框架进阶篇&#xff0c;需要实现掌握&#xff1a;HTMLCSSJS三件套、Node... &#x1f600;推荐分享一波个人Blog文档&#xff1a; JavaScript、前端工程\模块化、邂逅Node.JS的那一夜 什么是WebPack❓ Web…
阅读更多...
飞凌全志T527开发板modbus移植使用教程

飞凌全志T527开发板modbus移植使用教程

交叉编译 进入到源码目录&#xff0c;执行 ./configure ac_cv_func_malloc_0_nonnullyes --hostaarch64-none-linux-gnu --enable-static --prefix/home/feng/文档/development/Linux/application/OK527N/libmodbus-3.1.10/install/其中–host为交叉编译器的前缀&#xff1b;…
阅读更多...
谈一谈一条SQL的查询、更新语句究竟是如何执行的?

谈一谈一条SQL的查询、更新语句究竟是如何执行的?

文章目录 理解执行流程衍生知识redo logbinlog 本篇文章是基于《MySQL45讲》来写的个人理解与感悟。 理解 先看下图&#xff1a; 上一篇文章我们讨论了一条SQL查询语句的执行流程&#xff0c;并介绍了执行过程中涉及的处理模块。 回顾一下&#xff1a; 大体来说&#xff0c;…
阅读更多...
RK3568笔记三十九：多个LED驱动开发测试（设备树）

RK3568笔记三十九：多个LED驱动开发测试（设备树）

若该文为原创文章&#xff0c;转载请注明原文出处。 通过设备树配置一个节点下两个子节点控制两个IO口&#xff0c;一个板载LED&#xff0c;一个外接LED。 一、介绍 通过学习设备树控制GPIO&#xff0c;发现有多种方式 一、直接通过寄存器控制 二、通过设备树&#xff0c;但…
阅读更多...
【中项】系统集成项目管理工程师-第一模块：IT技术和管理-1.5数字化转型与元宇宙

【中项】系统集成项目管理工程师-第一模块：IT技术和管理-1.5数字化转型与元宇宙

前言&#xff1a;系统集成项目管理工程师专业&#xff0c;现分享一些教材知识点。觉得文章还不错的喜欢点赞收藏的同时帮忙点点关注。 备注&#xff1a;IT技术和管理-1.4章节涉及敏感&#xff0c;无法发送&#xff0c;故跳过。 软考同样是国家人社部和工信部组织的国家级考试…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023