目录
前提：list 的基本介绍
⭕list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
⭕ list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
⭕ list与 forward_list 非常相似：最主要的不同在于 forward_list 是单链表，只能朝前迭代，已让其更简单高效。
⭕与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
⭕ 与其他序列式容器相比，list 和 forward_list 最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
一、构造/析构/拷贝/赋值
我们已经知道 list 的底层逻辑是双向链表结构，所以 list 定义模版参数为T，并且节点结构体中有两个指针（_next、_prev)。使用 struct 类来定义节点，是为了便于 list 类访问，因为 struct 不对成员的访问进行限制。
1、构造函数
链表是由一个个的结点连接而成，所以第一步先构造出一个结点类。这个结点包含前后指针和对应的数据。对这个节点也需要进行初始化。
2、析构函数
可以调用 clear 函数，然后把 head 删除
3、拷贝构造函数
4、赋值
二、修改操作
1、push_back
功能：尾插一个节点。
步骤：利用 head 将最后一个节点记为 tail；
创建一个新的节点 newnode
更新节点的 next 和 prev
2、insert
功能：在 pos 处插入一个新的节点。
步骤：记录 pos 和 pos 前一个位置的值。
新建一个新的节点。
更新节点的 prev 和 next。
insert 也可以帮助尾插和头插
3、erase
功能：删除 pos 处的节点。
要注意迭代器失效的问题。具体内容可以参考【迭代器失效】
erase 也可以帮助尾删和头删
4、clear
功能：清除所有节点，但是保留头结点。
三、list iterator 的使用
list 容器的迭代器不再是像 string 或者 vector 那样的原生指针了，首先因为 list 的各个节点在物理空间上不是连续的，我们不能直接对节点的地址进行 ++ / - - 得到其前、后位置的迭代器；并且我们的数据是保存在节点之中的，不能把节点的指针解引用直接得到里面数据。这些操作我们可以通过封装节点的地址形成一个迭代器类，然后重载这个类的 operator* 和 operator++ 等运算符及其他一系列方法，最终可以向操作指针一样去操作迭代器。
1、operator *
功能：获取该迭代器指向位置的值
2、operator ++
功能：迭代器向后移动一位。返回值依旧是迭代器
3、operator --
功能：迭代器向前移动一位
4、operator ！=
功能：判断节点的指针是否不等。
5、operator ==
功能：判断节点的指针是否相等。
6、begin( ) / end( )
begin () 和 end() 的 const 版本需要借助 const 迭代器。
四、迭代器模板参数
1、const_iterator (重要)
在上述 begin 和 end 的函数中，const 修饰的是迭代器本身，并不是迭代器指向的内容，导致迭代器所指向的内容依旧可以修改。但是我们使用 const 修饰时，希望达成的目标是不能改变迭代器所指向的内容，迭代器自己可以修改。所以重定义一个 const 迭代器模板。
虽然重新定义一个 const 版本的迭代器可以使代码正常运行，但是代码显得很冗余，只有解引用处会不一样。为了解决这个问题，我们可以在定义迭代器模板时增加一个参数，模板参数不同，就可以实例化为两个不同的类，这样当传 const 修饰的值时就会调用 const 迭代器。
2、operator->（重要）
功能：迭代器是模拟指针的行为，通过->来访问迭代器所指向的内容。
这里我们可以像 const 迭代器一样，增加一个类参数来应对const迭代器而设计的，只不过这个模板参数控制的是箭头运算符重载函数的返回值类型，因为const迭代器使用 ->运算符后，返回的应该是const T类型，而正常迭代器使用 ->运算符后，返回的应该是T。
【补充】为什么要重载 ->
我们知道想调用成员可以使用 "." 和 "->"。下面箭头运算符其实是省略了一个->，it->_data 首先调用重载函数 it.operator->(). 返回的T* ,那 T* 是怎么访问的 _data 的呢？这里明显少了一个箭头，正确的写法应该是这样it->->_data ，但编译器为了简洁好看将一个箭头省略了。
五、完整代码
#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include<assert.h>
#include<iostream>
namespace zhou
{
template<class T>
struct List_node
{
//List_node类名；List_node<T>类型
List_node<T>* _next;//指向后一个节点
List_node<T>* _prev;//指向前一个节点
T _data;//存储的数据
//构造函数
//T()
List_node(const T& x = T())
:_next(nullptr)
, _prev(nullptr)
,_data(x)
{}
};
//迭代器的类
template<class T,class Ref,class Ptr>
struct _list_iterator
{
typedef List_node<T> node;
typedef _list_iterator<T,Ref,Ptr> self;
node* _node;
//构造函数
_list_iterator(node* n)
:_node(n)
{}
//解引用
Ref operator*()
{
return _node->_data;
}
Ptr operator ->()
{
return &_node->_data;
}
//前置++
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& s)
{
return _node != s._node;
}
bool operator==(const self& s)
{
return _node == s._node;
}
};
/*template<class T>
struct __list_const_iterator
{
typedef List_node<T> node;
typedef __list_const_iterator<T> self;
node* _node;
__list_const_iterator(node* n)
:_node(n)
{}
const T& operator*()
{
return _node->_data;
}
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& s)
{
return _node != s._node;
}
bool operator==(const self& s)
{
return _node == s._node;
}
};*/
template<class T>
class list
{
typedef List_node<T> node;
public:
typedef _list_iterator<T,T&,T*> iterator;
typedef _list_iterator<T,const T&,const T*> const_iterator;
//typedef __list_const_iterator<T> const_iterator;
void empty_init()
{
_head = new node;
//给头结点创造出一个空间
_head->_next = _head;
_head->_prev = _head;
//让其头和尾指向自己，形成一个循环列表
}
list()
{
empty_init();
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
//方法一
//list(const list<T>& it)
//{
// //必须要初始化
// empty_init();//将初始化写成一个函数
// for (auto e : it)
// {
// push_back(e);
// }
//}
//方法二
void swap(list<T>& tmp)
{
std::swap(_head, tmp._head);
}
list(const list<T>& lt)
{
empty_init();
list<T> tmp(lt.begin(), lt.end());
swap(tmp);
}
//赋值
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}
iterator begin()
{
/*iterator it(_head->_next);
return it;*/
return (_head->_next);
}
iterator end()
{
return (_head);
}
const_iterator begin() const
{
return const_iterator(_head->_next);
}
const_iterator end() const
{
return const_iterator(_head);
}
void push_back(const T& x)
{
/*node* tail = _head->_prev;
node* newnode = new node(x);
newnode->_next = _head;
_head->_prev = newnode;
tail->_next = newnode;
newnode->_prev = tail;*/
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
void insert(iterator pos, const T& x)
{
node* cur = pos._node;
node* prev = cur->_prev;
node* new_node = new node(x);
prev->_next = new_node;
new_node->_prev = prev;
new_node->_next = cur;
cur->_prev = new_node;
}
iterator erase(iterator pos)
{
assert(pos != end());
node* prev = pos._node->_prev;
node* next = pos._node->_next;
prev->_next = next;
next->_prev = prev;
delete pos._node;
return iterator(next);
}
void clear()
{
iterator it = begin();
while (it != end())
{
//it = erase(it);
erase(it++);//erase迭代器返回删除的后一个
}
}
private:
node* _head;
};
void test_list1()
{
list<int> It;
It.push_back(1);
It.push_back(2);
It.push_back(3);
It.push_back(4);
/*list<int>::iterator It = it.begin();
while (It != it.end())
{
cout << (*It) << " ";
It++;
}*/
list<int>::iterator it = It.begin();
while (it != It.end())
{
(*it) *= 2;//修改数据
cout << *it << " ";//读取数据
++it;
}
cout << endl;
}
struct AA
{
int _a1;
int _a2;
AA(int a1 = 0, int a2 = 0)
:_a1(a1)
,_a2(a2)
{}
};
void test_AA()
{
list<AA> lt;
lt.push_back(AA(1, 1));
lt.push_back(AA(2, 2));
lt.push_back(AA(3, 3));
lt.push_back(AA(4, 4));
list<AA>::iterator it = lt.begin();
while (it != lt.end())
{
cout << (*it)._a1 << ":" << (*it)._a2 << endl;//不习惯使用先解引用后.对象调用成员
cout << it->_a1 << ":" << it->_a2 << endl;//->调用迭代器所指向的内容，但是需要重载->
cout << it.operator->()->_a1 << ":" << it.operator->()->_a1 << endl;//但是编译器会自动省略一个->
it++;
}
}
}
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
