La gestion de fichiers en programmation est une tâche que le programmeur doit maîtriser. La connaissance des différentes fonctions d'ouverture, de lecture et d'écriture est essentielle car nous en avons toujours besoin pour stocker ou supprimer les informations stockées dans des fichiers.
Dans cet article Linux Hint, vous apprendrez à utiliser la fonction write() pour écrire les fichiers.
Nous expliquerons tout sur cette ella, sa syntaxe, la méthode d'appel, les arguments d'entrée et de sortie, le type de données qu'elle accepte dans chaque cas et comment la déclarer correctement.
Ensuite, nous appliquons ce que nous avons appris en mettant l'utilisation de cette fonction dans des exemples pratiques que nous avons préparés pour vous avec des extraits de code et des images, montrant l'utilisation de write() dans le langage C.
Afin que vous ayez une connaissance approfondie de l'utilisation de la fonction write(), nous avons ajouté une section spéciale qui décrit les erreurs individuelles qui peuvent survenir lors de l'utilisation de cette fonction, ainsi que leur détection et leur identification, afin que vous ayez la techniques nécessaires pour une solution rapide en cas d'apparition.
Syntaxe de la fonction Write() en langage C
entier écrire ( entier fd , annuler * buf , taille_t n ) ;Description de la fonction Write() en langage C
La fonction write() écrit dans un fichier ouvert. Cette fonction écrit le contenu du tampon pointé par « buf » dans le fichier spécifié par son descripteur dans l'argument d'entrée « fd ». La taille du bloc à écrire dans le fichier doit être spécifiée dans l'argument d'entrée 'n'.
Pour pouvoir écrire avec la fonction write(), le fichier doit être ouvert avec la fonction open() et spécifié dans les attributs O_RDONLY ou O_RDWR. Sinon, cette fonction n'a aucun effet.
Si l'appel réussit, il renvoie le nombre de caractères saisis. Si une erreur se produit lors de l'écriture, elle renvoie un résultat égal à -1. Le code d'identification qui indique l'erreur peut être récupéré à partir de la variable globale errno qui est définie dans l'en-tête « errno.h ».
Plus tard, vous trouverez une section où nous expliquons comment détecter et identifier les erreurs les plus courantes de cette fonction.
La fonction write() est définie dans l'en-tête « unistd.h ». Les drapeaux qui définissent les attributs et le mode d'ouverture du fichier sont définis dans 'fcntl.h'. Pour utiliser les fonctions open() et write(), vous devez inclure ces en-têtes dans votre code comme suit :
#include#include
Comment écrire dans un fichier à l'aide de la fonction Write() en langage C
Dans cet exemple, nous écrivons un fichier texte vide nommé 'example.txt' que nous avons créé précédemment dans le répertoire 'Documents'.
La première étape consiste à insérer les en-têtes nécessaires. Dans la fonction main(), ouvrez le fichier avec la fonction open(). Pour ce faire, nous devons déclarer l'entier 'fd' qui sert de descripteur de fichier, et le tableau tampon 'buf' de 1024 caractères qui contient le texte que nous voulons écrire dans le fichier. Dans ce tampon, nous stockons le premier paragraphe de la page de manuel GCC pour l'écrire dans le fichier 'example.txt'.
Après avoir ouvert le fichier avec la fonction open() en mode lecture/écriture, nous écrivons dans le fichier en appelant la fonction write() et en passant le descripteur de fichier 'fd' comme premier argument d'entrée, le pointeur 'buf' comme deuxième argument, et la taille de la chaîne contenue dans le tableau comme troisième argument, que nous obtenons avec la fonction strlen(). Voici le code de cet exemple :
#include#include
#include
#include
#include
#include
#include
annuler principal ( )
{
entier fd ;
carboniser amortir [ 1024 ] = 'Lorsque vous invoquez GCC, il effectue normalement le prétraitement, la compilation, l'assemblage et la liaison. Les options globales vous permettent d'arrêter ce processus à un stade intermédiaire. Par exemple, l'option -c indique de ne pas exécuter l'éditeur de liens. Ensuite, la sortie consiste en fichiers objets produits par l'assembleur.' ;
fd = ouvrir ( 'Documents/exemple.txt' , O_RDWR ) ;
écrire ( fd , & amortir , tendu ( amortir ) ) ;
fermer ( fd ) ;
}
Dans la figure suivante, nous voyons la compilation et l'exécution de ce code avec le fichier ouvert qui est écrit par la fonction write() :
Comment ajouter un texte à la fin d'un fichier avec la fonction Write () en langage C
Lorsqu'un fichier est ouvert en spécifiant les drapeaux O_WRONLY ou O_RDWR, le curseur saute à la première position et commence à écrire à partir de là.
Pour ajouter un texte à la fin d'un fichier, il doit être spécifié par une opération OU logique entre les drapeaux O_WRONLY ou O_RDWR et le drapeau O_APPEND dans l'argument des drapeaux d'entrée de la fonction open() lorsque le fichier est ouvert. De cette façon, le curseur est placé à la fin du fichier et l'écriture commence à partir de là. De plus, les attributs et le mode d'écriture peuvent être modifiés une fois le fichier ouvert avec la fonction fcntl().
Dans l'illustration suivante, vous pouvez voir un code qui ajoute un texte à la fin du fichier que nous avons écrit dans l'exemple précédent :
#include#include
#include
#include
#include
#include
#include
annuler principal ( )
{
entier fd ;
carboniser amortir [ 1024 ] = 'Ce texte est ajouté. Ce texte est ajouté.' ;
fd = ouvrir ( 'Documents/exemple.txt' , O_RDWR | O_APPEND ) ;
écrire ( fd , & amortir , tendu ( amortir ) ) ;
fermer ( fd ) ;
}
L'image suivante montre le texte ajouté. Comme vous pouvez le voir, avec cette méthode d'ouverture, la fonction write() commence à écrire à la position du dernier caractère écrit dans le fichier :
Comment détecter et identifier les erreurs pouvant survenir lors de l'utilisation de la fonction Write() en langage C
L'utilisation de write() peut générer diverses erreurs. Lorsque cela se produit, cette fonction renvoie un résultat égal à -1.
Le moyen le plus simple de déterminer si une erreur s'est produite est d'utiliser une condition 'if' où la condition est la valeur de retour de -1. Voyons maintenant comment vous pouvez utiliser cette méthode pour déterminer si une erreur s'est produite :
entier n ;n = écrire ( fd , & amortir , tendu ( amortir ) ) ;
si ( n == - 1 ) {
printf ( 'Une erreur s'est produite lors de la tentative d'écriture du fichier.' ) ;
}
Si la fonction write() renvoie une erreur, elle passe à l'instruction 'if' et imprime le message ' Une erreur s'est produite lors de la tentative d'écriture du fichier “.
Lorsqu'une erreur se produit, un code numérique est automatiquement stocké dans la variable globale errno qui est définie dans l'en-tête « errno.h ». Ce code peut être utilisé pour identifier l'erreur qui s'est produite.
Voici un extrait des erreurs que la fonction write() peut générer et qui sont définies dans l'en-tête « errno.h », ainsi qu'une brève description de chaque erreur et la valeur entière associée :
| Définition | Valeur dans errno | Erreur |
|---|---|---|
| ENCORE | onze | Essayer à nouveau. |
| EBADF | 9 | Numéro de dossier erroné. |
| EDESTADDRREQ | 89 | Adresse de destination requise. |
| EDQUOT | 122 | Quota dépassé. |
| EFAULT | 14 | Adresse incorrecte. |
| EFBIG | 27 | Fichier trop gros. |
| EINTR | 4 | Appel système interrompu. |
| CHOIX UNIQUE | 22 | Argument invalide. |
| EIO | 5 | Erreur d'E/S. |
| ENOSPC | 28 | Pas d'espace disponible sur le périphérique. |
| Supérieur | 1 | Opération non autorisée. |
Le moyen le plus simple d'identifier une erreur est d'ouvrir un commutateur où la variable errno est la condition de saut et chaque cas est une définition d'erreur.
Ensuite, regardons un exemple où nous essayons d'entrer un descripteur avec un signe négatif, ce qui entraîne une erreur. Pour identifier une erreur, nous utilisons la condition 'if' que nous avons vue dans l'extrait précédent. Pour l'identifier, nous ouvrons un commutateur avec les trois erreurs les plus courantes que cette fonction peut produire.
#include#include
#include
#include
#include
#include
#include
annuler principal ( )
{
entier fd ;
entier n ;
carboniser amortir [ 1024 ] = 'Bonjour le monde' ;
fd = ouvrir ( 'Documents/exemple.txt' , O_RDWR ) ;
n = écrire ( - 2 , & amortir , tendu ( amortir ) ) ;
si ( n == - 1 ) {
changer ( erreur non ) {
cas EBADF : {
printf ( 'Mauvais numéro de fichier. Erreur : %i \n ' , erreur non ) ;
casser ; }
cas CHOIX UNIQUE : {
printf ( 'Argument invalide. Erreur : %i \n ' , erreur non ) ;
casser ; }
cas EIO : {
printf ( 'Erreur d'E/S . Erreur : %i \n ' , erreur non ) ;
casser ; }
}
}
}
Comme nous pouvons le voir dans la figure suivante, la fonction write() renvoie une erreur lorsqu'un descripteur non valide est passé en argument d'entrée. La valeur extraite de la variable errno est utilisée comme condition de saut qui nous permet d'identifier l'erreur lorsque nous entrons dans le cas EBADF.
Conclusion
Dans cet article Linux Hint, nous vous avons montré comment utiliser la fonction write() pour écrire dans les fichiers. Nous vous avons montré la syntaxe et la description théorique de cette fonction. Nous avons également expliqué les méthodes de détection et d'identification des erreurs afin que vous disposiez des outils et des techniques nécessaires pour résoudre rapidement ces problèmes.
Pour vous aider à voir comment write() fonctionne, nous avons implémenté l'utilisation de cette fonction dans des exemples pratiques avec des codes et des images qui montrent l'utilisation de cette fonction et des autres fonctions de traitement de fichiers.
Nous vous avons également montré comment sélectionner le mode d'ouverture de fichier pour insérer un texte au début ou à la fin du fichier, et quelles fonctions sont disponibles pour modifier ces attributs.