basic_filebuf (Clase)basic_filebuf Class

Describe un búfer de secuencia que controla la transmisión de elementos de tipo Char_T, cuyos rasgos de caracteres están determinados por la clase TR, a y desde una secuencia de elementos almacenados en un archivo externo.Describes a stream buffer that controls the transmission of elements of type Char_T, whose character traits are determined by the class Tr, to and from a sequence of elements stored in an external file.

SintaxisSyntax

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

ParámetrosParameters

Char_TChar_T
Elemento básico del búfer del archivo.The basic element of the file buffer.

AnticipoTr
Rasgos del elemento básico del búfer de archivo (normalmente char_traits<Char_T> ).The traits of the basic element of the file buffer (usually char_traits<Char_T>).

ObservacionesRemarks

La plantilla de clase describe un búfer de secuencia que controla la transmisión de elementos de tipo Char_T, cuyos rasgos de caracteres están determinados por la clase TR, a y desde una secuencia de elementos almacenados en un archivo externo.The class template describes a stream buffer that controls the transmission of elements of type Char_T, whose character traits are determined by the class Tr, to and from a sequence of elements stored in an external file.

Nota

Los objetos de tipo basic_filebuf se crean con un búfer interno de tipo * Char independientemente del char_type especificado por el parámetro de tipo Char_T.Objects of type basic_filebuf are created with an internal buffer of type char* regardless of the char_type specified by the type parameter Char_T. Esto significa que una cadena Unicode (que contiene wchar_t caracteres) se convertirá en una cadena ANSI (que contiene char caracteres) antes de que se escriba en el búfer interno.This means that a Unicode string (containing wchar_t characters) will be converted to an ANSI string (containing char characters) before it is written to the internal buffer. Para almacenar cadenas Unicode en el búfer, cree un nuevo búfer de tipo wchar_t y establézcalo mediante el basic_streambuf::pubsetbuf () método.To store Unicode strings in the buffer, create a new buffer of type wchar_t and set it using the basic_streambuf::pubsetbuf() method. Para ver un ejemplo que muestra este comportamiento, vea a continuación.To see an example that demonstrates this behavior, see below.

Un objeto de clase basic_filebuf<Char_T, Tr> almacena un puntero de archivo, que designa el FILE objeto que controla la secuencia asociada a un archivo abierto.An object of class basic_filebuf<Char_T, Tr> stores a file pointer, which designates the FILE object that controls the stream associated with an open file. También almacena punteros a dos facetas de conversión de archivo para su uso por parte de las funciones miembro protegidas overflow y underflow.It also stores pointers to two file conversion facets for use by the protected member functions overflow and underflow. Para obtener más información, vea basic_filebuf::open.For more information, see basic_filebuf::open.

EjemploExample

En el ejemplo siguiente se muestra cómo forzar un objeto de tipo basic_filebuf<wchar_t> para almacenar caracteres Unicode en su búfer interno mediante una llamada al método pubsetbuf().The following example demonstrates how to force an object of type basic_filebuf<wchar_t> to store Unicode characters in its internal buffer by calling the pubsetbuf() method.

// 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();
}
Hex Dump of wcHello.txt - note that output is ANSI chars:
48 65 6c 6c 6f 20 57 6f 72 6c 64 00 00 00 00 00   Hello World.....

Hex Dump of wwHello.txt - note that output is wchar_t chars:
48 00 65 00 6c 00 6c 00 6f 00 20 00 57 00 6f 00   H.e.l.l.o. .W.o.
72 00 6c 00 64 00 00 00 00 00 00 00 00 00 00 00   r.l.d...........

ConstructoresConstructors

ConstructorConstructor DescripciónDescription
basic_filebufbasic_filebuf Construye un objeto de tipo basic_filebuf.Constructs an object of type basic_filebuf.

TypedefsTypedefs

Nombre de tipoType name DescripciónDescription
char_typechar_type Asocia un nombre de tipo con el parámetro de plantilla Char_T.Associates a type name with the Char_T template parameter.
int_typeint_type Hace que este tipo en el ámbito de basic_filebuf equivalga al tipo con el mismo nombre del ámbito Tr.Makes this type within basic_filebuf's scope equivalent to the type of the same name in the Tr scope.
off_typeoff_type Hace que este tipo en el ámbito de basic_filebuf equivalga al tipo con el mismo nombre del ámbito Tr.Makes this type within basic_filebuf's scope equivalent to the type of the same name in the Tr scope.
pos_typepos_type Hace que este tipo en el ámbito de basic_filebuf equivalga al tipo con el mismo nombre del ámbito Tr.Makes this type within basic_filebuf's scope equivalent to the type of the same name in the Tr scope.
traits_typetraits_type Asocia un nombre de tipo con el parámetro de plantilla Tr.Associates a type name with the Tr template parameter.

Funciones miembroMember functions

Función de miembroMember function DescripciónDescription
cercanosclose Cierra un archivo.Closes a file.
is_openis_open Indica si un archivo está abierto.Indicates whether a file is open.
openopen Abre un archivo.Opens a file.
desbordamientooverflow Función virtual protegida a la que se puede llamar cuando se inserta un carácter nuevo en un búfer lleno.A protected virtual function that can be called when a new character is inserted into a full buffer.
pbackfailpbackfail La función miembro virtual protegida intenta colocar un elemento en el flujo de entrada y, a continuación, convertirlo en el elemento actual (indicado por el puntero siguiente).The protected virtual member function tries to put back an element into the input stream, then make it the current element (pointed to by the next pointer).
seekoffseekoff La función miembro virtual protegida trata de modificar las posiciones actuales de las secuencias controladas.The protected virtual member function tries to alter the current positions for the controlled streams.
seekposseekpos La función miembro virtual protegida trata de modificar las posiciones actuales de las secuencias controladas.The protected virtual member function tries to alter the current positions for the controlled streams.
setbufsetbuf La función miembro virtual protegida realiza una determinada operación para cada búfer de secuencia derivado.The protected virtual member function performs an operation particular to each derived stream buffer.
PasarSwap Intercambia el contenido de basic_filebuf por el contenido del parámetro basic_filebuf proporcionado.Exchanges the content of this basic_filebuf for the content of the provided basic_filebuf parameter.
sincronícelosync Función virtual protegida que intenta sincronizar las secuencias controladas con cualquier flujo externo asociado.Protected, virtual function tries to synchronize the controlled streams with any associated external streams.
uflowuflow Función virtual protegida que extrae el elemento actual de la secuencia de entrada.Protected, virtual function to extract the current element from the input stream.
subdesbordamientounderflow Función virtual protegida que extrae el elemento actual de la secuencia de entrada.Protected, virtual function to extract the current element from the input stream.

RequisitosRequirements

Encabezado:<fstream>Header: <fstream>

Espacio de nombres: stdNamespace: std

basic_filebuf:: basic_filebufbasic_filebuf::basic_filebuf

Construye un objeto de tipo basic_filebuf.Constructs an object of type basic_filebuf.

basic_filebuf();

basic_filebuf(basic_filebuf&& right);

ObservacionesRemarks

El primer constructor almacena un puntero nulo en todos los punteros que controlan el búfer de entrada y el de salida.The first constructor stores a null pointer in all the pointers controlling the input buffer and the output buffer. También almacena un puntero nulo en el puntero de archivo.It also stores a null pointer in the file pointer.

El segundo constructor inicializa el objeto con el contenido de la derecha, tratado como una referencia rvalue.The second constructor initializes the object with the contents of right, treated as an rvalue reference.

basic_filebuf:: char_typebasic_filebuf::char_type

Asocia un nombre de tipo con el parámetro de plantilla Char_T.Associates a type name with the Char_T template parameter.

typedef Char_T char_type;

basic_filebuf:: Closebasic_filebuf::close

Cierra un archivo.Closes a file.

basic_filebuf<Char_T, Tr> *close();

Valor devueltoReturn Value

La función miembro devuelve un puntero nulo si el puntero de archivo es un puntero nulo.The member function returns a null pointer if the file pointer is a null pointer.

ObservacionesRemarks

close llama a fclose(fp).close calls fclose(fp). Si esa función devuelve un valor distinto de cero, la función devuelve un puntero nulo.If that function returns a nonzero value, the function returns a null pointer. De lo contrario, devuelve this para indicar que el archivo se ha cerrado correctamente.Otherwise, it returns this to indicate that the file was successfully closed.

En el caso de una secuencia ancha, si se han producido inserciones desde que se abrió la secuencia o desde la última llamada a streampos , la función llama a overflow .For a wide stream, if any insertions have occurred since the stream was opened, or since the last call to streampos, the function calls overflow. También Inserta cualquier secuencia necesaria para restaurar el estado de conversión inicial mediante la faceta de conversión de archivo fac para llamar a fac.unshift según sea necesario.It also inserts any sequence needed to restore the initial conversion state, by using the file conversion facet fac to call fac.unshift as needed. Cada elemento generado byte de tipo char se escribe en el flujo asociado designado por el puntero de archivo como si se realizaran fp llamadas sucesivas del formulario fputc(byte, fp) .Each produced element byte of type char is written to the associated stream designated by the file pointer fp as if by successive calls of the form fputc(byte, fp). Si fac.unshift se produce un error en la llamada a o a cualquier escritura, la función no se realiza correctamente.If the call to fac.unshift or any write fails, the function does not succeed.

EjemploExample

En el ejemplo siguiente se suponen dos archivos en el directorio actual: basic_filebuf_close.txt (el contenido es "Testing") y iotest.txt (el contenido es "SSSS").The following sample assumes two files in the current directory: basic_filebuf_close.txt (contents is "testing") and iotest.txt (contents is "ssss").

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

int main() {
   using namespace std;
   ifstream file;
   basic_ifstream <wchar_t> wfile;
   char c;
   // Open and close with a basic_filebuf
   file.rdbuf()->open( "basic_filebuf_close.txt", ios::in );
   file >> c;
   cout << c << endl;
   file.rdbuf( )->close( );

   // Open/close directly
   file.open( "iotest.txt" );
   file >> c;
   cout << c << endl;
   file.close( );

   // open a file with a wide character name
   wfile.open( L"iotest.txt" );

   // Open and close a nonexistent with a basic_filebuf
   file.rdbuf()->open( "ziotest.txt", ios::in );
   cout << file.fail() << endl;
   file.rdbuf( )->close( );

   // Open/close directly
   file.open( "ziotest.txt" );
   cout << file.fail() << endl;
   file.close( );
}
t
s
0
1

basic_filebuf:: int_typebasic_filebuf::int_type

Convierte este tipo en el basic_filebuf ámbito equivalente al tipo del mismo nombre en el Tr ámbito.Makes this type within basic_filebuf scope equivalent to the type of the same name in the Tr scope.

typedef typename traits_type::int_type int_type;

basic_filebuf:: is_openbasic_filebuf::is_open

Indica si un archivo está abierto.Indicates whether a file is open.

bool is_open() const;

Valor devueltoReturn Value

true Si el puntero de archivo no es NULL.true if the file pointer isn't null.

EjemploExample

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

int main( )
{
   using namespace std;
   ifstream file;
   cout << boolalpha << file.rdbuf( )->is_open( ) << endl;

   file.open( "basic_filebuf_is_open.cpp" );
   cout << file.rdbuf( )->is_open( ) << endl;
}
false
true

basic_filebuf:: off_typebasic_filebuf::off_type

Convierte este tipo en el basic_filebuf ámbito equivalente al tipo del mismo nombre en el Tr ámbito.Makes this type within basic_filebuf scope equivalent to the type of the same name in the Tr scope.

typedef typename traits_type::off_type off_type;

basic_filebuf:: Openbasic_filebuf::open

Abre un archivo.Opens a file.

basic_filebuf<Char_T, Tr> *open(
    const char* filename,
    ios_base::openmode mode,
    int protection = (int)ios_base::_Openprot);

basic_filebuf<Char_T, Tr> *open(
    const char* filename,
    ios_base::openmode mode);

basic_filebuf<Char_T, Tr> *open(
    const wchar_t* filename,
    ios_base::openmode mode,
    int protection = (int)ios_base::_Openprot);

basic_filebuf<Char_T, Tr> *open(
    const wchar_t* filename,
    ios_base::openmode mode);

ParámetrosParameters

extensiónfilename
Nombre del archivo que se va a abrir.The name of the file to open.

modomode
Una de las enumeraciones en ios_base::openmode .One of the enumerations in ios_base::openmode.

frenteprotection
La protección de apertura de archivo predeterminada, equivalente al parámetro shflag de _fsopen, _wfsopen.The default file opening protection, equivalent to the shflag parameter in _fsopen, _wfsopen.

Valor devueltoReturn Value

Si el búfer ya está abierto, o si el puntero de archivo es un puntero nulo, la función devuelve un puntero nulo.If the buffer is already open, or if the file pointer is a null pointer, the function returns a null pointer. De lo contrario, devuelve this .Otherwise, it returns this.

ObservacionesRemarks

Esta función utiliza un FILE * para devolver la basic_filebuf como si hubiera llamado a fopen/wfopen (filename, strmode) .This function uses a FILE * to back the basic_filebuf as though you had called fopen/wfopen(filename, strmode). strmodese determina a partir de mode & ~( ate | binary ) :strmode is determined from mode & ~(ate | binary):

  • ios_base::inse convierte en "r" (abrir archivo existente para lectura).ios_base::in becomes "r" (open existing file for reading).
  • ios_base:: out o ios_base::out | ios_base::trunc se convierte en "w" (se trunca el archivo existente o se crea para escribir en él).ios_base::out or ios_base::out | ios_base::trunc becomes "w" (truncate existing file or create for writing).
  • ios_base::out | appse convierte en "a" (abrir el archivo existente para anexar todas las escrituras).ios_base::out | app becomes "a" (open existing file for appending all writes).
  • ios_base::in | ios_base::outse convierte en "r+" (abrir archivo existente para lectura y escritura).ios_base::in | ios_base::out becomes "r+" (open existing file for reading and writing).
  • ios_base::in | ios_base::out | ios_base::truncse convierte en "w+" (truncar archivo existente o crear para lectura y escritura).ios_base::in | ios_base::out | ios_base::trunc becomes "w+" (truncate existing file or create for reading and writing).
  • ios_base::in | ios_base::out | ios_base::appse convierte en "a+" (abrir archivo existente para lectura y para anexar todas las escrituras).ios_base::in | ios_base::out | ios_base::app becomes "a+" (open existing file for reading and for appending all writes).

Si mode & ios_base::binary es distinto de cero, la función anexa b a strmode para abrir una secuencia binaria en lugar de una secuencia de texto.If mode & ios_base::binary is nonzero, the function appends b to strmode to open a binary stream instead of a text stream. Si mode & ios_base::ate es distinto de cero y el archivo se abrió correctamente, la ubicación actual en la secuencia se coloca al final del archivo.If mode & ios_base::ate is nonzero and the file was succesfully opened, the current location in the stream is positioned at the end of file. Si se produce un error, se cierra el archivo.If that fails, the file is closed.

Si las operaciones anteriores se completaron correctamente, se determina la faceta de conversión de archivo: use_facet<codecvt<Char_T, char, traits_type:: state_type > >( getloc ) , para su uso por subdesbordamiento y desbordamiento.If the above operations completed successfully, the file conversion facet is determined: use_facet<codecvt<Char_T, char, traits_type::state_type> >(getloc), for use by underflow and overflow.

Si el archivo no se pudo abrir correctamente, se devuelve NULL.If the file could not be succesfully opened, null is returned.

EjemploExample

Vea basic_filebuf::close para obtener un ejemplo que usa open .See basic_filebuf::close for an example that uses open.

basic_filebuf:: Operator =basic_filebuf::operator=

Asigna el contenido de este objeto de búfer de secuencia.Assign the content of this stream buffer object. Se trata de una asignación de movimiento que implica un valor r que no deja ninguna copia atrás.This is a move assignment involving an rvalue that doesn't leave a copy behind.

basic_filebuf& operator=(basic_filebuf&& right);

ParámetrosParameters

correctaright
Referencia a un valor R a un objeto basic_filebuf.An rvalue reference to a basic_filebuf object.

Valor devueltoReturn Value

Devuelve * this.Returns *this.

ObservacionesRemarks

El operador miembro reemplaza el contenido del objeto utilizando el contenido de la derecha, tratado como una referencia rvalue.The member operator replaces the contents of the object by using the contents of right, treated as an rvalue reference. Para obtener más información, vea declarador de referencia rvalue: &&.For more information, see Rvalue reference declarator: &&.

basic_filebuf:: Overflowbasic_filebuf::overflow

Se llama cuando se inserta un nuevo carácter en un búfer lleno.Called when a new character is inserted into a full buffer.

virtual int_type overflow(int_type _Meta = traits_type::eof);

ParámetrosParameters

_Meta_Meta
Carácter que se va a insertar en el búfer o traits_type::eof .The character to insert into the buffer or traits_type::eof.

Valor devueltoReturn Value

Si la función no se puede ejecutar correctamente, devuelve traits_type::eof .If the function can't succeed, it returns traits_type::eof. De lo contrario, devuelve traits_type:: not_eof (_Meta) .Otherwise, it returns traits_type::not_eof(_Meta).

ObservacionesRemarks

Si es _Meta != traits_type:: eof , la función miembro virtual protegida intenta insertar el elemento ch = traits_type:: to_char_type (_Meta) en el búfer de salida.If _Meta != traits_type::eof, the protected virtual member function attempts to insert the element ch = traits_type::to_char_type(_Meta) into the output buffer. Puede hacerlo de varias maneras:It can do so in various ways:

  • Si está disponible una posición de escritura, puede almacenar el elemento en la posición de escritura e incrementar el puntero siguiente para el búfer de salida.If a write position is available, it can store the element into the write position and increment the next pointer for the output buffer.

  • Puede proporcionar una posición de escritura al asignar almacenamiento nuevo o adicional para el búfer de salida.It can make a write position available by allocating new or additional storage for the output buffer.

  • Puede convertir cualquier salida pendiente en el búfer de salida, seguida de ch , mediante la faceta de conversión de archivo fac para llamar a fac.out según sea necesario.It can convert any pending output in the output buffer, followed by ch, by using the file conversion facet fac to call fac.out as needed. Cada elemento generado ch de tipo Char se escribe en el flujo asociado designado por el puntero de archivo como si se realizaran fp llamadas sucesivas del formulario fputc(ch, fp) .Each produced element ch of type char is written to the associated stream designated by the file pointer fp as if by successive calls of the form fputc(ch, fp). Si se produce un error en cualquier conversión o escritura, la función no se ejecuta correctamente.If any conversion or write fails, the function does not succeed.

basic_filebuf: error de:pbasic_filebuf::pbackfail

Intenta volver a colocar un elemento en el flujo de entrada y luego convertirlo en el elemento actual (al que apunta el puntero siguiente).Tries to put back an element into the input stream, then make it the current element (pointed to by the next pointer).

virtual int_type pbackfail(int_type _Meta = traits_type::eof);

ParámetrosParameters

_Meta_Meta
El carácter que se va a insertar en el búfer o traits_type::eof.The character to insert into the buffer, or traits_type::eof.

Valor devueltoReturn Value

Si la función no se puede ejecutar correctamente, devuelve traits_type::eof .If the function can't succeed, it returns traits_type::eof. De lo contrario, devuelve traits_type:: not_eof (_Meta) .Otherwise, it returns traits_type::not_eof(_Meta).

ObservacionesRemarks

La función miembro virtual protegida vuelve a colocar un elemento en el búfer de entrada y luego lo convierte en el elemento actual (al que apunta el siguiente puntero).The protected virtual member function puts back an element into the input buffer and then makes it the current element (pointed to by the next pointer). Si _Meta == traits_type:: eof es, el elemento que se va a devolver es realmente el que ya está en la secuencia antes del elemento actual.If _Meta == traits_type::eof, the element to push back is effectively the one already in the stream before the current element. De lo contrario, ese elemento se reemplaza por ch = traits_type:: to_char_type (_Meta) .Otherwise, that element is replaced by ch = traits_type::to_char_type(_Meta). La función puede devolver un elemento de distintas maneras:The function can put back an element in various ways:

  • Si una putback posición está disponible y el elemento almacenado en la comparación es igual a ch , puede reducir el puntero siguiente para el búfer de entrada.If a putback position is available, and the element stored there compares equal to ch, it can decrement the next pointer for the input buffer.

  • Si la función puede hacer que una putback posición esté disponible, puede hacerlo, establecer el siguiente puntero para que apunte a esa posición y almacenar ch en esa posición.If the function can make a putback position available, it can do so, set the next pointer to point at that position, and store ch in that position.

  • Si la función puede volver a insertar un elemento en el flujo de entrada, puede hacerlo, por ejemplo, mediante una llamada a ungetc para un elemento de tipo char .If the function can push back an element onto the input stream, it can do so, such as by calling ungetc for an element of type char.

basic_filebuf::p os_typebasic_filebuf::pos_type

Convierte este tipo en el basic_filebuf ámbito equivalente al tipo del mismo nombre en el Tr ámbito.Makes this type within basic_filebuf scope equivalent to the type of the same name in the Tr scope.

typedef typename traits_type::pos_type pos_type;

basic_filebuf:: seekoffbasic_filebuf::seekoff

Intenta modificar las posiciones actuales de los flujos controlados.Tries to alter the current positions for the controlled streams.

virtual pos_type seekoff(
    off_type _Off,
    ios_base::seekdir _Way,
    ios_base::openmode _Which = ios_base::in | ios_base::out);

ParámetrosParameters

_Off_Off
Posición que se va a buscar en relación con _Way.The position to seek for relative to _Way.

_Way_Way
El punto de partida de las operaciones de desplazamiento.The starting point for offset operations. Vea los valores posibles en seekdir.See seekdir for possible values.

_Which_Which
Especifica el modo de la posición del puntero.Specifies the mode for the pointer position. El valor predeterminado es permitirle modificar las posiciones de lectura y escritura.The default is to allow you to modify the read and write positions.

Valor devueltoReturn Value

Devuelve la posición nueva o una posición de flujo no válida.Returns the new position or an invalid stream position.

ObservacionesRemarks

La función miembro virtual protegida intenta modificar las posiciones actuales de las secuencias controladas.The protected virtual member function attempts to alter the current positions for the controlled streams. Para un objeto de clase basic_filebuf <Char_T, Tr> , una posición de flujo se puede representar mediante un objeto de tipo fpos_t , que almacena un desplazamiento y cualquier información de estado necesaria para analizar un flujo ancho.For an object of class basic_filebuf<Char_T, Tr>, a stream position can be represented by an object of type fpos_t, which stores an offset and any state information needed to parse a wide stream. El desplazamiento cero hace referencia al primer elemento de la secuencia.Offset zero refers to the first element of the stream. (Un objeto de tipo pos_type almacena al menos un fpos_t objeto).(An object of type pos_type stores at least an fpos_t object.)

En el caso de un archivo abierto para lectura y escritura, los flujos de entrada y salida se colocan en tándem.For a file opened for both reading and writing, both the input and output streams are positioned in tandem. Para cambiar entre inserción y extracción, debe llamar a pubseekoff o pubseekpos .To switch between inserting and extracting, you must call either pubseekoff or pubseekpos. Las llamadas a pubseekoff (y por tanto a seekoff ) tienen varias limitaciones para flujos de texto, secuencias binariasy secuencias anchas.Calls to pubseekoff (and hence to seekoff) have various limitations for text streams, binary streams, and wide streams.

Si el puntero de archivo fp es un puntero nulo, se produce un error en la función.If the file pointer fp is a null pointer, the function fails. De lo contrario, intenta modificar la posición de la secuencia mediante una llamada a fseek(fp, _Off, _Way) .Otherwise, it attempts to alter the stream position by calling fseek(fp, _Off, _Way). Si esa función se realiza correctamente y la posición resultante fposn se puede determinar mediante una llamada a fgetpos(fp, &fposn) , la función se ejecuta correctamente.If that function succeeds and the resulting position fposn can be determined by calling fgetpos(fp, &fposn), the function succeeds. Si la función se ejecuta correctamente, devuelve un valor de tipo pos_type que contiene fposn .If the function succeeds, it returns a value of type pos_type containing fposn. De lo contrario, devuelve una posición de flujo no válida.Otherwise, it returns an invalid stream position.

basic_filebuf:: seekposbasic_filebuf::seekpos

Intenta modificar las posiciones actuales de los flujos controlados.Tries to alter the current positions for the controlled streams.

virtual pos_type seekpos(
    pos_type _Sp,
    ios_base::openmode _Which = ios_base::in | ios_base::out);

ParámetrosParameters

_Sp_Sp
La posición que se va a buscar.The position to seek for.

_Which_Which
Especifica el modo de la posición del puntero.Specifies the mode for the pointer position. El valor predeterminado es permitirle modificar las posiciones de lectura y escritura.The default is to allow you to modify the read and write positions.

Valor devueltoReturn Value

Si el puntero de archivo fp es un puntero nulo, se produce un error en la función.If the file pointer fp is a null pointer, the function fails. De lo contrario, intenta modificar la posición del flujo llamando a fsetpos(fp, &fposn) , donde fposn es el fpos_t objeto almacenado en pos .Otherwise, it attempts to alter the stream position by calling fsetpos(fp, &fposn), where fposn is the fpos_t object stored in pos. Si esa función se ejecuta correctamente, la función devuelve pos.If that function succeeds, the function returns pos. De lo contrario, devuelve una posición de flujo no válida.Otherwise, it returns an invalid stream position. Para determinar si la posición del flujo no es válida, compare el valor devuelto con pos_type(off_type(-1)).To determine if the stream position is invalid, compare the return value with pos_type(off_type(-1)).

ObservacionesRemarks

La función miembro virtual protegida intenta modificar las posiciones actuales de las secuencias controladas.The protected virtual member function attempts to alter the current positions for the controlled streams. Para un objeto de clase basic_filebuf <Char_T, Tr> , una posición de flujo se puede representar mediante un objeto de tipo fpos_t , que almacena un desplazamiento y cualquier información de estado necesaria para analizar un flujo ancho.For an object of class basic_filebuf<Char_T, Tr>, a stream position can be represented by an object of type fpos_t, which stores an offset and any state information needed to parse a wide stream. El desplazamiento cero hace referencia al primer elemento de la secuencia.Offset zero refers to the first element of the stream. (Un objeto de tipo pos_type almacena al menos un objeto fpos_t).(An object of type pos_type stores at least an fpos_t object.)

En el caso de un archivo abierto para lectura y escritura, los flujos de entrada y salida se colocan en tándem.For a file opened for both reading and writing, both the input and output streams are positioned in tandem. Para cambiar entre inserción y extracción, debe llamar a pubseekoff o pubseekpos .To switch between inserting and extracting, you must call either pubseekoff or pubseekpos. Las llamadas a pubseekoff (y a seekoff ) tienen varias limitaciones para flujos de texto, flujos binarios y flujos anchos.Calls to pubseekoff (and to seekoff) have various limitations for text streams, binary streams, and wide streams.

En un flujo ancho, si se han producido inserciones desde la apertura del flujo o desde la última llamada a streampos, la función llama a overflow.For a wide stream, if any insertions have occurred since the stream was opened, or since the last call to streampos, the function calls overflow. También Inserta cualquier secuencia necesaria para restaurar el estado de conversión inicial mediante la faceta de conversión de archivo fac para llamar a fac.unshift según sea necesario.It also inserts any sequence needed to restore the initial conversion state, by using the file conversion facet fac to call fac.unshift as needed. Cada elemento generado byte de tipo char se escribe en el flujo asociado designado por el puntero de archivo como si se realizaran fp llamadas sucesivas del formulario fputc(byte, fp) .Each produced element byte of type char is written to the associated stream designated by the file pointer fp as if by successive calls of the form fputc(byte, fp). Si fac.unshift se produce un error en la llamada a o a cualquier escritura, la función no se realiza correctamente.If the call to fac.unshift or any write fails, the function does not succeed.

basic_filebuf:: setbufbasic_filebuf::setbuf

Realiza una determinada operación para cada búfer de flujo derivado.Performs an operation particular to each derived stream buffer.

virtual basic_streambuf<Char_T, Tr> *setbuf(
    char_type* _Buffer,
    streamsize count);

ParámetrosParameters

_Buffer_Buffer
Puntero a un búfer.Pointer to a buffer.

contabilizacount
Tamaño del búfer.Size of the buffer.

Valor devueltoReturn Value

La función miembro protegida devuelve cero si el puntero de archivo fp es un puntero nulo.The protected member function returns zero if the file pointer fp is a null pointer.

ObservacionesRemarks

setbuflas llamadas setvbuf( fp, (char*) _Buffer, _IOFBF, count * sizeof( Char_T)) a ofrecen la matriz de count elementos que comienzan en _Buffer como un búfer para la secuencia.setbuf calls setvbuf( fp, (char*) _Buffer, _IOFBF, count * sizeof( Char_T)) to offer the array of count elements beginning at _Buffer as a buffer for the stream. Si esa función devuelve un valor distinto de cero, la función devuelve un puntero nulo.If that function returns a nonzero value, the function returns a null pointer. De lo contrario, devuelve this a Signal Success.Otherwise, it returns this to signal success.

basic_filebuf:: swapbasic_filebuf::swap

Intercambia el contenido de este basic_filebuf por el contenido del basic_filebuf proporcionado.Exchanges the contents of this basic_filebuf for the contents of the provided basic_filebuf.

void swap(basic_filebuf& right);

ParámetrosParameters

correctaright
Referencia a un valor l a otro basic_filebuf .An lvalue reference to another basic_filebuf.

basic_filebuf:: Syncbasic_filebuf::sync

Intenta sincronizar los flujos controlados con cualquier flujo externo asociado.Tries to synchronize the controlled streams with any associated external streams.

virtual int sync();

Valor devueltoReturn Value

Devuelve cero si el puntero de archivo fp es un puntero nulo.Returns zero if the file pointer fp is a null pointer. De lo contrario, devuelve cero solo si llama a en desbordamiento y fflush(fp) realiza correctamente el vaciado de cualquier salida pendiente en la secuencia.Otherwise, it returns zero only if calls to both overflow and fflush(fp) succeed in flushing any pending output to the stream.

basic_filebuf:: traits_typebasic_filebuf::traits_type

Asocia un nombre de tipo con el parámetro de plantilla Tr.Associates a type name with the Tr template parameter.

typedef Tr traits_type;

basic_filebuf:: subflowbasic_filebuf::underflow

Extrae el elemento actual del flujo de entrada.Extracts the current element from the input stream.

virtual int_type underflow();

Valor devueltoReturn Value

Si la función no se puede ejecutar correctamente, devuelve traits_type:: eof .If the function can't succeed, it returns traits_type::eof. De lo contrario, devuelve, que se ch convierte como se describe en la sección Comentarios.Otherwise, it returns ch, converted as described in the Remarks section.

ObservacionesRemarks

La función miembro virtual protegida intenta extraer el elemento actual ch del flujo de entrada y devolver el elemento como traits_type:: to_int_type (ch) .The protected virtual member function attempts to extract the current element ch from the input stream, and return the element as traits_type::to_int_type(ch). Puede hacerlo de varias maneras:It can do so in various ways:

  • Si hay una posición de lectura disponible, toma ch como el elemento almacenado en la posición de lectura y avanza el puntero siguiente para el búfer de entrada.If a read position is available, it takes ch as the element stored in the read position and advances the next pointer for the input buffer.

  • Puede leer uno o más elementos de tipo char , como si se realizaran llamadas sucesivas del formulario fgetc(fp) , y convertirlos en un elemento ch de tipo mediante Char_T la faceta de conversión de archivo fac para llamar a fac.in según sea necesario.It can read one or more elements of type char, as if by successive calls of the form fgetc(fp), and convert them to an element ch of type Char_T by using the file conversion facet fac to call fac.in as needed. Si se produce un error en cualquier conversión o lectura, la función no se ejecuta correctamente.If any read or conversion fails, the function does not succeed.

Consulte tambiénSee also

<fstream>
Seguridad para subprocesos en la biblioteca estándar de C++Thread Safety in the C++ Standard Library
Programación con iostreamiostream Programming
Convenciones de iostreamsiostreams Conventions