【C++】STL---list的模拟实现

news/2025/2/22 14:12:57

目录

  • 前言
  • 一、list和vector的区别
  • 二、节点的定义
  • 三、list类定义
  • 四、push_back函数
  • 五、push_front函数
  • 六、迭代器
  • 七、begin和end函数
  • 八、迭代器区间初始化
  • 九、迭代器的操作符重载
    • 操作符++重载
    • 操作符- -重载
    • 操作符!=重载
    • 操作符==重载
    • 操作符*重载
  • 十、insert函数
  • 十一、erase函数
  • 十二、pop_back函数
  • 十三、pop_front
  • 十四、析构函数
  • 十五、拷贝构造函数
  • 十六、赋值操作符重载
  • 十七、迭代器优化
  • 十七、反向迭代器
  • 总结:

前言

上次模拟实现了一个vector容器,那么我们这次来实现一个list(链表)容器,链表在实际的开发中并不常见。但是也是一种很重要的数据结构,下面给大家介绍一下链表(list) 和 vector(顺序表)的区别。


listvector_13">一、list和vector的区别

list 和 vector 一样,是一个存储容器。不同的是vector在内存中是连续存储的,而list每个节点所在的内存区域是不连续的。那我们用vector还是用list呢?vector和list的优劣势有以下几点。
vector优点:
1.支持下标随机访问。
2.cpu命中缓存率高
vector缺点:
1.存在一定的程度的空间浪费。
2.扩容代价大。
3.中间和前面元素的删除与插入,代价大。


list优点:
1.按需申请空间,不存在空间浪费。
2.任意位置的插入与删除,时间复杂度都是O(1)。
list缺点:
1.不支持随机访问,以至于查找,排序等操作代价太大。
2.cpu命中缓存率低。

综上所述,我们可以看到list和vector是完全互补的两个容器。vector的优点就是list的缺点,vector的缺点就是list的优点。所以,如果查找多,用vector,如果增删操作多,用list,了解了list之后,接下来我们就可以模拟实现一下它。


二、节点的定义

我们要实现的是一个带头双向循环的链表
在这里插入图片描述
所以节点有三个参数,一个的prve指向前一个节点,一个是date存储数据,还有一个是next指向下一个节点。当然,我们还需要有个构造函数,来给date赋值。

代码:

	//节点结构体
	template<class T>
	struct ListNode
	{
		typedef ListNode<T> Node;
		Node* _prve;
		Node* _next;
		T _data;

		//构造函数
		ListNode():_prve(nullptr),_next(nullptr),_data(0){}
		
		ListNode(const T& val)
			:_prve(nullptr)
			,_next(nullptr)
		{
			_data = val;
		}
	};

list_66">三、list类定义

list定义很简单,因为要存任意类型的参数,我们用模板即可。
而私有成员只有一个,那就是头节点。

代码:

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		//构造函数
		list()
		{
			//开辟空间
			_head = new Node;
			//自己指向自己
			_head->_prve = _head;
			_head->_next = _head;
		}
	private:
		Node* _head;
	};

四、push_back函数

push_back函数也就是尾部插入,我们可以通过头节点的prev找到最后一个节点,随后链接即可。

代码:

		void push_back(const T& val)
		{
			//创建一个新节点
			Node* newNode = new Node(val);
			//找到尾节点
			Node* tail = _head->_prve;
			//尾节点和创建的节点链接
			tail->_next = newNode;
			newNode->_prve = tail;
			_head->_prve = newNode;
			newNode->_next = _head;
		}

五、push_front函数

就是头插,很简单,直接保存节点的下一个节点,然后创建一个新节点。把这俩节点链接起来。

代码:

		void push_front(const T& val)
		{
			//创建一个新节点
			Node* newNode = new Node(val);
			//保存头节点的下一个节点
			Node* next = _head->_next;
			//链接
			_head->_next = newNode;
			newNode->_prve = _head;
			next->_prve = newNode;
			newNode->_next = next;
		}

六、迭代器

因为是链表容器,链表在内存中的存储不是连续的,所以迭代器+1是无法找到下一个节点的。所以我们要单独弄一个结构体来封装list的迭代器。

代码:

	template<class T>
	struct_list_iterator
	{
		Node* _it;
		typedef ListNode<T> Node;
		// 构造函数
		_list_iterator(Node* node)
			:_it(node)
		{	
		}

	};

七、begin和end函数

我们的链表是带头的,也就是头节点是不存放有效值的,所以头节点的_next指向的节点就是链表的第一个节点。而最后一个节点的下一个节点又恰好是头节点。所以迭代器开始位置是在头节点的下一个位置,结束位置是头节点。不过再此之前,我们需要把迭代器typedef一下。

代码:

		//迭代器
		typedef _list_iterator<T> iterator;
		typedef _list_iterator<const T> const_iterator;
		//迭代器获取
		iterator begin()
		{
			return iterator(_head->_next);
		}

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

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

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

八、迭代器区间初始化

有了迭代器之后,我们可以用迭代器区间来进行初始化。

代码:

		template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			//创建头节点
			_head = new Node();
			_head->_prve = _head;
			_head->_next = _head;

			while (first != last)
			{
				pusb_back(*first);
				++first;
			}
		}

九、迭代器的操作符重载

接下来我们来完善迭代器的一些操作。

操作符++重载

迭代器++,就是指向下一个元素。

		typedef _list_iterator<T> self;
		//前置++重载
		self& operator++()
		{
			_it = _it->_next;
			return *this;
		}
		//后置++重载
		self operator++(int)
		{
			self tmp(*this);
			_it = _it->_next;
			return tmp;
		}

操作符- -重载

和++类似,不过- -是到前一个节点。

		//前置--重载
		self& operator--()
		{
			_it = _it->_prve;
			return *this;
		}

		//后置--重载
		self operator--(int)
		{
			self tmp(*this);
			_it = _it->_prve;
			return tmp;
		}

操作符!=重载

直接比较地址即可。

	// !=重载
		bool operator!=(const self& it)const
		{
			return _it != it._it;
		}

操作符==重载

直接比较地址即可。

	// ==重载
		bool operator==(const self& it)const
		{
			return _it == it._it;
		}

操作符*重载

*就是解引用,所以我们返回节点的值即可。

		T& operator*()
		{
			return _it->_data;
		}

但是这个代码有个缺陷,那就是当容器是const的时候,依旧可以解引用修改它的值,这也就意味着const迭代器根本就不具有常属性,要想const迭代具备常属性,我们必须增加模板参数。
在这里插入图片描述
当容器是const的时候,返回的const迭代器必须具有常属性。所以我们要加一个模板参数作为返回值。
在这里插入图片描述

然后list里面typedef的类型也修改一下。
在这里插入图片描述
然后我们解引用时,返回Ref这个模板参数
在这里插入图片描述
这样,我们就让const的迭代器具备了常属性
在这里插入图片描述
迭代器结构体的所有代码:

//迭代器
	template<class T,class Ref>
	struct _list_iterator
	{
	
		typedef ListNode<T> Node;
		typedef _list_iterator<T,Ref> self;
		Node* _it;
		// 构造函数
		_list_iterator(Node* node)
			:_it(node){}
		//前置++重载
		self& operator++()
		{
			_it = _it->_next;
			return *this;
		}

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

		//前置--重载
		self& operator--()
		{
			_it = _it->_prve;
			return *this;
		}

		//后置--重载
		self operator--(int)
		{
			self tmp(*this);
			_it = _it->_prve;
			return tmp;
		}
		// *重载
		Ref operator*()
		{
			return _it->_data;
		}
		// !=重载
		bool operator!=(const self& it)const
		{
			return _it != it._it;
		}
		// ==重载
		bool operator==(const self& it)const
		{
			return _it == it._it;
		}

	};

十、insert函数

insert函数是在指定位置插入一个节点,那么我们可以用迭代器来接收这个要插入的位置。

		//插入节点
		iterator insert(iterator pos, const T& val)
		{
			assert(pos._it);
			//保存pos的前一个位置
			Node* cru = pos._it;
			Node* prve = cru->_prve;
			//创建节点
			Node* newNode = new Node(val);
			//链接
			prve->_next = newNode;
			newNode->_prve = prve;
			newNode->_next = cru;
			cru->_prve = newNode;

			return pos;
		}

十一、erase函数

指定位置删除节点,删除节点会影响迭代器失效,所以要返回一个有效的迭代器。删除操作也十分简单,保存前一个节点的地址和后一个地址的节点,然后链接这2个节点,之后释放pos节点。

		iterator erase(iterator pos)
		{
			assert(pos._it);
			Node* cru = pos._it;
			Node* prve = cru->_prve;
			Node* next = cru->_next;
			//链接
			prve->_next = next;
			next->_prve = prve;
			//释放cru
			delete cru;
			return next;
		}
		

十二、pop_back函数

就是尾删,我们可以直接复用erase

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

当然,push_back也可以复用inset

十三、pop_front

就是头删,还是复用erase。头插也可以复用insert

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

十四、析构函数

链表的基本功能已经实现完了,但是当我们链表不用的时候,申请的空间必须销毁。而自带的析构函数不会销毁动态申请的空间,需要我们自己写析构函数销毁。

代码:

//析构函数
		~list()
		{
			//清空链表
			clear();
			//释放头节点
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			//除了头节点外,其他都释放。
			iterator it = begin();
			while (it != end())
			{
				//保存下一个位置的地址
				iterator next = it++;
				delete next._it;
			}
			//释放完之后,头节点指向的是个野指针,所以我们让它指向自己
			_head->_next = _head;
			_head->_prve = _head;
		}

十五、拷贝构造函数

那么我们想拷贝链表呢?我们可以直接用迭代器区间去创建一个新的对象,然后把新对象的头节点成员和旧对象进行交换。出了函数创建的对象会自动调用析构函数释放空间。

//拷贝构造
		list(const list<T>& l1)
		{
			//创建头节点
			_head = new Node();
			_head->_prve = _head;
			_head->_next = _head;
			//创建新对象,利用迭代器区间
			list<T> tmp(l1.begin(), l1.end());
			//随后交换新对象和旧对象的成员
			swap(_head, tmp._head);
		}

十六、赋值操作符重载

我们可以利用拷贝构造创建一个新对象,然后交换头节点。函数结束,创建的对象自动析构。

代码:

list<T>& operator=(const list<T>& l1)
		{
			list<T> tmp(l1);
			swap(_head, tmp._head);
			return *this;
		}

十七、迭代器优化

我们的迭代器还不够完美,因为如果list装的是自定义类型的话,我们还需要让迭代器支持 ->访问。期望它返回一个对象的指针回来,然后该对象的指针可以->直接访问成员。所以我们还需要增加模板参数。

增加一个指针参数
在这里插入图片描述
链表里的迭代器调整。
在这里插入图片描述
然后重载 迭代器的->操作符

		Ptr operator->()
		{
			//返回对象的指针
			return &(_it->_data);
		}

可以直接支持->访问
在这里插入图片描述

十七、反向迭代器

之前在vector实现的时候,我们实现过反向迭代器。vector实现链接。所以我们可以复用这个反向迭代器。

首先,包上反向迭代器的头文件名。
在这里插入图片描述
其次,我们typedef 2个反向迭代器
在这里插入图片描述

随后用rbegin函数和rend函数获取迭代器的开始和结束位置。
begin返回的是从头节点的下一个节点,所以rend就是返回头节点的下一个位置。
end返回的是头节点,所以rbegin返回头节点。

代码:

		//反向迭代器获取
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		const_reverse_iterator rbegin()const
		{
			return reverse_const_iterator(end());
		}

		const_reverse_iterator rend()const
		{
			return reverse_const_iterator(begin());
		}

全部代码:
list.h代码

#pragma once
#include "reverse_iterator.h"

namespace wyl
{
	//节点结构体
	template<class T>
	struct ListNode
	{
		typedef ListNode<T> Node;
		Node* _prve;
		Node* _next;
		T _data;

		//构造函数
		ListNode():_prve(nullptr),_next(nullptr),_data(0){}

		ListNode(const T& val)
			:_prve(nullptr)
			,_next(nullptr)
		{
			_data = val;
		}
	};

	//迭代器
	template<class T,class Ref,class Ptr>
	struct _list_iterator
	{
	
		typedef ListNode<T> Node;
		typedef _list_iterator<T,Ref,Ptr> self;
		Node* _it;
		// 构造函数
		_list_iterator(Node* node)
			:_it(node){}
		//前置++重载
		self& operator++()
		{
			_it = _it->_next;
			return *this;
		}

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

		//前置--重载
		self& operator--()
		{
			_it = _it->_prve;
			return *this;
		}

		//后置--重载
		self operator--(int)
		{
			self tmp(*this);
			_it = _it->_prve;
			return tmp;
		}
		// *重载
		Ref operator*()
		{
			return _it->_data;
		}
		// !=重载
		bool operator!=(const self& it)const
		{
			return _it != it._it;
		}
		// ==重载
		bool operator==(const self& it)const
		{
			return _it == it._it;
		}

		Ptr operator->()
		{
			//返回对象的指针
			return &(_it->_data);
		}

	};

	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;
		//反向迭代器
		typedef _reverse_iterator<iterator, T&, T*> reverse_iterator;
		typedef _reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;

		//构造函数
		list()
		{
			//开辟空间
			_head = new Node();
			//自己指向自己
			_head->_prve = _head;
			_head->_next = _head;
		}
		//迭代器区间初始化
		template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			//创建头节点
			_head = new Node();
			_head->_prve = _head;
			_head->_next = _head;

			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		//拷贝构造
		list(const list<T>& l1)
		{
			//创建头节点
			_head = new Node();
			_head->_prve = _head;
			_head->_next = _head;
			//创建新对象,利用迭代器区间
			list<T> tmp(l1.begin(), l1.end());
			//随后交换新对象和旧对象的成员
			swap(_head, tmp._head);
		}
		list<T>& operator=(const list<T>& l1)
		{
			list<T> tmp(l1);
			swap(_head, tmp._head);
			return *this;
		}

		//析构函数
		~list()
		{
			//清空链表
			clear();
			//释放头节点
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			//除了头节点外,其他都释放。
			iterator it = begin();
			while (it != end())
			{
				//保存下一个位置的地址
				iterator next = it++;
				delete next._it;
			}
			//释放完之后,头节点指向的是个野指针,所以我们让它指向自己
			_head->_next = _head;
			_head->_prve = _head;
		}

		void push_back(const T& val)
		{
			//创建一个新节点
			Node* newNode = new Node(val);
			//找到尾节点
			Node* tail = _head->_prve;
			//尾节点和创建的节点链接
			tail->_next = newNode;
			newNode->_prve = tail;
			_head->_prve = newNode;
			newNode->_next = _head;
		}

		void push_front(const T& val)
		{
			//创建一个新节点
			Node* newNode = new Node(val);
			//保存头节点的下一个节点
			Node* next = _head->_next;
			//链接
			_head->_next = newNode;
			newNode->_prve = _head;
			next->_prve = newNode;
			newNode->_next = next;
		}



		//迭代器获取
		iterator begin()
		{
			return iterator(_head->_next);
		}

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

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

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

		//反向迭代器获取
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		const_reverse_iterator rbegin()const
		{
			return const_reverse_iterator(end());
		}

		const_reverse_iterator rend()const
		{
			return const_reverse_iterator(begin());
		}


		//插入节点
		iterator insert(iterator pos, const T& val)
		{
			assert(pos._it);
			//保存pos的前一个位置
			Node* cru = pos._it;
			Node* prve = cru->_prve;
			//创建节点
			Node* newNode = new Node(val);
			//链接
			prve->_next = newNode;
			newNode->_prve = prve;
			newNode->_next = cru;
			cru->_prve = newNode;

			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos._it);
			Node* cru = pos._it;
			Node* prve = cru->_prve;
			Node* next = cru->_next;
			//链接
			prve->_next = next;
			next->_prve = prve;
			//释放cru
			delete cru;
			return next;
		}
		
		void pop_back()
		{
			erase(end());
		}

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

	private:
		Node* _head;
	};


	//--------------------------------------------------------------------------------------------
	//以下是测试内容

	void listTest1()
	{
		list<int> l;
		l.push_back(1);
		l.push_back(2);
		l.push_back(3);
		l.push_front(30);
		l.push_front(20);
		l.push_front(10);
	}

	void a(const list<int>& l)
	{
		list<int>::const_iterator it = l.begin();
		while (it != l.end())
		{
			//*it = 5;
			cout << *it << " ";
			it++;
		}
	}

	void listTest2()
	{
		list<int> l;
		l.push_back(1);
		l.push_back(2);
		l.push_back(3);
		list<int>::iterator it = l.begin();
		while (it != l.end())
		{
			*it = 55;
			cout << *it << " ";
			++it;
		}
		//a(l);
	}

	void listTest3()
	{
		list<int> l;
		l.push_back(1);
		l.push_back(2);
		l.push_back(4);
		l.push_back(5);
		l.insert(l.begin(),100);
		l.insert(l.end(), 10);

		list<int>::iterator it = l.begin();
		while (it != l.end())
		{
			if (*it % 2 == 0)
			{
				it = l.erase(it);
			}
			else
				++it;
		}
		it = l.begin();
		while (it != l.end())
		{
			cout << *it << " ";
			++it;
		}
	}

	void listTest4()
	{
		list<int> l;
		l.push_back(1);
		l.push_back(2);
		l.push_back(4);
		l.push_back(5);
		l.clear();
		l.push_back(1);
		l.push_back(2);
		l.push_back(4); 
		l.push_back(5);
		list<int> l2 = l;
		list<int>::iterator it = l2.begin();
		while (it != l2.end())
		{
			cout << *it << " ";
			++it;
		}
	}


	void listTest5()
	{
		list<Date> l;
		l.push_back(Date(2022, 1, 3));
		l.push_back(Date(2022, 1, 4));
		l.push_back(Date(2022, 1, 5));

		list<Date>::iterator it = l.begin();
		while (it != l.end())
		{
			cout << it->_year << "/"<<it->_month<<"/"<<it->_day<<endl;
			++it;
		}

	}

	void listTest6()
	{
		list<Date> l;
		l.push_back(Date(2022, 1, 3));
		l.push_back(Date(2022, 1, 4));
		l.push_back(Date(2022, 1, 5));

		list<Date>::reverse_iterator it = l.rbegin();
		while (it != l.rend())
		{
			cout << it->_year << "/" << it->_month << "/" << it->_day << endl;
			++it;
		}

	}

}

反向迭代器代码:
reverse_iterator.h

#pragma once

template<class iterator,class Ref,class Ptr>
class _reverse_iterator
{
	typedef _reverse_iterator<iterator, Ref, Ptr> self;
public:	
	_reverse_iterator(iterator it)
		:_it(it)
	{}
	//前置++
	self& operator++()
	{
		--_it;
		return *this;
	}
	//后置++
	self operator++(int)
	{
		self tmp(*this);
		--_it;
		return tmp;
	}

	//前置--
	self& operator--()
	{
		++_it;
		return *this;
	}
	//后置--
	self operator--(int)
	{
		self tmp(*this);
		++_it;
		return tmp;
	}

	Ref operator*()
	{
		iterator tmp = (*this)._it;
		return *(--tmp);
	}

	Ptr operator->()
	{
		return &operator*();
	}

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

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

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

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


private:
	iterator _it;
};

主程序代码:

#include"list.h"
void listTest()
{
	//wyl::listTest2();
	//wyl::listTest3();
	//wyl::listTest4();
	//wyl::listTest5();
	wyl::listTest6();

}

int main()
{
	listTest();

}

总结:

list的实现,其实最主要的部分还是迭代器。list的迭代器是比较特殊的,因为list在内存中不是连续存储的。以上代码都是我边打,边测试,没问题了才会发出来。如果有什么没测试到的错误,欢迎大家指出。以后会持续为大家更新STL的内容,以及数据结构,C语言,linux等方面的内容。感谢大家的支持,如果感觉写的还不错,麻烦给个三连嘛。我会多多努力的!


http://www.niftyadmin.cn/n/26124.html

相关文章

【NI Multisim 14.0 操作实例——音量控制电路】

目录 序言 一、音量控制电路 &#x1f34a;1.设置工作环境 &#x1f34a; 2.设置原理图图纸 &#x1f34a; 3.设置图纸的标题栏 &#x1f34a; 4.放置元器件 &#x1f34a; 5.编辑元器件属性 &#x1f34a; 6. 布局元器件 序言 NI Multisim最突出的特点之一就是用户界面…

C语言——指针面试题详解

&#x1f412;个人主页&#xff1a;平凡的小苏&#x1f4da;学习格言&#xff1a;别人可以拷贝我的模式&#xff0c;但不能拷贝我不断往前的激情目录 1. 指针和数组笔试题解析 一维数组 字符数组 二维数组 2. 指针笔试题 笔试题1&#xff1a; 笔试题2&#xff1a; 笔试题…

Esp8266+TFT太空人天气时钟

开源项目&#xff0c;只对动手能力有要求&#xff0c;有现成程序 b站演示视频: https://www.bilibili.com/video/BV1ND4y1W7oS/?spm_id_from333.999.0.0 效果图 模块和接线方法 使用ESP8266-12F模块&#xff0c;4M空间。OLED使用1.3寸IPS 240*240点阵彩屏&#xff0c;ST7789…

Linux常用命令——xz命令

在线Linux命令查询工具(http://www.lzltool.com/LinuxCommand) xz POSIX 平台开发具有高压缩率的工具。 补充说明 xz命令XZ Utils 是为 POSIX 平台开发具有高压缩率的工具。它使用 LZMA2 压缩算法&#xff0c;生成的压缩文件比 POSIX 平台传统使用的 gzip、bzip2 生成的压缩…

最新研究发现:天然海绵含有抑制Omicron变体感染的天然化合物

本文原文首发于2023年1月9日E-LIFESTYLE &#xff08;阅读时间4分钟&#xff09; 附标题&#xff1a;通过研究370多种来自植物、真菌和海绵等天然来源的化合物&#xff0c;寻找可用于治疗新冠肺炎的新抗病毒药物&#xff0c;用这些天然化合物制成的溶液中沐浴人类被SARS-CoV-2感…

内含JAVA简单概括和JAVA所需安装的软件和详细教程,想学习JAVA无从下手,这篇文章带你迈出第一步

本文大致概括了JAVA编程语言的简史和特点,主要介绍了JAVA开发环境安装,涉及JDK,Sublime Text IntelliJ IDEA三个软件的简单介绍,安装和使用,最后编写了第一个JAVA代码,保姆级教学,跟着文章一步步来,迈出你学习JAVA的第一步吧! 初识JAVA一.JAVA语言简介二.JAVA发展简史三.JAVA语…

如何使用Element-UI?

文章目录Element-UI概述Element-UI快速入门Element 布局Layout 局部Container 布局容器Element-UI组件使用案例介绍准备基本页面完成表格展示拷贝修改完成搜索表单展示完成批量删除和新增按钮展示完成对话框展示完成分页条展示完整页面代码Element-UI概述 Element&#xff1a;…

C生万物 | 反汇编深挖【函数栈帧】的创建和销毁

&#x1f451;作者主页&#xff1a;Fire_Cloud_1 &#x1f3e0;学习社区&#xff1a;烈火神盾 &#x1f517;专栏链接&#xff1a;万物之源——C 一文彻底搞懂函数栈帧创建和销毁的过程一、 什么是函数栈帧二、 理解函数栈帧能解决什么问题呢&#xff1f;三、 函数栈帧的创建和…