【C++: list的模拟实现】

news2025/1/16 0:51:45

目录

1 list的简单回顾

2 类中成员变量的声明

3 __list_iterator 中运算符重载

4 list中的迭代器

5 list中增删查改以及clear

6 const迭代器

6.1 __list_iterator的重新实现

6.2 list类的巧妙修改

7 构造函数&&拷贝构造&&赋值运算符重载

8 反向迭代器

1 list的简单回顾

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

 通过上面的信息我们不难得出list是一个带头双向循环链表，是不能够用库中的sort（库中sort要求必须是随机迭代器）,要排序的话只有用自己里的sort（这里实现用的是归并排序，但我们一般不会在链表中排序）至于list的其他接口大家可以去官方库中查阅，这里就不在多讲了。接下来就进入重点list的模拟实现（博主的模拟实现是参照stlSGI版本3.0）

2 类中成员变量的声明

首先我们肯定要定义一个类来完成结点的构建：

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

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

接下来大家想想我们就能够把结点直接定义到list类中吗？

这样貌似不行呀，大家想想：我们使用list的迭代器时是这样使用的：

 list<int> ls;
 ls.push_back(1);
 ls.push_back(2);
 ls.push_back(3);
 ls.push_back(4);
 auto it=ls.begin();
 while(it!=ls.end())
  {
    cout<<*it<<" ";
    ++it;
  }

如果我们直接将原生指针封装在list中而不做其他的事，那么实现++运算符重载时应该怎么办？

string和vector能够直接用原生指针的原因是他们的物理空间地址是连续的，++能够直接访问到下一位的地址，但是双向链表的物理空间地址并不是连续的，所以直接++肯定是非法访问的.

而这里的it是迭代器类型的，我们不可能直接在list中重载++,所以这里又得再重新将结点指针封装到另一个类里，我们不妨把这个类叫做__list_iterator，在__list_iterator这个类中重载++运算符，这样it就变成了__list_iterator类型的，再进行++操作时就能够正确跳转到下一位地址，这就是类型的力量。在list类中返回一个迭代器返回的就是__list_iterator类型的。

template<class T>
struct __list_iterator
{
	typedef ListNode<T> Node;
	typedef __list_iterator<T> iterator;

	Node* _node;
	__list_iterator( Node* n)
		:_node(n)
	{}
}

list类中：

template<class T>
class list
{
public:
	typedef ListNode<T> Node;
	typedef __list_iterator<T> iterator;
		
	list()
	{
		_head = new Node();
		_head->_next = _head;
		_head->_prev = _head;
	}
private:
       Node* _head;//头结点
}

3 __list_iterator 中运算符重载

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

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

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

		//--it
		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

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

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

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

有了上面的理解这里实现起来就容易多了。

4 list中的迭代器

        iterator begin()
		{
			return iterator(_head->_next);
		}

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

5 list中增删查改以及clear

        void clear()
		{
			/*iterator it = begin();
			while (it != end())
			{
				iterator del = it++;
				delete del._node;
			}

			_head->_next = _head;
			_head->_prev = _head;*/

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

		}

        void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newNode = new Node(x);
			tail->_next = newNode;
			newNode->_prev = tail;
			_head->_prev = newNode;
			newNode->_next = _head;

			//insert(_head, x);
		}

		void pop_back()
		{
			assert(_head->_prev!=_head);
			Node* tail = _head->_prev;
			Node* prev = tail->_prev;
			prev->_next = _head;
			_head->_prev = prev;
			delete tail;

			//erase(_head->_prev);
		}

		void push_front(const T& x)
		{
			insert(_head->_next, x);
		}

		void pop_front()
		{
			erase(_head->_next);
		}

		//在pos前插入数据，返回新节点的迭代器，pos并不会失效
		iterator insert(iterator pos, const T& val)
		{
			Node* cur = pos._node;
			Node* prev = pos._node->_prev;
			Node* newNode = new Node(val);
			prev->_next = newNode;
			newNode->_prev = prev;
			newNode->_next = cur;
			cur->_prev = newNode;

			return iterator(newNode);
		}

		//删除pos位置，返回删除后的下一位迭代器，pos肯定失效了
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;
			delete pos._node;
			prev->_next = next;
			next->_prev = prev;

			return iterator(next);
		}

这些都是我们之前双向带头循环链表玩过的，很简单，这里就不在多说了。

6 const迭代器

普通方法是我们自己再重新造一个const_iterator类，基本内容不变，只不过重载*时返回的是const T&,返回迭代器返回的是const_iterator。但是这样是不是代码写的有点儿挫了，两份几乎相同的代码重复出现，于是我们的C++大佬便想出了一个好办法，使用多个模板参数处理。（大佬就是大佬）

6.1 __list_iterator的重新实现

    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* n)
			:_node(n)
		{}

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

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

		//++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;
		}

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

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

	};

大家或许又有了疑问了？这里的Ptr又是什么鬼呢？

其实这里的Ptr专门是为了给->运算符重载准备的，因为使用->运算符也得区分是否是const迭代器。

6.2 list类的巧妙修改

里面的增删查改不需要变动，需要增加一个const迭代器：

    template<class T>
	class list
	{
	public:
		typedef ListNode<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()
		{
			return iterator(_head->_next);
		}

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

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

		const_iterator end()const
		{
			return const_iterator(_head);
		}
    private:
        Node* _head;
    }

这样我们调用const对象时就能够去调用const 迭代器。

7 构造函数&&拷贝构造&&赋值运算符重载

构造函数：

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

 拷贝构造传统写法：

        //list2(list1) 深拷贝：传统写法
		list(size_t n, const T& val=T())
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;

			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

拷贝构造现代写法与vector的实现类似，都是需要构造函数来帮助实现，所以我们还得再写一个构造函数：

        template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;

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

拷贝构造现代写法：

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

			list<T> tmp(ls.begin(), ls.end());
			std::swap(_head, tmp._head);
		}

赋值运算符重载传统写法：


		//list2=list1 传统写法
		list<T> operator=(const list<T>& ls)
		{
			if (&ls != this)
			{
				clear();
				for (auto& e : ls)
				{
					push_back(e);
				}
			}
			return *this;
		}

赋值运算符重载现代写法：

        //现代写法
		list<T> operator=(list<T> ls)
		{
			std::swap(_head, ls._head);
			return *this;
		}

但是大家发现了没有，当这样使用list2(2,2) 会优先选择list(InputIterator first, InputIterator last)，并不会选择list(size_t n, const T& val=T())。这样不就搞错了吗？处理方法是再重载一个拷贝构造：

        list(int n, const T& val = T())
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;

			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

这样当有现成的就不会再去调用模板了。

8 反向迭代器

有了上面的铺垫实现反向迭代器大家或许就会直接再生成一个__reverse_list_iterator就好了，但是同样的，这样写代码太冗余了，C++大佬就想出了另外一个巧妙的方法：再封装一层，封装一层反向迭代器类，类的成员变量为刚才我们实现的正向迭代器。这样封装又没有什么好处呢？答案是有的，这样处理不仅list可以用，像我们之前实现的string和vector也都可以用。（这就是那些C++大佬NB之处）

定义一个reverse_iterator类：

namespace grm
{
	// Iterator是哪个容器的迭代器，reverse_iterator<Iterator>就可以
	// 适配出哪个容器的反向迭代器。复用的体现
	template <class Iterator, class Ref, class Ptr>
	class reverse_iterator
	{
		typedef reverse_iterator<Iterator, Ref, Ptr> self;
		
	public:
		reverse_iterator(Iterator it)
			:_it(it)
		{}

		Ref operator*()
		{
			//return *_it;
			Iterator prev = _it;
			return *--prev;
		}

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

		self& operator++()
		{
			--_it;
			return *this;
		}

		self& operator--()
		{
			++_it;
			return *this;
		}

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

	private:
		Iterator _it;
	};
}

在list类中多typedef 一下:

        typedef reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;//这个要放在前面
		typedef reverse_iterator<iterator, T&, T*> reverse_iterator;

再增加一些成员函数：

        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());
		}

不知道大家注意到了没有C++大佬在设计反向迭代器时遵循了一种对称美，正向迭代器的begin()等于反向迭代器的rend(),正向迭代器的end()等于反向迭代器的rbegin(),正是由于这样设计所以在反向迭代器运算符*的重载设计是这样的：

        Ref operator*()
		{
			//return *_it;
			Iterator prev = _it;
			return *--prev;
		}

我们取得的数据是它的前一位数据。

但是如果只用一个模板参数又应该怎么处理呢？

在__list_iterator中又要typedef 一下：

        typedef Ref refence;//不用3个模板参数时将实例化后的参数类型能够通过Iterator类域取得
		typedef Ptr pointer;//但是像vector&&string的迭代器为原生指针的就不行，因为无法在原生指针中定义内嵌类型

reverse_iterator中：

namespace grm
{
	// Iterator是哪个容器的迭代器，reverse_iterator<Iterator>就可以
	// 适配出哪个容器的反向迭代器。复用的体现
	
	template <class Iterator>//不用3个模板参数

	class reverse_iterator
	{
		typedef reverse_iterator<Iterator> self;


		typedef typename Iterator::refence Ref;//可以typedef后直接用Ref和Ptr
		typedef typename Iterator::pointer Ptr;

		
	public:
		reverse_iterator(Iterator it)
			:_it(it)
		{}


		typename Iterator::refence operator*()//也可以不用typedef
		{
		    Iterator prev = _it;
			return *--prev;
		}

		typename Iterator::pointer operator->()
		{
			return &operator*();
		}

		self& operator++()
		{
			--_it;
			return *this;
		}

		self& operator--()
		{
			++_it;
			return *this;
		}

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

	private:
		Iterator _it;
	};
}

由于在模板里还没有实例化出对象出来，所以要用typename声明一下，等到对象实例化出来后再去找，不这样声明的话就编译不过。

需要源码的老铁可以在博主的码云中获得：https://gitee.com/monday-sky/text_cpp/commit/ea3b9b2a66531794d92ba71c730414f6f25f0814https://gitee.com/monday-sky/text_cpp/commit/ea3b9b2a66531794d92ba71c730414f6f25f0814

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

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

相关文章

金三银四丨黑蛋老师带你剖析-二进制漏洞

金三银四丨黑蛋老师带你剖析-二进制漏洞

作者&#xff1a;黑蛋二进制漏洞岗上篇文章我们初步了解了一下简历投递方式以及二进制方向相关逆向岗位的要求&#xff0c;今天我们就来看看二进制漏洞相关的岗位&#xff0c;当然&#xff0c;漏洞岗位除了分不同平台&#xff0c;也有漏洞挖掘岗和漏洞分析利用岗。同样&#xf…
阅读更多...
[人工智能-综述-11]：ChatGPT, 通用人工智能还是要来了

[人工智能-综述-11]：ChatGPT, 通用人工智能还是要来了

该来的还是要来的&#xff01;补充信息&#xff1a;ChatGPT是由人工智能研究实验室OpenAI在2022年11月30日发布的全新聊天机器人模型&#xff0c;一款人工智能技术驱动的自然语言处理工具。它能够通过学习和理解人类的语言来进行对话&#xff0c;还能根据聊天的上下文进行互动&…
阅读更多...
C语言共用体（C语言union用法）详解

C语言共用体（C语言union用法）详解

我们知道结构体&#xff08;Struct&#xff09;是一种构造类型或复杂类型&#xff0c;它可以包含多个类型不同的成员。在C语言中&#xff0c;还有另外一种和结构体非常类似的语法&#xff0c;叫做共用体&#xff08;Union&#xff09;&#xff0c;它的定义格式为&#xff1a;un…
阅读更多...
STM32的HAL库分析及使用

STM32的HAL库分析及使用

STM32的HAL库分析及使用 STM32的三种开发方式 通常新手在入门STM32的时候&#xff0c;首先都要先选择一种要用的开发方式&#xff0c;不同的开发方式会导致你编程的架构是完全不一样的。一般大多数都会选用标准库和HAL库&#xff0c;而极少部分人会通过直接配置寄存器进行开发…
阅读更多...
【Mysql第八期 子查询】

【Mysql第八期 子查询】

文章目录前言1. 需求分析与问题解决1.2 子查询的基本使用1.3 子查询的分类2. 单行子查询2.1 单行比较操作符2.2 代码示例2.5 子查询中的空值问题3. 多行子查询3.1 多行比较操作符3.2 代码示例3.3 空值问题4. 相关子查询4.2 代码示例4.3 EXISTS 与 NOT EXISTS关键字4.4 相关更新…
阅读更多...
开发者社区「运营官」招募启动啦！

开发者社区「运营官」招募启动啦！

国内首个聚焦AI3D视觉技术的开发者社区「运营官」招募启动啦&#xff01; 想积累实习经验&#xff0c;却苦于找不到大厂机会&#xff1f; 想进入AI3D视觉行业&#xff0c;却苦于没有知音伯乐&#xff1f; 想积累更多工作经历&#xff0c;却苦于路程奔波、天各一方&#xff1f…
阅读更多...
我们的微服务中为什么需要网关？

我们的微服务中为什么需要网关？

说起 Spring Cloud Gateway 的使用场景&#xff0c;我相信很多小伙伴都能够脱口而出认证二字&#xff0c;确实&#xff0c;在网关中完成认证操作&#xff0c;确实是 Gateway 的重要使用场景之一&#xff0c;然而并不是唯一的使用场景。在微服务中使用网关的好处可太多了&#x…
阅读更多...
MODBUS TCP 转 PROFINET 网关从站快速配置手册

MODBUS TCP 转 PROFINET 网关从站快速配置手册

一、本案例是1500PLC通过微硬创新MODBUS TCP 转 PROFINET 网关连接组态王服务器从站快速配置&#xff0c;将 Modbus TCP 设备数据转接入到西门子 PROFINET 网络中 二、设备列表如下&#xff1a; 三、MODBUS TCP 转 PROFINET 网关从站快速配置方法步骤&#xff1a; 第1步&#x…
阅读更多...
全网最详细的介绍ChatGPT：包括ChatGPT原理、应用、如何试用以及回答ChatGPT能否让程序员失业

全网最详细的介绍ChatGPT：包括ChatGPT原理、应用、如何试用以及回答ChatGPT能否让程序员失业

文章目录1. 介绍ChatGPT2. ChatGPT示例3. 试用ChatGPT4. ChatGPT原理5. ChatGPT应用5.1 世界杯问题咨询5.2 写书信&#xff08;情书&#xff09;6. 总结1. 介绍ChatGPT 今天开车去上班的路上&#xff0c;听到电台介绍ChatGPT&#xff0c;此时百度的股价涨幅为25%&#xff0c;当…
阅读更多...
谈谈Spring中Bean的生命周期？（让你瞬间通透~）

谈谈Spring中Bean的生命周期？（让你瞬间通透~）

目录 1.Bean的生命周期 1.1、概括 1.2、图解 2、代码示例 2.1、初始化代码 2.2、初始化的前置方法和后置方法&#xff08;重写&#xff09; 2.3、Spring启动类 2.4、执行结果 2.5、经典面试问题 3.总结 1.Bean的生命周期 1.1、概括 Spring中Bean的生命周期就是Bean在…
阅读更多...
Spring Cloud Alibaba+saas企业架构技术选型+架构全景业务图 + 架构典型部署方案

Spring Cloud Alibaba+saas企业架构技术选型+架构全景业务图 + 架构典型部署方案

基于Spring Cloud Alibaba 分布式微服务高并发数据平台化(中台)思想多租户saas设计的企业开发架构&#xff0c;支持源码二次开发、支持其他业务系统集成、集中式应用权限管理、支持拓展其他任意子项目。 一、架构技术选型 核心框架 Spring Boot SOA Spring Cloud …
阅读更多...
如何搞垮一个测试团队【反向教学，最为致命】

如何搞垮一个测试团队【反向教学，最为致命】

如何搞垮一个测试团队【反向教学&#xff0c;最为致命】 目录&#xff1a;导读 一、QA 二、项目经理 三、产品经理 四、开发人员 五、测试人员 六、组织文化 七、组织战略 要想彻底搞垮一个测试团队并非易事&#xff0c;需要多角色通力配合、多方联动、综合施策&#x…
阅读更多...
FFmpeg5.0源码阅读——内存池AVBufferPool

FFmpeg5.0源码阅读——内存池AVBufferPool

摘要&#xff1a;FFmpeg中大多数数据存储比如AVFrame,AVPacket都是通过AVBufferRef管理的&#xff0c;而承载数据的结构为AVBuffer。本文主要通过FFmpeg源码来分析下FFmpeg中AVBuffer相关的实现。 关键字&#xff1a;AVBuffer、AVBufferPool、AVBufferPool 1. AVBufferRef 1.…
阅读更多...
谁说菜鸟不会数据分析，不用Python,不用代码也轻松搞定

谁说菜鸟不会数据分析，不用Python,不用代码也轻松搞定

作为一个菜鸟&#xff0c;你可能觉得数据分析就是做表格的&#xff0c;或者觉得搞个报表很简单。实际上&#xff0c;当前有规模的公司任何一个岗位如果没有数据分析的思维和能力&#xff0c;都会被淘汰&#xff0c;数据驱动分析是解决日常问题的重点方式。很多时候&#xff0c;…
阅读更多...
RS232串口之RTS与CTS作用

RS232串口之RTS与CTS作用

RTS与CTS的定义 RTS和CTS用于流控&#xff0c;提供了流控信号&#xff0c;但实际的流控功能还是要在软件实现&#xff0c;就是说即使硬件上RTS和CTS做了连线&#xff0c;但软件没有使用这两个信号&#xff0c;则通信就如无流控状态。 RTS &#xff08;Require ToSend&#xf…
阅读更多...
力扣64.最小路径和

力扣64.最小路径和

文章目录力扣64.最小路径和题目描述方法1&#xff1a;动态规划力扣64.最小路径和 题目描述 给定一个包含非负整数的 m x n 网格 grid &#xff0c;请找出一条从左上角到右下角的路径&#xff0c;使得路径上的数字总和为最小。 说明&#xff1a;每次只能向下或者向右移动一步…
阅读更多...
爱了爱了，这些顶级的 Python 工具包太棒了

爱了爱了，这些顶级的 Python 工具包太棒了

Python 语言向来以丰富的第三方库而闻名&#xff0c;今天来介绍几个非常nice的库&#xff0c;有趣好玩且强大&#xff01;推荐好好学习。 文章目录技术交流数据采集AKShareTuShareGoPUPGeneralNewsExtractor爬虫playwright-pythonawesome-python-login-modelDecryptLoginScylla…
阅读更多...
「题解」关于sizeof陷阱,无符号整形,变种水仙花数

「题解」关于sizeof陷阱,无符号整形,变种水仙花数

&#x1f680;&#x1f680;&#x1f680;大家觉不错的话&#xff0c;就恳求大家点点关注&#xff0c;点点小爱心&#xff0c;指点指点&#x1f680;&#x1f680;&#x1f680; sizeof陷阱以及无符号整形 让我们看一下这段代码&#xff1a;​​​​​​​ int main(){ int x …
阅读更多...
C语言操作符详解(下)

C语言操作符详解(下)

提示&#xff1a;本篇内容是C语言操作符详解下篇 文章目录前言八、条件表达式九、逗号表达式十、 下标引用、函数调用和结构成员1. [ ] 下标引用操作符2. ( ) 函数调用操作符3.结构成员访问操作符十一、表达式求值1. 隐式类型转换举例说明1举例说明2举例说明32.算数转换3.操作…
阅读更多...
三子棋——【保姆级C语言小游戏】

三子棋——【保姆级C语言小游戏】

前言&#xff1a;今天七七为大家带来的是C语言中比较简单的小游戏“三子棋” 下面跟着七七一起来学习吧&#xff01; 文章目录游戏整体思路游戏的实现流程游戏的实现菜单的打印创建与初始化棋盘玩家下棋电脑下棋判断输赢代码的整体运行游戏整体思路 我们需要三个文件&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023