>> დინამიკები: ჯერჯერობით, ეს სავარაუდოდ, რომ ყველაზე თქვენი პროგრამები
უკვე ცოტა ეფემერული.
თქვენ აწარმოებს პროგრამა მოსწონს Mario და ხარბ.
ეს იმას, რომ რაღაც, იქნებ მოთხოვნა მომხმარებლის გარკვეული ინფორმაცია,
ბეჭდვა ზოგიერთი გამომავალი ეკრანზე, მაგრამ მაშინ, როცა თქვენი პროგრამა დასრულდა,
იქ ნამდვილად არ მტკიცებულება არსებობს იგი ოდესმე აწარმოებს, პირველ რიგში.
ვგულისხმობ, რა თქმა უნდა, თქვენ შეიძლება არ დაუტოვებიათ ის გახსნა ტერმინალის ფანჯარა,
მაგრამ თუ გარკვევა თქვენს ეკრანზე, არსებობს ნამდვილად არსებობს მტკიცებულება, რომ იგი არსებობდა.
ჩვენ არ გვაქვს საშუალება შენახვის მუდმივი ინფორმაციას,
რომ არსებობს მას შემდეგ, რაც ჩვენი პროგრამა შეწყდა,
ან ჩვენ არ გვაქვს, რომ ამ ეტაპზე.
საბედნიეროდ, თუმცა, გ აკეთებს მოგვაწოდოთ უნარი
ამის გაკეთება, ახორციელებს რაღაც მოუწოდა
ფაილი, სტრუქტურა, რომელიც, ძირითადად, წარმოადგენს ფაილი, რომელიც თქვენ ორმაგად
დააჭირეთ თქვენს კომპიუტერში, თუ თქვენ გამოიყენება გრაფიკული მომხმარებლის გარემოში.
საერთოდ, როდესაც მუშაობა გ, ჩვენ, ფაქტობრივად,
აპირებს მუშაობის მითითებას ფაილები ფაილი stars--
გარდა ცოტა როდესაც ვსაუბრობთ რამდენიმე
ფუნქციებს, მუშაობა ფაილი მითითებას.
თქვენ არ უნდა ნამდვილად გათხრილი ძალიან ღრმად გაგება პოინტერები
თავს.
აქ არის პატარა teeny ცოტა სადაც ჩვენ ვსაუბრობთ, მათ შორის,
მაგრამ ზოგადად წარადგინოს მითითებას და მითითებას, ხოლო ერთმანეთთან დაკავშირებული,
არ არის ზუსტად იგივე.
>> ახლა რას ვგულისხმობ, როცა მე ვიტყვი, მუდმივი მონაცემები?
რა არის მუდმივი მონაცემები?
რატომ აინტერესებთ ის?
ამბობენ, რომ, მაგალითად, თქვენ გაშვებული პროგრამა
ან თქვენ გადაწერილი პროგრამა, რომელიც არის თამაში,
და გსურთ, რომ შევინარჩუნოთ სიმღერა ყველა მომხმარებლის გადადის
ასე რომ, შესაძლოა, თუ რაღაც მიდის არასწორი, თქვენ შეგიძლიათ განიხილოს ფაილი შემდეგ თამაში.
ეს არის ის, რასაც ჩვენ ვგულისხმობთ, როდესაც ჩვენ ვისაუბროთ მუდმივი მონაცემები.
>> რა თქმა უნდა, გაშვებული პროგრამა, ფაილი არის შექმნილი.
და როდესაც თქვენი პროგრამა შეჩერდა გაშვებული,
რომ ფაილი არსებობს თქვენს სისტემაში.
ჩვენ შეგვიძლია შევხედოთ მას, და შეამოწმოს იგი.
და ისე, რომ პროგრამა იქნება მითითებული შექმნეს გარკვეული მუდმივი მონაცემებით,
არსებობს მონაცემები შემდეგ პროგრამა დაასრულა გაშვებული.
>> ახლა ყველა ამ ფუნქციას, რომ მუშაობა შექმნა ფაილი და მანიპულირების
მათ სხვადასხვა გზები ცხოვრობს სტანდარტული io.h
რომელიც არის header ფაილი, რომელიც თქვენ სავარაუდოდ იყო pound
მათ ზედა საკმაოდ ბევრი ყველა პროგრამა
რადგან იგი შეიცავს ერთი ყველაზე სასარგებლო ფუნქციები ჩვენთვის,
printf, რომელიც ასევე საშუალებას ცხოვრობს სტანდარტული io.h.
ასე, რომ თქვენ არ უნდა ფუნტი მოიცავს ნებისმიერი დამატებითი ფაილი, ალბათ,
იმისათვის, რომ მუშაობა ფაილი მითითებას.
>> ახლა თითოეული ფაილის კურსორი ფუნქცია, ან თითოეული ფაილის I / O, შეყვანის გამომავალი
ფუნქცია, იღებს, როგორც ერთ-ერთი მისი პარამეტრების და საშუალებებით
ფაილი მაჩვენებელი გარდა ერთი, fopen, რომელიც
არის ის, რაც თქვენ გამოიყენოს, რათა ფაილი მაჩვენებელი, პირველ რიგში.
მაგრამ მას შემდეგ, რაც თქვენ გახსნა ფაილი და თქვენ გაქვთ ფაილი მითითებას,
შეგიძლიათ შემდეგ გადმოეცა, რადგან არგუმენტები სხვადასხვა ფუნქციები
ჩვენ ვაპირებთ ვისაუბროთ დღეს, ისევე როგორც მრავალი სხვა
ასე რომ თქვენ შეგიძლიათ მუშაობა ფაილი.
>> ასე რომ, არსებობს ექვსი საკმაოდ საერთო ძირითადი პირობა
რომ ჩვენ ვაპირებთ ვისაუბროთ დღეს.
fopen და მისი კომპანიონი ფუნქცია fclose, fgetc
და მისი კომპანიონი ფუნქცია fputc, და fread და მისი კომპანიონი ფუნქცია,
fwrite.
მოდით მიიღოს უფლება მივანიჭო.
>> fopen-- რას აკეთებთ?
ისე, ეს ხსნის ფაილი და ეს გაძლევთ ფაილის კურსორი მას,
ასე რომ თქვენ შეგიძლიათ შემდეგ გამოიყენოთ, რომ ფაილის მაჩვენებელი, როგორც არგუმენტი
ნებისმიერ სხვა ფაილი I / O ფუნქციები.
ყველაზე მნიშვნელოვანი რამ უნდა გვახსოვდეს fopen
ის არის, რომ მას შემდეგ, რაც თქვენ არ გახსნა შეიტანოს ან ზარი, როგორც აქ,
თქვენ უნდა შეამოწმოთ რომ დავრწმუნდეთ, რომ მომცეთ, რომ თქვენ მიიღო უკან
არ არის ტოლი null.
თუ თქვენ არ უყურებს ვიდეო პოინტერები, ეს შეიძლება არ აქვს აზრი.
მაგრამ თუ თქვენ ცდილობენ და dereference null მაჩვენებელი გაწვევას,
თქვენი პროგრამა ალბათ განიცდიან სეგმენტაცია [INAUDIBLE].
ჩვენ გვინდა, რომ დავრწმუნდეთ, რომ ჩვენ მიიღო ლეგიტიმური მაჩვენებელი უკან.
უმრავლესობის დროს ჩვენ მიღებული ლეგიტიმური მაჩვენებელი უკან
და ეს არ იქნება პრობლემა.
>> ასე რომ, ჩვენ ზარი fopen?
იგი გამოიყურება საკმაოდ მოსწონს ეს.
ფაილის ვარსკვლავი ptr-- Ptr მყოფი generic სახელი ფაილი მაჩვენებელი fopen
და ჩვენ გაივლის ორი რამ, ფაილის სახელი და ოპერაცია ჩვენ გვინდა წამოწყებას.
ასე რომ, ჩვენ შეიძლება მოწოდება, რომელიც ასე გამოიყურება ამას ფაილი ვარსკვლავი ptr 1 უდრის fopen
file1.txt.
და ოპერაციის მე არჩეული r.
>> ასე რომ, რას ფიქრობთ r არის აქ?
რა სახის რამ, ჩვენ შეიძლება იყოს ვერ გააკეთებს, რათა ფაილი?
ასე რომ, r არის ოპერაცია, რომ ჩვენ აირჩიოს, როდესაც ჩვენ გვინდა წაიკითხოთ ფაილი.
ასე რომ ჩვენ გვინდა, ძირითადად, როდესაც ჩვენ დავრეკოთ მოსწონს ეს
მიღების თავს ფაილის კურსორი ასეთი, რომ ჩვენ შეგვიძლია მაშინ წავიკითხე ინფორმაცია
საწყისი file1.txt.
>> ანალოგიურად, ჩვენ ვერ ვხსნი 2.txt წერა და ასე რომ ჩვენ შეგვიძლია გაივლის ptr2,
ფაილის კურსორი მე ის აქ, როგორც არგუმენტი ნებისმიერი ფუნქცია, რომ
ინფორმაციას წერს ფაილი.
და მსგავსი წერილობით, არსებობს ასევე ვარიანტი დამატება, ა.
შორის სხვაობა წერა და მიერთება
იმისა, რომ როდესაც წერთ ფაილი, თუ ზარი fopen წერა
და რომ ფაილი უკვე არსებობს, ეს აპირებს გადავაწერო მთელი ფაილი.
ის აპირებს დაიწყოს თავიდანვე,
წაშლის ყველა ინფორმაცია რომ უკვე არსებობს.
>> ხოლო თუ თქვენ გასახსნელად appending, ის წავა ბოლომდე ფაილი
თუ არსებობს უკვე ტექსტი ის ან ინფორმაცია, ის,
და მას შემდეგ დაიწყება წერა იქიდან.
ასე რომ თქვენ არ დაკარგოს ნებისმიერ ინფორმაცია გავაკეთეთ ადრე.
თუ გსურთ დაწეროთ ან დამატება ერთგვარი დამოკიდებულია სიტუაცია.
მაგრამ თქვენ ალბათ იცით, თუ რა მარჯვენა ოპერაცია, როცა დრო მოდის.
ასე რომ, fopen.
>> რაც შეეხება fclose?
ისე, საკმაოდ უბრალოდ, fclose მხოლოდ ადასტურებს ფაილის კურსორი.
და როგორც თქვენ შეიძლება ველოდოთ, ეს იხურება ფაილი.
და კიდევ ჩვენ უკვე დაიხურა, ფაილი, ჩვენ არ შეგვიძლია შეასრულოს ნებისმიერი მეტი ფაილის I / O ფუნქციები,
კითხულობს და წერს, რომ ფაილი.
ჩვენ უნდა ხელახლა გახსნა წარადგინოს სხვა დრო, რათა
გავაგრძელოთ მუშაობა ის გამოყენებით I / O ფუნქციები.
ასე რომ, fclose საშუალებით ჩვენ გავაკეთეთ მუშაობს ეს ფაილი.
და ყველა ჩვენ უნდა გაიაროს არის სახელი ფაილის მაჩვენებელი.
ასე რომ, რამდენიმე სლაიდები წინ, ჩვენ fopened ფაილი 1 dot ტექსტი მოსმენით
და ჩვენ დაავალა, ფაილი მომცეთ ptr1.
ამჟამად ჩვენ გადავწყვიტეთ, რომ ჩვენ კეთდება კითხულობს რომ ფაილი.
ჩვენ არ გვჭირდება რაიმე უფრო მას.
ჩვენ შეგვიძლია უბრალოდ fclose ptr1.
და ანალოგიურად, შეიძლება, ჩვენ fclose სხვა პირობა.
ყველა უფლება.
ასე რომ გახსნის და დახურვის.
ეს ის ორი ძირითადი საქმიანობის დაწყებას.
>> ახლა ჩვენ გვინდა რეალურად დაკავდით საინტერესო პერსონალი,
და პირველი ფუნქცია, რომელიც ჩვენ გამოგიგზავნით ვხედავთ, რომ ყველაფერს გააკეთებს, რომ არის fgetc--
წარადგინოს კიდევ ხასიათი.
ეს არის ის რაც fgetc ზოგადად რომ თარგმნოს.
მისი მიზანი ცხოვრებაში არის წაკითხვის შემდეგ ხასიათი,
ან, თუ ეს თქვენი ძალიან პირველი ზარი fgetc
კონკრეტული ფაილი, პირველი ხასიათი.
მაგრამ შემდეგ, რომ, თქვენ მომდევნო ერთი,
მომდევნო ხასიათი რომ ფაილი, და ინახავს მას ხასიათი განსხვავებულია.
როგორც ჩვენ გავაკეთეთ აქ, char ch ტოლია fgetc,
გაივლის სახელი ფაილის მაჩვენებელი.
ისევ და ისევ, ეს არის ძალიან აქ მნიშვნელოვანია გვახსოვდეს,
რომ იმისათვის, რომ ამ ოპერაციის წარმატების მიღწევა,
ფაილის კურსორი თავად must've გაიხსნა მოსმენით.
ჩვენ ვერ წაიკითხა ხასიათი ფაილი მაჩვენებელი, რომ გავხსენით წერა.
ასე რომ, ერთ-ერთი შეზღუდვები fopen, არა?
ჩვენ უნდა შეზღუდოს საკუთარ თავს მხოლოდ ასრულებენ
ერთი ოპერაციის ერთი ფაილი მაჩვენებელი.
თუ გვინდოდა, რომ წავიკითხე და წერენ იგივე ფაილი,
გვექნებოდა გახსნა ორი ცალკე ფაილი მითითებას იგივე ფაილი
ერთი მოსმენით, ერთ წერა.
>> ასე რომ კიდევ ერთხელ, ერთადერთი მიზეზი მე მოუტანს, რომ ახლა არის
იმიტომ, რომ თუ ჩვენ ვაპირებთ, რომ მიიღოს ზარი რომ fgetc, რომ ფაილი მაჩვენებელი must've
გაიხსნა მოსმენით.
და მაშინ საკმაოდ უბრალოდ, ყველა ჩვენ უნდა გავაკეთოთ
გაივლის სახელით ფაილი მაჩვენებელი.
ასე რომ char ch ტოლია fgetc ptr1.
>> რომ აპირებს მიიღოს ჩვენთვის შემდეგი პერსონაჟი
ან კიდევ ერთხელ, თუ ეს არის პირველი დროს ჩვენ ეს ზარი,
პირველი პერსონაჟი, რაც ფაილი მიუთითა მიერ ptr1.
შეგახსენებთ, რომ ეს იყო ფაილი 1 dot ტექსტი.
ეს მიიღებთ პირველი ხასიათი რომ და ჩვენ ვინახავთ ეს ცვლადი ch.
საკმაოდ მარტივია.
ასე რომ, ჩვენ მხოლოდ შევხედე სამი ფუნქციები და უკვე ჩვენ
შეგვიძლია გავაკეთოთ რაღაც საკმაოდ სუფთა.
>> ასე რომ, თუ ჩვენ ეს უნარი მიღების ხასიათი
და ჩვენ loop it-- ამიტომ ჩვენ გააგრძელოს გმირები
საწყისი ფაილი მეტი და მეტი და over-- ახლა ჩვენ
შეგიძლიათ წაიკითხოთ თითოეული ხასიათი ფაილი.
და თუ ჩვენ ბეჭდვა თითოეული ხასიათი მაშინვე ვკითხულობდით,
ჩვენ ახლა წაკითხვის ფაილი და დაბეჭდილი მისი შინაარსი ეკრანზე.
ჩვენ ეფექტურად concatenated რომ ფაილი ეკრანზე.
და რომ ის, რაც Linux ბრძანება კატა აკეთებს.
>> თუ თქვენ აკრიფოთ კატა ფაილის სახელი, მას ამობეჭდოთ მთელი შინაარსი
ფაილი თქვენს ტერმინალის ფანჯარაში.
ასე რომ, ამ პატარა loop აქ, მხოლოდ სამი ხაზი კოდი,
მაგრამ ეს ეფექტურად ეგზ ლინუქსის ბრძანება კატა.
ასე რომ, ეს სინტაქსი შეიძლება ცოტა უცნაური,
მაგრამ აქ არის ის, რაც ხდება აქ.
მიუხედავად იმისა, რომ ch ტოლია fgetc, ptr არ არის ტოლი EOF-- ეს არის მთელი mouthful,
მაგრამ მოდით შესვენება მას მხოლოდ ასე რომ, ეს ნათელია სინტაქსი.
მე კონსოლიდაცია ეს გულისთვის სივრცეში,
მიუხედავად იმისა, რომ ეს არის პატარა სინტაქსურად სახიფათო.
>> ასე რომ ეს ნაწილი მწვანე უფლება ახლა, რა არის ეს აკეთებს?
ისე, რომ მხოლოდ ჩვენი fgetc დარეკეთ, არა?
ჩვენ ვნახეთ, რომ ადრე.
ეს მოპოვების ერთი ხასიათი ფაილი.
შემდეგ შევადარებთ, ხასიათი წინააღმდეგ EOF.
EOF არის სპეციალური ღირებულება, რომელიც არის განსაზღვრულია სტანდარტული io.h, რომელიც
არის ფაილის დასასრულს ხასიათი.
ასე რომ, ძირითადად, რა მოხდება არის ამ მარყუჟის წაიკითხავს ხასიათი,
შედარების eof, რომ ფაილის დასასრულს ხასიათი.
თუ ისინი არ ემთხვევა, ამიტომ ჩვენ არ გვაქვს მიაღწია ბოლომდე ფაილი,
ჩვენ ბეჭდვა რომ ხასიათი გარეთ.
მაშინ ჩვენ დაბრუნდეს დაწყებული მარყუჟის ერთხელ.
ჩვენ კიდევ ხასიათი, შეამოწმეთ წინააღმდეგ EOF, ამობეჭდოთ, და ა.შ.
და ასე შემდეგ და ასე შემდეგ, looping მეშვეობით, რომ გზა
სანამ ჩვენ მიაღწია ბოლომდე ფაილი.
და მაშინ, რომ წერტილი, ჩვენ არ დაბეჭდილი
მთელი შინაარსი ფაილი.
ასე რომ კიდევ ერთხელ, ჩვენ მხოლოდ ჩანს fopen, fclose, და fgetc
და უკვე შეგვიძლია დუბლიკატი ლინუქსის ტერმინალის ბრძანება.
>> როგორც ვთქვი დასაწყისში, ჩვენ გვქონდა fgetc და fputc,
და fputc იყო თანამგზავრი ფუნქცია fgetc.
ასე რომ, როგორც თქვენ ალბათ წარმოიდგინეთ, ეს არის წერა ექვივალენტს.
ეს საშუალებას გვაძლევს დაწერა ერთჯერადი ხასიათი ფაილი.
>> ისევ და ისევ, გაფრთხილებაც, რომ, უბრალოდ, როგორც ეს იყო fgetc, ფაილი
რომ ჩვენ წერილობით must've ყოფილა გაიხსნა წერილობით ან მიერთება.
თუ ჩვენ ვცდილობთ და გამოვიყენოთ fputc ფაილი რომ ჩვენ გახსნა მოსმენით,
ჩვენ ვაპირებთ, რომ განიცდიან ცოტა შეცდომა.
მაგრამ ზარი საკმაოდ მარტივია.
fputc კაპიტალი ptr2, ყველა რომ აპირებს გააკეთოს არის ის,
აპირებს დაწეროს წერილი შევიდა ფაილი 2 dot
ტექსტი, რომელიც იყო სახელი ფაილი, რომელიც ჩვენ გავხსენით და ენიჭება
მომცეთ ptr2.
ამიტომ, ჩვენ ვაპირებთ დაწერა კაპიტალის შეიტანოს 2 dot ტექსტი.
და ჩვენ წერენ ძახილის აღვნიშნო, რომ შეიტანოს 3 dot
ტექსტი, რომელიც მითითებულია ptr3.
ასე რომ კიდევ ერთხელ, საკმაოდ მარტივია.
>> მაგრამ ახლა ჩვენ შეგვიძლია გავაკეთოთ კიდევ ერთი რამ.
ჩვენ გვაქვს მაგალითი ჩვენ უბრალოდ აპირებს
მიმდინარეობს შეუძლია იმეორებს კატა Linux ბრძანება, ერთი, რომ ბეჭდავს
ეკრანზე.
ისე, ახლა რომ ჩვენ გვაქვს შესაძლებლობა, წაკითხვის გმირების ფაილი
და წერენ გმირები ფაილი, რატომ არ ჩვენ უბრალოდ შეიცვალა, რომ
ზარი printf ზარი fputc.
>> და ახლა ჩვენ დუბლირებული cp, ძალიან ძირითადი Linux ბრძანება
რომ ჩვენ ვისაუბრეთ გზა ხანგრძლივი წინ Linux ბრძანებები ვიდეო.
ჩვენ ეფექტურად დუბლირებული რომ უფლება აქ.
ჩვენ კითხულობს ხასიათი და მაშინ ჩვენ წერდა, რომ ხასიათი სხვა ფაილი.
კითხვა ერთი ფაილი, წერა სხვა, მეტი და მეტი
და კიდევ, სანამ ჩვენ მოხვდა EOF.
ჩვენ მივიღეთ ბოლოს წარადგინოს ჩვენ ვცდილობთ კოპირება.
ხოლო ის, რომ ჩვენ არ წერია ყველა გმირები ჩვენ უნდა ფაილი
რომ ჩვენ წერილობით.
ასე რომ, ეს არის cp, Linux კოპირება.
>> ამავე თავიდანვე ეს ვიდეო, მე მქონდა გაფრთხილებაც
, რომ ჩვენ გაიგო ცოტა შესახებ მითითებას.
აქ არის კონკრეტულად, სადაც ჩვენ ვართ ვაპირებთ ვისაუბროთ პოინტერები
გარდა ამისა, უნდა წარადგინოს მითითებას.
ასე რომ, ეს ფუნქცია გამოიყურება სახის საშინელი.
ეს მივიღე რამდენიმე პარამეტრებს.
არსებობს ბევრი ხდება აქ.
არსებობს ბევრი სხვადასხვა ფერები და ტექსტები.
მაგრამ რეალურად, ეს მხოლოდ generic ვერსია fgetc
რომელიც საშუალებას გვაძლევს მიიღოს ნებისმიერი რაოდენობით ინფორმაციას.
ეს შეიძლება იყოს ცოტა არაეფექტური თუ ჩვენ მიღების გმირები ერთ დროს,
iterating მეშვეობით ფაილი ერთი ხასიათი დროს.
თუ არ იქნება ლამაზი მისაღებად 100 დროს ან 500 დროს?
>> ისე, fread და მისი კომპანიონი ფუნქცია fwrite, რომელიც ჩვენ ვსაუბრობთ
მეორე, საშუალებას გვაძლევს, რომ მხოლოდ.
ჩვენ შეგვიძლია თვითნებური თანხა ინფორმაციის ფაილი
და ჩვენ ჩაწეროთ იგი სადმე დროებით.
იმის ნაცვლად, რომელსაც შეუძლია მხოლოდ ჯდება ეს ერთი ცვლადი,
ჩვენ შეიძლება უნდა ჩაწეროთ იგი მასივი.
ასე რომ, ჩვენ გაივლის ოთხ არგუმენტები, fread-- მაჩვენებელი
იმ ადგილას, სადაც ჩვენ მიმდინარეობს ინფორმაციის შესანახად,
რამდენად დიდი თითოეული ერთეულის ინფორმაცია იქნება, რამდენი ერთეული ინფორმაცია
ჩვენ გვინდა, რომ შეიძინოს, და რომელიც ფაილი ჩვენ გვინდა მათ.
ალბათ საუკეთესო ილუსტრირებული მაგალითია აქ.
მოდით ვთქვათ, რომ ვაცხადებთ მასივი 10 რიცხვებით.
ჩვენ უბრალოდ განაცხადა, დასტის თვითნებურად int arr 10.
ასე რომ, საკმაოდ მარტივია.
ახლა, რასაც ჩვენ ვაკეთებთ, თუმცა არის frecall არის ჩვენ კითხულობს ზომა int
ჯერ 10 ბაიტი ინფორმაცია.
ზომა int ყოფნა four--, რომ ზომა რიცხვი გ.
>> ასე რომ, რასაც ჩვენ ვაკეთებთ ჩვენ კითხულობს 40 bytes ღირებულების ინფორმაცია
ფაილი მიუთითა მიერ ptr.
და ჩვენ შენახვა იმ 40 bytes სადღაც
სადაც ჩვენ გათვალისწინებულია 40 bytes ღირებულების მეხსიერება.
საბედნიეროდ, ჩვენ უკვე გავაკეთეთ, რომ გამოცხადების arr, რომ მასივი უფლება არსებობს.
რომ შეუძლია ჰოლდინგი 10 ოთხი ბაიტი ერთეული.
ასე რომ საერთო ჯამში, მას შეუძლია გამართავს 40 bytes ღირებულების ინფორმაცია.
ჩვენ ახლა კითხულობს 40 ბაიტი ინფორმაციის ფაილი,
და ჩვენ შენახვის იგი arr.
>> შეგახსენებთ, ვიდეო მითითებას, რომ სახელი მასივი, როგორიცაა arr,
მართლაც მხოლოდ მომცეთ მისი პირველი ელემენტს.
ასე რომ, როდესაც ჩვენ გავლა arr, ჩვენ რომლებიც, ფაქტობრივად, გადადის მომცეთ.
>> ანალოგიურად, ჩვენ შეგვიძლია გავაკეთოთ ამას ჩვენ არ ემთხვეოდეს
უნდა გადავარჩინოთ ჩვენი ბუფერული Stack.
ჩვენ ასევე შეგვიძლია დინამიურად გამოყოფს ბუფერული, როგორც ეს, გამოყენებით malloc.
გახსოვდეთ, რომ როდესაც ჩვენ დინამიურად გამოყოფს მეხსიერება,
ჩვენ გადარჩენის ეს ბევრი, არ Stack.
მაგრამ ეს ჯერ კიდევ ბუფერული.
>> ეს ჯერ კიდევ, ამ შემთხვევაში, არის ჩატარების 640 ბაიტი ინფორმაცია
რადგან ორმაგი იღებს რვა ბაიტს.
და ჩვენ ითხოვს 80 მათგანი.
ჩვენ გვინდა, რომ სივრცე გამართავს 80 ორადგილიანი.
ასე რომ, 80-ჯერ 8 640 ბაიტი ინფორმაცია.
და რომ მოწოდება fread არის შეგროვება 640 ბაიტი ინფორმაცია
ფაილი მიუთითა მიერ ptr და შენახვის იგი ახლა arr2.
>> ახლა ჩვენ შეგვიძლია ასევე მკურნალობა fread ისევე, როგორც ზარი fgetc.
ამ შემთხვევაში, ჩვენ უბრალოდ ვცდილობთ, კიდევ ერთი პერსონაჟი ფაილი.
და ჩვენ არ გვჭირდება მასივი გამართავს ხასიათი.
ჩვენ შეგვიძლია მხოლოდ ჩაწეროთ იგი ხასიათი განსხვავებულია.
>> დაჭერა, თუმცა, ის არის, რომ როდესაც ჩვენ უბრალოდ უნდა ცვლადი,
ჩვენ უნდა გაიარონ მისამართი რომ ცვლადი
იმიტომ, რომ გავიხსენოთ, რომ პირველი არგუმენტი fread
მომცეთ განთავსების და მეხსიერება სადაც ჩვენ გვინდა შესანახად ინფორმაციას.
ისევ და ისევ, სახელით array არის მაჩვენებელი.
ამიტომ, ჩვენ არ უნდა გავაკეთოთ ampersand მასივი.
მაგრამ გ, ხასიათი გ აქ, არ არის მასივი.
ეს მხოლოდ ცვლადი.
ასე რომ, ჩვენ უნდა გაიაროს ampersand გ მიუთითოს
რომ ეს არის ის მისამართი, სადაც ჩვენ გვინდა შესანახად ამ ერთი ბაიტი ინფორმაცია,
ამ ერთი ხასიათი, რომ ჩვენ შეგროვება ptr.
Fwrite-- მე გავლა ამ ცოტა მეტი
quickly-- არის საკმაოდ ბევრი ზუსტი ეკვივალენტი fread
გარდა ის წერა ნაცვლად მოსმენით, უბრალოდ
როგორც other-- ჩვენ გვქონდა ღია და ახლოს, მიიღოთ ხასიათი,
წერენ ხასიათი.
ახლა ის მისაღებად თვითნებური თანხის ინფორმაციით,
მარჯვენა თვითნებური რაოდენობით ინფორმაციას.
ასე რომ, ისევე, როგორც ადრე, ჩვენ შეგვიძლია აქვს მასივი 10 რიცხვებით
სადაც ჩვენ უკვე გვაქვს ინფორმაცია ინახება, ალბათ.
>> ეს, ალბათ, რამდენიმე ხაზი კოდი რომ უნდა წავიდეს ამ ორ
სადაც მე შეავსოთ სია თურქეთიდან ერთად რაღაც მნიშვნელოვანი.
მე შეავსოთ იგი 10 სხვადასხვა რიცხვებით.
და ნაცვლად, რაც მე აკეთებს წერა arr
და შეგროვება ინფორმაცია arr.
და მე მივიღე ეს ინფორმაცია და აყენებს მას ფაილი.
>> ასე რომ, ნაცვლად იმისა, რომ იგი საწყისი ფაილი ბუფერულ,
ჩვენ ახლა აპირებს ბუფერული ფაილი.
ასე რომ, ეს უბრალოდ საპირისპირო.
ასე რომ კიდევ ერთხელ, ისევე, როგორც ადრე, ჩვენ შეგვიძლია ასევე აქვს ბევრი ბლოკი მეხსიერება
რომ ჩვენ გვაქვს დინამიურად გამოყოფილი და წაიკითხა, რომ
და წერს, რომ ფაილი.
>> და გვაქვს ერთი ცვლადი ჩატარება შეუძლია ერთი ბაიტი
ინფორმაციის, როგორიცაა ხასიათი.
მაგრამ კიდევ ერთხელ, ჩვენ უნდა გაიაროს მისამართი, რომელიც ცვლადი
როდესაც ჩვენ გვინდა, რომ წაკითხვის იგი.
ასე რომ, ჩვენ შეგვიძლია დავწეროთ ინფორმაცია ჩვენ ვხედავთ, რომ მისამართი
ფაილის მაჩვენებელი, Ptr.
>> არსებობს უამრავი სხვა დიდი ფაილი I / O ფუნქციები
რომ სხვადასხვა ნივთები, გარდა პირობა ჩვენ ვისაუბრეთ დღეს.
რამდენიმე პირობა თქვენ შეიძლება სასარგებლო
არიან fgets და fputs, რომლებიც ეკვივალენტს
საქართველოს fgetc და fputc მაგრამ კითხულობს ერთ სიმებიანი ფაილიდან.
იმის ნაცვლად, ერთი ხასიათი, იგი წაიკითხავს მთელი სიმებიანი.
fprintf, რომლებიც ძირითადად საშუალებას იძლევა თქვენ უნდა გამოვიყენოთ printf დაწერა შეიტანოს.
ასე რომ, ისევე შეგიძლიათ გააკეთოთ ცვლადი ჩანაცვლების გამოყენებით
placeholders პროცენტი მე და პროცენტს d, და ა.შ., printf
თქვენ შეგიძლიათ ერთნაირად მიიღოს printf სიმებიანი და ბეჭდვითი რაღაც
მინდა, რომ ფაილი.
>> fseek-- თუ თქვენ გაქვთ DVD player არის ანალოგია მე ჩვეულებრივ გამოიყენოთ აქ
არის ერთგვარი მოსწონს გამოყენებით თქვენი გადახვევა და სწრაფი წინ
ღილაკები გადაადგილება ფილმი.
ასევე, შეგიძლიათ გადაადგილება ფაილი.
ერთი რამ შიგნით რომ ფაილის სტრუქტურა
რომ გ ქმნის თქვენთვის არის მაჩვენებელი სადაც ხართ ფაილი.
ხართ თუ არა ძალიან დაწყებული, ერთი ბაიტი ნულოვანი?
ხართ თუ არა byte 100, byte 1000, და ა.შ.?
თქვენ შეგიძლიათ გამოიყენოთ fseek თვითნებურად გადაადგილება რომ მაჩვენებელი წინ ან უკან.
>> და ftell, კიდევ ერთხელ მსგავსი DVD player,
ჰგავს პატარა საათის რომ გიჩვენებთ რამდენი წუთი და წამი თქვენ
შევიდა კონკრეტულ ფილმი.
ანალოგიურად, ftell მოგვითხრობს, თუ როგორ რამდენი ბაიტი თქვენ შევიდა ფაილი.
feof არის განსხვავებული ვერსია გამოვლენის თუ არა თქვენ
მიაღწია ბოლომდე ფაილი.
და ferror ფუნქცია რომელიც შეგიძლიათ გამოიყენოთ
შესამჩნევია თუ არა რაღაც წავიდა არასწორი სამუშაო ფაილი.
ისევ და ისევ, ეს მხოლოდ scratching ზედაპირზე.
არსებობს კიდევ უამრავი სხვა ფაილი I / O ფუნქციების სტანდარტული io.h.
მაგრამ ეს, სავარაუდოდ, კიდევ თქვენ დაიწყო მუშაობა ფაილი მითითებას.
მე Doug Lloyd.
ეს არის CS50.