【C++】list基本接口+手撕 list(详解迭代器)

这篇具有很好参考价值的文章主要介绍了【C++】list基本接口+手撕 list(详解迭代器)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

父母就像迭代器,封装了他们的脆弱...... 

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

手撕list目录:

一、list的常用接口及其使用

1.1list 构造函数与增删查改

1.2list 特殊接口

1.3list 排序性能分析

二、list 迭代器实现(重点+难点)

关于迭代器的引入知识:

2.1迭代器的分类

2.2 list 迭代器失效问题(和vector有差异)

2.3list 迭代器源码模板

2.4list 整体基本框架

三、手撕list迭代器

3.1重载operator*()

3.2重载++、–、!=

3.3 利用类模板优化

四、增删查改

4.1 insert(参数必须加引用,担心非内置类型)和erase

4.2 push_back和push_front

4.3  pop_back和pop_front

五、list 构造+赋值重载

5.1默认构造+迭代器区间构造+拷贝构造

5.2 赋值重载现代写法

5.3 类名和类型的问题(C++的一个坑)

六、list和vector的对比(重点)

七、源码合集


一、list的常用接口及其使用

1.1list 构造函数与增删查改

list 是可以在常数范围内在任意位置进行插入和删除的序列式容器,其底层是带头双向循环链表;list 常用接口的使用和 string、vector 系列容器的接口使用一样,这里我不详细介绍,请看我们的老朋友:cplusplus.com - The C++ Resources Network

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

构造函数:

构造函数(constructor) 接口说明
list (size_type n, const value_type& val = value_type()) 构造的 list 中包含n个值为val的元素
list() 构造空的 list
构造空的 list 拷贝构造函数
list (InputIterator first, InputIterator last) 用 [first, last) 区间中的元素构造 list

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

增删查改: 

函数说明 接口说明
push_front 在list首元素前插入值为val的元素
pop_front 删除list中第一个元素
push_back 在list尾部插入值为val的元素
pop_back 删除list中最后一个元素
insert 在list position 位置中插入值为val的元素
erase 删除list position位置的元素
swap 交换两个list中的元素
clear 清空list中的有效元素

注意:

1、由于 list 的物理结构是非连续的 – 前一个节点地址和后一个节点地址的位置关系是随机的,所以 list 不支持随机访问,自然也就不支持 [ ] 操作

2、list 不支持reserve操作,因为 list 的节点是使用时开辟,使用完销毁,不能预留空间;

(从这个特点也容易看出来,如果需要一直插入删除元素,利用list更好

1.2list 特殊接口

除了上述 STL 容器基本都有的一般接口外,list 还提供一些独有的特殊操作接口,如下:

函数声明 接口说明
splice 将 list1 中的元素转移到 list2 中
remove 移除 list 中的指定元素
unique 链表去重(sort之后才可以用)
merge 合并两个链表
sort 链表排序(探究为什么list自己写sort
reverse 链表逆置

题外话: 为什么list需要自己实现sort接口??难道说库中的封装性不好?效率不高?

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

 我们先使用库中自己的sort函数:

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

我们使用算法库中的sort函数:

void test_sort()
{
     list<int> l1{ 5,6,4,8,9,2,7 };//C++ 11写法
     sort(l1.begin(),l1.end());
     for(auto l : l1)
     {
        cout << l << " ";
     }
     cout << endl;
}

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

报错了(意外之中,如果不报错我还写这个知识点干啥 doge) 报错原因说没有-迭代器

让我们看看sort源码~

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

这一切的一切都是因为sort的迭代器引起的!! 

注意:

1、链表排序只能使用 list 提供的 sort 接口,而不能使用 algorithm 提供的 sort 接口,因为链表物理地址不连续,迭代器为双向迭代器,不支持 + - 操作而算法库中的 sort 函数需要支持 + - 的随机迭代器

2、链表去重之前必须保证链表有序,否则去重不完全;

3、两个有序链表合并之后仍然保存有序;

 最后,虽然 list 提供了这些具有特殊功能的接口,它们也确实有一定的作用,但是实际上这些特殊接口使用频率非常低,包括 sort 接口 (链表排序的效率太低)。

1.3list 排序性能分析

虽然链表排序只能使用 list 提供的 sort 接口,而不能使用 algorithm 提供的 sort 接口,但是其使用频率仍然非常低,这是由于链表排序的效率太低了,我们可以通过对比两组测试数据来直观的感受链表排序的效率。

测试一:vector 排序与 list 排序性能对比

//vector sort 和 list sort 性能对比 -- release 版本下
void test_op1() {
	srand((size_t)time(0));
	const int N = 1000000;  //100万个数据

	vector<int> v;
	v.reserve(N);
	list<int> lt;
	for (int i = 0; i < N; ++i)
	{
		auto e = rand();
		v.push_back(e);
		lt.push_back(e);
	}

	//vector sort
	int begin1 = clock();
	sort(v.begin(), v.end());
	int end1 = clock();

	//list sort
	int begin2 = clock();
	lt.sort();
	int end2 = clock();

	printf("vector sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);
}

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

测试二:list 直接进行排序与将数据拷贝到 vector 中使用 vector 排序后再将数据拷回 list 中性能对比

//list sort 与 将数据转移到 vector 中进行排序后拷贝回来性能对比 -- release 版本下
void test_op2()
{
	srand(time(0));
	const int N = 1000000;  //100万个数据
	list<int> lt1;
	list<int> lt2;
	for (int i = 0; i < N; ++i)
	{
		auto e = rand();
		lt1.push_back(e);
		lt2.push_back(e);
	}

	//list sort -- lt1
	int begin1 = clock();
	lt1.sort();
	int end1 = clock();

	// 将数据拷贝到vector中排序,排完以后再拷贝回来 -- lt2
	int begin2 = clock();
	vector<int> v;
	v.reserve(N);
	for (auto e : lt2)  //拷贝
	{
		v.push_back(e);
	}
	sort(v.begin(), v.end());  //排序
	lt2.assign(v.begin(), v.end());  //拷贝
	int end2 = clock();

	printf("list1 sort:%d\n", end1 - begin1);
	printf("list2 sort:%d\n", end2 - begin2);
}

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

 可以看到,list sort 的效率远低于 vector sort,甚至于说,直接使用 list sort 的效率都不如先将数据拷贝到 vector 中,然后使用 vector sort,排序之后再将数据拷贝回 list 中快;所以list中的sort接口是很挫的!!


二、list 迭代器实现(重点+难点)

关于迭代器的引入知识:

迭代器的价值在于封装底层的实现,不具体暴露底层的实现细节,提供统一的访问方式

iterator只是代言人!!真正的牛逼大佬其实是_list_iterator

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

为什么在 list 中将迭代器搞成指针这招不好用了呢??

在数组中,*指针就是元素,指针++就是 +sizeof(T) 对象大小,没办法,谁叫他们物理空间连续,结构NB,所以对于vector和string类而言,物理空间是连续的,原生的指针就是迭代器了,解引用就是数据了但是对于这里的list而言,空间是不连续的

解决方法:

此时如果解引用是拿不到数据的(空间不连续),更不用说++指向下一个结点了。所以,对于list的迭代器,原生指针已经不符合我们的需求了,我们需要去进行特殊处理:进行类的封装。我们可以通过类的封装以及运算符重载支持,这样就可以实现像内置类型一样的运算符

迭代器的俩个特征:

1.解引用2.++ / --

运算符重载的大任务:

实现解引用operator*()和++函数

2.1迭代器的分类

按照迭代器的功能,迭代器一共可以分为以下三类:

  • 单向迭代器 – 迭代器仅仅支持 ++ 和解引用操作(单链表,哈希)
  • 双向迭代器 – 迭代器支持 ++、-- 和解引用操作,但不支持 +、- 操作(list 双向链表)
  • 随机迭代器 – 迭代器不仅支持 ++、-- 和解引用操作,还支持 +、- 操作,即迭代器能够随机访问(string,vector)

这也充分说明,vector和string是可以用库中的sort函数的

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl


迭代器还可以分成普通迭代器和const迭代器俩类:

//1.const T* p1
list<int>::const_iterator cit = lt.begin();
//2.T* const p2
const list<int>::iterator cit = lt.begin();
//不符合const迭代器的行为,因为保护迭代器本身不能修改,那么我们也就不能++迭代器

灵魂拷问:const迭代器是p1还是p2?p1

const迭代器类似p1的行为,保护指向的对象不被修改,迭代器本身可以修改

2.2 list 迭代器失效问题(和vector有差异)

vector迭代器失效:insert扩容+erase的时候会失效

和 vector 不同,list 进行 insert 操作后并不会产生迭代器失效问题,因为 list 插入的新节点是动态开辟的,同时由于 list 每个节点的物理地址是不相关的,所以插入的新节点并不会影响原来其他节点的地址

但是 list erase 之后会发生迭代器失效,因为 list 删除节点会直接将该节点释放掉,此时我们再访问该节点就会造成越界访问

2.3list 迭代器源码模板

我们知道,迭代器是类似于指针一样的东西,即迭代器要能够实现指针相关的全部或部分操作 – ++、–、*、+、-;对我们之前 string 和 vector 的迭代器来说,迭代器就是原生指针,所以它天然的就支持上述操作;

但是对于 list 来说,list 的节点是一个结构体,同时 list 每个节点的物理地址是不连续的,如果此时我们还简单将节点的指针 typedef 为迭代器的话,那么显然它是不能够实现解引用、++ 等操作的,所以我们需要用结构体/类来对迭代器进行封装,再配合运算符重载等操作让迭代器能够实现解引用、++、-- 等操作

框架代码如下:

//节点定义
template <class T>
struct __list_node {
    typedef void* void_pointer;
    void_pointer next;
    void_pointer prev;
    T data;
};

//迭代器定义
typedef __list_iterator<T, T&, T*>   iterator;
typedef __list_iterator<T, const T&, const T*>  const_iterator;

//迭代器类
template<class T, class Ref, class Ptr>
struct __list_iterator {
     typedef __list_iterator<T, Ref, Ptr>  self;
     typedef __list_node<T>* link_type;  //节点的指针
     link_type node; //类成员变量
    
     __list_iterator(link_type x) : node(x) {} //将节点指针构造为类对象
    
    //... 使用运算符重载支持迭代器的各种行为
    self& operator++() {...}
    self& operator--() {...}
    Ref operator*() const {...}
};

2.4list 整体基本框架

namespace lzy
{
    //结点
	template<class T>
	struct list_node
	{
		list_node* _next;
		list_node* _prev;
		T _data;

		list_node(const T& x)//节点的构造函数及初始化列表
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
	};

	template<class T>
	class list
	{
		typedef list_node<T> node;
	public:
        //迭代器
		typedef __list_iterator<T> iterator;
        typedef __list_const_iterator<T> const_iterator;
        //构造
		list()
		{
			_head = new node(T());
			_head->_next = _head;
			_head->_prev = _head;
		}
	private:
		node* _head;
        size_t _size;
	};
}

三、手撕list迭代器

迭代器的实现我们需要去考虑普通迭代器和const迭代器。这两种迭代器的不同,也会带来不同的接口。我们可以分别单独去进行实现,我们先来看一看简单的构造迭代器,只需要提供一个结点即可,看一看实现的基本框架:

    template<class T>
	struct __list_iterator
	{
		typedef list_node<T> node;
		node* _pnode;

		__list_iterator(node* p)
			:_pnode(p)
		{}
    }

为什么迭代器不写拷贝构造函数?浅拷贝真的可以吗?

对于迭代器的拷贝构造和赋值重载我们并不需要自己去手动实现,编译器默认生成的就是浅拷贝,而我们需要的就是浅拷贝,这也说明了,并不是说如果有指针就需要我们去实现深拷贝,而且迭代器不需要写析构函数,所以说不需要深拷贝

为什么聊这个问题?因为list<int>::iterator it=v.begin() 这就是一个拷贝构造

3.1重载operator*()

这个比较简单,就是要获取迭代器指向的数据,并且返回数据的引用:

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

 3.2重载++、–、!=

	   __list_iterator<T>& operator++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		__list_iterator<T>& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		bool operator!=(const __list_iterator<T>& it)
		{
			return _pnode != it._pnode;
		}

 如果按照上面的做法,我们在来看看此时普通迭代器和const迭代器的区别:

//typedef __list_iterator<T> iterator;
//typedef __list_const_iterator<T> const_iterator;
    template<class T>
	struct __list_iterator
	{
		typedef list_node<T> node;
		node* _pnode;

		__list_iterator(node* p)
			:_pnode(p)
		{}

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

		__list_iterator<T>& operator++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		__list_iterator<T>& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		bool operator!=(const __list_iterator<T>& it)
		{
			return _pnode != it._pnode;
		}
	};

	//跟普通迭代器的区别:遍历,不能用*it修改数据
	template<class T>
	struct __list_const_iterator
	{
		typedef list_node<T> node;
		node* _pnode;

		__list_const_iterator(node* p)
			:_pnode(p)
		{}

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

		__list_const_iterator<T>& operator++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		__list_const_iterator<T>& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		bool operator!=(const __list_const_iterator<T>& it)
		{
			return _pnode != it._pnode;
		}
	};

代码冗余!!!代码冗余!!!代码冗余!!!

如果是这样子去实现的话,我们就会发现,这两个迭代器的实现并没有多大的区别,唯一的区别就在于operator*的不同。const迭代器和普通迭代器的唯一区别就是普通迭代器返回T&,可读可写,const迭代器返回const T&,可读不可写。我们可以参考源码的实现:类模板参数解决这个问题,这也是迭代器的强大之处

3.3 利用类模板优化

template <class T,class Ref,class Ptr>
//typedef __list_iterator<T, T&, T*> iterator;
//typedef __list_iterator<T, const T&, const T*> const_iterator;

利用类模板参数修正之后的代码:

    //  typedef __list_iterator<T, T&, T*> iterator;
	//  typedef __list_iterator<T, const T&, const T*> const_iterator;
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref, Ptr> Self;
		node* _pnode;
		__list_iterator(node*p)
			:_pnode(p)
		{
		}
		//返回数据的指针
		Ptr operator->()
		{
			return &_pnode->_data;
		}
		//模板参数做返回值
		Ref operator *()
		{
			return _pnode->_data;
		}

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

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

		Self& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		Self operator--(int)
		{
			Self tmp(*this);
			_pnode = _pnode->_prev;
			return tmp;
		}

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

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

同一个类模板,此时我们传递不同的参数实例化成不同的迭代器了!!!这解决了我们刚刚所说的代码冗余问题


四、增删查改

4.1 insert(参数必须加引用,担心非内置类型)和erase

insert:在pos位置上一个插入,返回插入位置的迭代器,对于list的insert迭代器不会失效,vector失效是因为扩容导致pos位置造成野指针问题

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

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

			++_size;
			return iterator(newnode);
		}

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

 erase:这里的带头(哨兵位)头结点不可删除,返回值是删除位置的下一个,对于list的erase迭代器是失效的

		iterator erase(iterator pos)
		{
			assert(pos != end());
			node* prev = pos._pnode->_prev;
			node* next = pos._pnode->_next;

			prev->_next = next;
			next->_prev = prev;
			delete pos._pnode;
			--_size;
			return iterator(next);
		}

4.2 push_back和push_front

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

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

注意!list的begin和end的位置

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

同时这个问题还可以延伸出另一个问题:为什么迭代器访问元素的时候要这样写?

 在vector中,物理地址是连续的,这么写还情有可原,分析过list的begin和end之后,你还敢这么写吗??

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

 直接就报错了,所以正确的应该是!=,而不是 <

void test3()
{
    vector<int> vv={1,5,7,8,9,3,4};
    list<int> l={1,5,6,7};
    vector<int>::iterator it1=vv.begin();
    list<int>::iterator it2=l.begin();
    while(it1 < vv.end())
    {
        cout << *it1 << " ";
        it1++;
    }
    cout << endl;
    // while(it2 < l.end())
    // {
    //     cout << *it2 << " ";
    //     it2++;
    // }
    while(it2 != l.end())
    {
        cout << *it2 << " ";
        it2++;
    }
    cout << endl;
}

4.3  pop_back和pop_front

尾删和头删,复用erase即可

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

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

这里的尾删刚好用上了我们的重载


五、list 构造+赋值重载

5.1默认构造+迭代器区间构造+拷贝构造

默认构造:

list()
{
    _head = new node(T());
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}

我们可以用empty_initialize()来封装初始化,方便复用,不用每次都写:

void empty_initialize()
{
    _head = new node(T());
    _head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}

迭代器区间构造:

	    //迭代器区间构造
		template <class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			empty_initialize();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

拷贝构造:

 传统:
 

		list(const list<T>& lt)
		{
			empty_initialize();
			for (const auto& e : lt)
			{
				push_back(e);
			}
		}

 用范围for进行尾插,但是要注意要加上&,范围for是*it赋值给给e,又是一个拷贝,e是T类型对象,依次取得容器中的数据,T如果是string类型,不断拷贝,push_back之后又销毁

现代:

		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}		
		list(const list<T>& lt)
		{
			empty_initialize();
			list<T> tmp(lt.begin(), lt.end());
			swap(tmp);
		}

5.2 赋值重载现代写法

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

5.3 类名和类型的问题(C++的一个坑)

查看官方文档,我们可以看到list没有类型:

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

list<T>& operator=(list<T> lt)
list& operator=(list lt) 

对于普通类:类名等价于类型

对于类模板:类名不等价于类型(如list模板,类名:list 类型:list)

类模板里面可以用类名代表类型,但是并不建议,在类外面则必须要带模板参数list


六、list和vector的对比(重点)

vector list
底层结构 动态顺序表,一段连续空间 带头结点的双向循环链表
随机访问 支持随机访问,访问某个元素效率 O(1) 不支持随机访问
插入和删除 任意位置插入和删除效率低,需要搬移元素,时间复杂度为 O(N),插入时有可能需要增容,增容:开辟新空间,拷贝元素,释放旧空间,导致效率更低 任意位置插入和删除效率高,不需要搬移元素,时间复杂度为 O(1)
空间利用率 底层为连续空间,不容易造成内存碎片,空间利用率高,缓存利用率高 底层节点动态开辟,小节点容易造成内存碎片,空间利用率低,缓存利用率低
迭代器 原生态指针 对原生态指针 (节点指针) 进行封装
迭代器失效 插入元素时,要给所有的迭代器重新赋值,因为插入元素有可能会导致重新扩容,致使原来迭代器失效,删除时,当前迭代器需要重新赋值否则会失效 插入元素不会导致迭代器失效,删除元素时,只会导致当前迭代器失效,其他迭代器不受影响
使用场景 在插入元素时,要给所有的迭代器重新赋值,因为插入元素有可能会导致重新扩容,致使原来迭代器失效,删除时,当前迭代器需要重新赋值否则会失效 大量插入和删除操作,不关心随机访问

七、源码合集

#pragma once

#include <iostream>
#include <assert.h>
#include <algorithm>

namespace lzy {
	template<class T>
	struct list_node  //list 节点结构定义
	{
		list_node<T>* _next;//不加<T>也没错,但是写上好一些
		list_node<T>* _prev;
		T _data;

		list_node(const T& x)//构造
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
	};

	//迭代器最终版
	//const 迭代器 -- 增加模板参数,解决 operator*() 返回值与 operator->() 返回值问题
	//typedef __list_iterator<T, T&, T*> iterator;
	//typedef __list_iterator<T, const T&, const T*> const_iterator;
	//STL源码中大佬的写法,利用多个模板参数来避免副本造成的代码冗余问题
	template<class T, class Ref, class Ptr>
	struct __list_iterator  //迭代器类
	{
		typedef list_node<T> node;  //重命名list节点
		typedef __list_iterator<T, Ref, Ptr> Self;  //这里进行重命名是为了后续再添加模板参数时只用修改这一个地方
		node* _pnode;  //节点指针作为类的唯一成员变量

		__list_iterator(node* p)
			:_pnode(p)
		{}

		Ref operator*()  //解引用
		{
			return _pnode->_data;
		}

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

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

		Self& operator++(int) //后置++
		{
			Self it(*this);
			_pnode = _pnode->_next;
			return it;
		}

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

		Self& operator--(int) //后置--
		{
			Self it(*this);
			_pnode = _pnode->_prev;
			return it;
		}

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

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

	//list 类
	template<class T>
	class list
	{
		typedef list_node<T> node;  //list 的节点
	public:
		typedef __list_iterator<T, T&, T*> iterator;  //迭代器
		typedef __list_iterator<T, const T&, const T*> const_iterator; //const 迭代器

		//迭代器
		iterator begin() {
			return iterator(_head->_next);
		}

		iterator end() {
			//iterator it(_head);
			//return it;

			//直接利用匿名对象更为便捷
			return iterator(_head);
		}

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

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

		void empty_initialize() {  //初始化 -- 哨兵位头结点
			_head = new node(T());
			_head->_next = _head;
			_head->_prev = _head;

			_size = 0;  //空间换时间,用于标记节点个数
		}

		list() {  //构造,不是list<T>的原因:构造函数函数名和类名相同,而list<T>是类型
			empty_initialize();
		}

		//迭代器区间构造
		template <class InputIterator>
		list(InputIterator first, InputIterator last) {
			empty_initialize();
			while (first != last)
			{
				push_back(*first);
				++first;
				//first++;
			}
		}

		//拷贝构造传统写法
		//list(const list<T>& lt) {
		//	empty_initialize();

		//	for (const auto& e : lt)
		//	{
		//		push_back(e);
		//	}
		//}

		// 拷贝构造的现代写法
		//list(const list& lt) 官方库是这样写的,这是由于在类内类名等价于类型,但不建议自己这样写
		list(const list<T>& lt) {
			empty_initialize();  //初始化头结点,防止交换后tmp野指针不能正常的调用析构
			list<T> tmp(lt.begin(), lt.end());
			swap(tmp);
		}

		//赋值重载传统写法
		//list<T>& operator=(const list<T>& lt) {
		//	if (this != &lt)
		//	{
		//		clear();
		//		for (const auto& e : lt)
		//		{
		//			push_back(e);
		//		}
		//	}
		//	return *this;
		//}

		//赋值重载现代写法
		//list& operator=(list lt)
		list<T>& operator=(list<T> lt) {  //不能加引用,lt是调用拷贝构造生成的
			swap(lt);
			return *this;
		}

		~list() {  //析构
			clear();
			delete _head;
			_head = nullptr;
		}

		void swap(list<T>& lt) {  //交换两个链表,本质上是交换两个链表的头结点
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		size_t size() const {  //增加一个计数的成员,以空间换时间
			return _size;
		}

		bool empty() {  //判空
			return _size == 0;
		}

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

		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 push_front(const T& x) {
			insert(begin(), x);  //复用
		}

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

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

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

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

			++_size;
			return iterator(pos);
		}

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

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

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

			--_size;
			return iterator(next);
		}

	private:
		node* _head;
		size_t _size;
	};
}

 

【C++】list基本接口+手撕 list(详解迭代器),小阳c++专栏,c++,stl

完结撒花~文章来源地址https://www.toymoban.com/news/detail-714050.html

到了这里,关于【C++】list基本接口+手撕 list(详解迭代器)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++初阶:适合新手的手撕list(模拟实现list)

    上次讲了常用的接口:今天就来进行模拟实现啦 list.h头文件:包含类的全部(函数的声明与定义) reverseIterator.h文件:进行反向迭代器的实现 test.cpp源文件:进行调用test函数,测试和完善功能 基本结构: ListNode 结构体: 定义了链表的节点结构,包含了三个成员变量:前驱指针

    2024年02月20日
    浏览(47)
  • 【c++】list迭代器失效问题

    目录 一、list iterator的使用 二、list的迭代器失效         对于list的迭代器的用法,可以将它看做一个指针(实际要更加复杂)来使用,该指针指向list中的一个节点。         【注意】         (1)begin和end为正向迭代器,对迭代器执行++操作,迭代器向后移动         (2)r

    2024年01月23日
    浏览(40)
  • 【C++】详解map和set基本接口及使用

    关联式容器也是用来存储数据的,但与序列式容器不同的是,关联式容器里面存储的是 key, value 结构的键值对,因此**在数据检索时比序列式容器效率更高**。 键值对是用来表示 具有一一对应关系的一种结构 ,该结构中一般只包含两个成员变量 – key 和 value;其中 key 代表键

    2024年02月08日
    浏览(40)
  • 【C++进阶(四)】STL大法--list深度剖析&list迭代器问题探讨

    💓博主CSDN主页:杭电码农-NEO💓   ⏩专栏分类:C++从入门到精通⏪   🚚代码仓库:NEO的学习日记🚚   🌹关注我🫵带你学习C++   🔝🔝 本质重点: 本章重点讲解list的接口函数的熟悉 并且讲解list迭代器失效的特性 最后讲解迭代器的功能分类以及 算法库函数中谁能用谁不能

    2024年02月09日
    浏览(38)
  • C++:模拟实现list及迭代器类模板优化方法

    本篇模拟实现简单的list和一些其他注意的点 如下所示是利用拷贝构造将一个链表中的数据挪动到另外一个链表中,构造两个相同的链表 lt作为形参,传引用可以提高传参的效率,同时应该加上const修饰来保证不会因为不小心修改了形参导致外部的实参也被修改,这样的结果是

    2024年02月13日
    浏览(39)
  • C++:关于模拟实现vector和list中迭代器模块的理解

    本篇是关于 vector 和 list 的模拟实现中,关于迭代器模块的更进一步理解,以及在前文的基础上增加对于反向迭代器的实现和库函数的对比等 本篇是写于前面模拟实现的一段时间后,重新回头看迭代器的实现,尤其是在模板角度对 list 中迭代器封装的部分进行解析,希望可以

    2024年02月07日
    浏览(44)
  • C++之std::list<string>::iterator迭代器应用实例(一百七十九)

    简介: CSDN博客专家,专注Android/Linux系统,分享多mic语音方案、音视频、编解码等技术,与大家一起成长! 优质专栏: Audio工程师进阶系列 【 原创干货持续更新中…… 】🚀 人生格言: 人生从来没有捷径,只有行动才是治疗恐惧和懒惰的唯一良药. 更多原创,欢迎关注:An

    2024年02月12日
    浏览(57)
  • 【C++】反向迭代器的模拟实现通用(可运用于vector,string,list等模拟容器)

    🌏博客主页: 主页 🔖系列专栏: C++ ❤️感谢大家点赞👍收藏⭐评论✍️ 😍期待与大家一起进步! 我们要写出一个通用的反向迭代器模拟而且在保证代码简介不繁琐的的情况下,一定程度上使用我们自己模拟的已经封装好的iterator迭代器可以简化许多步骤,首先我们要知

    2024年02月14日
    浏览(54)
  • 手撕学生管理系统超详解——【c++】

    题目要求:设计一个学生成绩管理程序,实现按班级完成对学生成绩信息的录入和修改,并用文件保存。 实现按班级输出学生的成绩单;实现按学号和姓名进行查询,按平均成绩进行排序功能。 问题描述 该程序的目标是提供一个简单且易于使用的学生成绩管理工具,以便教育

    2024年02月11日
    浏览(32)
  • C++迭代器(STL迭代器)iterator详解

    要访问顺序容器和关联容器中的元素,需要通过“迭代器(iterator)”进行。迭代器是一个变量,相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素,通过迭代器就可以读写它指向的元素。从这一点上看,迭代器和指针类似。 迭代器按照定义方式分

    2024年02月03日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包