Namespaces
Variants

std:: input_iterator

From cppreference.net
C++
Iterator library
Iterator concepts
(C++20)
(C++20)
input_iterator
(C++20)
(C++20)
(C++20)

Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Défini dans l'en-tête <iterator>
template < class I >

concept input_iterator =
std:: input_or_output_iterator < I > &&
std:: indirectly_readable < I > &&
requires { typename /*ITER_CONCEPT*/ < I > ; } &&

std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: input_iterator_tag > ;
(depuis C++20)

Le concept input_iterator est un raffinement du concept input_or_output_iterator , ajoutant l'exigence que les valeurs référencées puissent être lues (via indirectly_readable ) et l'exigence que l'étiquette de concept d'itérateur soit présente.

Table des matières

Détermination du concept d'itérateur

La définition de ce concept est spécifiée via un alias de modèle exposition-seulement /*ITER_CONCEPT*/ .

Afin de déterminer /*ITER_CONCEPT*/ < I > , soit ITER_TRAITS < I > dénotant I si la spécialisation std:: iterator_traits < I > est générée à partir du modèle primaire, ou std:: iterator_traits < I > sinon :

  • Si ITER_TRAITS < I > :: iterator_concept est valide et désigne un type, /*ITER_CONCEPT*/ < I > dénote ce type.
  • Sinon, si ITER_TRAITS < I > :: iterator_category est valide et désigne un type, /*ITER_CONCEPT*/ < I > dénote ce type.
  • Sinon, si std:: iterator_traits < I > est généré à partir du modèle primaire, /*ITER_CONCEPT*/ < I > dénote std::random_access_iterator_tag .
    (C'est-à-dire que std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: input_iterator_tag > est supposé être true .)
  • Sinon, /*ITER_CONCEPT*/ < I > ne dénote pas un type et entraîne un échec de substitution.

Notes

Contrairement aux exigences LegacyInputIterator , le concept input_iterator n'exige pas equality_comparable , car les itérateurs d'entrée sont généralement comparés avec des sentinelles.

Exemple

Un itérateur d'entrée minimum. 

#include <cstddef>
#include <iterator>
class SimpleInputIterator
{
public:
    using difference_type = std::ptrdiff_t;
    using value_type = int;
    int operator*() const;
    SimpleInputIterator& operator++();
    void operator++(int) { ++*this; }
};
static_assert(std::input_iterator<SimpleInputIterator>);
**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` 
` et contient des termes spécifiques au C++ qui ne doivent pas être traduits. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Voir aussi

(C++20)
spécifie que les objets d'un type peuvent être incrémentés et déréférencés
(concept)
(C++20)
spécifie qu'un input_iterator est un itérateur avant, supportant la comparaison d'égalité et le multi-passage
(concept)