【list&list模拟】

原创 已于 2025-08-12 19:59:44 修改 · 666 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#list #c++

于 2025-08-11 15:49:48 首次发布

list&list模拟

1.list使用

 list常见接口不做介绍，跟前面vector有相似之处，跟数据结构list基本一样。
alt
 因为list使用带头的双向循环链表实现的，不能用小标访问，只能用迭代器或范围for访问
alt

 list有成员函数sort，来实现排序
alt
 void unique(),去重，去重先先要排序

void test_list1()
{
	list<int> lt1 = { 10,2,3,3,4,5,6 };
	list<int> ::iterator it = lt1.begin();
	while (it != lt1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//list不支持sort
	//sort(lt1.begin(), lt1.end(), greater<int>());
	//list有自己的排序算法
	lt1.sort();
	it = lt1.begin();
	while (it != lt1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	lt1.sort(greater<int>());
	it = lt1.begin();
	while (it != lt1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//unique 去重
	//先排序，在去重
	lt1.unique();
	for (auto e : lt1)
	{
		cout << e << " ";  //10 6 5 4 3 2
	}
	cout << endl;
}

alt
 splice粘接
 void splice(const _iterator position,list& x);把x粘接到pos位置。

void test_list2()
{
	//splice:粘接
	std::list<int> mylist1, mylist2;
	std::list<int>::iterator it;

	// set some initial values:
	for (int i = 1; i <= 4; ++i)
		mylist1.push_back(i);      // mylist1: 1 2 3 4

	for (int i = 1; i <= 3; ++i)
		mylist2.push_back(i * 10);   // mylist2: 10 20 30

	it = mylist1.begin();
	++it;                         // points to 2

	mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
							     // mylist2 (empty)
	                             // "it" still points to 2 (the 5th element
}

void splice(const_iterator position,list& x,const_itrator i);
把list的第i个位置的数粘接到position位置.

void test_list3()
{
	list<int> mylist;
	for (int i = 1; i <= 4; i++)
	{
		mylist.push_back(i);  //mylist:   1 2 3 4
	} 
	//想把3转移到头
	list<int>::iterator  it = find(mylist.begin(), mylist.end(), 3);
	//void splice (const_iterator position, list& x, const_iterator i);
	//把list的第i个位置的数粘接到position位置
	mylist.splice(mylist.begin(), mylist, it);
}

2、list模拟

 先写申请一个节点的类，把节点弄成一个类，相当与搞了一个新的数据类型。

//这是第一个类 ListNode
//所谓的类就是把成员对象和成员函数封装在一起.
//这个全部弄成共有
//供后面存储数据来用
template<class T>
struct ListNode
{
	ListNode<T>* _next;
	ListNode<T>* _prev;
	T _data;

	//const T& data是接受常量
	//不能权限放大，会报错
	ListNode(const T& data = T())
		:_next(nullptr)
		,_prev(nullptr)
		,_data(data)
	{}
};

 先写list的大框架

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& data)
	{
		//...
	}
private:
	Node* _head;
};

 写push_back（）先跑通框架

void push_back(const T& data)
{
	Node* newnode = new Node(data);
	Node* tail = _head->_prev;
	
	//tail newnode  _head
	tail->_next = newnode;
	newnode->_prev = tail;
	newnode->_next = _head;
	_head->_prev = newnode;
}

alt
 带头双向循环链表，非常简单，写尾插即可，通过_head->_prev找到尾巴，尾巴，新节点，头插入即可。


 然后把节点封装成迭代器。把节点写成一个类，封装成迭代器所具有的属性，即可。先写·迭代器的行为，在进行封装。

void list_test1()
{
	list<int> lt1;
	lt1.push_back(1);
	lt1.push_back(2);
	lt1.push_back(3);
	lt1.push_back(4);
	list<int>::iterator it = lt1.begin();
	while (it != lt1.end())
	{
		cout << (*it) << " ";
		++it;
	}
}

 通过iterator it = it1.begin(),定义一个对象it,把it初始化为第一个节点的位置，然后进行以下运算符重载，！=，前置++，*就可以了。
 

template<class T>
class ListIterator
{
	typedef ListIterator<T> Self;
	typedef ListNode<T> Node;
public:
	ListIterator(Node* node = T())
	{
		_node = node;
	}

	//拷贝构造不要
	//赋值也不要
	T& operator*()
	{
		return _node->_data;
	}
	
	bool operator!=(const Self& it)
	{
		return _node != it._node;
	}
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
public:
	Node* _node;
};

 const_iterator可以通过*的运算符重载的返回值+const实现，具体在增加一个模版参数即可，不过多叙述

//Ref引用
//Ptr指针
template<class T,class Ref,class Ptr>
struct  ListIterator
{
	typedef ListNode<T> Node;
	typedef ListIterator<T,Ref,Ptr> Self;

	
public:
	Node* _node;
	ListIterator(Node* node)
		:_node(node)
	{}

	//拷贝构造和赋值写也可以，不写也可以
	//这儿是浅拷贝
	ListIterator(const Self& it)
	{
		_node = it._node;
	}

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

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

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

	////这个是前置
	//T& operator*()
	//{
	//	return _node->_data;
	//}

	//这个是前置
	Ref operator*()
	{
		return _node->_data;
	}

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

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

 写insert,iterator insert(iterator pos,const T& x);
在pos前面插入，返回的是x所在节点的位置

//在pos前面插入
//没有迭代器失效
iterator insert(iterator pos, const T& x)
{
	Node* next = pos._node;
	Node* newnode = new Node(x);
	Node* prev = next->_prev;

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

	return iterator(newnode);
}

 写erase,iterator erase(iterator pos),防止迭代器失效，返回的是pos的下一个位置

//erase后pos失效了，pos指向节点被释放了
iterator erase(iterator pos)
{
	assert(pos != end());
	Node* cur = pos._node;
	Node* next = cur->_next;
	Node* prev = cur->_prev;

	prev->_next = next;
	next->_prev = prev;

	delete cur;
	return iterator(next);
}

 写void clear(),清空，只剩头结点

void clear()
{
	list<T>::iterator it = begin();
	while (it != end())
	{
		//防止迭代器失效
		it = erase(it);
	}
}

 写~list(),先clear,在释放头节点

~list()
{
	//Node* cur = _head->_next;
	//while (cur != _head)
	//{
	//	Node* next = cur->_next;
	//	delete cur;
	//	cur = next;
	//}
	//delete _head;
	//_head = nullptr;

	clear();
	delete _head;
	_head = nullptr;
}

 写voId init_empty()保证有头结点，在后面插入数据

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

 写拷贝构造，initializer_list< T >为参数的构造函数

//拷贝构造
//lt2(lt1)
list(const list<T>& lt)
{
	//引入这个是弄个头结点
	empty_init();
	for (const auto& e : lt)
	{
		push_back(e);
	}
}

list(initializer_list<T>il)
{
	empty_init();
	for (const auto& e : il)
	{
		push_back(e);
	}
}
//lt1 = lt3
//lt所在的
list<T>& operator= (list<T>lt)
{
	std :: swap(_head,lt._head);
	return *this;
}

 再说一下list& operator= (listlt)，注意形参是拷贝构造的一份，和赋值_head,把头地址交换即可，lt在栈桢销毁时，就会销毁交换的那个_head.

附录

#define  _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <iostream>
#include <list>
#include <algorithm>
#include <assert.h>
using namespace std;

namespace wyj
{
	//这是第一个类 ListNode
	//所谓的类就是把成员对象和成员函数封装在一起.
	//这个全部弄成共有
	//供后面存储数据来用
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;

		//const T& data是接受常量
		//不能权限放大，会报错
		ListNode(const T& data = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(data)
		{}
	};


	//Ref引用
	//Ptr指针
	template<class T,class Ref,class Ptr>
	struct  ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T,Ref,Ptr> Self;

		
	public:
		Node* _node;
		ListIterator(Node* node)
			:_node(node)
		{}

		//拷贝构造和赋值写也可以，不写也可以
		//这儿是浅拷贝
		ListIterator(const Self& it)
		{
			_node = it._node;
		}

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

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

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

		////这个是前置
		//T& operator*()
		//{
		//	return _node->_data;
		//}

		//这个是前置
		Ref operator*()
		{
			return _node->_data;
		}

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

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


	//template<class T>
	//class ListConstIterator
	//{
	//	typedef ListNode<T> Node;
	//	typedef ListConstIterator<T> Self;

	//	Node* _node;
	//public:
	//	ListConstIterator(Node* node)
	//		:_node(node)
	//	{}

	//	//拷贝构造和赋值写也可以，不写也可以
	//	//这儿是浅拷贝
	//	ListConstIterator(const Self& it)
	//	{
	//		_node = it._node;
	//	}

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

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

	//	//这个是前置
	//	const T& operator*()
	//	{
	//		return _node->_data;
	//	}

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

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


	template<class T >
	class list
	{
		//封装成私有，只能list内部用
		typedef ListNode<T> Node;
	public:
		//ListIterator通过传节点对节点进一步处理
		//typedef ListIterator<T> iterator;
		//typedef ListConstIterator<T> const_iterator;
		typedef ListIterator<T,T&,T*> iterator;
		typedef ListIterator<T,const T&,const T*> const_iterator;
		iterator begin()
		{
			//iterator it(_head->_next)；
			//return it;
			//匿名对象
			//iterator这个类把这个节点封装了，通过传这个节点给iterator
			//调用iterator的构造函数，把节点给iterator中的_node
			return iterator(_head->_next);
		}

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

		const_iterator begin()  const
		{
			//iterator it(_head->_next)；
			//return it;
			//匿名对象
			return const_iterator(_head->_next);
		}

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

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

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

		//拷贝构造
		//lt2(lt1)
		list(const list<T>& lt)
		{
			//引入这个是弄个头结点
			empty_init();
			for (const auto& e : lt)
			{
				push_back(e);
			}
		}

		list(initializer_list<T>il)
		{
			empty_init();
			for (const auto& e : il)
			{
				push_back(e);
			}
		}
		//lt1 = lt3
		//lt所在的
		list<T>& operator= (list<T>lt)
		{
			std :: swap(_head,lt._head);
			return *this;
		}

		~list()
		{
			//Node* cur = _head->_next;
			//while (cur != _head)
			//{
			//	Node* next = cur->_next;
			//	delete cur;
			//	cur = next;
			//}
			//delete _head;
			//_head = nullptr;

			clear();
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			list<T>::iterator it = begin();
			while (it != end())
			{
				//防止迭代器失效
				it = erase(it);
			}
		}
		void push_back(const T& x)
		{
			//Node* newnode = new Node(x);
			//Node* tail = _head->_prev;
			//
			//tail->_next = newnode;
			//newnode->_prev = tail;
			//newnode->_next = _head;
			//_head->_prev = newnode;

			insert(end(), x);
		}
		void pop_back()
		{
			erase(--end());
		}

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

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

		//在pos前面插入
		//没有迭代器失效
		iterator insert(iterator pos, const T& x)
		{
			Node* next = pos._node;
			Node* newnode = new Node(x);
			Node* prev = next->_prev;

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

			return iterator(newnode);
		}

		//erase后pos失效了，pos指向节点被释放了
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* cur = pos._node;
			Node* next = cur->_next;
			Node* prev = cur->_prev;

			prev->_next = next;
			next->_prev = prev;

			delete cur;
			return iterator(next);
		}
	private:
		Node* _head;
	};

	void func(const list<int>& lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << (*it) << " ";
			++it;
		}
		cout << endl;
	}

	void test_list1()
	{
		list<int>l1;
		l1.push_back(1);
		l1.push_back(2);
		l1.push_back(3);
		l1.push_back(4);
		l1.push_back(5);
		//调用begin,把节点给iterator,用iterator来接受
		list<int>::iterator it = l1.begin();
		while (it != l1.end())
		{
			cout << (*it) << " ";
			*it += 10;
			++it;
		}
		cout << endl;
		for (auto e : l1)
		{
			cout << e << " ";
			++it;
		}
		cout << endl;
	}

	struct Pos
	{
	
		Pos(int row =0,int col = 0)
			:_row(row)
			,_col(col)
		{}
	
		int _row;
		int _col; 
	};

	void test_list2()
	{
		list<Pos>lt1;
		lt1.push_back(Pos(100, 100));
		lt1.push_back(Pos(200, 200));
		lt1.push_back(Pos(300, 400));
		list<Pos>::iterator it = lt1.begin();
		while (it != lt1.end())
		{
			//为了可读性，省略了一个箭头
			cout << it->_row << ":"<<it->_col<<endl;
			//cout << it.operator->()->_row << ":" << it.operator->()->_col << endl;
			++it;
		}
	}

	void test_list3()
	{
		list<int>l1;
		l1.push_back(1);
		l1.push_back(2);
		l1.push_back(3);
		l1.push_back(4);
		l1.push_back(5);
		func(l1);
		cout << endl;

		l1.push_front(10);
		l1.push_front(10);
		l1.push_front(10);

		func(l1);
		cout << endl;

		l1.pop_front();
		l1.pop_front();
		func(l1);
		cout << endl;

		l1.pop_back();
		l1.pop_back();
		func(l1);
		cout << endl;
	}
	
	void test_list4()
	{
		list<int>lt1;
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(3);
		lt1.push_back(4);
		lt1.push_back(5);
		func(lt1);

		list<int> lt2(lt1);
		func(lt2);
		list<int> lt3;
		lt3 = lt1;
		func(lt2);
	}

	void test_list5()
	{
		list<int> lt1 = { 1,2,3,4,5,6 };
		func(lt1);
	}
}



#include "list.h"
#include "list1.h"
void test_list1()
{
	list<int> lt1 = { 10,2,3,3,4,5,6 };
	list<int> ::iterator it = lt1.begin();
	while (it != lt1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//list不支持sort
	//sort(lt1.begin(), lt1.end(), greater<int>());
	//list有自己的排序算法
	lt1.sort();
	it = lt1.begin();
	while (it != lt1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	lt1.sort(greater<int>());
	it = lt1.begin();
	while (it != lt1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//unique 去重
	//先排序，在去重
	lt1.unique();
	for (auto e : lt1)
	{
		cout << e << " ";  //10 6 5 4 3 2
	}
	cout << endl;
}


void test_list2()
{
	//splice:粘接
	std::list<int> mylist1, mylist2;
	std::list<int>::iterator it;

	// set some initial values:
	for (int i = 1; i <= 4; ++i)
		mylist1.push_back(i);      // mylist1: 1 2 3 4

	for (int i = 1; i <= 3; ++i)
		mylist2.push_back(i * 10);   // mylist2: 10 20 30

	it = mylist1.begin();
	++it;                         // points to 2

	mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
							     // mylist2 (empty)
	                             // "it" still points to 2 (the 5th element
}

void test_list3()
{
	list<int> mylist;
	for (int i = 1; i <= 4; i++)
	{
		mylist.push_back(i);  //mylist:   1 2 3 4
	} 
	//想把3转移到头
	list<int>::iterator  it = find(mylist.begin(), mylist.end(), 3);
	//void splice (const_iterator position, list& x, const_iterator i);
	//把list的第i个位置的数粘接到position位置
	mylist.splice(mylist.begin(), mylist, it);
}

int main()
{
	//wyj::test_list5();
	//test_list1();
	bit::list_test1();
	return 0;
}

 /*****************************************************/

 /*****************************************************/

 下来练习代码

#define  _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;


//先定义一个节点类
//所谓的类就是把成员变量和成员方法封装在一起
//例如这个节点类
//成员变量是指定义节点的变量，方法是指操作这个节点的方法
//那么通过成员变量和成员方法把这个节点类封装好之后，外面该怎么用呢？
//类可以理解为就是个新定义的数据类型，那么其它类使用，则在另一个类
//中定义这个类来使用
//比如：在另一个类中使用这个节点类，则在这个类中定义即可，并且你在
//这个类中定义一个节点类，会自动初始化，销毁，这是类的一个特性


namespace wyj
{
	template<class T>
	struct ListNode
	{
		//定义数据
		ListNode<T>*  _prev;
		ListNode<T>*  _next;
		T _data;

		//初始化
		ListNode(const T& data = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_data(data)
		{}

		//拷贝构造
		ListNode(const ListNode& node)
		{
			_prev = node._prev;
			_next = node._next;
			_data = node._data;
		}

		//赋值
		ListNode& operator=(const ListNode& node)
		{
			_prev = node._prev;
			_next = node._next;
			_data = node._data;
			return *this;
		}
	};

	//在这儿，把ListNode要封装一下，符合iterator的特性
	template<class T,class Ref>
	class ListIterator
	{
		//要封装节点，首先要把节点引进进来
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref> Self;
	public:
		//
		ListIterator(Node* node = nullptr)
			:_node(node)
		{}

		ListIterator(const Self& iterator)
		{
			_node = iterator._node;
		}

		ListIterator& operator=(const Self& iterator)
		{
			_node = iterator._node;
			return *this;
		}

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

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

		ListIterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

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

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

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

		bool operator==(const Self& iterator)
		{
			return  _node == iterator._node;
		}
	//private:
	public:
		Node* _node;
	};


	template<class T>
	class list
	{
	private:
		//这儿把封装好的ListNode重命名
		//ListNode可以理解为一种新的数据类型
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T,T&> iterator;
		typedef ListIterator<T,const T&> const_iterator;
		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);
		}

		//写构造函数
		list()
		{
			//调用了Node的构造函数
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}


		template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			init_empty();
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

		list(initializer_list<T> il)
		{
			init_empty();
			for (const auto& e : il)
			{
				push_back(e);
			}
		}

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

		list(const list<T>& lt)
		{
			init_empty();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}
		
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		//犯了一个错误，要加换了，还const
		//list& operator=(const list lt)
		list<T>& operator=(list<T> lt)
		{
			swap(_head,lt._head);
			return *this;
		}

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

		//插入
		void push_back(const T& data )
		{
			Node* newnode = new Node(data);
			Node* tail = _head->_prev;
			//  tail newnode _head
			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;
			
			//insert(end(), data);
		}
		void pop_back()
		{
			erase(--end());
		}
		
		void push_front(const T& data)
		{
			insert(begin(),data);
		}

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

		//在pos前面插入
		void insert(iterator pos, const T& data)
		{
			Node* newnode = new Node(data);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

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

		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->_prev = prev;

			delete cur;
			return iterator(next);
		}

	private:
		Node* _head;
	};

	void list_test1()
	{
		list<int> lt1;
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(3);
		lt1.push_back(4);
		list<int>::iterator it = lt1.begin();
		for (auto e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;

		while (it != lt1.end())
		{
			(*it) += 10;
			it++;
		}

		for (auto e : lt1)
		{
			cout << e << " ";
		}
	}
	void Func(const list<int>& lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << (*it) << " ";
			it++;
		}
		cout << endl;
	}
	void list_test2()
	{
		list<int> lt1;
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(3);
		lt1.push_back(4);
		lt1.push_back(5);

		Func(lt1);

		lt1.push_front(10);
		lt1.push_front(20);
		lt1.push_front(30);

		Func(lt1);

		lt1.pop_front();
		lt1.pop_front();
		Func(lt1);

		lt1.pop_back();
		lt1.pop_back();
		Func(lt1);

		lt1.pop_back();
		lt1.pop_back();
		lt1.pop_back();
		lt1.pop_back();
		//lt1.pop_back();
		Func(lt1);
	}

	void list_test3()
	{
		//构造函数
		list<int> lt1 = { 1,2,3,4,5,6,7,8 };
		for (auto& e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;

		list<int> lt2 = lt1;
		for (auto& e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;

		list<int>lt3;
		lt3 = lt1;
		for (auto& e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

 
 
 
 

【STL】模拟实现list
m0_73634434的博客
10-14 2665
因为迭代器·结点指针的行为不能满足迭代器定义，那么我们可以对这个结点指针进行封装，对结点指针的各种运算符进行重载，使得我们可以像使用string和vector当中的迭代器一样去使用list当中的迭代器。当我们使用解引用操作符时，是想得到该位置的数据内容，所以我们直接返回当前结点指针所指向的数据即可，但是这里需要解引用返回，得到数据之后，我们后面可能会对这个数据进行修改。对于后置--，我们需要记录结点指针当前的位置，让结点指针向指向前一个结点，然后返回自减前的结点指针即可。
【C++】list类模拟实现
qq_66314292的博客
11-09 2421
list类的模拟实现
C++ list模拟实现
Han同学
12-25 3212
C++模拟实现list
C++【list容器&&模拟实现函数解析】
m0_59292239的博客
03-16 2046
C++【list容器&&模拟实现函数解析】
详解list及其模拟实现
.
06-17 2381
list的模拟实现
【C++】list的模拟实现
小羊的博客
08-14 5612
list详解及模拟实现
【C++】List模拟实现
Renswc的博客
05-31 3244
C++中的list是一种双向链表（doubly linked list）的实现。它是C++标准库中的一种容器，可以存储一系列元素，并且允许在任意位置插入、删除和访问元素。对于双向链表有疑问的可以点击查看数据结构——带头双向循环链表详解对于list大部分和前面学习过的vector类似，关键点在于理解list的迭代器的封装以及const迭代器，还有list实现包括了三个类，它们分别都有类模板，容易绕晕，需要好好理解清楚
C++list的模拟实现
2301_77509762的博客
03-16 2522
STL容器List的介绍以及模拟实现
【爱上C++】list用法详解、模拟实现
2301_76677973的博客
07-22 5227
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
C++_list简单源码剖析：list模拟实现
Lvision2的博客
05-31 1346
->
C++ 模拟实现list(迭代器)实现代码
08-30
C++ 模拟实现 List（迭代器）实现代码 C++ 模拟实现 List（迭代器）是指使用 C++ 语言来模拟实现 List 数据结构，并提供迭代器来遍历 List 中的元素。在本文中，我们将介绍如何使用 C++ 语言来模拟实现 List（迭代...
33 C++ STL模板库2-initializer_list
17208955的博客
08-13 718
本文介绍了C++11引入的std::initializer_list模板类，它支持大括号初始化语法，用于封装一组值作为临时只读序列。文章详细讲解了其基本概念、声明方式、生命周期管理，并通过示例代码展示了在构造函数参数、函数重载和模板函数中的典型应用。还介绍了initializer_list的遍历操作方法（迭代器、范围for循环、size()），并强调了其只读性和临时性的注意事项。最后指出该特性在容器初始化、多维数组和可变参数传递等场景中的实用价值。
【C++ STL】list详解和模拟
2403_88316985的博客
08-13 718
本文摘要： 本文主要探讨了C++ STL中list容器的实现原理和关键特性。首先介绍了list的数据结构，指出它是一个带头节点的双向循环链表，其节点包含prev、next指针和数据域。其次详细分析了list迭代器的设计，强调其封装性和双向移动能力。文章还重点讲解了list的几个特殊接口：clear用于清空内容，remove删除特定值元素，unique对有序列表去重（可自定义比较方法），以及splice用于在不同list间转移元素。通过多个代码示例展示了这些接口的实际应用场景和使用方法。
HarmonyOS 实战：用 List 与 AlphabetIndexer 打造高效城市选择功能
不懂先生的博客
08-15 829
本文介绍了如何在HarmonyOS平台上实现高效城市选择功能，重点利用List和AlphabetIndexer组件的联动机制。通过分析功能需求，设计了包含历史城市、热门城市和字母分组城市的数据结构，并详细阐述了实现步骤：包括数据结构定义、索引数组构建、列表UI和索引器UI的搭建。针对开发中常见的索引器与列表位置不匹配问题，提出了通过映射数组建立精确的索引对应关系，并提供了优化后的完整代码方案。该实现不仅提升了城市选择效率，其技术方案也可应用于通讯录、词典等需要快速定位的场景。
手写MyBatis第16弹：泛型魔法应用：MyBatis如何破解List的运行时类型
源码获取 | 运行部署 | 定制二开修改，如果回复不及时请耐心等待，请见谅。
08-14 798
MyBatis结果映射机制深度解析：从方法签名到ORM转换 摘要：MyBatis通过精密的类型系统实现ORM转换，其核心在于对Mapper方法返回类型的智能解析。文章揭示了MyBatis获取返回类型的双重机制：基础类型反射获取和泛型参数解析，重点剖析了六类返回类型的处理策略（包括void、POJO、集合等）。技术亮点包括泛型嵌套解析的三层技巧、ResultSet元数据的三重价值（列名匹配/类型转换/结果验证），以及ResultHandler的流式处理能力。企业级实践建议强调类型安全检查、智能推导和缓存优化，
java中list的api详细使用
qq_45089709的博客
08-13 1077
Java中的List接口代表有序可重复集合，核心实现类包括ArrayList（数组实现）和LinkedList（链表实现）。主要API功能包括：添加元素（add/addAll）、删除元素（remove/removeAll/clear）、获取修改元素（get/set）、查找判断（contains/indexOf）以及迭代遍历（iterator）。支持按索引操作和批量处理，是Java集合框架中最常用的接口之一。使用时需注意索引范围及元素判等规则。
YAML 中定义 List 的几种方式
最新发布
果酱 の 博客
08-15 238
本文介绍了在YAML中定义List的三种方式：缩进式（推荐）、行内式和混合写法，并详细说明了在Spring应用中通过@Value和@ConfigurationProperties两种方式注入List的方法。特别强调了对象类型列表的注入方式，以及相关的注意事项，包括配置前缀匹配、字段命名规范、依赖添加和类型转换等。文章提供了完整的代码示例，帮助开发者灵活地在YAML中定义各类List，并在Spring应用中正确配置和使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值