Manejo de archivos en lenguaje C

 C Programming >> Programación C >  >> Tags >> File
Manejo de archivos en lenguaje C

Manejo de archivos en lenguaje C con ejemplos

En este artículo, voy a hablar sobre el manejo de archivos en lenguaje C con ejemplos Lea nuestro artículo anterior donde discutimos Gestión dinámica de memoria en C . Como parte de este artículo, vamos a discutir los siguientes puntos en detalle que están relacionados con el manejo de archivos en el programa C.

  1. ¿Qué es un archivo?
  2. ¿Por qué se necesitan los archivos?
  3. Tipos de archivos
  4. Modos de archivo
  5. Operaciones de archivos en C
  6. Programa:para leer datos de archivos
  7. Programa:para leer una línea de un archivo y mostrarla
  8. Programa:para invertir la cadena de datos presente en un archivo
  9. Programa:Buscar y actualizar (o reemplazar) un carácter
  10. Programa:Codificación y decodificación
  11. Programa:Operaciones en archivos de audio
  12. Programa:combina dos o más archivos de audio
¿Qué es un archivo?

Un archivo es el nombre de una ubicación de memoria física en el área de almacenamiento secundario. El archivo contiene una secuencia de bytes de datos en el área de almacenamiento secundario en forma no estructurada. En la implementación, cuando se nos pidió que interactuáramos con el área de almacenamiento secundario, se recomendó realizar operaciones de archivos. Mediante el uso de archivos, los datos relacionados con la memoria principal se pueden enviar al área de almacenamiento secundario y la información del área de almacenamiento secundario se puede cargar en la memoria principal. En el lenguaje de programación 'C', las operaciones IO se clasifican en dos tipos:

  1. Operaciones de E/S estándar
  2. Operaciones de E/S secundarias

Cuando interactuamos con dispositivos de E/S secundarios, se denomina operaciones de E/S secundarias. Relacionadas con E/S estándar y relacionadas con E/S secundarias, todas las funciones predefinidas se declaran solo en stdio.h.

¿Por qué se necesitan los archivos?

Todos los datos se pierden cuando se termina un programa. Almacenar los datos en un archivo preservará sus datos una vez que finalice el programa. Tomará mucho tiempo ingresar una gran cantidad de datos. Sin embargo, si tiene un archivo que contiene toda la información, accederá fácilmente al contenido del archivo usando algunos comandos en C. Sin cambios previos, puede mover fácilmente sus datos de una computadora a otra.

Tipos de archivos

Al manejar archivos, hay dos tipos de archivos que debe conocer:

  1. Archivos de texto
  2. Archivos binarios
Archivos de texto

Los archivos de texto son los archivos .txt normales. Puede crear fácilmente archivos de texto utilizando cualquier editor de texto simple como el Bloc de notas. Cuando abra esos archivos, verá todo el contenido dentro del archivo como texto sin formato. Puede editar o eliminar fácilmente los contenidos. Requieren el mínimo esfuerzo para que sean fáciles de leer, brindan la menor cantidad de seguridad y ocupan más espacio para almacenar. En los archivos de texto, los datos se representan con la ayuda de valores ASCII, es decir, .txt, .c, .cpp

Archivos binarios

Los archivos binarios son principalmente los archivos .bin en su computadora. En lugar de almacenar datos en texto sin formato, los almacenan en forma binaria (0 y 1). Pueden contener una mejor cantidad de conocimiento, no son fáciles de leer y brindan una mejor seguridad que los archivos de texto. En los archivos binarios, los datos se representan con la ayuda de bytes, es decir, .exe, .mp3, .mp4, .jpeg

Puntos para recordar:
  1. Para especificar que un archivo determinado se está abriendo o creando en "modo de texto", agregue "t" al modo de cadena. Ejemplos:rt, wt, at, rt+, wt+, at+
  2. Para especificar el modo binario, agregue "b" al final del modo de cadena. Ejemplo:RB. Wb, ab, r+b, w+b, a+b
  3. “fopen” y “fsopen” también permiten que se inserte “t” o “b” entre la letra y el carácter 't' en la cadena. Ejemplo:rt+ es equivalente a r+t.
  4. Si "t" o "b" no aparecen en la cadena, el modo se rige por el modo "f", si el modo "f" se establece en O_BINARY, los archivos se abren en modo BINARY.
  5. Si el modo "f" se establece en O_TEXT, se abren en modo de texto. Estas constantes se definen en fcntl.h
Operaciones de archivos

En C, realizará cuatro operaciones principales en archivos, ya sean de texto o binarios:

  1. Crear un archivo nuevo
  2. Abrir un archivo existente
  3. Cerrar un archivo
  4. Leer de un archivo y escribir información en un archivo
Ejemplo:
#include<stdio.h>
#include<dos.h>
#include<stdlib.h>
int main()
{
    FILE* fp;
    fp = fopen("F:\.txt","w");
    if(fp == NULL)
    {
       printf("\n Unable to create File");
       return EXIT_FAILURE;
    }
    fprintf(fp,"Welcome");
    fprintf(fp,"\n%d HELLO WORLD %f", 100, 12.50);
    fclose(fp);
    return EXIT_SUCCESS;
}
Salida:

Puntos para recordar:
  1. Cuando estamos abriendo un archivo, se deben pasar dos parámetros:Ruta y Modo
  2. El archivo puede abrirse o no abrirse. Si está abierto, devuelve DIRECCIÓN. Si no, devuelve NULL.
  3. stdio.h proporciona el prototipo de función predefinida relacionada con IO estándar.
  4. conio.h proporciona el prototipo de función predefinida relacionada con la consola.
  5. FILE es una estructura predefinida que está disponible en stdio.h. Al usar la estructura FILE, podemos manejar las propiedades del archivo. El tamaño de la estructura del ARCHIVO es de 16 bytes.
  6. fp es una variable de tipo FILE*, que mantiene la dirección de FILE. El tamaño de fp es de 2 bytes porque contiene una dirección.
fopen()

Es una función predefinida, que se declara en stdio.h, al usar esta función podemos abrir un archivo en una ruta específica con un modo específico. Requiere dos argumentos de tipo const char*. En caso de éxito, fopen() devuelve ARCHIVO*, en caso de error devuelve NULL. Generalmente, fopen() no puede abrir el ARCHIVO en los siguientes casos:

  1. La ruta es incorrecta.
  2. El modo es incorrecto
  3. Los permisos no están disponibles
  4. La memoria no está disponible

Sintaxis:ARCHIVO *fopen(const char* ruta, const char* modo);

fprintf()

Usando esta función predefinida, podemos escribir el contenido en el archivo. fprintf() puede tomar cualquier cantidad de argumentos, pero el primer argumento debe ser ARCHIVO* y los argumentos restantes son de cualquier ruta.

Sintaxis:int fprintf(FILE* flujo, const char*ruta,…..);

fcerrar()

Usando esta función predefinida, podemos cerrar el archivo después de guardar los datos. fclose() requiere un argumento de tipo ARCHIVO* y devuelve un valor int.

Sintaxis:int fclose(FILE* stream);

Modos de archivo

Los modos Siempre ARCHIVO indicarán con qué propósito se debe abrir o crear el archivo. Los modos de archivo se clasifican en tres tipos:

  1. Escribir
  2. Leer
  3. Anexar

Dependiendo de las operaciones, los modos de archivo se clasifican en 6 tipos:

  1. Escribir (w): Cree un archivo para escribir, si el archivo ya existe, se anulará (el archivo anterior se elimina y se crea un nuevo archivo). En el modo "w", ya sea que el archivo exista o no, siempre se construye un nuevo archivo.
  2. Lectura(r): Abra un archivo existente para leer, si el archivo no existe, entonces fopen() devuelve NULL. Cuando estamos trabajando con el modo "r", si el archivo no existe, no se construye un nuevo archivo.
  3. Agregar(a): Abra un archivo existente para agregar (escriba los datos al final del archivo) o cree un nuevo archivo para escribir si no existe. Cuando estamos trabajando con "a", si el archivo no existe, solo se construye un nuevo archivo.
  4. w+ (escribir y leer): Cree un archivo para la actualización, es decir, escriba y lea si el archivo ya existe, entonces se anulará. En modo w+, si el archivo está disponible o no, siempre se construye un nuevo archivo.
  5. r+ (leer y escribir): Abra un archivo existente para la actualización, es decir. Lee y escribe. Generalmente, se requiere el modo “r+”, cuando necesitamos actualizar la información existente. En modo “r+”, si el archivo no existe, no se construye un nuevo archivo.
  6. a+ (w+ y r+): Abra un archivo existente para actualizar o cree un nuevo archivo para actualizar. Al usar el modo a+, podemos realizar operaciones aleatorias.
Programa para leer datos de archivos usando lenguaje C
#include<stdio.h>
#include<stdlib.h>
int main()
{
    FILE* fp;
    char ch;
    fp = fopen("F:\.txt","r");
    if(fp == NULL)
    {
       printf("\n File not Found");
       return EXIT_FAILURE;
    }
    while(1)
    {
       fscanf(fp,"%c",&ch);
       if(feof(fp))	//if(ch == EOF)
          break;
       printf("%c",ch);
    }
    fclose(fp);
    return EXIT_SUCCESS;
}
Salida:

fscanf()

Es una función predefinida que se declara en stdio.h, al usar esta función, podemos leer los datos de un archivo. fscanf() puede tomar cualquier cantidad de argumentos, pero el primer argumento debe tener el formato de función scanf() y los argumentos restantes deben tener el formato de función. Cuando estamos trabajando con la función fscanf(), puede leer todo el contenido del archivo excepto.

Sintaxis:int fscanf(FILE* stream, const char” formato,…..);

feof()

Usando esta función, podemos encontrar el final de la posición del carácter. Requiere un argumento de tipo ARCHIVO* y devuelve un valor int. Cuando el puntero del archivo apunta al carácter EOF, devuelve un valor distinto de cero; si apunta a un carácter diferente al EOF, devuelve cero.

Sintaxis:int feof(FILE* stream);

fgetc()

Es una función sin formato predefinida que se declara en stdio.h, al usar esta función podemos leer los datos de un archivo que también incluye caracteres EOF. Devuelve un valor int, es decir, el valor ASCII de un carácter.

Sintaxis:int getc(FILE* stream);

Programa para leer una línea de un archivo y mostrarla usando lenguaje C
#include <stdio.h>
#include <stdlib.h> // For exit() function
int main() {
    char c[1000];
    FILE *fptr;
    if ((fptr = fopen("F:\.txt", "r")) == NULL) {
        printf("Error! opening file");
        // Program exits if file pointer returns NULL.
        exit(1);
    }

    // reads text until newline is encountered
    fscanf(fptr, "%[^\n]", c);
    printf("Data from the file:\n%s", c);
    fclose(fptr);

    return 0;
}
Salida

Ejemplo para comprender el manejo de archivos en lenguaje C:
#include<stdio.h>
#include<conio.h>
int main()
{
    FILE* fp;
    char path[50];
    char str[50];

    fprintf(stdout, "Enter a file path : ");
    gets(path);
    fp = fopen(path,”a");
    if(fp == NULL)
    {
       fprintf(stderr, "Unable o create file");
       getch();
       return 1;
    }
    printf("Enter a String : ");
    fflush(stdin);
    gets(str);
    fputs(str, fp);
    fclose(fp);
    return 0;
}
Salida

1.txt

Retraso en el manejo de archivos

Es una función predefinida que se declara en dos.h. Al usar esta función, podemos suspender la ejecución del programa. La función delay() requiere un argumento de tipo entero sin signo, es decir, valor en milisegundos. Usando delay(), podemos suspender el programa por un mínimo de 1 segundo y un máximo de 5 segundos.

Sintaxis:demora nula (milisegundos sin signo);

dormir()

Es una función predefinida que se declara en dos.h. Mediante el uso de esta función, podemos suspender la ejecución del programa. La función sleep() requiere un argumento de tipo de datos de formato de segundos enteros sin signo.

Sintaxis:void sleep(segundos sin firmar);

salida estándar: Es una variable de puntero global que se define en stdio.h. Al usar este puntero global, podemos manejar el búfer de salida estándar.

stdin: Al usar este puntero global, podemos manejar el búfer de entrada estándar.

stderr :Al usar este puntero global, podemos manejar errores estándar relacionados con IO. Cuando estamos trabajando con stderr, redirigirá los datos a stdout.

stdprn :Usando este puntero global, podemos manejar la impresora.

fseek()

Usando esta función predefinida, podemos crear el movimiento en el puntero del archivo. fseek() requiere tres argumentos de tipo ARCHIVO*, entero largo y un tipo entero.

Sintaxis:int fseek(FILE* flujo, desplazamiento largo, int de dónde);

Donde el flujo proporcionará información del archivo, Offset es el número de bytes y el valor es la ubicación del puntero del archivo. El valor de donde se puede reconocer usando los siguientes valores constantes:

  1. BUSCAR_SET: Esta constante pasará el puntero del archivo al principio del archivo.
  2. BUSCAR_CUR: Esta constante proporcionará la posición constante del puntero del archivo.
  3. BUSCAR_END:​​ Este valor constante enviará el puntero del archivo al final del archivo.

Estos valores constantes también se pueden reconocer utilizando valores INTEGER.

  1. El valor de SEEK_SET es 0.
  2. El valor de SEEK_CUR es 1.
  3. El valor de SEEK_END es 2.
rebobinar()

Usando esta función predefinida, podemos enviar el control al principio del archivo. rewind() requiere un argumento de tipo FILE*.

Sintaxis:void rebobinar(FILE* stream);

El comportamiento de rewind() es similar a:fseek(FILE*, O, SEEK_SET)

ftell()

Usando esta función predefinida, podemos encontrar el tamaño del archivo. ftell() requiere un argumento de tipo ARCHIVO* y devuelve un valor entero largo. Generalmente, ftell() devuelve la posición del puntero del archivo, por lo que si el puntero del archivo apunta al final del carácter, entonces es igual al tamaño del archivo.

Sintaxis:long ftell(FILE* stream);

eliminar()

Usando esta función predefinida, podemos eliminar dos archivos permanentemente del disco duro. remove() requiere un argumento de tipo constante char* y devuelve un valor int.

Sintaxis:int remove(const char* filename);

renombrar()

Usando esta función predefinida, podemos cambiar el nombre de un archivo existente. La función rename() requiere dos tipos de argumentos de tipo const char y devuelve un valor int.

Sintaxis:int rename(const char* nombre antiguo, const char* nombre nuevo);

Programa para revertir la cadena de datos presente en un archivo usando lenguaje C
#include<stdio.h>
#include<string.h>
#include<malloc.h>
int main()
{
    FILE *fp;
    char path[50];
    long int fsize, i = 0;
    char *str;
    char ch;
    printf ("Enter a file path :");
    gets (path);
    fp = fopen (path, "rt");
    if (fp == NULL)
    {
        printf ("\n File not found");
        return 1;
    }
    fseek (fp, 0, SEEK_END);
    fsize = ftell (fp);
    fseek (fp, 0, SEEK_SET);
    str = (char *) calloc (fsize, sizeof (char));
    while (1)
    {
        ch = fgetc (fp);
        if (feof (fp))
         break;
        str[i++] = ch;
    }
    str[i] = '\o';
    fclose (fp);
    remove (path);
    strrev (str);
    fp = fopen (path, "wt");
    fputs (str, fp);
    fclose (fp);
    free (str);
    str = NULL;
    return 0;
}
Salida

1.txt

Programa para buscar y actualizar (o reemplazar) un carácter en un archivo usando lenguaje C
#include<stdio.h>
#include<stdlib.h>
int main()
{
    FILE *fp;
    char path[50];
    char ch, sch, dch;
    printf ("Enter a file path : ");
    gets (path);
    fp = fopen (path, "rt+");
    if (fp == NULL)
    {
        printf ("File not found");
        return 1;
    }
    printf ("\n Enter a source character(s) : ");
    fflush (stdin);
    sch = getchar ();
    printf ("\n Enter a destination character(D) : ");
    fflush (stdin);
    dch = getchar ();
    while (1)
    {
        ch = fgetc (fp);
        if (ch == EOF)
         break;
        if (ch == sch)
        {
            fseek (fp, -1, SEEK_CUR);
            fprintf (fp, "%c", dch);
            fseek (fp, 0, SEEK_CUR);
        }
    }
    fclose (fp);
    return 0;
}
Salida

2.txt

Programa de Codificación y Decodificación en Lenguaje C
#include<stdio.h>
#include<conio.h>
int main()
{
    FILE *fp;
    int flag, code = 0;
    char path[30];
    char ch;
    printf ("Enter a file path : ");
    gets (path);
    fp = fopen (path, "r+");
    
    if (fp == NULL)
    {
        printf ("\n File not found");
        getch ();
        return 1;
    }
    
    do
    {
        printf ("\n 1 for ENCODE : ");
        printf ("\n 2 for DECODE : ");
        scanf ("%d", &flag);
    }
    while (flag != 1 && flag != 2);
    
    if (flag == 1)
        code = 40;
    else
        code = -40;
        
    while (1)
    {
        ch = fgetc (fp);
        if (ch == EOF)
         break;
        if(ch != '\n' && ch != '\r')
        {
         fseek (fp, -1, SEEK_CUR);
         fprintf (fp, "%c", ch + code);
         fseek (fp, 0, SEEK_CUR);
        }
    }
    fclose (fp);
    return 0;
}
Salida

2.txt (después de Codificar)

2.txt (después de decodificar)

Programa para Operaciones en Archivos de Audio usando Lenguaje C
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define f1 "F:\\part1.mp3"
#define f2 "F:\\part2.mp3"
#define f3 "F:\\part3.mp3"
#define f4 "F:\\part4.mp3"
int main(void)
{
    FILE *sfp;
    FILE *dfp;
    char spath[30];
    char dpath[4][30] = { f1, f2, f3, f4 };
    long int fsize = 0, nb = 0;	// nb is number of bytes
    int i = 0;
    char ch;
    printf ("\n Enter sfp path : ");
    gets (spath);
    if (sfp == NULL)
    {
        printf ("\n %s NOT FOUND", spath);
        return EXIT_FAILURE;
    }
    fseek (sfp, 0, SEEK_END);
    fsize = ftell (sfp);
    rewind (sfp);
    dfp = fopen (dpath[i], "wb");
    
    if (dfp == NULL)
    {
        fclose (sfp);
        printf ("\n%s Unable to create");
        return EXIT_FAILURE;
    }
    
    while (1)
    {
        ch = fgetc (sfp);
        if (feof (sfp))
         break;
        fprintf (dfp, "%c", ch);
        ++nb;
        if (nb = fsize / 4 && i != 3)
        {
            fclose (dfp);
            nb = 0;
            ++i;
            dfp = fopen (dpath[i], "wb");
            if (dfp == NULL)
            {
                printf ("\n %s Unable to create", dpath[i]);
                fclose (sfp);
                return EXIT_FAILURE;
            }
        }
    }
    fclose (sfp);
    fclose (dfp);
    return EXIT_SUCCESS;
}
Salida

Programa para combinar dos o más archivos de audio usando lenguaje C
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define f1 "F:\\part1.mp3"
#define f2 "F:\\part2.mp3"
#define f3 "F:\\part3.mp3"
#define f4 "F:\\part4.mp3"
int main(void)
{
    FILE *sfp;
    FILE *dfp;
    char dpath[30];
    char spath[4][30] = { f1, f2, f3, f4 };
    int i = 0;
    char ch;
    printf ("\n enter dfp path : ");
    gets (dpath);
    dfp = fopen (dpath, "wb");
    if (dfp == NULL)
    {
        printf ("\n%sUnable to create", dpath);
        return EXIT_SUCCESS;
    }
    
    for (i = 0; i < 4; i++)
    {
        sfp = fopen (spath[i], "rb");
        if (sfp == NULL)
        {
            fclose (dfp);
            printf ("\n%s Not Found", spath[i]);
            return EXIT_FAILURE;
        }
     
        while (1)
        {
            ch = fgetc (sfp);
            if (feof (sfp))
               break;
            fprintf (dfp, "%c", ch);
        }
        fclose (sfp);
    }
    fclose (dfp);
    return EXIT_SUCCESS;
}
Salida

En el próximo artículo, voy a hablar sobre el manejo de errores en programas C con ejemplos. Aquí, en este artículo, trato de explicar Manejo de archivos en lenguaje C con ejemplos. Espero que disfrute de este artículo Manejo de archivos en lenguaje C. Me gustaría tener sus comentarios. Publique sus comentarios, preguntas o comentarios sobre este artículo Manejo de archivos en lenguaje C con ejemplos.