Partilhar via


basic_filebuf Class

Descreve um buffer de fluxo que controla a transmissão de elementos do tipo Elem, cujas características de caractere são determinadas pela classe Tre para uma seqüência de elementos armazenados em um arquivo externo.

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

Parâmetros

  • Elem
    O elemento básico do buffer de arquivo.

  • Tr
    Características do elemento básico do buffer de arquivo (geralmente char_traits<Elem>).

Comentários

A classe de modelo descreve um buffer de fluxo que controla a transmissão de elementos do tipo Elem, cujas características de caractere são determinadas pela classe Tre para uma seqüência de elementos armazenados em um arquivo externo.

ObservaçãoObservação

Objetos do tipo basic_filebuf criado com um buffer interno do tipo char * independentemente do char_type especificado pelo parâmetro de tipo Elem.Isso significa que uma seqüência de caracteres Unicode (contendo wchar_t caracteres) será convertido em uma seqüência ANSI (contendo char caracteres) antes de serem gravada no buffer interno.Para armazenar seqüências de caracteres Unicode no buffer, criar um novo buffer do tipo wchar_t e defini-la usando o basic_streambuf::pubsetbuf() método.Para ver um exemplo que demonstra esse comportamento, consulte abaixo.

An object of class basic_filebuf<Elem, Tr> armazena um ponteiro de arquivo, que designa o FILE objeto que controla o fluxo associado com um arquivo aberto.Ele também armazena ponteiros para duas facetas de conversão de arquivo para uso com as funções de membro protegido estouro de e estouro negativo de.Para mais informações, consulte basic_filebuf::open.

Exemplo

O exemplo a seguir demonstra como forçar um objeto do tipo basic_filebuf<wchar_t> para armazenar caracteres Unicode em seu buffer interno chamando o pubsetbuf() método.

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

tzf8k3z8.collapse_all(pt-br,VS.110).gifConstrutores

basic_filebuf

Constrói um objeto do tipo basic_filebuf.

tzf8k3z8.collapse_all(pt-br,VS.110).gifTypedefs

char_type

Associa um nome de tipo com o Elem parâmetro do modelo.

int_type

Faz esse tipo de basic_filebufdo escopo equivalente ao tipo de mesmo nome de Tr escopo.

off_type

Faz esse tipo de basic_filebufdo escopo equivalente ao tipo de mesmo nome de Tr escopo.

pos_type

Faz esse tipo de basic_filebufdo escopo equivalente ao tipo de mesmo nome de Tr escopo.

traits_type

Associa um nome de tipo com o Tr parâmetro do modelo.

tzf8k3z8.collapse_all(pt-br,VS.110).gifFunções de membro

Fechar

Fecha um arquivo.

is_open

Indica se um arquivo é aberto.

abrir

Abre um arquivo.

estouro

Uma função virtual protegida que pode ser chamada quando um novo caractere é inserido em um buffer cheio.

pbackfail

A função de membro virtual protegido tenta colocar novamente um elemento no fluxo de entrada, em seguida, torna o elemento atual (indicado pelo ponteiro próximo).

seekoff

A função de membro virtual protegido tenta alterar posições atuais para fluxos controlados.

seekpos

A função de membro virtual protegido tenta alterar posições atuais para fluxos controlados.

setbuf

A função de membro virtual protegido realiza uma determinada operação para cada buffer de fluxo derivado.

Troca

Troca o conteúdo de basic_filebuf para o conteúdo do fornecida basic_filebuf parâmetro.

sincronização

Função virtual protegida tenta sincronizar fluxos controlados com quaisquer fluxos externos associados.

uflow

Protegido, a função virtual para extrair o elemento atual do fluxo de entrada.

estouro negativo

Protegido, a função virtual para extrair o elemento atual do fluxo de entrada.

Requisitos

Cabeçalho: <fstream>

Namespace: std

Consulte também

Referência

Segurança do thread na biblioteca C++ padrão

iostream de programação

Convenções de iostreams

Outros recursos

<fstream> Membros

os membros do basic_filebuf