Modos de apertura en E/S estándar en C/C++ con ejemplos

Requisitos previos: manejo de archivos en C++

Hasta ahora, las operaciones que utilizan el programa C se realizan en un indicador/terminal que no está almacenado en ninguna parte. Pero en la industria del software, la mayoría de los programas están escritos para almacenar la información obtenida del programa. Una de esas formas es almacenar la información obtenida en un archivo. Las diferentes operaciones que se pueden realizar sobre un archivo son:  

1. Creación de un nuevo archivo (abierto con atributos como “a” o “a+” o “w” o “w++”).
2. Abriendo un archivo existente (fopen).
3. Lectura desde archivo (fscanf o fgets).
4. Escribir en un archivo (fprintf o fputs).
5. Mover a una ubicación específica en un archivo (fseek, rebobinar).
6. Cerrar un archivo (fclose).

El texto entre paréntesis indica las funciones utilizadas para realizar esas operaciones.

¿Por qué se necesitan archivos?

• Preservación de datos: el almacenamiento de datos en archivos ayuda a preservar los datos incluso si el programa finaliza.
• Fácil acceso a los datos: el acceso a los datos se vuelve fácil cuando hay una gran cantidad de datos y están almacenados en el archivo, luego se puede acceder a estos datos usando los comandos C.
• Portabilidad: se vuelve más fácil mover datos de una computadora a otra sin ningún cambio.

tipos de archivos

Son dos tipos de archivos que todo el mundo debería conocer:

1. Archivos de texto: Los archivos de texto son los archivos normales que tienen una extensión “.txt” en el nombre del archivo. Estos se pueden crear simplemente usando editores como el Bloc de notas. Al abrir los archivos, el texto será visible como texto sin formato simple y el contenido se puede editar o eliminar fácilmente. Estos son los archivos de mantenimiento más bajos, fáciles de leer. Pero hay algunas desventajas de los archivos de texto, como que son los archivos menos seguros y ocupan más espacio de almacenamiento.
2. Archivos binarios: Los archivos binarios son archivos con extensión “.bin”. Los datos en estos archivos se almacenan en forma binaria, es decir, 0 y 1. Estos archivos pueden contener una gran cantidad de datos y brindar un mayor nivel de seguridad que los archivos de texto, pero estos archivos no son fáciles de leer.

Operaciones de archivos

Hay cuatro operaciones básicas que se pueden realizar en un archivo:

1. Creando un nuevo archivo.
2. Abriendo un archivo existente.
3. Leer o escribir información en el archivo.
4. Cerrando el archivo.

Trabajar con archivos

Al trabajar con los archivos, es necesario declarar un puntero del tipo archivo. Este puntero de tipo de archivo es necesario para la comunicación entre el archivo y el programa.

Archivo *fptr;

Abriendo un archivo

La apertura de un archivo se realiza mediante la función fopen() en el archivo de encabezado stdio.h.

Sintaxis:

fptr = fopen(“nombre_archivo”, “modo”);

Ejemplo:

fopen(“D:\\geeksforgeeks\\nuevoprogramagfg.txt”, “w”);
fopen(“D:\\geeksforgeeks\\oldprogramgfg.bin”, “rb”);

• Supongamos que el archivo newprogramgfg.txt no existe en la ubicación D:\geeksforgeeks. La primera función crea un nuevo archivo llamado newprogramgfg.txt y lo abre para escribir según el modo ‘w’. El modo de escritura le permite crear y editar (sobrescribir) el contenido del archivo.
• Suponga que el segundo archivo binario oldprogramgfg.bin existe en la ubicación D:\geeksforgeeks. La segunda función abre el archivo existente para lectura en modo binario ‘rb’. El modo de lectura solo permite leer el archivo, no se puede escribir en el archivo.

Modos de apertura de archivos en C: 

Cerrar un archivo

El archivo debe cerrarse después de leer o escribir. El cierre de un archivo se realiza mediante la función fclose().

Sintaxis:

fclose(ftr);

Aquí, fptr es el puntero de tipo de archivo asociado con el archivo que se cerrará.

Leer y escribir en un archivo de texto

Para leer y escribir en un archivo de texto, se utilizan las funciones fprintf() y fscanf(). Son las versiones de archivo de las funciones printf() y scanf(). La única diferencia es que fprintf() y fscanf() esperan el puntero al archivo de estructura.

Escribir en un archivo de texto:

Sintaxis:

ARCHIVO *filePointer;
filePointer = fopen(“nombre de archivo.txt”, “w”)

A continuación se muestra el programa C para escribir en un archivo de texto.

// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
  
// Driver code
int main()
{
    // Declare the file pointer
    FILE* filePointer;
  
    // Get the data to be written in file
    char dataToBeWritten[50]
        = "GeeksforGeeks-A Computer"
          + " Science Portal for Geeks";
  
    // Open the existing file GfgTest.c using fopen()
    // in write mode using "w" attribute
    filePointer = fopen("GfgTest.txt", "w");
  
    // Check if this filePointer is null
    // which maybe if the file does not exist
    if (filePointer == NULL) {
        printf("GfgTest.txt file failed to open.");
    }
    else {
        printf("The file is now opened.\n");
  
        // Write the dataToBeWritten into the file
        if (strlen(dataToBeWritten) > 0) {
            // writing in the file using fputs()
            fprintf(filePointer, dataToBeWritten);
            fprintf(filePointer, "\n");
        }
  
        // Closing the file using fclose()
        fclose(filePointer);
  
        printf("Data successfully written"
               + " in file GfgTest.txt\n");
        printf("The file is now closed.");
    }
    return 0;
}

Producción:

Leer de un archivo:

Sintaxis:

ARCHIVO * puntero de archivo;

filePointer = fopen(“fileName.txt”, “r”);

A continuación se muestra el programa C para leer el archivo de texto.

// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
  
// Driver code
int main()
{
    // Declare the file pointer
    FILE* filePointer;
  
    // Declare the variable for the data
    // to be read from file
    char dataToBeRead[50];
  
    // Open the existing file GfgTest.txt
    // using fopen() in read mode using
    // "r" attribute
    filePointer = fopen("GfgTest.txt", "r");
  
    // Check if this filePointer is null
    // which maybe if the file does not exist
    if (filePointer == NULL) {
        printf("GfgTest.txt file failed to open.");
    }
    else {
        printf("The file is now opened.\n");
  
        // Read the dataToBeRead from the file
        // using fgets() method
        while (fgets(dataToBeRead, 50,
                     filePointer)
               != NULL) {
            // Print the dataToBeRead
            printf("%s", dataToBeRead);
        }
  
        // Closing the file using fclose()
        fclose(filePointer);
  
        printf("Data successfully read"
               + " from file GfgTest.txt\n");
        printf("The file is now closed.");
    }
    return 0;
}

Producción:

Leer y escribir en archivo binario

Escribe un archivo binario:

Sintaxis:

ARCHIVO *filePointer;
filePointer = fopen(“fileName.bin”, “wb”);

Para escribir datos en un archivo binario, se necesita la función fwrite(). Esta función toma cuatro argumentos:

1. Dirección de datos a escribir en el disco.
2. Tamaño de los datos que se escribirán en el disco.
3. El número de tales tipos de datos.
4. Puntero al archivo donde desea escribir.

Sintaxis:

fwrite (datos de dirección, tamaño de datos, datos de números, puntero a archivo);

A continuación se muestra el programa C para implementar el enfoque anterior:

// C program to implement
// the above approach
#include <stdio.h>
#include <stdlib.h>
  
struct threeNum {
    int n1, n2, n3;
};
  
// Driver code
int main()
{
    int n;
    struct threeNum num;
  
    // Declaring the file pointer
    FILE* fptr;
  
    if ((fptr = fopen("C:\\GfgTest.bin",
                      "wb"))
        == NULL) {
        printf("Error! opening file");
  
        // Program exits if the file pointer
        // returns NULL.
        exit(1);
    }
  
    for (n = 1; n < 5; ++n) {
        num.n1 = n;
        num.n2 = 5 * n;
        num.n3 = 5 * n + 1;
        fwrite(&num, sizeof(struct threeNum),
               1, fptr);
    }
  
    printf("The file GfgTest.bin is"
           + " written successfully");
    fclose(fptr);
    return 0;
}

Leer de un archivo binario:

Sintaxis:

ARCHIVO * puntero de archivo;
filePointer = fopen(“fileName.txt”, “rb”);

Para leer datos de un archivo binario, se usa la función fread(0. Similar a la función fwrite(), esta función también toma cuatro argumentos.

Sintaxis:

fread(datosDirección, tamañoDeDatos, datosNúmeros, punteroAlArchivo);

A continuación se muestra el programa C para implementar el enfoque anterior:

// C program to implement
// the above approach
#include <stdio.h>
#include <stdlib.h>
  
struct threeNum {
    int n1, n2, n3;
};
  
// Driver code
int main()
{
    int n;
    struct threeNum num;
  
    // Declaring the file pointer
    FILE* fptr;
  
    if ((fptr = fopen("C:\\GfgTest.bin",
                      "rb"))
        == NULL) {
        printf("Error! opening file");
  
        // Program exits if the file pointer
        // returns NULL.
        exit(1);
    }
  
    for (n = 1; n < 5; ++n) {
        fread(&num, sizeof(struct threeNum),
              1, fptr);
        printf("n1: %d\tn2: %d\tn3: %d",
               num.n1, num.n2, num.n3);
        printf("\n");
    }
    fclose(fptr);
  
    return 0;
}

Producción:

Agregar contenido en un archivo de texto

Sintaxis:

ARCHIVO * puntero de archivo;
filePointer = fopen(“fileName.txt”, “a”);

Una vez que el archivo se abre en modo de adición, el resto de la tarea es la misma que para escribir contenido en un archivo de texto.

A continuación se muestra el ejemplo para agregar una string al archivo:

// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
  
// Driver code
int main()
{
    // Declare the file pointer
    FILE* filePointer;
  
    // Get the data to be appended in file
    char dataToBeWritten[100]
        = "It is a platform for"
          + " learning language"
          + " tech related topics";
  
    // Open the existing file GfgTest.txt using
    // fopen() in append mode using "a" attribute
    filePointer = fopen("GfgTest.txt", "a");
  
    // Check if this filePointer is null
    // which maybe if the file does not exist
    if (filePointer == NULL) {
        printf("GfgTest.txt file failed to open.");
    }
    else {
        printf("The file is now opened.\n");
  
        // Append the dataToBeWritten into the file
        if (strlen(dataToBeWritten) > 0) {
            // writing in the file using fputs()
            fprintf(filePointer, dataToBeWritten);
            fprintf(filePointer, "\n");
        }
  
        // Closing the file using fclose()
        fclose(filePointer);
  
        printf("Data successfully appended"
               + " in file GfgTest.txt\n");
        printf("The file is now closed.");
    }
    return 0;
}

Producción:

Agregar contenido en un archivo binario

Sintaxis:

ARCHIVO * puntero de archivo;
filePointer = fopen(“fileName.bin”, “ab”);

Una vez que el archivo se abre en modo de adición, el resto de la tarea es la misma que para escribir contenido en un archivo binario.

// C program to implement
// the above approach
#include <stdio.h>
#include <stdlib.h>
  
struct threeNum {
    int n1, n2, n3;
};
  
// Driver code
int main()
{
    int n;
    struct threeNum num;
  
    // Declaring the file pointer
    FILE* fptr;
  
    // Opening the file in
    // append mode
    if ((fptr = fopen("C:\\GfgTest.bin",
                      "ab"))
        == NULL) {
        printf("Error! opening file");
  
        // Program exits if the file pointer
        // returns NULL.
        exit(1);
    }
  
    for (n = 1; n < 10; ++n) {
        num.n1 = n;
        num.n2 = 5 * n;
        num.n3 = 5 * n + 1;
        fwrite(&num, sizeof(struct threeNum),
               1, fptr);
    }
  
    printf("The file GfgTest.bin"
           + " is appended successfully");
    fclose(fptr);
    return 0;
}

Producción:

Apertura de archivo para lectura y escritura.

Sintaxis:

ARCHIVO * puntero de archivo;
filePointer = fopen(“fileName.txt”, “r+”);

El archivo se abre usando el modo “r+’” y el archivo se abre tanto en modo de lectura como de escritura.

// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
  
// Driver code
int main()
{
    // Declare the file pointer
    FILE* filePointer;
    char dataToBeWritten[100]
        = "It is a platform for"
          + " learning language"
          + " tech related topics.";
  
    // Declare the variable for the data
    // to be read from file
    char dataToBeRead[50];
  
    // Open the existing file GfgTest.txt
    // using fopen() in read mode using
    // "r+" attribute
    filePointer = fopen("GfgTest.txt", "r+");
  
    // Check if this filePointer is null
    // which maybe if the file does not exist
    if (filePointer == NULL) {
        printf("GfgTest.txt file failed to open.");
    }
    else {
        printf("The file is now opened.\n");
  
        // Read the dataToBeRead from the file
        // using fgets() method
        while (fgets(dataToBeRead, 50,
                     filePointer)
               != NULL) {
            // Print the dataToBeRead
            printf("%s", dataToBeRead);
        }
        printf(
            "\nData successfully read"
            + " from file GfgTest.txt");
  
        if (strlen(dataToBeWritten) > 0) {
            // writing in the file using fprintf()
            fprintf(filePointer, dataToBeWritten);
            fprintf(filePointer, "\n");
        }
  
        printf("\nData successfully"
               + " written to the file");
  
        // Closing the file using fclose()
        fclose(filePointer);
  
        printf("\nThe file is now closed.");
    }
    return 0;
}

Producción:

Apertura de archivo para lectura y escritura en modo binario

Sintaxis:

ARCHIVO * puntero de archivo;
filePointer = fopen(“fileName.bin”, “rb+”);

// C program to implement
// the above approach
#include <stdio.h>
#include <stdlib.h>
  
struct threeNum {
    int n1, n2, n3;
};
  
// Driver code
int main()
{
    int n;
    struct threeNum num;
  
    // Declaring the file pointer
    FILE* fptr;
  
    if ((fptr = fopen("C:\\GfgTest.bin",
                      "rb"))
        == NULL) {
        printf("Error! opening file");
  
        // Program exits if the file pointer
        // returns NULL.
        exit(1);
    }
  
    for (n = 1; n < 5; ++n) {
        fread(&num, sizeof(struct threeNum),
              1, fptr);
        printf("n1: %d\tn2: %d\tn3: %d",
               num.n1, num.n2, num.n3);
        printf("\n");
    }
    printf("Data successfully read from the file");
  
    for (n = 1; n < 7; ++n) {
        num.n1 = n;
        num.n2 = 5 * n;
        num.n3 = 5 * n + 1;
        fwrite(&num, sizeof(struct threeNum),
               1, fptr);
    }
  
    printf("The file GfgTest.bin"
           + " is written successfully");
    fclose(fptr);
  
    return 0;
}

Producción:

Apertura de archivo para lectura y escritura en modo texto

En este modo, el archivo se abre para lectura y escritura en modo texto. Si el archivo existe, el contenido se sobrescribe en el archivo y, en caso de que el archivo no exista, se crea un nuevo archivo.

Sintaxis:

ARCHIVO * puntero de archivo;
filePointer = fopen(“fileName.txt”, “w+”);

// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
  
// Driver code
int main()
{
    // Declare the file pointer
    FILE* filePointer;
    char dataToBeWritten[100]
        = "It is a platform"
          + " for learning language"
          + " tech related topics.";
  
    // Declare the variable for the data
    // to be read from file
    char dataToBeRead[50];
  
    // Open the existing file GfgTest.txt
    // using fopen() in read mode using
    // "r+" attribute
    filePointer = fopen("GfgTest.txt", "w+");
  
    // Check if this filePointer is null
    // which maybe if the file does not exist
    if (filePointer == NULL) {
        printf("GfgTest.txt file failed to open.");
    }
    else {
        printf("The file is now opened.\n");
  
        if (strlen(dataToBeWritten) > 0) {
            // writing in the file using fprintf()
            fprintf(filePointer, dataToBeWritten);
            fprintf(filePointer, "\n");
        }
  
        printf("Data successfully"
               + " written to the file\n");
  
        // Read the dataToBeRead from the file
        // using fgets() method
        while (fgets(dataToBeRead, 50,
                     filePointer)
               != NULL) {
            // Print the dataToBeRead
            printf("%s", dataToBeRead);
        }
        printf("\nData successfully read"
               + " from file GfgTest.txt");
  
        // Closing the file using fclose()
        fclose(filePointer);
  
        printf("\nThe file is now closed.");
    }
    return 0;
}