>> Tagapagsalita: Sa ngayon, malamang na ang karamihan ng iyong mga programa
ay isang bit panandalian.
Nagpapatakbo ka ng isang programa tulad ng Mario o matakaw.
Ito ay isang bagay, ito marahil senyales ang user para sa ilang mga impormasyon,
i-print ang ilang mga output sa screen, ngunit pagkatapos ay kapag ang iyong programa ay higit sa,
may tunay na walang katibayan doon ito ay kailanman tumakbo sa unang lugar.
Ibig kong sabihin, sigurado, maaari kang magkaroon ng kaliwa buksan ito sa terminal na window,
ngunit kung i-clear mo ang iyong screen, may talagang walang katibayan na ito umiiral.
Wala kaming isang paraan ng pag-iimbak persistent impormasyon, impormasyon
na umiiral pagkatapos ng aming program ay tumigil sa pagtakbo,
o kami ay may hindi hanggang sa puntong ito.
Sa kabutihang palad bagaman, c ginagawa magbigay sa amin ng kakayahan
upang gawin ito sa pamamagitan ng pagpapatupad isang bagay na tinatawag
isang file, ang isang istraktura na talaga ay kumakatawan sa isang file na nais mong i-double
mag-click sa iyong computer, kung ikaw ay ginagamit sa isang graphical user na kapaligiran.
Karaniwan kapag nagtatrabaho may c, hindi namin talaga
pumapasok sa trabaho ay may mga payo sa files-- file stars--
maliban para sa isang maliit na piraso kapag kami makipag-usap tungkol sa isang pares
ng pag-andar na gumagana sa mga payo file.
Hindi mo na kailangan upang magkaroon ng tunay na utong masyadong malalim sa pag-unawa mga payo
sa kanilang sarili.
May isang maliit na maliit bit kung saan kami ay makipag-usap tungkol sa mga ito,
ngunit sa pangkalahatan maghain payo at payo, habang magkakaugnay,
ay hindi eksakto ang parehong bagay.
>> Ngayon kung ano ang ibig sabihin ako kapag Sinasabi ko persistent data?
Ano ang persistent data?
Bakit pag-aalaga namin ang tungkol dito?
Sabihin nating, halimbawa, na ikaw ay nagpapatakbo ng isang programa
o mo na muling pagsusulat ng isang programa na ay isang laro,
at nais mong subaybayan ng lahat ng mga gumagalaw ng gumagamit
kaya na siguro kung may mangyaring hindi mabuti, maaari mong suriin ang mga file pagkatapos ng laro.
Iyon ay kung ano ang ibig sabihin namin kapag kami makipag-usap tungkol persistent data.
>> Sa kurso ng pagpapatakbo ng iyong programa, ang isang file ay nilikha.
At kapag ang iyong programa ay tumigil sa pagtakbo,
Umiiral pa rin ang file sa iyong system.
At maaari naming tumingin sa ito at suriin ito.
At kaya ay itinakda sa programa na ay lumikha ng ilang mga paulit-ulit na data,
umiiral data pagkatapos ng programa ay tapos na tumatakbo.
>> Ngayon ang lahat ng mga function na ang trabaho sa paglikha ng mga file at pagmamanipula
ang mga ito sa iba't ibang paraan manirahan sa standard io.h,
kung saan ay isang header na file malamang na napuntahan mo na pound
kabilang sa tuktok ng pretty magkano ang lahat ng iyong mga programa
dahil naglalaman ito ng isa sa mga pinaka-kapaki-pakinabang na pag-andar para sa amin,
printf, na nagbibigay-daan din nabubuhay sa standard io.h.
Kaya hindi mo na kailangan na libra isama anumang karagdagang mga file marahil
upang gumana sa mga payo file.
>> Ngayon bawat solong function file pointer, o bawat solong file I / O, input output
function, tumatanggap bilang isa ng kanyang mga parameter o input
isang pointer-- file maliban para sa isa, fopen, na
ay kung ano ang ginagamit mo upang makuha ang file pointer sa unang lugar.
Ngunit pagkatapos mong binuksan ang maghain at makakuha ka ng mga payo file,
maaari mong pagkatapos ay ipasa ang mga ito bilang argumento sa iba't-ibang mga pag-andar
kami ay pagpunta sa makipag-usap tungkol ngayon, pati na rin ang marami pang iba
sa gayon ay maaari kang magtrabaho kasama ng mga file.
>> Kaya may mga anim na pretty karaniwang mga pangunahing iyan
na kami ay pagpunta sa makipag-usap tungkol sa ngayon.
fopen at kasamahan nito function na fclose, fgetc
at ang kasama nito function na fputc, at fread at ang kasama nito function,
fwrite.
Kaya sabihin makakuha ng karapatan sa mga ito.
>> fopen-- ano ang ginagawa nito?
Well, ito ay bumubukas ng isang file at ito nagbibigay sa iyo ng isang file pointer sa mga ito,
upang maaari mong pagkatapos ay gamitin na maghain pointer bilang isang argument
sa alinman sa mga iba pang mga I / O function file.
Ang pinaka importanteng bagay tandaan na may fopen
ay na pagkatapos mong binuksan ang maghain o ginawa ng isang tawag na tulad ng isa dito,
kailangan mong suriin upang matiyak na na ang pointer na ba kayong bumalik
ay hindi kapantay sa null.
Kung hindi mo pa napanood ang video sa mga payo, ito ay hindi maaaring magkaroon ng kahulugan.
Ngunit kung susubukan mo at dereference isang null pointer pagpapabalik,
Marahil ay magdusa ang iyong programa isang segmentation [hindi marinig].
Gusto naming siguraduhin na kami Nakatanggap ng isang lehitimong pointer likod.
Ginagamit ng karamihan ng mga oras na kami ay may tapat na paraan ng isang lehitimong pointer sa likod
at ito ay hindi isang problema.
>> Kaya paano namin gumawa ng isang tawag sa fopen?
Mukhang medyo marami tulad nito.
File star ptr-- ptr pagiging isang generic pangalan para sa file pointer-- fopen
at pumasa kami sa loob ng dalawang mga bagay-bagay, ang isang pangalan ng file at isang operasyon nais naming idaos.
Kaya maaari naming magkaroon ng isang tawag na ganito ang hitsura this-- file star ptr 1 ay katumbas fopen
file1.txt.
At ang mga operasyon na pinili ko ay r.
>> Kaya kung ano ang tingin mo r ay dito?
Ano ang mga uri ng mga bagay na aming maaaring magawa sa mga file?
Kaya r ay ang operasyon na tayo piliin kapag gusto naming basahin ang isang file.
Kaya gusto namin talaga kapag gumawa kami ng isang tawag na tulad nito
maging sa pagkuha ng ating sarili ang isang file pointer tulad na pagkatapos namin ay maaaring basahin ang impormasyon
mula file1.txt.
>> Katulad nito, maaari naming buksan ang file 2.txt para sa pagsusulat at sa gayon ay maaari naming ipasa ptr2,
ang file pointer na aking nilikha dito, bilang isang argument sa anumang function na
magsusulat ng impormasyon sa isang file.
At katulad ng pagsusulat, may din ang pagpipilian upang isama, a.
Ang pagkakaiba sa pagitan ng pagsulat at appending
pagiging na kapag ka magsulat sa isang file, kung gumawa ka ng isang tawag sa fopen para sa pagsusulat
at mayroon na file iyan, pagpunta upang patungan ang buong file.
Ito ay pagpunta sa simulan sa simula pa lamang,
pagtanggal ng lahat ng mga impormasyon na na doon.
>> Sapagkat kung bubuksan mo ito para appending, ito ay pumunta sa katapusan ng file
kung may naka-text sa ito o impormasyon sa mga ito,
at ito ay pagkatapos simulan pagsulat mula doon.
Kaya hindi mo mawawala ang anumang mga impormasyon na iyong ginawa bago.
Kung nais mong magsulat o magkabit uri ng depende sa sitwasyon.
Ngunit marahil mo na alam kung ano ang tamang operasyon ay kapag dumating ang oras.
Kaya na fopen.
>> Ano ang tungkol fclose?
Well, medyo lang, fclose lamang ang tumatanggap ng file pointer.
At bilang maaari mong asahan, magsasara na file.
At sa sandaling isinara namin ang isang file, hindi namin maaari magsagawa ng anumang higit pang mga file I / O pag-andar,
pagbabasa o pagsusulat, sa file na iyon.
Mayroon kaming upang muling buksan ang maghain ng isa pang oras upang
upang magpatuloy sa pagtatrabaho sa ito gamit ang mga function I / O.
Kaya fclose paraan tapos na kami nagtatrabaho sa mga file na ito.
At ang lahat na kailangan namin upang pumasa sa ay ang pangalan ng isang file pointer.
Kaya sa loob ng ilang mga slide na nakalipas, kami fopened file 1 dot text para sa pagbabasa
at itinalaga namin na maghain pointer sa ptr1.
Ngayon nagpasya kaming hindi namin tapos na pagbabasa mula sa file na iyon.
Hindi natin kailangan na gawin ang anumang higit pa sa mga ito.
Maaari lang namin fclose ptr1.
At katulad, maaaring namin fclose ang iba pang mga bago.
Lahat tama.
Kaya na pagbukas at pagsara.
Ang mga ay ang dalawang pangunahing pagsisimula ng operasyon.
>> Ngayon gusto naming aktwal gawin ang ilang mga kawili-wiling mga bagay-bagay,
at ang unang function na bibigyan namin ng makita na gawin iyon ay fgetc--
maghain makakuha ng isang character.
Iyon ay kung ano fgetc pangkalahatan ay isalin sa.
Ang layunin sa buhay ay ang basahin ang susunod na character,
o kung ito ay ang iyong tunay unang tawag sa fgetc
para sa isang partikular na file, ang unang character.
Ngunit pagkatapos ay matapos na, mong makuha ang susunod na isa,
ang tunay susunod na karakter ng file na iyon, at mga tindahan ng mga ito sa isang variable ng character.
Bilang ko na ginawa namin dito, char ch katumbas fgetc,
pumasa sa pangalan ng isang file na pointer.
Muli, ito ay tunay mahalaga dito upang tandaan
na sa order na magkaroon ng ang operasyon na ito ay magtagumpay,
mismo ang file pointer must've binuksan para sa pagbabasa.
Hindi namin maaaring basahin ang isang character mula sa isang file pointer na kami binuksan para sa pagsusulat.
Kaya na ang isa sa mga limitasyon ng fopen, di ba?
Mayroon kaming upang rendahan ang ating mga sarili upang lamang gumaganap
isang operasyon na may isang file pointer.
Kung gusto naming basahin at isulat mula sa parehong file,
gusto naming magkaroon ng open dalawang magkahiwalay payo file sa parehong file--
isa para sa pagbabasa, isa para sa pagsusulat.
>> Kaya muli, ang tanging dahilan Magdadala ako na hanggang ngayon ay
dahil kung kami ay pagpunta sa gumawa ng isang tawag upang fgetc, na file pointer must've
binuksan para sa pagbabasa.
At pagkatapos ay medyo simple, lahat ng kailangan naming gawin
ay pumasa sa pangalan ng file pointer.
Kaya char ch katumbas fgetc ptr1.
>> Iyan ay pagpunta sa kumuha sa amin mga susunod character--
o muli, kung ito ay ang unang oras na ginawa namin ang tawag na ito,
ang unang character-- ng kahit anong file ay nakatutok sa pamamagitan ptr1.
Alalahanin na na file 1 dot text.
Makikita ito makuha ang unang character ng na at kami ay mag-imbak ang mga ito sa variable ch.
Medyo tapat.
Kaya namin lamang tumingin sa tatlong function at naka-namin
maaaring gawin ang isang bagay na medyo kapong baka.
>> Kaya kung namin kunin ang kakayahan ng pagkuha ng isang character
at loop namin it-- kaya namin patuloy na makakuha ng mga character
mula sa isang file sa loob at paulit-over-- namin ngayon
maaaring basahin ang bawat solong character ng isang file.
At kung i-print namin ang bawat karakter kaagad pagkatapos naming basahin ito,
kami ngayon basahin mula sa isang file at naka-print na nilalaman nito sa screen.
Mabisa kaming concatenated file na sa screen.
At na kung ano ang Linux command cat ay.
>> Kung nagta-type ka cat sa pangalan ng file, ito ay i-print out ang buong nilalaman
ng file sa iyong terminal na window.
At kaya ito maliit na loop dito, lamang ng tatlong linya ng code,
ngunit ito ay epektibong mga duplicate ng Linux command cat.
Kaya ito syntax baka tumingin ng isang maliit na kakaiba,
ngunit narito ang kung ano ang nangyayari dito.
Habang ch katumbas fgetc, ptr ay hindi katumbas ng EOF-- ito ay isang buong maraming sinabi,
ngunit break ni ito down lamang ipaalam kaya malinaw sa mga syntax.
Pinagsama-sama ko para sa kapakanan ng space,
kahit na ito ay isang maliit na syntactically madaya.
>> Kaya ito bahagi sa green karapatan ngayon, kung ano ang ginagawa nito?
Well, ito lamang ang aming fgetc call, di ba?
Nakita namin na ang bago.
Ito ay pagkuha ng isa karakter mula sa file.
Pagkatapos ay ihambing natin na karakter laban EOF.
EOF ay isang espesyal na halaga na tinukoy sa standard io.h, na
ang wakas ng file character.
Kaya talaga kung ano ang nangyayari sa mangyayari ay ito loop ay basahin ang isang karakter,
ihambing ito sa EOF, ang pagtatapos ng file character.
Kung hindi sila tumutugma, kaya kami ay hindi naabot na ang dulo ng file,
ipapakita namin i-print na mga character out.
Pagkatapos ay magpapadala kami bumalik sa simula ng loop muli.
Kami makakuha ng isang character, suriin laban EOF, i-print ito, at iba pa
at iba pa at iba pa, looping sa pamamagitan sa na paraan
hanggang naabot na namin ang dulo ng file.
At pagkatapos ay sa pamamagitan ng puntong iyon, ay may naka-print na namin
ang kabuuang nilalaman ng mga file.
Kaya muli, na lamang ang nakita natin fopen, fclose, at fgetc
at na maaari naming doblehin isang Linux terminal command.
>> Tulad ng sinabi ko sa simula, nagkaroon kami fgetc at fputc,
at fputc ay ang kasamahan function ng fgetc.
At ito, bilang maaari mong isipin, ito ay ang katumbas ng sulat.
Ito ay nagpapahintulot sa amin upang makapagsulat ng isang solong character sa isang file.
>> Muli, ang caveat na, lamang tulad ng ito ay may fgetc, ang file
na kami ay sumusulat upang must've naging binuksan para sa pagsulat o para appending.
Kung sinubukan namin at gamitin fputc sa isang file na iyong binuksan namin para sa pagbabasa,
kami ay pagpunta sa magdusa isang piraso ng isang pagkakamali.
Ngunit ang tawag ay medyo simple.
fputc capital A ptr2, ang lahat ng na ang pagpunta sa gawin ay ito ay
pagpunta sa isulat ang mga titik sa A sa file 2 tuldok
teksto, na kung saan ay ang pangalan ng maghain na binuksan namin at bibigyan ng
ang pointer sa ptr2.
Kaya kami ay pagpunta sa magsulat ng isang capital A sa file 2 dot text.
At kami ay sumulat ng isang tandang point upang maghain 3 dot
teksto, na kung saan ay nakatutok sa pamamagitan ptr3.
Kaya muli, medyo tapat dito.
>> Ngunit ngayon maaari naming gawin ang isa pang bagay.
Mayroon kaming halimbawang ito lamang namin ay pagpunta sa paglipas ng
tungkol sa pagiging magagawang ginagaya ang pusa Linux command, ang isa na mga print out
sa screen.
Well, ngayon na kami ay may kakayahan basahin character mula sa mga file
at isulat ang mga character sa mga file, bakit hindi kami kapalit na lang
tumawag sa printf sa isang tawag sa fputc.
>> At ngayon nauulit na namin ang cp, isang tunay pangunahing utos Linux
na usapan natin ang tungkol sa mga paraan mahaba ang nakalipas sa Linux command video.
Na namin ang epektibong Nadoble na karapatan dito.
Kami ay nagbabasa ng isang character at pagkatapos ay hindi namin pagsulat na character sa isa pang file.
Nagbabasa mula sa isang file, pagsulat sa iba, nang paulit-ulit
at sa muli hanggang maabot namin EOF.
Mayroon kaming hanggang sa dulo ng maghain aming sinusubukan upang kopyahin mula sa.
At sa pamamagitan ng na kami ay may nakasulat na ang lahat ng ang mga character na kailangan namin upang ang file
na kami ay sumusulat upang.
Kaya ito ay cp, ang Linux kopya command.
>> Sa simula pa lamang ng ang video na ito, nagkaroon ako ng caveat
na kami ay makipag-usap sa isang maliit na piraso tungkol sa mga payo.
Narito ang partikular na kung saan hindi namin pagpunta sa makipag-usap tungkol sa mga payo
bilang karagdagan sa mga payo file.
Kaya mukhang uri ng nakakatakot ang function na ito.
Ito ay nakuha ng ilang mga parameter.
Mayroong maraming nagaganap dito.
May isang pulutong ng mga iba't-ibang kulay at teksto.
Ngunit ang tunay, ito lamang ay ang generic na bersyon ng fgetc
na nagbibigay-daan sa amin upang makakuha ng anumang halaga ng impormasyon.
Maaari itong maging isang bit na walang kakayahan kung hindi namin pagkuha ng mga character ng isa sa isang panahon,
iterating sa pamamagitan ng file isang character sa isang pagkakataon.
Hindi ba ito ay nicer upang makakuha ng 100 sa isang pagkakataon o 500 sa isang pagkakataon?
>> Well, fread at ang kasama nito pag-andar fwrite, na kung saan namin makipag-usap tungkol sa
sa isang segundo, nagpapahintulot sa amin upang gawin lamang na.
Maaari naming basahin ang isang arbitrary na halaga ng impormasyon mula sa isang file
at iniimbak namin ito sa isang lugar na pansamantala.
Sa halip na ma-lamang magkasya ito sa isang solong variable,
maaaring kailangan upang mag-imbak ang mga ito sa isang array.
At ito, ipasa namin sa apat na argumento sa fread-- isang pointer
sa lokasyon kung saan hindi namin pagpunta sa tindahan ng impormasyon,
kung paano malaki ang bawat yunit ng impormasyon ay, kung gaano karaming mga yunit ng impormasyon
gusto naming makuha, at mula na file na gusto naming makuha ang mga ito.
Marahil pinakamahusay na larawan may isang halimbawa dito.
Kaya sabihin natin na ipinahahayag natin isang hanay ng mga 10 integer.
Lamang na ipinahayag namin sa stack nagkataon int arr 10.
Kaya na medyo tapat.
Kung anong ginagawa namin kahit na ngayon ay ang frecall ay kami ay pagbabasa laki ng int
ulit 10 bytes ng impormasyon.
Sukat ng int pagkatao four-- na ang laki ng isang integer sa c.
>> Kaya kung ano ang aming ginagawa ay kami ay pagbabasa 40 bytes halaga ng impormasyon
mula sa mga file na nakatutok sa pamamagitan ptr.
At kami ay nag-iimbak ng mga 40 bytes sa tabi-tabi
na kung saan kami ay isantabi 40 bytes halaga ng memory.
Sa kabutihang palad, mayroon na tapos na namin na sa pamamagitan ng deklarasyon arr, na array doon.
Iyon ay kaya ng mga humahawak 10 four-byte units.
Kaya sa kabuuan, ito ay maaaring humawak ng 40 bytes halaga ng impormasyon.
At ngayon kami ay pagbabasa 40 bytes ng impormasyon mula sa mga file,
at kami ay nag-iimbak ito sa arr.
>> Pagpapabalik mula sa video sa mga payo na ang pangalan ng isang array, tulad ng mga arr,
ay talagang lamang ang pointer sa unang elemento nito.
Kaya kapag kami pumasa sa arr doon, tayo ay, sa katunayan, ang pagpasa sa isang pointer.
>> Katulad din na maaari naming gawin this-- namin na hindi namin kinakailangang
kailangang i-save ang aming buffer sa stack.
Kami ay magilas din maglaan isang buffer na tulad nito, ang paggamit ng malloc.
Tandaan, kapag tayo magilas na magtalaga ng memory,
kami ay nagse-save ang mga ito sa magbunton, hindi ang stack.
Ngunit ito ay isang buffer pa rin.
>> Ito pa rin, sa kasong ito, ay may hawak na 640 bytes ng impormasyon
dahil ang isang double tumatagal ng hanggang sa walong bytes.
At hinihingi namin para sa 80 ng mga ito.
Gusto naming magkaroon ng space upang i-hold 80 doubles.
Kaya 80 beses 8 ay impormasyon 640 bytes.
At na call to fread ay pagkolekta ng 640 bytes ng impormasyon
mula sa mga file na nakatutok sa pamamagitan ptr at pag-imbak nito ngayon sa arr2.
>> Ngayon ay maaari naming ring ituring fread tulad ng isang call to fgetc.
Sa kasong ito, lamang kami ay nagsisikap na makakuha ng isang character mula sa file.
At hindi namin kailangan ang isang array upang i-hold ang isang character.
Maaari lang namin iimbak ito sa isang variable ng character.
>> Ang mahuli, bagaman, ay na kapag kami na lang ay isang variable,
kailangan namin upang pumasa sa address ng variable na
dahil pagpapabalik na ang unang argumento sa fread
ay isang pointer sa lokasyon at memory kung saan nais namin upang mag-imbak ng impormasyon.
Muli, ang pangalan ng isang array ay isang pointer.
Kaya hindi namin kailangan na gawin ang ampersand array.
Ngunit c, ang character c dito, ito ay hindi isang array.
Ito ay isang variable lang.
At kaya kailangan namin upang pumasa sa isang ampersand c upang ipahiwatig
na iyon ang address kung saan nais namin upang mag-imbak ito sa isang byte ng impormasyon,
ang isang ito ng character na kami ay pagkolekta mula ptr.
Fwrite-- kukunin ko na pumunta sa pamamagitan ng ito ng kaunti pa
quickly-- ay medyo marami ang eksaktong katumbas ng fread
maliban ito ay para sa pagsusulat sa halip ng pagbabasa, lamang
tulad ng mga other-- namin ay bukas at isara, makakuha ng isang character,
magsulat ng isang character.
Ngayon ay makakuha ng arbitrary halaga ng impormasyon,
karapatan arbitrary halaga ng impormasyon.
Kaya tulad ng dati, magagawa namin magkaroon ng isang hanay ng mga 10 integer
na kung saan kami ay mayroon ng impormasyon na nakalagay, marahil.
>> Ito ay malamang na ang ilang mga linya ng code na dapat pumunta sa pagitan ng dalawang
kung saan punan ko arr sa isang bagay na mahalaga.
Punan ko ito sa 10 iba't ibang mga integer.
At sa halip, kung ano Ako ginagawa pagsusulat mula arr
at pagkolekta ng impormasyon mula arr.
At aking iniinom na impormasyon at ilagay ito sa ang file.
>> Kaya sa halip na ito sa pagiging mula sa ang file sa buffer,
ngayon kami ay pagpunta mula sa ang buffer sa file.
Kaya lamang ang reverse.
Kaya muli, tulad lamang ng dati, maaari naming Mayroon ding isang kimpal na tipak ng memory
na kami magilas inilalaan at basahin mula sa na
at isulat iyon sa mga file.
>> At kami ay mayroon din ng isang solong variable may-hawak na isang byte
ng impormasyon, tulad ng isang character.
Ngunit muli, kailangan namin upang pumasa sa ang address ng variable na
kapag gusto naming basahin mula dito.
Kaya maaari naming isulat ang impormasyon nakita namin sa address na iyon
sa file pointer, ptr.
>> Mayroong maraming iba pang mga mahusay na file I / O function
na gawin ang iba't-ibang mga bagay-bagay maliban mga ko na usapan natin ang tungkol sa ngayon.
Ang isang pares ng mga maaari mong mahanap ang kapaki-pakinabang
mga fgets at fputs, na kung saan ay ang katumbas
ng fgetc at fputc ngunit para sa pagbabasa isang solong string mula sa isang file.
Sa halip ng isang solong character, ito ay basahin ang isang buong string.
fprintf, na kung saan ay nagbibigay-daan talaga mong gamitin ang printf upang makapagsulat sa file.
Tulad lamang upang maaari mong gawin ang mga ang pagpapalit ng variable gamit
ang mga placeholder porsiyento i at percent d, at iba pa, na may printf
maaari mong parehas gawin ang printf string at i-print ang isang bagay
tulad na sa isang file.
>> fseek-- kung mayroon kang isang DVD player ay ang pagkakatulad Karaniwan ang gamit ko here--
ay uri ng tulad ng paggamit ng iyong rewind at fast forward
mga pindutan upang ilipat sa paligid ng pelikula.
Gayundin, maaari mong ilipat sa paligid ng file.
Isa sa loob ng mga bagay-bagay na istraktura ng file
na c gagawa para sa iyo ay isang tagapagpahiwatig ng kung saan ikaw ay nasa file.
Sigurado ka sa pinakadulo simula, sa byte zero?
Sigurado ka sa byte 100, byte 1000, at iba pa?
Maaari mong gamitin ang fseek na nagkataon ilipat na indicator pasulong o paatras.
>> At ftell, muli katulad ng isang DVD player,
ay tulad ng isang maliit na orasan na nagsasabi kung paano mo maraming minuto at segundo ka
Isasama sa isang partikular na pelikula.
Sa katulad na paraan, sinasabi sa ftell mo kung paano maraming bytes ikaw ay sa ang file.
feof ay isang iba't ibang mga bersyon ng mga tiktik kung na sa iyo
naabot na ang dulo ng file.
At ferror ay isang function na maaari mong gamitin
upang tuklasin kung ang isang bagay ay maling naganap nagtatrabaho sa isang file.
Muli, ito ay lamang scratching sa ibabaw.
Mayroong maraming higit pa file pa rin ako / O function sa standard io.h.
Ngunit marahil ito makakakuha ka ng nagsimula nagtatrabaho sa mga payo file.
Ako Doug Lloyd.
Ito ang cs50.