Ang pamamahala ng file sa programming ay isang gawain na dapat maging matatas ang programmer. Ang kaalaman sa iba't ibang open, read, at write function ay mahalaga dahil lagi nating kailangan ang mga ito upang mag-imbak o magtapon ng impormasyong nakaimbak sa mga file.
Sa artikulong ito ng Linux Hint, matututunan mo kung paano gamitin ang write() function para isulat ang mga file.
Ipapaliwanag namin ang lahat tungkol sa ella na ito, ang syntax nito, ang paraan ng pagtawag, ang input at output na mga argumento, ang uri ng data na tinatanggap nito sa bawat kaso, at kung paano ito ideklara nang tama.
Pagkatapos, inilalapat namin ang aming natutunan sa pamamagitan ng paglalagay ng paggamit ng function na ito sa mga praktikal na halimbawa na inihanda namin para sa iyo gamit ang mga snippet ng code at mga larawan, na nagpapakita ng paggamit ng write() sa wikang C.
Upang magkaroon ka ng komprehensibong kaalaman sa paggamit ng write() function, nagdagdag kami ng isang espesyal na seksyon na naglalarawan sa mga indibidwal na error na maaaring mangyari kapag ginagamit ang function na ito, pati na rin ang kanilang pagtuklas at pagkakakilanlan, upang magkaroon ka ng kinakailangang mga pamamaraan para sa isang mabilis na solusyon kung sakaling mangyari ang mga ito.
Syntax ng Write() Function sa C Language
int magsulat ( int fd , walang bisa * buf , laki_t n ) ;Paglalarawan ng Write() Function sa C Language
Ang write() function ay nagsusulat sa isang bukas na file. Isinulat ng function na ito ang mga nilalaman ng buffer na itinuturo ng 'buf' sa file na tinukoy ng descriptor nito sa 'fd' input argument. Ang laki ng bloke na isusulat sa file ay dapat na tinukoy sa 'n' input argument.
Upang makapagsulat gamit ang write() function, dapat na buksan ang file gamit ang open() function at tinukoy sa mga katangiang O_RDONLY o O_RDWR. Kung hindi, walang epekto ang function na ito.
Kung matagumpay ang tawag, ibinabalik nito ang bilang ng mga character na ipinasok. Kung may naganap na error habang nagsusulat, nagbabalik ito ng resulta na katumbas ng -1. Ang code ng pagkakakilanlan na nagpapahiwatig ng error ay maaaring makuha mula sa errno global variable na tinukoy sa 'errno.h' header.
Sa ibang pagkakataon, makakahanap ka ng isang seksyon kung saan ipinapaliwanag namin kung paano matukoy at matukoy ang mga pinakakaraniwang error ng function na ito.
Ang write() function ay tinukoy sa 'unistd.h' na header. Ang mga flag na tumutukoy sa mga katangian at mode para buksan ang file ay tinukoy sa 'fcntl.h'. Upang magamit ang open() at write() function, dapat mong isama ang mga header na ito sa iyong code gaya ng sumusunod:
#include#include
Paano Sumulat sa isang File Gamit ang Write() Function sa C Language
Sa halimbawang ito, nagsusulat kami ng walang laman na text file na pinangalanang 'example.txt' na ginawa namin kanina sa direktoryo ng 'Mga Dokumento.'
Ang unang hakbang ay ipasok ang mga kinakailangang header. Sa loob ng main() function, buksan ang file gamit ang open() function. Para magawa ito, kailangan nating ideklara ang 'fd' integer na nagsisilbing file descriptor, at ang 1024-character na 'buf' buffer array na naglalaman ng text na gusto nating isulat sa file. Sa buffer na ito, iniimbak namin ang unang talata ng GCC man page para isulat ito sa “example.txt” file.
Pagkatapos buksan ang file na may open() function sa read/write mode, sumusulat kami sa file sa pamamagitan ng pagtawag sa write() function at pagpasa sa “fd” file descriptor bilang unang input argument, ang “buf” pointer bilang pangalawa argument, at ang laki ng string na nakapaloob sa array bilang pangatlong argumento, na nakukuha namin gamit ang strlen() function. Narito ang code para sa halimbawang ito:
#include#include
#include
#include
#include
#include
#include
walang bisa pangunahing ( )
{
int fd ;
char buffer [ 1024 ] = 'Kapag nag-invoke ka ng GCC, karaniwan itong nagsasagawa ng preprocessing, compilation, assembly at linking. Nagbibigay-daan sa iyo ang pangkalahatang mga opsyon na ihinto ang prosesong ito sa isang intermediate na yugto. Halimbawa, sinasabi ng -c na opsyon na huwag patakbuhin ang linker. Pagkatapos ang output ay binubuo ng object file na output ng assembler.' ;
fd = bukas ( 'Documents/example.txt' , O_RDWR ) ;
magsulat ( fd , at buffer , strlen ( buffer ) ) ;
malapit na ( fd ) ;
}
Sa sumusunod na figure, nakikita namin ang compilation at execution ng code na ito kasama ang binuksan na file na isinulat ng write() function:
Paano Magdagdag ng Teksto sa Dulo ng File na may Function na Write() sa C Language
Kapag nabuksan ang isang file sa pamamagitan ng pagtukoy sa mga flag na O_WRONLY o O_RDWR, tumalon ang cursor sa unang posisyon at magsisimulang magsulat mula doon.
Upang magdagdag ng text sa dulo ng isang file, dapat itong tukuyin ng isang lohikal na OR na operasyon sa pagitan ng O_WRONLY o O_RDWR na mga flag at ang O_ APPEND na flag sa input flags argument ng open() function kapag binuksan ang file. Sa ganitong paraan, inilalagay ang cursor sa dulo ng file at magsisimula ang pagsusulat mula doon. Gayundin, ang mga katangian at ang write mode ay maaaring mabago sa sandaling mabuksan ang file gamit ang fcntl() function.
Sa sumusunod na paglalarawan, makakakita ka ng code na nagdaragdag ng text sa dulo ng file na isinulat namin sa nakaraang halimbawa:
#include#include
#include
#include
#include
#include
#include
walang bisa pangunahing ( )
{
int fd ;
char buffer [ 1024 ] = 'Idinagdag ang tekstong ito. Idinagdag ang tekstong ito.' ;
fd = bukas ( 'Documents/example.txt' , O_RDWR | O_APPEND ) ;
magsulat ( fd , at buffer , strlen ( buffer ) ) ;
malapit na ( fd ) ;
}
Ang sumusunod na larawan ay nagpapakita ng idinagdag na teksto. Tulad ng nakikita mo, sa pamamaraang ito ng pagbubukas, ang write() function ay magsisimulang magsulat sa posisyon ng huling character na nakasulat sa file:
Paano Matukoy at Matukoy ang Mga Error na Maaaring Maganap Kapag Ginagamit ang Write() Function sa C Language
Ang paggamit ng write() ay maaaring makabuo ng iba't ibang mga error. Kapag nangyari ito, ang function na ito ay nagbabalik ng resulta na katumbas ng -1.
Ang pinakamadaling paraan upang matukoy kung may naganap na error ay ang paggamit ng kondisyong 'kung' kung saan ang kundisyon ay ang return value na -1. Ngayon, tingnan natin kung paano mo magagamit ang paraang ito upang matukoy kung may naganap na error:
int n ;n = magsulat ( fd , at buffer , strlen ( buffer ) ) ;
kung ( n == - 1 ) {
printf ( 'May naganap na error habang sinusubukang isulat ang file.' ) ;
}
Kung ang write() function ay bumalik na may error, ito ay lilipat sa 'if' na pahayag at i-print ang mensahe, ' Nagkaroon ng error habang sinusubukang isulat ang file “.
Kapag nagkaroon ng error, awtomatikong iniimbak ang isang numeric code sa errno global variable na tinukoy sa header na 'errno.h'. Maaaring gamitin ang code na ito upang matukoy ang error na naganap.
Ang sumusunod ay isang sipi na may mga error na maaaring mabuo ng write() function at tinukoy sa header na 'errno.h', kasama ang isang maikling paglalarawan ng bawat error at ang nauugnay na halaga ng integer:
| Kahulugan | Halaga sa errno | Error |
|---|---|---|
| MULI | labing-isa | Subukan muli. |
| EBADF | 9 | Maling numero ng file. |
| EDESTADDRREQ | 89 | Kinakailangan ang address ng patutunguhan. |
| EDQUOT | 122 | Lumampas sa quota. |
| EFAULT | 14 | Maling address. |
| EFBIG | 27 | Masyadong malaki ang file. |
| EINTR | 4 | Naputol ang system call. |
| SINGLE CHOICE | 22 | Di-wastong argumento. |
| EIO | 5 | I/O error. |
| ENOSPC | 28 | Walang natitirang espasyo sa device. |
| Itaas | 1 | Hindi pinapayagan ang operasyon. |
Ang pinakamadaling paraan upang makilala ang isang error ay ang pagbukas ng switch kung saan ang errno variable ay ang jump condition at ang bawat case ay isang error definition.
Susunod, tingnan natin ang isang halimbawa kung saan sinusubukan nating maglagay ng descriptor na may negatibong senyales, na nagreresulta sa isang error. Upang matukoy ang isang error, ginagamit namin ang kundisyong 'kung' na nakita namin sa nakaraang snippet. Upang matukoy ito, binubuksan namin ang isang switch na may tatlong pinakakaraniwang error na maaaring gawin ng function na ito.
#include#include
#include
#include
#include
#include
#include
walang bisa pangunahing ( )
{
int fd ;
int n ;
char buffer [ 1024 ] = 'Hello World' ;
fd = bukas ( 'Documents/example.txt' , O_RDWR ) ;
n = magsulat ( - 2 , at buffer , strlen ( buffer ) ) ;
kung ( n == - 1 ) {
lumipat ( errno ) {
kaso EBADF : {
printf ( 'Masamang numero ng file. Error: %i \n ' , errno ) ;
pahinga ; }
kaso SINGLE CHOICE : {
printf ( 'Di-wastong argumento. Error: %i \n ' , errno ) ;
pahinga ; }
kaso EIO : {
printf ( 'I/O error . Error: %i \n ' , errno ) ;
pahinga ; }
}
}
}
Tulad ng makikita natin sa sumusunod na figure, ang write() function ay nagbabalik ng error kapag ang isang di-wastong descriptor ay ipinasa bilang isang input argument. Ang value na nakuha mula sa errno variable ay ginagamit bilang isang jump condition na nagbibigay-daan sa amin na matukoy ang error kapag pumasok kami sa EBADF case.
Konklusyon
Sa artikulong ito ng Linux Hint, ipinakita namin sa iyo kung paano gamitin ang write() function para magsulat sa mga file. Ipinakita namin sa iyo ang syntax at ang teoretikal na paglalarawan ng function na ito. Ipinaliwanag din namin ang mga paraan ng pagtuklas ng error at pagkakakilanlan upang magkaroon ka ng mga kinakailangang tool at diskarte upang mabilis na malutas ang mga problemang ito.
Upang matulungan kang makita kung paano gumagana ang write(), ipinatupad namin ang paggamit ng function na ito sa mga praktikal na halimbawa na may mga code at larawan na nagpapakita ng paggamit nito at ng iba pang mga function sa pagpoproseso ng file.
Ipinakita rin namin sa iyo kung paano piliin ang file open mode para magpasok ng text sa simula o sa dulo ng file, at kung anong mga function ang available para baguhin ang mga attribute na ito.