Namespaces
Variants

no-throw-input-iterator , no-throw-forward-iterator , no-throw-sentinel-for , no-throw-input-range , no-throw-forward-range

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
template < class I >

concept itérateur-d'entrée-sans-exception -


std:: input_iterator < I > &&
std:: is_lvalue_reference_v < std:: iter_reference_t < I >> &&
std:: same_as < std:: remove_cvref_t < std:: iter_reference_t < I >> , std:: iter_value_t < I >> ;
(1) ( exposition uniquement* )
template < class I >

concept no - throw - forward - iterator =
no - throw - input - iterator < I > &&
std:: forward_iterator < I > &&

no - throw - sentinel - for < I, I > ;
(2) ( exposition uniquement* )
template < class S, class I >
concept no - throw - sentinel - for = std:: sentinel_for < S, I > ;
(3) ( exposition uniquement* )
template < class R >

concept no - throw - input - range =
ranges:: range < R > &&
no - throw - input - iterator < ranges:: iterator_t < R >> &&

no - throw - sentinel - for < ranges:: sentinel_t < R > , ranges:: iterator_t < R >> ;
(4) ( exposition only* )
template < class R >

concept no - throw - forward - range =
no - throw - input - range < R > &&

no - throw - forward - iterator < ranges:: iterator_t < R >> ;
(5) ( exposition uniquement* )

Ces concepts d'exposition uniquement spécifient qu'aucune exception n'est levée par les opérations requises par les algorithmes sur les itérateurs, les sentinelles et les ranges.

1) Le concept no-throw-input-iterator exige que le déréférencement de l'itérateur produise une lvalue, comme contiguous_iterator et LegacyForwardIterator .

Exigences sémantiques

Comme tous les concepts standard, chaque concept listé ici est modélisé uniquement si tous les concepts qu'il subsume sont modélisés.

1) Un type I modélise no-throw-input-iterator seulement si aucune exception n'est levée lors de l'incrémentation, de la construction par copie, de la construction par déplacement, de l'affectation par copie, de l'affectation par déplacement, ou de l'indirection via des itérateurs valides.
3) Les types S et I modélisent no-throw-sentinel-for seulement si aucune exception n'est levée lors de la construction par copie, de la construction par déplacement, de l'affectation par copie, de l'affectation par déplacement, ou des comparaisons entre des valeurs valides de type I et S .
4) Un type R modélise no-throw-input-range seulement si aucune exception n'est levée lors des appels à ranges:: begin et ranges:: end sur un objet de type R .

Notes

Ces concepts permettent à certaines opérations sur les itérateurs et sentinelles de lever des exceptions, par exemple les opérations sur des valeurs non valides.

Voir aussi

(C++20)
spécifie qu'un type est un itérateur d'entrée, c'est-à-dire que ses valeurs référencées peuvent être lues et qu'il peut être pré-incrémenté et post-incrémenté
(concept)
(C++20)
spécifie qu'un input_iterator est un itérateur avant, supportant la comparaison d'égalité et le multi-passage
(concept)
(C++20)
spécifie qu'un type est un sentinelle pour un type input_or_output_iterator
(concept)
(C++20)
spécifie une plage dont le type d'itérateur satisfait input_iterator
(concept)
(C++20)
spécifie une plage dont le type d'itérateur satisfait forward_iterator
(concept)