Partager via

La classe basic_istream

  • Article

Décrit un objet qui contrôle l’extraction d’éléments et d’objets encodés à partir d’une mémoire tampon de flux avec des éléments de type Char_T, également appelés char_type, dont les caractéristiques de caractère sont déterminées par la classe Tr, également appelée traits_type.

Syntaxe

template <class Char_T, class Tr = char_traits<Char_T>>
class basic_istream : virtual public basic_ios<Char_T, Tr>

Notes

La plupart des fonctions membres surchargées operator>> sont des fonctions d’entrée mises en forme. Elles suivent le modèle :

iostate state = goodbit;
const sentry ok(*this);

if (ok)
{
    try
    {
        /*extract elements and convert
            accumulate flags in state.
            store a successful conversion*/
    }
    catch (...)
    {
        try
        {
            setstate(badbit);

        }
        catch (...)
        {
        }
        if ((exceptions()& badbit) != 0)
            throw;
    }
}
setstate(state);

return (*this);

De nombreuses autres fonctions membres sont des fonctions d'entrée non mise en forme. Elles suivent le modèle :

iostate state = goodbit;
count = 0;    // the value returned by gcount
const sentry ok(*this, true);

if (ok)
{
    try
    {
        /* extract elements and deliver
            count extracted elements in count
            accumulate flags in state */
    }
    catch (...)
    {
        try
        {
            setstate(badbit);

        }
        catch (...)
        {
        }
        if ((exceptions()& badbit) != 0)
            throw;
    }
}
setstate(state);

Les deux groupes de fonctions appellent setstate(eofbit) s’ils rencontrent la fin du fichier lors de l’extraction d’éléments. Pour plus d’informations, consultez setstate.

Objet de classe basic_istream<Char_T, Tr> stocke :

  • Objet de base public virtuel de classe basic_ios<Char_T, Tr>. Pour plus d’informations, consultez basic_ios.

  • Nombre d’extractions pour la dernière opération d’entrée non mise en forme (appelée count dans le code précédent).

Exemple

Consultez l’exemple de basic_ifstream classe pour en savoir plus sur les flux d’entrée.

Constructeurs

Constructeur Description
basic_istream Construit un objet de type basic_istream.

Fonctions Membre

Fonction membre Description
gcount Retourne le nombre de caractères lus au cours de la dernière entrée non mise en forme.
get Lit un ou plusieurs caractères dans le flux d'entrée.
getline Lit une ligne dans le flux d'entrée.
ignore Ignore un certain nombre d'éléments à partir de la position de lecture actuelle.
peek Retourne le caractère suivant à lire.
putback Place un caractère spécifié dans le flux.
read Lit un nombre spécifié de caractères dans le flux et les stocke dans un tableau.
readsome Lire seulement dans la mémoire tampon.
seekg Déplace la position de lecture dans un flux.
sentry La classe imbriquée décrit un objet dont la déclaration structure les fonctions d'entrée mise en forme et les fonctions d'entrée non mise en forme.
swap Échange cet objet basic_istream pour le paramètre d'objet basic_istream fourni.
sync Synchronise l’appareil d’entrée associé au flux avec la mémoire tampon du flux.
tellg Indique la position de lecture actuelle dans le flux.
unget Replace le dernier caractère lu dans le flux.

Opérateurs

Opérateur Description
operator>> Appelle une fonction sur le flux d'entrée ou lit les données mises en forme dans le flux d'entrée.
operator= Affecte le basic_istream du côté droit de l'opérateur à cet objet. Il s’agit d’une affectation de déplacement impliquant une rvalue référence qui ne laisse pas de copie derrière elle.

Spécifications

En-tête<istream>:

Espace de noms :std

basic_istream::basic_istream

Construit un objet de type basic_istream.

explicit basic_istream(
    basic_streambuf<Char_T, Tr>* strbuf,
    bool _Isstd = false);

basic_istream(basic_istream&& right);

Paramètres

strbuf
Objet de type basic_streambuf.

_Isstd
true s’il s’agit d’un flux standard ; sinon, false.

right
Objet basic_istream à copier.

Notes

Le premier constructeur initialise la classe de base en appelant init(strbuf). Il stocke également zéro dans le nombre d’extractions. Pour plus d’informations, consultez init. Pour plus d’informations sur ce nombre d’extractions, consultez la section Remarques de la vue d’ensemble de la basic_istream classe .

Le deuxième constructeur initialise la classe de base en appelant move(right). Il stocke right.gcount() également dans le nombre d’extraction et stocke zéro dans le nombre d’extraction pour right.

Exemple

Consultez l’exemple pour basic_ifstream::basic_ifstream en savoir plus sur les flux d’entrée.

basic_istream::gcount

Retourne le nombre de caractères lus au cours de la dernière entrée non mise en forme.

streamsize gcount() const;

Valeur de retour

Nombre d’extractions.

Notes

Permet basic_istream::get de lire des caractères non mis en forme.

Exemple

// basic_istream_gcount.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   cout << "Type the letter 'a': ";

   ws( cin );
   char c[10];

   cin.get( &c[0],9 );
   cout << c << endl;

   cout << cin.gcount( ) << endl;
}

a

Type the letter 'a': a
1

basic_istream::get

Lit un ou plusieurs caractères dans le flux d'entrée.

int_type get();

basic_istream<Char_T, Tr>& get(Char_T& Ch);
basic_istream<Char_T, Tr>& get(Char_T* str, streamsize count);
basic_istream<Char_T, Tr>& get(Char_T* str, streamsize count, Char_T delimiter);

basic_istream<Char_T, Tr>& get(basic_streambuf<Char_T, Tr>& strbuf);
basic_istream<Char_T, Tr>& get(basic_streambuf<Char_T, Tr>& strbuf, Char_T delimiter);

Paramètres

count
Nombre de caractères à lire à partir de strbuf.

delimiter
Caractère qui doit terminer la lecture si elle est rencontrée avant count.

str
Chaîne dans laquelle écrire.

Ch
Caractère à obtenir.

strbuf
Mémoire tampon dans laquelle écrire.

Valeur de retour

La forme sans paramètre de get renvoie l’élément lu sous la forme d’un entier ou d’une fin de fichier. Les formulaires restants retournent le flux (*this).

Notes

La première fonction d’entrée non mise en forme extrait un élément, si possible, comme si c’était le cas en retournant rdbuf->sbumpc. Sinon, traits_type::eofest retourné. Si la fonction extrait aucun élément, elle appelle setstate(failbit). Pour plus d’informations, consultez setstate.

La deuxième fonction extrait l’élément meta de la int_type même façon. Si meta la comparaison est égale à traits_type::eof, la fonction appelle setstate(failbit). Sinon, il stocke traits_type::to_char_type(meta) dans Ch. La fonction retourne *this. Pour plus d’informations, consultez to_char_type.

La troisième fonction retourne get(str, count, widen('\n')).

La quatrième fonction extrait jusqu’aux count - 1 éléments et les stocke dans le tableau à partir de str. Elle stocke toujours char_type après les éléments extraits qu’elle stocke. Pour les besoins du test, l’extraction s’arrête :

  • À la fin du fichier.

  • Une fois la fonction extraite un élément qui est égal à delimiter. Dans ce cas, l’élément est remis à la séquence contrôlée.

  • Une fois la fonction extraite des count - 1 éléments.

Si la fonction n’extrait aucun élément, elle appelle setstate(failbit). Dans tous les cas, elle retourne *this.

La cinquième fonction retourne get(strbuf, widen('\n')).

La sixième fonction extrait les éléments et les insère .strbuf L’extraction s’arrête sur la fin du fichier ou sur un élément qui est égal à delimiter, qui n’est pas extrait. Elle s’arrête également, sans extraire l’élément en question, si une insertion échoue ou lève une exception (qui est interceptée, mais n’est pas levée à nouveau). Si la fonction n’extrait aucun élément, elle appelle setstate(failbit). Dans tous les cas, la fonction retourne *this.

Exemple

// basic_istream_get.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10];

   c[0] = cin.get( );
   cin.get( c[1] );
   cin.get( &c[2],3 );
   cin.get( &c[4], 4, '7' );

   cout << c << endl;
}

1111

basic_istream::getline

Obtient une ligne du flux d’entrée.

basic_istream<Char_T, Tr>& getline(
    char_type* str,
    streamsize count);

basic_istream<Char_T, Tr>& getline(
    char_type* str,
    streamsize count,
    char_type delimiter);

Paramètres

count
Nombre de caractères à lire à partir de strbuf.

delimiter
Caractère qui doit terminer la lecture si elle est rencontrée avant count.

str
Chaîne dans laquelle écrire.

Valeur de retour

Flux (*this).

Notes

La première de ces fonctions d’entrée non mises en forme retourne getline(str, count, widen('\n')).

La deuxième fonction extrait jusqu’aux count - 1 éléments et les stocke dans le tableau à partir de str. Elle stocke toujours le caractère de fin de chaîne après tous les éléments extraits qu’elle stocke. Pour les besoins du test, l’extraction s’arrête :

  • À la fin du fichier.

  • Une fois la fonction extraite un élément qui est égal à delimiter. Dans ce cas, l’élément n’est pas remis en arrière et il n’est pas ajouté à la séquence contrôlée.

  • Une fois la fonction extraite des count - 1 éléments.

Si la fonction extrait aucun élément ou count - 1 élément, elle appelle setstate(failbit). Dans tous les cas, elle retourne *this. Pour plus d’informations, consultez setstate.

Exemple

// basic_istream_getline.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10];

   cin.getline( &c[0], 5, '2' );
   cout << c << endl;
}

121

basic_istream::ignore

Ignore un certain nombre d'éléments à partir de la position de lecture actuelle.

basic_istream<Char_T, Tr>& ignore(
    streamsize count = 1,
    int_type delimiter = traits_type::eof());

Paramètres

count
Nombre d’éléments à ignorer à partir de la position de lecture actuelle.

delimiter
L’élément qui, s’il est rencontré avant le nombre, provoque ignore le retour et l’autorisation de tous les éléments après delimiter avoir été lus.

Valeur de retour

Flux (*this).

Notes

La fonction d’entrée sans mise en forme extrait jusqu’à count éléments et les ignore. Si count elle numeric_limits<int>::maxest égale, cependant, elle est considérée comme arbitrairement importante. L’extraction s’arrête tôt à la fin du fichier ou sur un élément Ch de sorte qu’elle traits_type::to_int_type(Ch) soit égale à delimiter (qui est également extraite). La fonction retourne *this. Pour plus d’informations, consultez to_int_type.

Exemple

// basic_istream_ignore.cpp
// compile with: /EHsc
#include <iostream>
int main( )
{
   using namespace std;
   char chararray[10];
   cout << "Type 'abcdef': ";
   cin.ignore( 5, 'c' );
   cin >> chararray;
   cout << chararray;
}

Type 'abcdef': abcdef
def

basic\_istream::operator>>

Appelle une fonction sur le flux d'entrée ou lit les données mises en forme dans le flux d'entrée.

basic_istream& operator>>(basic_istream& (* Pfn)(basic_istream&));
basic_istream& operator>>(ios_base& (* Pfn)(ios_base&));
basic_istream& operator>>(basic_ios<Char_T, Tr>& (* Pfn)(basic_ios<Char_T, Tr>&));
basic_istream& operator>>(basic_streambuf<Char_T, Tr>* strbuf);
basic_istream& operator>>(bool& val);
basic_istream& operator>>(short& val);
basic_istream& operator>>(unsigned short& val);
basic_istream& operator>>(int& val);
basic_istream& operator>>(unsigned int& val);
basic_istream& operator>>(long& val);
basic_istream& operator>>(unsigned long& val);
basic_istream& operator>>(long long& val);
basic_istream& operator>>(unsigned long long& val);
basic_istream& operator>>(void *& val);
basic_istream& operator>>(float& val);
basic_istream& operator>>(double& val);
basic_istream& operator>>(long double& val);

Paramètres

Pfn
Pointeur de fonction.

strbuf
Objet de type stream_buf.

val
Valeur à lire à partir du flux.

Valeur de retour

Flux (*this).

Notes

L’en-tête <istream> définit également plusieurs opérateurs d’extraction globaux. Pour plus d’informations, consultez operator>> (\<istream>).

La première fonction membre garantit qu’une expression des appels de formulaireistr >> ws, puis retourne *this.ws(istr) Pour plus d’informations, consultez ws.

Les deuxième et troisième fonctions garantissent que d’autres manipulateurs, tels que hex, se comportent de la même façon. Les fonctions restantes sont les fonctions d’entrée mises en forme.

La fonction  :

basic_istream& operator>>(
    basic_streambuf<Char_T, Tr>* strbuf);

extrait des éléments, s’il strbuf ne s’agit pas d’un pointeur Null, et les insère .strbuf L’extraction s’arrête à la fin du fichier. Elle s’arrête également, sans extraire l’élément en question, si une insertion échoue ou lève une exception (qui est interceptée, mais n’est pas levée à nouveau). Si la fonction n’extrait aucun élément, elle appelle setstate(failbit). Dans tous les cas, la fonction retourne *this. Pour plus d’informations, consultez setstate.

La fonction  :

basic_istream& operator>>(bool& val);

extrait un champ et le convertit en valeur booléenne en appelant use_facet< num_get<Char_T, InIt>(getloc).get( InIt(rdbuf), Init(0), *this, getloc, val). Ici, InIt est défini comme istreambuf_iterator<Char_T, Tr>. La fonction retourne *this.

Pour plus d’informations, consultez use_facet, getloc, get, rdbuf et istreambuf_iterator.

Chacune des fonctions :

basic_istream& operator>>(short& val);
basic_istream& operator>>(unsigned short& val);
basic_istream& operator>>(int& val);
basic_istream& operator>>(unsigned int& val);
basic_istream& operator>>(long& val);
basic_istream& operator>>(unsigned long& val);
basic_istream& operator>>(long long& val);
basic_istream& operator>>(unsigned long long& val);
basic_istream& operator>>(void *& val);

extrayez un champ et convertissez-le en valeur numérique en appelant use_facet<num_get<Char_T, InIt>(getloc).get(InIt(rdbuf), Init(0), *this, getloc, val). Ici, InIt est défini comme istreambuf_iterator<Char_T, Tr>, et val a le type long, unsigned longou void * si nécessaire.

Si la valeur convertie ne peut pas être représentée comme type de val, la fonction appelle setstate(failbit). Dans tous les cas, la fonction retourne *this. Pour plus d’informations, consultez setstate.

Chacune des fonctions :

basic_istream& operator>>(float& val);
basic_istream& operator>>(double& val);
basic_istream& operator>>(long double& val);

extrayez un champ et convertissez-le en valeur numérique en appelant use_facet<num_get<Char_T, InIt>(getloc).get(InIt(rdbuf), Init(0), *this, getloc, val). Ici, InIt est défini comme istreambuf_iterator<Char_T, Tr>, et val a le type double ou long double si nécessaire.

Si la valeur convertie ne peut pas être représentée comme type de val, la fonction appelle setstate(failbit). Dans tous les cas, elle retourne *this.

Exemple

// istream_basic_istream_op_is.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;

ios_base& hex2( ios_base& ib )
{
   ib.unsetf( ios_base::dec );
   ib.setf( ios_base::hex );
   return ib;
}

basic_istream<char, char_traits<char> >& somefunc(basic_istream<char, char_traits<char> > &i)
{
   if ( i == cin )
   {
      cerr << "i is cin" << endl;
   }
   return i;
}

int main( )
{
   int i = 0;
   cin >> somefunc;
   cin >> i;
   cout << i << endl;
   cin >> hex2;
   cin >> i;
   cout << i << endl;
}

basic_istream::operator=

Affecte le basic_istream du côté droit de l'opérateur à cet objet. Il s’agit d’une affectation de déplacement impliquant une rvalue référence qui ne laisse pas de copie derrière elle.

basic_istream& operator=(basic_istream&& right);

Paramètres

right
Référence rvalue à un objet basic_ifstream.

Valeur de retour

Retourne *this.

Notes

L’opérateur membre appelle swap(right).

basic_istream::peek

Retourne le caractère suivant à lire.

int_type peek();

Valeur de retour

Caractère suivant à lire.

Notes

La fonction d’entrée non mise en forme extrait un élément, si possible, comme si c’était le cas en retournant rdbuf->sgetc. Sinon, traits_type::eofest retourné. Pour plus d’informations, consultez sgetc et eof.

Exemple

// basic_istream_peek.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10], c2;
   cout << "Type 'abcde': ";

   c2 = cin.peek( );
   cin.getline( &c[0], 9 );

   cout << c2 << " " << c << endl;
}

abcde

Type 'abcde': abcde
a abcde

basic_istream::putback

Place un caractère spécifié dans le flux.

basic_istream<Char_T, Tr>& putback(
    char_type Ch);

Paramètres

Ch
Caractère à remettre dans le flux.

Valeur de retour

Flux (*this).

Notes

La fonction d’entrée non mise en forme revient Ch, si possible, comme si elle appelait rdbuf->sputbackc. S’il rdbuf s’agit d’un pointeur Null ou si l’appel à sputbackc renvoyer traits_type::eof, la fonction appelle setstate(badbit). Dans tous les cas, elle retourne *this.

Pour plus d'informations, voir rdbuf, sputbackc, eof et setstate.

Exemple

// basic_istream_putback.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10], c2, c3;

   c2 = cin.get( );
   c3 = cin.get( );
   cin.putback( c2 );
   cin.getline( &c[0], 9 );
   cout << c << endl;
}

qwq

basic_istream::read

Lit un nombre spécifié de caractères dans le flux et les stocke dans un tableau.

Cette méthode est potentiellement dangereuse, car elle suppose que l’appelant vérifie que les valeurs passées sont correctes.

basic_istream<Char_T, Tr>& read(
    char_type* str,
    streamsize count);

Paramètres

str
Tableau dans lequel lire les caractères.

count
Nombre de caractères à lire.

Valeur de retour

Le flux ( *this).

Notes

La fonction d’entrée non mise en forme extrait jusqu’aux count éléments et les stocke dans le tableau à partir de str. L’extraction s’arrête tôt à la fin du fichier, auquel cas la fonction appelle setstate(failbit). Dans tous les cas, elle retourne *this. Pour plus d’informations, consultez setstate.

Exemple

// basic_istream_read.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main()
{
    char c[10];
    int count = 5;

    cout << "Type 'abcde': ";

    // Note: cin::read is potentially unsafe, consider
    // using cin::_Read_s instead.
    cin.read(&c[0], count);
    c[count] = 0;

    cout << c << endl;
}

abcde

Type 'abcde': abcde
abcde

basic_istream::readsome

Lit le nombre spécifié de valeurs de caractère.

Cette méthode est potentiellement dangereuse, car elle suppose que l’appelant vérifie que les valeurs passées sont correctes.

streamsize readsome(
    char_type* str,
    streamsize count);

Paramètres

str
Tableau dans lequel readsome stocke les caractères qu’il lit.

count
Nombre de caractères à lire.

Valeur de retour

Nombre de caractères réellement lus, gcount.

Notes

Cette fonction d’entrée sans mise en forme extrait jusqu’à count éléments du flux d’entrée et les stocke dans le tableau str.

Cette fonction n’attend pas l’entrée. Elle lit toutes les données disponibles.

Exemple

// basic_istream_readsome.cpp
// compile with: /EHsc /W3
#include <iostream>
using namespace std;

int main( )
{
   char c[10];
   int count = 5;

   cout << "Type 'abcdefgh': ";

   // cin.read blocks until user types input.
   // Note: cin::read is potentially unsafe, consider
   // using cin::_Read_s instead.
   cin.read(&c[0], 2);

   // Note: cin::readsome is potentially unsafe, consider
   // using cin::_Readsome_s instead.
   int n = cin.readsome(&c[0], count);  // C4996
   c[n] = 0;
   cout << n << " characters read" << endl;
   cout << c << endl;
}

basic_istream::seekg

Déplace la position de lecture dans un flux.

basic_istream<Char_T, Tr>& seekg(pos_type pos);

basic_istream<Char_T, Tr>& seekg(off_type off, ios_base::seekdir way);

Paramètres

pos
Position absolue à laquelle déplacer le pointeur de lecture.

off
Décalage pour déplacer le pointeur de lecture par rapport à way.

way
Une des ios_base::seekdir énumérations.

Valeur de retour

Flux (*this).

Notes

La première fonction membre effectue une recherche absolue, la deuxième fonction membre effectue une recherche relative.

Remarque

N’utilisez pas la deuxième fonction membre avec des fichiers texte, car la norme C++ ne prend pas en charge les recherches relative dans des fichiers texte.

Si fail c’est falsele cas, la première fonction membre appelle newpos = rdbuf->pubseekpos(pos), pour un pos_type objet newpostemporaire . Si fail c’est falsele cas, la deuxième fonction appelle newpos = rdbuf->pubseekoff( off, way). Dans les deux cas, si (off_type)newpos == (off_type)(-1) (l’opération de positionnement échoue), la fonction appelle istr.setstate(failbit). Les deux fonctions retournent *this.

Si fail c’est truele cas, les fonctions membres ne font rien.

Pour plus d'informations, voir rdbuf, pubseekpos, pubseekoff et setstate.

Exemple

// basic_istream_seekg.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main ( )
{
   using namespace std;
   ifstream file;
   char c, c1;

   file.open( "basic_istream_seekg.txt" );
   file.seekg(2);   // seek to position 2
   file >> c;
   cout << c << endl;
}

basic_istream::sentry

La classe imbriquée décrit un objet dont la déclaration structure les fonctions d’entrée avec et sans mise en forme.

class sentry {
   public:
   explicit sentry(
      basic_istream<Char_T, Tr>& _Istr,
      bool _Noskip = false);
   operator bool() const;
   };

Notes

Si _Istr.good c’est truele cas, le constructeur :

  • Appelle _Istr.tie->flush si _Istr.tie ce n’est pas un pointeur Null.

  • ws(_Istr) Appelle effectivement s’il _Istr.flags & skipws n’est pas différent de zéro.

Si après une telle préparation, _Istr.good est false, le constructeur appelle _Istr.setstate(failbit). Dans tous les cas, le constructeur stocke la valeur retournée par _Istr.good .status Un appel ultérieur pour operator bool remettre cette valeur stockée.

Pour plus d’informations, consultez good, tie, flush, ws, flags, skipws et setstate.

basic_istream::swap

Échange le contenu de deux objets basic_istream.

void swap(basic_istream& right);

Paramètres

right
Référence lvalue à un objet basic_istream.

Notes

La fonction membre appelle basic_ios::swap(right). Elle échange également le nombre d'extractions avec le nombre d'extractions pour right. Pour plus d’informations, consultez basic_ios::swap.

basic_istream::sync

Synchronise l’appareil d’entrée associé au flux avec la mémoire tampon du flux.

int sync();

Valeur de retour

S’il rdbuf s’agit d’un pointeur Null, la fonction retourne -1. Sinon, il appelle rdbuf->pubsync. Si cet appel retourne -1, la fonction appelle setstate(badbit) et retourne -1. Sinon, la fonction retourne zéro. Pour plus d’informations, consultez pubsync et setstate.

basic_istream::tellg

Indique la position de lecture actuelle dans le flux.

pos_type tellg();

Valeur de retour

Position actuelle dans le flux.

Notes

Si fail c’est falsele cas, la fonction membre retourne rdbuf->pubseekoff(0, cur, in). Sinon, pos_type(-1)est retourné. Pour plus d’informations, consultez rdbuf et pubseekoff.

Exemple

// basic_istream_tellg.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main()
{
    using namespace std;
    ifstream file;
    char c;
    streamoff i;

    file.open("basic_istream_tellg.txt");
    i = file.tellg();
    file >> c;
    cout << c << " " << i << endl;

    i = file.tellg();
    file >> c;
    cout << c << " " << i << endl;
}

basic_istream::unget

Replace le dernier caractère lu dans le flux.

basic_istream<Char_T, Tr>& unget();

Valeur de retour

Flux (*this).

Notes

La fonction d’entrée non mise en forme place l’élément précédent dans le flux, si possible, comme si elle appelait rdbuf->sungetc If rdbuf est un pointeur Null ou si l’appel à sungetc renvoyer traits_type::eof, la fonction appelle setstate(badbit). Dans tous les cas, elle retourne *this.

Pour plus d'informations, consultez sungetc, eof et setstate. Pour plus d’informations sur la façon dont unget l’échec peut échouer, consultez basic_streambuf::sungetc.

Exemple

// basic_istream_unget.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10], c2;

   cout << "Type 'abc': ";
   c2 = cin.get( );
   cin.unget( );
   cin.getline( &c[0], 9 );
   cout << c << endl;
}

abc

Type 'abc': abc
abc

Voir aussi

Sécurité des threads dans la bibliothèque C++ Standard
iostream Programmation
iostreams Conventions