[STL]list模拟实现

已于 2022-07-24 16:18:22 修改
阅读量299 收藏
点赞数
分类专栏： C++ 文章标签： c++ list 链表
于 2022-07-24 15:38:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51304981/article/details/125914838
版权

目录

一、list源码学习

核心框架：

template <class T>
struct __list_node {
  typedef void* void_pointer; // 结点指针
  void_pointer next;
  void_pointer prev;
  T data;
};

template <class T, class Alloc = alloc>
class list {
protected:
  typedef void* void_pointer;
  typedef __list_node<T> list_node; 
  typedef list_node* link_type; 
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

public:
  typedef __list_iterator<T, T&, T*> iterator;
  typedef __list_iterator<T, const T&, const T*> const_iterator;
  
protected:
  link_type node;
};

二、list模拟实现基本框架

namespace zmm
{
	template <class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;

		ListNode(const T& data = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(data)
		{}
	};
	template <class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		list()
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head; // 因为是双向循环链表
		}
		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newNode = new Node(x);
			tail->_next = newNode;
			newNode->_prev = tail;
			newNode->_next = _head;
			_head->_prev = newNode;
		}
	private:
		Node* _head;
	};

	void test_list1()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
	}
}

在list中，我们如何去实现迭代器？此时it++就不是指向下一个位置了，因为链表每个结点可能存在的物理地址都不一样，这样子++就不对了，但是C++中提供了运算符重载。

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

因此综上，最初的基础框架就完成了

namespace zmm
{
	template <class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;

		ListNode(const T& data = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(data)
		{}
	};

	template <class T>
	struct __list_iterator
	{
		typedef ListNode<T> Node;
		// typedef __list_iterator
		Node* _node; // 构造出了结点

		__list_iterator(Node* x) // 用结点的指针去构造迭代器
			:_node(x)
		{}

		T& operator*() // 可读可写
		{
			return _node->_data;
		}


		// 前置++，返回++之后的值
		__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;
		}
	};

	template <class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef __list_iterator<T> iterator;
		
		// begin end都是用结点的指针去构造的迭代器
		iterator begin()
		{
			// head->next就是第一个数据
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}
		list()
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head; // 因为是双向循环链表
		}
		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newNode = new Node(x);
			tail->_next = newNode;
			newNode->_prev = tail;
			newNode->_next = _head;
			_head->_prev = newNode;
		}
	private:
		Node* _head;
	};

	void test_list1()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);

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

list模拟实现需要去实现拷贝构造、赋值重载（深拷贝）以及析构函数吗？
——不需要，使用默认生成的即可
list<int>::iterator it = lt.begin();比如这句，就是浅拷贝，我们就是要让他们指向同一个位置，就是让节点的地址给it
析构也不需要去实现——迭代器是借助结点的指针去访问修改链表，结点属于链表，不属于迭代器，所以他不管释放，都不需要自己去实现

const迭代器

void print_list(const list<int>& lt) // 必须要加引用，否则就是浅拷贝
{
	// 这里是没办法遍历的，lt是const对象，需要使用const迭代器
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

const迭代器与普通迭代器的区别：普通迭代器访问普通对象可读可写，而const只能读，那我们该如何去实现？

可以这样做吗？——不行

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

因为我们是容器为const，*it是迭代器去调用的，但迭代器还是原先的iterator，而非是const_iterator
所以还需要在实现一个const迭代器

template <class T>
struct __list_iterator
{
	typedef ListNode<T> Node;
	// typedef __list_iterator
	Node* _node; // 构造出了结点

	__list_iterator(Node* x) // 用结点的指针去构造迭代器
		:_node(x)
	{}
	__list_iterator<T>& operator++(int)
	{
		__list_iterator<T> tmp(*this);
		_node = _node->_next;
		return tmp;
	}
	// ...
};
template <class T>
struct __const_list_iterator
{
	typedef ListNode<T> Node;
	// typedef __list_iterator
	Node* _node; // 构造出了结点

	__const_list_iterator(Node* x) // 用结点的指针去构造迭代器
		:_node(x)
	{}

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

这样做我们就实现了一个普通的iterator和const_iterator迭代器，但是这样就有代码冗余了，所以还应该进一步的修改
template <class T, class Ref>增加了一个模板参数ref
之后修改为这个

// T& operator*() 原先版本
ref operator*() 
{
	return _node->_data;
}

在对class list进行修改

class list
{
	typedef __list_iterator<T, T&> iterator;
	typedef __list_iterator<T, const T&> const_iterator;
};

又加入了一个模板参数后，这样子就可以防止代码冗余
在这里插入图片描述
在这里插入图片描述
但是这里就算是const，也可以去用->去修改对象，所以我们要在传入一个参数Ptr
因此最终的框架就形成了：

template <class T, class Ref, class Ptr>
struct __list_iterator
{
	typedef ListNode<T> Node;
	// 由于类模板添加了一些新的参数，为了方便些，再次typedef
	typedef __list_iterator<T, Ref, Ptr> self;

	// typedef __list_iterator
	Node* _node; // 构造出了结点

	__list_iterator(Node* x) // 用结点的指针去构造迭代器
		:_node(x)
	{}

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

template <class T>
class list
{
	typedef ListNode<T> Node;
public:
	typedef __list_iterator<T, T&, T*> iterator; // 普通迭代器返回T*
	typedef __list_iterator<T, const T&, const T*> const_iterator; // // const迭代器返回T*
private:
	Node* _head;
};

三、零散补充

3.1 vector与list区别

vector和list的区别

vector缺点：
连续的物理空间，是优势，也是一种劣势
优势：支持高效随机访问
劣势：
1、空间不够要增容， 增容代价比较大
2、可能存在一定的空间浪费，按需申请，会导致频繁的增容，所以一般会增容二倍左右（一般也不会造成每次都要增容）
3、头部或者中部插入删除需要挪动数据，效率低下（最致命的缺陷）
因此vector适合尾插尾删，随机访问

list很好地解决了vector的以上问题
1、list任意位置支持O（1）的插入删除（双向链表）
2、按需申请释放空间
因此list适合任意位置插入删除

本质上list和vector是两个互补的数据结构，在实际中，vector用的更多一些
STL中的所有容器都不保证线程安全
现在所提及的还只是链式结构，后面还有二叉树结构，哈希结构等

3.2 insert()

template <class T>
class list
{
	typedef ListNode<T> Node;
public:
	typedef __list_iterator<T, T&, T*> iterator; // 普通迭代器返回T*
	typedef __list_iterator<T, const T&, const T*> const_iterator; // // const迭代器返回T*
private:
	Node* _head;
};
// 这里insert后，pos会失效吗？——不会，插入数据后，pos位置没变
// pos位置前插入数据
iterator insert(iterator pos, const T& x) // 迭代器是一个对象，用.访问成员
{
	// 返回值指向新插入的元素
	Node* cur = pos._node; // 用迭代器拿到这个结点
	Node* prev = cur->_prev;
	Node* newNode = new Node(x);

	prev->_next = newNode;
	newNode->_prev = prev;
	newNode->_next = cur;
	cur->_prev = newNode;

	return iterator(newNode);
}
// vector失效原因有两点，一点是扩容会导致失效，第二点是插入了以后，pos指向的值就变了

因此insert是不会有迭代器失效的问题

3.3 erase()

// erase之后pos会失效吗——会失效，pos指向的节点就没了
iterator erase(iterator pos)
{
	assert(pos != end()); // 不能erase哨兵位
	Node* prev = pos._node->_prev;
	Node* next = pos._node->_next;
	delete pos._node;
	prev->_next = next;
	next->_prev = prev;

	return iterator(next);
}

修改版：

void clear()
{
	// 清除掉链表里面所有的数据(不删除哨兵位)
	iterator it = begin();
	while (it != end())
	{
		/*iterator del = it++; // 双向迭代器不支持it+1，随机迭代器才可以
		delete del._node;*/
		// 也可以去复用erase
		iterator del = it++;
		erase(del);
		// 也可以直接用erase(it++)去替换上面两行
	}
	_head->_next = _head;
	_head->_prev = _head;
}

3.4 深拷贝

传统写法

// lt2(lt1)
list(const list<T>& lt) // lt就是lt1
{
	_head = new Node;
	_head->_prev = _head;
	_head->_next = _head;
	// 传统写法:
	for (auto e : lt)
	{
		// push_back前提是要初始化后才可以使用
		push_back(e); // this的pushback
	}
}

// lt2 = lt1
list<T>& operator=(const list<T>& lt)
{
	if (this != &lt)
	{
		clear(); // 清除l2的所有数据也就是this
		for (auto e : lt) // 遍历lt1
		{
			push_back(e);
		}
	}
	return *this;
}

上面拷贝构造函数还是有问题，_head是随机值，与他交换后就会蹦，因此改为下面这种写法

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

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

在添加一个构造函数

// 这里最好给个缺省值，因为val可能是日期类，vector等等
list(size_t n, const T& val = T()) // 用n个val去初始化和一个迭代器区间初始化可能存在冲突
{
	_head = new Node();
	_head->_prev = _head;
	_head->_next = _head;

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

在这里插入图片描述
这里有两个构造函数，如果一个函数去调用他们，是去调用哪一个？——去调用类型最匹配的那一个

四、反向迭代器

反向迭代器的源码在stl_iterator.h文件中

template <class Iterator>
class reverse_iterator 
{
protected:
  Iterator current;
public:
  typedef typename iterator_traits<Iterator>::iterator_category
          iterator_category;
  typedef typename iterator_traits<Iterator>::value_type
          value_type;
  typedef typename iterator_traits<Iterator>::difference_type
          difference_type;
  typedef typename iterator_traits<Iterator>::pointer
          pointer;
  typedef typename iterator_traits<Iterator>::reference
          reference;

  typedef Iterator iterator_type;
  typedef reverse_iterator<Iterator> self;

public:
  reverse_iterator() {}
  explicit reverse_iterator(iterator_type x) : current(x) {}

  reverse_iterator(const self& x) : current(x.current) {}
#ifdef __STL_MEMBER_TEMPLATES
  template <class Iter>
  reverse_iterator(const reverse_iterator<Iter>& x) : current(x.current) {}
#endif /* __STL_MEMBER_TEMPLATES */
    
  iterator_type base() const { return current; }
  reference operator*() const {
    Iterator tmp = current;
    return *--tmp;
  }
  self& operator++() {
    --current;
    return *this;
  }
  self operator++(int) {
    self tmp = *this;
    --current;
    return tmp;
  }
  self& operator--() {
    ++current;
    return *this;
  }
  self operator--(int) {
    self tmp = *this;
    ++current;
    return tmp;
  }

可以发现，反向迭代器里面是包含了正向迭代器，反向迭代器的++就是调用正向迭代器的–，因此反向迭代器实际上就是整形迭代器的一种封装

  reference operator*() const {
    Iterator tmp = current;
    return *--tmp;
  }

解引用是取的正向迭代器的前一个位置，为什么会这样子？
查看stl_list.h源码可以发现:

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

在传统上，我们定义rend和rbegin是这样的：
在这里插入图片描述
但是在源码中，定义的却不是这样子，而是下面的情况
在这里插入图片描述
这样设计的意义就是：
正向迭代器的开始就是反向迭代器的结束
正向迭代器的结束就是反向迭代器的开始

reverse_iterator rit = rbegin();
while (rit != rend())
{
	*rit;
	++rit;
}

在这里插入图片描述
这样子rit到达rend的时候，就停止了
因此operator*取前一个位置，主要目的就是为了让反向迭代器的开始和结束与正向迭代器对称

反向迭代器与正向迭代器的区别就是++、--的方向是相反的，所以反向迭代器封装正向迭代器即可，控制重载++、--的方向

反向迭代器的完整实现：

#pragma once

namespace zmm
{
	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*()
		{
			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; // _it是一个正向迭代器，可以是任意容器的正向迭代器，是一个模板
	};
}

五、适配器

适配器也叫作配接器
Iterator是哪个容器的迭代器，reverse_iterator就可以是配出哪个容器的反向迭代器——复用的体现

凡是要取模板参数的内嵌类型都是需要添加typename的

typedef reverse_iterator<Iterator, Ref, Ptr> self;
// 上面三个模板参数太多了，因此我们是可以去使用内嵌类型的
typedef typename Iterator::Ref Ref // 告诉编译器Iterator::Ref是一个类型，等类模板实例化之后在取
typedef typename Iterator::Ptr Ptr

加typename的场景：

vector<int>::iterator it; // 此时类模板已经实例化了，是int类型，所以不需要加typename
list<int>::iterator it;

typename vector<T>::iterator it; // 等类模板实例化之后再去取iterator
typename list<T>::iterator it;
Protein_zmm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
list模拟实现
qq_68006585的博客
03-07 480
list模拟实现
【C++】list模拟实现
不 良的博客
07-08 709
list相当于带头节点的双向链表，我们定义节点时要用类模板参数，同时定义_next、_prev指针和数据_data，使用struct定义类，因为节点类要能够被访问，而struct的默认访问权限就是public；构造函数缺省值要使用匿名对象，保证无论是自定义类型还是内置类型都能够构造成功……
【C++】list的模拟实现
qq_62939852的博客
03-11 1285
C++中，Listnode作为类名，而next和prev都是类指针，指针引用成员时使用->，而对象引用成员时使用 .若在数组上有一个int类型的指针，解引用是int类型的数据，再++可以加载下一个位置，因为物理空间是连续的。erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。同样若在链表上，解引用类型为 node，再++不能到下一个节点，因为物理空间不连续。++pnode，找到下一个节点的地址，但是下一个节点不一定是要的节点。
list的模拟实现
m0_68641696的博客
06-10 2229
list是vector中重要的容器，了解它的原理对于我们掌握它是有很多的帮助的，一般list和vector都是一起来使用的，因为它们的优缺点不同，刚好可以互补。list的优点是任意位置的插入和删除都很快，它的缺点是不支持随机访问，而vector的优点是支持随机访问，进而就可以很好的支持排序算法，二分查找，堆算法等，它的缺点是扩容要付出一定的代价，而且除了尾上的插入和删除外其他位置的插入和删除都不快（因为要挪动数据）。下面让我们一起来实现一下list吧。
【C++】list的模拟实现【完整理解版】
最新发布
m0_74044018的博客
09-10 1042
list的模拟实现，主讲你不理解的地方，每个地方都会详细解释，重在理解
STL中list模拟实现源码
08-06
list模拟实现源码，适合初学者学习
c模拟c++ stl list
06-18
实现c++ list部分功能，内存自管理 函数的使用和c++ stl list类似，并不完全相同 简单测试过，并不保证完全无错，仅供参考
STL的List链表自行实现
11-04
C++中STL的List链表容器的自行实现，自行实现迭代器、类、封装函数等
STL -list实现02
04-24
STL list实现02，其他容器的实现，依次类推。看不懂的C基础太差，别想C++某些原理了
STL_C++stl实现_
10-01
C++ STL实现包含常用stl模板的手动实现仅供参考
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3113
简易版list模拟实现超详解
【C++】list类模拟实现
qq_66314292的博客
11-09 1870
list类的模拟实现
STL之list的模拟实现
Code_beeps的博客
06-11 287
实现的功能：迭代器、反向迭代器、以及list的各种接口 list.h namespace myList { ////List的结点类 template<class T> class ListNode { public: ListNode(const T& val = T()) :_data(val) , _next(nullptr) , _pre...
【STL详解】list的模拟实现
Holden_Caulfield的博客
03-29 1060
目录 list的模拟实现总览： 1.节点类的模拟实现 构造函数 2.迭代器类的模拟实现 迭代器类的模板参数说明 构造函数 ++运算符的重载 --运算符的重载 ==运算符的重载 !=运算符的重载 *运算符的重载 ->运算符的重载 list的模拟实现 默认成员函数 构造函数 拷贝构造函数（迭代器版本） 拷贝构造函数(现代写法) 赋值运算符重载函数（现代写法） 其他构造函数 析构函数 迭代器相关函数 访问容器相关函数 插入、删除函数 insert（...
模拟stl类的list
06-12
好的，我可以给您讲解一下如何模拟STL的list类。 List是一个双向链表，我们可以通过自己实现节点类和...这样，我们就实现了一个简单的模拟STL的list类。您可以通过调用insert、remove、find等方法来操作链表中的元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值