List介绍
List是带头结点的双向链表
-
list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
-
list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
-
与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
-
与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
List的使用
构造函数+五种拷贝构造函数
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> first; //空list
list<int> second(4, 100); //初始化4个结点并且值为100的 双向链表
list<int> third(second.begin(), second.end()); //迭代器区间初始化
list<int> fourth(third); //调用拷贝构造函数
int myints[] = { 16,2,77,29 };
list<int> fifth(myints, myints + sizeof(myints) / sizeof(int)); //使用一段连续的空间构造list
cout << "The contents of fifth are: ";
for (list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
cout << *it << " ";
cout << endl;
return 0;
}
迭代器 iterator
// 所有迭代器都是左闭右开
begin() // 返回第一个元素的迭代器
end() //返回最后一个元素下一个位置的迭代器的
front 和 back
front:获取list的第一个结点值的引用
back:获取list最后一个结点值的引用
常用接口：
push_back() 尾插数据
push_front() 头插数据
pop_back()删除list中最后一个元素
pop_front()删除list中第一个元素
insert()在pos位置插入值为val的结点
erase()删除list中pos位置的元素
swap()交换两个链表的值（底层就是交换一下头结点的指向即可）
list的迭代器失效
大家可将迭代器暂时理解成类似于指针，只不过底层是将指针封装了一个单独的类。迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。
为什么只有删除的时候当前结点的迭代器会失效？
答：我们知道list的带头结点双良链表，它的每一个结点是堆上开辟的，因此地址是不连续的。当我们在进行插入的时候，仅仅只是将一个结点链接在两个结点中间，不会改变迭代器的指向。但是我们在删除此节点的时候，仅仅只是此节点的迭代器失效，因为list中每个节点都是相互独立开辟的，并不是向vector那种地址连续的容器
因此erase()执行完之后会返回删除结点的下一个结点的迭代器
List模拟实现
- 我们知道List是带头结点的双向链表，作为链表那么肯定需要结点结构，有了结点结构才可以将结点串联起来构成双向链表
//结点模板——结构
template <class T>
struct list_node
{
T _data; //存储结点的值
list_node<T>* _prev; //前驱结点指针
list_node<T>* _next; //后继结点指针
// list_node(const T& val = 0) 但是这里T不一定是int，所以需要给一个匿名对象
list_node(const T& val = T())
:_data(val)
,_next(nullptr)
,_prev(nullptr)
{}
};
注意：
这里不能直接写成 const T& val = 0；因为这样就直接写死了，默认这个结点只能存储int类型，我们可以使用匿名对象创建初始值
- 有了结点结构，我们就可以构建List类了
为了方便并且仿照STL源码，这里我们将节点结构typedef一下
template <class T>
class list
{
//将结构模板重命名为 Node 仿照源码的标准
typedef list_node<T> Node;
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
typedef _list_Reverse_iterator<iterator, T&, T*> Reverse_iterator;
typedef _list_Reverse_iterator<const_iterator, const T&, const T*> Reverse_const_iterator;
public:
list()
{
empty_init();
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
list(const list<T>& ls) //l2(l1);
{
empty_init();
for (auto e : ls)
{
push_back(e);
}
}
void empty_init() //创建头结点，让头结点具有双向链表的结构
{
_head = new Node; //需要使用全缺省的参数了列表，不然没有默认构造函数会报错
_head->_next = _head;
_head->_prev = _head;
}
private:
Node* _head;
};
}
当我们在主函数中写List<int> l1-》首先会调用List模板类的默认构造函数-》默认构造函数会调用empty_init()函数-》empty_init函数是创建在堆空间上面申请一个结点空间赋值给（结点结构类型的）_head指针-》头结点创建完成之后完善双向链表的性质
- 接下来就需要插入数据，打印数据：
void push_back(const T& val) //创建一个结点结构-》尾链接结点
{
Node* tail = _head->_prev;
Node* newnode = new Node(val); //调用结点结构类的构造函数
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;
}
完成迭代器就可以打印链表了
思考：
这里的迭代器构建能否想vector一样使用原生指针直接遍历？
答：不可以！list是链表，每一个结点都是相互独立的，不可以直接使用指针进行遍历和解引用；
再说指针指向的每一个结点是一个结构，也不可以直接（解引用指针）获得该节点里面的val
那么迭代器需要怎样构建？
答：我们迭代器的底层虽然不是指针，但是我们可以将它封装成指针。
我们可以将迭代器封装成一个类，这个类里面重载了指针的许多操作：++，--，*，->，==，!= 等
//这里模板传三个参数的原因是：根据不同的参数模板实例化成不同的功能，
//这样就可以不同的需求使用同一个模板，简化了代码的编写
//Ref代表引用 Ptr代表指针
template <class T, class Ref, class Ptr>
struct __list_iterator
{
typedef __list_iterator<T, Ref, Ptr> self;
//成员变量
list_node<T>* _node;
//构造函数
__list_iterator(list_node<T>* node = nullptr) //使用链表结点的指针（地址）对迭代器对象进行初始化
: _node(node)
{}
//前置++
self& operator++()
{
//这里不能返回一个指针，因为迭代器的++，返回的是一个迭代器的对象，返回值可能后面还要使用，如果返回一个指针，那么后面使用的时候不能将迭代器与指针进行比较
//不可以： return _node->_next; 这里返回的是一个链表结点的地址
_node = _node->_next;
return *this; //返回的是迭代器对象
}
//后置++ 纠结的地方在于是否需要写 拷贝构造
//首先不可以返回引用，因为拷贝的局部变量处理作用域就销毁了
self operator++(int)
{
self temp(*this); //调用拷贝构造->不用深拷贝：迭代器的底层就是指针的封装，所以只需要浅拷贝一下当前迭代器对象的成员变量（当前结点的地址）
//因为迭代器的成员变量就是一个指针（内置类型）
_node = _node->_next;
return temp;
}
//前置--
self& operator--()
{
_node = _node->_prev;
return *this;
}
//后置--
self operator--(int)
{
self temp(*this);
_node = _node->_prev;
return temp;
}
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 iterator, class Ref, class Ptr>
struct _list_Reverse_iterator
{
typedef _list_Reverse_iterator<iterator, Ref, Ptr> self;
iterator _cur; //cur是正向迭代器类型的对象
//构造函数
_list_Reverse_iterator(iterator val = iterator())
:_cur(val)
{}
//反向迭代器的++ 就是正向迭代器的--
self& operator++()
{
_cur--;
return *this;
}
self operator++(int) //后置++
{
self temp(*this);
_cur--;
return temp;
}
//反向迭代器的-- 就是正向迭代器的++
self& operator--()
{
_cur++;
return *this;
}
self operator--(int) //后置--
{
self temp(*this);
_cur++;
return temp;
}
Ref operator*()
{
//iterator temp = _cur;
//--temp;
//return *temp;
return *_cur;
}
bool operator!=(const self& it)
{
return _cur != it._cur;
}
bool operator== (const self& it)
{
return _cur == it._cur;
}
};
这里就是使用多参数模板的好处，根据传过去的参数类型，我们就可以将const迭代器和普通迭代器进行一个模板的使用，不需要我们在写一个const迭代器的模板类
完整代码+细细品味
.h文件
#pragma once
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
using namespace std;
namespace zxy_list
{
//结点模板——结构
template <class T>
struct list_node
{
T _data;
list_node<T>* _prev;
list_node<T>* _next;
// list_node(const T& val = 0) 但是这里T不一定是int，所以需要给一个匿名对象
list_node(const T& val = T())
:_data(val)
,_next(nullptr)
,_prev(nullptr)
{}
};
//如果这里的迭代器还是之前的原生指针 那么*iterator 不能取到结点里面的值，因为结点是一个结构，
//同样iterator++不可以使结点后移一位
//list的迭代器是将结点指针封装成一个迭代器对象，迭代器对象里面包含的有运算符重载的访问接口，可以让迭代器变得像指针一样使用
template <class T, class Ref, class Ptr>
struct __list_iterator
{
typedef __list_iterator<T, Ref, Ptr> self;
//成员变量
list_node<T>* _node;
//构造函数
__list_iterator(list_node<T>* node = nullptr) //使用链表结点的指针（地址）对迭代器对象进行初始化
: _node(node)
{}
//前置++
self& operator++()
{
//这里不能返回一个指针，因为迭代器的++，返回的是一个迭代器的对象，返回值可能后面还要使用，如果返回一个指针，那么后面使用的时候不能将迭代器与指针进行比较
//不可以： return _node->_next; 这里返回的是一个链表结点的地址
_node = _node->_next;
return *this; //返回的是迭代器对象
}
//后置++ 纠结的地方在于是否需要写 拷贝构造
//首先不可以返回引用，因为拷贝的局部变量处理作用域就销毁了
self operator++(int)
{
self temp(*this); //调用拷贝构造->不用深拷贝：迭代器的底层就是指针的封装，所以只需要浅拷贝一下当前迭代器对象的成员变量（当前结点的地址）
//因为迭代器的成员变量就是一个指针（内置类型）
_node = _node->_next;
return temp;
}
//前置--
self& operator--()
{
_node = _node->_prev;
return *this;
}
//后置--
self operator--(int)
{
self temp(*this);
_node = _node->_prev;
return temp;
}
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 iterator, class Ref, class Ptr>
struct _list_Reverse_iterator
{
typedef _list_Reverse_iterator<iterator, Ref, Ptr> self;
iterator _cur; //cur是正向迭代器类型的对象
//构造函数
_list_Reverse_iterator(iterator val = iterator())
:_cur(val)
{}
//反向迭代器的++ 就是正向迭代器的--
self& operator++()
{
_cur--;
return *this;
}
self operator++(int) //后置++
{
self temp(*this);
_cur--;
return temp;
}
//反向迭代器的-- 就是正向迭代器的++
self& operator--()
{
_cur++;
return *this;
}
self operator--(int) //后置--
{
self temp(*this);
_cur++;
return temp;
}
Ref operator*()
{
//iterator temp = _cur;
//--temp;
//return *temp;
return *_cur;
}
bool operator!=(const self& it)
{
return _cur != it._cur;
}
bool operator== (const self& it)
{
return _cur == it._cur;
}
};
/*
template <class T>
//const_iterator
struct __list_const_iterator
{
//成员变量
list_node<T>* _node;
//构造函数
__list_const_iterator(list_node<T>* node = nullptr) //使用链表结点的指针（地址）对迭代器对象进行初始化
: _node(node)
{}
//前置++
__list_const_iterator<T>& operator++()
{
//这里不能返回一个指针，因为迭代器的++，返回的是一个迭代器的对象，返回值可能后面还要使用，如果返回一个指针，那么后面使用的时候不能将迭代器与指针进行比较
//不可以： return _node->_next; 这里返回的是一个链表结点的地址
_node = _node->_next;
return *this; //返回的是迭代器对象
}
//后置++ 纠结的地方在于是否需要写 拷贝构造
//首先不可以返回引用，因为拷贝的局部变量处理作用域就销毁了
__list_const_iterator<T> operator++(int)
{
__list_const_iterator<T> temp(*this); //调用拷贝构造->不用深拷贝：迭代器的底层就是指针的封装，所以只需要浅拷贝一下当前迭代器对象的成员变量（当前结点的地址）
//因为迭代器的成员变量就是一个指针（内置类型）
_node = _node->_next;
return temp;
}
//前置--
__list_const_iterator<T>& operator--()
{
_node = _node->_prev;
return *this;
}
//后置--
__list_const_iterator<T> operator--(int)
{
__list_iterator<T> temp(*this);
_node = _node->_prev;
return temp;
}
//const_iterator是 只读迭代器
const T& operator*()
{
return _node->_data;
}
bool operator!= (const __list_const_iterator<T>& it)
{
return _node != it._node;
}
bool operator== (const __list_const_iterator& it)
{
return _node == it._node;
}
};
*/
template <class T>
class list
{
//将结构模板重命名为 Node 仿照源码的标准
typedef list_node<T> Node;
public:
//根据传递参数的不同，模板实例化出不同的对象 -》但是类模板还是同一个 -》都是__list_iterator
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
typedef _list_Reverse_iterator<iterator, T&, T*> Reverse_iterator;
typedef _list_Reverse_iterator<const_iterator, const T&, const T*> Reverse_const_iterator;
list()
{
empty_init();
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
//const list<T>& ls const对象需要调用cosnt迭代器
list(const list<T>& ls) //l2(l1);
{
//先为l2对象创建一个头结点 this指针
empty_init();
//方法一： 遍历原来的链表，每一个创建一个结点尾插
//方法二： 使用迭代器遍历，直接使用push_back()接口
for (auto e : ls)
{
push_back(e);
}
}
Reverse_iterator rbegin()
{
return end();
}
Reverse_iterator rend()
{
return begin();
}
const_iterator begin() const
{
return const_iterator(_head->_next); //匿名对象
}
//迭代器的范围永远都是左闭右开
const_iterator end() const
{
return const_iterator(_head); //匿名对象
}
iterator begin()
{
return iterator(_head->_next); //匿名对象
}
//迭代器的范围永远都是左闭右开
iterator end()
{
return iterator(_head); //匿名对象
}
void empty_init() //创建头结点，让头结点具有双向链表的结构
{
_head = new Node; //需要使用全缺省的参数了列表，不然没有默认构造函数会报错
_head->_next = _head;
_head->_prev = _head;
}
void push_back(const T& val)
{
/*
Node* tail = _head->_prev;
Node* newnode = new Node(val);
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;
*/
//直接复用insert接口
insert(end(), val);
}
void push_front(const T& val)
{
insert(begin(), val);
}
void pops_front()
{
erase(begin());
}
void pops_back()
{
erase(end()--);
}
//list迭代器在insert操作之后迭代器不会失效
iterator insert(iterator pos, const T& val)
{
Node* cur = pos._node;
Node* newnode = new Node(val);
newnode->_prev = cur->_prev;
cur->_prev->_next = newnode;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode); //返回新插入元素的迭代器
}
//erase操作之后的迭代器失效，因为pos位置的结点删除了
iterator erase(iterator pos)
{
Node* cur = pos._node; //pos位置的结点
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
return iterator(next); //返回删除结点的下一个结点的迭代器
}
//因为erase删除时候该位置的迭代器就失效了，所以我们就使用erase的返回值进行迭代器的后移
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it);
}
}
//赋值运算符重载的传统写法：使用尾插接口，一个个的插数据
//list<int>& operator=(const list<int>& ls)
//{
// if (this != &ls)
// {
// clear(); //先清楚原本链表的内容
// for (auto e : ls)
// {
// push_back(e);
// }
// }
//}
//赋值运算符重载的新颖写法：传参调用拷贝构造函数（深拷贝）
list< int>& operator=(list<int> ls)
{
//ls 就是实参的深拷贝
//只需要两个对象里面的成员变量即可
std::swap(_head, ls._head);
return *this;
}
private:
Node* _head;
};
}
.cpp文件
#include "list.h"
using namespace std;
//void test1()
//{
// zxy_list::list<int> l1;
// l1.push_back(1);
// l1.push_back(2);
// l1.push_back(3);
// l1.push_back(4);
// l1.push_back(5);
// l1.push_front(0);
// l1.push_front(-1);
// l1.push_front(-2);
// l1.push_front(-3);
//
// zxy_list::list<int> l2;
// l2.push_back(4);
// l2.push_back(23);
// l2.push_back(3);
// l2.push_back(64);
// l2.push_back(57);
// l2.push_front(32);
// l2.push_front(-31);
// l2.push_front(-23);
// l2.push_front(-32);
//
// cout << "l1: ";
// for (auto e : l1)
// {
// cout << e << " ";
// }
// cout << endl;
//
// cout << "l2: ";
// for (auto e : l2)
// {
// cout << e << " ";
// }
// cout << endl;
//
// l2 = l1;
// cout << "l2: ";
// for (auto e : l2)
// {
// cout << e << " ";
// }
// cout << endl;
//}
template <class Container> //Container是一个模板-》类模板
void PrintContainer(const Container& con)
{
//Container是一个类模板，这个类有子类，前面加一个typename就是告诉编译器Container::const_iterator是一个类型
//Container是没有实例化的类模板，编译器无法区分Container::const_iterator是静态成员变量 还是 内嵌类型
//添加typename是等类模板实例化之后，再去类里面去取const_iterator
typename Container::const_iterator it = con.begin();
while (it != con.end())
{
cout << *it << " "; //使用Container模板的时候，注意这个容器需要重载 * 运算符-》STL容器本身就是有重载解引用运算符
it++;
}
cout << endl;
}
void test3()
{
//vector<string> v1;
//v1.push_back("111111");
//v1.push_back("111111");
//v1.push_back("111111");
//v1.push_back("111111");
//v1.push_back("111111");
//v1.push_back("111111");
//
//zxy_list::list<int> l1;
//l1.push_back(0);
//l1.push_back(1);
//l1.push_back(2);
//l1.push_back(3);
//l1.push_back(4);
//PrintContainer(l1);
zxy_list::list<int> l1;
l1.push_back(1);
l1.push_back(2);
l1.push_back(3);
l1.push_back(4);
l1.push_back(5);
l1.push_front(0);
l1.push_front(-1);
l1.push_front(-2);
l1.push_front(-3);
zxy_list::list<int>::Reverse_iterator it = l1.rbegin();
while (it != l1.rend())
{
cout << *it << " ";
++it;
}
cout << endl;
zxy_list::list<int>::iterator it1 = l1.begin();
while (it1 != l1.end())
{
cout << *it1 << " ";
++it1;
}
cout << endl;
}
//void test2()
//{
// zxy_list::list<int> l1;
// l1.push_back(0);
// l1.push_back(1);
// l1.push_back(2);
// l1.push_back(3);
// l1.push_back(4);
// zxy_list::list<int> l2(l1); //调用拷贝构造 -》需要有const迭代器-》使用一个类模板实例化不同的迭代器对象
// Print(l2);
//
//}
//
int main()
{
test3();
// //zxy_list::list<int> l1;
// //l1.push_back(1);
// //l1.push_back(2);
// //l1.push_back(3);
// //l1.push_back(4);
// //l1.push_back(5);
// //l1.push_front(0);
// //l1.push_front(-1);
// //l1.push_front(-2);
// //l1.push_front(-3);
//
//
// 封装 屏蔽了底层的差异
// //zxy_list::list<int>::iterator it = l1.begin();
// //while (it != l1.end())
// //{
// // cout << *it << " ";
// // ++it; //前置++
// //}
// //cout << endl;
//
//
// 范围for的底层还是迭代器，因为e变量的值就是迭代器解引用的值
// //for (auto e : l1)
// //{
// // cout << e << " ";
// //}
// //cout << endl;
// test2();
return 0;
}
1389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
