Namespaces
Variants

    std::forward_list<T,Allocator>:: merge

    From es.cppreference.net

    C++
    Containers library
    std::forward_list
    Member functions
    Non-member functions
    (until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
    Deduction guides (C++17)
    void merge ( forward_list & other ) ;
    		(1) (desde C++11)
    (constexpr desde C++26)
    void merge ( forward_list && other ) ;
    		(2) (desde C++11)
    (constexpr desde C++26)
    template < class Compare >
    void merge ( forward_list & other, Compare comp ) ;
    		(3) (desde C++11)
    (constexpr desde C++26)
    template < class Compare >
    void merge ( forward_list && other, Compare comp ) ;
    		(4) (desde C++11)
    (constexpr desde C++26)

    Combina dos listas ordenadas en una lista ordenada.

    • Si other se refiere al mismo objeto que * this , no hace nada.
    • De lo contrario, transfiere todos los elementos de other a * this . other queda vacío después de la fusión.

    Esta operación es estable:

    • Para elementos equivalentes en las dos listas, los elementos de * this siempre preceden a los elementos de other .
    • El orden de los elementos equivalentes de * this y other no cambia.
    1,2) Equivalente a merge ( other, std:: less < T > ( ) ) (hasta C++14) merge ( other, std:: less <> ( ) ) (desde C++14) .
    3,4) Los elementos se comparan utilizando comp .
    Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:
    • * this o other no está ordenado con respecto al comparador comp .
    • get_allocator ( ) == other. get_allocator ( ) es false .

    No se invalidan iteradores ni referencias. Los punteros y referencias a los elementos movidos desde * this , así como los iteradores que se refieren a estos elementos, referirán a los mismos elementos de * this , en lugar de other .

    Contenido

    Parámetros

    other - otro contenedor a fusionar
    comp - objeto función de comparación (es decir, un objeto que satisface los requisitos de Compare ) que devuelve ​ true si el primer argumento es menor que (es decir, está ordenado antes que) el segundo.

    La firma de la función de comparación debe ser equivalente a la siguiente:

    bool cmp ( const Type1 & a, const Type2 & b ) ;

    Aunque la firma no necesita tener const & , la función no debe modificar los objetos pasados a ella y debe poder aceptar todos los valores de tipo (posiblemente const) Type1 y Type2 independientemente de la categoría de valor (por lo tanto, Type1& no está permitido , ni tampoco Type1 a menos que para Type1 un movimiento sea equivalente a una copia (since C++11) ).
    Los tipos Type1 y Type2 deben ser tales que un objeto de tipo forward_list < T, Allocator > :: const_iterator pueda ser desreferenciado y luego convertido implícitamente a ambos. ​

    Requisitos de tipo
    -
    Compare debe cumplir con los requisitos de Compare .

    Valor de retorno

    (ninguno)

    Excepciones

    Si se lanza una excepción por cualquier razón, estas funciones no tienen efecto ( strong exception safety guarantee ). Excepto si la excepción proviene de una comparación.

    Complejidad

    Si other se refiere al mismo objeto que * this , no se realizan comparaciones.

    De lo contrario, dado N 1 como std:: distance ( begin ( ) , end ( ) ) y N 2 como std:: distance ( other. begin ( ) , other. end ( ) ) :

    1,2) Como máximo N 1 +N 2 -1 comparaciones usando operator < .
    3,4) Como máximo N 1 +N 2 -1 aplicaciones de la función de comparación comp .

    Ejemplo

    Ejecutar este código 
    #include <iostream>
#include <forward_list>
std::ostream& operator<<(std::ostream& ostr, const std::forward_list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}
int main()
{
    std::forward_list<int> list1 = {5, 9, 1, 3, 3};
    std::forward_list<int> list2 = {8, 7, 2, 3, 4, 4};
    list1.sort();
    list2.sort();
    std::cout << "list1: " << list1 << '\n';
    std::cout << "list2: " << list2 << '\n';
    list1.merge(list2);
    std::cout << "merged:" << list1 << '\n';
}

    Salida: 

    list1:  1 3 3 5 9
list2:  2 3 4 4 7 8
merged: 1 2 3 3 3 4 4 5 7 8 9

    Informes de defectos

    Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

    DR Aplicado a Comportamiento publicado Comportamiento correcto
    LWG 2045 C++11 No se podía garantizar O(1) en movimiento de nodos si
    get_allocator ( ) ! = other. get_allocator ( )     		el comportamiento es
    indefinido en este caso
    LWG 3088 C++11 el efecto cuando * this y other refieren
    al mismo objeto no estaba especificado
    operator < podría comportarse incorrectamente para elementos puntero     		especificado como no-operación
    definido por la implementación
    se utiliza orden total estricto

    Véase también

    		 mueve elementos de otro forward_list
    (función miembro pública)
    		fusiona dos rangos ordenados
    (plantilla de función & objeto función de algoritmo)
    (C++20)
    		fusiona dos rangos ordenados in situ
    (plantilla de función & objeto función de algoritmo)
    (C++20)
    (C++20)
    		 fusiona dos rangos ordenados
    (objeto función de algoritmo)
    (C++20)
    		 fusiona dos rangos ordenados in situ
    (objeto función de algoritmo)