[STL]详解list模拟实现

news2024/9/29 23:22:46

[STL]list模拟实现

文章目录

  • [STL]list模拟实现
    • 1. 整体结构总览
    • 2. 成员变量解析
    • 3. 默认成员函数
      • 构造函数1
      • 迭代器区间构造函数
      • 拷贝构造函数
      • 赋值运算符重载
      • 析构函数
    • 4. 迭代器及相关函数
      • 迭代器整体结构总览
      • 迭代器的模拟实现
      • begin函数和end函数
      • begin函数和end函数const版本
    • 5. 数据修改函数
      • push_back函数
      • insert函数
      • push_front函数
      • erase函数
      • pop_back函数
      • pop_front函数
      • clear函数
    • 6. 完整代码链接

1. 整体结构总览

template<class T>
	struct list_node //结点结构 --ListNode为类名，加上模板参数后为类型
	{
		list_node* _prev;
		list_node* _next;
		T _data;

		list_node(const T& val = T()) //结点的构造函数
		{
			_data = val;
			_prev = nullptr;
			_next = nullptr;
		}
	};

template<class T, class Ref, class Ptr> //迭代器类实现
	struct __list_iterator
	{
		typedef list_node<T> node; //对结点重命名
		typedef __list_iterator<T, Ref, Ptr> self; //对迭代器重命名
		//...
		node* _node;
	};


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

	public:
		void empty_init();

		list(); //默认构造函数
		template<class Iteartor>
		list(Iteartor begin, Iteartor end);
		void swap(list<T>& tmp);
		list(const list<T>& l);
		list<T>& operator=(list<T> l);
		~list();

		iterator begin();
		iterator end();

		const_iterator begin()const;
		const_iterator end()const;

		void push_back(const T& x);
		void insert(iterator pos, const T x);
		void push_front(const T& x);
		iterator erase(iterator pos);
		void pop_back();
		void pop_front();
		void clear();
	private:
		node* _head;
	};

2. 成员变量解析

成员变量相关代码结构如下：

template<class T>
struct list_node //结点结构 --ListNode为类名，加上模板参数后为类型
{
	list_node* _prev; //指向上一个结点的指针
	list_node* _next; //指向下一个结点的指针
	T _val;	//结点存储的数据
	// ...
};
template<class T>
class list
{
	typedef list_node<T> node;
	// ...
private:
	node* _head; //指向哨兵位的头结点
};

image-20230723183036391

由于list是由双向循环链表实现的，因此只需要一个指向哨兵位的头结点的指针_head作成员变量，通过_head和指向上一个结点和下一个结点的指针能够很快的找到头结点和尾结点。

3. 默认成员函数

构造函数1

无参的默认构造函数，由于实现的双向循环链表，因此需要在创建链表时创建哨兵位的头结点，由于创建哨兵位的过程在后续实现中还需使用，因此将其封装成一个单独的empty_init函数。

void empty_init() //便于后续复用
{
	_head = new node;
	_head->_prev = _head;
	_head->_next = _head;
}

list() //-const list也可以调用此构造函数，因为在初始化后才加的const属性
{
	empty_init();
}

迭代器区间构造函数

迭代器区间构造就是将传入的容器按其迭代器范围内的数据作为要构造的容器的数据进行构造，只需要将传入迭代器内的数据尾插即可。

template<class Iteartor>
list(Iteartor begin, Iteartor end)
{
	empty_init();
	while (begin != end)
	{
		push_back(*begin);
		++begin;
	}
}

拷贝构造函数

拷贝构造函数的实现分为传统写法和现代写法。

传统写法是将要拷贝的list的数据依次进行尾插：

list(const list<T>& l)
{
	//传统写法
	empty_init();
	const_iterator it = l.begin();
	while (it != l.end())
	{
		push_back(*it);
		it++;
	}
}

现代写法是创建一个临时的list进行数据拷贝，然后将临时的list内的结点交换过来:

void swap(list<T>& tmp)
{
	std::swap(_head, tmp._head);
}

list(const list<T>& l)
{
	//现代写法
	empty_init();  // -- 不申请结点会因为tmp变量析构野指针而报错
	list<T> tmp(l.begin().l.end());
	swap(tmp);
}

赋值运算符重载

赋值运算符重载的实现利用参数会拷贝构造的特性，然后交换参数的数据。

list<T>& operator=(list<T> l)
{
	swap(l);
	return *this;
}

析构函数

析构函数的实现可以复用能够将除了哨兵位结点外的所有结点删除的clear函数，然后删除哨兵位结点。（clear函数的实现在文末。）

qxm::list<T>::~list()
{
	clear();
	delete _head;
	_head = nullptr;
}

4. 迭代器及相关函数

迭代器整体结构总览

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* n){};//构造函数
        __list_iterator(const __list_iterator<T, T&, T*>& it){}; //普通迭代器构造const迭代器
		__list_iterator(const __list_iterator<T, const T&, const T*>& it){};//cosnt迭代器构造普通迭代器
		self& operator++(){};//前置++
		self operator++(int){};//后置++
		self& operator--(){};//前置--
		self operator--(int){};//后置--
		Ref operator*() {};//*运算符重载
        Ptr operator->() {};//->运算符重载
		bool operator!=(const self& s){};//!=运算符重载
		bool operator==(const self& s){};//==运算符重载
	};

迭代器的模拟实现

由于迭代器需要的功能很多，因此需要给迭代器单独封装一个类，成员变量是结点指针。迭代器成员变量有关的代码如下：

template<class T>
    struct __list_iterator
    {
        typedef list_node<T> node; //对结点重命名
        // ...
        node* _node; //指向结点的指针
    };

迭代器构造函数

迭代器只有一个指向结点的指针变量，迭代器构造函数只要将其初始化即可。

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

迭代器构造函数

为了实现普通迭代器和const迭代器的转换需要实现如下构造函数：

__list_iterator(const __list_iterator<T, T&, T*>& it) //普通迭代器构造const迭代器
    :_node(it._node)
    {}

__list_iterator(const __list_iterator<T, const T&, const T*>& it)//cosnt迭代器构造普通迭代器
    :_node(it._node)
    {}

迭代器前置++运算符重载

迭代器实现++操作只需要将指针指向下一个结点即可。

template<class T>    
self& operator++()//前置++
{
	_node = _node->_next;
	return _node;
}

迭代器后置++运算符重载

实现后置++和前置++相比只需要将++前的迭代器保存并且返回即可。

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

迭代器前置–运算符重载

迭代器实现–操作只需要将指针指向上一个结点即可。

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

迭代器后置–运算符重载

实现后置–和前置–相比只需要将–前的迭代器保存并且返回即可。

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

迭代器*运算符重载

迭代器进行*操作是要获取迭代器指向的数据，因此只需要将结点指向的数据返回即可。

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

迭代器->运算符重载

迭代器进行->操作是因为list存储的是自定义数据类型，->运算符的重载只需要返回数据的地址即可。

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

为了理解->运算符重载的实现，我们看下面的例子：

struct AA
{
	AA(int a1 = 1, int a2 = 2)
		:_a1(a1),
		_a2(a2)
	{}
	int _a1;
	int _a2;
};

void test_list2()
{
	qxm::list<AA> l; //qxm作用域是模拟实现时设置的命名空间
	l.push_back(AA(1, 1));
	l.push_back(AA(2, 2));
	l.push_back(AA(3, 3));

	for (qxm::list<AA>::iterator it = l.begin(); it != l.end(); it++)
	{
		cout << it->_a1 << ":" << it->_a2 << endl;
	}
}

在这个场景中如果调用迭代器的->会返回AA类型的指针,it->_a1相当于是&AA_a1将数据地址和变量写到一块，应该是访问不到数据的错误代码，但是编译器会自动做优化，此时一个->运算符当两个->使用，也就是说本来需要(it.operator->())->_a1访问数据的，但是编译器把其中一个->优化掉了，因此现在只要it->_a1就可以访问成功了。

迭代器!=运算符重载

迭代器的!=是指向的数据不同，因此只需要判断迭代器内的指针是否相同。

bool operator!=(const self& it)
{
    return this->_node != it->_node;
}

迭代器!=运算符重载

迭代器的==是指向的数据相同，因此只需要判断迭代器内的指针是否相同。

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

const迭代器实现

const迭代器和普通迭代器的实现只有在*运算符重载和->运算符的重载的返回值上有所不同。

const迭代器的*运算符重载函数返回的是const的数据，这样const迭代器就不能修改数据了。

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

const迭代器的->运算符重载函数返回的是const的指针，这样const迭代器就不能修改数据了。

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

迭代器模拟实现整体代码：

template<class T, class Ref, class Ptr> // -- Ref/Ptr控制是普通迭代器还是const迭代器
    struct __list_iterator
    {
        typedef list_node<T> node; //对结点重命名
        typedef __list_iterator<T, Ref, Ptr> self; //对迭代器重命名

        node* _node;

        __list_iterator(node* n)
            :_node(n)
            {}
        
        __list_iterator(const __list_iterator<T, T&, T*>& it)
			:_node(it._node)
		{}

		__list_iterator(const __list_iterator<T, const T&, const T*>& it)
			:_node(it._node)
		{}

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

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

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

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

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

注意： 模板参数Ref控制的是*运算符重载的返回值类型，模板参数Ptr控制的是->运算符重载的返回值类型，进而控制了迭代器是普通迭代器还是const迭代器。

begin函数和end函数

注： 文中此位置往下是迭代器相关函数实现，实现在list类内。

begin函数：

begin函数只需要返回拥有有效数据的头结点即可。

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

end函数：

end函数只需要返回哨兵位就可,因为哨兵位没有有效数据。

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

begin函数和end函数const版本

const版本begin函数：

begin函数只需要返回拥有有效数据的头结点即可。

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

const版本end函数：

end函数只需要返回哨兵位就可,因为哨兵位没有有效数据。

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

5. 数据修改函数

push_back函数

push_back函数为尾插函数，尾插示意图如下：

image-20230723165738795

实现尾插函数时创建一个临时变量tail，记录插入数据前的尾结点，方便进行指针指向的改动，避免因为指针指向改动而找不到正确的结点。

void push_back(const T& val)
{
	node* tail = _head->_prev; //记录插入数据前的尾部结点
	node* newnode = new node(x);

	tail->_next = newnode;//指针改变的顺序不影响结果
	newnode->_prev = tail;
	newnode->_next = _head;
	_head->_prev = newnode;
}

insert函数

insert函数的功能是通过迭代器，在迭代器指向的结点前插入结点，insert函数的实现只需要将传入的迭代器的前一个结点和迭代器指向的结点记录，然后将要插入的新节点进行链接。

insert函数插入结点示意图：

image-20230727131020076

void insert(iterator pos, const T x)
{
	node* cur = pos._node;
	node* prev = cur->_prev;
	node* newnode = new node(x);

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

说明： insert函数不会使迭代器失效，因为迭代器指向的结点不会随着插入而改变。

有了insert函数后，push_back函数可以改写为复用insert函数的版本：

void push_back(const T& x)
{
	insert(end(), x);
}

end函数返回的是有_head封装的迭代器，指向哨兵位，哨兵位的前一个结点就是尾结点，因此复用insert函数和end函数能实现尾插。

push_front函数

push_front函数的功能是头插结点，有了insert函数实现头插只需要在insert函数中传入头结点就可以实现。

void push_front(const T& x)
{
	insert(begin(), x);
}

erase函数

erase函数的功能是删除指定结点,并返回在删除之前删除结点的下一个结点，只需要将要删除的前一个结点和后一个结点记录，进行链接即可，但要注意不能删除哨兵位结点。

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

	node* prev = pos._node->_prev;
	node* next = pos._node->_next;

	prev->_next = next;
	next->_prev = prev;
	delete pos._node;

	return iterator(next);
}

pop_back函数

pop_back函数的功能是尾删，只需要复用erase函数和end函数即可，end函数返回的是哨兵位的迭代器，–得到的是尾结点的迭代器。

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

pop_front函数

pop_front函数的功能是尾删，只需要复用erase函数和begin函数即可，begin函数返回的头结点的迭代器。

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

clear函数

clear函数的功能是将除了哨兵位结点外的所有结点都删除，只需要复用erase函数循环删除结点。（erase函数的实现需上翻本文）

void clear()
{
	iterator it = begin();
	while (it != end)
	{
		it = erase(it); //--erase后需要重新对迭代器赋值，不然迭代器会失效。
		//erase(it++);  --后置++会返回++前的值，因此迭代器不会失效
	}
}

6. 完整代码链接

STL/List/List/List.h · 钱雪明/日常代码 - 码云 - 开源中国 (gitee.com)

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

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

相关文章

Spring源码（四）— 创建BeanDefinition

Spring源码（四）— 创建BeanDefinition

在第一章序言的图示中有提到&#xff0c;Spring中的配置文件都是通过各种的BeanDefinition来进行解析&#xff0c;并且支持不同类型的文件进行扩展。所以在创建完DefaultListableBeanFactory后&#xff0c;会通过BeanDefinition来解析传入的xml配置文件。 loadBeanDefinitions…
阅读更多...
如何建立ftp server？快解析内网穿透实现外网直接访问

如何建立ftp server？快解析内网穿透实现外网直接访问

serveru是一款由Rob Beckers开发的获奖的ftp服务器软件&#xff0c;全称为&#xff1a;serv-u ftp server&#xff0c;它功能强大又易于使用。ftp服务器用户通过它用ftp协议能在internet上共享文件。serv-u不仅100%遵从通用ftp标准&#xff0c;也包括众多的独特功能可为每个用户…
阅读更多...
常用直线模组的类型

常用直线模组的类型

目前&#xff0c;直线模组的应用非常广泛&#xff0c;而且直线模组的种类也有很多可以满足每个行业的应用要求&#xff0c;那么常见的直线模组类型有哪些&#xff0c;大家知道吗&#xff1f; 1、全封闭滚珠丝杆直线模组&#xff1a; 在半封闭式的基础上增加了不锈钢带防尘结构…
阅读更多...
自监督去噪: self2self 原理及实现（Pytorch）

自监督去噪: self2self 原理及实现（Pytorch）

Self2Self With Dropout: Learning Self-Supervised Denoising From Single Image 文章地址&#xff1a;https://ieeexplore.ieee.org/document/9157420原始代码&#xff1a;https://github.com/scut-mingqinchen/self2self本文参考代码: https://github.com/JinYize/self2self…
阅读更多...
无线系统传输距离（天线收发功率计算）

无线系统传输距离（天线收发功率计算）

无线通信系统如图8.1. 发射机发射功率，发射机天线增益； 接收机发射功率，接收机天线增益； 收发之间的距离是R； 如果没有大气损耗，极化失配，阻抗不匹配等情况，且天线在远场区域工作，那么各向同性发射天线在接收天线处的功率密度为 (8.1) 对于定向性天线，该公式修正…
阅读更多...
No105.精选前端面试题，享受每天的挑战和学习

No105.精选前端面试题，享受每天的挑战和学习

文章目录 手写new手写Mapget和post区别发起post请求的时候&#xff0c;服务端是怎么解析你的body的&#xff08;content-type&#xff09;&#xff0c;常见的content-type都有哪些&#xff0c;发文件是怎么解析的&#xff08;FormData&#xff09;&#xff0c;如果多个文件&…
阅读更多...
微信小程序｜进度条

微信小程序｜进度条

进度条是一个常见的用户界面元素，用于显示任务或操作的完成进度，可以在任何需要指示任务进度的情况下使用，以提供更好的用户体验和反馈。 一、前言1.1 进度条使用场景1.2 进度条属性介绍1.3 示例代码及效果二、自定义进度条2.1 进度条形状2.2 进度条尺寸2.3 进度条条纹2.4 进…
阅读更多...
【计算机网络】10、ethtool

【计算机网络】10、ethtool

文章目录 一、ethtool1.1 常见操作1.1.1 展示设备属性1.1.2 改变网卡属性1.1.2.1 Auto-negotiation1.1.2.2 Speed 1.1.3 展示网卡驱动设置1.1.4 只展示 Auto-negotiation, RX and TX1.1.5 展示统计1.1.7 排除网络故障1.1.8 通过网口的 LED 区分网卡1.1.9 持久化配置&#xff08…
阅读更多...
GitHub仓库如何使用

GitHub仓库如何使用

核心&#xff1a;GitHub仓库如何使用 目录 1.创建仓库&#xff1a; 2.克隆仓库到本地&#xff1a; 3.添加、提交和推送更改&#xff1a; 4.分支管理&#xff1a; 5.拉取请求&#xff08;Pull Requests&#xff09;&#xff1a; 6.合并代码&#xff1a; 7.其他功能&…
阅读更多...
windows 10/11 修改右键新建菜单

windows 10/11 修改右键新建菜单

问题&#xff1a;修改右键新建菜单内容 解决方法&#xff1a;使用软件ShellNew Settings 1.打开软件 2.根据需要取消勾选项 3.最终效果
阅读更多...
Linux 系列 常见 快捷键总结

Linux 系列 常见 快捷键总结

强制停止 Ctrl C 退出程序、退出登录 Ctrl D 等价 exit 查看历史命令 history !命令前缀&#xff0c;自动匹配上一个命令 &#xff08;历史命令中&#xff1a;从最新——》最老 搜索&#xff09; ctrl r 输入内去历史命令中检索 # 回车键可以直接执行 ctrl a 跳到命令开头 …
阅读更多...
zoho邮箱全收邮件catchall的设置

zoho邮箱全收邮件catchall的设置

登录 Zoho Mail 管理控制台。(https://mailadmin.zoho.com/cpanel/home.do#)转到域菜单&#xff0c;然后选择要为其配置“全收邮箱”地址的域。转到设置选项卡&#xff0c;然后找到全收邮箱地址部分。从下拉列表中选择您要配置为“全收邮箱”的电子邮件地址&#xff0c;然后单击…
阅读更多...
vmware踩坑

vmware踩坑

连不上网, 调试几个地方 这里禁用, 启用一下 这个网络设置 虚拟机设置里还有一个 虚拟机设置里还有一个
阅读更多...
Rust中对可变引用的迭代遇到的生命周期冲突问题解决

Rust中对可变引用的迭代遇到的生命周期冲突问题解决

Rust中自定义一个迭代器来迭代集合的可变引用&#xff08;mut reference&#xff09;的时候&#xff0c;经常会碰到报错&#xff1a; error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements今天我们就…
阅读更多...
苍穹外卖-day09

苍穹外卖-day09

苍穹外卖-day09 本项目学自黑马程序员的《苍穹外卖》项目&#xff0c;是瑞吉外卖的Plus版本 功能更多&#xff0c;更加丰富。 结合资料&#xff0c;和自己对学习过程中的一些看法和问题解决情况上传课件笔记 视频&#xff1a;https://www.bilibili.com/video/BV1TP411v7v6/?sp…
阅读更多...
NumPy 基础用法详解

NumPy 基础用法详解

概要 NumPy&#xff08;Numerical Python&#xff09;是一个开源的Python库&#xff0c;用于进行科学计算和数据分析。它提供了一个多维数组&#xff08;ndarray&#xff09;对象&#xff0c;用于存储和处理大规模的数据集&#xff0c;以及各种用于操作这些数组的函数。NumPy是…
阅读更多...
PHP使用Redis实战实录2：Redis扩展方法和PHP连接Redis的多种方案

PHP使用Redis实战实录2：Redis扩展方法和PHP连接Redis的多种方案

PHP使用Redis实战实录系列 PHP使用Redis实战实录1&#xff1a;宝塔环境搭建、6379端口配置、Redis服务启动失败解决方案PHP使用Redis实战实录2&#xff1a;Redis扩展方法和PHP连接Redis的多种方案 Redis扩展方法和PHP连接Redis的多种方案 一、Redis扩展方法二、php操作Redis语…
阅读更多...
llama2.c - 垂直领域LLM训练/推理全栈利器

llama2.c - 垂直领域LLM训练/推理全栈利器

llama2.c是一个极简的Llama 2 LLM全栈工具&#xff0c;非常适合用于制作面向细分市场垂直领域的大规模语言模型。 推荐&#xff1a;用 NSDT设计器 快速搭建可编程3D场景。 1、简介 使用此存储库中的代码&#xff0c;你可以在 PyTorch 中从头开始训练 Llama 2 LLM 架构&#xf…
阅读更多...
Linux文件系统中目录介绍

Linux文件系统中目录介绍

linux的文件系统&#xff1a; 根文件系统&#xff08;rootfs&#xff09;:fhs:文件系统目录标准 Filesystem Hierarchy Standard /boot:引导文件的存放目录&#xff1a;内核文件、引导加载文件都存放在此目录 /bin&#xff1a;共所有用户使用的基本命令&#xff0c;不能管理至…
阅读更多...
葡萄酒质量预测 -- 机器学习项目基础篇（1）

葡萄酒质量预测 -- 机器学习项目基础篇（1）

在这里&#xff0c;我们将根据给定的特征预测葡萄酒的质量。我们使用互联网上免费提供的葡萄酒质量数据集。该数据集具有影响葡萄酒质量的基本特征。通过使用几种机器学习模型&#xff0c;我们将预测葡萄酒的质量。 导入库和数据集 Pandas是一个有用的数据处理库。用于处理数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023