Classe basic_ostream

Questo modello di classe descrive un oggetto che controlla l'inserimento di elementi e oggetti codificati in un buffer di flusso con elementi di tipo Elem, noti anche come char_type, i cui tratti di carattere sono determinati dalla classe Tr, noto anche come traits_type.

Sintassi

template <class Elem, class Tr = char_traits<Elem>>
class basic_ostream : virtual public basic_ios<Elem, Tr>

Parametri

Elem
Un oggetto char_type.

Tr
Il carattere traits_type.

Osservazioni:

La maggior parte delle funzioni membro che l'operatore di<< overload sono funzioni di output formattate. Le funzioni seguono questo schema:

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

if (ok)
{try
{<convert and insert elements
    accumulate flags in state> }
    catch (...)
{try
{setstate(badbit);

}
    catch (...)
{}
    if ((exceptions()& badbit) != 0)
    throw; }}
width(0);
// Except for operator<<(Elem)
setstate(state);

return (*this);

Due altre funzioni membro sono funzioni di output formattate. Le funzioni seguono questo schema:

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

if (!ok)
    state |= badbit;
else
{try
{<obtain and insert elements
    accumulate flags in state> }
    catch (...)
{try
{setstate(badbit);

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

return (*this);

Entrambi i gruppi di funzioni chiamano setstate(badbit) se riscontrano un errore durante l'inserimento di elementi.

Oggetto della classe basic_istream<Elem, Tr> archivia solo un oggetto base pubblico virtuale di classe basic_ios<Elem, Tr.>

Esempio

Per altre informazioni sui flussi di output, vedere l'esempio per la Classe basic_ofstream.

Costruttori

Costruttore Descrizione
basic_ostream Costruisce un oggetto basic_ostream.

Funzioni membro

Funzione membro Descrizione
flush Scarica il buffer.
put Inserisce un carattere in un flusso.
seekp Reimposta la posizione nel flusso di output.
sentry La classe annidata descrive un oggetto la cui dichiarazione struttura le funzioni di output formattate e quelle non formattate.
swap Scambia i valori in questo oggetto basic_ostream con quelli dell'oggetto basic_ostream fornito.
tellp Indica la posizione nel flusso di output.
write Inserisce i caratteri in un flusso.

Operatori

Operatore Descrizione
operator= Assegna il valore del parametro di oggetto basic_ostream fornito a questo oggetto.
operator<< Scrive nel flusso.

Requisiti

Header:<ostream>

Spazio dei nomi: std

basic_ostream::basic_ostream

Costruisce un oggetto basic_ostream.

explicit basic_ostream(
    basic_streambuf<Elem, Tr>* strbuf,
    bool _Isstd = false);

basic_ostream(basic_ostream&& right);

Parametri

strbuf
Un oggetto di tipo basic_streambuf.

_Isstd
true se si tratta di un flusso standard; in caso contrario, false.

right
Riferimento rvalue a un oggetto di tipo basic_ostream.

Osservazioni:

Il primo costruttore inizializza la classe base chiamando init(strbuf). Il secondo costruttore inizializza la classe base chiamando basic_ios::move(right).

Esempio

Per altre informazioni sui flussi di output, vedere l'esempio per basic_ofstream::basic_ofstream.

basic_ostream::flush

Scarica il buffer.

basic_ostream<Elem, Tr>& flush();

Valore restituito

Un riferimento all'oggetto basic_ostream.

Osservazioni:

Se rdbuf non è un puntatore Null, la funzione chiama rdbuf-pubsync>. Se restituisce -1, la funzione chiama setstate(badbit). Restituisce *this.

Esempio

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

int main( )
{
   using namespace std;
   cout << "test";
   cout.flush();
}
test

basic_ostream::operator<<

Scrive nel flusso.

basic_ostream<Elem, Tr>& operator<<(
    basic_ostream<Elem, Tr>& (* Pfn)(basic_ostream<Elem, Tr>&));

basic_ostream<Elem, Tr>& operator<<(
    ios_base& (* Pfn)(ios_base&));

basic_ostream<Elem, Tr>& operator<<(
    basic_ios<Elem, Tr>& (* Pfn)(basic_ios<Elem, Tr>&));

basic_ostream<Elem, Tr>& operator<<(basic_streambuf<Elem, Tr>* strbuf);
basic_ostream<Elem, Tr>& operator<<(bool val);
basic_ostream<Elem, Tr>& operator<<(short val);
basic_ostream<Elem, Tr>& operator<<(unsigned short val);
basic_ostream<Elem, Tr>& operator<<(int __w64  val);
basic_ostream<Elem, Tr>& operator<<(unsigned int __w64  val);
basic_ostream<Elem, Tr>& operator<<(long val);
basic_ostream<Elem, Tr>& operator<<(unsigned long __w64  val);
basic_ostream<Elem, Tr>& operator<<(long long val);
basic_ostream<Elem, Tr>& operator<<(unsigned long long val);
basic_ostream<Elem, Tr>& operator<<(float val);
basic_ostream<Elem, Tr>& operator<<(double val);
basic_ostream<Elem, Tr>& operator<<(long double val);
basic_ostream<Elem, Tr>& operator<<(const void* val);

Parametri

Pfn
Un puntatore di funzione.

strbuf
Puntatore a un oggetto stream_buf.

val
Un elemento da scrivere nel flusso.

Valore restituito

Un riferimento all'oggetto basic_ostream.

Osservazioni:

L'intestazione <ostream> definisce anche diversi operatori di inserimento globali. Per altre informazioni, vedere l'argomento relativo all'operatore<<.

La prima funzione membro garantisce che un'espressione del modulo chiami endl(ostr)e quindi restituisca *this.ostr << endl La seconda e la terza funzione garantiscono che gli altri manipolatori, ad esempio hex, si comportino in modo analogo. Le funzioni rimanenti sono tutte funzioni di output formattato.

Funzione

basic_ostream<Elem, Tr>& operator<<(basic_streambuf<Elem, Tr>* strbuf);

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

Funzione

basic_ostream<Elem, Tr>& operator<<(bool val);

converte _Val in un campo booleano e lo inserisce chiamando use_facet<num_put<Elem, OutIt(>getloc). put(OutIt(rdbuf), *this, getloc, val). Qui, OutIt è definito come ostreambuf_iterator<Elem, Tr.> La funzione restituisce *this.

Funzioni

basic_ostream<Elem, Tr>& operator<<(short val);
basic_ostream<Elem, Tr>& operator<<(unsigned short val);
basic_ostream<Elem, Tr>& operator<<(int val);
basic_ostream<Elem, Tr>& operator<<(unsigned int __w64  val);
basic_ostream<Elem, Tr>& operator<<(long val);
basic_ostream<Elem, Tr>& operator<<(unsigned long val);
basic_ostream<Elem, Tr>& operator<<(long long val);
basic_ostream<Elem, Tr>& operator<<(unsigned long long val);
basic_ostream<Elem, Tr>& operator<<(const void* val);

ogni valore converte val in un campo numerico e lo inserisce chiamando use_facet<num_put<Elem, OutIt>(getloc). put(OutIt(rdbuf), *this, getloc, val). Qui OutIt è definito come ostreambuf_iterator<Elem, Tr>. La funzione restituisce *this.

Funzioni

basic_ostream<Elem, Tr>& operator<<(float val);
basic_ostream<Elem, Tr>& operator<<(double val);
basic_ostream<Elem, Tr>& operator<<(long double val);

ogni valore converte val in un campo numerico e lo inserisce chiamando use_facet<num_put<Elem, OutIt(). put(OutIt>(rdbufgetloc), *this, getloc, val). Qui OutIt è definito come ostreambuf_iterator<Elem, Tr>. La funzione restituisce *this.

Esempio

// basic_ostream_op_write.cpp
// compile with: /EHsc
#include <iostream>
#include <string.h>

using namespace std;

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

basic_ostream<char, char_traits<char> >& somefunc(basic_ostream<char, char_traits<char> > &i)
{
    if (i == cout)
    {
        i << "i is cout" << endl;
    }
    return i;
}

class CTxtStreambuf : public basic_streambuf< char, char_traits< char > >
{
public:
    CTxtStreambuf(char *_pszText)
    {
        pszText = _pszText;
        setg(pszText, pszText, pszText + strlen(pszText));
    };
    char *pszText;
};

int main()
{
    cout << somefunc;
    cout << 21 << endl;

    hex2(cout);
    cout << 21 << endl;

    CTxtStreambuf f("text in streambuf");
    cout << &f << endl;
}

basic_ostream::operator=

Assegna i valori per il parametro dell'oggetto basic_ostream specificato in questo oggetto.

basic_ostream& operator=(basic_ostream&& right);

Parametri

right
Riferimento rvalue a un oggetto basic_ostream.

Osservazioni:

L'operatore membro chiama swap (right).

basic_ostream::p ut

Inserisce un carattere in un flusso.

basic_ostream<Elem, Tr>& put(char_type _Ch);

Parametri

_Ch
Carattere.

Valore restituito

Un riferimento all'oggetto basic_ostream.

Osservazioni:

La funzione di output non formattata inserisce l'elemento _Ch. Restituisce *this.

Esempio

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

int main( )
{
   using namespace std;
   cout.put( 'v' );
   cout << endl;
   wcout.put( L'l' );
}
v
l

basic_ostream::seekp

Reimposta la posizione nel flusso di output.

basic_ostream<Elem, Tr>& seekp(pos_type _Pos);

basic_ostream<Elem, Tr>& seekp(off_type _Off, ios_base::seekdir _Way);

Parametri

_Pos
La posizione all'interno del flusso.

_Fuori
Offset relativo a _Way.

_Modo
Una delle enumerazioni ios_base::seekdir.

Valore restituito

Un riferimento all'oggetto basic_ostream.

Osservazioni:

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.

Esempio

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

int main()
{
    using namespace std;
    ofstream x("basic_ostream_seekp.txt");
    streamoff i = x.tellp();
    cout << i << endl;
    x << "testing";
    i = x.tellp();
    cout << i << endl;
    x.seekp(2);   // Put char in third char position in file
    x << " ";

    x.seekp(2, ios::end);   // Put char two after end of file
    x << "z";
}
0
7

basic_ostream::sentry

La classe annidata descrive un oggetto la cui dichiarazione struttura le funzioni di output formattate e quelle non formattate.

class sentry { public: explicit sentry(basic_ostream<Elem, Tr>& _Ostr); operator bool() const; ~sentry(); };

Osservazioni:

La classe annidata descrive un oggetto la cui dichiarazione struttura le funzioni di output formattate e quelle non formattate. Se ostr.good è true e ostr.tie non è un puntatore Null, il costruttore chiama ostr.tie-flush>. Il costruttore archivia quindi il valore restituito da ostr.good in status. Una chiamata successiva per recapitare operator bool questo valore archiviato.

Se restituisce e flags&unitbuf è diverso da zero, il distruttore chiama flush.falseuncaught_exception

basic_ostream::swap

Scambia i valori in questo oggetto basic_ostream con quelli dell'oggetto basic_ostream specificato.

void swap(basic_ostream& right);

Parametri

right
Riferimento a un oggetto basic_ostream.

Osservazioni:

La funzione membro chiama basic_ios::swap(right) per scambiare il contenuto di questo oggetto per il contenuto di destra.

basic_ostream::tellp

Indica la posizione nel flusso di output.

pos_type tellp();

Valore restituito

La posizione nel flusso di output.

Osservazioni:

Se fail è false, la funzione membro restituisce rdbuf-pubseekoff>(0, cur, in). In caso contrario, restituisce pos_type(-1).

Esempio

Vedere seekp per un esempio in cui viene usato tellp.

basic_ostream::write

Inserisce i caratteri in un flusso.

basic_ostream<Elem, Tr>& write(const char_type* str, streamsize count);

Parametri

count
Numero di caratteri da inserire nel flusso.

str
Caratteri da inserire nel flusso.

Valore restituito

Un riferimento all'oggetto basic_ostream.

Osservazioni:

La funzione di output non formattata inserisce la sequenza di elementi counta partire da str.

Esempio

Vedere streamsize per un esempio in cui viene usato write.

Vedi anche

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