Cómo usar C ++ Fstream

El fstream Término significa File Stream. Stream se refiere a una secuencia de caracteres que se mueven del disco al programa C ++ o del programa C+ al disco. Mover caracteres de un archivo en el disco al programa está ingresando. Mover caracteres del programa a un archivo en el disco está saliendo. La transmisión de archivo de entrada abreviada como si el shream está estructurado por la clase de plantilla, BASIC_IFSTREAM. Abreviado por la transmisión de archivo de salida, OfStream está estructurado por la clase de plantilla, BASIC_OFStream.

Es posible que la entrada y salida se realicen en una sesión. Esto es posible por la plantilla de clase, Basic_fstream. Ahora, fstream es sinónimo de básico_fstream. fstream, que sigue siendo básico_fstream, usa básico_ifstream y ofstream para operar.

Para realizar la entrada solo, hacer la salida sola, o ambos en una sesión, es suficiente iniciar el programa C ++ con las siguientes incluyendo e invocaciones del espacio de nombres:

#incluir
#incluir
usando el espacio de nombres STD;

Este tutorial tiene cuatro secciones principales: apertura y cierre de una transmisión de archivo, transmisión de archivos de salida, agrega, transmisión de archivos de entrada y edición de un archivo. Editar un archivo significa ingresar y emitir una transmisión.

Contenido del artículo

• Abrir y cerrar una transmisión de archivo
• Operación de flujo de archivo de salida
• Agregar los caracteres a un archivo
• Operación de flujo de archivo de entrada
• Leer el archivo completo con una función
• Lectura de línea por línea
• Buscando en el archivo
• Función Tellg ()

Abrir y cerrar una transmisión de archivo

Antes de que se pueda abrir una transmisión, se debe crear un objeto de transmisión. Abrir una transmisión significa establecer un canal entre el programa C ++ y el archivo en el disco. Esto se logra a través de la cual la secuencia de caracteres se moverá al archivo; o a través del cual la secuencia de caracteres dejará el archivo y vendrá al programa; o a través del cual los personajes se moverán hacia.

Se abre una secuencia solo para escribir (salida), lectura (entrada) o leer y escribir. También se puede abrir por otras razones.

Antes de abrir una transmisión, el objeto de transmisión debe construirse. La forma más sencilla de expresarlo es la siguiente en la función C ++ Main ():

fstream strm;

Ahora, con el objeto STRM, se pueden usar las funciones del miembro fstream, abrir () y cerrar (), que precede a cada uno con el operador DOT. La siguiente declaración se puede usar para abrir un FSTREAM para leer:

void open ("ruta/a/y/the/file", iOS_Base :: in);

La función de miembro aban () devuelve nula.

Con el objeto de transmisión, la declaración sería:

strm.abierto("./myFile ", iOS_Base :: in);

Dado que la función Open () miembro devuelve Void, para saber si el archivo en el disco se abrió correctamente, use la función miembro:

bool is_open () const;

Devuelve cero para falso si el archivo no se abrió y 1 para verdadero si el archivo se abrió. Ahora nuestro programa se ve así hasta ahora:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()
fstream strm;
strm.abierto("./myFile ", iOS_Base :: in);
if (strm.Esta abierto())
cout << "Open success" << endl;

demás
cout << "Open failed" << endl;
regresar 1;

regresar 0;

Para abrir un archivo para escribir, use este indicador:

strm.abrir ("ruta/to/y/the/file", iOS_Base :: out);

iOS_Base :: en significa abrir para la lectura y iOS_Base :: OUT significa abrir para escribir. Para abrir un archivo para leer y escribir, use:

strm.Open ("ruta/a/y/the/file", iOS_Base :: in | iOS_Base :: Out);

Nota: La presencia de "iOS_Base :: en | ios_base :: out ", que usa lógico o para combinar ambas banderas como un solo argumento a la función.

Cerrar una transmisión significa cerrar el canal a través del cual se pueden enviar datos de un lado a otro entre el programa y el archivo. No se puede enviar más dato en ninguna dirección utilizando ese canal. Cerrar la transmisión no está cerrando el objeto de la corriente. La misma secuencia aún se puede usar para abrir un nuevo canal, que debe cerrarse después de su uso en la transmisión de datos. Hacer que sea un hábito de cerrar cualquier transmisión de archivo, después de que se haya abierto. Cuando se cierra una transmisión, cualquier datos en la memoria que se suponía que estaba en el archivo se envía al archivo antes de cerrar realmente. El prototipo de la función miembro para cerrar fstream es:

nulo cerrado ();

Devuelve nulo, desafortunadamente. Entonces, para saber si el cierre fue exitoso, use la función miembro:

bool is_open () const;

Si el cierre fuera exitoso, esto volvería cero, lo que significa que la transmisión ya no está abierta. Si el cierre no tuviera éxito, regresaría 1 y lo que significa que la corriente no podría cerrarse.

Operación de flujo de archivo de salida

Ahora demostraremos abrir un archivo y darle un nuevo contenido de datos. Para abrir una transmisión de salida con FSREAM, solo use iOS_Base :: OUT Solo en la función de miembro abierto (). El siguiente programa abre un archivo y le envía el contenido de una cadena:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()
fstream strm;
strm.Abrir ("DOC1.txt ", ios_base :: out);
si (!strm.Esta abierto())
cout << "File could not be opened!" << endl;
regresar 1;

char str [] = "A: Esta es la primera línea.\norte"
"B: Esta es la segunda línea.\norte"
"C: Esta es la tercera línea.\norte";
strm << str;
strm.cerca();
if (strm.Esta abierto())
cout << "Stream could not close!" << endl;
regresar 1;

cout << "Success, check file" << endl;
regresar 0;

El nombre del archivo es DOC1.TXT puede incluir una ruta completa o una ruta relativa. STR identifica el nuevo contenido en el programa. Al final del programa, el contenido de cadena se habría insertado en la transmisión y, por lo tanto, el archivo con la declaración:

strm << str;

Cout es un objeto de salida estándar, y generalmente se usa para la consola. Utiliza el operador de extracción, << . El operador de extracción también se usa con transmisiones de archivos. El objeto de transmisión de archivo aquí es strm. El carácter '\ n' al final de cada cita anterior es asegurarse de que la siguiente línea aparezca a continuación en el archivo de salida:

En lugar de enviar texto al archivo con el operador de inserción, se puede usar la función de miembro Write (). El siguiente código ilustra esto:

Basic_ostream & Write (const char_type* s, streamsize n)

Aquí está el código completo con la función de escritura utilizada:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()
fstream strm;
strm.Abrir ("DOC2.txt ", ios_base :: out);
si (!strm.Esta abierto())
cout << "File could not be opened!" << endl;
regresar 1;

char str [] = "A: Esta es la primera línea.\norte"
"B: Esta es la segunda línea.\norte"
"C: Esta es la tercera línea.\norte";
strm.escribir (str, strlen (str));
strm.cerca();
if (strm.Esta abierto())
cout << "Stream could not close!" << endl;
regresar 1;

regresar 0;

El primer argumento de la función Write () es el identificador de la matriz de caracteres. El segundo argumento es el número de caracteres (sin \ 0) en la matriz.

Agregar caracteres a un archivo

Para agregar texto a un archivo, use "iOS_Base :: App" solo, en lugar de "iOS_Base :: Out" en la función de miembro Open (). Aún así, use el operador de inserción, <<, as follows:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()
fstream strm;
strm.Abrir ("DOC2.txt ", iOS_Base :: App);
si (!strm.Esta abierto())
cout << "File could not be opened!" << endl;
regresar 1;

char str [] = "D: Esta es la cuarta línea.\norte";
strm << str;
strm.cerca();
if (strm.Esta abierto())
cout << "Stream could not close!" << endl;
regresar 1;

cout << "Success, check file" << endl;
regresar 0;

El archivo de salida ahora debe tener cuatro líneas.

Operación de flujo de archivo de entrada

Ahora demostraremos leer un archivo de personaje por personaje con fstream. Para leer un archivo con fstream, use iOS_Base :: en Como la bandera en la función de miembro abierta (). El siguiente programa lee todo el contenido del archivo y lo muestra en la consola:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

fstream strm;
strm.Abrir ("DOC1.txt ", iOS_Base :: in);
si (!strm.Esta abierto())
cout << "Open file failed" << endl;
regresar 1;

char c;
mientras (!strm.eof ())
strm.obtener (c);
cout << c;

strm.cerca();
regresar 0;

El EOF () es una función miembro, y devuelve 1 cuando se alcanza el final del archivo y cero de lo contrario. El programa lee los caracteres del archivo, uno por uno, hasta que se alcanza el final del archivo. Utiliza la función de miembro get (), colocando el carácter de lectura en la variable c, que ya ha sido declarada. Cout envía a cada personaje a la consola. La salida debe ser:

A: Esta es la primera línea.
B: Esta es la segunda línea.
C: Esta es la tercera línea.

Leer el archivo completo con una función

Todo el archivo se puede leer utilizando la función miembro:

Basic_istream & get (char_type* s, streamsize n, char_type delim);

Copia caracteres del archivo y los pone en una matriz de personajes. Hace esto hasta que se encuentra con el delimitador, EOF o hasta que haya copiado el carácter N - 1. Se ajustará al carácter nulo ('\ 0') como el último personaje consecutivo en la matriz. Esto significa que el número de caracteres elegidos para la matriz debe estimarse en al menos el número de caracteres de archivo (incluido cualquier \ n), más uno para el carácter nulo. No copia el carácter delimitador. El siguiente código copia todo el archivo de DOC1.txt, usando esta función miembro:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

fstream strm;
strm.Abrir ("DOC1.txt ", iOS_Base :: in);
si (!strm.Esta abierto())
cout << "Open file failed" << endl;
regresar 1;

char arr [150];
strm.Obtener (arr, 150, EOF);
strm.cerca();
cout << arr << endl;
regresar 0;

Lectura de línea por línea

La función miembro para usar para leer desde un archivo con fstream line by line es:

Basic_istream& getLine (char_type* s, streamsize n, char_type delim);

Copia caracteres del archivo y los pone en una matriz de personajes. Hace esto hasta que se encuentra con el delimitador (e.gramo. '\ n') o hasta que haya copiado el carácter n - 1. Se ajustará al carácter nul ('\ 0') como el último personaje consecutivo en la matriz. Esto significa que el número de caracteres elegidos para la matriz debe estimarse en al menos el número de caracteres visibles, más uno para el personaje nulo. No copia el carácter delimitador. El siguiente código copia todo el archivo de DOC1.TXT Line by Line, usando esta función de miembro:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

fstream strm;
strm.Abrir ("DOC1.txt ", iOS_Base :: in);
si (!strm.Esta abierto())
cout << "Open file failed" << endl;
regresar 1;

char arr [100];
mientras (!strm.eof ())
strm.GetLine (arr, 100, '\ n');
cout << arr << endl;

strm.cerca();
regresar 0;

Dado que '\ n' no se copia al copiar una línea, EndL debe usarse para la pantalla de salida. Tenga en cuenta que el número de caracteres en la variable de matriz y transmisión se ha hecho el mismo. Si se sabe de antemano que el delimitador es '\ n', entonces se puede usar la siguiente función de miembro:

Basic_istream& getLine (char_type* s, streamsize n);

Buscando en el archivo

Personajes que incluyen '\ n' tienen sus posiciones naturales en el archivo, a partir de 0, luego 1, 2, 3, y así sucesivamente. La función miembro de Seekg (POS) apuntaría el puntero al carácter de una posición en el objeto de transmisión. Entonces, Get (C) se puede usar para obtener ese carácter. El personaje de los 27^th posición del DOC1 actual.El archivo txt es 'b'. El siguiente código lo lee y lo muestra:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

fstream strm;
strm.Abrir ("DOC1.txt ", iOS_Base :: in);
si (!strm.Esta abierto())
cout << "Open file failed" << endl;
regresar 1;

char c;
strm.Seekg (27);
strm.obtener (c);
cout << c << endl;
strm.cerca();
regresar 0;

Si la posición dada es mayor que la del último carácter en el archivo (menos 1), NULL se devuelve.

Función Tellg ()

A medida que se lee un archivo, un puntero interno apunta al siguiente personaje que se lee. La función miembro de TellG () puede obtener el número de posición del carácter al que apunta el puntero. Cuando el archivo se acaba de abrir, TellG () devolverá 0 para el primer carácter. Después de leer la primera línea, TellG () devolvería un número como 27 en el ejemplo a continuación:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

fstream strm;
strm.Abrir ("DOC1.txt ", iOS_Base :: in);
si (!strm.Esta abierto())
cout << "Open file failed" << endl;
regresar 1;

char arr [100];
int
strm.GetLine (arr, 100, '\ n');
pos = strm.Tellg ();
strm.cerca();
cout << "Position in file is now: " << pos <regresar 0;

La salida es:

~ $ ./T9
La posición en el archivo es ahora: 27

La función equivalente para la salida es TellP ().

Seekdir

Seekdir significa buscar dirección. Sus constantes definidas en la biblioteca iOS_Base son: Bend por el comienzo del archivo, CUR para la posición actual del archivo y finalizar para finalizar el archivo. La función SeekG () anterior está sobrecargada para la secuencia de entrada como:

Basic_istream & Seekg (Off_Type, iOS_Base :: SeekDir)

Entonces, si el puntero interno apunta al carácter en la posición 27 contando el comienzo desde 0, entonces

strm.Seekg (0, iOS_Base :: Cur);

Mantendrá el puntero en la posición actual.

strm.Seekg (5, iOS_Base :: Cur);

Tomará el puntero 5 lugares por delante para señalar "I" en el segundo "esto" del DOC1.archivo txt.

strm.Seekg (-5, iOS_Base :: Cur);

Tomará el puntero 5 lugares detrás para señalar "I" en la primera "línea" del DOC1.archivo txt. Tenga en cuenta que la posición del carácter nuevo '\ n', que no se muestra en la salida, se cuenta.

Ahora, no importa dónde pueda estar el puntero,

strm.Seekg (0, iOS_Base :: Beg);

Toma y mantiene el puntero al comienzo del archivo; señalar el primer carácter del archivo, con un desplazamiento de 0. En este caso, apuntará a "A".

strm.Seekg (5, iOS_Base :: Beg);

Tomará el puntero al principio con un desplazamiento de 5 lugares por delante; punto en "I" en el primer "esto" del DOC1.archivo txt. Tenga en cuenta que el espacio único se cuenta como un personaje.

Un entero negativo en la posición de desplazamiento para "iOS_Base :: Beg" no es útil.

Bueno, no importa dónde pueda el puntero,

strm.Seekg (0, iOS_Base :: End);

Tomará y mantendrá el puntero justo después del final del archivo; para señalar nada.

Un entero positivo en la posición de desplazamiento para "iOS_Base :: End" no es útil.

strm.Seekg (-5, iOS_Base :: End);

Tomará el puntero al final con una compensación de 5 lugares detrás; punto en "I" en la última "línea" del DOC1.archivo txt. Tenga en cuenta que '\ n' y el punto se cuentan como un carácter cada uno.

El siguiente código ilustra el uso de la función, en la posición actual, con un desplazamiento negativo y positivo:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

fstream strm;
strm.Abrir ("DOC1.txt ", iOS_Base :: in);
si (!strm.Esta abierto())
cout << "Open file failed" << endl;
regresar 1;

char c;
strm.Seekg (27);
strm.Seekg (0, iOS_Base :: Cur);
strm.obtener (c);
cout << c << endl;
strm.Seekg (-5, iOS_Base :: Cur);
strm.obtener (c);
cout << c << endl;
strm.Seekg (+10, iOS_Base :: Cur);
strm.obtener (c);
strm.cerca();
regresar 0;

La salida es:

B
norte

La función de miembro get () cambia el puntero un lugar por delante después de su ejecución.

La función equivalente para la salida es:

Basic_ostream& Seekp (Off_type, iOS_Base :: Seekdir)

Tenga en cuenta la "P" en Seekp para PUT, en lugar de "G" en Seekg para Get.

Conclusión

La clase FStream se ocupa de la entrada de un archivo a un programa C ++ y la salida del programa al archivo. Para usar el C ++ Fstream, un objeto de la clase debe ser instanciado. El objeto de transmisión debe abrirse para la entrada o salida o ambos. Para agregar texto al archivo, la transmisión debe abrirse para agregar. Hacer el hábito de cerrar siempre la corriente después de que se haya abierto y usado. Si el archivo es un archivo de imagen, entonces ios_base :: binario tendrá que ser ored usando | , con el segundo argumento de la función de miembro Open (). Con suerte, este artículo le ayudó a usar el C ++ Fstream.