Classe basic_streambuf

Descrive una classe base astratta per la derivazione di un buffer di flusso, che controlla la trasmissione di elementi verso e da una rappresentazione specifica di un flusso.

Sintassi

template <class Elem, class Tr = char_traits<Elem>>
class basic_streambuf;

Parametri

Elem
Un char_type.

Tr
Il carattere traits_type.

Osservazioni:

Il modello di classe descrive una classe base astratta per derivare un buffer di flusso, che controlla la trasmissione di elementi da e verso una rappresentazione specifica di un flusso. Un oggetto della classe basic_streambuf consente di controllare un flusso con elementi di tipo Tr, noti anche come char_type, i cui tratti di carattere sono determinati dalla classe char_traits, noti anche come traits_type.

Ogni buffer di flusso controlla concettualmente due flussi indipendenti: uno per le estrazioni (input) e uno per gli inserimenti (output). È tuttavia possibile che una rappresentazione specifica renda inaccessibili uno o entrambi i flussi. Viene in genere mantenuta una relazione tra i due flussi. Ciò che si inserisce nel flusso di output di un oggetto basic_stringbufElem<, Tr> ad esempio, è quello che si estrae successivamente dal flusso di input. Quando si posiziona un flusso di un basic_filebufElem<, Tr> si posiziona l'altro flusso in parallelo.

Il modello basic_streambuf di interfaccia pubblica a classe fornisce le operazioni comuni a tutti i buffer di flusso, ma specializzati. L'interfaccia protetta fornisce le operazioni necessarie per il funzionamento corretto di una rappresentazione specifica di un flusso. Le funzioni membro virtuali permettono di personalizzare il comportamento di un buffer di flusso derivato per una rappresentazione specifica di un flusso. Ogni buffer di flusso derivato in questa libreria descrive il modo in cui rende specializzato il comportamento delle rispettive funzioni membro virtuali protette. Il comportamento predefinito per la classe di base, che spesso non esegue alcuna operazione, è descritto in questo articolo.

Le funzioni membro virtuali rimanenti controllano la copia verso e da eventuali risorse di archiviazione fornite alle trasmissioni del buffer verso e dai flussi. Un buffer di input, ad esempio, è caratterizzato dagli elementi seguenti:

• eback: puntatore all'inizio del buffer.

• gptr: puntatore all'elemento successivo da leggere.

• egptr, un puntatore oltre la fine del buffer.

Analogamente, un buffer di output è caratterizzato dagli elementi seguenti:

• pbase: puntatore all'inizio del buffer.

• pptr: puntatore all'elemento successivo da scrivere.

• epptr, un puntatore oltre la fine del buffer.

Il protocollo seguente viene usato per qualsiasi tipo di buffer:

• Se il puntatore di tipo next è Null, non esiste alcun buffer. In caso contrario, tutti e tre i puntatori puntano nella stessa sequenza. È possibile confrontarli in modo sicuro per determinarne l'ordine.

• Nel caso di un buffer di output, se il puntatore di tipo next ottiene dal confronto un risultato inferiore a quello del puntatore di tipo end, sarà possibile archiviare un elemento in corrispondenza della posizione di scrittura designata dal puntatore di tipo next.

• Nel caso di un buffer di intput, se il puntatore di tipo next ottiene dal confronto un risultato inferiore a quello del puntatore di tipo end, sarà possibile leggere un elemento in corrispondenza della posizione di lettura designata dal puntatore di tipo next.

• Nel caso di un buffer di intput, se il puntatore di tipo beginning ottiene dal confronto un risultato inferiore a quello del puntatore di tipo next, sarà possibile reinserire un elemento in corrispondenza della posizione di putback designata dal puntatore di tipo next decrementato.

Tutte le funzioni membro virtuali protette scritte per una classe derivata da basic_streambuf<Elem, Tr> devono cooperare nella gestione di questo protocollo.

Un oggetto della classe basic_streambuf<Elem, Tr> archivia i sei puntatori descritti in precedenza. Archivia anche un oggetto di impostazioni locali in un oggetto di tipo locale per un uso potenziale da parte di un buffer di flusso derivato.

Costruttori

Costruttore	Descrizione
basic_streambuf	Costruisce un oggetto di tipo basic_streambuf.

Typedef

Nome tipo	Descrizione
char_type	Associa un nome di tipo al parametro di modello Elem.
int_type	Associa un nome di tipo entro l'ambito basic_streambuf al parametro di modello Elem.
off_type	Associa un nome di tipo entro l'ambito basic_streambuf al parametro di modello Elem.
pos_type	Associa un nome di tipo entro l'ambito basic_streambuf al parametro di modello Elem.
traits_type	Associa un nome di tipo al parametro di modello Tr.

Funzioni membro

Funzione membro	Descrizione
eback	Funzione protetta che restituisce un puntatore all'inizio del buffer di input.
egptr	Funzione protetta che restituisce un puntatore oltre la fine del buffer di input.
epptr	Funzione protetta che restituisce un puntatore oltre la fine del buffer di output.
gbump	Funzione protetta che aggiunge count al puntatore successivo per il buffer di input.
getloc	Ottiene le impostazioni locali dell'oggetto basic_streambuf.
gptr	Funzione protetta che restituisce un puntatore all'elemento successivo del buffer di input.
imbue	Funzione virtuale protetta chiamata da pubimbue.
in_avail	Restituisce il numero di elementi pronti per la lettura dal buffer.
overflow	Una funzione virtuale protetta che può essere chiamata quando viene inserito un nuovo carattere in un buffer pieno.
pbackfail	Funzione membro virtuale protetta che tenta di reinserire un elemento nel flusso di input e quindi di impostarlo come elemento corrente, a cui fa riferimento il puntatore di tipo next.
pbase	Funzione protetta che restituisce un puntatore all'inizio del buffer di output.
pbump	Funzione protetta che aggiunge count al puntatore successivo per il buffer di output.
pptr	Funzione protetta che restituisce un puntatore all'elemento successivo del buffer di output.
pubimbue	Configura le impostazioni locali dell'oggetto basic_streambuf.
pubseekoff	Chiama seekoff, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata.
pubseekpos	Chiama seekpos, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata e reimposta la posizione corrente del puntatore.
pubsetbuf	Chiama setbuf, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata.
pubsync	Chiama sync, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata e aggiorna il flusso esterno associato al buffer.
sbumpc	Legge e restituisce l'elemento corrente, spostando il puntatore di flusso.
seekoff	La funzione membro virtuale protetta prova a modificare le posizioni correnti per i flussi di controllati.
seekpos	La funzione membro virtuale protetta prova a modificare le posizioni correnti per i flussi di controllati.
setbuf	La funzione membro virtuale protetta esegue una particolare operazione per ogni buffer del flusso derivato.
setg	Funzione protetta che archivia _Gbeg nel puntatore di tipo beginning, _Gnext nel puntatore di tipo next e _Gend nel puntatore di tipo end per il buffer di input.
setp	Funzione protetta che archivia _Pbeg nel puntatore di tipo beginning e _Pend nel puntatore di tipo end per il buffer di output.
sgetc	Restituisce l'elemento corrente senza modificare la posizione nel flusso.
sgetn	Restituisce il numero di elementi letti.
showmanyc	Funzione membro virtuale protetta che restituisce un conteggio del numero di caratteri che è possibile estrarre dal flusso di input. Garantisce inoltre che il programma non sia soggetto a un'attesa illimitata.
snextc	Legge l'elemento corrente e restituisce l'elemento seguente.
sputbackc	Inserisce un elemento char_type nel flusso.
sputc	Inserisce un carattere nel flusso.
sputn	Inserisce una stringa di caratteri nel flusso.
stossc	Consente di spostarsi oltre l'elemento corrente nel flusso.
sungetc	Ottiene un carattere dal flusso.
swap	Scambia i valori in questo oggetto con i valori disponibili nel parametro dell'oggetto basic_streambuf fornito.
sync	Funzione virtuale protetta che prova a sincronizzare i flussi controllati con eventuali flussi esterni associati.
uflow	Funzione virtuale protetta che estrae l'elemento corrente dal flusso di input.
underflow	Funzione virtuale protetta che estrae l'elemento corrente dal flusso di input.
xsgetn	Funzione virtuale protetta che estrae elementi dal flusso di input.
xsputn	Funzione virtuale protetta che inserisce elementi nel flusso di output.

Operatori

Operatore	Descrizione
operator=	Assegna i valori di questo oggetto da un altro oggetto basic_streambuf.

Requisiti

Intestazione:<streambuf>

Spazio dei nomi: std

basic_streambuf::basic_streambuf

Costruisce un oggetto di tipo basic_streambuf.

basic_streambuf();

basic_streambuf(const basic_streambuf& right);

Parametri

right
Un riferimento lvalue all'oggetto basic_streambuf usato per impostare i valori per questo oggetto basic_streambuf.

Osservazioni:

Il primo costruttore protetto archivia un puntatore null in tutti i puntatori che controllano il buffer di input e il buffer di output. Archivia anche locale::classic nell'oggetto delle impostazioni locali. Per altre informazioni, vedere locale::classic.

Il secondo costruttore protetto copia i puntatori e le impostazioni locali da destra.

basic_streambuf::char_type

Associa un nome di tipo al parametro di modello Elem.

typedef Elem char_type;

basic_streambuf::eback

Funzione protetta che restituisce un puntatore all'inizio del buffer di input.

char_type *eback() const;

Valore restituito

Un puntatore all'inizio del buffer di input.

basic_streambuf::egptr

Funzione protetta che restituisce un puntatore oltre la fine del buffer di input.

char_type *egptr() const;

Valore restituito

Puntatore oltre la fine del buffer di input.

basic_streambuf::epptr

Funzione protetta che restituisce un puntatore oltre la fine del buffer di output.

char_type *epptr() const;

Valore restituito

Puntatore oltre la fine del buffer di output.

basic_streambuf::gbump

Funzione protetta che aggiunge conteggio al puntatore successivo per il buffer di input.

void gbump(int count);

Parametri

count
Quantità di avanzamento del puntatore.

basic_streambuf::getloc

Ottiene le impostazioni locali dell'oggetto basic_streambuf.

locale getloc() const;

Valore restituito

Oggetto delle impostazioni locali archiviato.

Osservazioni:

Per informazioni correlate, vedere ios_base::getloc.

Esempio

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

int main( )
{
   using namespace std;
   cout << cout.rdbuf( )->getloc( ).name( ).c_str( ) << endl;
}

C

basic_streambuf::gptr

Funzione protetta che restituisce un puntatore all'elemento successivo del buffer di input.

char_type *gptr() const;

Valore restituito

Un puntatore all'elemento successivo del buffer di input.

basic_streambuf::imbue

Una funzione virtuale protetta chiamata da pubimbue.

virtual void imbue(const locale& _Loc);

Parametri

_Loc
Un riferimento a impostazioni locali.

Osservazioni:

Il comportamento predefinito non prevede l'esecuzione di alcuna operazione.

basic_streambuf::in_avail

Restituisce il numero di elementi pronti per la lettura dal buffer.

streamsize in_avail();

Valore restituito

Il numero di elementi pronti per la lettura dal buffer.

Osservazioni:

Se è disponibile una posizione di lettura, la funzione membro restituisce egptr gptr - . In caso contrario, la funzione restituisce showmanyc.

Esempio

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

int main( )
{
   using namespace std;
   char c;
   // cin's buffer is empty, in_avail will return 0
   cout << cin.rdbuf( )->in_avail( ) << endl;
   cin >> c;
   cout << cin.rdbuf( )->in_avail( ) << endl;
}

basic_streambuf::int_type

Associa un nome di tipo nell'ambito basic_streambuf a uno dei tipi in un parametro di modello.

typedef typename traits_type::int_type int_type;

basic_streambuf::off_type

Associa un nome di tipo nell'ambito basic_streambuf a uno dei tipi in un parametro di modello.

typedef typename traits_type::off_type off_type;

basic_streambuf::operator=

Assegna i valori di questo oggetto da un altro oggetto basic_streambuf.

basic_streambuf& operator=(const basic_streambuf& right);

Parametri

right
Un riferimento lvalue all'oggetto lbasic_streambuf usato per assegnare valori a questo oggetto.

Osservazioni:

L'operatore membro protetto copia da destra i puntatori che controllano il buffer di input e il buffer di output. Archivia anche right.getloc() in locale object. Restituisce *this.

basic_streambuf::overflow

Una funzione virtuale protetta che può essere chiamata quando viene inserito un nuovo carattere in un buffer pieno.

virtual int_type overflow(int_type _Meta = traits_type::eof());

Parametri

_Meta
Carattere da inserire nel buffer o traits_type::eof.

Valore restituito

Se la funzione non riesce, restituisce traits_type::eof o genera un'eccezione. In caso contrario, restituisce traits_type::not_eof(_ Meta). Il comportamento predefinito consiste nel restituire traits_type::eof.

Osservazioni:

Se _Meta non è uguale a traits_type::eof, la funzione membro virtuale protetta tenta di inserire l'elemento traits_type::to_char_type(_Meta) nel flusso di output. Questa operazione può essere eseguita in vari modi:

• Se è disponibile write position, la funzione può archiviare l'elemento nella posizione di scrittura e incrementare il puntatore successivo per il buffer di output.

• Una posizione di scrittura può essere resa disponibile allocando spazio di archiviazione nuovo o aggiuntivo per il buffer di output.

• Può rendere disponibile una posizione di scrittura scrivendo, in una destinazione esterna, alcuni o tutti gli elementi tra l'inizio e i puntatori successivi per il buffer di output.

La funzione di overflow virtuale, insieme alle funzioni sync e underflow, definisce le caratteristiche della classe derivata da streambuf. Ogni classe derivata può implementare l'overflow in modo diverso, ma l'interfaccia con la classe del flusso di chiamata è la stessa.

La funzione overflow è in genere chiamata da funzioni streambuf pubbliche come sputc e sputn quando l'area put è completa, mentre le altre classi, incluse le classi di flusso, possono chiamare overflow in qualsiasi momento.

La funzione usa i caratteri nell'area put tra i puntatori pbase e pptr e quindi reinizializza l'area put. La overflow funzione deve anche utilizzare nCh (se nCh non EOFè ) oppure potrebbe scegliere di inserire tale carattere nella nuova area put in modo che venga utilizzata nella chiamata successiva.

La definizione di utilizzo è diversa nelle classi derivate. Ad esempio, la classe filebuf scrive i caratteri in un file, mentre la classe strstreambuf li mantiene nel buffer e, se il buffer è impostato come dinamico, espande il buffer in risposta a una chiamata all'overflow. Questa espansione viene ottenuta liberando il buffer precedente e sostituendolo con un nuovo buffer di dimensione maggiore. I puntatori vengono modificati in base alle esigenze.

basic_streambuf::p backfail

Funzione membro virtuale protetta che tenta di reinserire un elemento nel flusso di input e quindi di impostarlo come elemento corrente, a cui fa riferimento il puntatore di tipo next.

virtual int_type pbackfail(int_type _Meta = traits_type::eof());

Parametri

_Meta
Carattere da inserire nel buffer o traits_type::eof.

Valore restituito

Se la funzione non riesce, restituisce traits_type::eof o genera un'eccezione. In caso contrario, restituisce un altro valore. Il comportamento predefinito consiste nel restituire traits_type::eof.

Osservazioni:

Se _Meta confronta uguale a traits_type::eof, l'elemento di cui eseguire il pushback è effettivamente quello già presente nel flusso prima dell'elemento corrente. In caso contrario, tale elemento viene sostituito da traits_type::to_char_type(_Meta). La funzione può reinserire un elemento in vari modi:

• Se è disponibile una posizione di reinserimento, la funzione può archiviare l'elemento in tale posizione e decrementare il puntatore successivo per il buffer di input.

• Può rendere disponibile una posizione di reinserimento allocando spazio di archiviazione nuovo o aggiuntivo per il buffer di input.

• Per un buffer di flusso con flussi di input e output comuni, può rendere disponibile una posizione di reinserimento scrivendo, in una destinazione esterna, alcuni o tutti gli elementi tra l'inizio e i puntatori successivi per il buffer di output.

basic_streambuf::p base

Funzione protetta che restituisce un puntatore all'inizio del buffer di output.

char_type *pbase() const;

Valore restituito

Un puntatore all'inizio del buffer di output.

basic_streambuf::p bump

Funzione protetta che aggiunge conteggio al puntatore successivo per il buffer di output.

void pbump(int count);

Parametri

count
Il numero di caratteri per i quali spostare in avanti la posizione di scrittura.

basic_streambuf::p os_type

Associa un nome di tipo nell'ambito basic_streambuf a uno dei tipi in un parametro di modello.

typedef typename traits_type::pos_type pos_type;

basic_streambuf::p ptr

Funzione protetta che restituisce un puntatore all'elemento successivo del buffer di output.

char_type *pptr() const;

Valore restituito

Un puntatore all'elemento successivo del buffer di output.

basic_streambuf::p ubimbue

Specifica le impostazioni locali dell'oggetto basic_streambuf.

locale pubimbue(const locale& _Loc);

Parametri

_Loc
Un riferimento a impostazioni locali.

Valore restituito

Il valore precedente archiviato nell'oggetto delle impostazioni locali.

Osservazioni:

La funzione membro archivia _ Loc nell'oggetto delle impostazioni locali e chiama imbue.

Esempio

Vedere basic_ios::imbue per un esempio di utilizzo di pubimbue.

basic_streambuf::p ubseekoff

Chiama seekoff, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata.

pos_type pubseekoff(off_type _Off,
    ios_base::seekdir _Way,
    ios_base::openmode _Which = ios_base::in | ios_base::out);

Parametri

_Fuori
Posizione da cercare rispetto a _Way.

_Modo
Punto iniziale per le operazioni di offset. Vedere seekdir per i valori possibili.

_Che
Specifica la modalità per la posizione del puntatore. L'impostazione predefinita consente di modificare le posizioni di lettura e scrittura.

Valore restituito

Restituisce la nuova posizione o una posizione del flusso non valida (seekoff(_ Off, _Way, _Which)).

Osservazioni:

Sposta il puntatore rispetto a _Way.

basic_streambuf::p ubseekpos

Chiama seekpos, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata e reimposta la posizione corrente del puntatore.

pos_type pubseekpos(pos_type _Sp, ios_base::openmode _Which = ios_base::in | ios_base::out);

Parametri

_Sp
Posizione da cercare.

_Che
Specifica la modalità per la posizione del puntatore. L'impostazione predefinita consente di modificare le posizioni di lettura e scrittura.

Valore restituito

La nuova posizione o una posizione di flusso non valida. Per stabilire se la posizione del flusso non è valida, confrontare il valore restituito con pos_type(off_type(-1)).

Osservazioni:

La funzione membro restituisce seekpos(_ Sp, _Which).

basic_streambuf::p ubsetbuf

Chiama setbuf, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata.

basic_streambuf<Elem, Tr> *pubsetbuf(
    char_type* _Buffer,
    streamsize count);

Parametri

_Buffer
Un puntatore a char_type per la creazione dell'istanza.

count
Dimensione del buffer.

Valore restituito

Restituisce setbuf( _Buffer, count).

basic_streambuf::p ubsync

Chiama sync, una funzione virtuale protetta di cui viene eseguito l'override in una classe derivata e aggiorna il flusso esterno associato al buffer.

int pubsync();

Valore restituito

Restituisce la sincronizzazione o -1 in caso di errore.

basic_streambuf::sbumpc

Legge e restituisce l'elemento corrente, spostando il puntatore di flusso.

int_type sbumpc();

Valore restituito

L'elemento corrente.

Osservazioni:

Se è disponibile una posizione di lettura, la funzione membro restituisce traits_type::to_int_type(*gptr) e incrementa il puntatore successivo per il buffer di input. In caso contrario, la funzione restituisce uflow.

Esempio

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

int main( )
{
   using namespace std;
   int i = 0;
   i = cin.rdbuf( )->sbumpc( );
   cout << i << endl;
}

3

33
51

basic_streambuf::seekoff

Funzione membro virtuale protetta che prova a modificare le posizioni correnti per i flussi controllati.

virtual pos_type seekoff(
    off_type _Off,
    ios_base::seekdir _Way,
    ios_base::openmode _Which = ios_base::in | ios_base::out);

Parametri

_Fuori
Posizione da cercare rispetto a _Way.

_Modo
Punto iniziale per le operazioni di offset. Vedere seekdir per i valori possibili.

_Che
Specifica la modalità per la posizione del puntatore. L'impostazione predefinita consente di modificare le posizioni di lettura e scrittura.

Valore restituito

Restituisce la nuova posizione o una posizione del flusso non valida ( (seekoff _ Off, _Way, _Which)).

Osservazioni:

La nuova posizione è determinata nel modo seguente:

• Se _Way == ios_base::beg, la nuova posizione corrisponde all'inizio del flusso più _ Off.

• Se _Way == ios_base::cur, la nuova posizione corrisponde alla posizione del flusso corrente più _ Off.

• Se _Way == ios_base::end, la nuova posizione corrisponde alla fine del flusso più _ Off.

In genere, se which & ios_base::in è diverso da zero ne è influenzato il flusso di input e se which & ios_base::out è diverso da zero ne è interessato il flusso di output. L'utilizzo effettivo di questo parametro, tuttavia, varia da un buffer di flusso derivato all'altro.

Se la funzione modifica la posizione o le posizioni del flusso, restituisce la posizione di flusso risultante o una delle posizioni di flusso risultanti. In caso contrario, restituisce una posizione di flusso non valida. Il comportamento predefinito consiste nel restituire una posizione di flusso non valida.

basic_streambuf::seekpos

Funzione membro virtuale protetta che prova a modificare le posizioni correnti per i flussi controllati.

virtual pos_type seekpos(pos_type _Sp, ios_base::openmode _Which = ios_base::in | ios_base::out);

Parametri

_Sp
Posizione da cercare.

_Che
Specifica la modalità per la posizione del puntatore. L'impostazione predefinita consente di modificare le posizioni di lettura e scrittura.

Valore restituito

La nuova posizione o una posizione di flusso non valida. Per stabilire se la posizione del flusso non è valida, confrontare il valore restituito con pos_type(off_type(-1)).

Osservazioni:

La nuova posizione è _ Sp.

In genere, se which & ios_base::in è diverso da zero ne è influenzato il flusso di input e se which & ios_base::out è diverso da zero ne è interessato il flusso di output. L'utilizzo effettivo di questo parametro, tuttavia, varia da un buffer di flusso derivato all'altro.

Se la funzione modifica la posizione o le posizioni del flusso, restituisce la posizione di flusso risultante o una delle posizioni di flusso risultanti. In caso contrario, restituisce una posizione di flusso non valida (-1). Il comportamento predefinito consiste nel restituire una posizione di flusso non valida.

basic_streambuf::setbuf

Funzione membro virtuale protetta che esegue una particolare operazione in ogni buffer di flusso derivato.

virtual basic_streambuf<Elem, Tr> *setbuf(
    char_type* _Buffer,
    streamsize count);

Parametri

_Buffer
Puntatore a un buffer.

count
Dimensioni del buffer .

Valore restituito

Il comportamento predefinito consiste nel restituire this.

Osservazioni:

Vedere basic_filebuf. setbuf fornisce un'area di memoria per l'oggetto streambuf da usare. La modalità di utilizzo del buffer è definita nelle classi derivate.

basic_streambuf::setg

Funzione protetta che archivia _ Gbeg nel puntatore iniziale, _Gnext nel puntatore successivo e _Gend nel puntatore finale per il buffer di input.

void setg(char_type* _Gbeg,
    char_type* _Gnext,
    char_type* _Gend);

Parametri

_Gbeg
Puntatore all'inizio del buffer.

_Gnext
Puntatore a una posizione centrale del buffer.

_Gend
Puntatore alla fine del buffer.

basic_streambuf::setp

Funzione protetta che archivia _Pbeg nel puntatore iniziale e _Pend nel puntatore finale per il buffer di output.

void setp(char_type* _Pbeg, char_type* _Pend);

Parametri

_Pbeg
Puntatore all'inizio del buffer.

_Pend
Puntatore alla fine del buffer.

basic_streambuf::sgetc

Restituisce l'elemento corrente senza modificare la posizione nel flusso.

int_type sgetc();

Valore restituito

L'elemento corrente.

Osservazioni:

Se è disponibile una posizione di lettura, la funzione membro restituisce traits_type::to_int_type( *gptr). In caso contrario, la funzione restituisce underflow.

Esempio

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

int main( )
{
   using namespace std;
   ifstream myfile( "basic_streambuf_sgetc.txt", ios::in );

   char i = myfile.rdbuf( )->sgetc( );
   cout << i << endl;
   i = myfile.rdbuf( )->sgetc( );
   cout << i << endl;
}

basic_streambuf::sgetn

Estrae fino al numero di caratteri dal buffer di input e li archivia nel ptr del buffer fornito.

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

streamsize sgetn(
    char_type* ptr,
    streamsize count);

Parametri

ptr
Buffer che deve contenere i caratteri estratti.

count
Numero di elementi da leggere.

Valore restituito

Numero di elementi letti. Per altre informazioni, vedere Flussi per altre informazioni.

Osservazioni:

La funzione membro restituisce xsgetn( ptr, count).

Esempio

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

int main()
{
    using namespace std;

    ifstream myfile("basic_streambuf_sgetn.txt", ios::in);
    char a[10];

    // Extract 3 characters from myfile and store them in a.
    streamsize i = myfile.rdbuf()->sgetn(&a[0], 3);  // C4996
    a[i] = myfile.widen('\0');

    // Display the size and contents of the buffer passed to sgetn.
    cout << i << " " << a << endl;

    // Display the contents of the original input buffer.
    cout << myfile.rdbuf() << endl;
}

basic_streambuf::showmanyc

Funzione membro virtuale protetta che restituisce un conteggio del numero di caratteri che possono essere estratti dal flusso di input e assicurarsi che il programma non sia soggetto a un'attesa illimitata.

virtual streamsize showmanyc();

Valore restituito

Il comportamento predefinito consiste nel restituire zero.

basic_streambuf::snextc

Legge l'elemento corrente e restituisce l'elemento seguente.

int_type snextc();

Valore restituito

L'elemento successivo nel flusso.

Osservazioni:

La funzione membro chiama sbumpc e, se la funzione restituisce traits_type::eof, restituisce traits_type::eof. In caso contrario, la funzione restituisce sgetc.

Esempio

// basic_streambuf_snextc.cpp
// compile with: /EHsc
#include <iostream>
int main( )
{
   using namespace std;
   int i = 0;
   i = cin.rdbuf( )->snextc( );
   // cout << ( int )char_traits<char>::eof << endl;
   cout << i << endl;
}

aa

aa97

basic_streambuf::sputbackc

Inserisce un char_type nel flusso.

int_type sputbackc(char_type _Ch);

Parametri

_Ch
Il carattere.

Valore restituito

Restituisce il carattere o un errore.

Osservazioni:

Se è disponibile una posizione di putback e _Ch confronta uguale al carattere archiviato in tale posizione, la funzione membro decrementa il puntatore successivo per il buffer di input e restituisce traits_type::to_int_type( _Ch). In caso contrario, la funzione restituisce pbackfail( _Ch).

Esempio

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

int main( )
{
    using namespace std;

    ifstream myfile("basic_streambuf_sputbackc.txt",
        ios::in);

    int i = myfile.rdbuf()->sbumpc();
    cout << (char)i << endl;
    int j = myfile.rdbuf()->sputbackc('z');
    if (j == 'z')
    {
        cout << "it worked" << endl;
    }
    i = myfile.rdbuf()->sgetc();
    cout << (char)i << endl;
}

basic_streambuf::sputc

Inserisce un carattere nel flusso.

int_type sputc(char_type _Ch);

Parametri

_Ch
Il carattere.

Valore restituito

Restituisce il carattere, se ha esito positivo.

Osservazioni:

Se è write position disponibile, la funzione membro archivia _Ch nella posizione di scrittura, incrementa il puntatore successivo per il buffer di output e restituisce traits_type::to_int_type( _Ch). In caso contrario, la funzione restituisce overflow( _Ch).

Esempio

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

int main( )
{
   using namespace std;

   int i = cout.rdbuf( )->sputc( 'a' );
   cout << endl << ( char )i << endl;
}

a
a

basic_streambuf::sputn

Inserisce una stringa di caratteri nel flusso.

streamsize sputn(const char_type* ptr, streamsize count);

Parametri

ptr
La stringa di caratteri.

count
Il numero di caratteri.

Valore restituito

Numero di caratteri inseriti nel flusso.

Osservazioni:

La funzione membro restituisce xsputn( ptr, count). Per altre informazioni, vedere la sezione Osservazioni di questo membro.

Esempio

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

int main()
{
    using namespace std;

    streamsize i = cout.rdbuf()->sputn("test", 4);
    cout << endl << i << endl;
}

test
4

basic_streambuf::stossc

Consente di spostarsi oltre l'elemento corrente nel flusso.

void stossc();

Osservazioni:

La funzione membro chiama sbumpc. Non è necessaria un'implementazione per fornire questa funzione membro.

Esempio

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

int main( )
{
   using namespace std;
   ifstream myfile( "basic_streambuf_stossc.txt", ios::in );

   myfile.rdbuf( )->stossc( );
   char i = myfile.rdbuf( )->sgetc( );
   cout << i << endl;
}

basic_streambuf::sungetc

Ottiene un carattere dal flusso.

int_type sungetc();

Valore restituito

Restituisce il carattere o un errore.

Osservazioni:

Se è disponibile una posizione di reinserimento, la funzione membro decrementa il puntatore successivo per il buffer di input e restituisce traits_type::to_int_type( *gptr). Tuttavia, non è sempre possibile determinare l'ultimo carattere letto in modo che possa essere acquisito nello stato del buffer corrente. Se true, la funzione restituisce pbackfail. Per evitare questa situazione, tenere traccia del carattere da rimettere e chiamare sputbackc(ch), che non avrà esito negativo a condizione che non venga chiamato all'inizio del flusso e non si tenta di ripristinare più di un carattere.

Esempio

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

int main( )
{
   using namespace std;

   ifstream myfile( "basic_streambuf_sungetc.txt", ios::in );

   // Read and increment
   int i = myfile.rdbuf( )->sbumpc( );
   cout << ( char )i << endl;

   // Read and increment
   i = myfile.rdbuf( )->sbumpc( );
   cout << ( char )i << endl;

   // Decrement, read, and do not increment
   i = myfile.rdbuf( )->sungetc( );
   cout << ( char )i << endl;

   i = myfile.rdbuf( )->sungetc( );
   cout << ( char )i << endl;

   i = myfile.rdbuf( )->sbumpc( );
   cout << ( char )i << endl;
}

basic_streambuf::swap

Scambia i valori in questo oggetto con i valori disponibili nell'oggetto basic_streambuf fornito.

void swap(basic_streambuf& right);

Parametri

right
Un riferimento lvalue all'oggetto basic_streambuf usato per scambiare valori.

Osservazioni:

La funzione membro protetta scambia con destra tutti i puntatori che controllano input buffer e .output buffer Scambia anche right.getloc() con l'oggetto locale.

basic_streambuf::sync

Funzione virtuale protetta che prova a sincronizzare i flussi controllati con eventuali flussi esterni associati.

virtual int sync();

Valore restituito

Se la funzione non riesce, restituisce -1. Il comportamento predefinito consiste nel restituire zero.

Osservazioni:

sync comporta la scrittura degli elementi tra il puntatore iniziale e quello successivo per il buffer di output. Non comporta l'inserimento di elementi tra i puntatori successivi e finali per il buffer di input.

basic_streambuf::traits_type

Associa un nome di tipo al parametro di modello Tr.

typedef Tr traits_type;

basic_streambuf::uflow

Funzione virtuale protetta che estrae l'elemento corrente dal flusso di input.

virtual int_type uflow();

Valore restituito

L'elemento corrente.

Osservazioni:

La funzione membro virtuale protetta tenta di estrarre l'elemento corrente ch dal flusso di input, quindi incrementa la posizione del flusso corrente e restituisce l'elemento come traits_type::to_int_type( ch). Questa operazione può essere eseguita in vari modi:

• Se è disponibile una posizione di lettura, accetta ch come elemento archiviato nella posizione di lettura e incrementa il puntatore successivo per il buffer di input.

• Può leggere un elemento direttamente da un'origine esterna e fornirlo come valore di ch.

• Per un buffer di flusso con flussi di input e output comuni, può rendere disponibile una posizione di lettura scrivendo, in una destinazione esterna, alcuni o tutti gli elementi tra l'inizio e i puntatori successivi per il buffer di output. Oppure può allocare uno spazio di archiviazione nuovo o aggiuntivo per il buffer di input. La funzione legge quindi uno o più elementi da un'origine esterna.

Se la funzione non riesce, restituisce traits_type::eof o genera un'eccezione. In caso contrario, restituisce l'elemento corrente ch nel flusso di input, convertito come descritto in precedenza, e incrementa il puntatore successivo per il buffer di input. Il comportamento predefinito consiste nel chiamare underflow e, se tale funzione restituisce traits_type::eof, restituire traits_type::eof. In caso contrario, la funzione restituisce l'elemento corrente ch nel flusso di input, convertito come descritto in precedenza, e incrementa il puntatore successivo per il buffer di input.

basic_streambuf::underflow

Funzione virtuale protetta per estrarre l'elemento corrente dal flusso di input.

virtual int_type underflow();

Valore restituito

L'elemento corrente.

Osservazioni:

La funzione membro virtuale protetta estrae l'elemento corrente ch dal buffer di input senza incrementare la posizione del flusso corrente e restituisce l'elemento come traits_type::to_int_type( ch). Questa operazione può essere eseguita in vari modi:

• Se è disponibile una posizione di lettura, ch è l'elemento archiviato nella posizione di lettura. Per altre informazioni, vedere la sezione Note della Classe basic_streambuf.

• Può rendere disponibile una posizione di lettura allocando spazio di archiviazione nuovo o aggiuntivo per il buffer di input, quindi leggendo, da un'origine esterna, uno o più elementi. Per altre informazioni, vedere la sezione Note della Classe basic_streambuf.

Se la funzione non riesce, restituisce traits_type::eof() o genera un'eccezione. In caso contrario, restituisce l'elemento corrente nel flusso di input, convertito come descritto in precedenza. Il comportamento predefinito consiste nel restituire traits_type::eof().

La funzione underflow virtuale, con le funzioni sync e overflow, definisce le caratteristiche della classe derivata da streambuf. Ogni classe derivata può implementare underflow in modo diverso, ma l'interfaccia con la classe del flusso di chiamata è la stessa.

La funzione underflow è in genere chiamata da funzioni streambuf pubbliche come sgetc e sgetn quando l'area get è vuota, mentre le altre classi, incluse le classi di flusso, possono chiamare underflow in qualsiasi momento.

La funzione underflow fornisce l'area get con caratteri dell'origine di input. Se l'area get contiene caratteri, underflow restituisce il primo carattere. Se l'area get è vuota, riempie l'area get e restituisce il carattere successivo (che lascia nell'area get). Se non sono disponibili altri caratteri, underflow restituisce EOF e lascia vuota l'area get.

Nella classe strstreambufunderflow modifica il puntatore egptr per accedere allo spazio di archiviazione allocato dinamicamente da una chiamata a overflow.

basic_streambuf::xsgetn

Funzione virtuale protetta per l'estrazione di elementi dal flusso di input.

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

virtual streamsize xsgetn(
    char_type* ptr,
    streamsize count);

Parametri

ptr
Buffer che deve contenere i caratteri estratti.

count
Numero di elementi da estrarre.

Valore restituito

Numero di elementi estratti.

Osservazioni:

La funzione membro virtuale protetta estrae fino a contare gli elementi dal flusso di input, come se fossero chiamate ripetute a sbumpc e le archivia nella matrice a partire da ptr. Restituisce il numero di elementi estratti.

basic_streambuf::xsputn

Funzione virtuale protetta per l'inserimento di elementi nel flusso di output.

virtual streamsize xsputn(const char_type* ptr, streamsize count);

Parametri

ptr
Puntatore agli elementi da inserire.

count
Numero di elementi da inserire.

Valore restituito

Numero di elementi inseriti nel flusso.

Osservazioni:

La funzione membro virtuale protetta inserisce fino a contare gli elementi nel flusso di output, come se fossero ripetute chiamate a sputc, dalla matrice a partire da ptr. L'inserimento di caratteri nel flusso di output si interrompe dopo che tutti i caratteri di conteggio sono stati scritti o se la chiamata sputc( count) restituisce traits::eof(). Restituisce il numero di elementi inseriti.

Vedi anche

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