public member function
<list>

std::list::merge

(1)
  void merge (list& x);
(2)
template <class Compare>  void merge (list& x, Compare comp);
(1)
  void merge (list& x);  void merge (list&& x);
(2)
template <class Compare>  void merge (list& x, Compare comp);template <class Compare>  void merge (list&& x, Compare comp);
合并已排序的列表
x 中的所有元素按其各自的有序位置合并到列表中(两个容器都必须已排序)。

这会有效地移除 x 中的所有元素(使其变为empty),并将它们插入到容器的有序位置(该容器的size会因传输的元素数量而增加)。该操作无需构建或销毁任何元素:它们被传输,无论 x 是左值还是右值,也无论value_type是否支持移动构造。

具有两个参数(2)的模板版本具有相同的行为,但它们接受一个特定的谓词(comp)来执行元素之间的比较操作。此比较应产生元素的“严格弱序”(strict weak ordering)(即,一致的传递比较,不考虑其自反性)。

此函数要求在调用前list容器的元素已根据值(或comp)排序。对于无序列表的替代方法,请参见list::splice

在假定存在这种排序的情况下,x 中的每个元素都会根据由operator<comp 定义的“严格弱序”插入到与其值对应的位置。等效元素的结果顺序是稳定的(即,等效元素保留它们在调用前的相对顺序,并且现有元素优先于从 x 插入的等效元素)。

如果(&x == this).

参数

x
一个 list 对象,具有相同的类型(即相同的模板参数,TAlloc).
请注意,无论传递的是左值还是右值引用,此函数都会修改 x
comp
二元谓词,它接受两个与list中包含的元素类型相同的参数,并返回true如果第一个参数被认为在其定义的“严格弱序”中排在第二个参数之前,则返回false否则为 false。
这应该是一个函数指针或函数对象。

返回值



示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 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.1

注意在第二次合并中,函数mycomparison(仅比较整数部分)没有考虑到2.1小于2.22.9,因此它被插入到它们之后,在3.1.


复杂度

最多是两个容器大小之和减一(比较次数)的线性复杂度。

迭代器有效性

调用前,容器的迭代器、指针和引用没有变化。
先前指向被转移元素的迭代器、指针和引用将继续指向这些相同的元素,但迭代器现在将指向已转移到容器中的元素。

数据竞争

容器和 x 都被修改。
并发访问或修改它们的元素是安全的,尽管迭代任一容器都是不安全的。

异常安全

如果两个容器的allocator不相等,如果 comp 未定义“严格弱序”,或者容器元素未根据它排序,则会导致“未定义行为”。
否则,如果比较操作抛出异常,容器将保持有效状态(基本保证)。
否则,如果抛出异常,容器将不发生任何更改(强保证)。

另见