Stl中list容器解析--C++

目录

前言

list功能一览表

list结构框架

list迭代器

基本框架

* 重载

-> 重载

++ 重载

-- 重载

！= 重载

list功能模拟

最初模板

begin()

end()

insert()

erase()

push_back()

push_front()

pop_back()

pop_front()

clear()

swap()

= 重载

无参构造

区间构造

拷贝构造

析构

小结

---

前言

list容器与前面的vector容器很大的区别在与list是以链表为基本结构进行数据的存储的：即空间不连续存储。因此list容器的学习重点在于迭代器的理解和掌握。

list功能一览表

list结构框架

template<class T>
struct list_node   //节点结构体：双链表
{
	list_node<T>* _next;
	list_node<T>* _prev;
	T _data;
	list_node(const T& val=T())  //构造函数
		:_next(nullptr)
		,_prev(nullptr)
		,_data(val)
	{}
};

template<class T>
class list
{
	typedef list_node<T> Node;
private:
	Node* _head;  //成员变量只有头节点
public:
    /.../
}

从上面的的结构可以看出，如果我们对于迭代器做出各种操作例如 * 、-> 、++ 、-- 等时，是无法直接像内置类型数据那样直接正常使用的，因此我们要想达到同样的效果，就要去自己实现这些操作符的重载。

list迭代器

基本框架

template<class T, class Ref, class Ptr> //传三个模板参数是为了将const迭代器与
struct __list_iterator                  //非const迭代器糅合在一起
{
	typedef list_node<T> Node;
	typedef __list_iterator<T, Ref, Ptr> self;
	Node* _node;                         //迭代器成员还是只有一个节点_node
	__list_iterator(Node* node)          //构造函数
		:_node(node)
	{}
};

* 重载

Ref operator*()   //Ref后面可以替换成T& 或 const T&
{
	return _node->_data;
}

-> 重载

Ptr operator->()   //Ptr后面可以替换成T* 或 const T*
{
	return &_node->_data;
}

++ 重载

使迭代器指向下一个节点

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


self& operator++(int) //后置++，用多写一个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& it)
{
	return _node != it._node;
}

list功能模拟

最初模板

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

begin()

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

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

end()

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

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

insert()

iterator insert(iterator pos, const T& val)
{
	Node* newnode = new Node(val);//创建新节点
	Node* cur = pos._node;        //当前节点
	Node* prev = cur->_prev;      //前一节点
	//  prev  newnode  cur  最终三个节点的位置
    prev->_next = newnode; 
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;
	
    return iterator(newnode);
}

erase()

iterator erase(iterator pos)
{
	assert(pos != end());//不能删除哨兵位节点
	Node* cur = pos._node;//当前节点
	Node* prev = cur->_prev;//前一节点
	Node* next = cur->_next;//后一节点
    //prev   next   最终节点位置
	prev->_next = next;
	next->_prev = prev;
    //删除当前节点
	delete cur;
    //返回删除位置的下一位置的迭代器
	return iterator(next);
}

push_back()

void push_back(const T& val)
{
	insert(end(), val);//复用insert()函数
}

push_front()

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

pop_back()

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

pop_front()

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

clear()

函数功能：清除当前list内的数据

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

swap()

函数功能：交换list内容

void swap(list<T>& lt)
{
	std::swap(_head, lt._head);//交换头节点即可
}

= 重载

list<T>& operator=(list<T> lt)
{
	swap(lt);//由于lt是深度拷贝构造而来，因此直接调用swap函数对原参数没影响
	return *this;
}

无参构造

void empty_init()//创建哨兵位头节点
{
	_head = new Node();
	_head->_next = _head;
	_head->_prev = _head;
}
list()
{
	empty_init();
}

区间构造

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

拷贝构造

list(const list<T>& lt)
{
	empty_init();
	list<T> tmp(lt.begin(), lt.end());//先利用区间构造tmp再与*this进行交换
	swap(tmp);
}

析构

~list()
{
	clear();
	delete _head;//最后的头节点也删除
	_head = nullptr;
}

小结

list容器的特点就在于迭代器，其他的内容基本都和其他容器的核心思想相同。