C++初阶编程：list容器的简单模拟实现

最新推荐文章于 2024-07-14 20:07:21 发布
最新推荐文章于 2024-07-14 20:07:21 发布
阅读量891 收藏 16
点赞数 19
分类专栏： c++知识点 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/htw250056/article/details/140064873
版权

大家好啊，今天给大家带来的是我们C++编程中，stl库里的重要角色--list的简单的模拟实现，希望通过这篇小博客，对大家更加深入理解list容器有所帮助。

前言：

在C++标准库中，list是一种双向链表容器。

这里简单提一下双向链表——什么是双向链表呢？

双向链表是一种链式数据结构，其中每个节点包含三个部分：

  • 一个存储数据的字段。（我们通常用_data表示）
  • 一个指向前驱节点的指针。（我们通常用_prev表示）
  • 一个指向后继节点的指针。（我们通常用_next表示）

 这样，每个节点都知道它的前一个节点和后一个节点，从而支持在常数时间内进行插入和删除操作。

一：节点结构的定义

在实现list之前，我们要先定义一下这个链表的节点结构。一个链表是有多个节点链接组成，所以节点自然是重中之重。

我们在头文件定义一下节点结构，上文讲到，一个节点包括_data、_prev、_next三个部分：

template <class T>
struct ListNode
{
	ListNode(const T& data = T())//给的缺省值是我们想要存储的数据类型的一个匿名对象（自定义类型需要构造函数）
		:_data(data)
		, _next(nullptr)
		, _prev(nullptr)
	{

	}

	T _data;
	ListNode<T>* _next;//指向下一个节点
	ListNode<T>* _prev;//指向上一个节点
};

当然，也要记得写这个模板类的默认构造，我们用想存储的数据的一个匿名对象来完成对_data的初始化。 

二、list类的默认构造，成员变量

我们用_count来记录链表的节点数目，_head记录双向带头链表的头节点。

为了简写代码，方便我们操作，我们顺便把ListNode<T>重命名为Node。

随后书写list的默认构造函数，就是赋予头节点空间，将头节点的_prev与_next指向自己，还有把_count初始化为0。

template<class T>
class list
{
	typedef ListNode<T> Node;
public:
	list()
	{
		_head = new Node();
		_head->_next = _head;
		_head->_prev = _head;
		_count = 0;
	}
private:
	Node* _head;
	size_t _count;
};

三、list：用类实现迭代器的思想

在实现我们list的各种接口之前，我们首先要来实现一下list容器的迭代器。

这属于是list内容的重中之重，不同于vector，我们返回一个指针作为迭代器，指针的++就可以让迭代器向后移动到另一个元素。我们的list是由许多个节点链接而成，又怎么可以使用各种++操作符呢？

在这个基础上，我们想到了，可以是先用一个类，在这个类中重载各种++，--运算符，手动实现迭代器的向后移动（向前移动）。

那我们又如何实现const的迭代器呢？难不成学vector在前面加个const就可以了吗？

显而易见，由于底层结构的不同，const迭代器的实现原理也有所不同。

其实很简单，要想实现const迭代器的作用，我们只需要在迭代器类的各种内置函数的返回参数的类型做手脚就行。函数返回类型变成了const，自然就是const迭代器的作用。这样的代价就是我们要写两个迭代器模板。

但为了减少我们的麻烦，我们可以在写迭代器的时候在tmplete后面多加几个类型参数就行，这样就把我们的麻烦当做礼物送给了编译器（编译器：听我说，谢谢你）。

template<class T,class Ref,class Ptr>
struct ListIterator
{
	typedef ListNode<T> Node;//节点类型
	typedef ListIterator<T, Ref, Ptr> Self;//代表自己这个类型

	Node _node;
	ListIterator(Node node = nullptr)//缺省为nullptr的默认构造函数
		:_node(node)
	{

	}
	ListIterator(const Self& l)//传一个迭代器类型（在实现后置++，后置--可以用得到)
		:_node(l._node)
	{

	}

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

	Ptr operator->()
	{
		return &_node->_data;//Ptr是指针类型，模拟实现->时应该返回的是地址，即返回一个指向当前值的指针
	}

	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& l)
	{
		return _node != l._node;
	}

	bool operator==(const Self& l)
	{
		return _node == l._node;
	}
};

四、反向迭代器的实现

与我们刚刚实现正向迭代器一样的思想，反向迭代器也需要用模板类的思想来解决。

在实现反向迭代器的时候，我们核心仍然通过正向迭代器去运转，只不过在反向迭代器类中再次重载了各种操作符。例如，反向迭代器的前置++，我们只需要在实现的时候，在函数内调用正向迭代器的前置--就行。 

template<class Iterator, class Ref, class Ptr>
struct Reverse_iterator
{
	typedef typedef Reverse_iterator Self;
	Iterator _it;

	Reverse_iterator(Iterator it)
		:_it(it)
	{

	}

	Ref operator*()//因为反向迭代器的首位置是由正向迭代器的end（）初始化的，在最后一个元素的下一个位置，
		// 解引用时要先创建一个临时变量，使其向前移动一步，才是正确的返回位置（避免改变反向迭代器位置）
	{
		Iterator tmp = _it;
		return *(--tmp);
	}

	Ptr operator->()
	{
		Iterator tmp = _it;
		--tmp;
		return &(*tmp);
	}

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

	bool operator!=(const Self& l)
	{
		return _it != l._it;
	}

	bool operator==(const Self& l)
	{
		return _it == l._it;
	}

};

五、list迭代接口的实现

终于把list的迭代器给实现了，紧接着，我们就应该在list类里实现迭代器的各种接口。

先来重命名迭代器：

typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<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;

大家请看上面四行代码，我们通过传递的不同类型的参数类型，实例化出四种不同的迭代器，我们想使用const迭代器时就在重命名const_iterator时传递const T&，const T*就行。

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

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

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

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

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

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

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

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

六、list插入函数以及删除函数的实现

list的插入主要是push_back,insert，push_front三个函数，删除操作主要是pop_back(),erase，pop_front三个函数。

//不涉及释放空间，不存在迭代器失效
// 在pos位置前插入值为val的节点

iterator insert(iterator pos, const T& val)
{

	Node* cur = pos._node;
	Node* newnode = new Node(val);
	Node* prev = cur->_prev;

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

	_count++;

	return iterator(newnode);//返回由Node类型的newnode初始化完成的匿名对象
}

// 删除pos位置的节点，返回该节点的下一个位置
iterator erase(iterator pos)//存在迭代器失效
{
	assert(pos != end());//防止把头节点给删了
	Node* node = pos._node;
	Node* pnext = node->_next;
	Node* prev = node->_prev;

	prev->_next = pnext;
	pnext->_prev = prev;

	delete node;
	_count--;

	return iterator(pnext);
}

随后，我们就可以让push_back()和push_front调用insert函数实现复用，让pop_back()和pop_front调用erase实现复用，减少我们所需要写的代码：

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

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

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

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

七、list各种默认函数的实现

我们需要实现各种其他构造函数，方便list类的各种构造，例如(int n, const T& value = T())//传n个元素，每个元素默认为T()，又或者是根据迭代器区间默认构造。
 我们不难想到，由于要实现这么多的构造函数，这么多的构造函数，如果在构造前都要现在函数里初始化一遍，破坏了封装性，所以我们可以把初始化这个功能写成一个新的函数，随后，在各种构造函数里调用就行：

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

list()//更改默认构造函数
{
	empty_init();
}

  各种构造函数实现：

list(int n, const T& value = T())
{
	empty_init();
	for (int i = 0; i < n; ++i)
	{
		push_back(value);
	}
}

template <class Iterator>//适应各个迭代器的构造
list(Iterator first, Iterator last)
{
	empty_init();

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

list(const list<T>& l)//拷贝构造
{
	empty_init();
	for (const auto& it : l)
	{
		push_back(it);
	}
}

list<T>& operator=(const list<T> l)//赋值重载
{
	swap(l);

	return *this;
}

~list()
{
	clear();

	delete _head;
	_head = nullptr;
}

当然，在赋值重载中，我们仍然选择了现代写法，于是我们就要实现一个swap接口，在析构函数中，我们也选择用一个clear来删除除了头结点之外的所有节点，所以我们也需要实现一个clear：

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

void clear(list<T>& l)
{
	auto it = begin();

	while (it != end())
	{
		it = erase(it);//小心迭代器失效
	}
}

八、其他接口的实现：

我们想要看这个链表多长，就需要调用我们的size接口，想知道最后或者第一个元素的值，也需要调用back()，front()等接口。

以下是该接口的实现：

	T& front()
	{
		assert(_count > 0);
		return _head->_next->_data;
	}

	const T& front()const
	{
		assert(_count > 0);
		return _head->_next->_data;
	}

	T& back()
	{
		assert(_count > 0);
		return _head->_prev->_data;
	}

	const T& back()const
	{
		assert(_count > 0);
		return _head->_prev->_data;
	}

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

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

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

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

九、总代码

​
#pragma once
#include<assert.h>

namespace bit
{

	template <class T>
	struct ListNode
	{
		ListNode(const T& data = T())//给的缺省值是我们想要存储的数据类型的一个匿名对象（自定义类型需要构造函数）
			:_data(data)
			, _next(nullptr)
			, _prev(nullptr)
		{

		}

		T _data;
		ListNode<T>* _next;//指向下一个节点
		ListNode<T>* _prev;//指向上一个节点
	};

	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T>* Node;//节点类型
		typedef ListIterator<T, Ref, Ptr> Self;//代表自己这个类型

		Node _node;
		ListIterator(Node node = nullptr)//缺省为nullptr的默认构造函数
			:_node(node)
		{

		}
		ListIterator(const Self& l)//传一个迭代器类型（在实现后置++，后置--可以用得到)
			:_node(l._node)
		{

		}

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

		Ptr operator->()
		{
			return &_node->_data;//Ptr是指针类型，模拟实现->时应该返回的是地址，即返回一个指向当前值的指针
		}

		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& l)
		{
			return _node != l._node;
		}

		bool operator==(const Self& l)
		{
			return _node == l._node;
		}
	};


	template<class Iterator, class Ref, class Ptr>
	struct Reverse_iterator
	{
		typedef Reverse_iterator Self;
		Iterator _it;

		Reverse_iterator(Iterator it)
			:_it(it)
		{

		}

		Ref operator*()//因为反向迭代器的首位置是由正向迭代器的end（）初始化的，在最后一个元素的下一个位置，
			// 解引用时要先创建一个临时变量，使其向前移动一步，才是正确的返回位置（避免改变反向迭代器位置）
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

		Ptr operator->()
		{
			Iterator tmp = _it;
			--tmp;
			return &(*tmp);
		}

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

		bool operator!=(const Self& l)
		{
			return _it != l._it;
		}

		bool operator==(const Self& l)
		{
			return _it == l._it;
		}
	};

template<class T>
class list
{
	typedef ListNode<T> Node;
public:
	typedef ListIterator<T, T&, T*> iterator;
	typedef ListIterator<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;

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

	list()
	{
		empty_init();
	}

	list(int n, const T& value = T())
	{
		empty_init();
		for (int i = 0; i < n; ++i)
		{
			push_back(value);
		}
	}

	template <class Iterator>//适应各个迭代器的构造
	list(Iterator first, Iterator last)
	{
		empty_init();

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

	list(const list<T>& l)//拷贝构造
	{
		empty_init();
		for (const auto& it : l)
		{
			push_back(it);
		}
	}

	list<T>& operator=(const list<T> l)//赋值重载
	{
		swap(l);

		return *this;
	}

	~list()
	{
		clear();

		delete _head;
		_head = nullptr;
	}

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

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

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

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

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

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

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

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

	size_t size()const
	{
		return _count;
	}

	bool empty()const
	{
		return _count == 0;
	}

	T& front()
	{
		assert(_count > 0);
		return _head->_next->_data;
	}

	const T& front()const
	{
		assert(_count > 0);
		return _head->_next->_data;
	}

	T& back()
	{
		assert(_count > 0);
		return _head->_prev->_data;
	}

	const T& back()const
	{
		assert(_count > 0);
		return _head->_prev->_data;
	}

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

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

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

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

	//不涉及释放空间，不存在迭代器失效
	// 在pos位置前插入值为val的节点

	iterator insert(iterator pos, const T& val)
	{

		Node* cur = pos._node;
		Node* newnode = new Node(val);
		Node* prev = cur->_prev;

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

		_count++;

		return iterator(newnode);//返回由Node类型的newnode初始化完成的匿名对象
	}

	// 删除pos位置的节点，返回该节点的下一个位置
	iterator erase(iterator pos)//存在迭代器失效
	{
		assert(pos != end());//防止把头节点给删了
		Node* node = pos._node;
		Node* pnext = node->_next;
		Node* prev = node->_prev;

		prev->_next = pnext;
		pnext->_prev = prev;

		delete node;
		_count--;

		return iterator(pnext);
	}

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

	void clear()
	{
		auto it = begin();

		while (it != end())
		{
			it = erase(it);
		}
	}

	private:
		Node* _head;
		size_t _count;
	};
}#pragma once
#include<assert.h>

namespace bit
{

	template <class T>
	struct ListNode
	{
		ListNode(const T& data = T())//给的缺省值是我们想要存储的数据类型的一个匿名对象（自定义类型需要构造函数）
			:_data(data)
			, _next(nullptr)
			, _prev(nullptr)
		{

		}

		T _data;
		ListNode<T>* _next;//指向下一个节点
		ListNode<T>* _prev;//指向上一个节点
	};

	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T>* Node;//节点类型
		typedef ListIterator<T, Ref, Ptr> Self;//代表自己这个类型

		Node _node;
		ListIterator(Node node = nullptr)//缺省为nullptr的默认构造函数
			:_node(node)
		{

		}
		ListIterator(const Self& l)//传一个迭代器类型（在实现后置++，后置--可以用得到)
			:_node(l._node)
		{

		}

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

		Ptr operator->()
		{
			return &_node->_data;//Ptr是指针类型，模拟实现->时应该返回的是地址，即返回一个指向当前值的指针
		}

		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& l)
		{
			return _node != l._node;
		}

		bool operator==(const Self& l)
		{
			return _node == l._node;
		}
	};


	template<class Iterator, class Ref, class Ptr>
	struct Reverse_iterator
	{
		typedef Reverse_iterator Self;
		Iterator _it;

		Reverse_iterator(Iterator it)
			:_it(it)
		{

		}

		Ref operator*()//因为反向迭代器的首位置是由正向迭代器的end（）初始化的，在最后一个元素的下一个位置，
			// 解引用时要先创建一个临时变量，使其向前移动一步，才是正确的返回位置（避免改变反向迭代器位置）
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

		Ptr operator->()
		{
			Iterator tmp = _it;
			--tmp;
			return &(*tmp);
		}

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

		bool operator!=(const Self& l)
		{
			return _it != l._it;
		}

		bool operator==(const Self& l)
		{
			return _it == l._it;
		}
	};

template<class T>
class list
{
	typedef ListNode<T> Node;
public:
	typedef ListIterator<T, T&, T*> iterator;
	typedef ListIterator<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;

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

	list()
	{
		empty_init();
	}

	list(int n, const T& value = T())
	{
		empty_init();
		for (int i = 0; i < n; ++i)
		{
			push_back(value);
		}
	}

	template <class Iterator>//适应各个迭代器的构造
	list(Iterator first, Iterator last)
	{
		empty_init();

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

	list(const list<T>& l)//拷贝构造
	{
		empty_init();
		for (const auto& it : l)
		{
			push_back(it);
		}
	}

	list<T>& operator=(const list<T> l)//赋值重载
	{
		swap(l);

		return *this;
	}

	~list()
	{
		clear();

		delete _head;
		_head = nullptr;
	}

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

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

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

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

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

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

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

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

	size_t size()const
	{
		return _count;
	}

	bool empty()const
	{
		return _count == 0;
	}

	T& front()
	{
		assert(_count > 0);
		return _head->_next->_data;
	}

	const T& front()const
	{
		assert(_count > 0);
		return _head->_next->_data;
	}

	T& back()
	{
		assert(_count > 0);
		return _head->_prev->_data;
	}

	const T& back()const
	{
		assert(_count > 0);
		return _head->_prev->_data;
	}

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

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

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

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

	//不涉及释放空间，不存在迭代器失效
	// 在pos位置前插入值为val的节点

	iterator insert(iterator pos, const T& val)
	{

		Node* cur = pos._node;
		Node* newnode = new Node(val);
		Node* prev = cur->_prev;

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

		_count++;

		return iterator(newnode);//返回由Node类型的newnode初始化完成的匿名对象
	}

	// 删除pos位置的节点，返回该节点的下一个位置
	iterator erase(iterator pos)//存在迭代器失效
	{
		assert(pos != end());//防止把头节点给删了
		Node* node = pos._node;
		Node* pnext = node->_next;
		Node* prev = node->_prev;

		prev->_next = pnext;
		pnext->_prev = prev;

		delete node;
		_count--;

		return iterator(pnext);
	}

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

	void clear()
	{
		auto it = begin();

		while (it != end())
		{
			it = erase(it);
		}
	}

	private:
		Node* _head;
		size_t _count;
	};
}

​

十、总结：

本文实现了一个简化版的双向链表模板类 list，主要包括以下内容：

  1. ListNode 结构体：

    • 表示链表的节点，包含数据 _data 和指向前一个节点 _prev、后一个节点 _next 的指针。

  2. ListIterator 结构体：

    • 实现了链表的迭代器，支持前向和后向遍历，以及解引用操作符 * 和箭头操作符 ->。

  3. list 类：

    • 使用 ListNode 实现了双向链表的基本操作，包括插入、删除、遍历等功能。
    • 提供了正向迭代器 iterator 和反向迭代器 reverse_iterator。

  4. 功能实现：

    • 支持构造函数、拷贝构造函数和赋值运算符重载。
    • 实现了 begin()、end()、rbegin()、rend() 等方法，用于迭代器的初始化和操作。
    • 提供了 push_back()、pop_back()、push_front()、pop_front() 等方法，支持双向链表的节点插入和删除。
    • 包含 size()、empty()、front() 和 back() 等方法，用于获取链表大小和访问首尾元素。

通过这些实现，希望大家可以更加深入理解了双向链表的底层实现原理，并且掌握如何使用迭代器来操作链表元素等方法。

渡我白衣
关注
  • 19
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++高效编程：内存与性能优化(pdf版）
09-11
C++高效编程：内存与性能优化(pdf版），深入C++经典好书！
C++教程从入门到实战
热门推荐
believer
08-09 14万+
C++基础教程 一、数据类型 1.1、第一个C++程序 1.2、数据类型 1.3、常量及符号 1、整型常量：整型常量可以分为有符号整型常量和无符号整型常量 八进制：以0开头，即以0作为八进制数的前缀，每位取值范围是0~7，八进制数通常是无符号数。 例如：016、0101、0128都是合法的八进制数 十六进制：以0x或者0X开头，其数码取值范围0 ~ 9，以及A ~ F或者a ~ f 例如：0X2A1、0XC5、0XFFFF都是合法的16进制数 2、实型常量 小数表示法：由整
C++（c++基础入门，看这一篇就够了）
Xiaoming9106的博客
08-19 4万+
c plus plus 简称c++
C++知识要点总结笔记
最新发布
realbread的博客
07-14 1590
总结c++语法、内存等知识。仅供个人学习记录用。
C++入门（保姆级教程）
m0_62692838的博客
05-02 9149
c++入门看这一篇就够了
【C++入门】C和C++混合编程超详细讲解
weixin_42031299的博客
09-04 1万+
用C语言写功能库代码时，需要对外提供的函数接口头文件用extern “C”{}括起来，将来库无论被C语言调用还是被C++调用都支持；
C++ 教程（最新、最全、3.5万字总结），强烈建议收藏！！！
qq_44859843的博客
06-16 2万+
我们详细讲解了C++的语法和语义，包括变量和数据类型、运算符、控制流语句、函数和函数重载、结构体和类等。每个知识点都附带了具体的示例代码和解释，以帮助读者更好地理解。 我们还介绍了C++标准模板库（STL），包括各种容器（如向量、列表、集合、映射等）和常用算法（如排序、查找、变换等）。对于每个容器和算法，我们提供了详细的讲解和示例代码，帮助读者熟悉和应用STL。 最后，我们总结了整个教程的内容，强调了C++作为一门强大而灵活的编程语言的优点，并鼓励读者继续深入学习和探索C++的更多高级特性和应用领域。
每天学点C++（C++实例教程：教程+源码）list容器.zip
06-21
在实际编程中，结合理论知识和实践代码，你能够更好地掌握C++的`std::list`容器，并学会根据需求选择合适的容器类型。不断地练习和编写代码，是提升编程技能的关键。 总之，"每天学点C++"的这个实例教程对于初学者...
C++高效编程：内存与性能优化(PDG)
07-12
5. **STL（Standard Template Library）容器**：如`std::vector`, `std::list`, `std::map`等，它们内部处理了内存管理，但不同的容器有不同的性能特征，选择合适的容器能显著提升效率。 6. **迭代器与范围for循环*...
C++泛型编程：源起、实现与意义 免积分
02-28
1. **单根继承的限制**：C++中不强制实行单根继承，这意味着不能简单地通过所有对象继承自一个基类的方式来实现泛型容器。 2. **类型安全性和效率**：基于单根继承的泛型解决方案可能会牺牲类型安全性和执行效率，这...
C++编程实例100篇
08-28
C++标准库提供了大量预定义的类和函数，如容器（如vector、list、map）、算法（如排序、查找）和异常处理。熟悉这些库可以帮助编写更高效、可靠的代码。 模板是C++的一个高级特性，允许创建泛型代码，即可以在多种...
C++ 简介
生活需要深度
01-09 7677
C++是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。C++目前被认为是一种中级语言，它综合了低级语言和高级语言的特点。C++ 是由 Bjarne Stroustrup 于 1979 年在新泽西州美利山贝尔实验室开始设计开发的。C++从C语言扩充发展而来，依次经历了new C -> C with class -> C++，在1983年更名为C++。因此，任何合法的C语言程序都是合法的C++程序。 当然这里也给一下其他各个语言的出现时期
C++(老百科)
cyyyyds857的博客
12-20 1819
C++是一种计算机高级程序设计语言，由C语言扩展升级而产生 ，最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。––––以上源自于百度百科总的来说C++和C,C#,Python,Java……一样,都是一种编程语言.1.C++是一种静态类型的,编译式的,通用的,大小写敏感的,不规则的编程语言运行阶段不再处理有关类型的问题，性能高速度快代码中的缺陷充分暴露在编译阶段，运行时更安全代码编辑器可提供代码自动补全等人性化辅助功能数据完整性更好那什么又是编译型语言呢?编译型语言。
C++基本介绍
Dirty_artist的博客
05-23 2447
C++基本介绍
【C++简介】
Willing_hope的博客
07-11 4717
参考《C++Primer》
C++编程 基础知识
m0_56051805的博客
04-20 1718
C++编程 基础知识
一、C++简介
weixin_47248721的博客
05-10 2856
一、C++简介 C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。C++ 被认为是一种中级语言，它综合了高级语言和低级语言的特点。高级语言：实现效率高，执行效率低，对硬件的可控性弱，目标代码大，可维护性好，可移植性好。低级语言：实现效率低，执行效率高，对硬件的可控性强，目标代码小，可维护性差，可移植性差。 二、C++特征 C++是面向对象程序设计语言，所以包含面向对象的四大特征： 1、封装：封装指的是将隐匿某一方法执行步骤，取而代之的是消息传
C++基础
m0_64616721的博客
03-29 452
文章内容包含：什么是C++、C++关键字、C++发展史、C++关键字、命名空间、C++输入与输出、缺省参数、函数重载、引用、内联函数、auto关键字（C++11）、基于范围的for循环（C++11）、指针空值------nullptr（C++11）、
C++_字符串
JUSTfFUN的博客
02-14 548
文章目录C++定义字符串基础知识C语言风格C++风格测试源代码 C++定义字符串 基础知识 C语言风格 语法：char 变量名[] = “字符串值”; C++风格 语法：string 变量名 = “字符串值”; 测试源代码 /* 时间：2021.02.10 内容：C++字符串型 */ /* 1.C语言风格 char 变量名 [] = "字符串值"; 2.C++风格 string 变量名 = "字符串值"； 需要头文件<string> 经过测试在VS 16.8.4版本下可以不加&
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

渡我白衣

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值