Namespaces
Variants

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

From 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 ) .

Table des matières

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 du conteneur (surcharge ( 8 ) ), les références, pointeurs et itérateurs (à l'exception de l'itérateur de fin) vers other restent valides, mais se réfèrent aux éléments qui se trouvent désormais 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 LWG issue 2321 .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les gammes ; 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)