Classe basic_filebuf

Articolo
06/09/2015

Viene descritto un buffer del flusso che controlla la trasmissione degli elementi di tipo Elem, in cui i tratti di carattere sono determinati dalla classe Tr, in e da una sequenza di elementi archiviati in un file esterno.

template <class Elem, class Tr = char_traits<Elem> >
    class basic_filebuf : public basic_streambuf<Elem, Tr>

Parametri

Elem
L'elemento di base del buffer di file.
Tr
I tratti degli elementi di base del buffer di file in genere char_traits<Elem>).

Note

La classe modello descrive un buffer del flusso che controlla la trasmissione degli elementi di tipo Elem, in cui i tratti di carattere sono determinati dalla classe Tr, in e da una sequenza di elementi archiviati in un file esterno.

Nota

Oggetti di tipo basic_filebuf vengono creati con un buffer interno di tipo char * indipendentemente da char_type specificato dal parametro di tipo Elem.Ciò significa che una stringa Unicode (che contiene i caratteri di wchar_t ) verrà convertita in una stringa ANSI (/za che contiene i caratteri di char ) prima che venga scritto nel buffer interno.Per archiviare stringhe Unicode nel buffer, creare un nuovo buffer di tipo wchar_t e impostarlo tramite il metodo di basic_streambuf::pubsetbuf().Per un esempio che illustri questo comportamento, vedere di seguito.

Un oggetto di classe basic_filebuf<Elem, Tr> include un puntatore di file, che definisce l'oggetto di FILE che controlla quali il flusso associato a un file aperto. Inoltre memorizza i puntatori a due facet di conversione di file per l'utilizzo delle funzioni membro protette overflow e underflow. Per ulteriori informazioni, vedere basic_filebuf::open.

Esempio

Nell'esempio seguente viene illustrato come definire un oggetto di tipo basic_filebuf<wchar_t> dei caratteri unicode nel buffer interno chiamando il metodo pubsetbuf().

// unicode_basic_filebuf.cpp
// compile with: /EHsc

#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
#include <memory.h>
#include <string.h>

#define IBUFSIZE 16

using namespace std;

void hexdump(const string& filename);

int main()
{
    wchar_t* wszHello = L"Hello World";
    wchar_t wBuffer[128];

    basic_filebuf<wchar_t> wOutFile;

    // Open a file, wcHello.txt, then write to it, then dump the
    // file's contents in hex
    wOutFile.open("wcHello.txt",
        ios_base::out | ios_base::trunc | ios_base::binary);
    if(!wOutFile.is_open())
    {
        cout << "Error Opening wcHello.txt\n";
        return -1;
    }
    wOutFile.sputn(wszHello, (streamsize)wcslen(wszHello));
    wOutFile.close();
    cout << "Hex Dump of wcHello.txt - note that output is ANSI chars:\n";
    hexdump(string("wcHello.txt"));

    // Open a file, wwHello.txt, then set the internal buffer of
    // the basic_filebuf object to be of type wchar_t, then write
    // to the file and dump the file's contents in hex
    wOutFile.open("wwHello.txt",
        ios_base::out | ios_base::trunc | ios_base::binary);
    if(!wOutFile.is_open())
    {
        cout << "Error Opening wwHello.txt\n";
        return -1;
    }
    wOutFile.pubsetbuf(wBuffer, (streamsize)128);
    wOutFile.sputn(wszHello, (streamsize)wcslen(wszHello));
    wOutFile.close();
    cout << "\nHex Dump of wwHello.txt - note that output is wchar_t chars:\n";
    hexdump(string("wwHello.txt"));

    return 0;
}

// dump contents of filename to stdout in hex
void hexdump(const string& filename)
{
    fstream ifile(filename.c_str(),
        ios_base::in | ios_base::binary);
    char *ibuff = new char[IBUFSIZE];
    char *obuff = new char[(IBUFSIZE*2)+1];
    int i;

    if(!ifile.is_open())
    {
        cout << "Cannot Open " << filename.c_str()
             << " for reading\n";
        return;
    }
    if(!ibuff || !obuff)
    {
        cout << "Cannot Allocate buffers\n";
        ifile.close();
        return;
    }

    while(!ifile.eof())
    {
        memset(obuff,0,(IBUFSIZE*2)+1);
        memset(ibuff,0,IBUFSIZE);
        ifile.read(ibuff,IBUFSIZE);

        // corner case where file is exactly a multiple of
        // 16 bytes in length
        if(ibuff[0] == 0 && ifile.eof())
            break;

        for(i = 0; i < IBUFSIZE; i++)
        {
            if(ibuff[i] >= ' ')
                obuff[i] = ibuff[i];
            else
                obuff[i] = '.';

            cout << setfill('0') << setw(2) << hex
                 << (int)ibuff[i] << ' ';
        }
        cout << "  " << obuff << endl;
    }
    ifile.close();
}

Costruttori

basic_filebuf

Crea un oggetto di tipo basic_filebuf.

Definizioni typedef

char_type	Associa un nome del tipo con il parametro di modello di Elem.
int_type	Questo tipo è equivalente all'interno dell'ambito di basic_filebuf al tipo con lo stesso nome in ambito di Tr.
off_type	Questo tipo è equivalente all'interno dell'ambito di basic_filebuf al tipo con lo stesso nome in ambito di Tr.
pos_type	Questo tipo è equivalente all'interno dell'ambito di basic_filebuf al tipo con lo stesso nome in ambito di Tr.
traits_type	Associa un nome del tipo con il parametro di modello di Tr.

Funzioni del membro

scopo	Chiude un file.
is_open	Indica se un file è aperto.
apertura	Apre un file.
overflow	Una funzione virtuale protetta che possa essere chiamato quando un nuovo carattere viene inserito in un buffer completo.
pbackfail	La funzione membro virtuale protetta tenta di riportare un elemento del flusso di input, le rende l'elemento corrente (puntato il puntatore seguente).
seekoff	La funzione membro virtuale protetta tenta di modificare le posizioni correnti per i flussi archiviati.
seekpos	La funzione membro virtuale protetta tenta di modificare le posizioni correnti per i flussi archiviati.
setbuf	La funzione protetta membro virtuale esegua un determinato di un'operazione a ciascun buffer del flusso derivato.
Scambio	Scambia il contenuto di questo basic_filebuf per il contenuto del parametro specificato di basic_filebuf.
sincronizzazione	Protetta, la funzione virtuale tenta di sincronizzare i flussi archiviati con tutti i flussi esterni collegati.
uflow	Protetto, funzione virtuale per disegnare l'elemento corrente dal flusso di input.
underflow	Protetto, funzione virtuale per disegnare l'elemento corrente dal flusso di input.