Namespaces
Variants

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

    From fr.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) (depuis C++11)
    (constexpr depuis C++26)
    void merge ( forward_list && other ) ;
    		(2) (depuis C++11)
    (constexpr depuis C++26)
    template < class Compare >
    void merge ( forward_list & other, Compare comp ) ;
    		(3) (depuis C++11)
    (constexpr depuis C++26)
    template < class Compare >
    void merge ( forward_list && other, Compare comp ) ;
    		(4) (depuis C++11)
    (constexpr depuis C++26)

    Fusionne deux listes triées en une seule liste triée.

    • Si other fait référence au même objet que * this , ne fait rien.
    • Sinon, transfère tous les éléments de other vers * this . other est vide après la fusion.

    Cette opération est stable :

    • Pour les éléments équivalents dans les deux listes, les éléments de * this précèdent toujours les éléments de other .
    • L'ordre des éléments équivalents de * this et de other ne change pas.
    1,2) Équivalent à merge ( other, std:: less < T > ( ) ) (jusqu'en C++14) merge ( other, std:: less <> ( ) ) (depuis C++14) .
    3,4) Les éléments sont comparés en utilisant comp .
    Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :
    • * this ou other n'est pas trié(e) par rapport au comparateur comp .
    • get_allocator ( ) == other. get_allocator ( ) est false .

    Aucun itérateur ou référence n'est invalidé. Les pointeurs et références vers les éléments déplacés de * this , ainsi que les itérateurs référençant ces éléments, se référeront aux mêmes éléments de * this , au lieu de other .

    Contenu

    Paramètres

    other - autre conteneur à fusionner
    comp - objet fonction de comparaison (c'est-à-dire un objet qui satisfait aux exigences de Compare ) qui renvoie ​ true si le premier argument est inférieur à (c'est-à-dire est ordonné avant ) le second.

    La signature de la fonction de comparaison doit être équivalente à ce qui suit :

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

    Bien que la signature n'ait pas besoin d'avoir const & , la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) Type1 et Type2 indépendamment de la catégorie de valeur (ainsi, Type1& n'est pas autorisé , pas plus que Type1 sauf si pour Type1 un déplacement est équivalent à une copie (depuis C++11) ).
    Les types Type1 et Type2 doivent être tels qu'un objet de type forward_list < T, Allocator > :: const_iterator puisse être déréférencé puis implicitement converti vers les deux. ​

    Exigences de type
    -
    Compare doit satisfaire aux exigences de Compare .

    Valeur de retour

    (aucune)

    Exceptions

    Si une exception est levée pour quelque raison que ce soit, ces fonctions n'ont aucun effet ( garantie forte d'exception-sûreté ). Sauf si l'exception provient d'une comparaison.

    Complexité

    Si other fait référence au même objet que * this , aucune comparaison n'est effectuée.

    Sinon, étant donné N 1 comme std:: distance ( begin ( ) , end ( ) ) et N 2 comme std:: distance ( other. begin ( ) , other. end ( ) ) :

    1,2) Au maximum N 1 +N 2 -1 comparaisons en utilisant operator < .
    3,4) Au maximum N 1 +N 2 -1 applications de la fonction de comparaison comp .

    Exemple

    Exécuter ce code 
    #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';
}

    Sortie : 

    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

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Appliqué à Comportement publié Comportement corrigé
    LWG 2045 C++11 Le déplacement de nœud en O(1) ne pouvait être garanti si
    get_allocator ( ) ! = other. get_allocator ( )     		le comportement est
    indéfini dans ce cas
    LWG 3088 C++11 l'effet lorsque * this et other référencent
    le même objet n'était pas spécifié
    operator < pouvait mal fonctionner pour les éléments pointeurs     		spécifié comme no-op
    défini par l'implémentation
    ordre total strict utilisé

    Voir aussi

    		 déplace des éléments d'un autre forward_list
    (fonction membre publique)
    		fusionne deux plages triées
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    		fusionne deux plages ordonnées sur place
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    (C++20)
    		 fusionne deux plages triées
    (objet fonction d'algorithme)
    (C++20)
    		 fusionne deux plages ordonnées sur place
    (objet fonction d'algorithme)