Namespaces
Variants

C++ named requirements: Container

From cppreference.net
C++
C++ named requirements

Un Container est un objet utilisé pour stocker d'autres objets et prenant en charge la gestion de la mémoire utilisée par les objets qu'il contient.

Table des matières

Exigences

Étant donné les types et valeurs suivants :

Type Définition
T un type d'objet
C une classe conteneur contenant des objets de type T
Valeur Définition
u , v valeurs de type C ou const C
mv une valeur de type C
cv une valeur de type const C
lhs , rhs lvalues de type C
i , j valeurs de type C::iterator ou const C :: iterator

C satisfait les exigences de Container si les types, déclarations et expressions suivants sont bien formés et possèdent la sémantique spécifiée :

Types

Type Définition Exigences
typename C :: value_type T T est CopyConstructible (jusqu'à C++11) Erasable de C (depuis C++11) .
typename C :: reference T& Aucune exigence explicite
typename C :: const_reference const T &
typename C :: iterator un type d'itérateur
typename C :: const_iterator un type d'itérateur constant C::const_iterator est un LegacyForwardIterator , et son type de valeur est T .
typename C :: difference_type un type entier signé C::difference_type est identique au type de différence de C::iterator et C::const_iterator .
typename C :: size_type un type entier non signé C::size_type est suffisamment grand pour représenter toutes les valeurs non négatives de C::difference_type .

Instructions

Énoncé Sémantique Complexité
C c ;

C c = C ( ) ;

Postcondition c. empty ( ) est true . constante
C c ( v ) ;

C c = C ( v ) ;

Précondition

Si v n'est pas une rvalue de type C , T est CopyInsertable dans C .

(depuis C++11)
linéaire [1]
Postcondition
  • Si v est une lvalue, c == v est true .
  • Si v est une rvalue , et c et v ne font pas référence au même objet (depuis C++11) , c est égal à la valeur que v avait avant cette construction.
Notes
  1. ↑ Si v est une rvalue de type C , et C n'est pas une spécialisation de std::array ou std::inplace_vector , la complexité est constante.

Expressions

Expression Type Sémantique Complexité
C ( ) C Postcondition C ( ) . empty ( ) est true . constant
C ( v ) C Précondition

Si v n'est pas une rvalue de type C , T est CopyInsertable dans C .

(depuis C++11)
constante [1]
Postcondition
  • Si v est une lvalue, C ( v ) == v est true .
  • Si v est une rvalue , et que C ( v ) et v ne référencent pas le même objet (depuis C++11) , C ( v ) est égal à la valeur que v avait avant cette construction.
lhs = v C& Postcondition
  • Si v est une lvalue, lhs == v est true .
  • Si v est une rvalue , et lv et v ne font pas référence au même objet (depuis C++11) , lhs est égal à la valeur que v avait avant cette affectation.
linéaire
v.~C ( ) void Effet Détruit tous les éléments de v et libère toute la mémoire obtenue. linéaire
mv. begin ( ) C::iterator Effet Retourne un itérateur pointant vers le premier élément de mv . constant
cv. begin ( ) C::const_iterator Effet Retourne un itérateur pointant vers le premier élément de cv . constant
mv. end ( ) C::iterator Effet Retourne l'itérateur de fin de mv . constant
cv. end ( ) C::const_iterator Effet Retourne l'itérateur de fin de cv . constant
v. cbegin ( )
(depuis C++11) 		C::const_iterator Effet Retourne const_cast < const C & > ( v ) . begin ( ) . constant
v. cend ( )
(depuis C++11) 		C::const_iterator Effet Retourne const_cast < const C & > ( v ) . end ( ) . constant
i <=> j
(depuis C++20) 		std::strong_ordering Contrainte Cette expression n'est requise d'être bien formée que si C::iterator satisfait les exigences des itérateurs à accès aléatoire. constante
u == v bool Effet Retourne
u. size ( ) == v. size ( ) &&
std:: equal ( u. begin ( ) ,
u. end ( ) , v. begin ( ) ) 		(jusqu'en C++14)
std:: equal ( u. begin ( ) , u. end ( ) ,
v. begin ( ) , v. end ( ) ) 		(depuis C++14)
. 		linéaire [2]
u ! = v Effet Équivalent à ! ( u == v ) .
lhs. swap ( rhs )

swap ( lhs, rhs )

void Effet Échange le contenu de lhs et rhs . constant [3]
v. size ( ) C::size_type Effet Retourne le nombre d'éléments [4] de v . constant
v. max_size ( ) C::size_type Effet Retourne le nombre d'éléments du plus grand conteneur possible de type C . constant
v. empty ( ) bool Effet Retourne v. begin ( ) == v. end ( ) . constant
Exigences optionnelles de conteneur
(uniquement fournies pour certains types de conteneurs)
u <=> v
(depuis C++20) 		synth-three-way-result
< C :: value_type > 		Précondition Soit T modélise three_way_comparable , soit operator < définit une relation d'ordre total pour les valeurs de type T et const T . linéaire
Effet Retourne std:: lexicographical_compare_three_way
( u. begin ( ) , u. end ( ) ,
v. begin ( ) , v. end ( ) ,
synth-three-way  ) [5] .
Notes
  1. ↑ Si v est une rvalue de type C , et C est une spécialisation de std::array ou std::inplace_vector , la complexité est linéaire.
  2. ↑ Si u. size ( ) ! = v. size ( ) est true , la complexité est constante.
  3. ↑ Si C est une spécialisation de std::array ou std::inplace_vector , la complexité est linéaire.
  4. ↑ Le nombre d'éléments est défini par les règles des constructeurs, insertions et effacements. Il est égal à la valeur de std:: distance ( v. begin ( ) , v. end ( ) ) .
  5. ↑ Si les itérateurs passés à std::lexicographical_compare_three_way sont des ConstexprIterator s , l'opération est implémentée par des fonctions constexpr .

Dans les expressions i == j , i ! = j , i < j , i <= j , i >= j , i > j et i - j , si i et/ou j sont remplacés par des itérateurs de type C::const_iterator pointant vers le même élément respectivement, la sémantique reste inchangée.

Courses de données des conteneurs

Voir sécurité des threads des conteneurs .

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 179 C++98 iterator et const_iterator pouvaient être incomparables doivent être comparables
LWG 276 C++98 T devait être CopyAssignable T doit être
CopyConstructible
LWG 322 C++98 les types de valeur de iterator et const_iterator n'étaient pas spécifiés spécifiés comme T
LWG 774 C++98 aucune exigence sur swap ( a, b ) ajoutée
LWG 883 C++98 a. swap ( b ) était défini comme swap ( a, b ) ,
entraînant une définition circulaire 		défini comme échangeant
les valeurs de a et b
LWG 1319 C++98 iterator et const_iterator
pouvaient ne pas avoir la garantie multipass 		ils doivent satisfaire
les exigences de
LegacyForwardIterator
LWG 2114
( P2167R3 ) 		C++98 les types de retour non- bool de certaines fonctions étaient autorisés interdits
LWG 2182 C++98 les types dénotés par reference et
const_reference étaient mal spécifiés 		formulation améliorée
LWG 2257 C++98 deux conteneurs nécessitaient un temps linéaire pour être comparés
égaux même s'ils avaient des tailles différentes 		nécessite seulement un temps
constant dans ce cas
LWG 2263 C++11 la résolution de LWG issue 179 a été accidentellement supprimée en C++11 restaurée
LWG 2839 C++11 l'auto-affectation par déplacement des conteneurs standards n'était pas autorisée autorisée mais le
résultat n'est pas spécifié
N3346 C++11 C::value_type devait être Destructible doit être Erasable de C

Voir aussi

Documentation C++ pour Bibliothèque de conteneurs