目录
一、list介绍
list和vector一样，也是一种序列容器，并且允许在序列内的任何地方进行恒定时间插入和擦除操作。
/*
T 可以是任意数据类型
Allocator:空间配置器，用于获取/释放内存以及构造/销毁该内存中的元素的分配器，默认为allocator（new/delete）,一般不做修改。
*/
template<class T,class Allocator = std::allocator<T>>
class list;
list是由双向链表实现的，每个节点存储一个元素，内存分配是不连续的。与其他基本标准序列容器（vector或deque )相比，列表在元素插入、提取以及移动方面通常表现的更好，相应的，list的主要缺点就是它无法通过位置直接访问元素，即不支持随机访问，例如：访问list中的第六个元素，必须从已知位置（如开头或结尾）迭代到该位置。
list与forward_list非常相似：主要区别在于forward_list对象是单链表，因此forward_list只能向前迭代。
二、list的成员函数
1、构造函数
（1）构造一个空的list容器，没有元素，也是默认构造函数
explicit list (const allocator_type& alloc = allocator_type());
（2）构造一个包含n 个元素的容器，每个元素都是val的副本,若val未指定，则为默认值。
explicit list (size_type n);
explicit list (size_type n, const value_type& val,const allocator_type& alloc = allocator_type());（3）构造一个包含了范围[first,last)元素的list容器，每个元素都从该范围内的相应元素以相同的顺序就地构造。
template <class InputIterator>
list (InputIterator first, InputIterator last,const allocator_type& alloc = allocator_type());（4） 以list容器x作为数据源，构造一个新list容器，其中新list容器中的元素来自于x中元素拷贝的副本。
list (const list& x);
list (const list& x, const allocator_type& alloc);（5）构造一个容器，并直接从x中移动元素,之后x中的元素将被移除
list (list&& x);
list (list&& x, const allocator_type& alloc);
（6）以相同的顺序构造一个list容器，其中包含l中每个元素拷贝的副本
list (initializer_list<value_type> l,const allocator_type& alloc = allocator_type());
2、operator=函数
（1）使用list列表other对其进行复制拷贝
list& operator=( const list& other );（2）使用list列表other对其进行移动拷贝，之后other的数据将被清空
list& operator=( list&& other );（3）使用初始化列表对list进行赋值
list& operator=( std::initializer_list<T> ilist );3、迭代器
iterator begin(); // 返回list迭代器到第一个元素
const_iterator cbegin(); // 返回list迭代器到第一个元素
iterator end(); // 返回list迭代器到最后一个元素
const_iterator cend(); // 返回list迭代器到最后一个元素
reverse_iterator rbegin(); // 返回list反向迭代器到第一个元素
const_reverse_iterator crbegin();// 返回list反向迭代器到第一个元素
reverse_iterator rend(); // 返回list反向迭代器到最后一个元素
const_reverse_iterator crend(); // 返回list反向迭代器到最后一个元素4、容量相关
bool empty(); // 判断容器是否为空
size_type size();// 返回容器中当前元素个数
size_type max_size(); //返回容器内可存放的最大元素个数
// 调整容器大小，使其只包含其前n个元素，若n超过size，则使用默认值初始化。
void resize (size_type n);
// 调整容器大小，使其只包含其前n个元素，若n超过size，则使用val初始化。
void resize (size_type n, const value_type& val);5、元素访问
/* 返回list中最后1个元素 */
reference back();
const_reference back() const;
/* 返回list中第1个元素 */
reference front();
const_reference front() const; 6、容器更改
// 将list的元素使用count个value元素进行复制覆盖
void assign( size_type count, const T& value );
// 将list的元素使用[first,last)的元素进行复制覆盖
template< class InputIt >
void assign( InputIt first, InputIt last );
// 将list的元素使用初始化列表里的元素进行复制覆盖
void assign( std::initializer_list<T> ilist );
// 使用args作为构造参数就地构造新元素，并将其放入容器起始位置
void emplace_front (Args&&... args);
// 使用args作为构造参数就地构造新元素，并将其放入容器末尾位置
void emplace_back (Args&&... args);
// 复制或移动元素val至容器起始位置
void push_front (const value_type& val);
void push_front (value_type&& val);
// 复制或移动元素val至容器末尾位置
void push_back(const value_type& val);
void push_back(value_type&& val);
// 从容器起始位置删除一个元素
void pop_front();
// 从容器末尾位置删除一个元素
void pop_back();
// 通过在position插入一个新元素来扩展容器,这个新元素是使用args作为构造参数就地构造的。
iterator emplace (const_iterator position, Args&&... args);
// 在position位置插入元素val
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, const value_type& val);
// 在position位置插入n个元素val
iterator insert (const_iterator position, size_type n, const value_type& val);
// 在position位置插入元素[first,last)
iterator insert (const_iterator position, InputIterator first, InputIterator last);
// 在position位置插入一个initializer_list对象
iterator insert (const_iterator position, initializer_list<value_type> il);
// 从list容器中删除单个元素position
iterator erase (const_iterator position);
// 从list容器中删除一系列元素 [first,last)
iterator erase (const_iterator first, const_iterator last);
// 与list容器x互换内容，所有迭代器、引用和指针对交换的对象仍然有效。
void swap (list& x);
// 从list容器中移除所有元素（已销毁），并保留大小为0的容器。
void clear();
8、列表修改
// 将x中所有元素转移(无复制或移动)至该容器的position位置上
void splice (const_iterator position, list& x);
void splice (const_iterator position, list&& x);
// 将x中的元素i转移(无复制或移动)至该容器的position位置上
void splice (const_iterator position, list& x, const_iterator i);
void splice (const_iterator position, list&& x, const_iterator i);
// 将x中的元素[first,last)转移(无复制或移动)至该容器的position位置上
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);
// 从容器list中移除所有等于val的元素
void remove (const value_type& val);
// 从容器中移除所有Predicate pred返回true的元素。
template <class Predicate>
void remove_if (Predicate pred);
// 容器中连续相等的值序列只保留第一个
void unique();
// 自定义比较函数，容器中连续相等的值序列只保留第一个
template <class BinaryPredicate>
void unique (BinaryPredicate binary_pred);
// 将x中的所有元素合并到列表中（两个容器都应已排序）。
void merge (list& x);
void merge (list&& x);
// 自定义比较函数，将x中的所有元素合并到列表中
template <class Compare>
void merge (list& x, Compare comp);
template <class Compare>
void merge (list&& x, Compare comp);
// 对列表中的元素进行默认排序（递增）
void sort();
// 使用自定义比较函数，对列表中的元素进行排序
template <class Compare>
void sort (Compare comp);
// 反转列表容器中元素的顺序。
void reverse();
三、示例代码：
#include <list>
#include <string>
#include <iostream>
template<typename T>
std::ostream& operator<<(std::ostream& s, const std::list<T>& v)
{
s.put('[');
char comma[3] = {'\0', ' ', '\0'};
for (const auto& e : v) {
s << comma << e;
comma[0] = ',';
}
return s << ']';
}
struct is_odd {
bool operator() (const int& value) { return (value%2)==1; }
};
bool mycomparison (int first, int second)
{ return ( first < second ); }
int main()
{
std::cout << "------------------------ " << "con" <<"------------------------ "<<'\n';
// 构造函数
//（1） 默认构造函数
std::list<std::string> words1;
std::cout << "words1: " << words1 << '\n';
//（2） 以3个“wangxx”构造容器,若未指定后面字符串，则表示使用std::string()构造空字符串
std::list<std::string> words2(3,"wangxx");
std::cout << "words2: " << words2 << '\n';
//（3）使用words2的[begin(),end()之间的元素构造words3
std::list<std::string> words3(words2.begin(), words2.end());
std::cout << "words3: " << words3 << '\n';
// (4)使用word3来构造容器，其中word4中的元素都来自于word3元素的一份拷贝
std::list<std::string> words4(words3);
std::cout << "words4: " << words4 << '\n';
// (5)使用word4中的元素来构造容器word5，此时word4中的元素全部被移动到word5中，之后word4为空
std::list<std::string> words5(std::move(words4));
std::cout << "words5: " << words5 << '\n';
// （6）使用初始化列表形式来构造一个list容器,这里也是元素的拷贝
std::list<std::string> words6{"welcome","wangxx","csdn"};
std::cout << "words6 " << words6 << '\n';
std::cout << "------------------------ " << "operator=" <<"------------------------ "<<'\n';
//operator= 函数
std::list<int> nums1 {3, 1, 4, 6, 5, 9};
std::list<int> nums2;
std::list<int> nums3;
std::cout << "nums1: " << nums1 << '\n';
//（1） num1中的元素将以拷贝的方式复制到num2中
nums2 = nums1;
std::cout << "nums2: " << nums2 << '\n';
//（2） num2中的元素将以移动的方式移动到num3中，此时num2中数据将被清空
nums3 = std::move(nums2);
std::cout << "nums3: " << nums3 << '\n';
//（3）使用初始化列表对num3进行赋值
nums3 = {22,33,44,55};
std::cout << "nums3: " << nums3 << '\n';
std::cout << "------------------------ " << "assign" <<"------------------------ "<<'\n';
// assign函数
std::list<int> assign_test {3, 1, 4, 6, 5, 9};
// (1) 将list的元素使用count个value元素进行复制覆盖
assign_test.assign(5,10);
std::cout << "assign_test: " << assign_test << '\n';
//（2）将list的元素使用[first,last)的元素进行复制覆盖
assign_test.assign(nums1.begin(),nums1.end());
std::cout << "assign_test: " << assign_test << '\n';
// （3）将list的元素使用初始化列表里的元素进行复制覆盖
assign_test.assign({1, 2, 3, 4, 5, 6});
std::cout << "assign_test: " << assign_test << '\n';
std::cout << "------------------------ " << "access" <<"------------------------ "<<'\n';
// 元素访问
// (1)返回list中最后1个元素
std::cout << "assign_test.front(): " << assign_test.front() << '\n';
// (2)返回list中第1个元素
std::cout << "assign_test.front(): " << assign_test.back() << '\n';
std::cout << "------------------------ " << "size" <<"------------------------ "<<'\n';
// 容量相关
std::cout << "assign_test.empty(): " << assign_test.empty() << '\n';
std::cout << "assign_test.size(): " << assign_test.size() << '\n';
std::cout << "assign_test.max_size(): " << assign_test.max_size() << '\n';
std::cout << "------------------------ " << "modefy" <<"------------------------ "<<'\n';
// 元素修改
assign_test.emplace_back(11);
std::cout << "assign_test.emplace_back: " << assign_test << '\n';
assign_test.emplace_front(11);
std::cout << "assign_test.emplace_front: " << assign_test << '\n';
assign_test.push_front(10);
std::cout << "assign_test.push_front: " << assign_test << '\n';
assign_test.push_back(10);
std::cout << "assign_test.push_back: " << assign_test << '\n';
assign_test.emplace(assign_test.begin(),9);
std::cout << "assign_test.emplace(assign_test.begin()): " << assign_test << '\n';
assign_test.insert(assign_test.begin(),3,1);
std::cout << "assign_test.insert(assign_test.begin(),3,1): " << assign_test << '\n';
assign_test.erase(assign_test.begin());
std::cout << "assign_test.erase(assign_test.begin()): " << assign_test << '\n';
std::list<int> assign_test2 {1, 3, 4, 6, 5, 9};
assign_test.swap(assign_test2);
std::cout << "assign_test.swap(assign_test2): " << assign_test << '\n';
assign_test.resize(2);
std::cout << "assign_test.resize(2): " << assign_test << '\n';
std::cout << "------------------------ " << "list modefy" <<"------------------------ "<<'\n';
assign_test.splice(assign_test.begin(),assign_test2);
std::cout << "assign_test.splice(assign_test2): " << assign_test << '\n';
assign_test.remove(1);
std::cout << "assign_test.remove(1): " << assign_test << '\n';
assign_test.remove_if (is_odd());
std::cout << "assign_test.remove_if (is_odd()): " << assign_test << '\n';
assign_test = {2,4,6,8,10};
assign_test2 = {1,3,5,7,9};
std::cout << "assign_test: " << assign_test << '\n';
std::cout << "assign_test2: " << assign_test2 << '\n';
assign_test.merge(assign_test2,mycomparison);
std::cout << "assign_test.merge(assign_test2,mycomparison): " << assign_test << '\n';
assign_test.reverse();
std::cout << "assign_test.reverse(): " << assign_test << '\n';
assign_test.sort();
std::cout << "assign_test.sort(): " << assign_test << '\n';
return 0;
}输出：
------------------------ con------------------------
words1: []
words2: [wangxx, wangxx, wangxx]
words3: [wangxx, wangxx, wangxx]
words4: [wangxx, wangxx, wangxx]
words5: [wangxx, wangxx, wangxx]
words6 [welcome, wangxx, csdn]
------------------------ operator=------------------------
nums1: [3, 1, 4, 6, 5, 9]
nums2: [3, 1, 4, 6, 5, 9]
nums3: [3, 1, 4, 6, 5, 9]
nums3: [22, 33, 44, 55]
------------------------ assign------------------------
assign_test: [10, 10, 10, 10, 10]
assign_test: [3, 1, 4, 6, 5, 9]
assign_test: [1, 2, 3, 4, 5, 6]
------------------------ access------------------------
assign_test.front(): 1
assign_test.front(): 6
------------------------ size------------------------
assign_test.empty(): 0
assign_test.size(): 6
assign_test.max_size(): 768614336404564650
------------------------ modefy------------------------
assign_test.emplace_back: [1, 2, 3, 4, 5, 6, 11]
assign_test.emplace_front: [11, 1, 2, 3, 4, 5, 6, 11]
assign_test.push_front: [10, 11, 1, 2, 3, 4, 5, 6, 11]
assign_test.push_back: [10, 11, 1, 2, 3, 4, 5, 6, 11, 10]
assign_test.emplace(assign_test.begin()): [9, 10, 11, 1, 2, 3, 4, 5, 6, 11, 10]
assign_test.insert(assign_test.begin(),3,1): [1, 1, 1, 9, 10, 11, 1, 2, 3, 4, 5, 6, 11, 10]
assign_test.erase(assign_test.begin()): [1, 1, 9, 10, 11, 1, 2, 3, 4, 5, 6, 11, 10]
assign_test.swap(assign_test2): [1, 3, 4, 6, 5, 9]
assign_test.resize(2): [1, 3]
------------------------ list modefy------------------------
assign_test.splice(assign_test2): [1, 1, 9, 10, 11, 1, 2, 3, 4, 5, 6, 11, 10, 1, 3]
assign_test.remove(1): [9, 10, 11, 2, 3, 4, 5, 6, 11, 10, 3]
assign_test.remove_if (is_odd()): [10, 2, 4, 6, 10]
assign_test: [2, 4, 6, 8, 10]
assign_test2: [1, 3, 5, 7, 9]
assign_test.merge(assign_test2,mycomparison): [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
assign_test.reverse(): [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
assign_test.sort(): [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
536
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
