【STL基础】list

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, 3

l.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 << '
';
  return 0;
}
//first contains: 1.4 2.2 2.9 2.1 3.1 3.7 7.1

l.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);