Condividi tramite

Classe basic_ios

  • Articolo

Il modello di classe descrive le funzioni di archiviazione e membro comuni sia ai flussi di input (del modello basic_istreamdi classe ) che ai flussi di output (del modello basic_ostreamdi classe ) che dipendono dai parametri del modello. La classe ios_base descrive cosa è comune e non dipende dai parametri del modello. Un oggetto della classe basic_ios<class Elem, class Traits> consente di controllare un flusso con elementi di tipo Elem, i cui tratti di carattere sono determinati dalla classe Traits.

Sintassi

template <class Elem, class Traits>
class basic_ios : public ios_base

Parametri

Elem
Tipo carattere.

Traits
Tipo che fornisce informazioni sul tipo di carattere, il valore predefinito è char_traits < Elem >.

Osservazioni:

Oggetto degli archivi di classi basic_ios<class Elem, class Traits> :

  • Puntatore di associazione a un oggetto di tipo basic_istream<Elem, Traits>.

  • Puntatore al buffer di flusso a un oggetto di tipo basic_streambuf<Elem, Traits >.

  • Informazioni sulla formattazione.

  • Informazioni sullo stato del flusso in un oggetto di base di tipo ios_base.

  • Un carattere di riempimento in un oggetto di tipo char_type.

Per altre informazioni, vedere basic_istream e basic_streambuf.

Costruttori

Costruttore Descrizione
basic_ios Costruisce la classe basic_ios.

Typedef

Nome tipo Descrizione
char_type Sinonimo del parametro di modello Elem.
int_type Sinonimo di Traits::int_type.
off_type Sinonimo di Traits::off_type.
pos_type Sinonimo di Traits::pos_type.
traits_type Sinonimo del parametro di modello Traits.

Funzioni membro

Funzione membro Descrizione
bad Indica una perdita di integrità del buffer del flusso.
clear Cancella tutti i flag di errore.
copyfmt Copia i flag da un flusso a un altro.
eof Indica se è stata raggiunta la fine del flusso.
exceptions Indica quali eccezioni verranno generate dal flusso.
fail Indica un errore per estrarre un campo valido da un flusso.
fill Specifica o restituisce il carattere che verrà utilizzato quando il testo non è largo come il flusso.
good Indica che le condizioni del flusso sono buone.
imbue Modifica le impostazioni locali.
init Chiamato dai costruttori basic_ios.
move Sposta tutti i valori, ad eccezione del puntatore al buffer del flusso, dal parametro all'oggetto corrente.
narrow Individua il carattere equivalente per un char_type specifico.
rdbuf Indirizza un flusso al buffer specificato.
rdstate Legge lo stato dei bit per i flag.
set_rdbuf Assegna un buffer del flusso in modo che sia il buffer di lettura per questo oggetto flusso.
setstate Imposta flag aggiuntivi.
swap Scambia i valori in questo oggetto basic_ios con quelli di un altro oggetto basic_ios. I puntatori ai buffer del flusso non vengono scambiati.
tie Assicura che un flusso venga elaborato prima di un altro flusso.
widen Individua il tipo char_type equivalente per un carattere specifico.

Operatori

Operatore Descrizione
explicit operator bool Permette l'uso di un oggetto basic_ios come bool. La conversione automatica de tipo è disabilitata per impedire effetti collaterali imprevisti comuni.
operator void * Indica se il flusso è ancora valido.
operator! Indica se il flusso non è valido.

Requisiti

Intestazione: <ios>

Spazio dei nomi: std

basic_ios::bad

Indica una perdita di integrità del buffer del flusso

bool bad() const;

Valore restituito

true se rdstate & badbit è diverso da zero; in caso contrario, false.

Per altre informazioni su badbit, vedere ios_base::iostate.

Esempio

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

int main( void )
{
    using namespace std;
    bool b = cout.bad( );
    cout << boolalpha;
    cout << b << endl;

    b = cout.good( );
    cout << b << endl;
}

basic_ios::basic_ios

Costruisce la classe basic_ios.

explicit basic_ios(basic_streambuf<Elem,  Traits>* sb);
basic_ios();

Parametri

sb
Buffer standard in cui archiviare gli elementi di input o output.

Osservazioni:

Il primo costruttore inizializza i relativi oggetti membro chiamando init(_ Sb). Il secondo costruttore (protetto) lascia i relativi oggetti membro non inizializzati. Una chiamata successiva a init deve inizializzare l'oggetto prima che possa essere eliminato in modo sicuro.

basic_ios::char_type

Sinonimo del parametro di modello Elem.

typedef Elem char_type;

basic_ios::clear

Cancella tutti i flag di errore.

void clear(iostate state = goodbit, bool reraise = false);
void clear(io_state state);

Parametri

state
(Facoltativo) Flag da impostare dopo la cancellazione di tutti i flag. Il valore predefinito è goodbit.

reraise
(Facoltativo) Specifica se l'eccezione deve essere nuovamente generata. false L'impostazione predefinita è (non genererà nuovamente l'eccezione).

Osservazioni:

I flag sono goodbit, failbit, eofbite badbit. Testare questi flag con good, bad, eofe fail

La funzione membro sostituisce le informazioni archiviate sullo stato del flusso con:

state | (rdbuf != 0 goodbit : badbit)

Se state&exceptions è diverso da zero, genera un oggetto della classe failure.

Per altre informazioni, vedere rdbuf e exceptions.

Esempio

Vedere rdstate e getline per esempi che usano clear.

basic_ios::copyfmt

Copia i flag da un flusso a un altro.

basic_ios<Elem, Traits>& copyfmt(
const basic_ios<Elem, Traits>& right);

Parametri

right
Flusso di cui si vuole copiare i flag.

Valore restituito

Oggetto this per il flusso in cui si copiano i flag.

Osservazioni:

La funzione membro segnala l'evento erase_eventdi callback . Copia quindi da right nel *this carattere di riempimento, il puntatore di legatura e le informazioni di formattazione. Prima di modificare la maschera di eccezione, segnala l'evento copyfmt_eventdi callback . Se dopo il completamento della copia, state&exceptions è diverso da zero, la funzione chiama clear efficacemente con l'argomento rdstate. Restituisce *this.

Esempio

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

int main( )
{
    using namespace std;
    ofstream x( "test.txt" );
    int i = 10;

    x << showpos;
    cout << i << endl;
    cout.copyfmt( x );
    cout << i << endl;
}

basic_ios::eof

Indica se è stata raggiunta la fine del flusso.

bool eof() const;

Valore restituito

true se è stata raggiunta la fine del flusso; in caso contrario, false.

Osservazioni:

La funzione membro restituisce true se rdstate & eofbit è diverso da zero. Per altre informazioni su eofbit, vedere ios_base::iostate.

Esempio

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

using namespace std;

int main( int argc, char* argv[] )
{
    fstream   fs;
    int n = 1;
    fs.open( "basic_ios_eof.txt" );   // an empty file
    cout << boolalpha
    cout << fs.eof() << endl;
    fs >> n;   // Read the char in the file
    cout << fs.eof() << endl;
}

basic_ios::exceptions

Indica quali eccezioni verranno generate dal flusso.

iostate exceptions() const;
void exceptions(iostate Newexcept);
void exceptions(io_state Newexcept);

Parametri

Newexcept
Flag che si vuole generino un'eccezione.

Valore restituito

Flag attualmente specificati per generare un'eccezione per il flusso.

Osservazioni:

La prima funzione membro restituisce la maschera delle eccezioni archiviata. La seconda funzione membro archivia _Except nella maschera eccezioni e restituisce il valore archiviato precedente. L'archiviazione di una nuova maschera di eccezione può generare un'eccezione proprio come la chiamata clear( rdstate ).

Esempio

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

int main( )
{
    using namespace std;

    cout << cout.exceptions( ) << endl;
    cout.exceptions( ios::eofbit );
    cout << cout.exceptions( ) << endl;
    try
    {
        cout.clear( ios::eofbit );   // Force eofbit on
    }
    catch ( exception &e )
    {
        cout.clear( );
        cout << "Caught the exception." << endl;
        cout << "Exception class: " << typeid(e).name()  << endl;
        cout << "Exception description: " << e.what() << endl;
    }
}

0
1
Caught the exception.
Exception class: class std::ios_base::failure
Exception description: ios_base::eofbit set

basic_ios::fail

Indica un errore per estrarre un campo valido da un flusso.

bool fail() const;

Valore restituito

true se rdstate & (badbit|failbit) è diverso da zero; in caso contrario false, .

Per altre informazioni su failbit, vedere ios_base::iostate.

Esempio

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

int main( void )
{
    using namespace std;
    bool b = cout.fail( );
    cout << boolalpha;
    cout << b << endl;
}

basic_ios::fill

Specifica o restituisce il carattere che verrà utilizzato quando il testo non è largo come il flusso.

char_type fill() const;
char_type fill(char_type Char);

Parametri

Char
Il carattere che si vuole usare come carattere di riempimento.

Valore restituito

Il carattere di riempimento corrente.

Osservazioni:

La prima funzione membro restituisce il carattere di riempimento archiviato. La seconda funzione membro archivia Char nel carattere di riempimento e restituisce il relativo valore archiviato precedente.

Esempio

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

int main( )
{
    using namespace std;

    cout << setw( 5 ) << 'a' << endl;
    cout.fill( 'x' );
    cout << setw( 5 ) << 'a' << endl;
    cout << cout.fill( ) << endl;
}

a
xxxxa
x

basic_ios::good

Indica che le condizioni del flusso sono buone.

bool good() const;

Valore restituito

true se rdstate == goodbit (non sono impostati flag di stato), in caso contrario, false.

Per altre informazioni su goodbit, vedere ios_base::iostate.

Esempio

Vedere basic_ios::bad per un esempio di uso gooddi .

basic_ios::imbue

Modifica le impostazioni locali.

locale imbue(const locale& Loc);

Parametri

Loc
Stringa delle impostazioni locali.

Valore restituito

Impostazioni locali precedenti.

Osservazioni:

Se rdbuf non è un NULL puntatore, la funzione membro chiama

rdbuf-> pubimbue(_ Loc)

In tutti i casi, restituisce ios_base::imbue(_ Loc).

Per altre informazioni, vedere pubimbue e ios_base::imbue.

Esempio

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

int main( )
{
    using namespace std;

    cout.imbue( locale( "french_france" ) );
    double x = 1234567.123456;
    cout << x << endl;
}

basic_ios::init

Chiamato dai costruttori basic_ios.

void init(basic_streambuf<Elem,Traits>* _Sb, bool _Isstd = false);

Parametri

_Sb
Buffer standard in cui archiviare gli elementi di input o output.

_Isstd
Specifica se si tratta di un flusso standard.

Osservazioni:

La funzione membro archivia i valori in tutti gli oggetti membro in modo che si verifichi quanto segue:

  • rdbuf restituisce _Sb.

  • tie restituisce un NULL puntatore.

  • rdstate restituisce goodbit se _Sb è diverso da zero; in caso contrario, restituisce badbit.

  • exceptions restituisce goodbit.

  • flags restituisce skipws | dec. Per altre informazioni, vedere skipws e dec.

  • width restituisce 0.

  • precision restituisce 6.

  • fill restituisce il carattere spazio.

  • getloc restituisce locale::classic.

  • iword restituisce zero e pword restituisce un NULL puntatore per tutti i valori dell'argomento.

basic_ios::int_type

Sinonimo di traits_type::int_type.

typedef typename traits_type::int_type int_type;

basic_ios::move

Sposta tutti i valori, ad eccezione del puntatore al buffer del flusso, dal parametro all'oggetto corrente.

void move(basic_ios&& right);

Parametri

right
L'oggetto ios_base da cui spostare i valori.

Osservazioni:

La funzione membro protetta sposta tutti i valori archiviati in right ad *this eccezione dell'oggetto archiviato stream buffer pointer, che rimane invariato in right e impostato su un NULL puntatore in *this. L'oggetto archiviato tie pointer è impostato su un NULL puntatore in right.

basic_ios::narrow

Individua il carattere equivalente per un char_type specifico.

char narrow(char_type Char, char Default = '\0') const;

Parametri

Char
Oggetto char da convertire.

Default
char che si vuole restituire se non viene trovato alcun equivalente.

Valore restituito

char equivalente in un char_type specificato.

Osservazioni:

La funzione membro restituisceuse_facet<ctype<E>>(getloc()).narrow(Char, Default).

Per altre informazioni, vedere use_facet e getloc.

Esempio

// basic_ios_narrow.cpp
// compile with: /EHsc
#include <ios>
#include <iostream>
#include <wchar.h>

int main( )
{
    using namespace std;
    wchar_t *x = L"test";
    char y[10];
    cout << x[0] << endl;
    wcout << x << endl;
    y[0] = wcout.narrow( x[0] );
    cout << y[0] << endl;
}

basic_ios::off_type

Sinonimo di traits_type::off_type.

typedef typename traits_type::off_type off_type;

basic_ios::operator void *

Indica se il flusso è ancora valido.

operator void *() const;

Valore restituito

L'operatore restituisce un NULL puntatore solo se fail.

Esempio

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

int main( )
{
    using namespace std;
    cout << (bool)(&cout != 0) << endl;   // Stream is still good
}

1

basic_ios::operator!

Indica se il flusso non è valido.

bool operator!() const;

Valore restituito

Restituisce lo stesso risultato della chiamata basic_ios::fail

Esempio

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

int main( )
{
    using namespace std;
    cout << !cout << endl;   // Stream is not bad
}

0

basic_ios::operator bool

Permette l'uso di un oggetto basic_ios come bool. La conversione automatica de tipo è disabilitata per impedire effetti collaterali imprevisti comuni.

explicit operator bool() const;

Osservazioni:

Restituisce true se il flusso non contiene errori; in caso contrario false, .

basic_ios::pos_type

Sinonimo di traits_type::pos_type.

typedef typename traits_type::pos_type pos_type;

basic_ios::rdbuf

Indirizza un flusso al buffer specificato.

basic_streambuf<Elem, Traits> *rdbuf() const;
basic_streambuf<Elem, Traits> *rdbuf(
basic_streambuf<Elem, Traits>* _Sb);

Parametri

_Sb
Un flusso.

Osservazioni:

La prima funzione membro restituisce il puntatore del buffer di flusso archiviato.

La seconda funzione membro archivia _Sb nel puntatore del buffer di flusso archiviato e restituisce il valore archiviato in precedenza.

Esempio

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

int main( )
{
    using namespace std;
    ofstream file( "rdbuf.txt" );
    streambuf *x = cout.rdbuf( file.rdbuf( ) );
    cout << "test" << endl;   // Goes to file
    cout.rdbuf(x);
    cout << "test2" << endl;
}

test2

basic_ios::rdstate

Legge lo stato di errore del flusso.

iostate rdstate() const;

Valore restituito

Le informazioni sullo stato del flusso archiviato.

Esempio

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

void TestFlags( ios& x )
{
    cout << ( x.rdstate( ) & ios::badbit ) << endl;
    cout << ( x.rdstate( ) & ios::failbit ) << endl;
    cout << ( x.rdstate( ) & ios::eofbit ) << endl;
    cout << endl;
}

int main( )
{
    fstream x( "c:\test.txt", ios::out );
    x.clear( );
    TestFlags( x );
    x.clear( ios::badbit | ios::failbit | ios::eofbit );
    TestFlags( x );
}

0
0
0

4
2
1

basic_ios::setstate

Imposta i flag di errore del flusso specificati (i flag di stato di errore del flusso attualmente impostati rimangono invariati):

flag Descrizione
goodbit Nessun errore
badbit Errore irreversibile
failbit Operazione di I/O non riuscita, ad esempio un errore di formattazione o estrazione
eofbit Stream ha raggiunto la fine del file 
void setstate(iostate _State);

Parametri

_State
Flag aggiuntivi da impostare.

Osservazioni:

La funzione membro chiama clear(_ state | rdstate)essenzialmente .

Per altre informazioni, vedere clear e rdstate.

Esempio

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

int main( )
{
    bool b = cout.bad( );
    cout << b << endl;   // Good
    cout.clear( ios::badbit );
    b = cout.bad( );
    // cout.clear( );
    cout << b << endl;   // Is bad, good
    b = cout.fail( );
    cout << b << endl;   // Not failed
    cout.setstate( ios::failbit );
    b = cout.fail( );
    cout.clear( );
    cout << b << endl;   // Is failed, good
    return 0;
}

0
1

basic_ios::set_rdbuf

Assegna un buffer del flusso in modo che sia il buffer di lettura per questo oggetto flusso.

void set_rdbuf(
basic_streambuf<Elem, Tr>* strbuf)

Parametri

strbuf
Buffer del flusso che deve diventare il buffer di lettura.

Osservazioni:

La funzione membro protetta archivia strbuf nel puntatore del buffer di flusso. Non chiama clear.

basic_ios::tie

Assicura che un flusso venga elaborato prima di un altro flusso.

basic_ostream<Elem, Traits> *tie() const;
basic_ostream<Elem, Traits> *tie(
basic_ostream<Elem, Traits>* str);

Parametri

str
Un flusso.

Valore restituito

La prima funzione membro restituisce il puntatore tie archiviato. La seconda funzione membro archivia str nel puntatore tie e restituisce il relativo valore archiviato precedente.

Osservazioni:

tie causa la sincronizzazione di due flussi in modo che le operazioni in un flusso vengano eseguite dopo il completamento delle operazioni nell'altro flusso.

Esempio

Nell'esempio seguente, legando cin a cout, è garantito che la Enter a number: stringa passerà alla console prima che il numero stesso venga estratto da cin. In questo modo si elimina la possibilità che la stringa "Enter a number:" sia ancora seduta nel buffer quando il numero viene letto, in modo da essere certi che l'utente abbia effettivamente una richiesta di risposta. Per impostazione predefinita, cin e cout sono associati.

#include <ios>
#include <iostream>

int main( )
{
    using namespace std;
    int i;
    cin.tie( &cout );
    cout << "Enter a number:";
    cin >> i;
}

basic_ios::traits_type

Sinonimo del parametro di modello Traits.

typedef Traits traits_type;

basic_ios::widen

Trova char_type equivalente a char specificato.

char_type widen(char Char) const;

Parametri

Char
Carattere da convertire.

Valore restituito

Trova char_type equivalente a char specificato.

Osservazioni:

La funzione membro restituisceuse_facet<ctype<E>>(getloc).widen(Char).

Per altre informazioni, vedere use_facet e getloc.

Esempio

// basic_ios_widen.cpp
// compile with: /EHsc
#include <ios>
#include <iostream>
#include <wchar.h>

int main( )
{
    using namespace std;
    char *z = "Hello";
    wchar_t y[2] = {0,0};
    cout << z[0] << endl;
    y[0] = wcout.widen( z[0] );
    wcout << &y[0] << endl;
}

basic_ios::swap

Scambia i valori in questo oggetto basic_ios con quelli di un altro oggetto basic_ios. Tuttavia, i puntatori ai buffer del flusso non vengono scambiati.

void swap(basic_ios&& right);

Parametri

right
Oggetto basic_ios usato per lo scambio dei valori.

Osservazioni:

La funzione membro protetto scambia tutti i valori archiviati in right con *this, ad eccezione di stream buffer pointer archiviato.

Vedi anche

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