Écrire un fichier binaire en C++

C++ fournit la bibliothèque pour interagir avec les fichiers binaires, en particulier la classe « ofstream », pour écrire les données binaires. Cette fonctionnalité permet aux développeurs de créer, modifier et gérer de manière transparente les fichiers binaires. Cet article explore les différentes méthodes et techniques d'écriture de fichiers binaires en C++, mettant en lumière leurs applications et cas d'utilisation.

Écrire un fichier binaire en utilisant C++

Pour enregistrer les données dans un fichier binaire en utilisant C++, la méthode write() est utilisée. Cette fonction écrit un nombre spécifié d'octets dans le flux désigné, en commençant à l'emplacement du pointeur « put ». Si le pointeur « put » est à la fin, le fichier est étendu. Toutefois, les nouvelles données écrasent les caractères existants si le pointeur se trouve dans le fichier. En cas d'erreur lors du processus d'écriture, le flux est marqué comme étant dans un état d'erreur. Passons maintenant aux exemples pour apprendre à écrire dans un fichier binaire à l'aide de quelques fonctions C++ simples et intégrées.

Méthode 1 : écriture de fichiers binaires avec des données structurées

Dans de nombreux cas, vous devrez peut-être écrire des données structurées, telles que des structures personnalisées, dans un fichier binaire. Prenons un exemple contenant un enregistrement d'une personne qui comprend le nom, la taille et l'âge d'une personne. Consultez le code suivant et jetez un œil à l’explication :

Voici une ventilation du code avec les détails spécifiques. Le programme commence par définir une structure personnalisée nommée « Personne ». Il comporte trois champs : nom, âge et taille. Le détail de ces champs est le suivant :

• nom: Une chaîne pour stocker le nom de la personne (jusqu'à 50 caractères)
• âge: Un entier pour stocker l’âge de la personne
• hauteur: Un double pour mémoriser la taille de la personne

Après avoir défini la structure « Personne », la fonction principale démarre qui est le point d’entrée du programme. La première ligne du programme principal ouvre un fichier nommé « people.bin ». Nous utilisons « std :: ofstream » pour créer un fichier nommé « people.bin » pour écrire les données au format binaire. Vérifier si le fichier s’ouvre correctement est très important. Sinon, un message d'erreur s'affiche et le programme s'arrête. Par conséquent, à l’aide de la condition « if » et de la fonction is_open(), nous vérifions si le fichier s’est ouvert avec succès ou non.

Ici, les deux objets « Personne » sont créés. Nous définissons deux variables, « personne1 » et « personne2 », de type « Personne ». Nous attribuons les valeurs de nom, d'âge et de taille aux variables pour « Kalsoom Ilyas » et « Kalsoom Bajwa ».

Maintenant que nous avons les données à écrire dans un fichier binaire, exécutons la fonction réelle avec la fonction write(). Nous utilisons « outFile.write » pour écrire le contenu de chaque objet « Person » dans le fichier. Les « reinterpret_cast(&person1) » et « reinterpret_cast(&person2) » convertissent l'intégralité de la structure « Person » (y compris tous ses champs) en un flux continu d'octets adapté à l'écriture dans le fichier binaire. . Nous écrivons la taille de chaque objet « Personne » en utilisant « sizeof(person1) » et « sizeof(person2) » pour garantir que toutes les données sont écrites correctement.

Après avoir écrit les données sur le fichier, il est très important de le fermer correctement afin qu'aucune donnée ne soit perdue à cause d'une autre fonction. Nous utilisons outFile.close() pour libérer les ressources associées au fichier et garantir que les données sont écrites avec précision. Enfin, nous imprimons un message qui confirme l’écriture réussie des données dans le fichier binaire.

Si nous expliquons cet exemple en termes plus simples, imaginez un cahier spécial qui ne peut stocker des informations sur des personnes que dans un langage secret. Ce code crée un plan pour organiser les informations (nom, âge, taille). Il ouvre le cahier, remplit les profils de deux personnes, traduit les informations dans la langue secrète et les écrit soigneusement à l'intérieur. Il ferme ensuite le notebook en toute sécurité, préservant les profils pour une utilisation future. Reportez-vous au résultat du programme donné dans l'instantané suivant :

Méthode 2 : écriture d'entiers dans un fichier binaire

Dans cette méthode, un tableau d'entiers est écrit dans un fichier binaire nommé « integers.bin ». Le « reinterpret_cast » traite le tableau d'entiers comme une séquence de caractères (octets) à écrire dans le fichier. Ceci est particulièrement important car les fichiers binaires traitent des données brutes en octets. Jetons un coup d'œil à l'exemple simple suivant :

Voici une ventilation du code avec les détails spécifiques :

Les « #include » et « #include » apportent les outils nécessaires pour travailler avec des fichiers et imprimer les messages comme cin et write(), respectivement. Le 'std::ofstream outFile('integers.bin', std::ios::binary);' ouvre un fichier binaire nommé « integers.bin » qui ne peut stocker les nombres que dans un code secret (format binaire). Il vérifie si le fichier est ouvert. Sinon, un message d'erreur est donné.

La ligne suivante qui est 'int number[] = {42, 99, -1, 0};' définit un tableau nommé « numbers » avec les entiers 42, 99, -1 et 0. Le « outFile.write(reinterpret_cast(numbers), sizeof(numbers)); » traduit soigneusement les entiers au format binaire et les écrit dans le fichier « integer.bin ». Le « outFile.close(); » ferme le fichier correctement pour garder les entiers en sécurité et organisés. Enfin, un message est imprimé pour confirmer que les entiers ont été stockés avec succès dans le fichier binaire. Reportez-vous à la sortie suivante de ce programme pour voir le résultat :

Conclusion

L'écriture de fichiers binaires en C++ est une compétence cruciale pour gérer efficacement les différents types de données. Dans cette exploration de l’écriture de fichiers binaires en C++, nous avons appris comment la classe « ofstream » peut être utilisée pour gérer efficacement les données binaires. Qu'il s'agisse d'entiers simples ou de données structurées utilisant des structures personnalisées, le processus implique l'ouverture d'un flux de fichiers, l'écriture des données au format binaire, puis la fermeture du fichier. Cette capacité offre aux développeurs C++ la flexibilité de travailler avec une gamme variée de types de données binaires, contribuant ainsi à la polyvalence du langage dans des applications allant de la programmation au niveau système au traitement multimédia.