La gestió de fitxers en programació és una tasca que el programador ha de dominar. El coneixement de les diferents funcions d'obertura, lectura i escriptura és fonamental perquè sempre les necessitem per emmagatzemar o disposar de la informació que s'emmagatzema en els fitxers.
En aquest article de Linux Hint, aprendràs a utilitzar la funció write() per escriure els fitxers.
Explicarem tot sobre aquesta ella, la seva sintaxi, el mètode de crida, els arguments d'entrada i sortida, el tipus de dades que accepta en cada cas i com declarar-les correctament.
A continuació, apliquem el que hem après posant l'ús d'aquesta funció en exemples pràctics que us hem preparat amb fragments de codi i imatges, que mostren l'ús de write() en el llenguatge C.
Per tal que tingueu un coneixement exhaustiu de l'ús de la funció write(), hem afegit una secció especial que descriu els errors individuals que es poden produir en utilitzar aquesta funció, així com la seva detecció i identificació, de manera que tingueu la tècniques necessàries per a una solució ràpida en cas que es produeixin.
Sintaxi de la funció Write() en llenguatge C
int escriure ( int fd , buit * buf , mida_t n ) ;Descripció de la funció Write() en llenguatge C
La funció write() escriu en un fitxer obert. Aquesta funció escriu el contingut de la memòria intermèdia al qual apunta 'buf' al fitxer especificat pel seu descriptor a l'argument d'entrada 'fd'. La mida del bloc que s'ha d'escriure al fitxer s'ha d'especificar a l'argument d'entrada “n”.
Per poder escriure amb la funció write() s'ha d'obrir el fitxer amb la funció open() i especificar als atributs O_RDONLY o O_RDWR. En cas contrari, aquesta funció no té cap efecte.
Si la trucada té èxit, retorna el nombre de caràcters introduïts. Si es produeix un error durant l'escriptura, retorna un resultat que és igual a -1. El codi d'identificació que indica l'error es pot recuperar de la variable global errno que es defineix a la capçalera “errno.h”.
Més endavant, trobareu un apartat on us expliquem com detectar i identificar els errors més habituals d'aquesta funció.
La funció write() es defineix a la capçalera “unistd.h”. Els indicadors que defineixen els atributs i la manera d'obrir el fitxer es defineixen a 'fcntl.h'. Per utilitzar les funcions open() i write(), heu d'incloure aquestes capçaleres al vostre codi de la manera següent:
#include#inclou
Com escriure en un fitxer utilitzant la funció Write() en llenguatge C
En aquest exemple, escrivim un fitxer de text buit anomenat 'example.txt' que hem creat anteriorment al directori 'Documents'.
El primer pas és inserir les capçaleres necessàries. Dins de la funció main(), obriu el fitxer amb la funció open(). Per fer-ho, hem de declarar l'enter 'fd' que serveix com a descriptor del fitxer, i la matriu de memòria intermèdia 'buf' de 1024 caràcters que conté el text que volem escriure al fitxer. En aquest buffer, emmagatzemem el primer paràgraf de la pàgina de manual de GCC per escriure'l al fitxer 'example.txt'.
Després d'obrir el fitxer amb la funció open() en mode de lectura/escriptura, escrivim al fitxer cridant a la funció write() i passant el descriptor del fitxer 'fd' com a primer argument d'entrada, el punter 'buf' com a segon. argument i la mida de la cadena que conté la matriu com a tercer argument, que obtenim amb la funció strlen(). Aquí teniu el codi d'aquest exemple:
#include#inclou
#include
#include
#include
#inclou
#inclou
buit principal ( )
{
int fd ;
char tampó [ 1024 ] = 'Quan invoqueu GCC, normalment fa el preprocessament, la compilació, el muntatge i l'enllaç. Les opcions generals us permeten aturar aquest procés en una etapa intermèdia. Per exemple, l'opció -c diu que no heu d'executar l'enllaçador. Aleshores la sortida consta de fitxers d'objecte sortits per l'assemblador.' ;
fd = obert ( 'Documents/example.txt' , O_RDWR ) ;
escriure ( fd , & tampó , strlen ( tampó ) ) ;
Tanca ( fd ) ;
}
A la següent figura, veiem la compilació i execució d'aquest codi juntament amb el fitxer obert que està escrit per la funció write():
Com afegir un text al final d'un fitxer amb la funció Write() en llenguatge C
Quan s'obre un fitxer especificant els senyaladors O_WRONLY o O_RDWR, el cursor salta a la primera posició i comença a escriure des d'allà.
Per afegir un text al final d'un fitxer, s'ha d'especificar mitjançant una operació OR lògica entre els senyaladors O_WRONLY o O_RDWR i el senyalador O_ APPEND a l'argument de senyaladors d'entrada de la funció open() quan s'obre el fitxer. D'aquesta manera, el cursor es col·loca al final del fitxer i a partir d'aquí comença l'escriptura. A més, els atributs i el mode d'escriptura es poden canviar un cop obert el fitxer amb la funció fcntl().
A la il·lustració següent, podeu veure un codi que afegeix un text al final del fitxer que vam escriure a l'exemple anterior:
#include#inclou
#include
#include
#include
#inclou
#inclou
buit principal ( )
{
int fd ;
char tampó [ 1024 ] = 'Aquest text s'afegeix. Aquest text s'afegeix.' ;
fd = obert ( 'Documents/example.txt' , O_RDWR | O_APPEND ) ;
escriure ( fd , & tampó , strlen ( tampó ) ) ;
Tanca ( fd ) ;
}
La imatge següent mostra el text afegit. Com podeu veure, amb aquest mètode d'obertura, la funció write() comença a escriure a la posició de l'últim caràcter que s'escriu al fitxer:
Com detectar i identificar els errors que poden ocórrer quan s'utilitza la funció Write() en el llenguatge C
L'ús de write() pot generar diversos errors. Quan això passa, aquesta funció retorna un resultat que és igual a -1.
La manera més senzilla de determinar si s'ha produït un error és utilitzar una condició 'si' on la condició és el valor de retorn de -1. Ara, vegem com podeu utilitzar aquest mètode per determinar si s'ha produït un error:
int n ;n = escriure ( fd , & tampó , strlen ( tampó ) ) ;
si ( n == - 1 ) {
imprimirf ( 'S'ha produït un error en intentar escriure el fitxer.' ) ;
}
Si la funció write() torna amb un error, passa a la instrucció 'si' i imprimeix el missatge ' S'ha produït un error en intentar escriure el fitxer “.
Quan es produeix un error, un codi numèric s'emmagatzema automàticament a la variable global errno que es defineix a la capçalera “errno.h”. Aquest codi es pot utilitzar per identificar l'error que s'ha produït.
El següent és un extracte amb els errors que pot generar la funció write() i que es defineixen a la capçalera “errno.h”, juntament amb una breu descripció de cada error i el valor sencer associat:
| Definició | Valor en error | Error |
|---|---|---|
| DE NOSALTRES | 11 | Torna-ho a provar. |
| EBADF | 9 | Número de fitxer incorrecte. |
| EDESTADDRREQ | 89 | Adreça de destinació necessària. |
| EDQUOT | 122 | Quota superada. |
| EFAULT | 14 | Adreça incorrecta. |
| EFBIG | 27 | Fitxer massa gran. |
| EINTR | 4 | S'ha interromput la trucada del sistema. |
| ÚNICA Elecció | 22 | Argument invàlid. |
| EIO | 5 | Error d'E/S. |
| ENOSPC | 28 | No queda espai lliure al dispositiu. |
| Superior | 1 | Operació no permesa. |
La manera més senzilla d'identificar un error és obrir un interruptor on la variable errno és la condició de salt i cada cas és una definició d'error.
A continuació, vegem un exemple on intentem introduir un descriptor amb un signe negatiu, donant lloc a un error. Per identificar un error, utilitzem la condició 'si' que vam veure al fragment anterior. Per identificar-lo, obrim un interruptor amb els tres errors més habituals que pot produir aquesta funció.
#inclou#include
#include
#include
#inclou
#inclou
#inclou
buit principal ( )
{
int fd ;
int n ;
char tampó [ 1024 ] = 'Hola món' ;
fd = obert ( 'Documents/example.txt' , O_RDWR ) ;
n = escriure ( - 2 , & tampó , strlen ( tampó ) ) ;
si ( n == - 1 ) {
interruptor ( errno ) {
Caixa EBADF : {
imprimirf ( 'Número de fitxer incorrecte. Error: %i \n ' , errno ) ;
trencar ; }
Caixa ÚNICA Elecció : {
imprimirf ( 'Argument no vàlid. Error: %i \n ' , errno ) ;
trencar ; }
Caixa EIO : {
imprimirf ( 'Error d'E/S . Error: %i \n ' , errno ) ;
trencar ; }
}
}
}
Com podem veure a la figura següent, la funció write() retorna un error quan es passa un descriptor no vàlid com a argument d'entrada. El valor que es recupera de la variable errno s'utilitza com a condició de salt que ens permet identificar l'error quan entrem al cas EBADF.
Conclusió
En aquest article de Linux Hint, us vam mostrar com utilitzar la funció write() per escriure als fitxers. Us vam mostrar la sintaxi i la descripció teòrica d'aquesta funció. També us vam explicar els mètodes de detecció i identificació d'errors perquè disposeu de les eines i tècniques necessàries per resoldre ràpidament aquests problemes.
Per ajudar-vos a veure com funciona write(), hem implementat l'ús d'aquesta funció en exemples pràctics amb codis i imatges que mostren l'ús d'aquesta i d'altres funcions de processament de fitxers.
També us vam mostrar com seleccionar el mode d'obertura del fitxer per inserir un text al principi o al final del fitxer, i quines funcions estan disponibles per canviar aquests atributs.