C++ list讲解
目录
一、list的介绍以及使用
1.1 list的介绍
1.2 list的使用
1.2.1 list的构造
1.2.2 list iterator的使用
1.2.3 list capacity
1.2.4 list element access
1.2.5 list modifiers
1.2.6 list的迭代器失效
二、list的模拟实现
2.1 模拟实现list
一、list的介绍以及使用
1.1 list的介绍
1、list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代（所谓的常熟范围内，就是时间复杂度为O(1)）
2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
这一段关于list的特性，需要能够与vector对比理解。
1.2 list的使用
1.2.1 list的构造
| 构造函数（ (constructor)） | 接口说明 |
| list() | 构造空的list |
| list (size_type n, const value_type& val = value_type()) | 构造的list中包含n个值为val的元素 |
| list (const list& x) | 拷贝构造函数 |
| list (InputIterator first, InputIterator last) | 用[first, last)区间中的元素构造list |
#include
#include
using namespace std;
int main()
{
std::list l1; // 构造空的l1
std::list l2(4, 100); // l2中放4个值为100的元素
std::list l3(l2.begin(), l2.end()); // 用l2的[begin(), end()）左闭右开的区间构造l3
std::list l4(l3); // 用l3拷贝构造l4
// 以数组为迭代器区间构造l5
int array[] = { 16,2,77,29 };
std::list l5(array, array + sizeof(array) / sizeof(int));
// 用迭代器方式打印l5中的元素
for (std::list::iterator it = l5.begin(); it != l5.end(); it++)
std::cout << *it << " ";
std::cout << endl;
// C++11范围for的方式遍历
for (auto& e : l5)
{
std::cout << e << " ";
}
std::cout << endl;
return 0;
}
1.2.2 list iterator的使用
| 函数声明 | 接口说明 |
| begin + end |
返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器 |
| rbegin + rend |
返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置 |
注意：
1、begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2、rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动
#include
#include
using namespace std;
void print_list(const list& l)
{
// 注意这里调用的是list的 begin() const，返回list的const_iterator对象
for (list::const_iterator it = l.begin(); it != l.end(); ++it)
{
cout << *it << " ";
// *it = 10; 编译不通过
}
cout << endl;
}
int main()
{
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list l(array, array + sizeof(array) / sizeof(array[0]));
// 使用正向迭代器正向list中的元素
for (list::iterator it = l.begin(); it != l.end(); ++it)
{
cout << *it << " ";
}
cout << endl;
// 使用反向迭代器逆向打印list中的元素
for (list::reverse_iterator it = l.rbegin(); it != l.rend(); ++it)
{
cout << *it << " ";
}
cout << endl;
return 0;
}
1.2.3 list capacity
| 函数声明 | 接口说明 |
| empty | 检测list是否为空，是返回true，否则返回false |
| size | 返回list中有效节点的个数 |
1.2.4 list element access
| 函数声明 | 接口说明 |
| front | 返回list的第一个节点中值的引用 |
| back | 返回list的最后一个节点中值的引用 |
1.2.5 list modifiers
| 函数声明 | 接口说明 |
| 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.2.6 list的迭代器失效
前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响
#include
#include
using namespace std;
void TestListIterator1()
{
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list l(array, array + sizeof(array) / sizeof(array[0]));
auto it = l.begin();
while (it != l.end())
{
// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋值
l.erase(it);
++it;
}
}
// 改正
void TestListIterator()
{
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list l(array, array + sizeof(array) / sizeof(array[0]));
auto it = l.begin();
while (it != l.end())
{
l.erase(it++); // it = l.erase(it);
}
}
二、list的模拟实现
2.1 模拟实现list
这是本章的重中之重。
#include
#include
using std::cout;
using std::endl;
namespace zjx
{
// List的节点类
template
struct ListNode
{
ListNode(const T& val = T())
:_pPre(nullptr),
_pNext(nullptr),
_val(val)
{
}
ListNode* _pPre;
ListNode* _pNext;
T _val;
};
//List的迭代器类
template
struct ListIterator
{
typedef ListNode* PNode;
typedef ListIterator Self;
public:
ListIterator(PNode pNode = nullptr)
{
_pNode = pNode;
}
//ListIterator(const Self& l);
Ref operator*()
{
return _pNode->_val;
}
Ptr operator->()
{
return &_pNode->_val;
}
Self& operator++()
{
_pNode = _pNode->_pNext;
return *this;
}
Self operator++(int)
{
Self tmp(*this);
_pNode = _pNode->_pNext;
return tmp;
}
Self& operator--()
{
_pNode = _pNode->_pPre;
return *this;
}
Self& operator--(int)
{
Self tmp(*this);
_pNode = _pNode->_pPre;
return tmp;
}
bool operator!=(const Self& l)
{
return _pNode != l._pNode;
}
bool operator==(const Self& l)
{
return _pNode == l._pNode;
}
public:
PNode _pNode;
};
//list类
template
class list
{
typedef ListNode Node;
typedef Node* PNode;
public:
typedef ListIterator iterator;
typedef ListIterator const_iterator;
public:
// List的构造
list()
{
_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
//构造函数
list(int n, const T& value = T())
{
_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
for (int i = 0; i < n; i++)
{
push_back(value);
}
}
template
list(Iterator first, Iterator last)
{
_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
while (first != last)
{
push_back(*first);
first++;
}
}
//拷贝构造函数
list(const list& l)
{
//用迭代器先构造出来一个
list tmp(l.begin(), l.end());
_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
std::swap(_pHead, tmp._pHead);
}
list& operator=(list l)
{
std::swap(_pHead, l._pHead);
return *this;
}
~list()
{
clear();
delete _pHead;
_pHead = nullptr;
}
//List Iterator
iterator begin()
{
return iterator(_pHead->_pNext);
}
iterator end()
{
return iterator(_pHead);
}
const_iterator begin() const
{
return const_iterator(_pHead->_pNext);
}
const_iterator end() const
{
return const_iterator(_pHead);
}
// List Capacity
size_t size()const//这个函数右边的const是用来限定this指针的。原本的this指针，不可以改变指向，可以改变所知的内容。
//但若要对所指向的内容加以限定的话，那就在函数的右边加上const，表示此函数的隐藏的参数，也就是this指针，被加以const限定。
{
size_t count = 0;
const_iterator cur = begin();
while (cur != end())
{
count++;
cur++;
}
return count;
}
//list为空返回1，否则返回0
bool empty()const
{
return size() == 0;
}
// List Access
T& front()
{
return begin()._pNode->_val;
}
const T& front()const
{
return begin()._pNode->_val;
}
T& back()
{
return _pHead->_pPre->_val;
}
const T& back()const
{
return _pHead->_pPre->_val;
}
// List Modify
//void push_back(const T& val)
//{
// insert(begin(), val);
//}
void push_back(const T& val)
{
Node* tail = _pHead->_pPre;
Node* newnode = new Node(val);
tail->_pNext = newnode;
newnode->_pPre = tail;
newnode->_pNext = _pHead;
_pHead->_pPre = newnode;
}
void pop_back()
{
erase(--end());
}
void push_front(const T& val)
{
insert(begin(), val);
}
void pop_front()
{
erase(begin());
}
在pos位置前插入值为val的节点
iterator insert(iterator pos, const T& val)
{
PNode next = pos._pNode;
PNode prev = next->_pPre;
PNode newnode = new Node(val);
newnode->_pNext = next;
newnode->_pPre = prev;
prev->_pNext = newnode;
next->_pPre = newnode;
return iterator(newnode);
}
删除pos位置的节点，返回该节点的下一个位置
iterator erase(iterator pos)
{
assert(pos != end());
PNode next = pos._pNode->_pNext;
PNode prev = pos._pNode->_pPre;
delete pos._pNode;
prev->_pNext = next;
next->_pPre = prev;
return iterator(next);
}
void clear()
{
iterator cur = begin();
while (cur != end())
{
erase(cur++);
}
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
//void swap(list& l);
private:
void CreateHead()
{
_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
PNode _pHead;
};
};
class Date
{
private:
int _year;
int _month;
int _day;
public:
Date(int year = 0, int month = 0, int day = 0)
:_year(year),
_month(month),
_day(day)
{
}
void print()
{
std::cout << _year << " " << _month << " " << _day << std::endl;
}
};
int main()
{
using namespace zjx;
list it;
it.push_back(Date(2022, 5, 16));
it.push_back(Date(2022, 5, 17));
it.push_back(Date(2022, 5, 18));
it.push_back(Date(2022, 5, 19));
it.push_back(Date(2022, 5, 20));
for (auto e : it)
{
e.print();
}
cout << endl;
list a1(5, 2);
for (auto e : a1)
{
cout << e << " ";
}
cout << endl;
list a2(it);
for (auto e : a2)
{
e.print();
}
cout << endl;
int arr[] = { 1,2,3,4,5,6,7,8,9 };
list a3(arr, arr + 9);
for (auto e : a3)
{
cout << e << " ";
}
cout << endl;
a1 = a3;
for (auto e : a1)
{
cout << e << " ";
}
cout << endl;
cout << "a3的元素的个数 = " << a3.size() << endl;
list a4;
cout << a4.empty() << endl;
const auto ans1 = a3.front();
auto ans2 = a3.back();
cout << "ans1 = " << ans1 << " " << "ans2 = " << ans2 << endl;
a3.push_front(30);
a3.pop_back();
a3.pop_front();
a3.pop_front();
for (auto e : a3)
{
cout << e << " ";
}
cout << endl;
return 0;
} 函数右边的const是用来限定this指针的。原本的this指针，不可以改变指向，可以改变所知的内容。
但若要对所指向的内容加以限定的话，那就在函数的右边加上const，表示此函数的隐藏的参数，也就是this指针，被加以const限定。const对象会自动找到const修饰的函数。
list的迭代器
迭代器有两种实现方式，具体应根据容器底层数据结构实现:
1．原生态指针，比如: vector
2．将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法:
1．指针可以解引用，迭代器的类中必须重载operator*()
2．指针可以通过->访问其所指空间成员，迭代器类中必须重载oprator->()
3．指针可以++向后移动，迭代器类中必须重载operator++()与operator++(int)
至于operator--( )/operator--(int)释放需要重载，根据具体的结构来抉择，双向链表可以向前移动，所以需要重载，如果是forward_list就不需要重载--
4．迭代器需要进行是否相等的比较，因此还需要重载operator==()与operator!=()
list与vector的对比
vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不 同，其主要不同如下：