list::splice-c和c++中文资料站

C&C++标准库

std::

list::splice

公众成员函数 <list>

C++98	entire list(1)	void splice (iterator position, list& x);
	single element(2)	void splice (iterator position, list& x, iterator i);
	element range(3)	void splice (iterator position, list& x, iterator first, iterator last);

将元素从一个列表转移到另一个列表

将元素从x转移到容器中，并将其插入到指定位置。

这将这些元素插入到容器中，并将它们从x中删除，从而改变了两个容器的大小。该操作不涉及任何元素的建造或销毁。不管x是左值还是右值，也不管value_type是否支持移动构造，它们都会被转移。

第一个版本(1)将x的所有元素转移到容器中。
第二个版本(2)只将i指向的元素从x转移到容器中。
第三个版本(3)将范围[first,last]从x转移到容器中。

☲ 参数

position: 插入x元素的容器中的位置。

成员类型iterator和const_iterator是指向元素的双向迭代器类型。
x: 一个相同类型的列表对象(例如，具有相同的模板参数T和Alloc)。
如果position指向一个没有被拼接的元素，这个参数可能是* This (对于第一个版本，这是不可能的，但对于其他版本，这是可能的)。
i: 迭代器指向x中的一个元素。只传递这一个元素。
Iterator是一种成员类型，定义为双向迭代器类型。
成员类型iterator和const_iterator是指向元素的双向迭代器类型。
first, last: 指定x中元素范围的迭代器。将范围[first,last]中的元素转移到position。。
使用的范围是[first,last]，它包括first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。

成员类型iterator和const_iterator是指向元素的双向迭代器类型。

☉ 返回值

none

☣ 示例

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

✥ 复杂度

(1)和(2)是常量。
对于(3)，转移元素数可达线性。

☣ 迭代器的有效性

在调用之前，与容器相关的迭代器、指针和引用没有变化。
指向被转移元素的迭代器、指针和引用一直指向那些相同的元素，但现在迭代器迭代到元素被转移到的容器中。

⇄ 数据竞争

容器和x都被修改。
并发地访问或修改它们的元素是安全的，但迭代x或包含position的范围则不安全。

☂ 异常安全性

如果两个容器中的分配器没有进行相等比较，如果指定的任何迭代器或范围是无效的，或者(1)中的x是*this，或者(3)中的position在[first,last]范围内，则会导致未定义行为。
否则，函数永远不会抛出异常(无抛出保证)。

🍄 另请参阅

list::insert	插入元素(公众成员函数)
list::merge	合并已排序的容器(公众成员函数)
list::erase	删除元素(公众成员函数)