list的使用和模拟实现
目录
1.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
2.为什么使用迭代器？
3.list的模拟实现
3.1完整代码
3.2代码解析
4.list与vector的对比
1.list的介绍及使用
1.1 list的介绍
1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
1.2 list的使用
list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口
1.2.1 list的构造
| 构造函数 |
接口说明 |
| list (size_type n, const value_type& val = value_type()) |
构造的list中包含n个值为val的元素 |
| list () |
构造空的list |
| list (const list& x) |
拷贝构造函数 |
| list (InputIterator first, InputIterator last) |
用两个迭代器[firs, last)区间中的元素构造list |
1.2.2 list iterator的使用
此处，可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。
| 函数声明 |
接口说明 |
| begin+end |
返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器 |
| rbegin+rend |
返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator，即begin的前一个位置 |
1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动
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位置的元素 |
| erase |
删除list position位置的元素 |
| swap |
交换两个list中的元素 |
| clear |
清空list中的有效元素 |
2.为什么使用迭代器？
容器类使用迭代器进行访问和遍历的主要原因包括以下几点：
- 抽象数据结构访问接口：通过迭代器，容器类可以提供一种统一的、抽象的方法来访问和操作容器中的元素。这样，无论容器内部的数据结构是什么，用户都可以使用相同的方式来访问和操作元素，提高了代码的可复用性和可维护性。
- 封装容器的内部实现细节：容器的内部实现可能采用各种不同的数据结构，例如数组、链表、树等。通过迭代器，容器可以隐藏内部实现细节，只提供迭代器的接口给用户使用，从而保护容器内部数据的完整性和安全性。
- 支持灵活的遍历方式：迭代器提供了多种灵活的遍历方式，例如正向遍历、反向遍历、随机遍历等。这使得用户可以根据实际需求选择最适合的遍历方式，提高了代码的灵活性和效率。
- 方便的算法和函数库使用：许多算法和函数库都是基于迭代器的，例如STL中的算法库、boost库等。通过使用迭代器，可以方便地在容器上应用这些算法和函数，提高了开发效率和代码的重用性。
综上所述，使用迭代器可以提供一种统一的、抽象的方法来操作容器中的元素，封装容器的内部实现细节，提供灵活的遍历方式，并支持方便的算法和函数库的使用。这使得容器的访问和遍历更加方便、灵活和高效
3.list的模拟实现
3.1完整代码
//ReverseIterator.h
#define _CRT_SECURE_NO_WARNINGS 1
namespace bit
{
template//Ref表示引用类型，Ptr表示指针类型
struct ReverseIterator
{
typedef ReverseIterator Self;//重命名
Iterator _it;//成员
ReverseIterator(Iterator it)
:_it(it)
{}
Ref operator*()
{
Iterator tmp = _it;
return *(--tmp);
}
Ptr operator->()
{
return &(operator*());
}
Self& operator++()
{
--_it;
return *this;
}
Self operator++(int)
{
Self tmp = *this;
--_it;
return tmp;
}
Self& operator--()
{
++_it;
return *this;
}
Self& operator--(int)
{
Self tmp = *this;
++_it;
return tmp;
}
bool operator!=(const Self& s) const
{
return _it != s._it;
}
};
} //list.h
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include "ReverseIterator.h"
namespace bit
{
template
struct list_node
{
list_node* _next;
list_node* _prev;
T _val;
list_node(const T& val = T())
:_next(nullptr)
, _prev(nullptr)
, _val(val)
{}
};
template
struct __list_iterator//迭代器
{
typedef list_node Node;
typedef __list_iterator self;
Node* _node;
__list_iterator(Node* node)
:_node(node)
{}
Ref operator*()
{
return _node->_val;
}
Ptr operator->()
{
return &_node->_val;
}
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& it) const
{
return _node != it._node;
}
bool operator==(const self& it) const
{
return _node == it._node;
}
};
template
class list
{
typedef list_node Node;//重命名一样受访问限制符限制，这个是给内部用的
public:
typedef __list_iterator iterator;//这个是给外部用的，所以公有的
typedef __list_iterator const_iterator;
typedef ReverseIterator reverse_iterator;
typedef ReverseIterator const_reverse_iterator;
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
reverse_iterator rend()
{
return reverse_iterator(begin());
}
iterator begin()
{
//return _head->_next;//C++单参数类型支持隐式转换
return iterator(_head->_next);//这两种写法是一样的
}
iterator end()
{
//return _head;//C++单参数类型支持隐式转换
//虽然两种写法都是一样的，不过这种写法能更加明确的告诉我们返回的是迭代器类型的对象
return iterator(_head);//匿名对象
}
const_iterator begin() const
{
//return _head->_next;//C++单参数类型支持隐式转换
return const_iterator(_head->_next);//这两种写法是一样的
}
const_iterator end() const
{
return _head;
}
void empty_init()
{
_head = new Node;
_head->_prev = _head;
_head->_next = _head;
_size = 0;
}
list()
{
empty_init();
}
list(const list& lt)
{
empty_init();
for (auto& e : lt)
{
push_back(e);
}
}
void swap(list& lt)
{
std::swap(_head, lt._head);
std::swap(_size, lt._size);
}
list& operator=(list lt)
{
swap(lt);
return *this;
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it);
}
_size = 0;
}
void push_back(const T& x)
{
//第一种写法
/*Node* tail = _head->_prev;
Node* newnode = new Node(x);
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;*/
//第二种写 -- 复用insert函数
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* newnode = new Node(x);
prev->_next = newnode;
newnode->_next = cur;
cur->_prev = newnode;
newnode->_prev = prev;
++_size;
return newnode;
}
iterator erase(iterator pos)
{
assert(pos != end());
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
--_size;
delete cur;
return next;//因为迭代器失效问题所以要返回下一个迭代器
//为什么失效？因为删除之后迭代器原来的指向失效，需要返回下一个节点作为新的迭代器
}
size_t size()
{
return _size;
}
private:
Node* _head;
size_t _size;
};
struct A
{
A(int a1 = 0, int a2 = 0)
:_a1(a1)
, _a2(a2)
{}
int _a1;
int _a2;
};
} //main.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
using namespace std;
#include "list.h"
void Print(const bit::list& lt)
{
bit::list::const_iterator it = lt.begin();
while (it != lt.end())
{
//(*it)++;
cout << *it << " ";
++it;
}
cout << endl;
}
void test_list1()
{
bit::list lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
//因为链表的底层不一样，所以我们需要对其iterator进行封装然后重载运算符
bit::list::iterator it = lt.begin();
while (it != lt.end())
{
cout << *it << " ";
++it;
}
cout << endl;
Print(lt);
}
void test_list2()
{
bit::list lt;
lt.push_back(bit::A(1, 1));
lt.push_back(bit::A(2, 2));
lt.push_back(bit::A(3, 3));
lt.push_back(bit::A(4, 4));
bit::list::iterator it = lt.begin();
while (it != lt.end())
{
cout << it->_a1 << " " << it->_a2 << endl;
++it;
}
cout << endl;
}
void test_list3()
{
bit::list lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);
lt.push_back(6);
lt.push_back(7);
lt.push_back(8);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl;
lt.pop_front();
lt.pop_back();
for (auto e : lt)
{
cout << e << " ";
}
cout << endl;
}
void test_list4()
{
bit::list lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
bit::list lt1(lt);
for (auto e : lt1)
{
cout << e << " ";
}
cout << endl;
bit::list lt2;
lt2.push_back(10);
lt2.push_back(20);
lt2.push_back(30);
lt2.push_back(40);
lt1 = lt2;
for (auto e : lt1)
{
cout << e << " ";
}
cout << endl;
}
void test_list5()
{
bit::list lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
//bit::list lt1(lt);
//for (auto e : lt1)
//{
// cout << e << " ";
//}
//cout << endl;
bit::list::reverse_iterator rit = lt.rbegin();
while (rit != lt.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
}
void test_list6()
{
bit::list lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
bit::list::iterator it = lt.begin();
while (it != lt.end())
{
if (*it == 2)
{
it = lt.erase(it);
}
cout << *it << " ";
++it;
}
cout << endl;
}
int main()
{
test_list6();
return 0;
}
3.2代码解析
4.list与vector的对比
vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：
| vector |
list |
|
| 底层结构 |
动态顺序表，一段连续空间 |
带头节点的双向循环链表 |
| 随机访问 |
支持随机访问，访问某个元素效率O(1) |
不支持随机访问，访问某个元素效率O(N) |
| 插入和删除 |
任意位置插入和删除效率低，需要搬移元素，时间复杂度O(N)，插入时有可能需要增容，增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低 |
任意位置插入和删除效率高，不需要搬移元素，时间复杂度为O(1) |
| 空间利用率 |
底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高 |
底层节点动态开辟，小节点容易造成内存碎片，空间利用率低缓存利用率低 |
| 迭代器 |
原生态指针 |
对原生态指针(节点指针)进行封装 |
| 迭代器失效 |
在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效 |
插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响 |
| 使用场景 |
需要高效存储，支持随机访问，不关心插入删除效率 |
需要大量插入和删除操作，不关心随机访问
|