C++-list
std::list是C++标准模板库(STL)提供的双向链表容器，它提供了高效的插入和删除操作，特别适合频繁修改的序列。定义在 <list> 头文件中，属于 std 命名空间。该类的接口与常规容器接口基本一致。
模板原型：
cpp
template < class T, class Alloc = allocator<T> > class list;allocator<T>：STL空间配置器（内存池）。
基本特性：
-
实现方式：双向链表结构，每个元素包含指向前驱和后继的指针。
-
内存分配：元素在内存中非连续存储的，通过指针链接。
-
泛型容器：通过模板实现，可以存储任何类型的元素。
-
迭代器：双向迭代器（支持++和--操作）。
1. 底层理解
list 底层是 带头双向循环链表。
cpp
template<typename T>
struct list_node{
T val;
list_node* prev;
list_node* next;
list_node(const T& data = T()) :val(data) , prev(nullptr) , next(nullptr) {}
};
template<typename T>
class list {
private:
list_node<T>* node;
}
2. 成员函数
2.1 成员类型
| 成员类型 | 解释 |
|---|---|
| value_type | 第一个模板参数（T） |
| allocator_type | 第二个模板参数（Alloc） |
| size_type | 无符号整数（size_t） |
| reference | 类型引用（T&） |
| const_reference | const类型引用（const T&） |
2.2 构造函数
| 序号 | 函数原型 | 说明 |
|---|---|---|
| 1️⃣ | explicit list (const allocator_type& alloc = allocator_type()) | 默认构造 |
| 2️⃣ | list (const list& x) | 拷贝构造 |
| 3️⃣ | explicit list (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()) | 使用 n 个 val 值初始化 |
| 4️⃣ | template <class InputIterator> list (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()) | 使用一段迭代器区间初始化 |
2.3 赋值重载
| 序号 | 函数原型 | 说明 |
|---|---|---|
| 1️⃣ | list& operator= (const list& x) | 两个已存在的 list 对象的赋值 |
2.4 迭代器
| 序号 | 函数原型 | 说明 |
|---|---|---|
| 1️⃣ | iterator begin() | 返回指向 list 对象中第一个元素的迭代器 |
| 2️⃣ | const_iterator begin() const | 返回指向 list 对象中第一个元素的 const迭代器 |
| 3️⃣ | iterator end() | 返回指向 list 对象末尾元素之后位置的迭代器 |
| 4️⃣ | const_iterator end() const | 返回指向 list 对象末尾元素之后位置的 const迭代器 |
| 5️⃣ | reverse_iterator rbegin() | 返回指向 list 对象末尾元素的反向迭代器 |
| 6️⃣ | const_reverse_iterator rbegin() const | 返回指向 list 对象末尾元素的const反向迭代器 |
| 7️⃣ | reverse_iterator() rend() | 返回指向 list 对象起始元素之前位置的反向迭代器 |
| 8️⃣ | const_reverse_iterator() rend() const | 返回指向 list 对象起始元素之前位置的const反向迭代器 |
2.5 容量相关的接口
| 序号 | 函数原型 | 说明 |
|---|---|---|
| 1️⃣ | size_type size() const | 返回 list 对象中元素的数量 |
| 2️⃣ | bool empty() const | 判断当前 list 对象是否为空 |
2.6 元素的访问
| 序号 | 函数原型 | 说明 |
|---|---|---|
| 1️⃣ | reference front() | 返回 list 对象第一个元素的引用 |
| 2️⃣ | const_reference front() const | 返回 const list 对象第一个元素的 const引用 |
| 3️⃣ | reference back() | 返回 list 对象最后一个元素的引用 |
| 4️⃣ | const_reference back() const | 返回 const list 对象最后一个元素的引用 |
2.7 修改相关的接口
| 序号 | 函数原型 | 说明 |
|---|---|---|
| 1️⃣ | template <class InputIterator> void assign (InputIterator first, InputIterator last) | 使用一段迭代器区间赋值给 list 对象（通常使用其他容器） |
| 2️⃣ | void push_front (const value_type& val) | 在 list 对象头部插入 val 元素 |
| 3️⃣ | void pop_front() | 在 list 对象头部删除一个元素 |
| 4️⃣ | void push_back (const value_type& val) | 在 list 对象尾部插入 val 元素 |
| 5️⃣ | void pop_back() | 在 list 对象尾部删除一个元素 |
| 6️⃣ | iterator insert (iterator pos, const value_type& val); | 在 list 对象的 pos 位置迭代器插入 val 元素，返回新插入元素的迭代器 |
| 7️⃣ | iterator erase (iterator pos); | 删除 list 对象的 pos 位置迭代器元素，返回删除位置元素的下一个迭代器 |
| 8️⃣ | void clear(); | 清空 list 对象中所有元素 |
2.8 其他操作
| 序号 | 函数原型 | 说明 |
|---|---|---|
| 1️⃣ | void reverse() | 逆置 list 对象中的元素 |
| 2️⃣ | void sort() | 排序 list 对象中的元素（默认升序） |
| 3️⃣ | void merge (list& x) | 合并两个有序的 list，将 x 对象中的所有元素合并到当前 list 中，合并完后 x 将变为空链表 |
| 4️⃣ | void unique() | 去重，但前提需要 list 对象有序 |
| 5️⃣ | void remove (const value_type& val) | 移除所有 val 元素 |
| 6️⃣ | void splice (iterator position, list& x) | 将x链表中的所有元素移动到当前链表的 position迭代器之前，移动后 x 变为空链表 |
| 7️⃣ | void splice (iterator position, list& x, iterator i) | 将x链表中 i 位置迭代器元素移动到当前链表的 position迭代器之前 |
| 8️⃣ | void splice (iterator position, list& x, iterator first, iterator last); | 将x链表一段迭代器区间移动到当前链表的 position迭代器之前 |
- reverse
- sort
- merge
- unique
- remove
6.splice
3. list迭代器失效
C++中，list 与 vector 迭代器失效有所不同，list迭代器失效主要发生在 元素被删除时
迭代器失效的情况：
-
erase 时被删除位置元素迭代器失效。
- 解决方式：通过 erase 返回值重新获取迭代器（erase返回删除元素的下一个位置迭代器）
-
整个 list 被销毁或赋值时，所有迭代器都会失效。
4. list模拟实现
cpp
// list.hpp
#pragma once
#include <iostream>
#include <cassert>
namespace simulate_list {
template<typename T>
struct list_node{
T val;
list_node* prev;
list_node* next;
list_node(const T& data = T()) :val(data) , prev(nullptr) , next(nullptr) {}
};
template<typename T , typename Ref , typename Ptr>
struct __list_iterator {
typedef list_node<T> node;
typedef __list_iterator<T , Ref , Ptr> self;
__list_iterator(node* nodeptr) :cur(nodeptr) {}
self& operator++() {
cur = cur->next;
return *this;
}
self operator++(int) {
self temp(cur);
cur = cur->next;
return temp;
}
self& operator--() {
cur = cur->prev;
return *this;
}
self operator--(int) {
self temp(cur);
cur = cur->prev;
return temp;
}
Ref operator*() {
return cur->val;
}
Ptr operator->() {
return &(operator*());
}
bool operator==(const self& s) {
return cur == s.cur;
}
bool operator!=(const self& s) {
return cur != s.cur;
}
node* cur;
};
template<typename 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;
iterator begin() { return iterator(head->next); }
iterator end() { return iterator(head); }
const_iterator begin() const { return const_iterator(head->next); }
const_iterator end() const { return const_iterator(head); }
bool empty() const { return head->next == head; }
T& front() { assert(!empty()); return head->next->val; }
T& back() { assert(!empty()); return head->prev->val; }
const T& front() const { assert(!empty()); return head->next->val; }
const T& back() const { assert(!empty()); return head->prev->val; }
size_t size() const {
size_t count = 0;
for (auto& a : *this) count++;
return count;
}
void clear() {
auto it = begin();
while (it != end())
it = erase(it);
}
void initializer_list() {
head = new node;
head->prev = head;
head->next = head;
}
list<T>() {
initializer_list();
}
list<T>(const list<T>& l) {
initializer_list();
for (auto& node : l)
push_back(node);
}
list<T>& operator=(list<T> l) {
std::swap(head , l.head);
return *this;
}
~list<T>() {
clear();
delete head;
head = nullptr;
}
iterator insert(iterator position , const T& val);
iterator erase(iterator position);
void push_front(const T& val) { insert(begin() , val); }
void pop_front() { assert(!empty()); erase(begin()); }
void push_back(const T& val) { insert(end() , val); }
void pop_back() { assert(!empty()); erase(--end()); }
private:
node* head = nullptr;
};
template<typename T>
typename list<T>::iterator list<T>::insert(list<T>::iterator position , const T& val) {
node* prev = position.cur->prev;
node* newnode = new node(val);
prev->next = newnode;
newnode->prev = prev;
newnode->next = position.cur;
position.cur->prev = newnode;
return iterator(newnode); // 返回新插入节点的迭代器
}
template<typename T>
typename list<T>::iterator list<T>::erase(list<T>::iterator position) {
node* prev = position.cur->prev;
node* next = position.cur->next;
prev->next = next;
next->prev = prev;
delete position.cur;
return iterator(next); // 返回删除元素的下一个元素
}
} // namespace simulate_list end