Tema 3. Uso de ficheros en C y C++.

I Parte.

Programación
 Índice

1. Introducción al uso de ficheros

2. Tipos de ficheros
3. Uso de ficheros
4. Ficheros en C
5. Ficheros en C++
6. Tratamiento de errores
7. Excepciones
8. Excepciones en C++

2
 1. Introducción al uso de ficheros

● Los datos generados en los programas, (ej. los de

un vector) se guardan durante la ejecución en la
memoria volátil del ordenador. Una vez ejecutado
el programa, los datos desaparecen.
● Muchas de las aplicaciones que se desarrollan
necesitan leer/escribir datos de ficheros para un
uso posterior por el mismo u otro programa.
 1. Introducción al uso de ficheros

● Un fichero o archivo es una colección ordenada de

datos que tienen entre sí una relación y que se
almacenan de forma permanente en un dispositivo
de memoria no volátil.
● Un fichero tiene un formato predefinido, conocido
de antemano, lo que permite su lectura y/o escritura
siguiendo unas pautas preestablecidas.
● Para una correcta lectura o escritura, el formato del
fichero debe ser conocido de antemano.
 Índice

1. Introducción al uso de ficheros

2. Tipos de ficheros
3. Uso de ficheros
4. Ficheros en C
5. Ficheros en C++
6. Tratamiento de errores
7. Excepciones
8. Excepciones en C++

5
 2. Tipos de ficheros

● Teniendo en cuenta la forma en que los datos son almacenados, los

ficheros podríamos clasificarlos como:
● Ficheros binarios:
● Contienen una secuencia de bytes interpretables como valores.
● No son interpretables por un ser humano.
● Generalmente no portable (se debe leer en el mismo tipo de ordenador y con el mismo
lenguaje de programación con el que se creó).
● Suelen contener volcados de zonas de memoria de un programa (variables y sus
contenidos).
● Escritura/lectura eficiente.
● Almacenamiento eficiente de la información.
● Ficheros de texto:
● Secuencia de caracteres, codificados en ASCII, UTF-8, ISO-8859-1, etc.
● Se organizan en líneas, delimitadas por el carácter de salto de línea '\n'.
● Interpretable por un humano.
● Generalmente portable (legible en diferentes equipos).
● Escritura/lectura menos eficiente que para ficheros binarios.
● Requiere mayor tamaño que un fichero binario para representar información.
 Índice

1. Introducción al uso de ficheros

2. Tipos de ficheros
3. Uso de ficheros
4. Ficheros en C
5. Ficheros en C++
6. Tratamiento de errores
7. Excepciones
8. Excepciones en C++

7
 3. Uso de ficheros

● Cuando trabajamos con ficheros debemos realizar

algunas tareas:
● Abrir el fichero: asociar el fichero (definido a nivel del
S.O.) con un objeto que provea la fuente de datos y
definir si se va utilizar para entrada o para salida de
datos, es decir, para leer o para escribir.
● Cerrar el fichero: una vez finalizada la interacción con
el objeto que representa el fichero, este hecho debe ser
informado al S.O. mediante los métodos apropiados. Así,
el S.O. podrá realizar las acciones requeridas para
garantizar que el fichero queda en un estado
consistente y seguro.
 3. Uso de ficheros

● Conceptos relacionados con ficheros:

● Stream: las operaciones de lectura/escritura hacen uso del concepto
de flujo o corriente de datos (stream).
● Memoria intermedia buffers: La entrada/salida desde/hacia ficheros está
mediada, de forma transparente al programador, por el uso de áreas de la
memoria RAM, conocidas como búferes (buffers).
● Dado que los procesos de lectura/escritura en los dispositivos son mucho
más lentos que los realizados en la RAM, los datos son temporalmente
leídos/escritos en búferes. De esta forma, los accesos a un dispositivo lento
no ralentizan las aplicaciones.

buffer
stream
program fichero
a stream

buffer
 3. Uso de ficheros

● Conceptos relacionados con ficheros:

● Cuando operamos con flujos de archivos, éstos se asocian a un objeto
buffer interno. Este objeto buffer puede representar un bloque de
memoria que actúa como intermediario entre el stream y el archivo físico.
● Cuando el buffer se vacía, todos los datos contenidos en él se escriben en
el medio físico (si es un stream de salida). Este proceso se denomina
sincronización y tiene lugar en cualquiera de las siguientes circunstancias:
a) Cuando se cierra el archivo: antes de cerrar un archivo, se sincronizan
todos los búferes que aún no han sido vaciados y se escriben o leen
todos los datos pendientes en el medio físico.
b) Cuando el buffer está lleno: Los buffers tienen un tamaño
determinado. Cuando el buffer está lleno se sincroniza automáticamente.
c) De forma explícita cuando se produce una sincronización explícita por
medio de funciones de sincronización.
 3. Uso de ficheros

● ¿Por qué es importante cerrar un fichero?

● La escritura/lectura se realiza sobre buffers, y sus
contenidos son eventualmente transferidos al medio
físico. Cuando se cierra el fichero, se fuerza a realizar
esa transferencia. De otro modo, se podría incurrir en
pérdida de información.
● La utilización de un fichero puede comportar un consumo
importante de memoria del ordenador (buffer y otros
elementos). Si no se cierra el fichero, esa memoria
permanece bloqueada, sin uso, y, por tanto, inutilizada.
● El Sistema Operativo establece un número máximo de
ficheros que pueden estar abiertos simultáneamente a
cargo de una aplicación. Si no cerramos los ficheros que, de
momento, no estamos utilizando, puede que nuestro
programa no pueda abrir otros que sí son necesarios.
 Índice

1. Introducción al uso de ficheros

2. Tipos de ficheros
3. Uso de ficheros
4. Ficheros en C
5. Ficheros en C++
6. Tratamiento de errores
7. Excepciones
8. Excepciones en C++

12
 4. Ficheros en C

● C representa un fichero como una estructura

FILE definida en la biblioteca stdio.h.

#include <stdio.h>
int main(){

FILE *f; /* Descriptor de fichero, es la única

variable que utilizaremos para referirnos al fichero*/

return 0;

}
 4. Ficheros en C

● Pasos para la lectura/escritura de un fichero en C:

1. Apertura del fichero fopen.
2. Escritura o lectura utilizando fprintf o fscanf.
3. Cierre del fichero explícitamente fclose.
 4. Ficheros en C

● Las funciones fopen()y fclose()trabajan con ficheros

de texto con buffer:
● la entrada y salida se almacenan temporalmente en un área
de memoria llamada buffer.
● Cuando el buffer se llena, el contenido se traspasa a un
bloque de memoria (en lectura) o a la salida (en escritura).
● Una de las tareas principales de fclose()es el vaciado
del buffer, que podría haber quedado parcialmente
lleno al cerrar el fichero, y que puede ocasionar que
realicemos una lectura errónea en el futuro.
● También se puede utilizar la función fflush() para,
literalmente, forzar el volcado del contenido del
buffer en el fichero, sin cerrarlo.
 4. Ficheros en C

Abrir el fichero:
● FILE* fopen(const char *nombre, const char *modo)
● devuelve un puntero a fichero. Si el fichero no ha podido abrirse,
devuelve un NULL.
● nombre: cadena de caracteres con el nombre del fichero o con la ruta.
● modo: cadena de caracteres con el modo de acceso al fichero.
● r (read): abre un archivo existente para lectura.
● w (write): crea un nuevo archivo para escritura (si ya existe, se pierden los datos
preexistentes)
● a (append): abre el archivo para añadir datos al final (se conservan datos
existentes), o crea el archivo si no existía.
● r+: indica que el archivo se abre en modo de lectura y escritura. Esto significa que
se pueden realizar tanto operaciones de lectura como de escritura en el archivo. Si
se quiere escribir en el archivo, se sobrescribirá el contenido existente desde el
principio del archivo. Si se quiere agregar contenido al final del archivo, se debe
usar la función fseek para mover el puntero de posición del archivo al final del
archivo antes de escribir, o bien usar el modo a+ (lectura y escritura al final)
● b (binary): modificador de los modos r, w, a, para lectura y/o escritura de ficheros
binarios.
 4. Ficheros en C

Ejemplo de apertura de un fichero:

Es importante comprobar que se ha abierto
correctamente el fichero antes de proceder
a su utilización.

En expresiones condicionales, se puede usar un

#include <stdio.h> puntero NULL como una condición falsa, ya que se
int main(){ evalúa como falso en un contexto booleano.
FILE *fichero;
if (!(fichero = fopen("[Link]", "w"))) {
printf("Error al abrir el fichero");
exit(0); /* abandonamos el programa */
} else {
/*otras instrucciones*/
fclose(fichero); /*cerramos el fichero*/
}
return 0;
}
 4. Ficheros en C

Escritura en un fichero:
● int fprintf(FILE *nombre, const char *formato, ...)
● FILE *nombre es un puntero al fichero.
● const char *formato contiene la cadena de texto que se
va a escribir
● Se pueden usar códigos de formato: %d, %f, etc. para formatear el
contenido de una o varias variables del programa que deseamos
escribir en el fichero.
● Argumentos adicionales que coinciden con los especificadores
de formato en la cadena de formato.
● Devuelve el nº de bytes o caracteres escritos en el fichero. En
caso de error, devuelve un valor negativo.
● Nota: fprintf no genera al final un salto de línea en el
fichero.
 4. Ficheros en C

Escritura en un fichero:
● Especificadores de formato más comunes:
● %d - Entero decimal con signo
● %u - Entero decimal sin signo
● %x - Entero hexadecimal sin signo en minúsculas
● %f - Número de punto flotante
● %e - Número de punto flotante en notación científica (e minúscula)
● %c - Carácter
● %s - Cadena de caracteres
● %% - Carácter de porcentaje (literal)
 4. Ficheros en C

Escritura en un fichero:
● Ejemplos de formato:
● '%10d': el número entero debe imprimirse en un campo de ancho de
10 espacios de caracteres.
● '%.2f': el número de punto flotante debe imprimirse con dos dígitos
decimales.
● '%10.3f': el número de punto flotante debe imprimirse con:
● El 10 indica la anchura de campo de 10 caracteres
● Si el número que se va a imprimir tiene menos de 10 caracteres, se rellenará
con espacios en blanco hasta alcanzar la anchura especificada.
● El 3 indica la precisión de 3 dígitos después del punto decimal
● Si el número tiene menos de tres dígitos después del punto, se rellenará con
ceros a la derecha hasta alcanzar la precisión especificada.
● Si el número tiene más de tres dígitos después del punto, se redondearán los
dígitos adicionales según las reglas de redondeo estándar.
 4. Ficheros en C

Ejemplo de escritura en un fichero:

#include <stdio.h>
int main(){
FILE *fichero;
char nombre[20] = ”Laura";
int edad = 34;
/* controlamos si se produce un error */
if (!(fichero = fopen("[Link]", "w"))) {
printf("Error al abrir el fichero");
exit(0); /* abandonamos el programa */
}else{
fprintf(fichero, "%20s %2d\n", nombre, edad);
fclose(fichero);
}
return 0;
}
 4. Ficheros en C

Ejemplo de escritura de un fichero:

[Link]
#include <stdio.h>
#define TABLA 7
Tabla de multiplicar del 7
void main(){ 7x1=7
int i, m;
7 x 2 = 14
FILE *f; 7 x 3 = 21
if (!(f = fopen("[Link]", "w"))) {
printf("Error al abrir el fichero");
7 x 4 = 28
exit(0); /* abandonamos el programa */ 7 x 5 = 35
} else {
fprintf(f, "Tabla de multiplicar del %i\n", TABLA);
7 x 6 = 42
for(i = 1; i <= 10; i++){ 7 x 7 = 49
m = TABLA * i;
fprintf(f, "%d x %d = %d\n", TABLA, i, m);
7 x 8 = 56
} 7 x 9 = 63
fclose(f);
printf("Tabla creada.");
7 x 10 = 70
}
}
 4. Ficheros en C

Lectura de fichero:
● int fscanf(FILE *nombre, const char *formato, ...)
● FILE *nombre: es un puntero al fichero
● const char *formato: contiene el texto que se va a leer
(junto con los códigos de formato: %d, %f, etc).
● Una o varias variables donde deseamos almacenar el o los
datos leídos.
● fscanf devuelve el nº de valores que han sido leídos del
fichero y almacenados en las variables. Si no ha podido leer
más valores porque ha llegado al final del
fichero, devuelve EOF.
 4. Ficheros en C

Ejemplo de lectura de datos de fichero:

#include <stdio.h>
#include <stdlib.h>

int main() {

FILE *fichero;
char nombre[20];
int edad = 34;

if (!(fichero = fopen("[Link]", "r"))) {

printf("Error al abrir el fichero");
exit(0);
} else {
fscanf(fichero, "%s %d\n", nombre, &edad);
printf("Nombre: %s Edad: %d", nombre, edad);
fclose(fichero);
}

return 0;
}
 4. Ficheros en C

Ejemplo de lectura de todas las líneas de un fichero:

#include <stdio.h>
#include <stdlib.h>

int main(){
char nombre[20];
int edad;
float talla;

FILE *f;

if (!(f = fopen("[Link]", "r"))) {

printf("Error al abrir el fichero"); que el número de
exit(0); datos leído sea igual
} else {
a3
while(fscanf(f, "%s %d %f", nombre, &edad, &talla) == 3){
printf("nombre: %s edad: %d talla: %.2f\n", nombre, edad, talla);
}
fclose(f);
}
return 0;
}

[Link]
Luis 20 1.80 $> ./leerTodasLasLineasFichero
nombre: Luis edad: 20 talla: 1.80
Carlos 34 1.60 nombre: Carlos edad: 34 talla: 1.60
Pablo 40 1.70 nombre: Pablo edad: 40 talla: 1.70
 4. Ficheros en C

Lectura de fichero:
● char *fgets(char *str, int num, FILE *nombre);
● char *str: Es un puntero a un buffer de caracteres donde
se almacenará la línea leída del archivo.
● int num: número máximo de caracteres que se leerán desde
el archivo.
● FILE *nombre: Es un puntero al archivo del que se leerá la
línea.
● La función devuelve:
● un puntero al buffer de caracteres str si tiene éxito.
● NULL si ocurre un error o si se alcanza el final del archivo sin leer
ninguna línea.
 4. Ficheros en C

Ejemplo de lectura de todas las líneas de un fichero:

#include <stdio.h>
#include <stdlib.h>

int main() {
char linea[100];
char nombre[20];
int edad;
float talla; Se usa sscanf para
analizar la línea y
FILE *f; extraer los valores
de nombre, edad y
if (!(f = fopen("[Link]", "r"))) {
talla. Si sscanf
printf("Error al abrir el fichero");
exit(1); devuelve 3, significa
} else { que se han leído los
while (fgets(linea, sizeof(linea), f) != NULL) { tres valores
// Parsea los valores de la línea correctamente y se
if (sscanf(linea, "%s %d %f", nombre, &edad, &talla) == 3) {
imprimen en la
printf("nombre: %s edad: %d talla: %.2f\n", nombre, edad, talla);
} else { consola
printf("Error al leer la línea: %s\n", linea);
}
}
[Link] fclose(f);
}
Luis 20 1.80 }
return 0;

Carlos 34 1.60
$> ./leerTodasLasLineasFichero
Pablo 40 1.70 nombre: Luis edad: 20 talla: 1.80
nombre: Carlos edad: 34 talla: 1.60
nombre: Pablo edad: 40 talla: 1.70
 Índice

1. Introducción al uso de ficheros

2. Tipos de ficheros
3. Uso de ficheros
4. Ficheros en C
5. Ficheros en C++
6. Tratamiento de errores
7. Excepciones
8. Excepciones en C++

28
 5. Ficheros en C++

● Para el uso de lectura/escritura de ficheros es

necesario que el programador cree objetos de la
clase necesaria que representen el flujo de datos.
● Las clases para manejar ficheros se encuentran
dentro de la librería fstream
● ifstream (input file stream), clase orientada para la
lectura.
● ofstream (output file stream), clase orientada para la
escritura.
● fstream (file stream), cuando deseemos
alternativamente leer o escribir del mismo fichero en el
mismo programa.
 5. Ficheros en C++

● Pasos para la lectura/escritura de un fichero en

C++:
1. Apertura del fichero creando un objeto de la clase deseada
(ifstream, ofstream ó fstream).
2. Escritura o lectura utilizando los operadores de
inserción << o extracción >> como si del teclado o consola se tratase.
3. Cierre del fichero implícitamente cuando el objeto sale del ámbito en el
que se ha definido o explícitamente llamando a la función
miembro close().
Incluye la biblioteca estándar de C++ para entrada y salida estándar.
#include <iostream>
Incluye la biblioteca estándar de C++ para operaciones de archivos.
#include <fstream>
using namespace std;
Crea un objeto de flujo de salida de
archivos cuyo identificador es
int main() {
miFichero y lo abre en modo de
// Paso 1: crear y abrir un fichero de texto
escritura. Se crea un archivo llamado
ofstream miFichero("[Link]");
"[Link]" (o se sobrescribe si ya
existe).
// Paso 2: escribir en el fichero
Escribe la cadena de caracteres "Estamos
miFichero << ”Estamos escribiendo!";
escribiendo!" en el archivo miFichero. El
operador << se utiliza para enviar datos al
// Paso 3: cerrar el fichero
archivo.
[Link]();
}
 5. Ficheros en C++

● La clase ofstream por defecto crea ficheros

tipo texto para escritura. Si el fichero existe, equivale a su
borrado previo.
● La clase ifstream por defecto abre ficheros
tipo texto para lectura. Si el fichero no existe, se generará
un error.
● C++ permite especificar explícitamente otros modos (flags)
de apertura. Están definidos en el espacio de nombres ios.
Algunos de ellos son:
● ios:: binary: modo binario.
● ios:: app: modo añadir (append). Este modo permite añadir
datos al final de un fichero ya existente y, por tanto, no se pierden
los datos anteriores.
ofstream fich(nombre_fichero, ios::app);
 5. Ficheros en C++
● Ejemplo: escritura en un fichero con el operador de
inserción <<
if (!fich.is_open()){
#include <fstream> // Para ofstream
#include <iostream> // Para cout También se podría utilizar el método
is_open que devuelve true o false si el
using namespace std;
stream está actualmente asociado a un
archivo.
int main(){
Paso 1. Creamos un objeto con
1. ofstream fich("[Link]"); identificador fich de la clase ofstream
if (!fich){ que hace referencia a un fichero para
cout << "Error al abrir [Link]\n"; escritura con nombre “[Link]”.
exit(EXIT_FAILURE); Si no se ha podido crear el objeto que
} representa el fichero, se genera un
mensaje de error y salimos del
programa.
for (int i = 0; i < 10; ++i)
Paso 2. Si se ha podido crear el fichero,
2. fich << i << endl; escribimos la secuencia de número del
1 al 10.
3. [Link]();
}

Paso 3. Cuando un objeto en C++ sale del ámbito en el que se encuentra declarado, una función
interna llamada destructor se encarga automáticamente de liberar los recursos que ese objeto haya
podido acaparar.
En el ejemplo, el destructor de la clase ofstream se encarga de cerrar el fichero, aunque nosotros no
lo hayamos hecho.
 5. Ficheros en C++

● Ejemplo: añadir datos a un fichero

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

void guarda_enteros(int valor, string nombre_fichero){

ofstream fich(nombre_fichero, ios::app);
if (!fich){
cout << "Error al abrir " << nombre_fichero << endl;
exit(EXIT_FAILURE);
} else {
for (int i = 0; i < valor; ++i){
fich << i << endl;
}
[Link]();
}
}

int main(){
int valor = 10;
string nombre_fichero = "[Link]";
guarda_enteros(valor, nombre_fichero);
return 0;
}
 5. Ficheros en C++
#include <fstream> // Para ifstream

● Ejemplo: lectura de datos de #include <iostream> // Para cout

using namespace std;

un fichero con el operador de void muestraVector(int a[], int numDatos);

extracción >> int main(){

ifstream fich("[Link]");
Paso 1. Creamos un objeto fich de la clase if (!fich.is_open()){
ifstream con nombre “[Link]”. Si no se ha cout << "Error al abrir el fichero\n";
podido crear el objeto que representa el fichero, se exit(EXIT_FAILURE);
genera un mensaje de error y salimos del programa. }

int valor;
int i = 0;
int numDatos;
fich >> numDatos;

Paso 2. Si se ha podido abrir el fichero, escribimos la int a[numDatos];

secuencia de número del 1 al 10 y lo guardamos en while (fich >> valor){
el vector. a[i] = valor;
i++;
}
Paso 3. Cuando un objeto en C++ sale del ámbito en [Link]();
el que se encuentra declarado, una función interna muestraVector(a, numDatos);
llamada destructor se encarga automáticamente return 0;
de liberar los recursos que ese objeto haya podido }
acaparar.
void muestraVector(int a[], int numDatos){
En el ejemplo, el destructor de la clase ifstream se for (int i = 0; i < numDatos; i++ )
cout << a[i] << " ";
encarga de cerrar el fichero, aunque nosotros no lo
cout << endl;
hayamos hecho.
}
 5. Ficheros en C++

●Ejemplo: lectura de datos de un fichero con el operador de extracción

>>

● Podemos utilizar distintos formatos para almacenar la información.

10 10 10
1 123456789 1
2 10 2
3
3
4
5 4
6 5
7 6
8 7
9 8
10 9 10
● Al igual que ocurre con cin, el proceso de extracción ignora espacios en blanco y caracteres nueva línea.
● el operador de extracción >> procesa el flujo de datos entre dos caracteres distintos a espacios en
blanco.
 5. Ficheros en C++

● Ejemplo: lectura de líneas de un fichero con el

método getline
● istream& getline(istream& is, string& str)
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main () {
string linea;
ifstream miFichero("[Link]");
if (miFichero.is_open()){
while(getline(miFichero, linea)){
cout << linea << '\n';
}
[Link]();
}
else cout << ”Error al abrir el fichero";
return 0;
}
 5. Ficheros en C++

● istringstream es una clase (tipo de datos) en C++

que se utiliza para convertir cadenas de texto
en datos de otros tipos, como enteros, flotantes,
etc. Es parte de la biblioteca de flujo (<sstream>).
● istringstream se utiliza comúnmente junto con
la operación de extracción (>>) para leer datos de
una cadena de texto.
● Por ejemplo, se puede utilizar istringstream para
extraer los valores numéricos de cada línea
de un archivo. Esto nos permite leer la línea como
una cadena de texto y luego extraer los valores
numéricos uno por uno, verificando si son válidos.
 5. Ficheros en C++

● Ejemplo: lectura de líneas de un fichero con el

método getline
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;

int main() {
string linea;
ifstream miFichero("[Link]");
if (miFichero.is_open()) {
while (getline(miFichero, linea)) {
istringstream ss(linea);
string nombre;
int edad;
double altura;
ss >> nombre >> edad >> altura;
cout << "Nombre: " << nombre << ", Edad: " << edad << ", Alt: " << altura << endl;
}
[Link]();
} else {
cout << "Error al abrir el fichero" << endl;
}
return 0;
}
 5. Ficheros en C vs C++

C C++

librería #include <stdio.h> #include <iostream>

s #include <fstream>
apertur FILE* fichero = fopen("[Link]", "w") ofstream fichero("[Link]");
a FILE* fichero = fopen("[Link]", "a") ofstream fichero("[Link]", ios::app);
FILE* fichero = fopen("[Link]", "r") ifstream fichero("[Link]");
//comprobar si el fichero se ha abierto con éxito //comprobar si el fichero se ha abierto con éxito
if (fichero == NULL) { if (! fichero.is_open()) {
perror("Error\n"); std::cerr << "Error" << std::endl;
return 1; return 1;
} }
escritur char palabra[100]= “Ana”; string nombre = “Ana”;
a int edad = 20; int edad = 20;
fprintf(fichero, "%s %d\n", nombre, edad); fichero << nombre << " "<< edad << endl;
lectura char palabra[100]; string nombre;
de int edad; int edad;
datos fscanf(fichero, "%s %d\n", nombre, &edad); fichero >> nombre >> edad
lectura char linea[100]; string linea;
de fgets(linea, 100, fichero); getline(fichero, linea)
línea //extraer los datos de la línea //extraer los datos de la línea
sscanf(linea, "%s %d", nombre, &edad); istringstream ss(linea);
ss >> nombre >> edad;
cierre fclose(fichero) [Link]()
 5. Ficheros en C vs C++
Ejemplo de escritura en fichero en C y en C++
#include <stdio.h> #include <iostream>
#include <fstream>
int main() {
FILE *archivo; int main() {
std::ofstream archivo("[Link]");
// Abre el archivo para escritura
archivo = fopen("[Link]", "w"); if (!archivo.is_open()) {
if (archivo == NULL) { std::cerr << "Error" << std::endl;
printf("No se pudo abrir\n"); return 1;
return 1; }
}
// Escribe en el archivo
// Escribe en el archivo archivo << "Hola, mundo!" << std::endl;
fprintf(archivo, "Hola, mundo!\n");
// Cierra el archivo
// Cierra el archivo [Link]();
fclose(archivo); return 0;
}
return 0;
}
 5. Ficheros en C vs C++
Ejemplo de lectura de fichero en C y en C++
#include <stdio.h> #include <iostream>
#include <fstream>
int main() { #include <string>
FILE *archivo;
char linea[100]; int main() {
std::ifstream archivo("[Link]");
// Abre el archivo para lectura std::string linea;
archivo = fopen("[Link]", "r");
if (archivo == NULL) { if (!archivo.is_open()) {
printf("No se pudo abrir\n"); std::cerr << "Error" << std::endl;
return 1; return 1;
} }

// Lee y muestra cada línea del archivo // Lee y muestra cada línea del archivo
while (fgets(linea, 100, archivo) != NULL) { while (std::getline(archivo, linea)) {
printf("%s", linea); std::cout << linea << std::endl;
} }

// Cierra el archivo // Cierra el archivo

fclose(archivo); [Link]();

return 0; return 0;
} }