Files open karna, modes aur lifetimes
Read, write, append, update aur exclusive-creation modes choose karke stream ownership/close failures manage karein.
Is chapter mein8 sections
File kholna policy choose karta hai: existing data padhna, naya banana, contents replace karna ya append karna. Later write se pehle bhi file change ho sakti hai. Modes, failures aur open stream close karne ki responsibility ko jodenge.
1. Handle use se pehle acquisition check karein
fopen(name, mode) success par FILE pointer aur failure par null pointer return karta hai. Null pointer ko read, write ya fclose mein pass na karein. File naming, directories, permissions aur existing named files host properties hain. Standard C universal path separator, current-folder policy ya permission model define nahi karti.
2. Mode data-preservation policy state karta hai
| Mode | Effect |
|---|---|
r | Existing text file reading ke liye open; open na ho sake toh fail. |
w | Text file create ya existing file zero length par truncate. |
a | Needed ho toh create; writes then-current file end par force hoti hain. |
r+ | Existing text file ko initial truncation ke bina read/write. |
w+ | Read/write; pehle create ya truncate. |
a+ | Read aur append; needed ho toh create. Writes end par hi jaati hain. |
wx, wbx | C11 exclusive creation: file already exist ya create na ho sake toh fail. |
Binary access ya update ke liye rb ya w+b jaisi valid spelling use karein. x modifier eligible w/w+ creation forms ke liye hai, har mode ka universal suffix nahi. Sirf null return se failed fopen ka specific reason pata nahi chalta. Distinction matter kare toh chosen platform ke documented diagnostics use karein.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *stream = fopen("codedile-note.txt", "wx");
if (stream == NULL) return EXIT_FAILURE;
int status = EXIT_SUCCESS;
if (fputs("Learning C.\n", stream) == EOF) status = EXIT_FAILURE;
if (fclose(stream) == EOF) status = EXIT_FAILURE;
return status;
}
Example new note create karta hai aur existing note overwrite nahi karta. Suitable working folder mein run karein; note already present ho toh second run fail hoga. wx ko w karne se truncation allowed hogi. Pehle path-exists check aur phir w, same exclusive-creation operation nahi aur race introduce kar sakta hai.
3. Append writes control karta hai, saari reading nahi
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *stream = fopen("codedile-log.txt", "a");
if (stream == NULL) return EXIT_FAILURE;
int status = EXIT_SUCCESS;
if (fputs("next\n", stream) == EOF) status = EXIT_FAILURE;
if (fclose(stream) == EOF) status = EXIT_FAILURE;
return status;
}
Append mode intervening positioning ke baad bhi har write current end par direct karta hai. Concurrent writers ke whole application records atomic hone ka promise nahi. Update append stream mein intended reads se pehle explicitly position aur update-direction rules follow karein. Ek runtime ke habits se portable initial read position infer na karein.
4. Successful acquisition ko ownership decision chahiye
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
if (argc != 2) return EXIT_FAILURE;
FILE *stream = fopen(argv[1], "r");
if (stream == NULL) {
fputs("Could not open input.\n", stderr);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
int ch = fgetc(stream);
if (ch == EOF) {
if (ferror(stream)) status = EXIT_FAILURE;
else if (puts("empty") == EOF) status = EXIT_FAILURE;
} else if (printf("first=%c\n", ch) < 0) {
status = EXIT_FAILURE;
}
if (fclose(stream) == EOF) status = EXIT_FAILURE;
if (fflush(stdout) == EOF) status = EXIT_FAILURE;
return status;
}
Program apni opened stream own karke acquisition ke baad har path par close karta hai. Borrowed FILE pointer receive karne wala helper tabhi close kare jab documented contract mein ownership transfer ho. Fclose EOF return kare tab bhi stream file se disassociate hoti hai. Old handle par fclose retry ya flags inspect na karein; ab valid stream handle nahi. Ek pointer variable NULL karna uski accidental reuse avoid kar sakta hai, aliases update nahi karta.
5. Text aur binary stream translation describe karte hain
Text stream implementation rules ke under text represent karti hai; external representation program ke characters se different ho sakti hai, including line-ending translation. Binary stream standard ke binary-stream rules mein internal data ka transparent transfer support karti hai. Koi mode file format validate nahi karta. Serialized record read karne ke liye field widths, byte order, representation, size aur error contracts chahiye.
Primary references aur aage ki reading
- WG14 N1570 — public C11 committee draft: 7.21.2–7.21.3, 7.21.5.1, 7.21.5.3, 7.21.7. C17 baseline ke stable core provisions ke liye; final ISO publication nahi.
Aage badhne se pehle
- Opening mode reading, creation, replacement, append ya update behavior choose karta hai.
- Opening later write se pehle file modify ya fail kar sakti hai.
- Stream ownership mein appropriate close aur uski possible failure shamil hai.
In ideas ko alag rakhein
- Text mode / External schema
- Stream mode translation aur access behavior control karta hai; portable record format define nahi karta.
Naya destination create karte waqt existing file protect karne ke liye kaunsa mode aur failure policy choose karenge?
Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.Apni understanding check karein
Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.
Har choice ki explanation padhein
- Returned pointer NULL hai ya nahi.
✓ Sahi reasoning. NULL open karne ki failure batata hai; use valid stream maankar use karna contract violate karega.
- Returned pointer EOF ke barabar hai ya nahi.
EOF doosre I/O interfaces ka integer macro hai, fopen ka failure pointer nahi.
- Sirf filename mein dot hai ya nahi.
Filename ka appearance opening successful hone ka proof nahi.
C17
Earlier edition ka quick reference
Existing section links aur saved passages ke liye retained. Connected ideas expanded lessons mein hain; exact corrections source review mein recorded hain.
C files ko ek opaque FILE * handle ke through treat karti hai jo fopen(filename, mode) se milta hai:
| Mode | Meaning |
|---|---|
"r" |
Read (file already exist honi chahiye) |
"w" |
Write (file create karta hai, ya agar exist karti hai toh truncate kar deta hai) |
"a" |
Append (agar file exist nahi karti toh create kar deta hai) |
"r+" |
Read aur update |
"w+" |
Write aur update (truncate karta hai) |
"a+" |
Append aur update |
"b" append karna (jaise, "rb") file ko binary mode mein open karta hai, jisse woh newline translation disable ho jaati hai jo kuch platforms \n aur \r\n ke beech otherwise perform karte hain.
Reading aur Writing
fprintf/fscanfformatted text handle karte hain, apne console counterparts jaise hi.fgets/fputsline-oriented text handle karte hain.fread/fwritesupplied byte size ke elements transfer karte hain aur complete elements ki count return karte hain. Yeh text streams par bhi kaam karte hain; text translations opening mode par depend karti hain.
Random Access
fseek, ftell aur rewind stream positions manage karte hain. Text stream mein portable fseek offset 0 use karta hai, ya us file ke ftell se mile value ko SEEK_SET ke saath; text-stream ftell value zaroori nahi byte count ho. Binary streams character offsets use karte hain, lekin SEEK_END meaningfully support karna required nahi. fseek/ftell failures check karein; fgetpos/fsetpos file position aur stream ki multibyte conversion state (agar ho) save aur restore karte hain. fclose ka EOF return check karein, especially writing ke baad. Failure par bhi stream disassociated ho jaati hai; old stream use ya fclose retry na karein. Read failure ke baad feof/ferror test karein, reading se pehle prediction ke liye nahi.
Update aur binary streams: + update stream mein output se input par jaane se pehle fflush ya positioning operation chahiye. Input se output par jaane se pehle positioning operation chahiye, jab tak preceding input ne end-of-file encounter na kiya ho. Binary mode text translations avoid karta hai; raw structure dumps ko padding, byte order ya numeric representations ke across portable nahi banata.
Agla idea padhne ke liye tayyar?
Mark this chapter as read whenever you feel ready.