#include <iostream>
#include <list>
#include <vector>

using namespace std;

int main ( void )
{
    list<string> myString;

    vector<char*> myChar;

    myChar.push_back ( "1 2 3 4 5 6" );
    myChar.push_back ( "7 8 9 10" );
    myChar.push_back ( "11 12 13 14" );

    myString.assign ( myChar.begin(), myChar.end() );         //可以将 char* 转换为 string

    for ( auto i = myString.begin(); i != myString.end(); i++ )
    {
        cout << *i << ' ';
    }

    cout << endl;
    
    return 0;
}

这段代码中对assign的调用将names中的元素替换为迭代器指定的范围中的元素的拷贝。
assign的参数决定了容器中将有多少个元素以及它们的值都是什么。
输出

（1）范围赋予

void assign ( InputIterator first, InputIterator last );

（2）填充赋予

接受一个整数值和一个元素值。它用指定数目且具有相同给定值的元素替换容器中原有的元素

void assign ( size_type n, const value_type &val );

（3）列表元素赋予

接受一段元素列表，将list容器中的元素和大小按序替换为该元素列表内的值和个数

void assign ( initializer_list<value_type> il );

?2)emplace

?3)emplace_front

void emplace_front ( Args&&... args );

?4)emplace_back

void emplace_back ( Args&&... args );

来救救蒟蒻吧，emplace没学懂，欢迎留言补充交流

?5)push_front

在list容器的头部创建一个值为val的元素，相应地使size增大了1

void push_front ( const value_type &val );

?6)pop_front

删除list容器的的首元素

void pop_front ( void );

?7)push_back

在list容器的尾部创建一个值为val的元素，相应地使size增大了1

void push_back ( const value_type &val );

?8)pop_back

删除list容器的的尾元素

void pop_back ( void );

?9)insert

（1）插入单个元素

在迭代器position指向的元素之前创建一个值为val的元素，返回指向新添加的元素的迭代器

iterator insert ( const_iterator position, const value_type& val );

（2）插入 n 个相同元素

在迭代器position指向的元素之前插入n个值为val的元素，返回指向新添加的一个元素的迭代器；若n为0，则返回p

iterator insert ( const_iterator position, size_type n, const value_type& val );

（3）插入元素值列表 { a, b, c, ... }

il是一个花括号包围的元素值列表。将这些给定值插入到迭代器position指向的元素之前。返回指向新添加的第一个元素的迭代器；若列表为空，则返回p

iterator insert (const_iterator position, initializer_list<value_type> il);

?10)erase

?ａ.删除单个元素

删除由一个迭代器指定的单个元素

返回指向删除的元素之后位置的迭代器

iterator erase ( const_iterator position );

?ｂ.删除多个元素

接受一对迭代器，允许我们删除一个范围内的元素
迭代器first指向要删除的第一个元素，last指向我们要删除的最后一个元素之后的位置

iterator erase (　const_iterator first, const_iterator last　);

?11)swap

用于交换容器内容，swap交换两个list容器内部的数据结构（元素本身并未交换），所以非常快，可以保证在常数时间内完成。

void swap ( list &x );

?12)resize

将容器的大小变为n

1、如果n小于当前容器的大小，则将元素个数减少到前n个元素，并删除超出范围的元素。

2、如果n大于当前容器的大小，则通过在末尾插入任意数量的元素以达到n个元素。

如果指定了val，则将新元素初始化为val的副本，否则，将对它们进行值的默认初始化。

void resize ( size_type n, value_type val = value_type() );

?13)clear

删除list容器中所有元素
void clear ( void )

8、操作

?1)splice

例如有lista，listb
则splice的作用是将b中的某些元素移动到a当中的某个位置去

?a.移动所有元素

将x容器中的所有元素移动到指定容器的迭代器position所指向的位置。

插入的第一个元素置于迭代器position所指向的位置

原先位置的元素置于被插入的最后一个元素的后面。（两容器的大小均已改变）

注意和insert的区别，splice相当是把元素插入在了position的前面

void splice ( iterator position, list &x );

?c.单一元素移动

将x容器中,迭代器i所指向的元素移动到list容器中,迭代器position所指向的位置之前.

void splice (iterator position, list& x, iterator i);

?c.范围元素移动

将范围[first，last）内的元素从x移动到list容器中position所指向的位置之前。

void splice (iterator position, list& x, iterator first, iterator last);

关于splice的具体操作请见代码：

// splicing lists
#include <iostream>
#include <list>

int main ()
{
  std::list<int> mylist1, mylist2;
  std::list<int>::iterator it;

  // set some initial values:
  for (int i=1; i<=4; ++i)
     mylist1.push_back(i);      // mylist1: 1 2 3 4

  for (int i=1; i<=3; ++i)
     mylist2.push_back(i*10);   // mylist2: 10 20 30

  it = mylist1.begin();
  ++it;                         // points to 2

  mylist1.splice (it, mylist2); // mylist1: 1 10 20 30 2 3 4
                                // mylist2 (empty)
                                // "it" still points to 2 (the 5th element)
                                          
  mylist2.splice (mylist2.begin(),mylist1, it);
                                // mylist1: 1 10 20 30 3 4
                                // mylist2: 2
                                // "it" is now invalid.
  it = mylist1.begin();
  std::advance(it,3);           // "it" points now to 30

  mylist1.splice ( mylist1.begin(), mylist1, it, mylist1.end());
                                // mylist1: 30 3 4 1 10 20

  std::cout << "mylist1 contains:";
  for (it=mylist1.begin(); it!=mylist1.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  std::cout << "mylist2 contains:";
  for (it=mylist2.begin(); it!=mylist2.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

mylist1 contains: 30 3 4 1 10 20
mylist2 contains: 2

// 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 20

  std::cout << "mylist contains:";
  for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

mylist contains: 36 20