>> JASON HIRSCHHORN: მოგესალმებით, ყველას, რომ Week 6.
მოხარული ვარ, რომ თქვენ ყველა ცოცხალია და კარგად მას შემდეგ, რაც Quiz 0, იმიტომ, რომ მე ვიცი, რომ
ცოტა უხეში.
მაგრამ საბედნიეროდ, თქვენ ყველა გააკეთა წარმოუდგენლად კარგად.
და ისე, რომ მშვენიერია.
თუ თქვენ ჩემს განყოფილებაში, მე მოცემული საუკეთესო თქვენ დაბრუნება თქვენი ტესტებში უკვე.
>> რამდენიმე თქვენ, მე შეხვედრა მას შემდეგ, რაც კლასის.
და თუ თქვენ გაგრძელების სტუდენტი და თქვენ არ მიუღიათ თქვენს ვიქტორინა უკან
ჯერჯერობით, თქვენი TF ალბათ მუშაობა და შეფასების, და მიიღებს უკან
თქვენ მალე.
ასე რომ, ჩემი გაფართოება სტუდენტები, რომლებიც თვალს ახლა - იმედია, ცხოვრობს -
მე მიიღებთ თქვენს ტესტებში მოკლედ ისევე.
>> ჩვენი დღის წესრიგი დღეს ასეთია.
პირველი, ჩვენ ვაპირებთ წავიდეთ მეტი რამდენიმე რესურსები, რომ CS50 უზრუნველყოფს თქვენ.
ჩვენ ვაპირებთ წავიდეთ მეტი Quiz 0 მომდევნო, და მე უპასუხოს ნებისმიერ შეკითხვას არავისთვის
აქვს კონკრეტული პრობლემები.
და შემდეგ, ჩვენ ვაპირებთ მეტი ფაილის I / O და პრობლემა კომპლექტი 5.
იმ ბოლო ორი თემა მიიღებს up ნაყარი მონაკვეთზე დღეს.
>> მე ზუსტად ამ სიაში ყოველ კვირაში შეგახსენებთ, რომ თქვენ ყველა, მაგრამ ძირითადი
განყოფილებიანი, ჩვენ მხოლოდ 90 წუთი - ჩვენ ვერ დაფარავს ყველაფერს, რომ მე
მიყვარს მოიცავს თქვენ ბიჭები.
მაგრამ ჩვენ გვყავს ტონა რესურსები თქვენ მიაპყროს საფუძველზე, როგორც თქვენ უნდა იცოდეს
მატერიალური და მუშაობის გზით თქვენი პრობლემა კომპლექტი.
>> შეგახსენებთ, რომ მაქვს ონლაინ ტექსტური ყუთი, წყობის თქვენ შეავსოთ, თუ
გაქვთ რაიმე კავშირი ჩემთვის, როგორც დადებითი, ასევე
კონსტრუქციული, დაახლოებით მონაკვეთზე.
რომ URL მდებარეობს უფლება ქვემოთ აქ.
ასე რომ, გთხოვთ, მიიღოს მომენტში თუ თქვენ გაქვთ რაიმე კავშირი, თუ არა დროს განყოფილებიანი,
ან მის შემდეგ, ან მას შემდეგ, უყუროთ ვიდეო ამჟამად, მომეცი თქვენი კავშირი.
მე ნამდვილად ვაფასებ ნებისმიერი და ყველა ის.
>> ასე რომ, მე, რომელსაც მცირე საუბარი ბევრი ჩემი
სტუდენტები კვირის განმავლობაში - როგორც მე გადასცემს უკან ტესტებში, ვსაუბრობთ
რა თქმა უნდა, ხედავს, თუ როგორ ვაკეთებთ.
და ერთი თემა ამუშავება მეტი და მეტი საუბარი - ში
კერძოდ -
პრობლემა ადგენს.
და მე არ encapsulated რომ თემა ფორუმში ახლა.
>> არსებითად, არსებობს განსხვავება შორის გთხოვოთ, რომ რაღაც არის
სწორად და რამე რომ კეთდება კარგად.
ადამიანების უმეტესობა არ აკეთებს ფანტასტიკური თვალსაზრისით სისწორის -
5 ან 4 ყველა psets.
ადამიანების უმეტესობა იღებენ იმ ყველა დროის.
>> თუმცა, მხოლოდ იმიტომ, რომ ვაკეთებ რაღაც უფლება არ ნიშნავს იმას, რომ თქვენ
გავაკეთეთ რაღაც, როგორც ელეგანტურად, ან ეფექტურად, ან როგორც cleanly როგორც თქვენ
შეეძლო მას.
და ეს რა დიზაინი -
და ნაკლები ხარისხი, სტილი -
ცულები არიან.
ამიტომ მე უბიძგებს ყველა, და სხვა TFs უბიძგებს თქვენ ბიჭები, არა მარტო თავის მხრივ,
რამ, რომ სწორია, მაგრამ იქაური იმ რამ, რომ კოდირებული კარგად.
>> არ აკეთებს არასაჭირო მარყუჟების, არ recalculating ცვლადები თუ
თქვენ არ უნდა.
მაგალითად, ეძებს უკან პრობლემა კომპლექტი 4, როდესაც დებს აგური
ეკრანზე, ყველა row - ყველა აგურის მოცემული ზედიზედ აქვს იგივე y-კოორდინაცია -
იგივე სიმაღლე კოორდინაციას.
>> ასე რომ y-კოორდინაცია არ უნდა გამოითვლება შიგნით ინტერიერი
წყობილი მარყუჟის, რომ თქვენ, როგორც ჩანს, გამოყენებული დააყენოს იმ აგური ეკრანზე.
ეს მხოლოდ უნდა იყოს გათვლილი ყველა დროს თქვენ შეცვალა a row, ან
გადავიდა ქვემოთ a row.
ასე რომ ვთქვათ, თუ არსებობს 10 აგური ზედიზედ, თითოეული აგურის შეგიძლიათ იგივე
y-კოორდინირება, რომ y-კოორდინაცია შეგიძლიათ უბრალოდ გამოითვლება
ერთხელ ყველა იმ.
>> ეს არ უნდა იყოს გათვლილი 10 ჯერ, არც რომ გაანგარიშება სჭირდება
უნდა მოხდეს ფაქტობრივი ფუნქცია ზარი -
ახალი gracked ფუნქცია ზარი.
ასე რომ, თუ რომ იყო ცოტა დამაბნეველი თქვენ, უფრო generically, რამ
არ უნდა მოხდეს თითოეული დრო თქვენ გავლა მარყუჟის არ უნდა იყოს
დააყენა შიგნით ამისთვის მარყუჟის, და არ უნდა ხდება ყოველ დროს, თქვენ წავიდეთ
მეშვეობით იყიდება loop.
>> კიდევ ერთი კარგი დიზაინის მაგალითი ჩვენ ვნახეთ კვირა 3 15, შეგიძლიათ შენარჩუნება
სიმღერა ნულოვანი.
ასე რომ, როდესაც თქვენ ინიციალიზაცია ფორუმში, გადარჩენა - გლობალური ცვლადი, ალბათ -
x და y-კოორდინაციას ნულოვანი.
და მაშინ, როდესაც თქვენ -
თქვენი ნაბიჯი ფუნქცია, როდესაც თქვენ წარმატებული ნაბიჯი, თქვენ განახლება
მდებარეობა ნულოვანი.
>> რომ გადაარჩენს თქვენ მქონე გავაკეთოთ წყობილი ამისთვის მარყუჟების გაეცნონ
მონიშნე ყველა დროის თქვენი ნაბიჯი ფუნქცია და იპოვოს ნულოვანი, ან ფილა,
და შემდეგ შეამოწმეთ რა მომავალი იგი.
ამის ნაცვლად, თქვენ გაქვთ მდებარეობა ნულოვანი, შეგიძლიათ უბრალოდ გამოიყურება ზემოთ, ქვემოთ,
და მარცხნივ და მარჯვნივ, რათა იპოვოს ფილა ეძებდით.
>> ასე რომ, იმ თვალსაზრისით, პროგრამები ჩვენ წერილობით, ისინი არასდროს დიდი საკმარისი
რომ ზოგიერთი დიზაინის გადაწყვეტილებები ნამდვილად აპირებს ხელი შეუშალოს თქვენი
პროგრამა, ან მიიღოს იგი აწარმოებს უფრო ნელა, ან შესაძლოა ამოიწურა მეხსიერება.
მაგრამ ჩვენ მაინც უბიძგებს თქვენ ბიჭები წერენ, როგორც დახვეწილი და
ეფექტური კოდი, რაც შეიძლება.
>> ასე რომ, თუ თქვენ აკეთებთ დასრულდება მდე წერა რამ რომ აქვს გაცილებით დიდი
ფარგლებში, ისინი წერილობითი კარგი დიზაინი გარდა იმისა, რომ სწორი.
ასე რომ, რიგი გაქვთ მოიყვანა, რომ.
ეს რაღაც ჩვენ ვეძებთ - რაღაც ჩვენ გავაგრძელებთ
დააყენებს თქვენ ბიჭები.
>> თუ თქვენ ოდესმე გაქვთ რაიმე შეკითხვები დიზაინი თქვენი პროგრამა, მოგერიდებათ
მივაწვდინოთ ჩემთვის და მოხარული ვარ, გავლა თქვენი პროგრამა, თქვენთან ერთად,
და აღვნიშნო ზოგიერთი დიზაინი გადაწყვეტილებები თქვენ გააკეთა და მოგცემთ ზოგიერთი
წინადადებები, თუ როგორ, რათა კიდევ უკეთესი დიზაინის გადაწყვეტილებები.
>> ამიტომ, ჩვენ ვაპირებთ გადაადგილება to ვსაუბრობთ Quiz 0.
სანამ ჩვენ გავაკეთოთ, რომ ვინმეს გაქვთ რაიმე შეკითხვა, თუ რა
მე დაფარული აქამდე?
>> [Rustling ხმაური]
>> JASON HIRSCHHORN: შვიდი წამი.
OK.
მოდით ვისაუბროთ Quiz 0 bit.
ყველაზე მეტად თქვენ გაქვთ თქვენი Quiz 0 ზურგზე.
თუ არ, იმედია გახსოვთ ცოტა.
მაგრამ თუ თქვენ გადაღებული Quiz 0, მაშინ ასევე გაქვთ PDF ონლაინ
ნიმუში გადაწყვეტილებები.
>> ვინმეს გაქვთ რაიმე შეკითხვები, სანამ ჩვენ ხტომა შევიდა კვირას მასალა
კონკრეტული პრობლემა Quiz 0 -
რატომ პასუხი რა არის?
არის ვინმე დაბნეული შესახებ არაფერი?
მაშინაც კი, თუ თქვენ გაქვთ პრობლემა უფლება, მაგრამ უბრალოდ მინდა ჩემთვის ამას ცოტა
უფრო მეტიც, მოხარული ვარ, რომ ამის გაკეთება ახლა.
>> ასე რომ, მე ვთხოვე თქვენ ბიჭები მოვიდა მომზადებული ზოგიერთი
ფიქრები Quiz 0.
ასე რომ, ვისაც სურს მიიღოს us დაიწყო კითხვა ან
კომენტარის Quiz 0?
>> [PAPER Rustling]
>> JASON HIRSCHHORN: ყველას არ გააკეთა კარგად.
ასე ვიცი [იცინის]
იქ უნდა იყოს გარკვეული კითხვები დაახლოებით Quiz 0.
OK.
დიახ.
Ompica.
>> OMPICA: პუნქტების 10.
>> JASON HIRSCHHORN: პუნქტების 10.
რომელი იყო ნომერი 10?
>> OMPICA: -
>> JASON HIRSCHHORN: I haven't -
>> OMPICA: მოიცავს -
>> JASON HIRSCHHORN: ხმების 10 რვა to i - წერა რვა i?
>> OMPICA: ჰო.
>> JASON HIRSCHHORN: OK.
ასე რომ, კიდევ ერთი შეკითხვა, თუ შეიძლება კითხვაზე, იყო მე prescient?
პასუხი არის დიახ.
განყოფილებაში სანამ ვიქტორინა, მე ვკითხე თქვენ ბიჭები კოდექსში ორივე სტერლინგი და
რვა i.
ორივე მათგანი მოხდა გამოჩნდება ვიქტორინა.
ასე რომ, იმედია, თქვენ გადახდილი ყურადღება.
>> და თუ ჰქონდა, მაშინ უნდა ალბათ კარგად იმ ორი.
მაგრამ რვა i, ჩვენ არ რეალურად კოდი ეს კლასი, მაგრამ ეს იყო, კიდევ ერთხელ,
სთხოვა ვიქტორინა.
ასე რომ, რამდენიმე რამ, რომ მიიღოს აღვნიშნო, როდესაც კოდირების რვა i.
პირველი, რაც, ერთ კითხვაზე, იყო რომ თქვენ საჭირო, რათა შეამოწმოთ, თუ სიმებიანი
ტოლფასი იყო null.
>> რამდენიმე ადამიანმა სცადა გადაამოწმოთ მოგვიანებით პროგრამაში თუ bracket მე -
ისე კონკრეტული ხასიათის, რომ string - ტოლფასი იყო null.
მაგრამ გახსოვდეთ, რომ null არსებითად - კარგია ვფიქრობ
null, როგორც ნულოვანი მაჩვენებელი - მომცეთ zero -
ადგილას მეხსიერებაში, სადაც თქვენ ვერ შედიხართ.
>> ასე რომ, თუ რაღაც ტოლია null, თქვენ ვიცი, რომ ეს არ იყო ინიციალიზაცია,
ან არაფერი არსებობს.
ასე s არის char ვარსკვლავი, დრიურის bracket i არის char.
ასე რომ აზრი შედარების s null, მაგრამ არა s bracket i to null.
თუმცა ისევ და ისევ - ისე, რომ იყო პირველი, რაც რომ თქვენ უნდა გავაკეთოთ -
შეამოწმეთ დარწმუნდით, რომ თქვენ რეალურად მივიღე რეალური string.
>> შემდეგი, თქვენ სურდა გაიაროს თითოეული პერსონაჟი სიმებიანი.
და ისე, რომ იქნება, როგორიც s bracket მე, მაგალითად, თუ თქვენი iterator.
და მიიღოს, რომ ხასიათი და მიიღეთ მისი ფაქტობრივი ღირებულება.
თქვენ ის ინახება როგორც char, მაგრამ ASCII ღირებულება zero -
ნულოვანი როგორც პერსონაჟი -
არ არის რეალურად რიცხვი ნულის ტოლია.
ეს რაღაც სხვა ნომერი, რომელიც შეგიძლიათ გამოიყურება მდე ASCII მაგიდასთან.
>> ასე რომ ერთი გზა კორექტირება, რომ - ალბათ საუკეთესო გზა კორექტირება
რომ - არის სხვაობა ეს ხასიათი ღირებულება -
ნულოვანი როგორც ხასიათი.
ასე რომ მინუს ერთი გაცემა, ნულოვანი, კიდევ ერთი გაცემა.
რომ მიიღებს, რაც ნომერი გაქვთ როგორც char, და მიიღეთ იგი უდრის
ნომერი, ფაქტობრივი რიცხვი.
>> და ეს არის ძალიან მსგავსი მიდგომა ბევრი ადამიანი მიიღო
პრობლემა კომპლექტი 2, Caesar და Viginere -
იმ ciphers, როდესაც თქვენ იყო მბრუნავი მათ.
ასე რომ, მას შემდეგ, რაც თქვენ გაქვთ ის, როგორც ნომერი ნულოვანი ცხრა, მაშინ - დამოკიდებულია
სადაც ის მიდის საბოლოო ნომერი - თქვენ უნდა გავამრავლოთ ის
რომელსაც ძალა 10.
>> ზოგიერთი ადამიანი გადაინაცვლა უკან წინა და გამრავლებული ინდივიდუალური
ნომერი მიერ ძალა 10.
ზოგიერთი ადამიანი გადავიდა წინა უკან -
და ასე აიღო უმაღლესი შეკვეთა ნომერი პირველი -
და რომ გადარჩენა იმ გლობალური counter ცვლადი.
და შემდეგ ყოველ ჯერზე მეშვეობით FOR loop, გამრავლების, რომ გიგანტური მსოფლიო
Counter ცვლადი 10, რათა ფართი მომდევნო char.
>> ასე რომ იყო ცოტა დამაბნეველი გარეშე ჩემთვის წერა ის ფორუმში.
მაგრამ ნიმუში გადაწყვეტა არის ხელმისაწვდომი.
მაგრამ ეს იყო დიდი რამ ჩვენ ეძებდნენ.
ასევე გამშვები დავრწმუნდეთ, რომ ყოველი ინდივიდუალური ხასიათი მართლაც
ხასიათი შორის ნულოვანი და ცხრა, და არა ზოგიერთი სხვა ხასიათი, ისევე, როგორც,
მაგალითად.
>> ეს იყო ის, რაც ჩვენ ეძებდნენ წელს ამ კითხვას.
ამჯამად რომ უპასუხოს შეკითხვას?
>> OMPICA: ჰო.
>> JASON HIRSCHHORN: OK.
არსებობს რაიმე სხვა სახის კითხვებით დაახლოებით Quiz 0?
რაც შეეხება შედგენა?
ყველას შედგენის უფლება?
პოსტები
იყო -
[იცინის]
შეკითხვები compilation პროცესში?
Wow.
>> [PAPER Rustling]
>> JASON HIRSCHHORN: დიახ.
მაიკლ.
>> MICHAEL: არის ნომერი 7 - შემთხვევითი?
>> JASON HIRSCHHORN: პუნქტების 7.
პუნქტების 7 იყო კიდევ შემთხვევითი რიცხვი.
შესანიშნავი.
ასე რომ, თქვენ მოცემული რიცხვი და რიცხვი b, და გსურთ შემთხვევითი
რიცხვი შორის და ბ.
ჩვენ შეგვიძლია რეალურად წერენ ამ ერთი ფორუმში, იმიტომ, რომ ამ ერთი
იყო ერთი ხაზი კოდი -
ერთი გზა ამის გაკეთება.
>> ამიტომ ჩვენ მოცემული drand როგორც ფუნქცია ჩვენ შეგვიძლია გამოვიყენოთ.
და რა drand -
ვთქვათ, რომ ეს უკვე დაითესა -
რას drand დაბრუნებას?
>> MICHAEL: A float შორის 0.0 და 1.0.
>> JASON HIRSCHHORN: ნომერი - yeah.
რიცხვი 0 და 1.
და ამიტომ ჩვენ B და ა.
და მაშინ ჩვენ გვაქვს ჩვენი შემთხვევითი რიცხვების შორის 0 და 1 ენიჭება ჩვენს მიერ drand.
ზოგიერთი ადამიანი ვცდილობდი ბ, ბ minus , ან რაღაც შიგნით იმ
ფრჩხილებში.
ეს ნიშნავს იმას, რომ ისინი არგუმენტები ამ ფუნქციას.
>> drand არ იღებს რაიმე არგუმენტი - როგორიცაა GetString აკეთებს
არ მიიღოს ნებისმიერი არგუმენტები.
ასე რომ მხოლოდ ღია paren ახლოს, Paren - და ეს, თავისთავად, არ არის
ფუნქცია ზარი.
და რომელიც გაძლევთ ნომერი შორის 0 და 1.
რა თქმა უნდა, ჩვენ გვაქვს მთელი რიგი რომ ციფრები შეიძლება იყოს შემოსული
>> ამბობენ, თუ ბ არის 10 და 5, ჩვენ ნამდვილად მინდა ნომერი რიგ 5.
ასე რომ, შემდეგი რამ უნდა გავაკეთოთ არის გავამრავლოთ ეს სპექტრი b მინუს.
ასე რომ, ვთქვათ, რომ ის მრავლდება.
და რომ ყველაფერს მოგვცეს ნომერი მოცემულ სპექტრი.
და რომ კონკრეტული დიაპაზონი, რომ განსხვავება b მინუს.
>> და ბოლოს, რომ ყველაფერს მხოლოდ მისცეს მას - ამბობენ, რომ სპექტრი შორის b მინუს
5, რომელიც მოგვცემს ნომერი 0 დან 5.
მაგრამ თუ ფაქტობრივად 5, ჩვენ უნდა გაზარდოს ამ სპექტრს მდე, სადაც ეს
რეალურად უნდა იყოს, დასძინა.
ასე რომ იღებს ლოგიკა უფლება.
და შემდეგ, რომ თქვენ გაქვთ კიდევ ერთი კითხვა?
>> MICHAEL: არა
უბრალოდ ვგრძნობ მართლაც dumb ახლა.
[იცინის]
>> JASON HIRSCHHORN: არა
ვერ ვგრძნობ მართლაც dumb.
რაოდენობის ხალხი იბრძვის ამ კითხვაზე.
და შემდეგ, მეორე საკითხი, drand, თქვენ თქვით, გაძლევთ float -
დააბრუნებს float.
მაგრამ ეს ფუნქცია რეალურად სთხოვა განთავსების რიცხვი უნდა დაბრუნდნენ.
>> თქვენ არ უნდა მისცეს ამ მკაფიოდ მთელი რიცხვი, რადგან ეს
ოპერაციების მკურნალობა, როგორც ყველა ათწილადი - როგორც მცურავი პუნქტიანი ნომერი.
მოსწონს ეს ნება - მაშინაც კი, თუ ამ არის მთელი რიცხვი, ეს იქნება
უნდა გამრავლდეს სწორად.
ყველა გამრავლება იმუშავებს.
თქვენ არ უნდა მისცეს მას აქ.
ფაქტობრივად, თქვენ არ უნდა მიიღო ის.
>> რომ -
თუ მიცემული ნომერი რომ არის 0 და 1 -
შემთხვევითი ნომერი, მცურავი წერტილი -
მაშინ იყოს მხოლოდ 0 ან 1, ასე რომ, თქვენ დაკარგავთ ყველა რომ სიზუსტით.
მაგრამ ბოლოს, როცა დაბრუნდება, ეს ავტომატურად იღებს
დააბრუნეს როგორც მთელი რიცხვი.
ასე რომ თქვენ არ გჭირდებათ რომ გააკეთოთ რომ აძლევენ თავს.
>> ასე რომ, ეს იყო პასუხი კითხვაზე, ნომერი 7.
ნებისმიერი სხვა კითხვები Quiz 0?
ჰო, Annie.
>> ANNIE: როდესაც ვიყენებთ რეკურსიული -
როდესაც ვიყენებთ iterative მარყუჟების?
>> JASON HIRSCHHORN: როდესაც იყენებთ რეკურსიული - ასე უფრო ზოგადად,
დადებითი და cons უკან წინააღმდეგ განმეორებითი მიდგომა.
შეიძლება ვინმეს გთავაზობთ პრო ან con?
გთხოვთ?
არ შეიძლება ვინმეს.
რომელიც გთავაზობთ პრო ან con?
>> [PAPER Rustling]
>> STUDENT 1 რეკურსიული ნაკლებია, კოდირების - ნაკლებად ფერთა?
>> JASON HIRSCHHORN: ასე რომ, ზოგადად, უკან განსაკუთრებით ფუნქცია -
ან ალგორითმი, როგორიცაა შერწყმა დალაგება - რომელიც lends თავს
to რეკურსიული მიდგომა -
შეიძლება უფრო მარტივია კოდექსში რეკურსიული.
და მხოლოდ უფრო გრძნობა ამის გაკეთება რეკურსიული.
ისე, რომ იქნება პრო უკან.
სხვები?
ჰო?
>> სტუდენტური 2 con რომ უკან -
იგი იყენებს უფრო მეხსიერებაში.
>> JASON HIRSCHHORN: ასე ზუსტად უფლება.
რეკურსიული ფუნქცია დაიცავს დასძინა დასტის ფარგლებში Stack.
ასე რომ, თუ თქვენ მოქმედი ბევრი ნომერი, და მოვუწოდებთ ამ
ფუნქციონირებს ბევრი, მაშინ თქვენ აუცილებლად დასჭირდეს მეტი მეხსიერება, ხოლო
განმეორებითი მიდგომა მხოლოდ დააყენა ერთი დასტის ჩარჩო დასტის, რადგან
ეს ყველაფერი ხდება ერთ ფუნქციას.
>> ნებისმიერი სხვა დადებითი და cons?
ჰო.
>> სტუდენტური 3: დადებითი განთავსების უკან.
თქვენ არ გაქვთ განსაზღვროს წინასწარ რამდენჯერ
კოდი უნდა განმეორდეს.
თქვენ შეგიძლიათ წინასწარ ნომერი ჯერ, რომ თქვენ უნდა iterate, მაშინ
უკან უკეთესია, რადგან სჭირდება, რომ შედეგი.
>> JASON HIRSCHHORN: მე ვფიქრობ, რომ ასეა.
მაგრამ მე ვფიქრობ, ორივე შემთხვევაში თქვენ არასოდეს -
თქვენ ალბათ კიდევ რამდენიმე შეყვანის შესახებ.
ან ეს ფუნქცია ექნება რამდენიმე input რომ დადგინდეს, თუ რამდენი ჯერ
უნდა გაუშვათ.
ასე რომ, ზოგადად, თქვენ არ არის ძნელი კოდი - კი განმეორებითი მიდგომა - როგორ
ბევრჯერ, რომ loop უნდა აწარმოებს.
>> გქონდათ ერთი იყავით ფიქრი, Annie?
OK.
ასე რომ, ეს, ალბათ, ორი -
ყველაზე დიდი პრო და ყველაზე დიდი con რომ რეკურსიული წინააღმდეგ
განმეორებითი მიდგომა.
OK.
არაფერი Quiz 0?
>> მოდით გადაადგილება.
ფაილის I / O. არსებობს მშვენიერი მოკლე ამ კვირაში ფაილის I / O რომ იმედია
თქვენ არ პოპულარულები სხვადასხვა ჯერ, და აღფრთოვანებული.
ბევრი მუშაობა შევიდა, რომ, და მე გავიგე, ეს არის insanely გამოსადეგი.
მე ასევე ბმული ამ slide, იმ შემთხვევაში თუ თქვენ არ ჰქონდა
შანსი უყუროთ მას 10 ჯერ.
>> ასე რომ, ჩვენ ვაპირებთ, რომ მოკლედ წავიდეთ მეტი ძირითადი ნაბიჯები, რათა გახსნას და სამუშაო
ფაილი, და მაშინ ჩვენ ვაპირებთ ჩაყვინთვის შევიდა კოდირების პრობლემის წინაშე
საგამოცდო პრობლემა კომპლექტი.
ასე რომ კიდევ ერთხელ, მე ვაპირებ დააყენა ამ მდე ეკრანზე, მაგრამ მე ვაპირებ გაიგო for
მხოლოდ ერთი წუთით, თუ რა ჩვენ აკეთებს აქ ფაილის I/O--
რას ნიშნავს ეს?
>> ეს იმას ნიშნავს რომ ჩვენ შეგვიძლია შევქმნათ ჩვენი პროგრამები, და მაშინ ჩვენი პროგრამების
გასასვლელი, და არ გააკეთა რაიმე გავლენა მსოფლიოში გარეთ ჩვენი პროგრამა.
მაგრამ როდესაც ჩვენ ამუშავდება ფაილები - ორივე კითხულობს მათ და ქმნის
მათ - ჩვენ შეგვიძლია აქვს გარკვეული ეფექტი მსოფლიოს გარეთ ჩვენი პროგრამა.
>> ისევე, როგორც იმ შემთხვევაში, თუ Microsoft Word-მა ვერ შეძლო რაიმე Word დოკუმენტების, მაშინ
ერთხელ Microsoft Word დატოვა, ყველა თქვენი მუშაობა იქნება წასული, და ეს იქნებოდა
ნამდვილად აზრი არ აქვს.
ჩვენ არ გვინდა საბოლოოდ შეძლებს წერენ პროგრამებს, შეიძლება გავლენა იქონიოს
მსოფლიოს გარშემო, როგორც აღების კომპლექსური საშუალებებით - თვალსაზრისით ფაილი და
მეშვეობით ფაილი, და ასევე შექმნაში საინტერესო და მყარი მასალები -
თვალსაზრისით სხვადასხვა სახის ფაილებს.
>> ასე რომ, სწორედ ამიტომ ჩვენ ვიწყებთ ვისწავლოთ თუ როგორ უნდა იმუშაოს ფაილი.
უფრო კონკრეტულად, რა ვაკეთებთ ასეთია.
ეს ძალიან მარტივია.
არსებობს მხოლოდ რამდენიმე ნაბიჯები, და ისინი აქ ჩამოთვლილი ამ კოდი.
ამიტომ, ჩვენ ვაპირებთ გავლა ეს კოდი ხაზს.
>> პირველი, თქვენ ხედავთ ხაზგასმით -
როდესაც თქვენ მუშაობის ფაილი, მიუხედავად ტიპის ფაილი არის,
თქვენ უნდა გახსნა.
და რომ არის ზარი fopen -
უფლება აქ.
თქვენ მოიცავს სახელით ფაილი.
იმ შემთხვევაში, თუ ფაილი არ არის თქვენს დირექტორია, ან საქაღალდეში სადაც ეს პროგრამა
ცხოვრება, მაშინ ასევე უნდა შეიცავდეს გზა, სადაც ეს ფაილი.
>> ჩვენ ვაპირებთ, რომ ვივარაუდოთ, რომ ეს ფაილი სახელად "text.txt" -
მარტივი ტექსტური დოკუმენტი - არის იმავე საქაღალდეში, როგორც ამ პროგრამის.
ასე რომ კიდევ ერთი რამ უნდა შევინარჩუნოთ გონება - რომ, თუ გსურთ გახსნათ ფაილი
სხვაგან, თქვენ რეალურად სჭირდება მოიცავს მისი ადგილმდებარეობა.
>> მეორე, თქვენ ვერ გაივლის არგუმენტი fopen, და ეს არის ის, რაც გსურთ
ფაილის.
არსებობს სამი ძირითადი არგუმენტები, რომ თქვენ აპირებს გაიაროს fopen.
ვის შეუძლია მომეცი იმ სამ?
ვის შეუძლია მომეცი ერთი მათგანი?
დიახ.
>> სტუდენტური 4: ფაილის სახელი?
>> JASON HIRSCHHORN: უკაცრავად.
სამი ძირითადი არგუმენტი თქვენ ვერ გაივლის მეორე არგუმენტი fopen.
თქვენ უფლება - ფაილის სახელი პირველი არგუმენტი.
მაგრამ მეორე არგუმენტი fopen არის ზოგადად სამი სიმები, და - დიახ.
Aleja.
>> Aleja: A განთავსების დამატება.
>> JASON HIRSCHHORN: A, თუ გსურთ დამატება ფაილი, რომელიც უკვე არსებობს.
>> სტუდენტური 5: R განთავსების წაკითხული.
>> JASON HIRSCHHORN: R, თუ მინდა წაიკითხონ ფაილიდან.
>> სტუდენტური 6: W განთავსების ჩაწერის.
>> JASON HIRSCHHORN: და w, თუ გსურთ დაწეროთ ფაილი.
ასე რომ, ამ შემთხვევაში, ჩვენ წერილობით ფაილი, ამიტომ ჩვენ გვაქვს w.
გასახსნელად, თქვენ ასევე უნდა გადავარჩინოთ ფაილი სადმე, და ეს ერთად
კოდი მარცხენა მხარეს, დავალება ოპერატორი -
მე შექმნაში მომცეთ ფაილი მოუწოდა, ამ შემთხვევაში, ფაილი.
>> ჩვენ არ ვაპირებთ ფიქრი რა ამ ყველა caps ი რამ არის.
საკმარისია ითქვას, რომ ეს არის დიდი ნაკადი zeros და პირობა.
და ასე ვაპირებთ მუშაობას და გაგება.
>> შემდეგი რამ უნდა გავაკეთოთ - და ეს არის ძალიან მნიშვნელოვანი -
როცა გახსნა ფაილი -
ფაქტობრივად, როცა მოვუწოდებთ malloc, for მაგალითად, და მიიღოთ გარკვეული მეხსიერება და ვცდილობთ
და შეინახეთ ის მაჩვენებელი, თქვენ ყოველთვის გსურთ შეამოწმოთ, რომ დავრწმუნდეთ, რომ
ფუნქცია არ დაბრუნდება null.
>> ასე რომ, ამ შემთხვევაში, ჩვენ შემოწმების რათა დარწმუნებული ვარ, რომ ჩვენ რეალურად გახსნა
ფაილის სწორად, და არ იყო შეცდომა ჩვენი პროგრამა.
შემდეგი, ერთხელ ჩვენ შემოწმდება, რათა დავრწმუნდეთ, რომ ჩვენ გვაქვს მუშაობის ფაილი, ჩვენ შეგვიძლია
ვწერ, ან ვკითხულობ, ან დამატება ფაილი.
ამ შემთხვევაში, მე უბრალოდ ბეჭდვა ერთი ხაზი ამ ფაილს.
>> როგორ მე ვიცი, რომ?
ისე, მე გამოყენებით ამ ფუნქციას ე.წ. fprintf.
ყველა ფუნქციების თქვენ გამოყენებით როდესაც წერა, ან კითხვა, ან
მანიპულირების ფაილი მსგავსი იქნება ფუნქციების თქვენ მინახავს ადრე, მაგრამ
იწყება წერილი F, იდგა ფაილი.
და fprintf, განსხვავებით ჩვენი ნორმალური print app იღებს ერთი დამატებითი არგუმენტი,
და ეს არის ფაილი სადაც თქვენ გვინდა ბეჭდვა ეს ხაზი.
>> მე არ მაქვს არაფერი მარჯვნივ ohai.
მე არ მაქვს მესამე არგუმენტი printf -
ან მეორე არგუმენტი printf, მესამე არგუმენტი fprintf, რადგან მე
არ გაქვთ placeholders აქ.
მე არ ვარ მათ შორის ნებისმიერი ცვლადები.
მაგრამ ერთხელ, fprintf და ყველა ეს ფაილი ფუნქციები, რომელიც მოქმედებენ ფაილი
ზოგადად სჭირდება ფაილი რომელზეც ისინი ფუნქციონირებს.
>> საბოლოოდ, ბოლო მნიშვნელოვანი რამ გააკეთოთ დახურეთ ფაილი, ისევე, როგორც
ერთად - როდესაც ჩვენ malloc რაღაც, ჩვენ გვინდა თავისუფალი, რაღაც, მცირეოდენ ჩვენ
აქვს მეხსიერების გაჟონვის - ჩვენ გვინდა დახურვა ჩვენი ფაილი.
იმ შემთხვევაში, თუ ამ პროგრამის დასრულების გარეშე დახურვის ფაილი, შანსები არაფერი წავიდოდა
არასწორია, განსაკუთრებით, თუ ის იყო პატარა ფაილი.
>> მაგრამ ეს, რა თქმა უნდა კარგი კოდირების სტილი და პრაქტიკაში ყოველთვის დახუროთ თქვენი ფაილი
როდესაც თქვენ დასრულდა გამოყენება.
ასე რომ საფუძვლებს ფაილის I / O. თქვენ ალბათ ჩანს, რომ ადრე, ან
პოპულარულები ის, რომ ფანტასტიკური მოკლე.
ვინმეს გაქვთ რაიმე შეკითხვები, სანამ ჩვენ წასვლას გარკვეული პრაქტიკა კოდირება
პრობლემების, ფაილის I / O ან ნაბიჯები მე უბრალოდ წავიდა?
>> [Typing ხმები]
>> JASON HIRSCHHORN: თქვენ მაქვს შეკითხვა, Avi?
>> AVI: არა
>> JASON HIRSCHHORN: OK.
მე ვაპირებ დაველოდოთ კიდევ შვიდი წამი.
[იცინის]
ეს მართლაც კარგი წვერი.
შენ უბრალოდ არ მომწონს სვამს კითხვებს.
ეს ჯარიმა.
OK.
ამიტომ ჩვენი პირველი პრაქტიკა პრობლემა ის არის, რომ ჩვენ ვართ აპირებს დუბლიკატი ფუნქცია
ბრძანების ინსტრუმენტი, რომ თქვენ ალბათ უხმარია - ასლი -
ასლი ინსტრუმენტი.
თუ თქვენ ტიპის cp და შემდეგ გაიაროს ეს ორი არგუმენტები თქვენს ტერმინალი, შეგიძლიათ
ასლი ფაილი.
და ეს არის ის, რაც ჩვენ ვაპირებთ წერენ ახლა.
>> ასე რომ კიდევ ერთხელ, კითხულობს off ამ slide, მინდა გაძლევთ დაწეროთ პროგრამა, რომელიც იღებს
ორი და მხოლოდ ორი ბრძანება ხაზი არგუმენტები -
წყაროს ფაილი და დანიშნულების ფაილი -
და ასლები შინაარსი წყარო წარადგინოს დანიშნულების ფაილი
ერთი byte დროს.
ასე რომ ბევრი ითხოვენ.
>> ერთხელ, კარგი მიდგომა ამ არის არ წავიდეთ პირდაპირ C კოდი, მაგრამ
შესვენება მას შევიდა რამდენიმე ნაბიჯები.
პირველი, ვიფიქროთ ლოგიკა - ზუსტად რა მე გეკითხებით თქვენ უნდა გააკეთოთ -
და მესმის ყველა ნაბიჯები, რათა ეს პრობლემა.
არა C, უბრალოდ ზოგიერთ pseudocode, ან თუნდაც გონებრივი მოდელი
რა ხდება.
>> შემდეგი, ერთხელ თქვენ გაქვთ pseudocode down, გაერკვნენ, თუ როგორ pseudocode
რუკები გადატანა ინსტრუმენტები და რამ ჩვენ შეიტყო გამოყენება C.
>> და ბოლოს, კიდევ გაქვთ, რომ ყველა ერთად, შეგიძლიათ კოდექსის პრობლემა.
მიიღეთ 5 10 წუთი მუშაობა ამ პრობლემას.
მე დააყენა ინსტრუქციები უკან მეორე.
და მაშინ ჩვენ ვაპირებთ წავიდეთ მეტი pseudocode და კოდი
იგი ცხოვრობს როგორც ჯგუფი.
>> იმ შემთხვევაში, თუ თქვენ გაქვთ რაიმე შეკითხვები, ხოლო თქვენ ვმუშაობთ, მოგერიდებათ დააყენებს
თქვენი მხრივ, და მე მოვა გარშემო და უპასუხოს მათ.
>> სტუდენტური 7: შემიძლია დარტყმა ნაჭერი ქაღალდი?
>> JASON HIRSCHHORN: რა არის up?
>> [Typing ხმები]
>> JASON HIRSCHHORN: OK.
მოდით წავიდეთ მეტი pseudocode პირველი და მაშინ მე მივცემ თქვენ რამდენიმე
ე დასრულება კოდირების.
>> ვისაც სურს დაიწყოს me off პირველი ხაზი
pseudocode ამ ფუნქციას?
>> სტუდენტური 8: შეამოწმეთ რომ დავრწმუნდეთ, რომ თქვენ მოცემულია ორი ფაილი.
>> JASON HIRSCHHORN: OK.
და თუ ჩვენ არა ვართ?
>> სტუდენტური 8: მე დაბრუნებას 0.
>> JASON HIRSCHHORN: უნდა დაბრუნდნენ 0?
>> სტუდენტური 8: დაბრუნება -
blanking.
უკაცრავად.
>> JASON HIRSCHHORN: ჰო.
ალბათ არა 0.
იმის გამო, 0 ნიშნავს, რომ ყველაფერი კარგი იყო.
OK.
ასე რომ, პირველი ხაზი საქართველოს pseudocode.
ვის აქვს მეორე ხაზი pseudocode?
>> სტუდენტური 9 Open ორივე ფაილი?
>> JASON HIRSCHHORN: გახსენით ორივე ფაილი.
OK?
>> STUDENT 10: შეამოწმეთ თუ ფაილი არის NULL?
>> JASON HIRSCHHORN: შეამოწმეთ რათა დარწმუნებული ვარ, არც NULL.
როგორც განზე -
slash 0 -
ის არის, რომ NULL?
>> STUDENT 11: No
>> JASON HIRSCHHORN: ეს არ არის NULL.
რომ ეწოდება NULL terminator.
სინამდვილეში ჩაწერეთ მხოლოდ ერთი l.
ისე შემოწმების რაღაც წინააღმდეგ, რომ - რომ რეალურად ხასიათი -
ისე შემოწმების რაღაც წინააღმდეგ, რომელიც არ არის იგივე როგორც შემოწმების თუ ის
უდრის NULL.
>> და ზოგიერთი ადამიანი -
მათი ტესტები და მათი პრობლემა კომპლექტი - გვაქვს
ორი იმ დაბნეული.
მაგრამ ორი მათგანი არის სინამდვილეში განსხვავებული.
ერთი დამთავრდა string -
ერთი მომცეთ 0.
>> STUDENT 12: რატომ არ შეამოწმებს დარწმუნდით, რომ ფაილი არ არის NULL
სანამ გახსნა მათ?
>> JASON HIRSCHHORN: So ღია ზოგავს რაღაც რომ ფაილი.
და თუ აქ -
ასე რომ, ეს ხაზი - fopen -
მოგაწვდით მისამართი და მაღაზია რომ მისამართი ფაილს თუ ის მუშაობს.
თუ ეს არ იმუშავებს, ეს შეინახავს NULL -
>> STUDENT 12: Oh.
OK.
მივიღე თქვენ.
>> JASON HIRSCHHORN: In ფაილი.
ასე რომ თქვენ ვერ შემოწმება NULL სანამ თქვენ გახსნა მათ.
NULL ნიშნავს, რაღაც არ იმუშავებს სწორად.
OK.
ასე რომ, შემოწმება, რათა დავრწმუნდეთ, არც არის?
ან?
რას ფიქრობთ?
ჩვენ წავიდეთ ერთად, რომ.
>> STUDENT 13: არის.
>> JASON HIRSCHHORN: არის?
არც არის?
>> STUDENT 13: არის.
>> JASON HIRSCHHORN: OK.
ჩვენ, როგორც ჩანს, გარკვეული კონსენსუსი, რომ.
არც არის NULL.
OK, შემდეგი ხაზი pseudocode.
ვინ არ მომცა ხაზი არის?
ჩვენ დაველოდებით თქვენ.
ჰო.
>> STUDENT 14: თქვენ უნდა წაიკითხოთ პირველი ფაილი?
>> JASON HIRSCHHORN: OK.
>> STUDENT 14 ან ვიყენებთ fscanf ან ასე რომ პირველი ფაილი?
>> JASON HIRSCHHORN: ასე რომ ჩვენ გვინდა, რომ წაკითხვის პირველი ფაილი და -
მოდით დააყენა, რომ უფლება აქ.
წაკითხვის წყარო ფაილი.
და მაშინ, რას ვაკეთებთ შემდეგ ჩვენ წაკითხვის წყარო ფაილი?
სხვისი?
>> STUDENT 15: დაწერეთ შევიდა დანიშნულების ფაილი?
>> JASON HIRSCHHORN: ჩვენ ვწერ დანიშნულების ფაილი, და -
OK.
რა ვართ დაკარგული?
სხვისი, ვინც არ მომცა ხაზი კოდი ყოლა - საქართველოს pseudocode.
ჰო.
>> STUDENT 16: შესაძლოა თქვენ ყოველთვის შეგიძლიათ გადაამოწმოთ არსებობს თუ არა რაიმე წაიკითხავს,
ისევე როგორც მომდევნო ხაზი?
, რომლებიც, ისევე როგორც მომდევნო ხაზი, თუ იგი არსებობს.
>> [ELECTRONIC BEEP]
>> JASON HIRSCHHORN: Oops.
ეს არის ჩემი journaling პროგრამული უზრუნველყოფა.
ჰო?
>> STUDENT 16: Yeah.
>> JASON HIRSCHHORN: ასე რომ ეს ჩემთვის კიდევ ერთხელ.
>> STUDENT: 16 შეამოწმეთ თუ არსებობს მაინც მომდევნო ხაზი
წყარო ფაილი წაიკითხოს.
>> JASON HIRSCHHORN: OK.
ასე რომ ჩვენ არ კითხულობს ხაზები - კითხულობს bytes აქ -
მაგრამ თქვენ სწორი.
ჩვენ გვინდა, რომ წაიკითხოთ და დაწეროთ სანამ არ არსებობს უფრო bytes.
OK.
და ა.შ. ეს უნდა იყოს ნამდვილად indented ცოტა, იმიტომ, რომ ისინი ქვეშ არსებობს.
უფლება?
სანამ ჩვენ გარეთ ბაიტი, ჩვენ ვაპირებთ წაკითხვის წყარო ფაილი და დაწეროთ
დანიშნულების ფაილი.
>> და მაშინ, რა არის ბოლო ხაზი pseudocode?
ვინც არ მიეცა ჩემთვის რაღაც არავის გაუკეთებია.
>> STUDENT 17 დახურვა ფაილი?
>> JASON HIRSCHHORN: ზუსტად.
დახურვა ფაილი.
ასე რომ ჩვენი pseudocode.
მე ვაპირებ დააყენა pseudocode შევიდა gedit და რამდენიმე წუთში ჩვენ
იქნება კოდექსს ერთად.
>> OK.
მოდით დავიწყოთ, როგორც ჯგუფი.
Nishant, მე მაქვს ჩემი ახალი ფაილი.
მე უბრალოდ გახსნა ამ მდე.
Untitled document 1.
რა არის პირველი რაც უნდა გავაკეთოთ?
>> NISHANT: ჩართეთ ბიბლიოთეკები?
>> JASON HIRSCHHORN: OK.
რა ბიბლიოთეკებს?
>> NISHANT: stdio.h, stdlib.h, მე მჯერა?
>> JASON HIRSCHHORN: OK.
რა არის stdlib ამისთვის?
>> NISHANT: დამავიწყდა.
>> JASON HIRSCHHORN: OK.
ასე რომ, არის stdio.
რა უნდა გავაკეთოთ, კიდევ დავიწყო კოდირების?
>> NISHANT: დაწერეთ header?
>> JASON HIRSCHHORN: როგორ მივიღებ ეს ფერადი?
>> [INTERPOSING VOICES]
>> NISHANT: როგორ იღებთ ეს ფერადი?
>> JASON HIRSCHHORN: როგორ შემიძლია ფერადი კოდირების?
>> NISHANT: მე არ ვიცი.
Oh.
გადარჩენა.
>> JASON HIRSCHHORN შენახვა.
დიახ.
მე უნდა გადარჩენა, როგორც. გ.
ასე რომ გადარჩენა ეს დესკტოპის როგორც cp.c.
ტკბილი.
და თუ მინდა მიიღოს სრული სტილი რაოდენობა, რა უნდა
არის ზედა?
>> NISHANT თქვენ შეეძლო დაეწერა თქვენი სახელი, გვარი პროგრამა, და მიზანი
პროგრამა ასევე?
>> JASON HIRSCHHORN: კარგად გამოიყურება.
შესანიშნავი.
ასე რომ, თქვენ დაიწყო us off შესანიშნავად.
# მოიცავს -
ჩვენ ასევე წერა -
OK.
ასე რომ, მე ვფიქრობ, მე ყველა მითითებული წასვლა.
ვის აქვს პირველი ხაზი კოდი me - ან პირველი ხაზი კოდი, რომ
დასჭირდება, რათა დააკმაყოფილოს ჩვენი პირველი კომენტარის pseudocode?
თქვენ.
>> STUDENT 18: არ უნდა იყოს ის, int argc და შემდეგ char * argv?
>> JASON HIRSCHHORN: ვფიქრობ თქვენ უფლება.
მოდით შეცვალოს იგი int, მთავარ ღია paren, int argc, მძიმე, char * argv?
ასე?
>> STUDENT 18 ფრჩხილებში.
>> JASON HIRSCHHORN: ფრჩხილებში.
ღია bracket, ახლო bracket, close მშობელი.
სრულყოფილი.
ახლა შემიძლია მიიღოს ბრძანება ხაზი არგუმენტები.
OK.
დარწმუნდით ჩვენ მოცემული ორი ფაილი.
შეგიძლიათ მომეცი რომ ისევე.
>> STUDENT 18: თუ argc -
ეს ერთი არ გაუტოლდება 3.
>> JASON HIRSCHHORN თუ ღია paren argc არ უდრის 3?
>> STUDENT 18: Yeah, თქვენ დაბრუნდება 1 ან არაფერი.
>> JASON HIRSCHHORN: უკაცრავად.
>> STUDENT 18 Return 1 ან არაფერი.
>> JASON HIRSCHHORN: დაბრუნება 1.
OK?
დიდი.
გახსენით ორივე ფაილი.
ვისაც შეუძლია დამეხმაროს გახსნა ორივე ფაილი?
ვინ არ მომცა კოდი არის?
Kurt?
>> KURT: ასე რომ ყველა caps F-I-L-E star წყარო.
>> JASON HIRSCHHORN: მე ვაპირებ აიღოს ხმოვანთა.
ეს არის მაგარი.
ეს მოსწონს Tumblr.
>> STUDENT 18 უდრის fopen -
>> JASON HIRSCHHORN: უდრის fopen?
>> STUDENT 18: ღია paren, argv, ღია bracket.
>> JASON HIRSCHHORN: Wait.
უკაცრავად.
ღია paren.
OK.
>> STUDENT 18: Yeah.
Argv sub 1.
>> JASON HIRSCHHORN: Sub 1?
>> STUDENT 18: Yeah.
Argv ღია bracket 1 -
დიახ.
და შემდეგ მძიმე, და შემდეგ ღია ორმაგი გაცემა, r, ორმაგი გაცემა,
close paren, მძიმით.
>> JASON HIRSCHHORN: Sweet.
რაც შეეხება მეორე?
>> STUDENT 18: მსგავსი, არამედ S-R-C, ნეტავ ეძახით D-S-T.
>> JASON HIRSCHHORN: Oo!
მომწონს, რომ.
>> STUDENT 18: Just D-S-T. ჰო.
და შემდეგ argv, ღია bracket, 2.
ჰო.
და შემდეგ w ნაცვლად რ.
ჰო.
>> JASON HIRSCHHORN: Great.
მომდევნო რამდენიმე ხაზები.
ასევე, თუ ვინმეს აქვს რამ რჩეულებში ხაზები, რომ ჩვენ გავაკეთეთ, მოგერიდებათ
დაამატოთ იმ, ისევე.
შეამოწმეთ რომ დავრწმუნდეთ არც არის NULL.
ვის შეუძლია მომეცი კოდი უნდა დააკმაყოფილა, რომ ხაზი pseudocode?
Archer.
>> ARCHER თუ src შეადგენს შეადგენს NULL ან dst შეადგენს შეადგენს
NULL, მაშინ დაბრუნდება -
>> JASON HIRSCHHORN: What?
>> ARCHER: დაბრუნება 2?
>> JASON HIRSCHHORN: დაბრუნება 2.
ასე რომ, თუ ღია paren src შეადგენს უდრის NULL, ან -
რასაც thing's - მილები?
Pipe?
ჩვენ მოვუწოდებთ მას მილს.
მილები, მილის, dst შეადგენს შეადგენს NULL, დაბრუნდება 2.
OK?
სანამ ჩვენ გარეთ bytes -
ჩვენ ერთგვარი გამოტოვებენ ამ ნაბიჯს pseudocode ნაწილი აპირებს აქ.
>> მაგრამ სანამ ჩვენ გარეთ bytes - რას გავს?
რა ტიპის C სტრუქტურა -
მაგრამ მე არ გამოიყენოს სიტყვა სტრუქტურა, იმიტომ, რომ ჩვენ ვაპირებთ დავიწყოთ გამოყენებით
რომ სხვა შემთხვევაში -
მაგრამ C ინსტრუმენტი აკეთებს, რომ გავს?
>> STUDENT 19: loop.
>> JASON HIRSCHHORN: A loop.
ჟღერს loop.
ასე რომ, ვისაც შეუძლია მომეცი პირველი ხაზი მარყუჟის კოდი უფლება აქ?
თქვენ ასევე შეგიძლიათ აირჩიოთ, თუ რა სახის loop გსურთ, თუ თქვენ მომეცი
ეს ხაზი კოდი.
არსებობს სამი სახის.
თქვენ უნდა აირჩიოთ.
მინდა ვარაუდობენ ერთ იმ.
Avi.
რომელი ერთი გინდათ?
>> AVI: FOR.
>> JASON HIRSCHHORN: FOR.
>> AVI: int i ნულის ტოლი.
>> JASON HIRSCHHORN: OK.
>> AVI ეს ნაწილი მე არ ვარ დარწმუნებული.
მაგრამ მე ნაკლებია, ვიდრე ზომა ვარსკვლავი წყარო?
მე არ ვარ დარწმუნებული, რომ.
>> JASON HIRSCHHORN: OK.
>> AVI: იმის გამო, რომ გსურთ ზომის ფაილების, არა?
>> JASON HIRSCHHORN: ასე რომ, ეს ალბათ არ მოგვცეს ზომა ფაქტობრივი
ფაილი bytes.
ასე რომ, რა შეიძლება გავაკეთოთ?
რა არის სხვა ტიპის loop?
ან უნდა გამყარებაში იყიდება loop?
>> STUDENT 20: იქნებ გავაკეთოთ ხოლო loop?
და შემდეგ, რა ნეტავ გავაკეთოთ არის you'd -
იმიტომ რომ ჩვენ გვაქვს char * ფაილი.
ასე რომ, თუ ჩვენ უბრალოდ გააგრძელეთ დამატება, რომ სანამ ჩვენ გვინდა ვიპოვოთ NULL ხასიათი at
ბოლოს ეს?
ან არა, ის არის, რომ არა ფაილი მუშაობს?
>> JASON HIRSCHHORN: ასე რომ ჩვენ შეგვიძლია შევინარჩუნოთ დამატება char *
სანამ ჩვენ NULL -
>> STUDENT 20 არსებითად შენარჩუნებას აპირებს ხასიათი ხასიათი, სანამ ჩვენ მოხვდა
ბოლოს ფაილი.
>> JASON HIRSCHHORN: დიახ.
ასე რომ, ის, რაც ჩვენ გვინდა, რომ გავაკეთოთ.
ჩვენ გვინდა, რომ შევინარჩუნოთ reading, ხასიათი by ხასიათი, სანამ არ მივიღებთ
ბოლოს ფაილი.
>> STUDENT 20: Yeah.
მონახე -
რა არის ბოლოს და გაჩერების ნიშანი ბოლოს ტექსტური ფაილი.
>> JASON HIRSCHHORN: OK.
ასე რომ, როდესაც მივიღებთ ბოლომდე ფაილი - ვიცით ჩვენ მიაღწია
ბოლოს ფაილი?
იმ შემთხვევაში, თუ მე მოუწოდებდა -
მოდით უკან დახევას.
რა არის ფუნქცია?
მოდით წავიდეთ ამ ხაზის უფლება აქ.
წაკითხვის წყარო ფაილი.
ვის შეუძლია მაძლევს, რომ ხაზი კოდი?
>> STUDENT 21 fscanf?
>> JASON HIRSCHHORN: fscanf.
OK.
რა მოხდება თუ მე მინდა წაიკითხონ, ძალიან კერძოდ, ერთი ბაიტი?
>> STUDENT 21: არ ვიცი.
>> JASON HIRSCHHORN: OK.
კიდევ უფრო მარტივი, ვიდრე fscanf - რა არის -
მინდა წაიკითხოთ წყარო ფაილი?
დაწვრილებით წყარო ფაილი.
რა არის ფუნქცია - yeah.
>> STUDENT 22: ეს fread?
>> JASON HIRSCHHORN: Fread.
მე ვფიქრობ, მოდით გამყარებაში რომ ერთი არის.
რა სახის არგუმენტები ჯერ fread მიიღოს?
>> STUDENT 22: ალბათ ფაილის ტიპის, და შემდეგ ადგილმდებარეობა ფაილი?
>> JASON HIRSCHHORN: რა შემიძლია აკრიფოთ აქ გაერკვნენ, თუ რა ტიპის არგუმენტები
fread იღებს?
>> მრავალჯერადი სტუდენტური მამაკაცს fread.
>> JASON HIRSCHHORN: Man fread და fwrite.
როგორც ჩანს, ისინი გათიშეთ out ერთად.
ასე fread იღებს რამდენი არგუმენტები?
>> STUDENT 23: ოთხი.
>> JASON HIRSCHHORN: იგი იღებს ოთხი არგუმენტები.
იგი იღებს მაჩვენებელი, ზომა, და რომ რამ, რაც არის უცნაური, და ზოგიერთი ფაილი.
OK?
მოდით წაიკითხოთ ამის შესახებ აქ.
"ფუნქცია fread ნათქვამია n memb ელემენტები მონაცემები, თითოეული ზომით bytes
ხანგრძლივი, საწყისი ნაკადი მიუთითა მიერ ნაკადი, შენახვა მათ მდებარეობა
მიერ მოცემული მაჩვენებელი. "
>> ასე რომ ოთხი არგუმენტები.
რატომ არ მე უბრალოდ დააკოპირეთ ეს, და ჩასვით აქ.
OK.
ასე რომ, ვისაც შეუძლია დაიწყოს შევსების ეს არგუმენტები ჩემთვის?
Avi.
>> AVI: Take out ბათილად.
განათავსეთ უბრალოდ src.
აიღოს მაჩვენებელი და ვარსკვლავი.
განათავსეთ src.
შემდეგ -
>> JASON HIRSCHHORN: ასე რომ მე ვაპირებ შეწყვიტოს თქვენ არ არსებობს, იმიტომ, რომ არასწორია.
თქვენ უფლება src, მაგრამ სად უნდა src წავიდეთ?
>> [INTERPOSING VOICES]
>> JASON HIRSCHHORN: ეს უნდა წავიდეთ მეტი აქ.
სწორედ src - ჩვენი src არის ტიპის.
მოდით შევხედოთ აქ.
ეს ითხოვს ტიპის ფაილ *, ჩვენ რეალურად, როგორც წესი, ვხედავთ, რომ.
ასე რომ, ეს ითხოვს არგუმენტი ჩაწერეთ ი * მოუწოდა ნაკადი რომ არის src.
OK?
>> რა ზომა რამ ჩვენ გვინდა, რომ წაიკითხოთ?
მივეცი თქვენ ამ პრობლემის აღწერა.
>> სტუდენტთა 24: ერთი byte დროს.
>> JASON HIRSCHHORN: ერთი byte.
როგორ დიდი არის byte?
მისი ზომა ბაიტებში, მერე რა შემიძლია დააყენა უფლება არსებობს?
>> STUDENT 25: One.
>> JASON HIRSCHHORN: One.
უფლება.
მისი ზომა არის ერთეული byte, ასე რომ 1 არის 1 byte.
რამდენი მინდა წაკითხვის დროს.
>> STUDENT 26: One?
>> JASON HIRSCHHORN: ერთი რამ.
მე მინდა წაიკითხონ ერთი რამ ზომა 1, ერთი bite დროს.
და სად მე ამას, კიდევ ერთხელ წავიკითხე ეს?
>> STUDENT 27 დანიშნულება?
>> JASON HIRSCHHORN: ასე რომ მე ვერ დააყენა ეს სწორი შევიდა დანიშნულების.
>> STUDENT 28: თქვენ კარგად დააყენა მას მესამე მაჩვენებელი?
>> STUDENT 27 დან დანიშნულების.
>> JASON HIRSCHHORN: OK.
ჰო.
>> STUDENT 29: თქვენ შეგიძლიათ გამოაცხადოთ რაღაც იმოქმედოს, როგორც დროებითი შენახვის ადრე.
>> JASON HIRSCHHORN: OK.
მომეცი, რომ.
>> STUDENT 29 სხვა ფაილი მაჩვენებელი, იქნებ?
>> JASON HIRSCHHORN: OK.
ასე რომ, ეს არის ბათილად star -
ის ტიპის ბათილად ვარსკვლავი, ასე რომ არ უნდა იყოს ფაილის მაჩვენებელი.
და თუ მე კითხულობს ერთი byte, სადაც იქნება კარგი ადგილია
შესანახად ერთი byte?
>> STUDENT 29 მასივი?
>> JASON HIRSCHHORN: მასივი.
OK.
და რა არის ის, რაც უბრალოდ ზომა ერთი byte?
>> STUDENT 30 char *?
>> STUDENT 29: Yeah.
>> JASON HIRSCHHORN: A char * არ არის ერთი ბაიტი.
>> STUDENT 29 char.
>> JASON HIRSCHHORN: A char არის ერთ ერთი byte.
უფლება?
მოდით მოვუწოდებთ ამ ბუფერულ არის generic სახელი გამოიყენება ეს ყველაფერი შესანახად
რაღაც დროებით.
ასე რომ, მე შექმნას ბუფერული.
უფლება?
მაგრამ ეს არ მიიღოს void *.
იქნებ თქვენ უფლება, რომ უნდა იყოს ბუფერული ზომა 0.
ასე რომ ინახავს ერთ -
უფლება.
>> იმიტომ, რომ ეს სწორედ აქ - char ბუფერული არის ხასიათი, მაგრამ
ეს იღებს ბათილად * -
მაჩვენებელი.
ასე რომ, მე ვერ გავაკეთებ ამ და ახლა ბუფერული არის მაჩვენებელი.
რა შეიძლება გავაკეთო?
>> STUDENT: 31 განათავსეთ star შემდეგი char.
>> JASON HIRSCHHORN: შემეძლო შევქმენი ეს char *.
OK.
რა არის კიდევ ერთი რამ, მე ვერ გავაკეთებ?
ან მოდით წავიდეთ ეს ერთი.
Char * ბუფერული, ასე რომ შემიძლია დააყენა აქ?
>> STUDENT 31 ბუფერული.
>> JASON HIRSCHHORN: Buffer.
ბუფერული არის მომცეთ char.
და რომ მდებარეობა, ჩვენ აყენებს ერთი byte რაღაც ჩვენ წაიკითხა.
ჰო.
Avi.
>> AVI: უბრალოდ სწრაფი კითხვა.
გსურთ malloc ბუფერული?
>> JASON HIRSCHHORN: ვის შეუძლია ამ კითხვაზე პასუხის გაცემა?
>> STUDENT 32: ისე, ეს ნამდვილად არ წერტილი არაფერს ახლა, ისე -
>> JASON HIRSCHHORN: მაგრამ ჩვენ გვინდა malloc ეს?
>> STUDENT 32 თუ იყო ამის გაკეთება, რომ ისე, ვფიქრობ, yeah, რადგან ნეტავ უნდა
რამდენიმე ადგილას ეს აღვნიშნო.
>> JASON HIRSCHHORN: Do we უნდა malloc ეს?
>> STUDENT 33: თუ თქვენ აპირებთ გამოიყენოს იგი გარეთ loop.
>> JASON HIRSCHHORN: ჩვენ ვაპირებთ გამოიყენოს იგი გარეთ loop?
>> STUDENT 34: დიახ.
>> STUDENT 35 მოითმინოთ.
გვინდა გამოაცხადოს ის ამ loop to მის ფარგლებს გარეთ?
>> JASON HIRSCHHORN: ასე რომ, ვფიქრობ, ჩვენ ზოგიერთი ფსევდო ხოლო loop აქ, რომ ჩვენ
ცდილობენ გაერკვნენ, რომელიც ჩვენ ჯერ არ მივსულვართ ჯერ.
ჩვენ არ უნდა malloc იგი.
ჩვენ მოქმედი მთავარი, ეს მხოლოდ აპირებს უნდა იყოს გამოყენებული შიგნით ამ loop.
ეს არ უნდა არსებობდეს გარეთ ამ.
>> ასე რომ, ეს შეიძლება იყოს ადგილობრივი ცვლადი.
თქვენ უნდა მომცეთ ადგილობრივი ცვლადი.
>> STUDENT 36: მაგრამ ეს არ არის მიუთითებს არაფერი.
>> JASON HIRSCHHORN: არა, ეს არ არის ინიციალიზაცია არაფერი.
მაგრამ ჩვენ არ ვაპირებთ გამოიყენოს იგი ასევე.
ჩვენ ვაპირებთ დააყენა რაღაც ეს პირველი შემთხვევაა, ვიყენებთ მას.
ასე რომ, როგორც ჩანს, OK.
ასე რომ, ჩვენ არ უნდა malloc აქ.
და მე ვფიქრობ, ეს OK როგორც არის.
OK.
ჩვენ გვაქვს fread ონლაინ.
მოდით მომდევნო ხაზი.
>> თუ გვინდა, რომ ვწერ ფაილს, რა არის კარგი ფუნქციის გამოყენება ამის გაკეთება?
>> STUDENT 37 Fwrite?
>> STUDENT 38 fprintf?
>> JASON HIRSCHHORN: fprintf ერთი.
რა არის ერთი?
>> STUDENT 39 Fwrite.
>> JASON HIRSCHHORN: Fwrite.
და ჩვენი მიზნებისთვის, fwrite, რომელიც ჩვენ ვნახეთ, აქ არის
ალბათ უკეთესი არჩევანი.
იგი იღებს ოთხი არგუმენტები ასევე.
Nishant, შეგიძლიათ მისცეს ჩემთვის არგუმენტები?
>> NISHANT: პირველი აპირებს უნდა იყოს მხოლოდ ბუფერული.
>> JASON HIRSCHHORN: OK.
>> NISHANT: მეორე ერთი უბრალოდ იქნება 1.
მესამე იქნება 1.
და მეოთხე იქნება dst.
>> JASON HIRSCHHORN: ვინმეს აქვს რაიმე შეკითხვები, რომ ხაზი?
რომ კარგად გამოიყურება.
OK.
ასე რომ, ახლა როგორც ჩანს ერთი რამ ჩვენ დაკარგული - ფაქტობრივად, მოდით დავწეროთ
ამ ბოლო ხაზი.
დახურვა ფაილი.
ვინ შეიძლება დასრულდეს us up წერილობით ამ ბოლო ორი ხაზი?
დიახ.
უკაცრავად, რა გქვია?
>> LUCY: Lucy.
>> JASON HIRSCHHORN: Lucy.
>> LUCY: Fclose src და შემდეგ fclose დანიშნულების.
>> JASON HIRSCHHORN: Fclose, ღია paren, src ახლოს paren, მძიმით.
და fclose -
yeah?
>> LUCY: ღია ფრჩხილებში, dst და შემდეგ მძიმით.
>> JASON HIRSCHHORN: Great.
და რა უნდა შეიცავდეს ბოლოს?
>> LUCY: დაბრუნება 0.
>> JASON HIRSCHHORN: დაბრუნება 0.
არ მაქვს?
უბრალოდ კითხვა.
გვაქვს მოიცავს დაბრუნების 0?
>> მრავალჯერადი სტუდენტური: არა
>> JASON HIRSCHHORN: არა
მთავარი აკეთებს ავტომატურად თუ თქვენ გაქვთ ბოლომდე.
მაგრამ, ვფიქრობ, ეს კარგია არის ეს მკაფიოდ.
განსაკუთრებით მაშინ, როდესაც ჩვენ დაბრუნების სხვა რამ მთელი პროგრამა.
OK.
ეს არის ის, რაც ჩვენ აკლია -
ხოლო, თუ რა?
ვინ შეიძლება ვიფიქროთ, რაღაც -
რაღაც გრძნობა, რაც შეიძლება წავიდეს იქ?
მაშინაც კი, თუ ეს მხოლოდ ზოგიერთ pseudocode ისევე როგორც ენა?
>> რა ჩვენ ნამდვილად - რა გვინდა წასვლა სანამ?
ჰო, Lucy.
>> LUCY: ფაილის ბოლოს.
>> JASON HIRSCHHORN: ფაილის ბოლოს.
ასე რომ რას ნიშნავს ბოლომდე ფაილი?
>> LUCY: ერთხელ თქვენ მიღწევა ფაილის ბოლოში, შეწყვიტოს.
>> JASON HIRSCHHORN: OK.
ასე რომ ერთხელ ჩვენ მიაღწიონ ბოლომდე ფაილი.
ვიცით, როდესაც ჩვენ მიაღწია ბოლოს ფაილი?
>> STUDENT 40: მე ვფიქრობ, რომ ბუფერული იქნება მითითებული NULL.
>> STUDENT 41 Buffer ცხადდება შიგნით loop.
>> JASON HIRSCHHORN: ასე ფიქრობთ ბუფერული იქნება მითითებული NULL.
რატომ ბუფერული მითითებული null?
>> STUDENT 40 რადგან, როდესაც თქვენ fread, თქვენ ცდილობთ დააყენა
არაფერი შევიდა ბუფერული.
>> JASON HIRSCHHORN: OK.
ასე რომ თქვენ ფიქრი fread -
როდესაც ჩვენ მიაღწია ბოლოს ფაილი, რა fread აპირებს?
მე ვფიქრობ, რომ კითხვა ჩვენ გაერკვნენ.
რას fread გავაკეთოთ?
იგი დააყენა NULL ბუფერულ, ან აკეთებთ რაღაც?
როგორ შეგვიძლია გაერკვნენ, თუ რას აკეთებს?
>> STUDENT 42: Man.
>> JASON HIRSCHHORN: Man.
მოდით შევხედოთ აქ.
დაბრუნება ღირებულება.
წარმატება, fread და fwrite დაბრუნდნენ ნომერი ნივთები წაიკითხა ან წერილობითი.
ეს რიცხვი შეადგენს ბაიტების რაოდენობას გადაეცემა მხოლოდ მაშინ, როცა ზომა არის 1.
თუ შეცდომა ხდება, ან ბოლომდე ფაილი მიაღწია, დაბრუნების ღირებულება არის
მოკლე საქონლის რაოდენობა ან 0.
>> ასე რომ, ჩვენი მიზნებისთვის, თუ fread აღწევს ბოლოს ფაილი, და იკითხება
ფაილის დასასრულს, იქ არაფერი დარჩა წავიკითხე, რა არის ის დაბრუნებას აპირებს?
>> STUDENT 43: Zero?
>> JASON HIRSCHHORN: What?
>> STUDENT 43: Zero?
>> JASON HIRSCHHORN: Zero.
ის დაბრუნებას აპირებს ნულოვანი.
ასე რომ, ჩვენ ვიცით, რომ fread, როდესაც ჩვენ მიაღწია ფაილის ბოლოში, აპირებს
დაბრუნების ნულოვანი.
როგორ გამოვიყენოთ რომ ჩვენი უპირატესობა?
>> AVI შეგიძლიათ განაცხადოს ცვლადი გარეთ მარყუჟის მოუწოდა ქვითარი.
იმ შემთხვევაში, თუ შემოწმების შეადგენს -
ახლა ერთ - ერთი.
>> JASON HIRSCHHORN: OK.
>> AVI: და მაშინ თქვენ შეგიძლიათ განათავსოთ IF განცხადება მას შემდეგ fread განაცხადა, რომ იმ შემთხვევაში, თუ
fread შეადგენს zero -
არ.
>> JASON HIRSCHHORN: ვინ დაგეხმარებათ Avi out?
>> AVI: რა არის ღირებულება დაბრუნდა fread?
>> JASON HIRSCHHORN: ჩვენ მხოლოდ წავიდა, რომ.
>> AVI: როგორ წარმოადგენს მას?
>> JASON HIRSCHHORN: ასე რომ, ის დააბრუნებს - მოდით ეძებოთ აქ - ის დააბრუნებს
size_t, რომელიც არსებითად მთელი რიცხვი.
ასე რომ, ის დააბრუნებს რიცხვი.
და ჩვენს შემთხვევაში, ის დაბრუნდნენ 1 ან 0 -
1 თუ ეს წავიკითხე ერთი რამ - ერთი ბაიტი, და 0 თუ ჩვენ მიაღწია ბოლომდე.
ასე რომ, თუ fread -
yeah?
>> STUDENT 45: ვერ უბრალოდ დააყენა სრული fread (ბუფერული, 1, 1, src) შევიდა
ხოლო loop?
>> JASON HIRSCHHORN: ასე რომ თქვენ შესთავაზოს ამით შევიდა იქ?
>> [INTERPOSING VOICES]
>> JASON HIRSCHHORN: Hold on.
ასე რომ ჩვენ ridding რომ.
ასე რომ თქვენ სთავაზობს აყენებს fread შევიდა იქ?
რა უნდა ჩვენ ასევე გადაადგილება თუ გსურთ ამის გაკეთება?
>> STUDENT 45 ბუფერული გარეთ.
>> JASON HIRSCHHORN: ჩვენ უნდა ასევე გადაადგილება ამ აქ.
>> STUDENT 45: მაგრამ იმას, რომ მუდმივად გადატანა ნაბიჯია?
>> [INTERPOSING VOICES]
>> JASON HIRSCHHORN: OK.
ასე რომ, ეს არის ის, რაც Okshar შესთავაზა.
ჩვენ შევქმნათ ჩვენი ბუფერული.
ჩვენ ხოლო fread, მაშინ ჩვენ fwrite.
აზრები ამ საკითხთან დაკავშირებით?
>> STUDENT 46 ჩემი ერთადერთი საკითხი არ არის, რომ რეალურად შესრულდეს ბრძანება fread?
>> JASON HIRSCHHORN: Great კითხვა.
როდესაც თქვენ აყენებს ფუნქცია ზარი შიგნით მდგომარეობაში, აკეთებს, რომ
ფუნქციის ზარის შეასრულოს?
ჩვენ ვნახეთ მაგალითები ადრე.
უფლება?
>> STUDENT 46 OK.
ჰო.
ასე რომ, ეს არ შეასრულოს.
>> JASON HIRSCHHORN: ჩვენ ვნახეთ რამ როგორიცაა, რომ ადრე, სადაც ჩვენ გვაქვს
ფუნქციის ზარის შიგნით მდგომარეობა.
ამჯამად რომ ფუნქცია ზარი შეასრულოს?
დიახ.
ასე რომ, პასუხი არის დიახ.
ეს ფუნქცია ზარი განახორციელებს.
თუმცა ისევ და ისევ, არის ის, რაც ჩვენ გვინდა?
>> რა არის ერთი გზა, ჩვენ ვერ გაერკვნენ თუ ის, რაც ჩვენ გვინდა?
>> მრავალჯერადი სტუდენტები: გაუშვით?
>> JASON HIRSCHHORN ჩვენ ვერ აწარმოებს.
მაგრამ სანამ ჩვენ გავაკეთოთ, რომ შეგვეძლო ასევე მსჯელობა მეშვეობით.
იმ შემთხვევაში, თუ -
ამბობენ, რომ ჩვენ ერთი byte ჩვენს შეიტანოს, ჩვენ კიდევ აქ,
ჩვენ კიდევ ეს კოდი.
ამ მიიღებს.
fread დაბრუნდება ერთი byte და ჩაწერს მას ბუფერული.
და ეს იქნება შეაფასოს 1, მარჯვენა, შემდეგ იგი ბრუნდება 1.
>> ასე რომ, ხოლო 1.
ნიშნავს ეს კოდი შიგნით ხოლო loop განახორციელებს?
>> STUDENT 47: Yeah.
ეს სიმართლეა.
>> JASON HIRSCHHORN: დიახ.
1 მართალია.
ეს არ არის 0.
ამიტომ კოდი შიგნით აქ შეასრულოს.
ამიტომ ჩვენ წერენ, რომ.
ჩვენ გადაადგილება უკან ამ ხაზი კიდევ ერთხელ.
ახლა გვაქვს -
ჩვენ დასასრულს ჩვენი ფაილი.
ჩვენ წაკითხვის ბოლოს ჩვენი ფაილი, იმიტომ, რომ ჩვენ მხოლოდ ერთი byte მას.
>> Fread დააბრუნებს 0, მაღაზიები რაღაც ბუფერული.
მე ნამდვილად არ ვიცი, რა იგი ინახავს ბუფერულ.
ჩვენ შეგვეძლო ალბათ ეძებოთ იმისათვის, რომ ნახოთ, თუ რას აკეთებს.
რომ მე ნამდვილად არ ვიცი.
ჩვენ არ ვიცით, ვინ ზრუნავს რა იგი ინახავს ბუფერულ?
მაგრამ ეს არ დაბრუნდება 0.
და მიუხედავად იმისა 0 შეასრულოს?
>> ხოლო 0 არ შეასრულოს.
ასე რომ მაშინ ჩვენ ქვევით აქ.
მოდით მისაღებად შოუ ხელში, თუ ამ არის კოდი ჩვენ უნდა აწარმოებს, ან თუ ჩვენ
უნდა გავაკეთოთ ცვლილებები პირველი.
ასე რომ, თუ თქვენ ფიქრობთ - თქვენ გაქვთ ხმის მიცემა.
თუ ფიქრობთ, რომ ჩვენ უნდა აწარმოებს ამ კოდი როგორც არის, გთხოვთ დააყენებს თქვენი მხრივ.
>> OK.
იქ ერთ -
გაქვთ კითხვა, შეშფოთება?
ჰო.
>> STUDENT 48: შემდეგ გადავდივართ ბუფერული გარეთ მარყუჟის, ჩვენ
უნდა malloc ეს?
>> JASON HIRSCHHORN: Great კითხვა.
შემდეგ გადავდივართ ბუფერული გარეთ loop, გვაქვს malloc ეს?
ეს არის ფარგლებში კითხვაზე.
იმ შემთხვევაში, თუ ჩვენ ინიციალიზაცია ბუფერული გარეთ ამ მარყუჟის, იქნება ეს არსებობს
შიგნით loop?
>> მრავალჯერადი სტუდენტური: დიახ.
>> JASON HIRSCHHORN: დიახ.
მოქმედების არეალი მოიცავს შიგნით მარყუჟის, და, მართლაც, არაფერს ქვემოთ შიგნით
ამ კოდექსის, მათ შორის, რამ შიგნით აქ.
ასე რომ, ჩვენ არ უნდა malloc იგი.
ეს ადგილობრივი ცვლადი, და მის ფარგლებს მაინც მოიცავს loop.
>> STUDENT 49: ჩვენ უნდა გავათავისუფლოთ ეს?
>> JASON HIRSCHHORN: Do we უნდა უფასო ბუფერული?
>> STUDENT 49: Yeah, თუ ჩვენ არ malloc.
>> JASON HIRSCHHORN: Do we უნდა უფასო ბუფერული?
არა.
ისევ, ეს არის ადგილობრივი ცვლადი, ამიტომ ჩვენ არ უნდა გავათავისუფლოთ იგი.
OK.
ვნახოთ, რა მოხდება.
ასე რომ, ეს არის uninitialized.
ეს იყო რა, რომ რაღაც Marcus გააკეთა.
ასე რომ, ჩვენ, რომ შეცდომა, ცვლადი ბუფერული არის uninitialized როდესაც გამოიყენება აქ.
>> როგორ შეგვიძლია დაფიქსირება ამ?
>> STUDENT 50 Malloc ეს?
>> STUDENT 51 უდრის NULL?
>> STUDENT 52: Say ბუფერული უდრის NULL.
>> JASON HIRSCHHORN: OK.
კარგად გამოიყურება.
ჩვენ ახლა.
მოდით შევქმნათ რაღაც ცდილობენ კოპირება.
ასე რომ, ჩვენ გვაქვს ჩვენი ტექსტური ფაილი.
როგორ შეგვიძლია აწარმოებს ამ პროგრამის?
ჰო.
>> STUDENT 53: შეგიძლიათ გააკეთოთ dot slash cp, test.txt.
და მაშინ ასახელებს სხვა ფაილი რომელიც მას შესანახად შევიდა.
>> JASON HIRSCHHORN: OK.
ჩვენ მოვუწოდებთ მას out.txt.
Cool?
Seg ბრალია.
ფიქრები seg ბრალია?
ეს არის დიდი.
როგორ შეგვიძლია გავარკვიოთ, სადაც seg ბრალია?
რა?
>> STUDENT 54 GDB.
>> JASON HIRSCHHORN: GDB.
ჩვენ აწარმოებს GDB წერილობით GDB dot ხაზი, სახელი ჩვენი პროგრამა.
არარის ბრძანება ხაზი არგუმენტები არსებობს.
ჩვენ ვაპირებთ, რომ მითითებული breakpoint დროს ძირითადი.
იმ შემთხვევაში, თუ მინდა, რომ დაიწყოს GDB, რა გავაკეთო?
>> STUDENT 55: R.
>> JASON HIRSCHHORN: R. და მერე რა?
>> STUDENT 55 არგუმენტები?
>> JASON HIRSCHHORN: მაშინ ბრძანების ხაზი არგუმენტები.
მოდით გავლა.
N უბრალოდ აღების ჩემთვის ხაზს.
მე ვაპირებ წასვლა სანამ მივიღო ჩემი seg ბრალია.
იქ ჩემი seg ბრალია.
ეს ჰგავს fread გამოიწვია ჩემი seg ბრალია.
მე ვიცი fread გამოიწვია ჩემი seg ბრალია, იმიტომ, რომ იყო
ონლაინ ჩვენ უბრალოდ დახვრიტეს.
>> და ერთადერთი, რაც იყო, ხდება, რომ ხაზი -
ორი რამ ხდებოდა.
Fread ხდებოდა, და მაშინ ვიყავით აკეთებს ზოგიერთი ხოლო შემოწმების.
მე სურვილი დადებს, რომ იმ დროს, როდესაც შემოწმების არ იწვევს ჩემი seg ბრალია.
სავარაუდოდ, fread იყო რამაც ჩემი seg ბრალია.
მეც ვხედავ რაღაც აქ, memcopy.
>> Memory ასლი.
ჟღერს მოძრავი მეხსიერება ერთი ადგილმდებარეობა სხვა.
ჟღერს რაღაც რომ მოხდება in fread, შესაძლოა, გარკვეული მეხსიერება
მოძრავი აქ აქ.
მოდით გავლა ამ ერთხელ.
როგორ დავიწყო, რომ მეტი და გაუშვით ერთხელ?
ჰო.
>> STUDENT 56: თქვენ უნდა დააყენოს ampersand წინაშე ბუფერული?
>> JASON HIRSCHHORN: ასე ampersand წინაშე ბუფერული მაძლევს მისამართი
ბუფერული, რომელიც არის char *.
მოდით აწარმოებს ამ გზით კიდევ ერთხელ.
როგორ შემიძლია აწარმოებს მეშვეობით ეს კიდევ ერთხელ?
>> STUDENT 57: შეგიძლიათ უბრალოდ ჩაწერეთ run ერთხელ?
>> JASON HIRSCHHORN: მხოლოდ ჩაწერეთ ტირაჟი ერთხელ.
ასე რომ, ჩვენ არ ვაპირებთ შეასრულოს ამ ხაზის.
ასე რომ ბუფერული არის NULL მაჩვენებელი.
სწორი?
ის მიუთითებს - ვნახოთ.
იმ შემთხვევაში, თუ ჩვენ გვყავს ჩვენი -
დავხატოთ სწრაფი სურათი ამ.
შეგიძლიათ ყველამ ნახოთ, თუ ვწერ აქ?
>> ასე რომ, დასტის, ჩვენ ადგილობრივი ცვლადი და ეს ე.წ. ბუფერულ, და
ის მომცეთ char.
რა მისამართზე არის ეს char ზე?
>> STUDENT 58: 0x0.
>> JASON HIRSCHHORN: Right.
სწორედ ამ არის.
აქ, შიგნით, ბუფერული, ინახება 0x0.
ის, რაც გვაქვს - setup ჩვენ ახლა.
ასე რომ, ეს ხაზი, fread, აყენებს რაღაც წყარო სად?
ამ ყუთში ან ამ ყუთში?
რომელ ყუთში?
მარცხენა ყუთში ან მარჯვენა ყუთში?
ეს უფლება ყუთში.
>> ეს შემდეგნაირად მაჩვენებელი, და აყენებს მას აქ.
როდესაც ვცდილობთ და სენსორული მეხსიერება განთავსების 0, რას მივიღებთ?
სეგმენტაცია ბრალია.
სწორედ შეცდომა ჩვენ ახლა.
ჰო.
>> STUDENT 59: არ გაქვთ დააყენოს ვარსკვლავი ბუფერული?
თუ არა?
განთავსების fread?
>> JASON HIRSCHHORN: So fread იღებს მაჩვენებელი.
ასე რომ გადის ბუფერული.
და მერე კიდე დე მითითება ის სადღაც შიგნით fread.
თუმცა ისევ და ისევ, ჩვენ ვნახეთ, ის მაჩვენებელი.
ჩვენ არ უნდა გაიაროს ეს ვარსკვლავი ბუფერული.
რომ იქნება გავლის ის, რასაც აქ.
და რომ, ალბათ, გვაძლევს შეცდომა რადგან ჩვენ დე მითითება იგი.
>> უფლება?
როდესაც ჩვენ დე მინიშნება ეს მაჩვენებელი, როდესაც ჩვენ ვცდილობთ ამ განყოფილების
ჩვენ ვიღებთ შეცდომა - ჩვენი სეგმენტაცია ბრალია.
ასე რომ, -
oops.
ჩვენ ვაპირებთ დატოვა გარეთ GDB.
ჩვენი ხაზი -
ჩვენი პრობლემა - არის სწორი აქ, ამ ხაზის.
და ეს პრობლემა, რადგან ამ ხაზის.
>> როგორ შეგვიძლია შევქმნათ ყუთი, ხელმისაწვდომია fread.
უფლება?
ჩვენ უნდა შევქმნათ ყუთი რომ ერთი byte დიდი, ზომა char.
მაგრამ ჩვენ გვჭირდება, რომ ყუთში იყოს ხელმისაწვდომი როდესაც ეს ფუნქცია გაუშვებს.
ასე რომ, სად -
yeah.
ნებისმიერი იდეები?
>> STUDENT 60: Just მითითებული, როგორც ნებისმიერი შემთხვევითი ხასიათი.
უბრალოდ char ბუფერული შეადგენს ხასიათი.
და მაშინ, როცა ბუფერში იქ -
>> JASON HIRSCHHORN: Wait.
Char ბუფერული?
ასე რომ არ ვარსკვლავი?
>> STUDENT 60: Yeah.
აიღოს ვარსკვლავი.
შეადგენს შემთხვევითი ხასიათი.
>> JASON HIRSCHHORN: OK.
ასე რომ მომეცი ერთი.
>> STUDENT 60: Like a ან რამე.
და მაშინ, როდესაც თქვენ გაქვთ ბუფერული იქ, თქვენ იყენებთ -
>> STUDENT 61: Star?
Oh no, ampersand.
>> STUDENT 60: გამოიყენეთ ampersand.
>> JASON HIRSCHHORN: OK.
რაც შეეხება ამ fwrite?
>> STUDENT 60: გამოიყენეთ ampersand ერთხელ.
>> JASON HIRSCHHORN ყველა უფლება.
ასე რომ თქვენი იდეა არის ის, რომ ჩვენ შევქმნათ char და დააყენა რაღაც, და მერე
წერენ, რომ char.
>> STUDENT 60: Yeah.
>> JASON HIRSCHHORN: რა ფიქრობს ხალხი?
>> STUDENT 62: ეს convoluted.
>> JASON HIRSCHHORN: OK.
მოდით დავხატოთ ის.
ასე რომ, ამ დროს, მე ვაპირებ შევაჩერო ამ წითელი დასტის აქ, და შემდეგ ჩვენ
ექნება -
ooh!
უკაცრავად.
ასე რომ, ამ დროს ჩვენ გვაქვს რაღაც მოუწოდა ბუფერი, და ეს Stack.
სწორი?
და ჩვენ გადარჩენა მას, თავდაპირველად.
>> მაშინ ჩვენ გვაქვს ჩვენი მოწოდება fread.
რა fread არ არის ის იღებს byte დან ჩვენი ფაილი და აყენებს მას სადღაც.
იგი აყენებს მას რასაც რაც მიუთითებს.
ისე, ადრე გვქონდა ამ მისამართზე -
0x0.
ახლა რა მისამართზე გვაქვს?
>> STUDENT 63: Whatever მისამართი ბუფერი.
>> JASON HIRSCHHORN: Whatever მისამართი ბუფერი.
ალბათ იქნება რამე მაგდაგვარს.
ალბათ აპირებს დაიწყოს ბ და f, და შემდეგ ექვსი სხვა
თექვსმეტობითი ციფრები.
მნიშვნელობა არ აქვს.
ზოგიერთი მისამართზე.
და ჩვენ ავლით, რომ მისამართი შემოსული
>> და ჩვენ ვაპირებთ, რომ ჩვენი ერთი byte რამ იმ მისამართზე.
ამიტომ, ჩვენ ვაპირებთ, რომ ჩვენი ერთი byte, რაც შიგნით აქ.
და მაშინ ჩვენ ვაპირებთ დავწეროთ დან რა ოდესმე შიგნით აქ.
ვინმეს გაქვთ რაიმე შეკითხვები ამის შესახებ?
ვინც ფიქრობს, ამ კოდექსით იმუშავებს?
>> გაზარდოთ თქვენი მხრივ, თუ ფიქრობთ, ეს კოდი იმუშავებს.
თქვენ უნდა მიიღოს პოზიცია.
და ვინც ფიქრობს, რომ ეს კოდი არ იმუშავებს?
ამაღლება თქვენი მხრივ.
ყველას უნდა იყოს ამაღლების მათი მხრივ.
OK.
მიხეილი, სად იდგა?
>> MICHAEL მე ვერ გადაწყვეტს.
კეთილი ცენტრიდან.
>> JASON HIRSCHHORN: თქვენ ცენტრიდან.
აირჩიოთ ერთი.
>> MICHAEL: მე რწმენა და აცხადებენ, რომ ის იმუშავებს.
>> JASON HIRSCHHORN: OK.
თქვენ უნდა რწმენა და აცხადებენ, რომ ეს მუშაობს?
რა მოხდა?
>> [INTERPOSING VOICES]
>> JASON HIRSCHHORN: არარის seg ბრალია.
როგორ შეგვიძლია შეამოწმეთ თუ ორი რამ არის თანაბარი?
ორი ფაილი იდენტურია.
>> STUDENT 64: Diff.
>> JASON HIRSCHHORN: Diff.
Diff ამოწმებს განსხვავებები ორი ფაილი, და თუ ის დააბრუნებს
არაფერი, ისინი იდენტურია.
და თუ ჩვენ გახსნას, მივიღებთ ჩვენი ფაილი.
ასე, რომ ეს იყო სწორი გადაწყვეტილება.
მოდით ვიხსენებთ მას კიდევ ერთხელ.
ჩვენ, ფაქტობრივად, არც კი უნდა ინიციალიზაცია იგი.
>> ეს, ალბათ გამოიყურებოდეს ცოტა დამლაგებელი თუ თქვენ არ დააყენა
რაღაც შემთხვევითი არსებობს.
წერტილი, რომ, თქვენ საჭიროა შეიქმნას გარკვეული სივრცე შესანახად რაღაც
fread და მიიღოს რაიმე out of fwrite.
და რომ, რაც უნდა იყოს ან ადგილობრივი ცვლადი დასტის - თქვენ
შეიძლება მე malloc'd გარკვეული ფართი.
>> ამიტომ ჩვენ რეალურად შეგვეძლო წერილობითი malloc აქ, და
რომ არ მუშაობდა.
და მაშინ ჩვენ უკვე შენახვა ჩვენი რამ სადმე ბევრი.
მაგრამ ეს არის რეალურად, ალბათ, ყველაზე ელეგანტური გადაწყვეტა.
უბრალოდ შევქმნათ სივრცე დასტის ეს ყველაფერი უნდა წავიდეს.
>> მე ორი სხვა კომენტარი.
თუ იყო მიიღოს მხრივ, და შემდეგ მიიღოს გაიტანა ამ, ჩემი კომენტარი
იქნება შემდეგნაირად.
ეს 1 არის აქ, ჩემთვის, შევხედოთ მოსწონს Magic ნომრები.
ეს 1, თვალსაზრისით fread, აზრი.
სწორედ რიგი საკითხები, წაკითხვის ან ჩაწერის.
>> მაგრამ ეს ერთი აქ უნდა ალბათ რაღაც.
რა არის ერთი გამოსავალი?
>> STUDENT 65: ზომა byte.
>> JASON HIRSCHHORN: Like რომ?
>> STUDENT 65: ზომა char.
>> JASON HIRSCHHORN: ზომა char.
ჰო, byte არ არის ტიპის.
ასე ზომა char სამუშაოები.
ჩვენ შეგვეძლო, ზედა ჩვენი კოდი, # განმარტა, რომ.
მოუწოდა რაღაც ბიტიანი და ეს მართლაც char.
რეალურად, კიდევ უკეთესი მიდგომა შეიძლება ყოფილიყო ამ -
uint.
ვინმე იცით, რა არის?
>> უკაცრავად.
მე მას უკან.
დაველოდოთ, არა.
რომელი გზა აქვს მას წასვლა?
ვინმე იცით, რა არის?
ჰო.
>> STUDENT 67 უნდა დაეხმაროს standardize მთელი სისტემები რამ, რომ
აქვს - მოსწონს ხელმოუწერელი რიცხვებით რომ აქვს 8 ბაიტი?
>> JASON HIRSCHHORN: ეს სწორედ.
სხვადასხვა მანქანები, ზომა char -
როგორც წესი, არ char.
სიმბოლო, როგორც წესი, ერთი byte.
მაგრამ ზომა სხვა მონაცემები სახის სხვადასხვა ზომის on 32-bit მანქანა
წინააღმდეგ 64-bit მანქანა.
Uint8_t ყოველთვის 8 ბიტი -
ყოველთვის ერთი byte.
>> და მე უნდა შეიცავდეს, რომ სტანდარტული int header ფაილი.
ახლა, ეს იქნებოდა ალბათ საუკეთესო გზა წერენ ეს კოდი.
ასე რომ, თავი დაეღწია ჯადოსნური ნომრები.
და მე ასევე აქვს უფრო ლოგიკური ტიპის ბუფერული.
ეს არ არის უბრალოდ char, ეს არის byte, რაც ჩვენ მოველით, რომ იყოს.
>> და აქ, ჩვენ, ფაქტობრივად, ცოტა უფრო ძლიერი.
ჩვენ არ უწოდა char, რომელიც -
იქნებ, ვინ იცის - შეიძლება იყოს სხვადასხვა ზომის სხვადასხვა მანქანები.
ჩვენ რეალურად ვამბობ, ეს არის ზუსტად ის ერთი ბაიტი, ყოველთვის, არა აქვს მნიშვნელობა რა.
და თუ გადავხედავთ აქ, ჩვენ cp.
Uh-oh.
რა მოხდა?
>> STUDENT 68: ეს შეიძლება იყოს ჩართული.
>> JASON HIRSCHHORN: What?
>> STUDENT 69: არის ეს?
>> STUDENT 70: თქვენ არ განისაზღვროს, როგორც ტიპის.
>> STUDENT 71: მაგრამ ეს უნდა განისაზღვროს სტანდარტი.
>> STUDENT 72: რა ხდება?
>> STUDENT 73 უნდა განსაზღვროს იქნება ყველა caps?
>> JASON HIRSCHHORN: ასე რომ, ეს არ არის # განსაზღვრავს.
სინამდვილეში, ამ შემთხვევაში, მე ვარ აპირებს გამოიყენოს typedef.
იმიტომ, რომ ჩვენ იყენებს მას, როგორც ტიპის ერთ ადგილას.
ასე რომ, ამ შემთხვევაში, ჩვენ რეალურად გვინდა typedef ისევე როგორც ჩვენ დაბეჭდვის ახალი ტიპის
byte, და ეს, არსებითად, ამ.
ეს ცოტა განსხვავებული # განსაზღვრავს.
>> და ახლა, ჩვენი კოდი მუშაობს იდეალურად.
ასე რომ, კიდევ ერთხელ, # განსაზღვრავს იღებს რაღაც, ცვლის მას ყველგან
სხვა რამ.
უბრალოდ მაკრო -
სტენოგრამის თავი დაეღწია ჯადოსნური ნომრები.
მაგრამ ამ შემთხვევაში, რადგან ჩვენ გამოყენებით, როგორც ტიპი -
სწორედ აქ -
იმისათვის, რომ იმუშაოს, საჭიროა to typedef რასაც byte არის.
>> და ჩვენ განსაზღვრავს მას უფლება აქ.
ეს არ არის struct, სინამდვილეში მხოლოდ unsigned რიცხვი.
ეს არის ერთ ერთი byte ხანგრძლივი.
ეს კოდი იქნება ხელმისაწვდომი, და თქვენ ყველა უნდა ჰქონდეს მას ახლა.
>> ასე რომ, ჩვენ -
სრულყოფილი -
13 წუთის დაუტოვებიათ წასვლა მეტი პრობლემა კომპლექტი 5.
მინდა გავლა copy.c ერთად, და მაშინ ჩვენ გაიგო მოკლედ
შესახებ სხვა ნაწილები პრობლემა შეიქმნა.
ნება მომეცით, დახევის up copy.c.
და მაგარი რამ არის, ჩვენ, ფაქტობრივად, უკვე დაწერილი ბევრი ეს კოდი.
>> კოდი ჩვენ წერდა სიტყვასიტყვით უბრალოდ გამოვიდა აქ, როდესაც მე ვიყავი
წერა ამ ჩემს.
მაგრამ ეს არის copy.c, ქმნის საფუძველს პირველი ორი ნაწილი
პრობლემა მითითებული whodunit.c, რომელიც თქვენ უნდა დაწეროთ და resize.c.
Recover.c, რომელიც არის მესამე და საბოლოო ნაწილი პრობლემა კომპლექტი, რომელიც არ არის
საფუძველზე off ამ ფაილის.
>> თქვენ აპირებთ უნდა დაწეროთ, რომ ფაილი, ჩვენ გაძლევთ თარგი რომ
შეიტანოს, მაგრამ მას არაფერი აქვს უნდა გავაკეთოთ copy.c.
არამედ იმიტომ, რომ copy.c არის საფუძველი პირველი ორი ნაწილი, ჩვენ ვაპირებთ
გავლა ახლა, ასე რომ თქვენ უნდა კარგი გრძნობა, თუ რას აკეთებს.
>> და კომენტარები მისცეს ზოგიერთი ის დაშორებით.
ჩვენ უკვე დაწერილი გარკვეული ამ.
პირველი, ჩვენ მიღების დარწმუნებული ვარ, ჩვენ კიდევ სამი არგუმენტები.
შემდეგი, ჩვენ დამახსოვრების ფაილის სახელი.
ასე რომ, ჩვენ გამოტოვებენ ეს ნაბიჯი, როდესაც ჩვენ კოდირებული ჩვენი რამ -
როდესაც ჩვენი cp.
მაგრამ აქ, ისინი მიღების ცოტა სუფთა.
>> ისინი შემოწმების დარწმუნდით ორივე ფაილი არის კარგი,
გარდა ამისა, გახსნის მათ.
ჩვენ წერდა ყველა ამ კოდექსის ახლა, ასე რომ მე არ აპირებს დაეფუძნება ეს კოდი.
შემდეგი არის რაღაცები, რომ კონკრეტული სახის ფაილებს ჩვენ გამოყენებით, რომელიც
არის bitmap ფაილი.
Bitmap ფაილი აქვს გარკვეული მეტადატის მათთან ასოცირებული.
>> ასე რომ, პირველი რამდენიმე bytes გითხრათ ფაილი.
ისინი არ არიან ფერები pixel რომ იმიჯი.
ისინი გითხრათ ფაილი.
და თუ წაიკითხავთ მეშვეობით პრობლემა კომპლექტი, თქვენ ბევრად უფრო მეტი ინფორმაცია
თუ რა სახის მეტადატის სტრუქტურებში შედის bitmaps.
>> მაგრამ ამიტომ ჩვენ ამ პირველ კომპლექტი - ეს კოდი უფლება აქ.
ჩვენ კითხულობს მეტადატის -
ორი ცალი მეტადატის - ფაილი header და ინფორმაციის header.
და ჩვენ შემოწმების ზოგიერთ ნაწილში, რომ ეს დარწმუნდით, რომ იგი არის ნამდვილი bitmap ფაილი
გაგრძელებამდე.
>> ისევ და ისევ, ეს არის დეტალები, ჩვენ არ უნდა წასვლას ახლა.
თუ წაიკითხავთ მეშვეობით პრობლემა კომპლექტი, თქვენ კარგად ესმის ეს.
დიდხანს ამბავი მოკლედ, ეს უბრალოდ ვამბობ, ეს არის bitmap ფაილი და
ადასტურებს, რომ.
>> შემდეგი, ჩვენ წერილობით იმ რათა out ფაილი.
ჩვენ ვხედავთ, რომ აქ.
ჩვენ წერილობით out მაჩვენებელი.
შემდეგი, ჩვენ განსაზღვრის padding.
ასე რომ კიდევ ერთხელ, როგორც ეს განსაკუთრებულობის ერთად Bitmap ფაილი, ზოგიერთი ხაზები არის
padding დასასრულს.
და თუ წაიკითხავთ მეშვეობით პრობლემა კომპლექტი, თქვენ გაიგეთ მეტი padding.
ეს არის ფორმულა, რათა იპოვოს padding.
>> მნიშვნელოვანია გვახსოვდეს, -
როდესაც თქვენ შეცვლით ზომა bitmap ფაილის padding ცვლილებები.
როდესაც თქვენ შეცვლით ზომა ფაილის padding ცვლილებები.
ის არასდროს იქნება უფრო მეტი, ვიდრე 3 -
ეს იქნება 0 მეშვეობით 3, მოიცავს.
მაგრამ როდესაც თქვენ შეცვალოს ზომა რაღაც, padding ცვლილებები.
>> თუ მე მხოლოდ ერთი pixel რომ ზედიზედ, მე გვჭირდება სამი ბაიტი padding, რადგან
თითოეული მწკრივი უნდა იყოს ჯერადი ოთხი ბაიტი ხანგრძლივი Bitmap ფაილი.
მაგრამ თუ მე გაორმაგდება ის, რომ წავიდეს ერთი pixel ორ pixel, რომელთაგან თითოეული,
ვთქვათ, არის byte, მაშინ მე უნდა ორი ბაიტი padding, რათა
რომ თანაბარი ოთხ.
>> ასე რომ, როდესაც მე შეცვალოთ ზომის რაღაც, მე უნდა შეცვალოს ოდენობით
საქართველოს padding მაქვს.
ამჯამად, რომ აზრი, რომ ყველასთვის?
შემდეგი, ჩვენ iterate მეტი თითოეულ სტრიქონს, ან მთელი რიგები.
და მაშინ ჩვენ iterate მეშვეობით ყოველი სვეტი თითოეული მწკრივი.
ჩვენ მკურნალობის ამ bitmap მოსწონს ბადე, როგორიც ჩვენ მკურნალობა
ფორუმში 15.
>> როგორც ჩვენ დამუშავებული აგური, როდესაც ჩვენ დაბეჭდილი მათ ეკრანზე.
ქსელში რიგები და სვეტები.
მაშინ - ჩვენ ვნახეთ ეს.
ჩვენ რეალურად მხოლოდ კოდირებული ეს.
ჩვენ შევქმენით რაღაც დროებითი შენახვის.
ვკითხულობთ იქ, და მაშინ ჩვენ წერენ გარეთ.
ეს არის ზუსტად ის, რაც ჩვენ უბრალოდ გააკეთეს.
>> შემდეგი, იმიტომ, რომ მე ვთქვი, თითოეული ხაზი მთავრდება ზოგიერთი padding, ჩვენ
გაფართოებული გამო, რომ padding -
ძველი padding.
და მაშინ ჩვენ დაამატოთ ეს უკან.
ამ შემთხვევაში, ჩვენ შექმნის იმავე ზუსტი ფაილი.
ჩვენ უბრალოდ გადაწერა იგი.
ასე რომ, ეს ხაზი არის სახის სულელური.
ჩვენ შეგვიძლია სიტყვასიტყვით უბრალოდ დააყენა padding შემოსული
>> მაგრამ თუ თქვენ შეგიძლიათ შეცვალოთ ზომის ფაილი, თქვენ მაინც მინდა ეს ხაზი?
ასე რომ, თუ ჩვენ შეცვალოთ ზომის ფაილი, ჩვენ კვლავ გსურთ გამოტოვოთ
ძველი padding?
>> STUDENT 74: დიახ.
>> JASON HIRSCHHORN: ასე რომ, ჩვენ ვაკეთებთ.
იმიტომ, რომ ეს, კიდევ ერთხელ, გარიგება წყარო ფაილი.
ჩვენ არ აინტერესებს padding წყარო ფაილი.
ჩვენ გვინდა წასვლა მომდევნო ხაზი.
მაგრამ ჩვენ არ უბრალოდ დააყენოს უკან ძველი ოდენობით padding.
ჩვენ უნდა დააყენოს უკან new თანხის padding.
>> ასე რომ, როდესაც ჩვენ იცვლება ზომა ფაილი, ჩვენ მაინც მინდა გამოტოვოთ მეტი
padding ძველი ფაილი - რა ჩვენ კითხულობს წელს.
მაგრამ რაც ჩვენ წერილობით, ჩვენ ვაპირებთ უნდა დააყენოს უკან განსხვავებული
ნომერი padding, რომ ჩვენ განისაზღვრა.
ჰო.
>> STUDENT 75 ბრძანება იმ ორი ხაზების მნიშვნელობა არ აქვს, არა?
იმიტომ, რომ თქვენ გატარება სხვადასხვა files.
>> JASON HIRSCHHORN: ზუსტად.
იმისათვის, რომ ამ ორ ხაზს მნიშვნელობა არ აქვს.
ჩვენ წერენ ეს ხაზი.
ეს არის აქ ფაილი ჩვენ წერილობით.
ეს მნიშვნელოვანია, ამიტომ მივიღებთ უფლება ოდენობით padding.
ეს უნდა გაუმკლავდეთ ფაილი.
ჩვენ გვინდა, რომ გამოტოვოთ უფლება მეტი padding.
>> ჩვენ არ გვინდა, რომ წაიკითხა -
თუ ჩვენ კითხულობს byte დროს, ჩვენ არ აინტერესებს იმ padding bytes.
ჩვენ გვინდა, რომ გადაადგილება, რათა მომდევნო ხაზი.
და ბოლოს, ისევე, როგორც Lucy მისცა ჩვენთვის, ჩვენ დახურვა ფაილი და დაბრუნებას 0.
ასე რომ, ეს copy.c.
და ჩვენ, ფაქტობრივად წერდა - ჩვენ გაატარა უმრავლესობა განყოფილების წერა ამ, არსებითად.
>> თქვენ გააკეთა ეს.
ასე რომ იმედია თქვენ გაქვთ კარგი გაგებით რა ხდება აქ.
დიდი განსხვავება, პატიოსნად, მხოლოდ ამ პირველ ნაწილში, რომელიც ეხება
თავისებურებები bitmap ფაილი.
ასე რომ, მე, როგორც ჩემი მომავალი slide, რა უნდა გავაკეთოთ?
ისე, მოდით ვიფიქროთ whodunit.
>> და ვინც წაიკითხა მეშვეობით პრობლემა კომპლექტი, რას
უნდა გავაკეთოთ whodunit?
უბრალოდ.
Aleja.
>> Aleja შეგიძლიათ აიღოს ნაწილი თითოეული pixel რომ ნიშნავს წითელი.
ხოლო შემდეგ -
სახის?
>> JASON HIRSCHHORN: OK.
ასე რომ აიღოს ნაწილი თითოეული pixel რომ ნიშნავს წითელი.
რომ არის მიახლოებული, თუმცა არა ყველა ეს.
>> STUDENT 76: ისე, არსებობს სხვადასხვა გზა ამის გაკეთება.
>> JASON HIRSCHHORN: OK.
მომეცი ერთი გზა.
>> STUDENT 76: აიღეთ ყველა წითელი და შემდეგ ხაზი გავუსვა, ლურჯი და მწვანე.
>> JASON HIRSCHHORN: OK.
ასე რომ, მოცემულ ორივე გზა -
ჟღერს ვაძლევთ მას pixel, ეს აქვს წითელი, ლურჯი, მწვანე და დონეზე.
ჩვენ გვინდა, რომ ნათესავი დონეზე წითელი, ლურჯი, მწვანე, დამოკიდებულია
რომ pixel.
სადაც ეს კოდი უნდა შევცვალოთ ნათესავი წითელი, ლურჯი, მწვანე და
დონეზე მოცემული pixel.
მას შემდეგ, რაც ჩვენ წაიკითხა, რომ -
სანამ ჩვენ დაწერა?
მომეცი ხაზის ნომერი.
>> მრავალჯერადი სტუდენტები: 83.
>> JASON HIRSCHHORN: 83.
ასე რომ სწორედ აქ.
განთავსების whodunit, კოდი გჭირდებათ ჩაწერის უნდა წავიდეს უფლება არსებობს.
და ეს ერთადერთი კოდი თქვენ უნდა დაწეროთ.
რადგან, ისევე როგორც გავიგეთ, ყველა თქვენ უნდა გავაკეთოთ არის შეცვალოთ ეს ნათესავი ლურჯი,
წითელი და მწვანე დონეზე თითოეული pixel.
>> თქვენ წაიკითხავთ მას, და ახლა თქვენ აპირებს დაწეროს ის.
როგორ მივიღო - თუ მე მაქვს ეს საგანი ე.წ. სამმაგი, სწორედ აქ, და ეს საქართველოს
ჩაწერეთ RGBTRIPLE -
ასევე, თუ ჩვენ ჩანდა bmp.h, რა არის RGBTRIPLE?
>> STUDENT 77: ეს struct.
>> JASON HIRSCHHORN: RGBTRIPLE არის struct.
ჩვენ ვხედავთ, რომ უფლება ქვემოთ აქ.
და ასე თუ მინდოდა შესვლა, ვთქვათ, წითელი დონეზე struct, როგორ შემიძლია
წვდომის წითელი დონეზე ამ struct?
>> [CLASS Murmurs]
>> STUDENT 78: RGBTRIPLE.rgbtred?
>> JASON HIRSCHHORN: მართალია?
>> STUDENT 79: ეს უნდა იყოს triple dot, ნაცვლად RGBTRIPLE dot?
>> JASON HIRSCHHORN: Triple.
Triple არის ადგილობრივი ცვლადი, ასე რომ, აქ, იქ არ არის პოინტერები აქ.
ასე რომ, ჩვენ უბრალოდ გამოიყენოთ dot ნოტაცია.
ეს ხელს მაძლევს დონეზე წითელი.
იმ შემთხვევაში, თუ მინდა, რომ შეიცვალოს ეს, მე მხოლოდ მითითებული მას ტოლი რაღაც განსხვავებული.
ასე რომ კიდევ ერთხელ, ამ ხაზი კოდი ხელმისაწვდომი ამ ცვლადის შიგნით ამ struct და
ჩვენ შეგვიძლია მითითებული, რომ ეს რაღაც ახალი.
>> ასე whodunit, კიდევ ერთხელ, ეს არის, არსებითად, რაც ჩვენ უნდა გავაკეთოთ.
ძალიან მარტივია.
უბრალოდ შეცვალოს ზოგიერთი ნათესავი დონეზე, და ეს არის, სადაც რომ კოდი მიდის.
შემცირება, მეორეს მხრივ, ცოტა trickier.
ფაქტობრივად, ზომა, ალბათ, trickiest ნაწილი პრობლემა კომპლექტი.
ჩვენ სამი წუთის წასვლა მას.
>> თუმცა ისევ და ისევ, ჩვენ უკვე დაწერილი ყველაზე მეტად ეს კოდი, ამიტომ ჩვენ
უნდა იყოს საკმაოდ ნაცნობი.
რა რამ გვინდა გავაკეთოთ ზომის შეცვლა, თუ თქვენ წაიკითხავთ მეტი
პრობლემა კომპლექტი?
თუ თქვენ მათ ჩემთვის, ჩვენ ვერ გაიგო მათ შესახებ.
რა რამ გვინდა გავაკეთოთ?
>> STUDENT 80 ვერტიკალურად -
ასე რომ თქვენ უნდა ჰორიზონტალურად შეცვლის მას, მაგრამ ვერტიკალურად ზომის შეცვლა იგი ისევე?
>> JASON HIRSCHHORN: ასე რომ, თუ ჩვენ ეძლევა pixel, და ჩვენ გვინდა შეცვლის ის მიერ
ფაქტორი ორი, რომ ახლა უნდა იყოს resized ჰორიზონტალურად და resized
ვერტიკალურად.
ამჯამად რომ აზრი?
ჰო.
ასე რომ, ალბათ, ყველაზე დიდი გამოწვევა.
და ჩვენ ვსაუბრობთ, რომ წ.
ჰო.
>> STUDENT 81: გზა ვფიქრობდი, რომ ეს იყო საჭირო ამობეჭდოთ -
>> JASON HIRSCHHORN: Wait.
არ გვეუბნებიან რა გააკეთეთ თქვენ.
ჩვენ ვაპირებთ, რომ გაიგო ლოგიკა.
>> STUDENT 81: OK.
რა იყო კითხვა?
>> JASON HIRSCHHORN თქვენ უბრალოდ დააყენა თქვენს ხელში.
არ არსებობს საკითხი.
ნება მომეცით წარმოგიდგინოთ იგი.
ნება მომეცით უბრალოდ განვიხილოთ ეს მოკლედ.
ასე რომ, ჩვენ ერთი pixel, ჩვენ გვინდა იმეორებს მას, როგორც ჰორიზონტალურად და
ვერტიკალურად.
ასე რომ იდეალურად რას ვაკეთებთ აქ, ჩვენ წაიკითხეთ ჩვენი pixel, ჩვენ დაწერა
თუმცა ბევრი ჯერ.
>> მაგრამ მაშინ ჩვენ გვაქვს ჩვენი შეასრულა აქ, იმიტომ, რომ მაშინ ჩვენ გვინდა გაფართოებული
შემდეგი ხაზი და დაწეროთ იგი დასაწყისში მომდევნო ხაზი.
ასე რომ, თუ ჩვენ გვინდა, რომ იმეორებს ორივე ჰორიზონტალურად და ვერტიკალურად, რა არის
ერთი კარგი გზა უნდა გააკეთოს, რომ -
ერთი კარგი, თუმცა ამის გაკეთება?
ამიტომ, ჩვენ არ უნდა მუდმივად შეეცდება გარშემო ჩვენი ფაილი განვათავსოთ რამ.
>> ამ კითხვაზე შეიძლება არ აქვს გააკეთა გრძნობა, მაგრამ მე ვფიქრობ,
პასუხი ის დაეხმარება.
>> STUDENT 82: შექმენით მასივი?
>> JASON HIRSCHHORN: ასე რომ, მოდით ვიფიქროთ თითოეული ფაილი, როგორც a row.
მოდით ვიფიქროთ თვალსაზრისით რიგები.
იმ შემთხვევაში, თუ ჩვენ გვაქვს ჩვენი პირველი რიგის ჩვენი პატარა სურათი, ჩვენ შეგვიძლია, რომ row
შევიდა დიდი row დიდი სურათი, და შემდეგ იმეორებს, რომ ზედიზედ თუმცა
ბევრი ჯერ ის უნდა ტირაჟირებული, ვიდრე აპირებს pixel მიერ pixel,
რომელიც იღებს გაუგებარია, როდესაც საქმე files.
>> რადგან თუ გვქონდა -
მე გაშვებული გარეთ სივრცეში.
იმ შემთხვევაში, თუ ეს არის ჩვენი ფაილი, და ჩვენ რომ ერთი pixel იქ, და ჩვენ გვინდა, რომ დააყენოს ის
უფლება არსებობს, ჩვენ ჯერ კიდევ გვაქვს ზოგიერთი რამ რომ უნდა წავიდეთ იქ, როდესაც ჩვენ
წერა და შექმნის ჩვენი ახალი ფაილი -
ჩვენი ფაილი რომ ორჯერ დიდია.
>> მაგრამ ეს მართლაც მძიმე ფაილის ფუნქციები გაფართოებული გარშემო ახალი ხაზები
რომ, და შემდეგ დაბრუნდეს აქ და ამით რამ არსებობს.
ეს თითქმის შეუძლებელია, რომ რამე როგორც, რომ, თუ ეს აზრი.
ასე რომ, თუ ჩვენ ვფიქრობთ თვალსაზრისით რიგები, ჩვენ შეგვიძლია ჩვენი მწკრივი, და შემდეგ დააყენოს ის -
იმეორებს რიგები ვერტიკალურად.
>> და რომ ის, თუ როგორ გაუმკლავდეთ resizing ვერტიკალურად ვიდრე ჰორიზონტალურად.
ეს იყო ერთგვარი სწრაფი და ცოტა გაუგებარია.
სამწუხაროდ, ჩვენი დრო არის up.
მე ვიქნები გარეთ იმ თქვენ აქ, რომელსაც აქვს შეკითხვები
პრობლემა კომპლექტი, მათ შორის ფეხზე.
>> მოდით adjourn ახლა.
ისევ და ისევ, თუ თქვენ გაქვთ რაიმე შეკითხვები, ჩვენ შეგვიძლია სტატისტიკა გარეთ.