Namespaces
Variants

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

    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)
    **Traductions effectuées :** - "since" → "depuis" dans "(constexpr since C++26)" - Le reste du contenu textuel a été préservé conformément aux instructions : - Les balises HTML et attributs non traduits - Le code C++ dans les balises ` ` non traduit - Les termes spécifiques C++ conservés en anglais
    forward_list ( ) : forward_list ( Allocator ( ) ) { }
    		(1) (constexpr depuis C++26)
    explicit forward_list ( const Allocator & alloc ) ;
    		(2) (constexpr depuis C++26)
    explicit forward_list ( size_type count,
    const Allocator & alloc = Allocator ( ) ) ;
    		(3) (constexpr depuis C++26)
    forward_list ( size_type count, const T & value,
    const Allocator & alloc = Allocator ( ) ) ;
    		(4) (constexpr depuis C++26)
    template < class InputIt >

    forward_list ( InputIt first, InputIt last,

    const Allocator & alloc = Allocator ( ) ) ;
    		(5) (constexpr depuis C++26)
    template < container-compatible-range < T > R >

    forward_list ( std:: from_range_t , R && rg,

    const Allocator & alloc = Allocator ( ) ) ;
    		(6) (depuis C++23)
    (constexpr depuis C++26)
    forward_list ( const forward_list & other ) ;
    		(7) (constexpr depuis C++26)
    forward_list ( forward_list && other ) ;
    		(8) (constexpr depuis C++26)
    (9)
    forward_list ( const forward_list & other, const Allocator & alloc ) ;
    		(jusqu'en C++23)
    forward_list ( const forward_list & other,
    const std:: type_identity_t < Allocator > & alloc ) ;
    		(depuis C++23)
    (constexpr depuis C++26)
    (10)
    forward_list ( forward_list && other, const Allocator & alloc ) ;
    		(jusqu'au C++23)
    forward_list ( forward_list && other,
    const std:: type_identity_t < Allocator > & alloc ) ;
    		(depuis C++23)
    (constexpr depuis C++26)
    forward_list ( std:: initializer_list < T > init,
    const Allocator & alloc = Allocator ( ) ) ;
    		(11) (constexpr depuis C++26)

    Construit un nouveau forward_list à partir de diverses sources de données, en utilisant optionnellement un allocateur fourni par l'utilisateur alloc .

    1) Le constructeur par défaut. Construit une forward_list vide avec un allocateur construit par défaut.
    Si Allocator n'est pas DefaultConstructible , le comportement est indéfini.
    2) Construit une forward_list vide avec l'allocateur donné alloc .
    3) Construit une forward_list avec count objets par défaut de T . Aucune copie n'est effectuée.
    Si T n'est pas DefaultInsertable dans forward_list , le comportement est indéfini.
    4) Construit une forward_list avec count copies d'éléments de valeur value .
    Si T n'est pas CopyInsertable dans forward_list , le comportement est indéfini.
    5) Construit une forward_list avec le contenu de la plage [ first , last ) . Chaque itérateur dans [ first , last ) est déréférencé exactement une fois.
    Cette surcharge participe à la résolution de surcharge uniquement si InputIt satisfait aux exigences de LegacyInputIterator .
    Si T n'est pas EmplaceConstructible dans forward_list à partir de * first , le comportement est indéfini.
    6) Construit une forward_list avec le contenu de la plage rg . Chaque itérateur dans rg est déréférencé exactement une fois.
    Si T n'est pas EmplaceConstructible dans forward_list à partir de * ranges:: begin ( rg ) , le comportement est indéfini.
    7) Le constructeur de copie. Construit une forward_list avec le contenu de other . L'allocateur est obtenu comme si en appelant std:: allocator_traits < Allocator > :: select_on_container_copy_construction
    ( other. get_allocator ( ) )     .
    8) Le constructeur de déplacement. Construit une forward_list avec le contenu de other . L'allocateur est obtenu par construction par déplacement depuis other. get_allocator ( ) .
    9) Identique au constructeur de copie, sauf que alloc est utilisé comme allocateur.
    Si T n'est pas CopyInsertable dans forward_list , le comportement est indéfini.
    10) Identique au constructeur de déplacement, sauf que alloc est utilisé comme allocateur.
    Si T n'est pas MoveInsertable dans forward_list , le comportement est indéfini.
    11) Équivalent à forward_list ( il. begin ( ) , il. end ( ) , alloc ) .

    Sommaire

    Paramètres

    alloc - allocateur à utiliser pour toutes les allocations mémoire de ce conteneur
    count - la taille du conteneur
    value - la valeur pour initialiser les éléments du conteneur
    first, last - la paire d'itérateurs définissant la source range des éléments à copier
    other - un autre conteneur à utiliser comme source pour initialiser les éléments du conteneur
    init - liste d'initialisation pour initialiser les éléments du conteneur
    rg - une plage compatible avec le conteneur

    Complexité

    1,2) Constant.
    3,4) Linéaire en count .
    5) Linéaire en std:: distance ( first, last ) .
    6) Linéaire en ranges:: distance ( rg ) .
    7) Linéaire en other. size ( ) .
    8) Constante.
    9) Linéaire en other. size ( ) .
    10) Linéaire en other. size ( ) si alloc ! = other. get_allocator ( ) , sinon constant.
    11) Linéaire en init. size ( ) .

    Exceptions

    Les appels à Allocator :: allocate peuvent lever des exceptions.

    Notes

    Après la construction par déplacement d'un conteneur (surcharge (8)), les références, pointeurs et itérateurs qui se référaient initialement aux éléments dans other restent valides, mais font référence aux éléments qui sont maintenant dans *this. La norme actuelle garantit cela via l'énoncé général dans [container.reqmts]/67, et une garantie plus directe est à l'étude via le problème LWG 2321.

    Macro de test de fonctionnalité Valeur Std Fonctionnalité
    __cpp_lib_containers_ranges 202202L (C++23) compatible avec les Ranges construction et insertion ; surcharge (6)

    Exemple

    Exécuter ce code 
    #include <forward_list>
#include <iostream>
#include <string>
template<typename T>
std::ostream& operator<<(std::ostream& s, const std::forward_list<T>& v)
{
    s.put('{');
    for (char comma[]{'\0', ' ', '\0'}; const auto& e : v)
        s << comma << e, comma[0] = ',';
    return s << "}\n";
}
int main()
{
    // Syntaxe de liste d'initialisation C++11 :
    std::forward_list<std::string> words1{"the", "frogurt", "is", "also", "cursed"};
    std::cout << "1: " << words1;
    // words2 == words1
    std::forward_list<std::string> words2(words1.begin(), words1.end());
    std::cout << "2: " << words2;
    // words3 == words1
    std::forward_list<std::string> words3(words1);
    std::cout << "3: " << words3;
    // words4 est {"Mo", "Mo", "Mo", "Mo", "Mo"}
    std::forward_list<std::string> words4(5, "Mo");
    std::cout << "4: " << words4;
    const auto rg = {"cat", "cow", "crow"};
#ifdef __cpp_lib_containers_ranges
    std::forward_list<std::string> words5(std::from_range, rg); // surcharge (6)
#else
    std::forward_list<std::string> words5(rg.begin(), rg.end()); // surcharge (5)
#endif
    std::cout << "5: " << words5;
}

    Sortie : 

    1: {the, frogurt, is, also, cursed}
2: {the, frogurt, is, also, cursed}
3: {the, frogurt, is, also, cursed}
4: {Mo, Mo, Mo, Mo, Mo}
5: {cat, cow, crow}

    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 2193 C++11 le constructeur par défaut était explicite rendu non-explicite
    LWG 2210 C++11 la surcharge ( 3 ) n'avait pas de paramètre allocateur paramètre ajouté
    N3346 C++11 pour la surcharge ( 3 ) , les éléments dans
    le conteneur étaient initialisés par valeur     		ils sont insérés par défaut

    Voir aussi

    		assigne des valeurs au conteneur
    (fonction membre publique)
    		assigne des valeurs au conteneur
    (fonction membre publique)