Archivos
Estructura de archivos:
📁 06_Archivos
└── 📁 Archivos-NN
├── 📄 main.c
└── 📄 Makefile
Ejercicios:
Archivos 01
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Apertura de archivo en modo lectura y asignacion a fp
* r => Modo lectura, el archivo debe existir, de no existir la funcion devuelve NULL
*/
fp = fopen("nuevoarc.txt", "r");
/* Si fopen falla, muestra mensaje y llama a la funcion exit con el parametro 1 */
if (fp == NULL)
{
printf("\n\nError de apertura\n\n");
/* exit(1):
* - Finaliza el programa inmediatamente.
* - El 1 indica terminacion con error.
* - Por convencion:
* - 0 => Ejecucion correcta.
* - != 0 => Error
*/
exit(1);
}
/* SIEMPRE se debe cerrar el archivo asociado al puntero para liberar recursos del sistema, el archivo debio abrirse correctamente */
fclose(fp);
return 0;
}
Archivos 02
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Apertura de archivo en modo escritura.
* w => Modo write:
* - Si el archivo NO existe, lo crea.
* - Si el archivo EXISTE, lo sobreescribe pero perdiendo el contenido anterior
*/
fp = fopen("nuevoarc.txt", "w");
/* Verificacion de error en la apertura.
* Si fopen devuelve NULL, la operacion fallo (problemas de permisos, ruta invalida, etc.).
*/
if (fp == NULL)
{
printf("\n\nError de apertura\n\n");
/* Finalizacion del programa con codigo de error */
exit(1);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
* En modo w. si el archivo fue creado, queda efectivamente generado al cerrarlo.
*/
fclose(fp);
return 0;
}
Archivos 03
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <conio.h> // Se usa getche()
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Variable de tipo char inicializada en 0.
* Almacena cada caracter ingresado por teclado.
* Se utiliza como condicion de corte del bucle */
char c = 0;
/* Apertura de archivo en modo escritura.
* w => Modo write:
* - Si el archivo NO existe, lo crea.
* - Si el archivo EXISTE, lo sobreescribe pero perdiendo el contenido anterior
*/
fp = fopen("nuevoarc.txt", "w");
/* Verificacion de error en la apertura.
* Si fopen devuelve NULL, la operacion fallo (problemas de permisos, ruta invalida, etc.).
*/
if (fp == NULL)
{
printf("\n\nError de apertura\n\n");
/* Finalizacion del programa con codigo de error */
exit(1);
}
/* Bucle de ingreso de caracteres.
* Se ejecuta hasta que el usuario ingrese numeral.
*/
while (c != '#')
{
/* getche():
* Lee un caracter desde el teclado (stdin) y lo muestra en pantalla (stdout).
*/
c = getche();
/* fputc():
* Escribe un caracter en el archivo apuntado por fp.
* El caracter se almacena en el buffer del flujo.
*/
fputc(c, fp);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
* En modo w. si el archivo fue creado, queda efectivamente generado al cerrarlo.
*/
fclose(fp);
return 0;
}
Archivos 04
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Variable de tipo char inicializada en 0.
* Se utiliza para almacenar cada caracter leido del archivo
* y como condicion de corte del bucle.
*/
char c = 0;
/* Apertura de archivo en modo lectura.
* El cursor se posiciona al inicio del archivo.
*/
fp = fopen("nuevoarc.txt", "r");
/* Verificacion de error en la apertura.
* Si fopen devuelve NULL, la operacion fallo (problemas de permisos, ruta invalida, etc.).
*/
if (fp == NULL)
{
printf("\n\nError de apertura\n\n");
/* Finalizacion del programa con codigo de error */
exit(1);
}
/* Bucle de lectura caracter por caracter desde el archivo.
* En cada iteracion:
* - fgetc() lee el siguiente caracter del flujo.
* - putchar() lo muestra en pantalla.
* Finaliza cuando se detecta el caracter numeral.
*/
while (c != '#')
{
/* fgetc():
* Lee un caracter del archivo apuntado por fp.
* Avanza automaticamente la posicion del cursor.
*/
c = fgetc(fp);
/* putchar():
* Escribe en la salida estandar (stdout) el caracter leido.
*/
putchar(c);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo abierto en modo lectura.
*/
fclose(fp);
return 0;
}
Archivos 05
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Variable de tipo char inicializada en 0.
* Se utiliza para almacenar cada caracter leido del archivo
* y como condicion de corte del bucle.
*/
char c = 0;
/* Apertura de archivo en modo lectura.
* El cursor se posiciona al inicio del archivo.
*/
fp = fopen("nuevoarc.txt", "r");
/* Verificacion de error en la apertura.
* Si fopen devuelve NULL, la operacion fallo (problemas de permisos, ruta invalida, etc.).
*/
if (fp == NULL)
{
printf("\n\nError de apertura\n\n");
/* Finalizacion del programa con codigo de error */
exit(1);
}
/* Bucle do-while. Se ejecuta al menos una vez.
* En cada iteracion:
* - fgetc() lee un caracter del archivo.
* - putchar() lo muestra en pantalla.
*/
do
{
/* fgetc():
* Lee el siguiente caracter del flujo.
* Avanza automaticamente el cursor.
*/
c = fgetc(fp);
/* putchar():
* Muestra en la salida estandar (stdout) el caracter leido.
*/
putchar(c);
}
/* feof():
* Devuelve verdadero cuando se alcanza el fin de archivo (EOF).
*/
while(!feof(fp));
/* Cierre del archivo.
* Libera los recursos asociados al flujo abierto en modo lectura.
*/
fclose(fp);
return 0;
}
Archivos 06
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <conio.h> // Se usa getch()
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de punteros a FILE.
* in => flujo de entrada (archivo origen).
* out => flujo de salida (archivo destino).
*/
FILE *in, *out;
/* Variable de tipo char inicializada en 0.
* Se utiliza para almacenar cada caracter leido del archivo
* y como condicion de corte del bucle.
*/
char c;
/* Apertura del archivo origen en modo lectura.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if (!(in = fopen("Archiv1.c", "r")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
/* Apertura del archivo destino en modo escritura.
* Si no existe, se crea.
* Si existe se sobreescribe.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error-
*/
if (!(out = fopen("Arc.c", "w")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\n\n");
/* Bucle de copia caracter por caracter.
* Mientras no se alcance el fin del archivo origen:
* - fgetc() lee un caracater desde in.
* - fputc() lo escribe en el archivo out.
* - printf() lo muestra en pantalla.
*/
while(!feof(in))
{
c = fgetc(in);
/* Escritura del caracter leido en el archivo destino */
fputc(c,out);
/* Visualizacion en salida estandar */
printf("%c", c);
}
/* Cierre de los archivos.
* Libera los recursos asociados al flujo.
*/
fclose(in);
fclose(out);
/* getch():
* Pausa la ejecucion hasta presionar una tecla.
*/
getch();
return 0;
}
Archivos 07
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h> // gets() eliminado en C11, reemplazo fgets().
#include <string.h> // Se usa strcmp()
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Vector de caracteres (cadena).
* Capacidad maxima: 49 caracteres + '\0'.
*/
char str[50];
/* Apertura del archivo en modo escritura.
* Si no existe, se crea.
* Si existe se sobreescribe.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if (!(fp = fopen("arcstr.txt", "w")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nESCRITURA DEL ARCHIVO\n\n");
/* gets():
* Lee una linea desde teclado hasta presionar ENTER.
* Almacena la cadena en str.
* No controla la dimension del buffer.
* Fue eliminada en C11, por ser insegura y no controlar overflow buffer y se puede reemplazar con fgets():
* fgets(str, sizeof(str),stdin);
*/
gets(str);
/* strcmp():
* Compara dos cadenas.
* Devuelve 0 si son iguales.
* El bucle se repite mientras str sea distinta de FIN.
*/
while(strcmp(str, "FIN"))
{
/* fputs():
* Escribe una cadena en el archivo apuntado por fp.
* No agrega automaticamente salto de linea.
* Y como gets() lo elimina, el archivo se va a escribir sin saltos de linea.
*/
fputs(str, fp);
/* En C11 se elimino, se puede reemplazar con:
* fgets(str, sizeof(str), stdin);
*/
gets(str);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
/* Apertura del archivo apuntado por fp en modo lectura.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error-
*/
if (!(fp = fopen("arcstr.txt", "r")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nLECTURA DEL ARCHIVO\n\n");
/* feof():
* Devuelve verdadero cuando se alcanza el fin de archivo (EOF).
*/
while (!feof(fp))
{
/* fgets():
* Lee hasta (n - 1) caracteres del archivo.
* En este caso, como n = 5:
* - Lee hasta 4 caracteres por vez.
* - Agrega '\0' al final.
* Puede detenerse antes si encuentra '\n' o EOF
*/
fgets(str, 5, fp);
/* puts():
* Muestra la cadena en la salida estandar.
* Agrega automaticamente un salto de linea.
*/
puts(str);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
return 0;
}
Archivos 08
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h> // gets() eliminado en C11, reemplazo fgets().
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Vector de caracteres (cadena).
* Capacidad maxima 49 caracteres + '\0'.
*/
char str[50];
/* Variable entera.
* Almacena la cantidad maxima de caracteres a leer en cada llamada a fgets().
*/
int largo;
/* scanf():
* Lee un valor entero ingresado por teclado
* y lo almacena en la variable largo.
* Se pasa la direccion de memoria (&largo).
*/
scanf("%d", &largo);
/* Apertura del archivo en modo lectura.
* El archivo debe existir.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if (!(fp = fopen("arcstr.txt", "r")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nLECTURA DEL ARCHIVO\n\n");
/* Bucle de lectura hasta fin de archivo.
* En cada iteracion:
* - fgets() lee hasta (largo - 1) caracteres.
* - Agrega el caracter '\0' al final de la cadena.
* - puts() muestra la cadena en pantalla.
*/
while(!feof(fp))
{
/* fgets():
* Lee desde el archivo fp como maximo (largo - 1) caracteres.
* Se detiene si encuentra '\n' o EOF.
*/
fgets(str, largo, fp);
/* puts():
* Muestra la cadena en la salida estandar
* y agrega automaticamente un salto de linea.
*/
puts(str);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
return 0;
}
Archivos 09
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h> // gets() eliminado en C11, reemplazo fgets().
#include <string.h> // Se usa strcmp()
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Vector de caracteres (cadena).
* Capacidad maxima 49 caracteres + '\0'.
*/
char str[50];
/* Apertura del archivo en modo escritura.
* Si no existe, se crea.
* Si existe se sobreescribe.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error
*/
if (!(fp = fopen("arcstr1.txt", "w")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nESCRITURA DEL ARCHIVO\n\n");
/* gets():
* Lee una linea desde teclado hasta presionar ENTER.
* Almacena la cadena en str.
* No controla la dimension del buffer.
* Fue eliminada en C11, por ser insegura y no controlar overflow buffer y se puede reemplazar con fgets():
* fgets(str, sizeof(str),stdin);
*/
gets(str);
/* strcmp():
* Compara dos cadenas.
* Devuelve 0 si son iguales.
* El bucle se repite mientras str sea distinta de FIN.
*/
while (strcmp(str, "FIN"))
{
/* fputs():
* Escribe una cadena en el archivo apuntado por fp.
* No agrega automaticamente salto de linea.
* Y como gets() lo elimina, el archivo se va a escribir sin saltos de linea.
*/
fputs(str, fp);
/* En C11 se elimino, se puede reemplazar con:
* fgets(str, sizeof(str), stdin);
*/
gets(str);
/* fputc():
* Escribe un caracter individual en el archivo.
* Es este caso, se agrega manualmente un salto de linea
* para separar las cadenas almacenadas.
*/
fputc('\n', fp);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
/* Apertura del archivo apuntado por fp en modo lectura.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error-
*/
if (!(fp = fopen("arcstr1.txt", "r")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nLECTURA DEL ARCHIVO\n\n");
/* feof():
* Devuelve verdadero cuando se alcanza el fin de archivo (EOF).
*/
while(!feof(fp))
{
/* fgets():
* Lee hasta (n - 1) caracteres del archivo.
* En este caso, como n = 50:
* - Lee hasta 49 caracteres por vez.
* - Agrega '\0' al final.
* Puede detenerse antes si encuentra '\n' o EOF
*/
fgets(str, 50, fp);
/* puts():
* Muestra la cadena en la salida estandar.
* Agrega automaticamente un salto de linea.
*/
puts(str);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
return 0;
}
Archivos 10
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <string.h> // Se usa strcpy()
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Vector de caracteres (cadena).
* Capacidad maxima 49 caracteres + '\0'.
* Variable de tipo char inicializada con el caracter 'x'
*/
char str[50], c = 'x';
/* Variables enteras:
* i => se utiliza como contador en los bucles.
* j => se utiliza como contador independiente en la lectura.
*/
int i, j;
/* Variable de tipo float inicializada */
float f = 1.1;
/* strcpy():
* Copia la cadena constante "PRUEBA" dentro del arreglo str
*/
strcpy(str, "PRUEBA");
/* Apertura del archivo en modo escritura.
* Si no existe, se crea.
* Si existe se sobreescribe.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error
*/
if (!(fp = fopen("arch2.txt", "w")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nESCRITURA DEL ARCHIVO\n\n");
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %s indica escritura de cadena.
*/
fprintf(fp, "%s", str);
printf("%s\n", str);
for (i = 0; i < 10; i++)
{
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %d => escribe un entero en formato decimal.
*/
fprintf(fp, "%d", i);
printf("%d\n", i);
}
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %c => escribe un caracter.
*/
fprintf(fp, "%c", c);
printf("%c\n", c);
for (i = 0; i < 10; i++)
{
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %f => escribe un numero de tipo float en formato decimal.
*/
fprintf(fp, "%f", f);
printf("%f\n", f);
f *= 1.1;
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
/* Apertura del archivo apuntado por fp en modo lectura.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if(!(fp = fopen("arch2.txt", "r")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nLECTURA DEL ARCHIVO\n\n");
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %s => lee una cadena hasta espacio o salto de linea.
*/
fscanf(fp, "%s", str);
/* puts():
* Muestra la cadena en la salida estandar.
* Agrega automaticamente un salto de linea.
*/
puts(str);
printf("\n");
for (j = 0; j < 10; j++)
{
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %d => lee un entero del archivo.
* Se pasa la direccion de memoria (&i).
*/
fscanf(fp, "%d", &i);
printf("%d", i);
}
printf("\n");
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %c => lee una caracter del archivo. NO ignora espacios en blanco.
* Si hubiera un '\n' pendiente en el buffer, podria leerse como caracter.
*/
fscanf(fp, "%c", &c);
printf("%c", c);
printf("\n");
for (i = 0; i < 10; i++)
{
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %f => lee un numero de tipo float.
*/
fscanf(fp, "%f", &f);
printf("%f", f);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
/* Nota:
* No se agregan espacios ni saltos de linea entre los datos.
* La lectura funciona porque fscanf interpreta el formato
* exactamente en el mismo orden en que fueron escritos.
* Si se alterara el orden o formato, la lectura fallaria.
*/
return 0;
}
Archivos 11
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <string.h> // Se usa strcpy()
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Vector de caracteres (cadena).
* Capacidad maxima 49 caracteres + '\0'.
* Variable de tipo char inicializada con el caracter 'x'
*/
char str[50], c = 'x';
/* Variables enteras:
* i => se utiliza como contador en los bucles.
* j => se utiliza como contador independiente en la lectura.
*/
int i, j;
/* Variable de tipo float inicializada */
float f = 1.1;
/* strcpy():
* Copia la cadena constante "PRUEBA" dentro del arreglo str
*/
strcpy(str, "PRUEBA");
/* Apertura del archivo en modo escritura.
* Si no existe, se crea.
* Si existe se sobreescribe.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if(!(fp = fopen("arch2.txt", "w")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nESCRITURA DEL ARCHIVO\n\n");
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %s\n => indica escritura de cadena con separador '\n'.
*/
fprintf(fp, "%s\n", str);
printf("%s\n", str);
for(i = 0; i < 10; i++)
{
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %d => escribe un entero en formato decimal.
*/
fprintf(fp, "%d,", i);
printf("%d\n", i);
}
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %c => escribe un caracter.
*/
fprintf(fp,"%c,", c);
printf("%c\n", c);
for(i = 0; i < 10; i++)
{
/* fprintf():
* Escribe datos formateados en el archivo al que apunta fp.
* %f => escribe un numero de tipo float en formato decimal.
*/
fprintf(fp, "%f,", f);
printf("%f\n", f);
f *= 1.1;
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
/* Apertura del archivo apuntado por fp en modo lectura.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if(!(fp = fopen("arch2.txt", "r")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nLECTURA DEL ARCHIVO\n\n");
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %s => lee una cadena hasta espacio o salto de linea.
* '\n' en el formato No representa un salto literal,
* Sino que indica consumir cualquier cantidad de espacios en blanco
* (incluyendo '\n') posteriores.
*/
fscanf(fp, "%s\n", str);
/* puts():
* Muestra la cadena en la salida estandar.
* Agrega automaticamente un salto de linea.
*/
puts(str);
printf("\n");
for(j = 0; j < 10; j++)
{
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %d, => lee un entero del archivo. Se usa el separado ','.
* Se pasa la direccion de memoria (&i).
*/
fscanf(fp, "%d,", &i);
printf("%d\n", i);
}
printf("\n");
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %c, => lee una caracter del archivo. NO ignora espacios en blanco.
* Si hubiera un '\n' pendiente en el buffer, podria leerse como caracter.
* Se usa separador ','.
*/
fscanf(fp, "%c,", &c);
printf("%c", c);
printf("\n");
for(i = 0; i < 10; i++)
{
/* fscanf():
* Lee datos formateados desde el archivo al que apunta fp.
* %f, => lee un numero de tipo float. Se usa separador ','.
*/
fscanf(fp, "%f,", &f);
printf("%f\n", f);
}
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
return 0;
}
Archivos 12
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <string.h> // Se usa strcpy()
#include <stdlib.h> // Se usa exit()
/* Declaracion de estructura */
struct x
{
int i;
float f;
char c, str[10];
};
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *fp;
/* Vectores de caracteres (cadenas).
* Capacidad maxima 49 caracteres + '\0'.
* Variable de tipo char inicializada con el caracter 'x' y variable no inicializada
*/
char str[50], c = 'x', str1[50], c1;
/* Variables enteras:
* i => se utiliza como contador en los bucles.
* j => se utiliza como contador independiente en la lectura.
* Vector de tipo int de dimension 10.
*/
int i, j, k[10];
/* Variable de tipo float inicializada y vector de tipo float de dimension 10 */
float f = 1.1, g[10];
/* Variables de tipo struct x */
struct x st, st1;
/* Inicializacion de los campos de la estructura*/
st.i = 11;
st.f = 3.14159;
st.c = 'J';
/* strcpy():
* Copia la cadena constante "prueba" dentro del campo str de la estructura st.
* Copia la cadena constante "PRUEBA" dentro del vector str
*/
strcpy(st.str, "prueba");
strcpy(str, "PRUEBA");
/* Apertura del archivo apuntado por fp en modo escritura-binaria.
* w => escritura (crea el archivo o lo sobreescribe si existe).
* b => modo binario.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if(!(fp = fopen("arch.bin", "wb")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nESCRITURA DEL ARCHIVO\n\n");
/* fwrite():
* Escribe datos binarios en el archivo.
* str => direccion del bloque de memoria a escribir.
* sizeof(str) => dimension total del vector (50 bytes).
* 1 => cantidad de bloques a escribir.
* fp => puntero a FILE.
*/
fwrite(str, sizeof(str), 1, fp);
/* Muestra el vector str*/
printf("%s\n", str);
for(i = 0; i < 10; i++)
{
/* fwrite():
* Escribe datos binarios en el archivo.
* &i => direccion de la variable i.
* sizeof(i) => dimension de un entero en bytes.
* 1 => se escribe un elemento por iteracion.
* fp => puntero a FILE.
*/
fwrite(&i, sizeof(i), 1, fp);
printf("%d\n", i); // Muestra la iteracion
}
/* fwrite():
* Escribe datos binarios en el archivo.
* &c => direccion del caracter.
* sizeof(char) => dimension de un byte.
* 1 => cantidad de elementos.
* fp => puntero a FILE.
*/
fwrite(&c, sizeof(char), 1, fp);
printf("%c\n", c); // Muestra el caracter con salto de linea
for(i = 0; i < 10; i++)
{
/* fwrite():
* Escribe datos binarios en el archivo.
* &f => direccion de la variable f.
* sizeof(float) => dimension de un float en bytes.
* 1 => se escribe un elemento por iteracion.
* fp => puntero a FILE.
*/
fwrite(&f, sizeof(float), 1, fp);
printf("%f\n", f); // Muestra el valor de f
f *= 1.1; // Reasigna el valor de f
}
/* fwrite():
* Escribe datos binarios en el archivo.
* &st => direccion de la estructura.
* sizeof(struct x) => dimension total de la estructura en memoria.
* 1 => se escribe una estructura completa como bloque binario.
* fp => puntero a FILE.
*/
fwrite(&st, sizeof(struct x), 1, fp);
/* Muestra todos los campos de la estructura st */
printf("\n%c, %d, %f, %s\n", st.c, st.i, st.f, st.str);
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
/* Apertura del archivo apuntado por fp en modo lectura-binaria.
* r => lectura (el archivo debe existir).
* b => modo binario.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if(!(fp = fopen("arch.bin", "rb")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\nLECTURA DEL ARCHIVO\n\n");
/* fread():
* str1 => direccion donde se almacenan los datos leidos.
* sizeof(str1) => dimension total del vector (50 bytes).
* 1 => cantidad de bloques a leer.
* fp => puntero a FILE.
*/
fread(str1, sizeof(str1), 1, fp);
/* puts():
* Muestra la cadena en la salida estandar.
* Agrega automaticamente un salto de linea.
*/
puts(str1);
printf("\n");
/* fread():
* k => vector donde se almacenan los enteros.
* sizeof(int) => dimension de cada entero.
* 10 => cantidad de elementos a leer.
* fp => puntero a FILE.
*/
fread(k, sizeof(int), 10, fp);
/* Recorre el vector k */
for(j = 0; j < 10; j++)
printf("%d\n", k[j]); // Muestra cada elemento
printf("\n");
/* fread():
* c1 => direccion donde se almacena el caracter.
* sizeof(char) => dimension de un byte.
* 1 => cantidad de elementos.
* fp => puntero a FILE.
*/
fread(&c1, sizeof(char), 1, fp);
printf("%c", c1); // Muestra el caracter leido, no hay salto de linea automatico
printf("\n"); // Salto de linea manual
/* fread():
* g => vector donde se almacenan los floats.
* sizeof(float) => dimension de cada float.
* 10 => cantidad de elementos a leer.
* fp => puntero a FILE.
*/
fread(g, sizeof(float), 10, fp);
/* Recorre el vector g */
for(i = 0; i < 10; i++)
printf("%f\n", g[i]); // Muestra cada elemento
/* fread():
* &st1 => direccion donde se almacena la estructura leida.
* sizeof(struct x) => dimension total de la estructura.
* 1 => se lee una estructura completa.
* fp => puntero a FILE.
*/
fread(&st1, sizeof(struct x), 1, fp);
/* Muestra todos los campos de la estructura st1 */
printf("\n%c, %d, %f, %s\n", st1.c, st1.i, st1.f, st1.str);
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(fp);
/* Nota:
* En archivos binarios los datos se almacenan en su representacion
* interna en memoria, no en formato legible.
* Por eso se utilizan fwrite() y fread().
*/
return 0;
}
Archivos 13
Makefile
CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -pedantic
PROG = main
OBJ = main.o
$(PROG): $(OBJ)
$(CC) $(OBJ) -o $(PROG)
$(OBJ): main.c
$(CC) $(CFLAGS) -c main.c
.PHONY: clean
clean:
del $(OBJ) $(PROG).exe
Código:
// gcc -std=c11 -Wall -Wextra -pedantic main.c -o main
#include <stdio.h>
#include <stdlib.h> // Se usa exit()
int main(void)
{
/* Declaracion de un puntero a FILE.
* Almacena la direccion del flujo asociado al archivo.
*/
FILE *in;
/* Variable de tipo char.
* Se utiliza para almacenar cada caracter leido del archivo.
* Variable de tipo long.
* Se utiiza para mostrar la posicion del indicador del archivo.
*/
char c;
long l;
/* Apertura del archivo apuntado por 'in' en modo lectura.
* Se realiza la asignacion dentro de la condicion.
* Si fopen devuelve NULL, la expresion es verdadera y se ejecuta el bloque de error.
*/
if(!(in = fopen("Archiv01.c", "r")))
{
printf("\n\nError de apertura\n\n");
exit(1);
}
printf("\n\n");
/* ftell():
* Devuelve la posicion actual del indicador de archivo medida en bytes desde el inicio.
* in => puntero a FILE.
*/
l = ftell(in);
/* Muestra la posicion actual (inicio = 0) */
printf("%ld", l);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 0 => desplazamiento
* SEEK_END => referencia desde el final del archivo.
*
* Coloca el puntero al final del archivo.
*/
fseek(in, 0, SEEK_END);
printf("\n\n");
/* ftell():
* Devuelve la posicion actual del indicador de archivo medida en bytes desde el inicio.
* in => puntero a FILE.
*/
l = ftell(in);
/* Muestra la posicion actual */
printf("%ld", l);
/* rewind():
* Reposiciona el puntero al inicio del archivo.
* Equivale a fseek(in, 0, SEEK_SET).
*/
rewind(in);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 200 => se desplaza 200 bytes
* SEEK_SET => desde el inicio del archivo.
*
* Coloca el puntero en el byte 200 desde el inicio del archivo.
*/
fseek(in, 200, SEEK_SET);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 220 => se desplaza 220 bytes
* SEEK_SET => desde el inicio del archivo.
*
* Coloca el puntero en el byte 220 desde el inicio del archivo.
*/
fseek(in, 220, SEEK_SET);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 1 => avanza 1 byte
* SEEK_CUR => desde la posicion actual.
*/
fseek(in, 1, SEEK_CUR);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 0 => no se mueve
* SEEK_CUR => mantiene la posicion actual.
*/
fseek(in, 0, SEEK_CUR);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 0 => no se mueve
* SEEK_CUR => mantiene la posicion actual.
*
* No modifica la posicion actual del puntero.
*/
fseek(in, 0, SEEK_CUR);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* -1 => retrocede 1 byte
* SEEK_CUR => desde la posicion actual.
*/
fseek(in, -1, SEEK_CUR);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 200 => se desplaza 200 bytes
* SEEK_SET => desde el inicio del archivo.
*
* Coloca el puntero en el byte 200 desde el inicio del archivo.
*/
fseek(in, 200, SEEK_SET);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* 200 => se desplaza 200 bytes
* SEEK_SET => desde el inicio del archivo.
*
* Coloca el puntero en el byte 200 desde el inicio del archivo.
*/
fseek(in, 200, SEEK_SET);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* fseek():
* Desplaza el indicador de posicion del archivo.
* in => puntero a FILE.
* -150 => retrocede 150 bytes
* SEEK_END => desde el final del archivo.
*
* Coloca el puntero 150 bytes antes del final del archivo.
*/
fseek(in, -150, SEEK_END);
/* fgetc():
* Lee un caracter del archivo en la posicion actual
* y avanza el puntero automaticamente una posicion.
*/
c = fgetc(in);
/* Muestra el caracter leido */
printf("\n%c", c);
/* Cierre del archivo.
* Libera los recursos asociados al flujo.
*/
fclose(in);
return 0;
}