basic_filebuf Class

Article
03/15/2013

Décrit une mémoire tampon du flux qui contrôle la transmission d'éléments de type Elem, dont traits de caractère sont déterminées par la classe Tr, vers et à partir d'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 base de la mémoire tampon du fichier.
Tr
Les caractéristiques de l'élément de base de la mémoire tampon du 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 d'éléments de type Elem, dont traits de caractère sont déterminées par la classe Tr, vers et à partir d'une séquence d'éléments stockés dans un fichier externe.

[!REMARQUE]

Les objets de type basic_filebuf sont créés avec une mémoire tampon interne de type char * , quel que soit le char_type spécifié par le paramètre de type Elem.Cela signifie qu'une chaîne Unicode (contenant wchar_t caractères) sera converti en une chaîne ANSI (contenant char caractères) avant qu'il soit écrit dans la mémoire tampon interne.Pour stocker les chaînes Unicode dans la mémoire tampon, créez une nouvelle mémoire tampon de type wchar_t et définissez-la en utilisant la basic_streambuf::pubsetbuf() méthode.Pour voir un exemple qui illustre ce comportement, voir ci-dessous.

An object of class basic_filebuf<Elem, Tr> stocke un pointeur de fichier, qui désigne le FILE objet qui contrôle le flux associé à un fichier ouvert.Il stocke également des pointeurs vers les deux facettes de conversion de fichier pour une utilisation par les fonctions de membre protégé débordement et dépassement.Pour plus d'informations, consultez basic_filebuf::open.

Exemple

L'exemple suivant montre comment forcer un objet de type basic_filebuf<wchar_t> pour stocker des caractères Unicode dans sa mémoire tampon interne en appelant le pubsetbuf() méthode.

// 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

char_type	Associe un nom de type avec le Elem paramètre de modèle.
int_type	Rend ce type au sein de basic_filebufde portée équivalente au type portant le même nom dans la Tr étendue.
off_type	Rend ce type au sein de basic_filebufde portée équivalente au type portant le même nom dans la Tr étendue.
pos_type	Rend ce type au sein de basic_filebufde portée équivalente au type portant le même nom dans la Tr étendue.
traits_type	Associe un nom de type avec le Tr paramètre de modèle.

Fonctions membres

Fermer	Ferme un fichier.
is_open	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 fonction membre virtuel protégé tente replacé un élément dans le flux d'entrée, puis faire l'élément en cours (indiqué par le pointeur suivant).
seekoff	La fonction membre virtuel protégé tente de modifier les positions actuelles pour les flux contrôlés.
seekpos	La fonction membre virtuel protégé tente de modifier les positions actuelles pour les flux contrôlés.
setbuf	La fonction membre virtuel protégé effectue une opération notamment chaque tampon de flux dérivée.
Swap	Remplace le contenu de ce basic_filebuf pour le contenu de la liste fournie basic_filebuf paramètre.
Sync	Fonction virtuelle protégée essaie de synchroniser les flux contrôlés avec n'importe quel flux externes associés.
uflow	Protégé, une fonction virtuelle pour extraire l'élément actuel à partir du flux d'entrée.
dépassement de capacité négatif	Protégé, une fonction virtuelle pour extraire l'élément actuel à partir du flux d'entrée.