C++ std::list 容器接口详解与使用指南

4. 容量

// 判空
bool empty() const noexcept;

// 容器元素的个数
size_type size() const noexcept;

5. 访问元素

// 返回容器中第一个元素的引用
reference front();
const_reference front() const;

// 返回容器中最后一个元素的引用
reference back();
const_reference back() const;

6. 修改

// 用一段迭代器赋值
template<class InputIterator>
void assign(InputIterator first, InputIterator last);

// 用 n 个 val 赋值
void assign(size_type n, const value_type& val);

// 用初始化列表赋值
void assign(initializer_list<value_type> il);

// 头插
void push_front(const value_type& val);

// 头删
void pop_front();

// 尾插
void push_back(const value_type& val);

// 尾删
void pop_back();

// 在 pos 位置插入单个元素
iterator insert(const_iterator position, const value_type& val);

// 在 pos 位置插入 n 个 val
iterator insert(const_iterator position, size_type n, const value_type& val);

// 在 pos 位置插入一段迭代器区间
template<class InputIterator>
iterator insert(const_iterator position, InputIterator first, InputIterator last);

// 在 pos 位置插入一个初始化列表
iterator insert(const_iterator position, initializer_list<value_type> il);

// 删除 pos 位置的元素
iterator erase(const_iterator position);

// 删除一段迭代器区间
iterator erase(const_iterator first, const_iterator last);

// 交换两个 list 对象的内容
void swap(list& x);

// n < size，保留前 n 个元素
// n > size，插入元素到 n 个，如果 val 是具体的，就用 val 的拷贝去初始化，否则，将被值初始化
void resize(size_type n);
void resize(size_type n, const value_type& val);

// 清空 list 中所有的元素
void clear() noexcept;

7. 操作

// 在 pos 位置插入一个 list 对象
void splice(const_iterator position, list& x);

// 只转移 x 对象中 i 位置的元素到另一个 list 对象中
void splice(const_iterator position, list& x, const_iterator i);
void splice(const_iterator position, list&& x, const_iterator i);

// 转移 x 中的一段迭代器区间到另一个 list 对象中
void splice(const_iterator position, list& x, const_iterator first, const_iterator last);
void splice(const_iterator position, list&& x, const_iterator first, const_iterator last);

// 删除容器中所有和 val 值相等的元素
void remove(const value_type& val);

// 去重，原理双指针（只能去除相邻的重复的元素，常与 sort 搭配使用）
void unique();

// 合并链表，原理归并排序（要求两个 list 对象都是有序的）
void merge(list& x);

// comp 仿函数对象，控制比较大小的逻辑
template<class Compare>
void merge(list& x, Compare comp);

// 链表排序
void sort();
template<class Compare>
void sort(Compare comp);

// 逆置链表
void reverse() noexcept;

8. 非成员函数

// 友元函数
template<class T, class Alloc>
bool operator==(const list<T, Alloc>& lhs, const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator!=(const list<T, Alloc>& lhs, const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator<(const list<T, Alloc>& lhs, const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator<=(const list<T, Alloc>& lhs, const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator>(const list<T, Alloc>& lhs, const list<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator>=(const list<T, Alloc>& lhs, const list<T, Alloc>& rhs);

// 交换两个 list 对象的内容
template<class T, class Alloc>
void swap(list<T, Alloc>& x, list<T, Alloc>& y);

list 的接口到此结束。