basic_filebuf, classe

Article
06/09/2015

Décrit une mémoire tampon du flux qui contrôle la transmission des éléments de type Elem, dont les caractéristiques de caractères sont déterminées par la classe Tr, vers et depuis une séquence d'éléments stockés dans un fichier externe.

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

Paramètres

Elem
L'élément de la mémoire tampon de fichier.
Tr
Les caractéristiques de l'élément de la mémoire tampon de fichier (généralement char_traits<Elem>).

Notes

La classe de modèle décrit une mémoire tampon du flux qui contrôle la transmission des éléments de type Elem, dont les caractéristiques de caractères sont déterminées par la classe Tr, vers et depuis une séquence d'éléments stockés dans un fichier externe.

Notes

Les objets de type basic_filebuf sont créés avec une mémoire tampon interne de type char * indépendamment de char_type spécifié par le paramètre de type Elem.Cela signifie qu'une chaîne Unicode (contenant des caractères wchar_t ) est convertie en chaîne ANSI (contenant des caractères de char ) avant d'être écrite dans la mémoire tampon interne.Pour stocker des chaînes Unicode dans la mémoire tampon, créez une nouvelle mémoire tampon de type wchar_t et définissez-la à l'aide de la méthode basic_streambuf::pubsetbuf().Pour obtenir un exemple qui illustre ce comportement, voir ci-dessous.

Un objet de la classe basic_filebuf<Elem, Tr> contient un pointeur de fichier, qui pointe vers l'objet FILE pour contrôler le flux associé à un fichier ouvert. Elle enregistre également les pointeurs vers deux facettes de conversion de fichier à utiliser par les méthodes protégées dépassement de capacité et dépassement de précision. Pour plus d'informations, consultez basic_filebuf::open.

Exemple

L'exemple suivant montre comment forcer un objet de type basic_filebuf<wchar_t> à stocker les caractères Unicode dans son tampon interne en appelant la méthode 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();
}

Constructeurs

basic_filebuf

Construit un objet de type basic_filebuf.

Typedef

caractère (type)	Associe un nom de type avec le paramètre de modèle Elem.
int (type)	Rend ce type dans la portée de basic_filebuf équivalent au type du même nom dans la portée de Tr.
off_type	Rend ce type dans la portée de basic_filebuf équivalent au type du même nom dans la portée de Tr.
pos_type	Rend ce type dans la portée de basic_filebuf équivalent au type du même nom dans la portée de Tr.
traits_type	Associe un nom de type avec le paramètre de modèle Tr.

Fonctions membres

fermer	Ferme un fichier.
est_ouvert	Indique si un fichier est ouvert.
ouvrir	Ouvre un fichier.
dépassement de capacité	Une fonction virtuelle protégée qui peut être appelée lorsqu'un nouveau caractère est inséré dans une mémoire tampon saturée.
pbackfail	La méthode virtuelle protégée qui tente de remettre un élément dans le flux d'entrée, puis fait de lui l'élément actuel (référencé par le prochain pointeur).
seekoff	La méthode virtuelle protégée tente de modifier les positions actuelles pour les flux de données contrôlés.
seekpos	La méthode virtuelle protégée tente de modifier les positions actuelles pour les flux de données contrôlés.
setbuf	La méthode virtuelle protégée exécute une opération particulière à chaque tampon de flux dérivé.
Echange	Échange le contenu de cet basic_filebuf avec le contenu du paramètre fourni de basic_filebuf.
sync	Une fonction virtuelle protégée qui tente de synchroniser les flux de données contrôlés avec n'importe quels flux externes associés.
uflow	Une fonction virtuelle protégée pour extraire l'élément actuel du flux d'entrée.
flux inférieur	Une fonction virtuelle protégée pour extraire l'élément actuel du flux d'entrée.