Classe `basic_istream`

Articolo
10/12/2023

Descrive un oggetto che controlla l'estrazione di elementi e oggetti codificati da un buffer di flusso con elementi di tipo Char_T, noti anche come char_type, i cui tratti di carattere sono determinati dalla classe Tr, noto anche come traits_type.

Sintassi

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

Osservazioni:

La maggior parte delle funzioni membro che eseguono l'overload operator>> sono funzioni di input formattate. Le funzioni seguono questo schema:

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);

Molte altre funzioni membro sono funzioni di input formattate. Le funzioni seguono questo schema:

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);

Entrambi i gruppi di funzioni chiamano setstate(eofbit) se incontrano la fine del file durante l'estrazione di elementi. Per ulteriori informazioni, vedere setstate.

Oggetto degli archivi di classi basic_istream<Char_T, Tr> :

Oggetto di base pubblico virtuale della classe basic_ios<Char_T, Tr>. Per ulteriori informazioni, vedere basic_ios.
Numero di estrazione per l'ultima operazione di input non formattata (chiamata count nel codice precedente).

Esempio

Vedere l'esempio relativo basic_ifstream a Class per altre informazioni sui flussi di input.

Costruttori

Costruttore	Descrizione
`basic_istream`	Costruisce un oggetto di tipo `basic_istream`.

Funzioni membro

Funzione membro	Descrizione
`gcount`	Restituisce il numero di caratteri letti durante l'ultimo input non formattato.
`get`	Legge uno o più caratteri dal flusso di input.
`getline`	Legge una riga dal flusso di input.
`ignore`	Fa sì che un certo numero di elementi venga ignorato dalla posizione di lettura corrente.
`peek`	Restituisce il carattere successivo da leggere.
`putback`	Inserisce un carattere specificato nel flusso.
`read`	Legge un numero specificato di caratteri dal flusso e li archivia in una matrice.
`readsome`	Legge solo dal buffer.
`seekg`	Sposta la posizione di lettura in un flusso.
`sentry`	La classe annidata descrive un oggetto la cui dichiarazione struttura le funzioni di input formattate e quelle non formattate.
`swap`	Scambia questo oggetto `basic_istream` con il parametro dell'oggetto `basic_istream` specificato.
`sync`	Sincronizza il dispositivo di input associato al flusso con il buffer del flusso.
`tellg`	Segnala la posizione corrente all'interno del flusso.
`unget`	Reinserisce il carattere letto più di recente nel flusso.

Operatori

Operatore	Descrizione
`operator>>`	Chiama una funzione nel flusso di input o legge dati formattati dal flusso di input.
`operator=`	Assegna l'oggetto `basic_istream` a destra dell'operatore a questo oggetto. Si tratta di un'assegnazione di spostamento che implica un `rvalue` riferimento che non lascia una copia dietro.

Requisiti

Intestazione: <istream>

Spazio dei nomi: std

`basic_istream::basic_istream`

Costruisce un oggetto di tipo basic_istream.

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

basic_istream(basic_istream&& right);

Parametri

strbuf
Un oggetto di tipo basic_streambuf.

_Isstd
true se è un flusso standard; in caso contrario, false.

right
Oggetto basic_istream da copiare.

Osservazioni:

Il primo costruttore inizializza la classe base chiamando init(strbuf). Archivia anche zero nel conteggio di estrazione. Per ulteriori informazioni, vedere init. Per altre informazioni su questo conteggio di estrazione, vedere la sezione Osservazioni della panoramica della basic_istream classe .

Il secondo costruttore inizializza la classe base chiamando move(right). Archivia anche right.gcount() nel conteggio di estrazione e archivia zero nel conteggio di estrazione per right.

Esempio

Vedere l'esempio per basic_ifstream::basic_ifstream altre informazioni sui flussi di input.

`basic_istream::gcount`

Restituisce il numero di caratteri letti durante l'ultimo input non formattato.

streamsize gcount() const;

Valore restituito

Il conteggio di estrazione.

Osservazioni:

Utilizzare basic_istream::get per leggere caratteri non formattati.

Esempio

// 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;
}

Type the letter 'a': a
1

`basic_istream::get`

Legge uno o più caratteri dal flusso di input.

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);

Parametri

count
Numero di caratteri da leggere da strbuf.

delimiter
Carattere che deve terminare la lettura se viene rilevata prima countdi .

str
Una stringa in cui scrivere.

Ch
Un carattere da ottenere.

strbuf
Un buffer in cui scrivere.

Valore restituito

La forma senza parametri di get restituisce l'elemento letto come numero intero o fine del file. I moduli rimanenti restituiscono il flusso (*this).

Osservazioni:

La prima funzione di input non formattata estrae, se possibile, un elemento come se restituisce rdbuf->sbumpc. In caso contrario, viene restituito traits_type::eof. Se la funzione non estrae alcun elemento, chiama setstate(failbit). Per ulteriori informazioni, vedere setstate.

La seconda funzione estrae l'elemento int_type meta nello stesso modo. Se meta viene confrontato uguale a traits_type::eof, la funzione chiama setstate(failbit). In caso contrario, archivia traits_type::to_char_type(meta) in Ch. La funzione restituisce *this. Per ulteriori informazioni, vedere to_char_type.

La terza funzione restituisce get(str, count, widen('\n')).

La quarta funzione estrae fino agli count - 1 elementi e li archivia nella matrice a partire da str. char_type viene sempre archiviato dopo gli elementi estratti archiviati. In ordine di test, l'estrazione si interrompe:

Alla fine del file.
Dopo che la funzione estrae un elemento che confronta uguale a delimiter. In questo caso, l'elemento viene riportato alla sequenza controllata.
Dopo che la funzione estrae gli count - 1 elementi.

Se non estrae alcun elemento, la funzione chiama setstate(failbit). In tutti i casi, restituisce *this.

La quinta funzione restituisce get(strbuf, widen('\n')).

La sesta funzione estrae gli elementi e li inserisce in strbuf. L'estrazione si arresta alla fine del file o su un elemento che confronta uguale a delimiter, che non viene estratto. L'estrazione si interrompe anche, senza estrazione dell'elemento, se un inserimento ha esito negativo o genera un'eccezione che viene rilevata ma non generata nuovamente. Se non estrae alcun elemento, la funzione chiama setstate(failbit). In ogni caso, la funzione restituisce *this.

Esempio

// 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;
}

`basic_istream::getline`

Ottiene una riga dal flusso di input.

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);

Parametri

count
Numero di caratteri da leggere da strbuf.

delimiter
Carattere che deve terminare la lettura se viene rilevata prima countdi .

str
Una stringa in cui scrivere.

Valore restituito

Flusso (*this).

Osservazioni:

La prima di queste funzioni di input non formattate restituisce getline(str, count, widen('\n')).

La seconda funzione estrae fino agli count - 1 elementi e li archivia nella matrice a partire da str. La funzione archivia sempre il carattere di terminazione della stringa dopo gli elementi estratti archiviati. In ordine di test, l'estrazione si interrompe:

Alla fine del file.
Dopo che la funzione estrae un elemento che confronta uguale a delimiter. In questo caso, l'elemento non viene riportato di nuovo e non viene aggiunto alla sequenza controllata.
Dopo che la funzione estrae gli count - 1 elementi.

Se la funzione non estrae elementi o count - 1 elementi, chiama setstate(failbit). In tutti i casi, restituisce *this. Per ulteriori informazioni, vedere setstate.

Esempio

// 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;
}

`basic_istream::ignore`

Fa sì che un certo numero di elementi venga ignorato dalla posizione di lettura corrente.

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

Parametri

count
Numero di elementi da ignorare dalla posizione di lettura corrente.

delimiter
Elemento che, se rilevato prima del conteggio, restituisce ignore e consente la lettura di tutti gli elementi.delimiter

Valore restituito

Flusso (*this).

Osservazioni:

La funzione di input non formattato estrae fino a count elementi e li ignora. Se count è uguale numeric_limits<int>::maxa , tuttavia, viene considerato arbitrariamente grande. L'estrazione si interrompe all'inizio della fine del file o su un elemento Ch che traits_type::to_int_type(Ch) confronta uguale a delimiter (che viene estratto anche). La funzione restituisce *this. Per ulteriori informazioni, vedere to_int_type.

Esempio

// 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>>`

Chiama una funzione nel flusso di input o legge dati formattati dal flusso di input.

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);

Parametri

Pfn
Un puntatore di funzione.

strbuf
Oggetto di tipo stream_buf.

val
Valore che deve essere letto dal flusso.

Valore restituito

Flusso (*this).

Osservazioni:

L'intestazione <istream> definisce anche numerosi operatori di estrazione globali. Per ulteriori informazioni, vedere operator>> (\<istream>).

La prima funzione membro garantisce che un'espressione del modulo istr >> ws chiami ws(istr)e quindi restituisca *this. Per ulteriori informazioni, vedere ws.

La seconda e la terza funzione assicurano che altri manipolatori, ad esempio hex, si comportino in modo analogo. Le funzioni rimanenti sono le funzioni di input formattate.

La funzione :

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

estrae gli elementi, se strbuf non è un puntatore Null e li inserisce in strbuf. L'estrazione si interrompe alla fine del file. L'estrazione si interrompe anche, senza estrazione dell'elemento, se un inserimento ha esito negativo o genera un'eccezione che viene rilevata ma non generata nuovamente. Se non estrae alcun elemento, la funzione chiama setstate(failbit). In ogni caso, la funzione restituisce *this. Per ulteriori informazioni, vedere setstate.

La funzione :

basic_istream& operator>>(bool& val);

estrae un campo e lo converte in un valore booleano chiamando use_facet< num_get<Char_T, InIt>(getloc).get( InIt(rdbuf), Init(0), *this, getloc, val). In questo caso, InIt è definito come istreambuf_iterator<Char_T, Tr>. La funzione restituisce *this.

Per altre informazioni, vedere use_facet, getloc, get, rdbuf e istreambuf_iterator.

Ognuna delle funzioni:

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);

estrarre un campo e convertirlo in un valore numerico chiamando use_facet<num_get<Char_T, InIt>(getloc).get(InIt(rdbuf), Init(0), *this, getloc, val). In questo caso, InIt viene definito come istreambuf_iterator<Char_T, Tr>e val ha il tipo long, unsigned longo void * in base alle esigenze.

Se il valore convertito non può essere rappresentato come tipo di val, la funzione chiama setstate(failbit). In ogni caso, la funzione restituisce *this. Per ulteriori informazioni, vedere setstate.

Ognuna delle funzioni:

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

estrarre un campo e convertirlo in un valore numerico chiamando use_facet<num_get<Char_T, InIt>(getloc).get(InIt(rdbuf), Init(0), *this, getloc, val). In questo caso, InIt è definito come istreambuf_iterator<Char_T, Tr>e val ha tipo double o long double in base alle esigenze.

Se il valore convertito non può essere rappresentato come tipo di val, la funzione chiama setstate(failbit). In tutti i casi, restituisce *this.

Esempio

// 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=`

Assegna l'oggetto basic_istream a destra dell'operatore a questo oggetto. Si tratta di un'assegnazione di spostamento che implica un rvalue riferimento che non lascia una copia dietro.

basic_istream& operator=(basic_istream&& right);

Parametri

right
Riferimento rvalue a un oggetto basic_ifstream.

Valore restituito

Restituisce *this.

Osservazioni:

L'operatore membro chiama swap(right).

`basic_istream::peek`

Restituisce il carattere successivo da leggere.

int_type peek();

Valore restituito

Il carattere successivo che verrà letto.

Osservazioni:

La funzione di input non formattato estrae, se possibile, un elemento come se restituisce rdbuf->sgetc. In caso contrario, viene restituito traits_type::eof. Per altre informazioni, vedere sgetc e eof.

Esempio

// 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`

Inserisce un carattere specificato nel flusso.

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

Parametri

Ch
Carattere da inserire nuovamente nel flusso.

Valore restituito

Flusso (*this).

Osservazioni:

Se possibile, la funzione di input non formattato restituisce Ch, come se fosse possibile chiamando rdbuf->sputbackc. Se rdbuf è un puntatore Null o se la chiamata a sputbackc restituisce traits_type::eof, la funzione chiama setstate(badbit). In tutti i casi, restituisce *this.

Per altre informazioni, vedererdbuf, sputbackc, eofe setstate.

Esempio

// 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`

Legge un numero specificato di caratteri dal flusso e li archivia in una matrice.

Questo metodo è potenzialmente non sicuro, poiché si basa sul chiamante per verificare che i valori passati siano corretti.

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

Parametri

str
Matrice in cui leggere i caratteri.

count
Numero di caratteri da leggere.

Valore restituito

Il flusso ( *this).

Osservazioni:

La funzione di input non formattato estrae fino agli count elementi e le archivia nella matrice a partire da str. L'estrazione si arresta all'inizio del file, nel qual caso la funzione chiama setstate(failbit). In tutti i casi, restituisce *this. Per ulteriori informazioni, vedere setstate.

Esempio

// 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`

Legge il numero specificato di valori di carattere.

Questo metodo è potenzialmente non sicuro, poiché si basa sul chiamante per verificare che i valori passati siano corretti.

streamsize readsome(
    char_type* str,
    streamsize count);

Parametri

str
La matrice in cui readsome archivia i caratteri letti.

count
Numero di caratteri da leggere.

Valore restituito

Numero di caratteri effettivamente letti, gcount.

Osservazioni:

La funzione di input non formattato estrae fino a count elementi dal flusso di input e li archivia nella matrice str.

Questa funzione non attende l'input. Legge tutti i dati disponibili.

Esempio

// 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`

Sposta la posizione di lettura in un flusso.

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

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

Parametri

pos
Posizione assoluta in cui spostare il puntatore di lettura.

off
Offset per lo spostamento del puntatore di lettura relativamente a way.

way
Una delle ios_base::seekdir enumerazioni.

Valore restituito

Flusso (*this).

Osservazioni:

La prima funzione membro esegue una ricerca assoluta, la seconda funzione membro esegue una ricerca relativa.

Nota

Non usare la seconda funzione membro con file di testo poiché C++ standard non supporta le ricerche relative nei file di testo.

Se fail è false, la prima funzione membro chiama newpos = rdbuf->pubseekpos(pos), per alcuni pos_type oggetti newpostemporanei . Se fail è false, la seconda funzione chiama newpos = rdbuf->pubseekoff( off, way). In entrambi i casi, se (off_type)newpos == (off_type)(-1) (l'operazione di posizionamento ha esito negativo), la funzione chiama istr.setstate(failbit). Entrambe le funzioni restituiscono *this.

Se fail è true, le funzioni membro non eseguono alcuna operazione.

Per altre informazioni, vedererdbuf, pubseekpos, pubseekoffe setstate.

Esempio

// 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 annidata descrive un oggetto la cui dichiarazione struttura le funzioni di input formattato e non formattato.

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

Osservazioni:

Se _Istr.good è true, il costruttore:

Chiama _Istr.tie->flush se _Istr.tie non è un puntatore Null.
ws(_Istr) Chiama in modo efficace se _Istr.flags & skipws è diverso da zero.

Se dopo una tale preparazione, _Istr.good è false, il costruttore chiama _Istr.setstate(failbit). In ogni caso, il costruttore archivia il valore restituito da _Istr.good in status. Una chiamata successiva per recapitare operator bool questo valore archiviato.

Per altre informazioni, vedere good, tie, flush, ws, flags, skipws e setstate.

`basic_istream::swap`

Scambia il contenuto di due oggetti basic_istream.

void swap(basic_istream& right);

Parametri

right
Riferimento lvalue a un oggetto basic_istream.

Osservazioni:

La funzione membro chiama basic_ios::swap(right). e scambia il conteggio di estrazione con il conteggio di estrazione per right. Per ulteriori informazioni, vedere basic_ios::swap.

`basic_istream::sync`

Sincronizza il dispositivo di input associato al flusso con il buffer del flusso.

int sync();

Valore restituito

Se rdbuf è un puntatore Null, la funzione restituisce -1. In caso contrario, chiama rdbuf->pubsync. Se la chiamata restituisce -1, la funzione chiama setstate(badbit) e restituisce -1. In caso contrario, la funzione restituisce zero. Per altre informazioni, vedere pubsync e setstate.

`basic_istream::tellg`

Segnala la posizione corrente all'interno del flusso.

pos_type tellg();

Valore restituito

Posizione corrente all'interno del flusso.

Osservazioni:

Se fail è false, la funzione membro restituisce rdbuf->pubseekoff(0, cur, in). In caso contrario, viene restituito pos_type(-1). Per altre informazioni, vedere rdbuf e pubseekoff.

Esempio

// 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`

Reinserisce il carattere letto più di recente nel flusso.

basic_istream<Char_T, Tr>& unget();

Valore restituito

Flusso (*this).

Osservazioni:

La funzione di input non formattato restituisce l'elemento precedente nel flusso, se possibile, come se chiamando rdbuf->sungetc If rdbuf è un puntatore Null o se la chiamata a sungetc restituisce traits_type::eof, la funzione chiama setstate(badbit). In tutti i casi, restituisce *this.

Per altre informazioni, vedere sungetc, eof e setstate. Per informazioni su come unget potrebbe non riuscire, vedere basic_streambuf::sungetc.

Esempio

// 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

Vedi anche

Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
iostream Programmazione
iostreams Convenzioni

Condividi tramite

Classe basic_istream

Sintassi

Osservazioni:

Esempio

Costruttori

Funzioni membro

Operatori

Requisiti

basic_istream::basic_istream

Parametri

Osservazioni:

Esempio

basic_istream::gcount

Valore restituito

Osservazioni:

Esempio

basic_istream::get

Parametri

Valore restituito

Osservazioni:

Esempio

basic_istream::getline

Parametri

Valore restituito

Osservazioni:

Esempio

basic_istream::ignore

Parametri

Valore restituito

Osservazioni:

Esempio

basic\_istream::operator>>

Parametri

Valore restituito

Osservazioni:

Esempio

basic_istream::operator=

Parametri

Valore restituito

Osservazioni:

basic_istream::peek

Valore restituito

Osservazioni:

Esempio

basic_istream::putback

Parametri

Valore restituito

Osservazioni:

Esempio

basic_istream::read

Parametri

Valore restituito

Osservazioni:

Esempio

basic_istream::readsome

Parametri

Valore restituito

Osservazioni:

Esempio

basic_istream::seekg

Parametri

Valore restituito

Osservazioni:

Esempio

basic_istream::sentry

Osservazioni:

basic_istream::swap

Parametri

Osservazioni:

basic_istream::sync

Valore restituito

basic_istream::tellg

Valore restituito

Osservazioni:

Esempio

basic_istream::unget

Valore restituito

Osservazioni:

Esempio

Classe `basic_istream`

`basic_istream::basic_istream`

`basic_istream::gcount`

`basic_istream::get`

`basic_istream::getline`

`basic_istream::ignore`

`basic\_istream::operator>>`

`basic_istream::operator=`

`basic_istream::peek`

`basic_istream::putback`

`basic_istream::read`

`basic_istream::readsome`

`basic_istream::seekg`

`basic_istream::sentry`

`basic_istream::swap`

`basic_istream::sync`

`basic_istream::tellg`

`basic_istream::unget`