¿Cómo crear un archivo binario a partir del archivo de texto existente?

En este artículo, discutiremos cómo crear un archivo binario a partir del archivo de texto dado. Antes de continuar con los pasos, veamos qué son los archivos de texto y los archivos binarios.

Archivos de texto : los archivos  de texto almacenan datos en forma legible por humanos y de forma secuencial.

Archivos binarios : los archivos binarios almacenan datos en forma de bits/grupos de bits (bytes) en secuencia. Las combinaciones de estos bits pueden referirse a datos personalizados. Los archivos binarios pueden almacenar múltiples tipos de datos, como imágenes, audio, texto, etc.

Declaración del problema: la tarea aquí es leer datos de un archivo de texto y crear un nuevo archivo binario que contenga los mismos datos en forma binaria.

Ejemplo: supongamos que hay detalles de clientes en un archivo llamado «Custdata.txt» y la tarea es crear un archivo binario llamado «Customerdb» leyendo datos del archivo de texto «Custdata.txt» .

• Cada línea del archivo “Custdata.txt” contiene un registro de la información de un cliente.
• Un registro tiene 3 atributos, es decir, ID , Nombre y Edad .
• Cada registro tiene una longitud fija.

Supongamos que «Custdata.txt» tiene los siguientes datos :

• Sea el tamaño del registro, el número de bytes en un registro = B .
• Si los datos de 3 clientes se escriben en un archivo de disco, el archivo contendrá 3 × B bytes .
• Si hay información sobre la posición relativa «pos» del registro del cliente en el archivo, entonces la información del cliente se puede leer directamente.
• pos* (B – 1) será la posición de byte inicial del registro.

No existe ningún requisito, como tal, para almacenar todos los valores en un registro en formato de texto. El formato interno se puede usar para almacenar valores directamente. Una opción que es buena y se puede tomar como opción es definir una estructura para nuestro registro.

struct Customers 
{
    int ID;
    char name[30];
    int age;
}

Ahora se puede acceder a los elementos individuales de los clientes de estructura creando una variable de estructura cs como:

1. cs.ID.
2. cs.nombre.
3. cs.edad.

Veamos los métodos que serían necesarios para leer el archivo de texto y escribir en el archivo binario. La función requerida para leer es fscanf() y para escribir es fwrite() .

Lectura: la función fscanf() se utiliza para leer el archivo de texto que contiene los datos del cliente.

Sintaxis:

int fscanf(FILE* streamPtr, const char* formatPtr, …);
Esta función lee los datos del flujo de archivos y almacena los valores en las respectivas variables.

Parámetros de fscanf():

• streamPtr: especifica el puntero a la secuencia del archivo de entrada para leer los datos.
• formatPtr: Puntero a una string de caracteres terminada en nulo que especifica cómo leer la entrada. Consiste en especificadores de formato que comienzan con %. Ejemplo: %d para int, %s para string, etc.

Es necesario incluir el archivo de encabezado <cstdio> para usar esta función .

Escritura: la función fwrite() se usa en el programa para escribir los datos leídos del archivo de texto al archivo binario en forma binaria. 

Sintaxis:

size_t fwrite(const void * bufPtr, size size, size_t count, FILE * ptr_OutputStream);
La función fwrite() escribe el número de «recuento» de objetos, donde el tamaño de cada objeto es bytes de «tamaño», en el flujo de salida dado.

Parámetros de escribir():

• bufPtr: Puntero al bloque de memoria cuyo contenido se escribe (convertido a const void*).
• tamaño: El tamaño en bytes de cada objeto a escribir.
• count: el recuento del total de objetos que se van a leer.
• ptr_OutputStream: Puntero a un archivo que especifica la secuencia del archivo de salida para escribir.

Es necesario incluir el archivo de encabezado <cstdio> para usar esta función.

Algoritmo: a continuación se muestra el enfoque del programa para leer el archivo de texto y escribir el contenido en forma binaria en un archivo binario.

• Abra el archivo de texto de entrada y el archivo binario de salida.
• Hasta que se alcance el final del archivo de texto, realice los siguientes pasos:
  • Lea una línea del archivo de texto de entrada, en 3 variables usando fscanf() .
  • La variable de estructura se establece en valores para elementos (para escribir la variable de estructura en el archivo de salida.
  • Escriba esa variable de estructura en el archivo binario de salida usando fwrite() .
• Cierre el archivo de texto de entrada y el archivo binario de salida.

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

// C++ program for the above approach
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
  
// Creating a structure for customers
struct Customers {
    int ID;
    char name[30];
    int age;
};
  
// Driver Code
int main()
{
    struct Customers cs;
    int rec_size;
    rec_size = sizeof(struct Customers);
    cout << "Size of record is: "
         << rec_size << endl;
  
    // Create File Pointers fp_input for
    // text file, fp_output for output
    // binary file
    FILE *fp_input, *fp_output;
  
    // Open input text file, output
    // binary file.
    // If we cannot open them, work
    // cannot be done, so return -1
    fp_input = fopen("custdata.txt", "r");
  
    if (fp_input == NULL) {
        cout << "Could not open input file"
             << endl;
        return -1;
    }
  
    fp_output = fopen("Customerdb", "wb");
  
    if (fp_output == NULL) {
        cout << "Could not open "
             << "output file" << endl;
        return -1;
    }
  
    // Read one line from input text file,
    // into 3 variables id, n & a
    int id, a;
    char n[30];
  
    // Count for keeping count of total
    // Customers Records
    int count = 0;
    cout << endl;
  
    // Read next line from input text
    // file until EOF is reached
    while (!feof(fp_input)) {
  
        // Reading the text file
        fscanf(fp_input, "%d %s %d ",
               &id, n, &a);
  
        // Increment the count by one
        // after reading a record
        count++;
  
        // Structure variable cs is set
        // to values to elements
        cs.ID = id, strcpy(cs.name, n), cs.age = a;
  
        // Write the structure variable
        // cs to output file
        fwrite(&cs, rec_size, 1, fp_output);
        printf(
            "Customer number %2d has"
            " data %5d %30s %3d \n",
            count, cs.ID,
            cs.name, cs.age);
    }
  
    cout << "Data  from file read"
         << " and printed\n";
    cout << "Database created for "
         << "Customers info\n";
  
    // Count contains count of total records
    cout << "Total records written: "
         << count << endl;
  
    // Close both the files
    fclose(fp_input);
    fclose(fp_output);
  
    return 0;
}

Producción:

Size of record is: 40

Customer number  1 has data     1                    Annil  22
Customer number  2 has data     2                      Ram  45
Customer number  3 has data     3                    Golu  25          
Data  from file read and printed
Database created for Customers info     
Total records written: 3

Explicación: había 3 registros en el archivo «custdata.txt» que se leyeron, imprimieron y guardaron en el archivo «Customerdb» en modo binario.
El archivo de texto contiene 3 campos en cada línea: ID, Nombre y Edad.
La primera línea del archivo de texto contiene-

 1                    Annil  22

Esta línea se lee del archivo, es decir, se leen los datos de ID, Nombre y Edad y se asignan sus valores a las variables id, ny a respectivamente. Ahora asigne los valores de estas 3 variables a los miembros de datos: ID, nombre[] y edad de la variable de estructura cs respectivamente.
Ahora, usando fwrite(&cs, rec_size, 1, fp_output) , escriba un objeto cs de tamaño rec_size en el archivo binario: «fp_output» (modo binario).
Este procedimiento continúa para todas las líneas de los archivos de texto hasta llegar al final del archivo. Después de que finalice la ejecución del programa, el archivo «custdata.txt» permanecerá como está, tal como se abrió en el modo de lectura.

 1                         Annil  22
 2                           Ram  45
 3                          Golu  25

Estos datos se leen línea por línea y se escriben en el archivo «Customerdb» en modo binario. El archivo «Customerdb» tendrá el contenido en forma binaria, que no es legible. El archivo, cuando se abre normalmente, se ve así: