Namespaces
Variants

std:: istreambuf_iterator

From cppreference.net
C++
Iterator library
Iterator concepts
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)
std::istreambuf_iterator
Défini dans l'en-tête <iterator>
template < class CharT, class Traits = std:: char_traits < CharT > >

class istreambuf_iterator
: public std:: iterator < std:: input_iterator_tag ,
CharT, typename Traits :: off_type ,

/* non spécifié */ , CharT >
(jusqu'à C++17)
template < class CharT, class Traits = std:: char_traits < CharT > >
class istreambuf_iterator ;
(depuis C++17)

std::istreambuf_iterator est un itérateur d'entrée à passage unique qui lit les caractères successifs depuis l'objet std::basic_streambuf pour lequel il a été construit.

Le std::istreambuf_iterator construit par défaut est connu sous le nom d'itérateur de fin de flux . Lorsqu'un std::istreambuf_iterator atteint la fin du flux sous-jacent, il devient égal à l'itérateur de fin de flux. Le déréférencement ou l'incrémentation ultérieure invoque un comportement indéfini.

std::istreambuf_iterator possède un constructeur de copie trivial, un constructeur par défaut constexpr et un destructeur trivial.

(depuis C++11)

Table des matières

Types membres

Type de membre Définition
iterator_category std:: input_iterator_tag
value_type CharT
difference_type typename Traits :: off_type
pointer /* unspecified */
reference CharT
char_type CharT
traits_type Traits
int_type typename Traits :: int_type
streambuf_type std:: basic_streambuf < CharT, Traits >
istream_type std:: basic_istream < CharT, Traits >
/* proxy */ Type de classe défini par l'implémentation.
Un objet proxy contient un caractère char_type et un pointeur streambuf_type* .
Le déréférencement d'un objet proxy avec operator* retourne le caractère stocké.
( type de membre d'exposition uniquement* )

Les types membres iterator_category , value_type , difference_type , pointer et reference doivent être obtenus en héritant de std:: iterator < std:: input_iterator_tag , CharT, typename Traits :: off_type , /* non spécifié */ , CharT > .

(jusqu'à C++17)

Le type membre pointer est généralement CharT* (voir ci-dessous ).

Fonctions membres

construit un nouveau istreambuf_iterator
(fonction membre publique)
(destructeur)
(déclaré implicitement)
détruit un istreambuf_iterator
(fonction membre publique)
obtient une copie du caractère actuel
(fonction membre publique)
avance l'itérateur
(fonction membre publique)
teste si deux istreambuf_iterator sont tous deux en fin de flux ou tous deux valides
(fonction membre publique)

Fonctions non membres

(supprimé en C++20)
compare deux istreambuf_iterator s
(modèle de fonction)

Notes

La résolution de LWG issue 659 a introduit operator - > . Il est attendu que pour un std::istreambuf_iterator i , les expressions ( * i ) . m et i - > m aient le même effet.

Cependant, la résolution ne fournit pas une spécification formelle de son comportement. Ainsi, elle est implémentée différemment, incluant le retour de nullptr , le retour de l'adresse d'un temporaire, ou ne fournit même pas du tout le membre. Son comportement prévu est difficilement réalisable, et il est supprimé par la résolution de LWG issue 2790 .

La résolution de LWG issue 659 a également rendu le type membre pointer non spécifié afin de permettre à operator-> de retourner un proxy. Ceci permet à operator-> de compiler lorsque CharT n'est pas un type classe.

Exemple

Exécuter ce code 
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
int main()
{
    // cas d'utilisation typique : un flux d'entrée représenté comme une paire d'itérateurs
    std::istringstream in{"Hello, world"};
    std::istreambuf_iterator<char> it{in}, end;
    std::string ss{it, end};
    std::cout << "ss has " << ss.size() << " bytes; "
                 "it holds \"" << ss << "\"\n";
    // démonstration de la nature à passage unique
    std::istringstream s{"abc"};
    std::istreambuf_iterator<char> i1{s}, i2{s};
    std::cout << "i1 returns '" << *i1 << "'\n"
                 "i2 returns '" << *i2 << "'\n";
    ++i1;
    std::cout << "after incrementing i1, but not i2:\n"
                 "i1 returns '" << *i1 << "'\n"
                 "i2 returns '" << *i2 << "'\n";
    ++i2;
    std::cout << "after incrementing i2, but not i1:\n"
                 "i1 returns '" << *i1 << "'\n"
                 "i2 returns '" << *i2 << "'\n";
}

Sortie : 

ss has 12 bytes; it holds "Hello, world"
i1 returns 'a'
i2 returns 'a'
after incrementing i1, but not i2:
i1 returns 'b'
i2 returns 'b'
after incrementing i2, but not i1:
i1 returns 'c'
i2 returns 'c'

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 Applicable à Comportement publié Comportement corrigé
LWG 659 C++98 1. std::istreambuf_iterator ne possédait pas operator - >
2. le type membre pointer était spécifié comme CharT* 		1. ajouté
2. rendu non spécifié
LWG 2790 C++98 l' operator - > ajouté par LWG issue 659 n'était pas utile supprimé

Voir aussi

itérateur de sortie qui écrit dans std::basic_streambuf
(modèle de classe)
itérateur d'entrée qui lit depuis std::basic_istream
(modèle de classe)