list
构造函数：
//default:
list<T> l; //空的list//fill:
list<T> l(n); //n个元素, 元素默认初始化
list<T> l(n, value); //n个元素值为value//range:
list<T> l(first, last); //两个迭代器之间的元素构成
list<T> l(arr, arr + sizeof(arr) / sizeof(T)); //由内置数组构造//copy:
list<T> l(const list<T> &t); //v是u的拷贝//move:
list<T> l(list<T> &&x); //x是右值引用(只能引用右值，如list<int> &&x = {1,2,3};)//initializer list:
list<T> l{value1, value2...};
赋值与swap：
l1 = l2;
l1 = { 1, 2, 3 };
l1.swap(l2);
swap(l1, l2);
大小：
size_type l.size() const noexcept; //元素数目
size_type l.max_size() const noexcept; //可容纳元素的最大数目
bool l.empty() //是否为空
l.resize(n);
l.resize(n, value);
获取元素：
l.front(); //首元素
l.back(); //尾元素
修改：
//assign
l.assign(n, value); //将v置为n个值为value的元素
l.assign(first, last); //用t的两个迭代器之间的值为l赋值，左闭右开 t可以是vector、array、list、forward_list、deque、set、unordered_set、multiset、unordered_multiset等。 元素的顺序和重复性由传入的容器类型性质决定
l.assign(begin(t), end(t)); //与上条语句类似，除上述类型，还支持内置数组类型
l.assign(arr, arr + n); //将数组中的一部分赋给l
l.assign({value1, value2...}); //列表l.push_back(value); //尾部插入一个元素
l.push_front(value); //首部插入一个元素
l.pop_back(); //删除最后一个元素
l.pop_front(); //删除第一个元素//insert
l.insert(it, value); //迭代器指向的位置插入值为value的元素
l.insert(it, n, value); //迭代器指向的位置插入n个值为value的元素
l.insert(it, first, last); //迭代器it指向的位置插入另一个容器的两个迭代l之间的元素
l.insert(it, x); //x是T的右值引用 T&&
l.insert(it, {value1, value2...}); //列表
//以上函数返回一个指向新插入的第一个元素的迭代器//emplace(C++11)
l.emplace(it, args); //以args为参数，调用T的构造函数构造一个对象插入it所指的位置
l.emplace_back(args); //将构造的T对象插入尾部
l.emplace_front(args); //插入前端
//以上函数返回一个指向新插入的元素的迭代器//erase
l.erase(it); //删除it指向的元素
l.erase(first, last); //删除范围内的元素
//以上函数返回一个迭代器，指向被删除的最后一个元素之后的元素l.clear(); //删除所有元素
修改：
//splice
l.splice(it, x);
l.splice(it, x, itx); //x为引用或右值引用，将x的内容拼接到it指向的位置处. 该过程不包括构造和析构过程，而是元素的转移。如果给定itx则是转移x中itx指向的元素
l.splice(it, first, last);list<int> l1 {1,2,3};
list<int> l2 {10, 20, 30};
l1.splice(l1.begin(), l2); //l1: 1, 10, 20, 30, 2, 3l.remove(value); //删除所有等于value的元素
l.remove_if(pred);// list::remove_if
#include <iostream>
#include <list>// a predicate implemented as a function:
bool single_digit (const int& value) { return (value<10); }
// a predicate implemented as a class:
struct is_odd {
bool operator() (const int& value) { return (value%2)==1; }
};
int main ()
{
int myints[]= {15,36,7,17,20,39,4,1};
std::list<int> mylist (myints,myints+8); // 15 36 7 17 20 39 4 1
mylist.remove_if (single_digit); // 15 36 17 20 39
mylist.remove_if (is_odd()); // 36 20return 0;
}l.unique();
l.unique(binary_pred);
#include <iostream>
#include <cmath>
#include <list>// a binary predicate implemented as a function:
bool same_integral_part (double first, double second)
{ return ( int(first)==int(second) ); }
// a binary predicate implemented as a class:
struct is_near {
bool operator() (double first, double second)
{ return (fabs(first-second)<5.0); }
};
int main ()
{
double mydoubles[]={ 12.15, 2.72, 73.0, 12.77, 3.14,
12.77, 73.35, 72.25, 15.3, 72.25 };
std::list<double> mylist (mydoubles,mydoubles+10);mylist.sort(); // 2.72, 3.14, 12.15, 12.77, 12.77,
// 15.3, 72.25, 72.25, 73.0, 73.35
mylist.unique(); // 2.72, 3.14, 12.15, 12.77
// 15.3, 72.25, 73.0, 73.35
mylist.unique (same_integral_part); // 2.72, 3.14, 12.15
// 15.3, 72.25, 73.0
mylist.unique (is_near()); // 2.72, 12.15, 72.25return 0;
}l.merge(x);
l.merge(x, comp);
// list::merge
#include <iostream>
#include <list>
// compare only integral part:
bool mycomparison (double first, double second)
{ return ( int(first)<int(second) ); }
int main ()
{
std::list<double> first, second;
first.push_back (3.1);
first.push_back (2.2);
first.push_back (2.9);
second.push_back (3.7);
second.push_back (7.1);
second.push_back (1.4);
first.sort();
second.sort();
first.merge(second);
// (second is now empty)
second.push_back (2.1);
first.merge(second,mycomparison);
std::cout << "first contains:";
for (std::list<double>::iterator it=first.begin(); it!=first.end(); ++it)
std::cout << ‘ ‘ << *it;
std::cout << ‘\n‘;
return 0;
}
//first contains: 1.4 2.2 2.9 2.1 3.1 3.7 7.1l.sort();
l.sort(comp);
bool compare_nocase (const T &first, const T &second);l.reverse();
获取迭代器：
l.begin(), l.end(); //首元素位置，尾后位置
l.cbegin(), l.cend(); //const_iterator//reverse_iterator 按逆序寻址
//const_reverse_iterator
l.rbegin(), l.rend();
l.crbegin(), l.crend();begin(l), end(l);
【STL基础】list