[Powered by Google Translate] [File I / O]
[ჯეისონ Hirschhorn, ჰარვარდის უნივერსიტეტი]
[ეს არის CS50, CS50.TV]
როდესაც ჩვენ ვიფიქროთ, ფაილი, რაც შეეხება გონება Microsoft Word დოკუმენტის,
JPEG image, ან MP3 სიმღერა,
და ჩვენ ურთიერთქმედება თითოეულ ამ ტიპის ფაილების სხვადასხვა გზით.
მაგალითად, Word დოკუმენტის ჩვენ მისამართს ტექსტი
ხოლო ერთად JPEG გამოსახულება შეიძლება მოსავლის გარეთ კიდეები ან რეტუში ფერები.
Yet ქვეშ Hood ყველა ფაილი ჩვენს კომპიუტერში არიან და მეტი არაფერი
ვიდრე ხანგრძლივი თანმიმდევრობა zeros და პირობა.
ეს მდე კონკრეტული პროგრამა, რომელიც ურთიერთქმედებს ფაილი
გადასაწყვეტია როგორ გადაამუშავებს ამ ხანგრძლივი თანმიმდევრობა და წარადგინოს იგი მომხმარებელს.
ერთი მხრივ, დოკუმენტში შეიძლება შევხედოთ მხოლოდ ერთი ბაიტი,
ან 8 zeros და პირობა, და არიან ASCII ხასიათი ეკრანზე.
მეორეს მხრივ, bitmap გამოსახულება შეიძლება შევხედოთ 3 ბაიტი,
ან 24 zeros და პირობა,
და ინტერპრეტაცია მათ 3 თექვსმეტობითი ციფრები
რომ წარმოადგენენ ღირებულებათა წითელი, მწვანე, და ლურჯი
ერთ pixel of გამოსახულება.
რაც მათ შეიძლება გამოიყურებოდეს თქვენს ეკრანზე, მათი ძირითადი,
ფაილი მეტი არაფერი თანმიმდევრობა zeros და პირობა.
მოდით ჩაყვინთვის და გაიხსენოთ ჩვენ რეალურად მანიპულირება ამ zeros და პირობა
როდესაც საქმე წერილობით და კითხულობს ფაილიდან.
>> დავიწყებ ჩაამტვრია იგი ქვემოთ შევიდა მარტივი 3-ნაწილი პროცესში.
შემდეგი, მე ჩაყვინთვის შევიდა ორი კოდი მაგალითები, რომ დემონსტრირება ამ სამ ნაწილად.
და ბოლოს, მე განიხილავს პროცესი და ზოგიერთი მისი ყველაზე მნიშვნელოვანი დეტალები.
როგორც ნებისმიერი ფაილი, რომელიც ზის თქვენს კომპიუტერს,
პირველი, რაც უნდა გააკეთოთ მისი გახსნა.
In C ჩვენ ამას ვაკეთებთ მიერ გამოცხადების მომცეთ წინასწარგანსაზღვრული struct
რომელიც წარმოადგენს ფაილი დისკზე.
ამ ფუნქციის ზარი, ჩვენ ასევე გადაწყვიტოს გვინდა ვწერ ან წაკითხვის ფაილი.
შემდეგი, ჩვენ ფაქტობრივი კითხვა და წერა.
არსებობს მთელი რიგი სპეციალიზებული ფუნქციები შეგვიძლია გამოვიყენოთ ამ ნაწილში,
და თითქმის ყველა მათგანი იწყება წერილი F, რომელიც დგას ფაილი.
ბოლო, akin რომ პატარა წითელი X ზედა კუთხეში ფაილი გასახსნელად თქვენს კომპიუტერში,
ჩვენ დახურვა ფაილი საბოლოო ფუნქცია ზარი.
არის, რომ ჩვენ გვყავს ზოგადად იდეა, რასაც ჩვენ ვაპირებთ გავაკეთოთ,
მოდით ჩაყვინთვის შევიდა კოდი.
>> ამ დირექტორიაში, ჩვენ გვაქვს ორი C ფაილი და მათი შესაბამისი შესრულებადი ფაილი.
საბეჭდი მანქანა პროგრამა იღებს ერთ command line არგუმენტი,
სახელწოდება დოკუმენტის გვინდა შევქმნათ.
ამ შემთხვევაში, ჩვენ მოვუწოდებთ მას doc.txt.
მოდით პროგრამის გაშვება და შევა რამდენიმე ხაზები.
Hi. ჩემი სახელია ჯეისონ.
და ბოლოს, ჩვენ აკრიფოთ "დატოვა."
თუ ჩვენ ახლა ჩამოვთვალოთ ყველა ფაილი ამ დირექტორიაში,
ჩვენ ვხედავთ, რომ ახალი დოკუმენტი არსებობს მოუწოდა doc.txt.
სწორედ ფაილი ამ პროგრამის მხოლოდ შექმნა.
და რა თქმა უნდა, ეს ძალიან, მეტი არაფერი ხანგრძლივი თანმიმდევრობა zeros და პირობა.
თუ ჩვენ გახსნა ამ ახლის,
ჩვენ ვხედავთ 3 ხაზი კოდი ჩვენ შევიდა ჩვენი პროგრამა -
Hi. მაისი სახელია ჯეისონ.
ახლა კი რა რეალურად მიმდინარეობს, როდესაც typewriter.c გადის?
პირველი ხაზი ჩვენთვის საინტერესო არის ხაზზე 24.
ამ მიმართულებით, ვაცხადებთ ჩვენი ფაილის კურსორი.
ფუნქცია დააბრუნებს, რომ ამ მაჩვენებელმა, fopen, იღებს ორ არგუმენტს.
პირველი არის ფაილის სახელი ჩათვლით ფაილის გაფართოება საჭიროების შემთხვევაში.
შეგახსენებთ, რომ ფაილის გაფართოება გავლენას არ ახდენს ფაილის მისი ყველაზე დაბალი დონე.
ჩვენ ყოველთვის საქმე ხანგრძლივი თანმიმდევრობა zeros და პირობა.
მაგრამ ეს იმას გავლენა როგორ ფაილი ინტერპრეტირებული და რა განაცხადების გამოიყენება გასახსნელად მათ.
მეორე არგუმენტი fopen არის ერთი წერილი
რომ დგას, რაც ჩვენ ვგეგმავთ გავაკეთოთ შემდეგ ჩვენ გახსნა ფაილი.
არსებობს სამი ვარიანტი ამ არგუმენტს - W, R, და ა
ჩვენ მიერ არჩეული W ამ შემთხვევაში, რადგან ჩვენ გვინდა ჩაწერის ფაილი.
R, როგორც თქვენ ალბათ შეუძლია გამოიცნოს, არის წასაკითხად ფაილი.
და არის appending ფაილი.
მიუხედავად იმისა, რომ ორივე W და შეიძლება გამოყენებულ იქნეს წერილობით ფაილი
ღ დაიწყება წერილობით დასაწყისიდან ფაილი
და პოტენციურად გადავაწერო ნებისმიერი მონაცემი, რომელიც ადრე შენახული.
ჩვეულებრივ, ფაილის ჩვენ გახსნა, თუ ის არ არსებობს,
იქმნება ჩვენი დღევანდელი სამუშაო დირექტორია.
თუმცა, თუ ჩვენ გვინდა, რათა შეამოწმონ ან შექმნათ ფაილის სხვადასხვა ადგილას,
პირველ არგუმენტი fopen,
ჩვენ შეუძლია განსაზღვროს ფაილის გეზი გარდა ფაილის სახელი.
მიუხედავად იმისა, რომ პირველი ნაწილი ამ პროცესის მხოლოდ ერთი ხაზი კოდი ხანგრძლივი,
ის ყოველთვის კარგი პრაქტიკა მოიცავს მეორე კომპლექტი ხაზები
რომ შეამოწმოთ, რათა უზრუნველყოს, რომ ფაილი წარმატებით გახსნა ან შექმნილი.
თუ fopen ბრუნდება null, ჩვენ არ გვინდა, რომ გაყალბებას დააჩქაროს ჩვენი პროგრამის,
და ეს შეიძლება მოხდეს იმ შემთხვევაში, თუ ოპერაციული სისტემის მეხსიერება ღალატობს
ან თუ ჩვენ ვცდილობთ გახსნას ფაილის დირექტორიაში რომელიც არ გვქონდა უფლება.
>> ნაწილი ორი პროცესი ხდება საბეჭდი მანქანა ს ხოლო loop.
ჩვენ ვიყენებთ CS50 ბიბლიოთეკის ფუნქცია მისაღებად შეიტანენ მომხმარებელი,
და თუ ვთქვათ, რომ მათ არ სურთ დანებება პროგრამა,
ჩვენ ვიყენებთ ფუნქცია fputs მიიღოს სიმებიანი და დაწეროთ ის ფაილი.
fputs არის მხოლოდ ერთი მრავალი ფუნქციების ჩვენ შეეძლო ვწერ ფაილი.
სხვა მოიცავს fwrite, fputc, და კიდევ fprintf.
მიუხედავად კონკრეტული ფუნქცია ჩვენ დასრულდება მდე გამოყენებით, თუმცა,
ყველა მათგანი უნდა იცოდეთ, გავლით მათი არგუმენტები,
მინიმუმ ორი რამ -
რა უნდა დაწერილი და სადაც ის უნდა ჩაიწეროს.
ჩვენს შემთხვევაში, შემავალი არის სიმებიანი რომელიც უნდა წერილობითი
და FP არის მაჩვენებელი, ხელმძღვანელობს გვაძლევს, სადაც ჩვენ წერილობით.
ამ პროგრამაში, ნაწილი ორი პროცესი საკმაოდ მარტივია.
ჩვენ უბრალოდ აღების string საწყისი მომხმარებლის
და შეავსოთ იგი პირდაპირ ჩვენს ფაილი პატარა-ს არ შეყვანის Validation ან უსაფრთხოების ამოწმებს.
ხშირად, თუმცა, ნაწილს ორი დაიწყებს ნაყარი თქვენი კოდი.
საბოლოოდ, ნაწილი სამი არის on line 58, სადაც ჩვენ დახურვა ფაილი.
აქ ჩვენ მოვუწოდებთ fclose და გაიაროს ეს ჩვენი ორიგინალური ფაილის კურსორი.
მომდევნო ხაზი, ვბრუნდებით ნულოვანი, სასიგნალო ბოლოს ჩვენი პროგრამა.
და, დიახ, ნაწილი სამი არის იმდენად მარტივია, რომ.
>> მოდით გადაადგილება, რათა კითხულობს ფაილიდან.
თავში ჩვენს დირექტორია გვაქვს ფაილი სახელად printer.c.
მოდით გაუშვით ერთად ფაილის ჩვენ უბრალოდ შექმნილი -
doc.txt.
ეს პროგრამა, როგორც სახელი ვარაუდობს, უბრალოდ ამობეჭდოთ შინაარსი ფაილის გავიდა მას.
და იქ არის ეს.
ხაზების კოდი გვქონდა აკრეფილი ადრე და შენახული doc.txt.
Hi. ჩემი სახელია ჯეისონ.
თუ ჩვენ ჩაყვინთვის შევიდა printer.c,
ჩვენ ვხედავთ, რომ ბევრი კოდი გამოიყურება მსგავსი, რასაც ჩვენ მხოლოდ ფეხით ისეირნა წელს typewriter.c.
მართლაც ხაზი, სადაც 22 გავხსენით ფაილი,
და ხაზი 39, სადაც ჩვენ დახურული ფაილი,
ორივე თითქმის იდენტურია typewriter.c, გარდა fopen მეორე არგუმენტი.
ამჯერად ჩვენ კითხულობს ფაილიდან,
ამიტომ ჩვენ ავირჩიეთ R ნაცვლად w.
ამდენად, მოდით, ფოკუსირება მეორე ნაწილი პროცესს.
სტრიქონში 35, როგორც მეორე მდგომარეობა ჩვენს 4 loop,
ჩვენ ზარი fgets,
კომპანიონი ფუნქცია fputs საწყისი წინაშე.
ამჯერად ჩვენ გვაქვს სამ არგუმენტს.
პირველი არის მომცეთ მასივი გმირები სადაც სიმებიანი იქნება შენახული.
მეორე არის მაქსიმალური რაოდენობის სიმბოლოებს უნდა წაიკითხოთ.
და მესამე არის მომცეთ ფაილი რომელიც ჩვენ ვმუშაობთ.
თქვენ შეამჩნევთ, რომ ამისთვის loop დამთავრდა, როდესაც fgets ბრუნდება null.
არსებობს ორი მიზეზი, რომ ეს შეიძლება მომხდარიყო.
პირველი, შეცდომა შეიძლება არ მოხდა.
მეორე, და უფრო სავარაუდოა, ფაილის ბოლოში მიღწეულ იქნა და არა გმირები წაიკითხეს.
იმ შემთხვევაში თუ თქვენ გაინტერესებთ, ორი ფუნქცია არ არსებობს, რომ საშუალებას მოგვცემს ვუთხრა
რაც მიზეზი ის არის მიზეზი ამ კონკრეტულ null მაჩვენებელი.
და, გასაკვირი არ არის, რადგან მათ უნდა გავაკეთოთ ერთად მუშაობის ფაილი,
ორივე ferror ფუნქცია და feof ფუნქცია იწყება წერილი ვ.
>> და ბოლოს, სანამ ჩვენ დავასკვნათ, ერთი სწრაფი შენიშვნა შესახებ ფაილის დასასრულს ფუნქცია,
რომელიც, როგორც მხოლოდ აღნიშნა, წერია როგორც feof.
ხშირად თქვენ აღმოჩნდეთ გამოყენებით, ხოლო და მარყუჟების თანდათანობით წაიკითხა თქვენს გზას ფაილი.
ამდენად, თქვენ გჭირდებათ გზა დასრულდება ამ მარყუჟების მას შემდეგ მიაღწევს ბოლოს ეს ფაილი.
დარეკვის feof თქვენს ფაილის კურსორი და შემოწმების თუ ეს სიმართლეა
ყველაფერს გააკეთებს, რომ მხოლოდ.
ამდენად, ხოლო მარყუჟის რეჟიმში მდგომარეობა (! Feof (FP)) ალბათ მოსწონს შესანიშნავად შესაბამისი გადაწყვეტა.
თუმცა, ამბობენ, რომ ჩვენ ერთი ხაზი დაუტოვებიათ ჩვენს ტექსტურ ფაილს.
ჩვენ შევა ჩვენი ხოლო მარყუჟი და ყველაფერი იმუშავებს, როგორც დაგეგმილი.
მეორე ტურში მეშვეობით, ჩვენი პროგრამა შეამოწმებს თუ feof of FP მართალია,
მაგრამ - და ეს არის გადამწყვეტი წერტილი მესმის აქ -
ეს არ იქნება ნამდვილი მხოლოდ ამჟამად.
ეს იმიტომ, რომ მიზანი feof არ არის, რათა შეამოწმოს
თუ მომდევნო ზარი წაკითხვის ფუნქცია ექნება მოხვდა ფაილის ბოლოში,
არამედ შეამოწმოს თუ არა ფაილის ბოლოში უკვე მიღწეულია.
იმ შემთხვევაში, თუ ეს მაგალითად,
კითხულობს ბოლო ხაზი ჩვენი ფაილი მიდის შესანიშნავად შეუფერხებლად,
მაგრამ პროგრამა არ გაუკეთებია ვიცით, რომ ჩვენ მოხვდა ბოლოს ჩვენი ფაილი.
ეს არ არის, სანამ ის ჯერ ერთი დამატებითი წაკითხული, რომ ეს მრიცხველები ფაილის ბოლოში.
ამრიგად, სწორი მდგომარეობა იქნება შემდეგი:
fgets და მის სამ არგუმენტს - გამომავალი, ზომა გამომუშავება, და FP -
და ყველა რომ არ უტოლდება null.
ეს არის მიდგომა ავიღეთ წელს printer.c,
და ამ შემთხვევაში, შემდეგ მარყუჟის გასასვლელების,
თქვენ შეიძლება მოუწოდოს feof ან ferror ინფორმირება მომხმარებლის როგორც კონკრეტული მიზეზის ამისთვის არსებული ამ loop.
>> წერილობით და კითხულობს საწყისი ფაილი არის, მისი ძირითადი,
მარტივი 3-ნაწილი პროცესში.
პირველი, ჩვენ გახსნა ფაილი.
მეორე, ჩვენ დააყენა ზოგი რამ ჩვენს ფაილი ან გარკვეული რამ გარეთ.
მესამე, ჩვენ დახურვა ფაილი.
პირველი და ბოლო ნაწილები ადვილი.
შუა ნაწილი, სადაც სახიფათო პერსონალის მდგომარეობს.
და თუმცა ქვეშ Hood ჩვენ ყოველთვის საქმე ხანგრძლივი თანმიმდევრობა zeros და პირობა,
ეს იმას დაეხმაროს, როდესაც კოდირების დასამატებელი ფენა აბსტრაქცია
რომ თურმე თანმიმდევრობა შევიდა რაღაც, რომ უფრო მჭიდროდ ჰგავს, რასაც ჩვენ ვერ გამოიყენება ხედავს.
მაგალითად, თუ ჩვენ მუშაობის 24-bit Bitmap ფაილი,
ჩვენ სავარაუდოდ კითხულობს ან წერილობით სამი ბაიტი დროს.
რა შემთხვევაში, ეს იქნებოდა აზრი განსაზღვრა და სათანადოდ ასახელებს
struct რომ არის 3 bytes დიდი.
>> თუმცა მუშაობის ფაილი ჩანდეს რთული,
გამოყენებით მათ საშუალებას გვაძლევს რაღაც შთამბეჭდავი.
ჩვენ შეგვიძლია შევცვალოთ სახელმწიფო მსოფლიოს გარეთ ჩვენი პროგრამის,
ჩვენ შეგვიძლია შევქმნათ რაღაც რომ მიღმა ცხოვრების ჩვენი პროგრამის,
ან შეგვიძლია კი შეცვალოს ის, რაც შეიქმნა ჩვენი პროგრამა დაიწყო გაშვებული.
ინტერაქციაში ფაილი არის ჭეშმარიტად ძლიერი ნაწილი პროგრამების C.
და მე აღფრთოვანებული რომ ნახოთ თუ რას აპირებს შექმნას ერთად ის კოდი მოვა.
ჩემი სახელია ჯეისონ Hirschhorn. ეს არის CS50.
[CS50.TV]
>> [სიცილის]
Okay. ერთი მიიღოს. Here We Go.
როდესაც ჩვენ ვფიქრობთ of file - >> Oh, დაველოდოთ. უკაცრავად.
[სიცილის] Okay.
Hey არსებობს.
როდესაც ჩვენ ვფიქრობთ of file -
როდესაც ფიქრობთ ფაილი - Okay. მითხარით, როდესაც თქვენ მზად.
ოჰ, დიდი.
თუმცა კითხულობს საწყისი teleprompter ჩანდეს - არ. ჩემი ცუდი.