>> [მუსიკალური სათამაშო]
>> დევიდ ჯ Malan ყველა უფლება.
>> [სიცილი]
>> კეთილი იყოს.
ეს არის CS50.
ეს ბოლოს კვირაში ხუთი.
და დღემდე, ჩვენ საკმაოდ ბევრი ხორციელდება თავისთავად, რომ არსებობს
არსებობს ამ შემდგენელი, Clang, რომ თქვენ უკვე არა მარტო აპელირებს გზით ამ
სხვა ინსტრუმენტი მოუწოდა გააკეთოს, რომ როგორმე magically გარდაქმნის თქვენი წყაროს კოდი
შევიდა ობიექტის კოდი, zeros და პირობა რომ თქვენი კომპიუტერი CPU, ცენტრალური
გადამამუშავებელი ერთეული, რეალურად ესმის.
მაგრამ აღმოჩნდება, რომ არსებობს მთელი რიგი, რომ მიმდინარეობს ქვეშ hood in
შორის შემავალი და გამომავალი.
>> მინდა შესთავაზოს, რომ ჩვენ ხორცი რომ პატარა დეტალი შევიდა
ამ ოთხი ნაბიჯი, რაღაც მოუწოდა წინასწარ დამუშავებას, რაღაც
მოუწოდა შედგენა, რომელიც ჩვენ ვნახეთ, რაღაც მოუწოდა იკრიბებიან და
რაღაც მოუწოდა აკავშირებს.
ასე რომ, დღემდე, ზოგიერთ ჩვენი პროგრამები, ჩვენ გვქონდა მკვეთრი მოიცავს.
ცოტა ხნის წინ ჩვენ გვქონდა გარკვეული მკვეთრი განსაზღვრავს for მუდმივები.
გამოდის, რომ ის, რომ მათ prefixed ერთად hash სიმბოლო ან
ფუნტი სიმბოლო არის წინასწარ პროცესორი დავალებები მისცა.
ეს უბრალოდ ლამაზი გზა და განაცხადა, რომ ეს ხაზი კოდი, რომ, ფაქტობრივად,
გარდაიქმნება სხვა რაიმე ადრე კომპიუტერული კი ცდილობენ გარდაქმნას თქვენი
პროგრამა შევიდა zeros და პირობა.
>> მაგალითად, მკვეთრი მოიცავს სტანდარტული I / O. სთ, საკმაოდ ბევრი მხოლოდ იმას ნიშნავს, წავიდეთ
წინ, დაიბრუნოს შინაარსი ფაილი stdio.h და ჩასვით უფლება არსებობს.
ასე რომ არ zeros და პირობა იმ ეტაპზე არ არის.
ეს მართლაც მხოლოდ რიგებში.
და ეს განმავლობაში განხორციელებული ე.წ. წინასწარი დამუშავების ეტაპზე, როდესაც თქვენ
რეალურად აწარმოებს Clang ან კონკრეტულად სასტარტედ ხშირ შემთხვევაში.
ასე რომ, ეს ყველაფერი მოხდა პირველი ავტომატურად დღემდე.
>> შემდეგ მოდის შედგენაში ნაბიჯი.
მაგრამ ჩვენ oversimplified კომპილაცია.
შედგენა პროგრამა ნამდვილად ნიშნავს მას ეხლა რაღაც C,
წყაროს კოდი ჩვენ წერდა, ქვემოთ რაღაც მოუწოდა ასამბლეის.
ასამბლეის ენა ქვედა დონის ენა, რომელიც, საბედნიეროდ, ჩვენ არ
ბევრი რამ გვაქვს შემთხვევა, დაწერა ამ სემესტრში.
მაგრამ ეს ყველაზე დაბალი დონის გრძნობა, რომ თქვენ ფაქტიურად წერა
დავამატებთ და სხვაობა და გამრავლების და დატვირთვის საწყისი მეხსიერების და შენახვა მეხსიერება,
ძალიან რჩევები, რომ კომპიუტერი, ქვეშ Hood,
რეალურად ესმის.
>> და ბოლოს, შეკრებაზე იღებს, რომ ენა to zeros და პირობა, რომ ჩვენ
სადაც აღწერილია დღემდე.
და მართლაც ბოლოს, არსებობს ე.წ. აკავშირებს ეტაპი, რომელიც ჩვენ გამოგიგზავნით
ვხედავ რაღაც მომენტში, რომელიც აერთიანებს თქვენი zeros და პირობა zeros და
ვინც სხვა ადამიანების წინაშე თქვენ შექმენით.
>> ამიტომ მიგვაჩნია, რომ ეს სუპერ მარტივი პროგრამა.
ეს იყო კვირა 1.
ეს უბრალოდ განაცხადა, Hello World, ეკრანზე.
ჩვენ გაიქცა ამ გზით Clang.
ან ჩვენ გაიქცა ის მეშვეობით სასტარტედ რომელიც გაიქცა Clang.
და outputted დროს, როდესაც ზოგიერთი zeros და პირობა.
მაგრამ აღმოჩნდება, რომ არსებობს შუალედური ნაბიჯი.
თუ მე აქ - oops, არ გვინდა, რომ მას ამჟამად.
თუ მე აქ, ჩემს მოწყობილობების მე და ქმნის hello.c, აქ
ის არის, რომ იმავე პროგრამით.
და რა მე ვაპირებ გავაკეთებ ტერმინალში ფანჯარა აქ მე ვაპირებ
აწარმოებს Clang ვიდრე მიიღოს, რომელიც automates ოთხივე
იმ ნაბიჯებს ჩვენთვის.
და მე ვაპირებთ clang-S და შემდეგ hello.c და შემდეგ შევა.
>> და მე მოციმციმე სწრაფი ერთხელ, რაც კარგია.
ახლა კი ოდნავ უფრო დიდი ფანჯარა, მე ვაპირებ გახსნას gedit აქ.
და მე ვაპირებ გახსნას ფაილი, რომელიც, აღმოჩნდება, ეწოდება hello.s ამ
შეიცავს, რომ შეკრებისა ენა მე მოხსენიებული ადრე.
ეს კი რასაც ასამბლეის ენა, საკმაოდ დაბალი დონე
მითითებები, რომ თქვენი Intel CPU ან რასაც ის არის, რომ შიგნით
ესმის.
და mov არის ნაბიჯი. ზარი არის მოუწოდებს, ძალიან მაღალი დონის ფუნქცია.
ქვე არის სხვაობა.
>> ასე რომ, როდესაც თქვენ გაქვთ კონკრეტული CPU შიგნით თქვენს კომპიუტერში, რა ხდის
მკაფიო, წინააღმდეგ სხვა პროცესორები წლის ბაზარზე, რომელიც რაც ინსტრუქციები იგი
ესმის და ხშირად რამდენად ეფექტურია ეს არის, რამდენად სწრაფად იგი არის შესრულებაში გარკვეული
იმ მითითებებს.
ახლა მეტი ამ, თქვენ შეუძლია მომდევნო საშემოდგომო CS61 კოლეჯში.
მაგრამ აქ ჩვენ გვაქვს, მაგალითად, რამდენიმე იდენტიფიკატორების, რომ შეიძლება ნაცნობი.
hello.c არის პროგრამის სახელი.
>> . ტექსტი -
იქ არ არის ბევრი ინტერესი არსებობს ახლა, გავიხსენოთ, რომ ტექსტი
სეგმენტი, როგორც ორშაბათს, არის სადაც მეხსიერების თქვენი პროგრამის რეალურად მთავრდება.
ასე რომ, სულ ცოტა ბუნდოვნად ნაცნობი იქ.
აქ, რა თქმა უნდა, ნახსენები ჩვენი მთავარი ფუნქცია.
მოძრავი ქვემოთ, ეს ეხება რამ წ რეესტრი, ძალიან მცირე მოცულობით
მეხსიერების შიგნით თქვენი ფაქტობრივი CPU.
და თუ გადაფურცლეთ ქვემოთ კი შემდგომი, მე ვერ ვხედავ რაიმე სახის
არაპირდაპირი ნახსენები ASCII.
და იქ, რა თქმა უნდა, არის ის, რომ ტექსტი, hello, მძიმე, მსოფლიოში.
>> ცოტა ხნის ამბავი მოკლედ, ეს იყო ხდება თქვენთვის, ავტომატურად,
ქვეშ hood ყველა ამ დროს.
და რაც ხდებოდა რეალურად ერთხელ თქვენ აწარმოებს Clang, ან გზით
გააკეთოს, თქვენ მისაღებად პირველი, საწყისი კოდების,
ე.წ. ასამბლეის ენაზე.
მაშინ Clang არის კონვერტაცია ასამბლეას ენის ქვემოთ zeros და პირობა.
და ეს არის slide, რომ ჩვენ დავიწყეთ ჩვენი განხილვის კვირა 0 on -
და მაშინ კვირა 1.
და მაშინ საბოლოოდ, იმ zeros და პირობა მათ ერთად zeros და პირობა
იმ ბიბლიოთეკების ჩვენ ხორციელდება თავისთავად, როგორიცაა სტანდარტული I / O ან
სიმებიანი ბიბლიოთეკა ან თუნდაც CS50 ბიბლიოთეკა.
>> ასე ხატვა ამ სურათს მეტი ვიზუალურად, ჩვენ გვაქვს hello.c.
და ეს, რა თქმა უნდა, იყენებს printf ფუნქციონირებს ვთქვა, Hello World.
კრებული ნაბიჯი იღებს იგი ქვემოთ რომ ფაილი უბრალოდ დაინახა hello.s, მაშინაც კი,
მიუხედავად იმისა, რომ ის, როგორც წესი, ამოღებულია ავტომატურად თქვენთვის.
მაგრამ ეს შეკრების კოდი შუა ნაბიჯი.
და მაშინ, როდესაც ჩვენ შეიკრიბება ასამბლეის ენა, ასე ვთქვათ, სწორედ მაშინ, როდესაც
მიიღოს იმ zeros და პირობა.
ასე რომ, ჩვენ zoomed ეფექტურად დღეს ის, რაც ჩვენ უკვე აღების მიანიჭა,
ნიშნავს აპირებს წყაროს კოდი გააპროტესტებენ კოდი.
>> მაგრამ ბოლოს, ახლა, რომ იგივე სურათი - მოდით shove გადასცემს მას
მარცხენა მხარეს.
და აღნიშნავენ, რომ ზედა არსებობს აღვნიშნე stdio.h.
ეს არის ის, ფაილი, რომელიც ჩვენ შედის თითქმის ყველა
პროგრამების ჩვენ დაწერილი.
და ეს ფაილი, რომლის შინაარსი მიიღეთ ასლი გაკრული,
ეფექტურად atop თქვენი კოდი.
მაგრამ აღმოჩნდება, რომ, on კომპიუტერი სისტემაში სადღაც, იქ, სავარაუდოდ
stdio.c ფაილი რომ ვინმე წერდა წლის წინ, რომ ახორციელებს ყველა
ფუნქციები, რომელიც გამოცხადდა ამ stdio.h.
>> ახლა რეალურად ეს, ალბათ არა თქვენი Mac ან თქვენი კომპიუტერის ან თუნდაც
CS50 მოწყობილობების არის ნედლეული C კოდი.
ვიღაცამ უკვე შედგენილი და შედის . O ფაილი ობიექტის კოდი ან.
ფაილი, რომელიც ეხება გაუზიარეს ბიბლიოთეკა რომ უკვე წინასწარ დაყენებული და
წინასწარ შედგენილი თქვენთვის.
თუმცა ვივარაუდოთ, რომ იქ ნამდვილად არსებობს ჩვენს კომპიუტერში stdio.c პარალელურად
ერთად Clang.
შენი კოდექსის იქმნება და შეიკრიბება.
stdio.c 's კოდი მიმდინარეობს შედგენილი და შეიკრიბნენ, რათა ეს ძალიან ბოლო
ნაბიჯ, ქვემოთ, ჩვენ უნდა როგორღაც კავშირი, ასე ვთქვათ, თქვენი zeros და პირობა
, მისივე zeros და პირობა ერთ მარტივი პროგრამა, რომელიც საბოლოოდ არის
მოუწოდა მხოლოდ Hello.
>> ასე რომ, ყველა ჯადოსნური, რომ ხდებოდა აქამდე.
და ვაგრძელებთ ამ პროცესები თავისთავად, მაგრამ გააცნობიეროს
არსებობს ბევრი წვნიანი ვრცლად მიმდინარეობს ქვეშ არსებობს.
და ეს არის ის, რაც ხდის თქვენს კომპიუტერი Intel შიგნით
განსაკუთრებით მკაფიო.
>> ასე რომ შენიშვნა, თუ გსურთ შემოგვიერთდნენ ლანჩზე ამ პარასკევს, ამის წასვლა
ჩვეულებრივი ადგილის cs50.net/rsvp, 1:15 PM ამ პარასკევს.
ახლა კი რამდენიმე განცხადებები.
ასე რომ, ჩვენ გვაქვს კარგი ამბავი.
და ჩვენ გვაქვს ცუდი ამბავი.
გადავიდეთ კარგი ამბავია აქ.
>> [Groaning]
>> ყველა უფლება.
ისე, ეს ტექნიკურად დღესასწაული, ასე ეს არ არის იმდენად საჩუქარი ჩვენგან.
მაგრამ ცუდი ამბავი რა თქმა უნდა.
>> [Groaning]
>> გავატარე ბევრი დრო აღნიშნულ ანიმაციები.
>> [სიცილი]
>> იქნება საანგარიშო სხდომამდე ამ მოდის ორშაბათს.
ეს იქნება ერთი 5:30 საათზე.
ჩვენ შეგახსენოთ ყველა ეს დეტალი ფოსტით on კურსის
ნახვა მხოლოდ რამდენიმე დღის განმავლობაში.
ეს იქნება გადაღებული და ხელმისაწვდომი ცოტა ხნის შემდეგ.
ასე რომ, თუ თქვენ ვერ გააკეთოს, რომ ორშაბათს ღამის სლოტი, არ ინერვიულოთ.
განყოფილებები ამ ერთი კვირის განმავლობაში ასევე ფოკუსირება მიმოხილვა ინტელექტუალური.
თუ თქვენი მონაკვეთი, რომელიც ორშაბათს, რომელიც მართლაც უნივერსიტეტის დღესასწაული, ჩვენ
მაინც შეხვდება ნაწილში.
თუ თქვენ უბრალოდ ვერ გააკეთოს, რომ სექცია, რადგან თქვენ აპირებს
მოშორებით, რომ ეს ჯარიმა.
დაესწროს კვირა ან სამშაბათი სექციაში სრულყოფილი-in to ჯეისონ-ის მონაკვეთი, რომელიც
ხელმისაწვდომი.
>> ასე რომ, უფრო ცუდი ამბავი.
ასე რომ, შესაბამისად სილაბუსი, ჩვენ გვაქვს ლექცია მომდევნო პარასკევს.
მაგრამ კარგი ამბავი -
აშკარად, გავატარე ძალიან ბევრი დრო ამ.
>> [სიცილი]
>> ჩვენ ყველაფერს გააუქმოს მომავალი პარასკევის ლექციებს.
ასე რომ, იქნება საჩუქარი ჩვენთვის, ასე რომ თქვენ ნამდვილად აქვს ლამაზი შესვენების შემდეგ
შორის ამ კვირაში და ორი კვირის აქედან გამომდინარე.
ასე რომ არ ლექციების მომავალ კვირას, პატარა ცოტა ინტელექტუალური, რისთვისაც უნდა
მიღების უფრო და უფრო აღფრთოვანებული.
>> მოდით ახლა იქცეს ჩვენი ყურადღება რაღაც რომ მართლაც უფრო ვიზუალური
და უფრო საინტერესო და შექმნას ეტაპზე იმისათვის, რაც იქნება ჰორიზონტზე ჩანს
სულ რაღაც რამდენიმე კვირის განმავლობაში.
მას შემდეგ, რაც ინტელექტუალური, ჩვენ იქცევა ფოკუსირება ჩვენი პრობლემა კომპლექტი სხვა
domain კონკრეტული პრობლემა, რომ სასამართლო ექსპერტიზის ან უსაფრთხოებას ზოგადად.
>> სინამდვილეში, ტრადიცია, ამ პრობლემის კომპლექტი არის ჩემთვის ერთ
სწავლების თანამემამულე ან CAS ფეხით გასწვრივ campus გარკვეული ფოტოებით
იდენტიფიცირება მაგრამ არა აშკარა ადამიანი, ადგილები, ან რამ, მაშინ ყოველ წელს I
როგორღაც მოახერხა შემთხვევით წაშლა ან კორუმპირებული ციფრული მედია ანკეტა
რომ შიგნით ჩვენი კამერა.
თუმცა არ არის დიდი გარიგება.
შემიძლია წავიდეთ წინ და plug რომ ჩემს კომპიუტერში.
მე შემიძლია სასამართლო იმიჯი, ასე საუბარი, რომელსაც გადაწერა zeros და
პირობა გამორთვა, რომ მეხსიერების ბარათი, თუ არა მისი SD ბარათის ან კომპაქტური ფლეშ ბარათი ან
რასაც თქვენ ხართ იცნობს.
და მაშინ ჩვენ შეგვიძლია ხელი, რომელიც გარეთ.
>> ასე რომ, გამოწვევა წინ, სადაც სხვა რამ თქვენთვის, იქნება დაწერა
C კოდი, რომელიც აღდგება მთელი bunch of JPEGs ჩემთვის და გამოვლენილი იქნება
იმ ადამიანებს, ადგილები, ან რამ.
და ჩვენ ასევე გაიგო, ამ პრობლემის მითითებული და უახლოეს მომავალში, დაახლოებით
გრაფიკული ზოგადად.
ჩვენ გამოიყენება, მათ, რა თქმა უნდა, ამისთვის წარმართულიყო.
მაგრამ თქვენ ერთგვარი მიღებული მიანიჭა არსებობს ამ მაღალი დონის ცნებები
საქართველოს ოთხკუთხედს და ovals.
მაგრამ ქვეშ hood არსებობს pixels.
თქვენ არ უნდა დაიწყოს ფიქრი იმ.
ან თქვენ for P-ნაკრები 4 უნდა ვიფიქროთ შესახებ უფსკრული თქვენი აგურის, თუ როგორ
სწრაფად თქვენ ბურთი გადაადგილდებიან ეკრანზე წარმართულიყო.
ასე რომ, არსებობს ამ ცნება წერტილების თქვენს ეკრანზე, რომ
მოვიდეს თამაში უკვე.
>> ახლა რას ვხედავ, თუმცა, არის ის, რაც თქვენ შესახებ კომპიუტერის ეკრანზე.
თუ თქვენ ოდესმე ნახეს რაღაც კარგი ან ცუდი TV, შანსი მათ საკმაოდ ბევრი
მკურნალობა მაყურებელს მოსწონს technophobes ვინც ნამდვილად არ
ვიცი ბევრი შესახებ კომპიუტერული.
ასე რომ, ეს ძალიან ადვილია პოლიციის დეტექტივის ვთქვა, შეგიძლიათ
გაწმენდა რომ ჩემთვის?
ან გაძლიერება, არა?
გაძლიერება ჰგავს ხმაურს სიტყვა ყველაზე ნებისმიერი დანაშაული დაკავშირებული შოუ.
რეალობა არის თუ მიიღოს ძალიან blurry სურათს ეჭვმიტანილის აკეთებს
რაღაც ცუდი, თქვენ ვერ მხოლოდ გაზრდის.
თქვენ არ შეგიძლიათ გასადიდებლად უსასრულოდ.
თქვენ ვერ ხედავთ ამ Glint სხვისი თვალი, რომლებმაც ჩაიდინეს, რომ
კერძოდ დანაშაული, მიუხედავად გავრცელების ამ ტელევიზიით.
>> ასე რომ, რომ მოდით მოტივაცია, რომ მომავალი პრობლემა მითითებული glimpse at
ზოგიერთი შოუები, რომელიც თქვენ შეიძლება იყოს ნაცნობი.
>> [ვიდეო აღწარმოების]
>> -OK.
ახლა მოდით კარგი შევხედოთ თქვენ.
>> -მოლაპარაკებათა მაგიდას.
გაშვება, რომ უკან.
>> -დაელოდეთ ერთი წუთით.
წავიდეთ უფლება.
>> -არსებობს.
გაყინვას, რომ.
>> -Full ეკრანზე.
>> -OK.
გაყინვას, რომ.
>> გამკაცრდეს up აღნიშნულ საკითხზე, იქნება ya?
>> -ვექტორი წელს, რომ ბიჭი by უკან საჭე.
>> -ზომით უფლება აქ ამ ადგილას.
>> -უფლების მქონე ტექნიკის, imaged შეიძლება გაფართოებული და sharpened.
>> -რა არის რომ?
>> -ის გაფართოება პროგრამა.
>> -შეგიძლიათ მიანიშნა, რომ არავითარ?
>> მე არ ვიცი.
მოდით გაზრდის.
>> -გაძლიერება მონაკვეთზე-6.
>> -I გაუმჯობესებულია დეტალურად და -
>> -ვფიქრობ, საკმარისია, რათა გაზარდოს.
გაათავისუფლოს იგი ჩემს ეკრანზე.
>> -გაძლიერება ასახვას მისი თვალი.
>> -მოდით აწარმოებს ამ გზით ვიდეო გაფართოება.
>> -Edgar, შეგიძლიათ გაზარდოს ეს?
>> -Hang on.
>> -I've მუშაობს ამ ასახვა.
>> -ვიღაცის ასახვა.
>> -ასახვა.
>> -არის ასახვა საქართველოს ადამიანის სახე.
>> -ასახვა.
>> -არის ასახვა.
>> -ზომით სარკეში.
>> -შეგიძლიათ ასახვა.
>> -შეგიძლიათ აძლიერებს იმიჯი აქედან?
>> -შეგიძლიათ აძლიერებს მას უფლება აქ?
>> -შეგიძლიათ გაზრდის?
>> -შეგვიძლია გავაძლიეროთ ეს?
>> -შეგიძლიათ გაზრდის?
>> -გაიმართება მეორე, მე გაზარდოს.
>> -ზომით კარი.
>> -X10.
>> -Zoom.
>> [სიცილი]
>> -გადატანა შემოსული
>> -მოითმინეთ, შეწყდეს.
>> გაჩერების.
>> -პაუზის იგი.
>> -როტაცია 75 გრადუსია დაახლოებით ვერტიკალური გთხოვთ.
>> [სიცილი]
>> გაჩერების და უკან ნაწილი შესახებ კარი ერთხელ.
>> -Got იმიჯი Enhancer რომელიც შეიძლება bitmap?
>> -იქნებ ჩვენ შეგვიძლია გამოვიყენოთ Pradeep Sen მეთოდის სანახავად შევიდა ფანჯრები.
>> -ეს პროგრამული უზრუნველყოფა არის დონით.
>> -ხატი ღირებულება არის მოედანი.
>> -უფლების მქონე კომბინაცია საქართველოს ალგორითმები.
>> -ის გადაღებული განათება ალგორითმები to მომდევნო დონეზე და შემიძლია მათი გამოყენება
აძლიერებს ამ ფოტოს.
>> -დაბლოკვა და გაფართოების z-ღერძი.
>> -გაძლიერება.
>> -Freeze და აძლიერებს.
>> [END ვიდეო აღწარმოების]
>> დევიდ ჯ Malan: ასე რომ პრობლემა Set 5 რა დევს წინ ანგარიშით არსებობს.
ასე რომ, ჩვენ მალე უკეთ თუ როდის და რატომ შეგიძლიათ
და ჩვენი ვერ შეუწყობს ამ გზით.
მაგრამ პირველი, დავუბრუნდეთ ჩვენს ყურადღებას ზოგიერთი შენობა ბლოკად ჩვენ გამოგიგზავნით
უნდა შეეძლოს გითხრათ, რომ ამბავი.
>> ასე რომ გავიხსენოთ, რომ ჩვენ მიიპყრო ამ სურათს ორშაბათს და ცოტა გასულ კვირას.
ეს აღწერს განლაგება რამ თქვენს კომპიუტერის მეხსიერების როდესაც
გაშვებული ზოგიერთი პროგრამა.
ტექნიკური სეგმენტი დასაწყისშივე, გაწვევას, ეხება ფაქტობრივად zeros და პირობა
რომ დაკომპლექტებას თქვენი პროგრამა.
აქ არის, ქვემოთ რომ, ზოგიერთი ინიციალიზაცია ან uninitialized მონაცემები, რომლებიც, როგორც წესი,
ეხება რამ, როგორიცაა მუდმივები ან strings ან გლობალური ცვლადები, რომ აქვს
გამოცხადდა წინასწარ.
აქ არის ბევრი, მაგრამ ჩვენ მოვა უკან რომ ცოტა.
>> და მაშინ იქ დასტის.
ისევე, როგორც დასტის ქაღალდის in cafeteria, ეს არის სადაც მეხსიერება იღებს
ფენიანი და ფენიანი როდესაც ეს თქვენ რა ამ პროგრამაში?
რა არის დასტის გამოყენება?
>> ჰო?
>> Call of ფუნქცია.
ნებისმიერ დროს თქვენ მოვუწოდებთ ფუნქცია, ეს მიენიჭოს Sliver მეხსიერების მისი
ადგილობრივი ცვლადები ან მისი პარამეტრები.
და pictorially, ჩვენ ვხედავთ, რომ თითოეული თანმიმდევრული ფუნქცია მოუწოდა, როდესაც
ზარები B ზარები C ზარები D, მათ მიიღეთ ფენიანი გადატანა დასტის.
და თითოეულ მათგანს ნაჭერი მეხსიერება არსებითად უნიკალური ფარგლებს
ამისათვის ფუნქცია, რომელიც, რა თქმა უნდა, პრობლემატურია, თუ გინდათ გადასცემს
ერთი ფუნქცია კიდევ ერთი ცალი მონაცემთა, რომ გსურთ
to mutate ან შეცვალოს.
>> ასე რომ, რა იყო ჩვენი გადაწყვეტა, რომელიც უზრუნველყოფს ფუნქციის წარმოდგენილია ერთი დასტის
ვიზრუნოთ შეცვალოს მეხსიერების შიგნით მეორე დასტის ჩარჩოში?
როგორ ორი განხილვა ერთმანეთს?
ამიტომ გზით მითითებას ან მისამართები, რომელიც, კიდევ ერთხელ, მხოლოდ აღწერს, სადაც
მეხსიერება, გზით კონკრეტული bite ნომერი, კერძოდ
ღირებულება შეიძლება მოიძებნოს.
ასე რომ გავიხსენოთ, ბოლო დროს ძალიან გავაგრძელეთ ამბავი და უყურებდნენ
საკმაოდ buggy პროგრამა.
ეს პროგრამა არის buggy რამდენიმე მიზეზის გამო, მაგრამ ყველაზე შემაშფოთებელი ის არის,
რადგან იგი არ შეამოწმოს რა?
>> ჰო, ის ვერ შეამოწმებს შეყვანა.
ბოდიში?
>> თუ ეს უფრო მეტია, ვიდრე 12 სიმბოლო.
ასე რომ, ძალიან smartly, დარეკვისას memcopy, რაც, როგორც სახელი ვარაუდობს, უბრალოდ
ასლები მეხსიერება თავისი მეორე არგუმენტი მისი პირველი არგუმენტი.
მესამე არგუმენტი, ძალიან smartly, არის შეამოწმეს, რათა დავრწმუნდეთ, რომ თქვენ არ
კოპირება ზე მეტი, ამ შემთხვევაში, სიგრძე საქართველოს ბარი, რაოდენობის პერსონაჟი,
შევიდა დანიშნულების, რომელიც ამ მასივი C. მაგრამ პრობლემა ისაა, რომ რა
თუ C თავად არ არის საკმარისი გაუმკლავდეს, რომ?
თქვენ აპირებს რაოდენობის bytes რომ თქვენ მიეცა.
მაგრამ რას რეალურად უფრო მეტი bytes ვიდრე თქვენ გაქვთ ოთახში?
>> ასევე, ამ პროგრამით ძალიან foolishly მხოლოდ ბრმად ამისა მიიღოს რაც არ არის
მოცემული მიესალმები წარმატებული 0 არის დიდი თუ სიმებიანი მოკლე
საკმარისია, ისევე როგორც ხუთი სიმბოლო.
მაგრამ თუ ეს რეალურად 12 სიმბოლო ან 1,200 პერსონაჟი, დავინახეთ, ბოლო დროს
რომ თქვენ მხოლოდ აპირებს მთლიანად გადაწერა მეხსიერება, რაც
არ ეკუთვნის თქვენ.
ხოლო უარეს შემთხვევაში, თუ ჩაანაცვლებს, რომელიც წითელი ნაწილი იქ რომ ჩვენ მოუწოდა
დაბრუნების მისამართი -
ეს მხოლოდ, სადაც კომპიუტერული ავტომატურად, თქვენ, უკან
სცენები, tucks მოშორებით 32-bit ღირებულება, რომელიც შეახსენებს, რომ ის, თუ რა მისამართი საჭიროა
დაბრუნებას, როდესაც foo, ეს სხვა ფუნქცია, კეთდება შესრულებაში.
ეს პური crumb ჯიშები რომელსაც იგი ბრუნდება.
თუ თქვენ გადაწერა, რომ პოტენციურად, თუ თქვენ ცუდი ბიჭი, შეიძლება შესაძლებელი იქნებოდა
პოტენციურად აღება ვიღაცის კომპიუტერი.
და თქვენ ყველაზე, რა თქმა უნდა ავარიის იგი ხშირ შემთხვევაში.
>> ახლა ეს პრობლემა მხოლოდ ამძაფრებს როგორც ჩვენ ალაპარაკდა მეხსიერება
მართვის ზოგადად.
და malloc, მეხსიერების გამოყოფის, არის ფუნქცია, რომ ჩვენ შეგვიძლია გამოვიყენოთ გამოყოფას
მეხსიერება როდესაც ჩვენ არ ვიცით წინასწარ რომ ჩვენ შეიძლება საჭიროა გარკვეული.
ასე მაგალითად, თუ მე დაბრუნდეს to მოწყობილობის აქ.
და მე ქმნის ბოლო დროს hello2.c, გავიხსენოთ, ამ პროგრამის, რაც ჩანდა
ცოტა რაღაც მსგავსი, მხოლოდ სამი ხაზი -
განვაცხადო, თქვენი სახელი, შემდეგ სიმებიანი სახელი, მარცხენა შეადგენს getstring.
და მერე ბეჭდვა ის, მომხმარებლის სახელი.
>> ასე რომ, ეს იყო სუპერ მარტივი პროგრამა.
იმისათვის რომ ნათელი, ნება მომეცით წავიდეთ წინ და მიიღოს Hello-2.
მე ვაპირებ გაკეთებას dot ხაზი Hello-2.
სახელმწიფო თქვენი სახელი -
დავით.
შეიტანეთ.
გაუმარჯოს დავით.
როგორც ჩანს მუშაობა OK.
ახლა კი რა სინამდვილეში ქვეშ hood აქ?
პირველი მოდით კანი უკან რაღაც ფენებს.
სიმებიანი მხოლოდ სინონიმი ჩვენ მიხვდა, თუ რა?
Char ვარსკვლავი.
მოდით, რომ მას უფრო arcane მაგრამ უფრო ტექნიკურად ზუსტი რომ ეს
არის char ვარსკვლავი, რაც ნიშნავს, რომ სახელი, დიახ, არის განსხვავებულია.
მაგრამ რა სახელი მაღაზიებში არის მისამართი char, რომელიც გრძნობს ცოტა უცნაურია
იმიტომ, რომ მე მისაღებად უკან სიმებიანი.
მე მისაღებად უკან მრავალჯერადი სიმბოლო არ char.
>> მაგრამ, რა თქმა უნდა, საჭიროა მხოლოდ პირველი char მისამართი უნდა გვახსოვდეს, სადაც
მთელი სიმებიანი არის, რადგან რატომ?
როგორ გაერკვნენ, სადაც ბოლოს სტრიქონს იცის, დასაწყისში?
წარმატებული ნულოვანი.
ასე რომ, იმ ორი წარმოშობა თქვენ გაერკვნენ დაწყებამდე და ბოლოს
რომელიმე სიმებიანი არიან, ასე რომ, სანამ ისინი სათანადოდ გაფორმებული, რომ null
terminator, რომ წარმატებული ნულოვანი.
>> მაგრამ ეს მოუწოდებენ getstring.
და აღმოჩნდება, რომ getstring მთელი ამ ხნის განმავლობაში ასეთი
მოტყუების ჩვენთვის.
ეს აკეთებდა ამ შრომას, რა თქმა უნდა, მიღების ნახატზე შესახებ.
მაგრამ სად არის ის, რომ მეხსიერება უკვე მოდის?
თუ ჩვენ დაბრუნდეს სურათზე აქ და ვრცელდება განმარტება მხოლოდ
მომენტში წინ, რომ სტეკი არის სადაც მეხსიერება მიდის, როდესაც ფუნქციები უწოდებენ,
იმ ლოგიკით, როცა რეკავთ getstring, და მერე აკრიფოთ
D--V-I-D შეიტანეთ, სადაც D--V-I-D წარმატებული ნულოვანი ინახება, საფუძველზე
ამბავი ჩვენ გვითხრა, შორს?
>> როგორც ჩანს, ამ სტეკი, არა?
როცა მოვუწოდებთ მიიღოს სიმებიანი თქვენ გაქვთ პატარა ნაჭერი მეხსიერება on დასტის.
ასე რომ, იგი დგას, რომ მიზეზი, რომ D--V-I-D წარმატებული ნულოვანი ინახება
იქ დასტის.
მაგრამ დაველოდოთ ერთი წუთით, getstring ბრუნდება რომ სიმებიანი, ასე ვთქვათ, რაც იმას ნიშნავს,
ეს უჯრა საწყისი cafeteria არის აღებული off დასტის.
და ჩვენ ვთქვით, რომ ბოლო დროს, რომ როგორც კი ფუნქცია დააბრუნებს, და შენ რომ
პანელში, ასე ვთქვათ, off დასტის, რა შეგიძლიათ ვივარაუდოთ შესახებ ნარჩენებისგან
რომ მეხსიერება?
მე სახის redrew მათ, როგორც კითხვის ნიშნები იმიტომ, რომ ისინი ეფექტურად გახდეს
უცნობი ღირებულებებს.
ისინი შეიძლება გამოყენებული, როდესაც რამდენიმე მომდევნო ფუნქცია ეწოდება.
>> სხვა სიტყვებით, თუ მოხდება უნდა შენახვა -
მე მიაპყროს სწრაფი სურათზე აქ დასტის.
თუ ჩვენ არ უნდა იყოს ხატვის ბოლოში , ჩემი მეხსიერების სეგმენტი და ჩვენ ვთქვათ,
რომ ეს არის ადგილი მეხსიერება ოკუპანტების მიერ ძირითადი და იქნებ Arg გ და
Arg V და არაფერი ამ პროგრამაში, როდესაც getstring ეწოდება,
სავარაუდოდ getstring იღებს ბლოკი მეხსიერება აქ.
და მაშინ D--V-I-D რატომღაც მთავრდება ამ ფუნქციას.
და მე ვაპირებ oversimplify.
მაგრამ მოდით ვივარაუდოთ, რომ მის D--V-I-D წარმატებული ნულოვანი.
ასე რომ, ეს ბევრი bytes გამოიყენება ჩარჩოს getstring.
>> მაგრამ როგორც კი getstring ბრუნდება, ჩვენ განაცხადა ბოლო დროს, რომ ამ მეხსიერების მეტი
აქ ყველა ხდება - woops -
ყველა ხდება ეფექტურად წაშლილია.
ჩვენ შეგვიძლია ვიფიქროთ, ეს ახლა კითხვის ნიშნები, რადგან, ვინც იცის
რა უნდა გახდეს, რომ მეხსიერებაში.
მართლაც, მე ძალიან ხშირად მოვუწოდებთ ფუნქციები გარდა getstring.
და როგორც კი მოვუწოდებ ზოგიერთ სხვა ფუნქცია ვიდრე getstring, იქნებ არ
ამ კონკრეტულ პროგრამას, უბრალოდ ჩანდა ზე, მაგრამ რაღაც სხვა, აუცილებლად რაღაც სხვა
ფუნქცია შეიძლება დასრულდეს up აძლევენ ამ მომდევნო ადგილზე დასტის.
>> ასე რომ, ეს არ შეიძლება იყოს, რომ getstring მაღაზიები D--V-I-D მე სტეკი, რადგან მე
მაშინვე დაკარგავს ხელმისაწვდომობის იგი.
მაგრამ ჩვენ ვიცით, რომ ისინი getstring მხოლოდ ბრუნდება რა?
ეს არ ბრუნდებიან მე ექვსი სიმბოლო.
რა არის ეს ნამდვილად დაბრუნების საერთოდ ვთვლით, ბოლო დროს?
მისამართი პირველი.
ასე რომ, რატომღაც, მაშინ, როდესაც მოუწოდა getstring, ის გამოყოფის ბლოკი მეხსიერების
სიმებიანი რომ წევრებს ტიპისა და შემდეგ დაბრუნების მისამართი იგი.
და აღმოჩნდება, რომ, როდესაც გსურთ ფუნქციონირებს გამოყოს მეხსიერება ამ
გზა და დაბრუნების პირი, რომელსაც ეწოდება რომ ფუნქცია, მისამართი
რომ ბლოკი მეხსიერება, თქვენ აბსოლუტურად ვერ დააყენა ეს დასტის ზე
ბოლოში, რადგან ფუნქციურად უბრალოდ აპირებს არ გახდება თქვენი ძალიან
სწრაფად, ასე რომ თქვენ ალბათ მისახვედრია, სადაც ჩვენ, ალბათ აპირებს toss it
ნაცვლად, ე.წ. ბევრი.
>> ამიტომ შორის ბოლოში თქვენი მეხსიერება ნახვა განლაგება და ყველაზე თქვენი მეხსიერება ნახვა
განლაგება არიან მთელი bunch of სეგმენტები.
ერთი არის დასტის, და მარჯვენა ზემოთ ეს ბევრი.
და ბევრი უბრალოდ სხვადასხვა ბლოკი მეხსიერება, რომელიც არ გამოიყენება ფუნქციები
როდესაც ისინი მოუწოდა.
ეს გამოიყენება გრძელვადიანი მეხსიერება, როდესაც გსურთ ერთი ფუნქცია უნდა დაიბრუნოს ზოგიერთი
მეხსიერება და შეძლებს გათიშეთ შესახებ, რომ იგი დაკარგვის გარეშე კონტროლი.
>> ახლა თქვენ ალბათ, მაშინვე ვხედავთ, რომ ეს არ არის
აუცილებელი სრულყოფილი დიზაინი.
როგორც თქვენი პროგრამის გამოყოფილი მეხსიერება წლის დასტის, ან როგორც თქვენ მოვუწოდებთ უფრო და
მეტი ფუნქციებს, ან როგორც თქვენ გამოუყოფს მეხსიერება on ბევრი ერთად malloc off როგორც
getstring აკეთებს, რა ნათლად როგორც ჩანს, გარდაუვალი პრობლემა?
>> Right.
მსგავსად იმისა, რომ ეს ისრები მათ მიუთითებს ერთმანეთს
კარგს არაფერს უქადის.
მართლაც, ჩვენ შეგვიძლია ძალიან სწრაფად ავარიის გადაცემა ნებისმიერი რაოდენობის გზები.
სინამდვილეში, ვფიქრობ, შესაძლოა, გაკეთდეს ამ შემთხვევით კიდევ ერთხელ.
ან თუ არა, მოდით ეს შეგნებულად არის.
ნება მომეცით წავიდეთ წინ და წერა სუპერ სწრაფად პროგრამა dontdothis.c.
ახლა კი წავალ აქაც და ამის მკვეთრი მოიცავს stdio.h.
მოდით განაცხადოს ფუნქციის foo იღებს არანაირი არგუმენტი, რომელიც
აღნიშნა ასევე მიერ ბათილად.
>> და ერთადერთი, რაც foo აპირებს არის ზარი foo, რაც ალბათ არ არის
smartest იდეა, მაგრამ ასე იქნება ეს.
ყელ მთავარი ბათილად.
ახლა ერთადერთი, რაც მთავარია აპირებს ამისათვის არის მოვუწოდებთ foo ასევე.
და მხოლოდ ჩათვლით, მე ვაპირებ წასვლა წინ გვაქვს აქ და აცხადებენ, printf "Hello from
foo ".
>> OK.
ასე რომ, თუ არ რაიმე შეცდომებს, სასტარტედ dontdothis dot ხაზი.
და მოდით ამას უფრო დიდი ფანჯარა -
dot ხაზი, dontdothis.
კარგით.
Uh Oh.
როგორც ჩანს, შეგიძლიათ ამის გაკეთება.
Damn it.
OK.
დაველოდოთ.
ლოდინის.
მივიღეთ -
ჩვენ გამოიყენოთ ეს გააკეთოს.
>> [Sighs]
>> მე ვიცი, მაგრამ მე ვფიქრობ, რომ ჩვენ უბრალოდ იშლება, რომ.
Uh, ჰო.
Damn it.
მოსაგვარებლად Rob.
რა?
ეს ძალიან მარტივია.
ჰო, გადავედით ოპტიმიზაცია მოედანი.
OK, დგანან bye.
ახლა მე თავს კარგად გრძნობენ.
OK.
ყველა უფლება.
>> მოდით recompile ამ -
თქვენ dontdothis.
ალბათ გადარქმევა ეს dothis.c რაღაც მომენტში.
იქ ჩვენ წავიდეთ.
დიდი მადლობა.
OK.
ასე რომ, ის ფაქტი, რომ მე დაბეჭდვის რაღაც იყო, ფაქტობრივად მხოლოდ
შენელებისა პროცესი, რომლითაც ჩვენ იქნებოდა მიღწეული, რომ წერტილი.
OK.
Phew,
>> ასე რომ, რა ხდება რეალურად ხდება?
მიზეზი არ არსებობს, ისევე, როგორც განზე არის აკეთებს არაფერი თვალსაზრისით შემავალი და
გამომავალი ტენდენცია იყოს უფრო ნელა იმიტომ, რომ თქვენ უნდა დაწეროს პერსონაჟს
ეკრანზე, აქვე გადახვევა.
ასე რომ გრძელი ამბავი მოკლედ, ჰქონდა მე რეალურად მოხდა ისე, მოუთმენელი, გვექნებოდა
დრო საბოლოო ჯამში, ასევე.
ახლა, როდესაც მე მივიღე ride ბეჭდური-ups, ჩვენ ვხედავთ, რომ დაუყოვნებლივ.
რატომ ხდება ეს.
ასევე, მარტივი ახსნა, რა თქმა უნდა, ის არის, რომ foo ალბათ არ უნდა
უნდა მოუწოდებდა თავად.
>> ახლა ზოგადად, ეს არის უკან.
ჩვენ კი გვეგონა, რამდენიმე კვირის განმავლობაში წინ რეკურსიული არის კარგი.
უკან არის ამ ჯადოსნური გზა გამომხატველი თავს სუპერ აღწეროთ.
და ეს უბრალოდ მუშაობს.
თუმცა, არსებობს ძირითადი ფუნქცია ყველა რეკურსიული პროგრამების ჩვენ ვილაპარაკეთ
შესახებ და შევხედე ჯერჯერობით, რომელიც ის იყო, რომ მათ ჰქონდათ, თუ რა?
ბაზის შემთხვევა, რომელიც გარკვეული რთული კოდირებული შემთხვევაში, რომ განაცხადა, ზოგიერთ სიტუაციაში
არ ვუწოდებ foo, რომელიც აშკარად არ არის საქმე აქ.
>> ანუ, რაც ნამდვილად ხდება თვალსაზრისით ამ სურათს?
როცა მთავარ მოუწოდებს foo, იგი იღებს ნაჭერი მეხსიერება.
როდესაც foo მოუწოდებს foo, ის იღებს ნაჭერი მეხსიერება.
როდესაც foo მოუწოდებს foo, ის იღებს ნაჭრით.
იგი იღებს ნაჭრით.
იმის გამო, რომ foo არასოდეს ბრუნდებიან.
ჩვენ არასდროს erasing ერთი იმ ფარგლებში ეხლა დასტის.
ასე რომ, ჩვენ აფეთქება მეშვეობით ბევრი, არ უნდა აღინიშნოს, ვინ იცის, რა და
ჩვენ overstepping ფარგლებში ჩვენი ე.წ. სეგმენტი მეხსიერება.
შეცდომა წასვლა სეგმენტაცია ყალბი.
>> ასე რომ, გამოსავალი არსებობს აშკარად არ გააკეთებს.
მაგრამ უფრო დიდი გავლენა არის, რომ, დიახ, იქ აბსოლუტურად გარკვეული ზღვარი,
მაშინაც კი, თუ ეს არ ჩამოყალიბებული, თუ როგორ ბევრი ფუნქცია შეგიძლიათ ზარები
პროგრამა, რამდენი ფუნქცია შეუძლიათ თავად.
ასე რომ, მიუხედავად იმისა, რომ ჩვენ ეს იქადაგა უკან რადგან ეს პოტენციურად ჯადოსნური რამ
რამდენიმე კვირის წინ, sigma ფუნქცია, და როცა მივიღებთ მონაცემები
სტრუქტურებისა და CS50, დაინახავთ, სხვა განაცხადების, ეს ასე არ არის
აუცილებლად საუკეთესო რამ.
იმიტომ, რომ თუ ფუნქცია მოუწოდებს თავად, უწოდებს საკუთარ თავს, მაშინაც კი, თუ არსებობს ბაზა
იმ შემთხვევაში, თუ არ მოხვდა, რომ ბაზა შემთხვევაში ამისთვის 1,000 ზარები 10,000 ზარი, მიერ
იმ დროს თქვენ ალბათ ამოიწურა ოთახი თქვენს ე.წ. დასტის და მოხვდა
ზოგიერთი სხვა სეგმენტების მეხსიერება.
ასე რომ, ეს ძალიან არის დიზაინი ვაჭრობის შორის ელეგანტურობა და შორის
robustness თქვენი კონკრეტული განხორციელებას.
>> ასე რომ, კიდევ ერთი downside ან კიდევ ერთი GOTCHA თუ რა ჩვენ
აკეთებდა აქამდე.
როცა მოუწოდა getstring -
ნება მომეცით დაბრუნდეს შევიდა Hello-2.
გავითვალისწინოთ, რომ მე მოუწოდებენ getstring, რომელიც ბრუნდება მისამართი.
და ჩვენ ვამბობთ, რომ მისამართი არის ბევრი.
ახლა კი მე დაბეჭდვისას სიმებიანი იმ მისამართი.
მაგრამ ჩვენ არ ჰქვია საპირისპირო getstring.
ჩვენ არასდროს არ გვქონია, რომ calll ფუნქცია, როგორიცაა ungetstring, სადაც მხრივ უკან
რომ მეხსიერებაში.
მაგრამ გულწრფელად ჩვენ ალბათ უნდა ყოფილიყო.
იმიტომ, რომ თუ ჩვენ შევინარჩუნოთ ითხოვს კომპიუტერული მეხსიერების, გზით ვინმეს მოსწონს
getstring მაგრამ არ მისცეს მას უკან, აუცილებლად რომ ძალიან არის ვალდებული გამოიწვიოს
პრობლემები, რომლის დროსაც ჩვენ ამოიწურა მეხსიერება.
>> და სინამდვილეში, ჩვენ შეგვიძლია ვეძებოთ ეს პრობლემები ახალი ინსტრუმენტი, რომლის გამოყენება
ცოტა cryptic შეიტანოთ.
მაგრამ ნება მიბოძეთ წავიდეთ წინ და მისალმების ეს ეკრანზე რაღაც მომენტში.
მე ვაპირებ წავიდეთ წინ და აწარმოებს Valgrind ერთად პარამეტრების რომლის პირველი ბრძანება
ხაზი არგუმენტი სახელი იმ პროგრამის Hello-2.
და სამწუხაროდ გამომავალი atrociously
კომპლექსი არის კარგი მიზეზი.
ასე რომ, ჩვენ ყველა რომ ხმაური.
დავით მოგახსენებთ ჩემს სახელს.
ასე რომ, პროგრამა რეალურად გაშვებული.
ახლა ჩვენ მიიღოს ამ გამომავალი.
>> ასე რომ Valgrind მსგავსი სულითა to GDB.
ეს არ არის debugger თავისთავად.
მაგრამ ეს მეხსიერების ქვა.
ეს პროგრამა, რომელიც აწარმოებს თქვენი პროგრამა და გეტყვით, თუ თქვენ სთხოვა
კომპიუტერული მეხსიერების და არასდროს გადასცა მას უკან, რითაც რაც იმას ნიშნავს, რომ თქვენ გაქვთ
მეხსიერების გაჟონვის.
მეხსიერების გაჟონვის ტენდენცია იყოს ცუდი.
თქვენ არის წევრებს კომპიუტერების აქვს ალბათ იგრძნო ეს, თუ არა აქვს
Mac ან PC.
ოდესმე გამოიყენება თქვენი კომპიუტერი ხოლო და არა rebooted რამდენიმე
დღის განმავლობაში, ან თქვენ უბრალოდ ბევრი პროგრამები გაშვებული და რა რამ
slows to სახეხი შეჩერებას, ან თუნდაც ეს სუპერ შემაშფოთებელი გამოიყენოს, რადგან
ყველაფერი მხოლოდ მიიღო სუპერ ნელი.
>> ახლა, შეიძლება იყოს ნებისმიერი რიგი მიზეზების გამო.
ეს შეიძლება იყოს უსასრულო ციკლი, ხარვეზების ვიღაცის კოდი, ან, უფრო მარტივად, ეს
შეიძლება ნიშნავს, რომ თქვენ უფრო მეხსიერება, ან ცდილობს, თქვენი
კომპიუტერული რეალურად აქვს.
და, შესაძლოა, იქ ხარვეზების ზოგიერთი პროგრამა რომ შევინარჩუნოთ ითხოვს მეხსიერება.
ბრაუზერები წლების განმავლობაში ცნობილია ეს ითხოვს მეტი და მეტი მეხსიერების
მაგრამ გადაცემის უკან.
რა თქმა უნდა, თუ თქვენ მხოლოდ სასრული თანხის მეხსიერებაში შეგიძლიათ არ ვთხოვ
უსასრულოდ ბევრჯერ for ზოგიერთი, რომ მეხსიერებაში.
>> ასე რომ, რას ვხედავ აქ, მიუხედავად იმისა, ერთხელ Valgrind ის გამომუშავება
ზედმეტად კომპლექსი შეხედვით პირველი, ეს არის საინტერესო.
ბევრი -
გამოყენებულ გასასვლელი.
ასე რომ, აქ არის, რამდენი მეხსიერება იყო გამოიყენება ბევრი at
დროს ჩემი პროგრამის დასრულების -
როგორც ჩანს, ექვსი bytes ერთ ბლოკში.
ამიტომ, მე ვაპირებ ტალღა ხელები რა ბლოკი.
წარმოიდგინეთ, ეს მხოლოდ ბლოკი, უფრო ტექნიკური სიტყვაა ბლოკი.
მაგრამ ექვსი bytes -
რა არის ექვსი bytes რომ ჯერ კიდევ გამოიყენება?
>> ზუსტად.
D--V-I-D წარმატებული ნულოვანი, ხუთი წერილი სახელი პლუს null terminator.
ასე რომ ამ პროგრამის Valgrind შენიშნა, რომ მე სთხოვა ექვსი ბაიტი, ჩანს
გზა getstring, მაგრამ არასოდეს მისცა მათ უკან.
და სინამდვილეში, ეს არ შეიძლება იყოს ისე ცხადია, თუ ჩემი პროგრამა არ არის სამი
ხაზების, მაგრამ ეს 300 ხაზები.
ასე რომ, ჩვენ შეიძლება რეალურად მივცეთ კიდევ ერთი ბრძანება ხაზი არგუმენტი Valgrind to
უფრო verbose.
ეს პატარა შემაშფოთებელი უნდა გვახსოვდეს.
მაგრამ, თუ ამის გაკეთება -
ვნახოთ.
გაჟონვის -
იყო თუ არა გაჟონვის -
კი არ მახსოვს რა არის off ხელში.
>> - გაჟონვის შემოწმება შეადგენს სავსე.
Yep, მადლობა.
- გაჟონვის შემოწმება შეადგენს სავსე.
შეიტანეთ.
იგივე პროგრამა გაშვებული.
ტიპის დავით ერთხელ.
ახლა მე ვხედავ ცოტა უფრო დეტალურად.
მაგრამ ქვემოთ ბევრი შემაჯამებელი, რომელიც იდენტურია ოთხი - ah,
ეს არის ერთგვარი ლამაზი.
ახლა Valgrind რეალურად ეძებს ცოტა რთული ჩემს კოდი.
და ეს და განაცხადა, რომ, სავარაუდოდ, malloc დროს ხაზი -
ჩვენ დააშორებს.
ამასთან ხაზი -
ჩვენ ვერ ვხედავთ, რასაც ხაზი ეს არის.
მაგრამ malloc არის პირველი დამნაშავეებმა.
აქ წაკითხვა in malloc.
>> ყველა უფლება?
OK, არ.
არა?
დავურეკე getstring.
getstring სავარაუდოდ, მოუწოდებს malloc.
ასე რომ, რა ხაზი კოდი აშკარად დამნაშავე, რომელსაც
გამოყოფილი ამ მეხსიერების?
მოდით ვივარაუდოთ, რომ ვინც დაწერა malloc უკვე გარშემო ხანგრძლივი საკმარისი, რომ ეს
მათი ბრალი არ.
ასე რომ, ეს, ალბათ აფეთქდა.
getstring in cs50.c - ისე, რომ ის წარადგინოს სადმე კომპიუტერი -
შეესაბამება 286, როგორც ჩანს, დამნაშავეებმა.
ახლა ვარაუდობენ, რომ cs50 უკვე გარშემო ღირსეული დროის, ისე
ჩვენც ვართ infallible.
ასე რომ, ეს, ალბათ, არ getstring რომ ხარვეზის მდგომარეობს, არამედ
Hello-2.c ხაზი 18.
>> მოდით შევხედოთ რა, რომ ხაზი 18 იყო.
Oh.
რატომღაც ამ ხაზის არ არის აუცილებელი buggy, თავისთავად, მაგრამ ეს არის მიზეზი
უკან რომ მეხსიერების გაჟონვის.
ასე რომ სუპერ უბრალოდ, რას ინტუიციურად იყოს გამოსავალი აქ?
თუ ჩვენ ითხოვს მეხსიერება, არასდროს რაც მას უკან, და რომ, როგორც ჩანს,
პრობლემა დროთა განმავლობაში ჩემი კომპიუტერი შესაძლოა ამოიწურა მეხსიერება, შესაძლოა შენელდება
ქვემოთ, ცუდი შეიძლება მოხდეს, ისევე, რა არის მარტივი ინტუიციური გამოსავალი?
უბრალოდ მისცეს მას უკან.
>> როგორ გასათავისუფლებლად მდე რომ მეხსიერება?
ისე, საბედნიეროდ ეს საკმაოდ მარტივი უბრალოდ say უფასო სახელწოდება.
და ჩვენ არასოდეს კეთდება ეს ადრე იყო.
მაგრამ შეგიძლიათ არსებითად ვფიქრობ უფასო როგორც საპირისპირო malloc.
უფასო არის საპირისპირო გამოყოფის მეხსიერება.
ასე რომ, ახლა ნება მომეცით recompile ამ.
სასტარტედ Hello-2.
ნება მომეცით აწარმოებს კიდევ ერთხელ. Hello-2 დავით.
ასე რომ, როგორც ჩანს მუშაობა ზუსტად ისე.
მაგრამ თუ დაბრუნდეს Valgrind და ხელახლა აწარმოებს იმავე ბრძანება ჩემს ახლად
შედგენილი პროგრამა, აკრეფა ჩემი სახელით, როგორც ადრე -
ლამაზი.
ბევრი ინფორმაცია -
გამოყენებულ გასასვლელი -
ნულოვანი bytes in ნულოვანი ბლოკად.
ეს არის სუპერ ლამაზი, ყველა ბევრი ბლოკად გათავისუფლდა.
არ გაჟონვის შესაძლებელია.
>> ასე რომ მალე, არა პრობლემა Set 4, მაგრამ პრობლემა Set 5, სასამართლო
და შემდგომი, ესეც გახდება ღონისძიების სისწორეში თქვენი
პროგრამა, თუ არა გაქვთ ან არ აქვთ მეხსიერების ტბები.
მაგრამ საბედნიეროდ, არა მარტო შეგიძლიათ მიზეზი მათი საშუალებით ინტუიციურად, რომელიც
არის, სავარაუდოდ, ადვილად მცირე პროგრამები მაგრამ უფრო რთული დიდი პროგრამების,
Valgrind, მათთვის უფრო დიდი პროგრამების, შეგვიძლია დაგეხმაროთ იდენტიფიცირება
კონკრეტული პრობლემა.
>> მაგრამ არსებობს ერთი პრობლემა რომლებიც შეიძლება წარმოიშვას.
ნება მომეცით გახსნა ამ ფაილის აქ, რომელიც, ერთხელ, გარკვეულწილად უბრალო მაგალითი.
მაგრამ ფოკუსირება რა ამ პროგრამის აკეთებს.
ამას უწოდებენ memory.c.
ჩვენ ყველაფერს პოსტი ამ უკანასკნელს დღეს zip დღევანდელი წყაროს კოდი.
და შეამჩნია, რომ მაქვს ფუნქცია მოუწოდა ვ რომ იღებს არანაირი არგუმენტი და
ბრუნდება არაფერი.
შესაბამისად 20, მე როგორც ჩანს გამოცხადების მომცეთ int და უწოდა x.
მე მინიჭება არის დაბრუნების ღირებულება malloc.
და მხოლოდ უნდა იყოს ნათელი, თუ რამდენი ბაიტი am მე ალბათ მიღების უკან malloc
ამ სიტუაციაში?
>> ალბათ 40.
სად იღებთ რომ?
კარგად, თუ გავიხსენებთ, რომ int ხშირად 4 ბაიტი, მაინც ეს არის
მოწყობილობების, 10 ჯერ 4 აშკარად 40.
ასე რომ malloc ბრუნდება მისამართი ბლოკი მეხსიერება და შენახვის, რომ
სიტყვით საბოლოოდ in x.
ასე რომ იყოს ნათელი, თუ რა შემდეგ ხდება?
ასევე, ნება მომეცით გადართვის უკან ჩვენს სურათს აქ.
ნება მომეცით არ არის მხოლოდ მიაპყროს ბოლოში ჩემი კომპიუტერის მეხსიერებაში, ნება მომეცით წავიდეთ წინ და
მიაპყროს მთლიანი ოთხკუთხედი, რომ წარმოადგენს ყველა ჩემი ოპერატიული.
>> ჩვენ ყველაფერს ამბობენ, რომ სტეკი არის ქვედა.
და არ არსებობს ტექსტის სეგმენტის uninitialized მონაცემები.
მაგრამ მე მხოლოდ აპირებს აბსტრაქტული იმ სხვა საკითხებთან ერთად, რადგან dot, dot dot.
მე მხოლოდ აპირებს ეხება ეს როგორც ბევრი ზედა.
და მაშინ ბოლოში ამ სურათზე, წარმოადგენს ძირითად, მე ვაპირებ
მისცეს მას ნაჭერი მეხსიერება on დასტის.
იყიდება ვ, მე ვაპირებ, რათა ეს ნაჭერი მეხსიერების on დასტის.
ახლა, მე მივიღე კონსულტაციები ჩემი წყაროს კოდი კიდევ ერთხელ.
რა არის ადგილობრივი ცვლადები ძირითად?
როგორც ჩანს არაფერი, ისე, რომ ნაჭერი არის ეფექტურად ცარიელია ან არ კი როგორც დიდი
როგორც მე შედგენილი იგი.
მაგრამ ვ, მაქვს ადგილობრივი ცვლადი, რომელსაც x.
ამიტომ, მე ვაპირებ წავიდეთ წინ და მისცეს ვ ბლოკი მეხსიერება, უწოდა x.
>> ახლა კი malloc 10 ჯერ 4, ასე რომ malloc 40, სად, რომ
მეხსიერების მოდის?
ჩვენ არ ფორმდება სურათზე მინდა ეს ადრე იყო.
მაგრამ მოდით ვივარაუდოთ, რომ ის ეფექტურად მოდის აქ, ასე რომ ერთი,
ორი, სამი, ოთხი, ხუთი.
ახლა კი გვჭირდება 40 ამ.
ასე რომ, მე მხოლოდ ამის dot, dot, dot შევთავაზებთ რომ არსებობს კიდევ უფრო მეტი მეხსიერება
მოდის უკან ბევრი.
ახლა რა მისამართზე?
მოდით ავირჩიოთ ჩვენი თვითნებური მისამართი, როგორც ყოველთვის -
Ox123, მიუხედავად იმისა, ეს, ალბათ აპირებს რამ სრულიად განსხვავებული.
ეს არის ის, მისამართი პირველი ბაიტი in მეხსიერება, რომ მე ითხოვს malloc ამისთვის.
>> ასე რომ, მოკლედ, კიდევ ერთხელ ხაზი 20 გაუშვებს, რა არის ფაქტიურად
ინახება შიგნით x აქ?
Ox123.
და ხარი არის უინტერესო.
ეს მხოლოდ იმას ნიშნავს, აქ არის რიცხვი.
მაგრამ რა არის მთავარი არის, ის, რაც მე მაღაზიაში in x, რაც ადგილობრივი განსხვავებულია.
მაგრამ მისი მონაცემები ტიპის, კიდევ ერთხელ, არის მისამართი int.
ისე, მე ვაპირებ შესანახად Ox123.
თუმცა ისევ და ისევ, თუ ეს ცოტა გართულებული ზედმეტად, თუ გადახვევა
უკან, შეგვიძლია აბსტრაქტული ამ მოშორებით საკმაოდ გონივრულად და უბრალოდ, ვამბობთ, რომ x არის
მომცეთ, რომ ბლოკი მეხსიერება.
>> OK.
ახლა კითხვა ხელთ ასეთია -
ხაზი 21, თურმე არის buggy.
რატომ?
>> ბოდიში?
არა აქვს -
ამბობენ, რომ კიდევ ერთხელ.
ისე, ეს არ უფასო.
ასე რომ, მეორე მაგრამ.
ასე რომ, არსებობს ერთი, მაგრამ მაინც კონკრეტულად ერთი ხაზი 21.
>> ზუსტად.
ეს მარტივი ხაზი კოდი მხოლოდ ბუფერული overflow, ბუფერული გაუსწრო.
ბუფერული მხოლოდ იმას ნიშნავს, ბლოკი მეხსიერება.
მაგრამ ეს ბლოკი მეხსიერება of ზომა 10, 10 რიცხვებით, რაც იმას ნიშნავს, თუ ჩვენ
ინდექსი შევიდა ის გამოყენებით სინტაქსური შაქარი საქართველოს მასივი notation, მოედანი
ფრჩხილებში, თქვენ გაქვთ x bracket 0 x bracket 1 x,
bracket dot, dot, dot.
x bracket 9 არის ყველაზე დიდი ერთი.
ასე რომ, თუ გავაკეთო x bracket 10, სადაც მე რეალურად მიმდინარეობს მეხსიერების?
>> ისე, თუ მე მაქვს 10 int -
მოდით რეალურად მიაპყროს ყველა ამ აქ.
ასე რომ, იყო პირველი ხუთი.
აი დანარჩენი ხუთი ints.
ასე რომ x bracket 0 აქ არის. x bracket 1 აქ. x bracket 9 აქ არის. x bracket
10 აქ არის, რაც იმას ნიშნავს, მე ვეუბნებოდი, შეესაბამება 21, კომპიუტერული დააყენოს
რომელშიც?
ნომერი 0 რომელშიც?
ისე, ეს 0, დიახ.
მაგრამ ის ფაქტი, რომ მის 0 ერთგვარი დამთხვევა.
ეს შეიძლება იყოს ნომერი 50, ყველა ჩვენ ზრუნვა.
მაგრამ ჩვენ ვცდილობთ დააყენოს იგი x bracket 10, რომელიც, სადაც ეს
კითხვის ნიშნის დგება, რომელიც არ არის კარგი რამ.
ეს პროგრამა შეიძლება ძალიან კარგად ავარიის შედეგად.
>> ახლა მოდით წავიდეთ წინ და თუ ეს ნამდვილად, რა მოხდება.
სასტარტედ მეხსიერება, რადგან ფაილი ეწოდება memory.c.
მოდით წავიდეთ წინ და აწარმოებს პროგრამის მეხსიერებაში.
ასე რომ, ჩვენ მივიღეთ გაუმართლა, რეალურად, როგორც ჩანს.
ჩვენ გაუმართლა.
მაგრამ ვნახოთ, თუ ჩვენ ახლა აწარმოებს Valgrind.
ერთი შეხედვით, ჩემი პროგრამა შეიძლება როგორც ჩანს, კარგად სწორი.
მაგრამ ნება მიბოძეთ აწარმოებს Valgrind ერთად - გაჟონვის შემოწმება შეადგენს სრული სახით მეხსიერება.
>> ახლა კი, როცა აწარმოებს ამ -
საინტერესოა.
არასწორი დაწერა of ზომა 4 ხაზი 21 memory.c.
ხაზი 21 memory.c არის რომელი?
ოჰ, საინტერესოა.
მაგრამ დაველოდოთ.
ზომა 4, რა არის, რომ მას მხედველობაში?
მე მხოლოდ ერთი წერა, მაგრამ of ზომა 4.
რატომ არის 4?
ეს იმიტომ, რომ ეს int, რომელიც არის, კიდევ ერთხელ, ოთხი bytes.
ასე რომ Valgrind რომ პროგრამაში შეცდომაა, რომ მე, glancing ჩემს კოდი, არა.
და, შესაძლოა, თქვენი TF რომ ან არა.
რა მაგრამ Valgrind დანამდვილებით დაადგინა, რომ ჩვენ გავაკეთეთ შეცდომა არსებობს, მაშინაც კი,
თუმცა მივიღეთ გაუმართლა და კომპიუტერული გადაწყდა, eh, მე არ ვაპირებ მარცხი
მხოლოდ იმიტომ, რომ შეეხო ერთ ნაწილად, ერთი int ის ღირს მეხსიერების და არ არის
რეალურად საკუთარი.
>> ისე, რა არის buggy აქ.
მისამართი -
ეს გიჟები ეძებს მისამართი ამ თექვსმეტობითი.
ეს მხოლოდ იმას ნიშნავს, სადღაც ბევრი არის ნულოვანი ბაიტი შემდეგ ბლოკის ზომა 40
გამოიყოფა.
ნება მომეცით დააშორებს აქ და თუ ეს უფრო სასარგებლოა.
საინტერესო.
40 bytes ნამდვილად წააგო ამ ზარალის ჩანაწერი 1 1.
კიდევ ერთხელ, უფრო სიტყვა, ვიდრე არის სასარგებლო აქ.
მაგრამ საფუძველზე ხაზი გაუსვა ხაზი, სად უნდა ალბათ ფოკუსირება ჩემი
ყურადღებას კიდევ bug?
როგორც ჩანს, ხაზი 20 memory.c.
>> ასე რომ, თუ ჩვენ დაბრუნდეს ხაზი 20 ეს არის ის, ერთი, რომ თქვენ გამოვლენილი ადრე.
და ეს არ არის აუცილებელი buggy.
მაგრამ ჩვენ ამ შეცვალა თავისი ეფექტი.
ასე რომ, როგორ შემიძლია გამოსწორებას, სულ მცირე, ერთი იმ შეცდომების?
რა შეიძლება გავაკეთო შემდეგ ხაზი 21?
მე ვერ გააკეთებს თავისუფალი x, ასე მისცეს უკან რომ მეხსიერებაში.
და როგორ უნდა დააფიქსიროს ეს ხარვეზი?
მე უნდა აუცილებლად წავიდეთ არ შემდგომი ვიდრე 0.
ნება მომეცით ცდილობენ და თავიდან გაუშვით ეს.
სამწუხაროდ, აუცილებლად წავიდეთ არ შემდგომი ვიდრე 9.
სასტარტედ მეხსიერება.
ნება მომეცით გამეორება Valgrind ამ უფრო დიდი ფანჯარა.
ახლა კი გამოიყურება.
ლამაზი.
ყველა ბევრი ბლოკად გათავისუფლდა.
არ გაჟონვის შესაძლებელია.
და ზემოთ აქ, იქ არის ნახსენები ნებისმიერი მეტი ინვალიდი უფლება.
>> მხოლოდ მისაღებად ხარბ და მოდით თუ კიდევ ერთი აქცია
არ მიდის როგორც განკუთვნილი -
მე მისაღებად იღბლიანი მომენტი წინ.
ხოლო ის ფაქტი, რომ ეს არის 0, ალბათ ზედმეტად შეცდომა.
მოდით, უბრალოდ გაკეთება 50, გარკვეულწილად თვითნებური ნომერი, მიიღოს მეხსიერება dot ხაზი მეხსიერება -
მაინც გაუმართლა.
არაფერი ის crashing.
დავუშვათ, მე უბრალოდ რაღაც სულელური, და მე 100.
ნება მომეცით რიმეიკი მეხსიერება, dot ხაზი მეხსიერება -
მივიღე გაუმართლა ერთხელ.
როგორ შესახებ 1000?
ints მის ფარგლებს გარეთ, უხეშად სადაც მე უნდა?
სასტარტედ მეხსიერება -
რა იგი.
>> [სიცილი]
>> OK.
ნუ არეულობას გარშემო აღარ.
გამეორება მეხსიერება.
იქ ჩვენ წავიდეთ.
ყველა უფლება.
ასე რომ, როგორც ჩანს, თქვენ ინდექსი 100,000 ints მიღმა, სადაც თქვენ უნდა ყოფილიყო
მეხსიერება, ცუდი რამ ხდება.
ასე რომ, ეს აშკარად არ არის ხისტი, სწრაფი წესით.
მე სახის გამოყენებით სასამართლო პროცესი და შეცდომა მისაღებად არსებობს.
მაგრამ ეს იმიტომ, გრძელი ამბავი მოკლედ, თქვენი კომპიუტერის მეხსიერების ასევე იყოფა
შევიდა ეს ყველაფერი მოუწოდა სეგმენტები.
და ზოგჯერ, კომპიუტერი რეალურად მიერ მოცემული ცოტა მეტი მეხსიერება
ვიდრე ითხოვენ.
მაგრამ ეფექტურობა, უბრალოდ უფრო ადვილი მიიღეთ მეტი მეხსიერების მაგრამ მხოლოდ გითხრათ
რომ თქვენ მისაღებად ნაწილის.
>> და თუ თქვენ გაქვთ იღბლიანი ზოგჯერ, ამიტომ, თქვენ შესაძლოა შეეხოს
მეხსიერება, რომელიც არ განეკუთვნება თქვენ.
თქვენ არ გაქვთ იმის გარანტია, რომ თუ რა მნიშვნელობა დააყენა იქ დარჩება, რადგან
კომპიუტერული დღემდე ფიქრობს, რომ ეს არ თქვენი, მაგრამ არა აუცილებლად აპირებს
მოხვდა კიდევ ერთი სეგმენტი მეხსიერება კომპიუტერი და გამოიწვიოს შეცდომა მოსწონს
ეს ერთი აქ.
ყველა უფლება.
ნებისმიერი კითხვებით შემდეგ მეხსიერება?
>> ყველა უფლება.
მოდით შევხედოთ აქ, მაშინ, ზე რაღაც ჩვენ უკვე აღების for
მინიჭებული საკმაოდ გარკვეული დრო, რომელიც არის ამ ფაილი სახელად cs50.h.
ასე რომ, ეს ფაილი.
ეს არის მხოლოდ მთელი bunch კომენტარები up დასაწყისში.
და შეიძლება არ ჩანდა, ამ შემთხვევაში თქვენ poked გარშემო მოწყობილობების.
მაგრამ აღმოჩნდება, რომ ყველა დროის, როდესაც ჩვენ გამოყენებული უნდა გამოიყენოს სიმებიანი როგორც
სინონიმი, საშუალება, რომლითაც ჩვენ განვაცხადეთ რომ სინონიმი იყო ამ
სიტყვით typedef, ტიპის განსაზღვრას.
და ჩვენ ფაქტობრივად ამბობდა, მიიღოს სიმებიანი სინონიმი char ვარსკვლავი.
ეს საშუალება, რომლითაც დასტის შეიქმნა ეს სასწავლო დისკები ცნობილია, როგორც
სიმებიანი.
>> ახლა აქ მხოლოდ პროტოტიპის ამისთვის getchar.
ჩვენ შეიძლება არ უნახავს ეს ადრე, მაგრამ ეს მართლაც, თუ რას აკეთებს. getchar
იღებს არანაირი არგუმენტი, ბრუნდება char.
getdouble იღებს არ არგუმენტები, დააბრუნებს ორმაგი.
getfloat იღებს არანაირი არგუმენტი ბრუნდება float და სხვ.
getint არის აქ. getlonglong არის აქ.
და getstring არის აქ.
და ეს არის ის.
ეს purple ხაზი კიდევ ერთი preprocessor დირექტივა გამო
hashtag დასაწყისში იგი.
>> ყველა უფლება.
ასე რომ, ახლა ნება მომეცით წასვლას cs50.c.
და ჩვენ არ გაიგო დიდი ხნის მანძილზე ამ.
მაგრამ გადმოგცეთ glimpse თუ რა რაც ხდება ეს ყველაფერი
დრო, მინდა წასვლა -
მოდით getchar.
ასე რომ getchar ძირითადად კომენტარი.
მაგრამ ეს ასე გამოიყურება.
ასე რომ, ეს რეალური ფუნქცია getchar, რომ ჩვენ
აღების თავისთავად ცხადად არსებობს.
და მიუხედავად იმისა, რომ ჩვენ არ გამოიყენოს ეს ერთი რომ ხშირად, თუ ოდესმე, ეს სულ მცირე
შედარებით მარტივი.
ასე რომ, ღირს აღება სწრაფი შევხედოთ აქ.
>> ასე რომ getchar აქვს უსასრულო ციკლი, შეგნებულად ასე როგორც ჩანს.
ეს მაშინ უწოდებს - ეს კი ერთგვარი ლამაზი reuse კოდის ჩვენ თვითონ დაწერა.
ის მოუწოდებს getstring.
იმის გამო, რომ რას ნიშნავს, რომ მიიღოს char?
ისე, თქვენ შესაძლოა, ასევე ცდილობენ მთელი ხაზი ტექსტის შესახებ და
მაშინ მხოლოდ ვუყურებდეთ იმ სიმბოლოს.
შესაბამისად 60, აქ არის პატარა ცოტა საღი აზრის ქვითარი.
თუ getstring დაბრუნდა null, ნუ გაგრძელება.
რაღაც გაფუჭდა.
>> ახლა ეს გარკვეულწილად შემაშფოთებელი, მაგრამ ჩვეულებრივი in C. char მაქს ალბათ
წარმოადგენს რა უბრალოდ საფუძველზე მისი სახელი?
ეს მუდმივი.
ეს იგივეა რიცხვითი ღირებულება ყველაზე დიდი char შეგიძლიათ წარმოადგენს ერთად
ერთი bite, რომელიც სავარაუდოდ ამ ნომერზე 255, რომელიც არის ყველაზე დიდი ნომერი
წარმოადგენს რვა ბიტი, დაწყებული ნულოვანი.
ასე რომ, მე გამოიყენოს ეს, ამ ფუნქციას, როდესაც წერა ამ კოდექსით, მხოლოდ იმიტომ,
თუ რამე მიდის არასწორი getchar მაგრამ მისი მიზანი ცხოვრების დაბრუნებას
char, თქვენ უნდა როგორღაც შევძლებთ to ნიშანს შესახებ, რომ
რაღაც გაფუჭდა.
ჩვენ ვერ ბრუნდება null.
გამოდის, რომ null არის მაჩვენებელი.
ისევ და ისევ, getchar აქვს დაბრუნების char.
>> ასე რომ, კონვენციის, თუ რამე მიდის არასწორია, თქვენ, პროგრამისტი, ან
ამ შემთხვევაში, მე ბიბლიოთეკაში, მე მქონდა უბრალოდ გადაწყვიტოს თვითნებურად, თუ
რაღაც მიდის არასწორი, მე ვაპირებ დაბრუნებას ნომერი 255, რომელიც ნამდვილად
ნიშნავს, რომ ჩვენ არ შეგვიძლია, მომხმარებელს შეუძლია არა აკრიფოთ ხასიათი წარმოდგენილია მიერ
ნომერი 255 იმიტომ რომ ჩვენ იპარავს მას როგორც ე.წ. Sentinel მნიშვნელობა
წარმოადგენს პრობლემას.
ახლა კი გამოდის, რომ ხასიათი 255 არ არის რაღაც თქვენ შეგიძლიათ ტიპის
თქვენს კლავიატურაზე, ამიტომ არ არის დიდი გარიგება.
მონაწილე არ შეამჩნია, რომ მე მოპარული ეს პერსონაჟი.
მაგრამ თუ თქვენ ოდესმე ვხედავ ამ კაცს გვერდებზე კომპიუტერული სისტემის ზოგიერთი მინიშნება
ყველა caps მუდმივი მსგავსი, რომელიც ამბობს, შემთხვევაში შეცდომა ამ მუდმივ სიძლიერეზე
დაუბრუნდება, ეს ყველაფერი ადამიანის გააკეთა წლების წინ უკანონოდ გადაწყვიტა
დაბრუნდეს ეს განსაკუთრებული მნიშვნელობა და მას მუდმივი შემთხვევაში
რაღაც მიდის არასწორი.
>> ახლა ჯადოსნური ხდება ქვემოთ აქ.
პირველი, მე გამოცხადების შეესაბამება 67 ორი სიმბოლო, C1 და C2.
ხოლო შემდეგ ხაზი 68, იქ რეალურად ხაზი კოდი, რომ თქვენში
ჩვენი მეგობარი printf, იმის გათვალისწინებით, რომ ეს აქვს პროცენტით Cs in შეთავაზებებს.
მაგრამ შეამჩნია, რა ხდება აქ. sscanf ნიშნავს სიმებიანი scan -
ნიშნავს სკანირების ფორმატირებული სიმებიანი, Ergo sscanf.
რას ნიშნავს ეს?
ეს იმას ნიშნავს, თქვენ გაიაროს sscanf სიმებიანი.
და ხაზი რაც არ უნდა შესახებ სახის სისტემაში
თქვენ გაივლის sscanf სტრიქონში მოსწონს ეს რომ ეუბნება scanf რა
თქვენ იმედით მომხმარებელს ჯერ აკრეფილი შემოსული
თქვენ ისე მიეღო-in მისამართები ორი მოცულობით მეხსიერება, ამ შემთხვევაში,
იმიტომ, რომ მე ორი placeholders.
ამიტომ, მე ვაპირებ, რათა ეს მისამართი საქართველოს C1 და მისამართი C2.
>> და გავიხსენოთ, რომ თქვენ ფუნქცია მისამართი ზოგიერთი ცვლადის, რა
გავლენა?
რა შეიძლება, რომ ფუნქცია გავაკეთოთ შედეგად მინიჭების ეს მისამართი
ცვლადი, როგორც ეწინააღმდეგებოდა ცვლადი თავად?
მას შეუძლია შეცვალოს ის, არა?
თითქოს ვინმე რუკაზე ფიზიკური მისამართი, მათ შეუძლიათ წავალთ და ამის გაკეთება
რაც მათ უნდათ, რომ მისამართი.
იგივე იდეა აქ.
თუ ჩვენ გაიაროს sscanf, მისამართი ორი მოცულობით მეხსიერება, თუნდაც ეს პატარა
პატარა მოცულობით მეხსიერება, C1 და C2, მაგრამ ჩვენ ვეუბნებით, რომ ეს მისამართი მათგანი,
sscanf შეგიძლიათ შეცვლის.
>> ასე რომ sscanf მიზანი ცხოვრებაში, თუ ჩვენ წაიკითხა კაცი გვერდზე, არის წაკითხვის რა
მომხმარებლის აკრეფილი, იმედი შესახებ, რომელსაც აკრეფილი ხასიათი და იქნებ
კიდევ ერთი გმირი, და მიუხედავად შესახებ აკრეფილი, პირველ სიმბოლოს მიდის
აქ, მეორე სიმბოლო მიდის აქ.
ახლა, როგორც განზე, და თქვენ მხოლოდ ვიცი ეს დოკუმენტაცია,
ის ფაქტი, რომ მე ცარიელი სივრცე არსებობს მხოლოდ იმას ნიშნავს, რომ არ მაინტერესებს, თუ
შესახებ ჰიტები ფართი ბარი რამდენიმე ჯერ ადრე იგი იღებს
ხასიათი, მე ვაპირებ იგნორირება ნებისმიერ თეთრი სივრცეში.
ასე რომ, მე ვიცი, დოკუმენტაცია.
>> ის ფაქტი, რომ არსებობს მეორე% c მოჰყვა თეთრი სივრცე, ფაქტობრივად,
განზრახ.
მინდა შეძლებს აღმოაჩინოს თუ მომხმარებელი ბრალია ან არ ითანამშრომლებს.
ასე რომ მე იმ იმედით, რომ მომხმარებელს მხოლოდ აკრეფილი ერთ ხასიათი, ამიტომ მე იმ იმედით,
რომ sscanf მხოლოდ დაბრუნებას აპირებს ღირებულება 1, რადგან, კიდევ ერთხელ, თუ წავიკითხე
დოკუმენტაცია, sscanf მიზანი in ცხოვრება დაუბრუნდნენ რაოდენობის
ცვლადები, რომ ივსებოდა მქონე მომხმარებლის შეტანა.
>> I გავიდა ორი ცვლადის მისამართები, C1 და C2.
მე იმ იმედით, თუმცა, რომ მხოლოდ ერთი მათ იღებს მოკლეს, რადგან თუ sscanf
ბრუნდება 2, რა სავარაუდოდ გავლენა ლოგიკურად?
რომ მომხმარებელს არ მხოლოდ მაძლევს ერთი ხასიათი, როგორიც მე ვუთხარი მას.
ალბათ აკრეფილი ზე არანაკლებ ორი სიმბოლო.
ასე რომ, თუ მე ნაცვლად არ ჰქონდათ მეორე % C, მე მქონდა ერთი, რაც
გულწრფელად იქნება უფრო ინტუიტიური მიდგომა, ვფიქრობ, ერთი შეხედვით,
თქვენ არ აპირებს შეძლებს აღმოაჩინოს თუ მომხმარებელი უკვე გაძლევთ უფრო
შეყვანის ვიდრე რეალურად სურდა.
ასე რომ, ეს ფარული ფორმა შეცდომის შემოწმება.
>> მაგრამ შეამჩნია რა მე.
მას შემდეგ, რაც დარწმუნებული ვარ, რომ მომხმარებელს მომცა ერთი ხასიათი, მე გასათავისუფლებლად ხაზი, აკეთებს
საპირისპირო getstring, რაც თავის მხრივ იყენებს malloc, და მერე დაბრუნდნენ
C1, ხასიათი, რომ იმედი მქონდა მომხმარებლის გათვალისწინებული და მხოლოდ იმ პირობით.
ასე სწრაფად glimpsed, არამედ ნებისმიერ შეკითხვებს getchar?
ჩვენ ყველაფერს დაბრუნდება ზოგიერთი სხვები.
>> ისე, მინდა გითხრათ, წავიდეთ წინ და გაკეთება - ვარაუდობენ, ახლა, უბრალოდ მოტივაცია ჩვენი
დისკუსიის ერთ კვირაში პლუს დროს, ეს არის ფაილი სახელად structs.h.
ისევ და ისევ, ეს მხოლოდ გემოვნების რაღაც რომ დევს წინ.
მაგრამ შეამჩნია, რომ ბევრი ეს არის კომენტარი.
ნება მომეცით ხაზი გავუსვა მხოლოდ საინტერესო იქნება.
typedef -
იქ იმავე სიტყვით კიდევ ერთხელ.
typedef ვიყენებთ განაცხადოს სიმებიანი როგორც სპეციალური მონაცემების ტიპის.
თქვენ შეგიძლიათ გამოიყენოთ typedef, რათა შეიქმნას ახალი მონაცემთა ტიპები, რომ არ არსებობდა, როდესაც
C გამოიგონეს.
მაგალითად, int მოდის C. char გააჩნია C. ორმაგი გააჩნია C. მაგრამ
არ არსებობს ცნება სტუდენტი.
და მაინც, ეს იქნება საკმაოდ სასარგებლო იქნება შეუძლია დაწეროს პროგრამა, რომელიც ინახავს
in ცვლადი, სტუდენტის პირადობის მოწმობის ნომერი, მათი სახელი და მათი სახლში.
სხვა სიტყვებით, სამი ცალი მონაცემთა, მინდა int და
სიმებიანი და სხვა სიმებიანი.
>> ერთად typedef, რაც საკმაოდ ძლიერი ამის შესახებ და სიტყვით sturct for
სტრუქტურა, თქვენ, programmer 2013 წელს, შეიძლება რეალურად განსაზღვროს საკუთარი
მონაცემთა ტიპები, რომ არ არსებობდა წლის წინ, მაგრამ, რომ მოერგოს თქვენი მიზნებისათვის.
ასე რომ, აქ, ხაზების 13 გზით 19, ჩვენ ვაცხადებთ ახალი მონაცემები ტიპის, ისევე როგორც
int, მაგრამ უწოდა სტუდენტი.
და შიგნით ამ ცვლადის აპირებს სამი რამ - int, ტექსტი,
და სიმებიანი.
ასე, რომ თქვენ შეიძლება ვიფიქროთ, თუ რა მართლაც აქ მოხდა, მიუხედავად იმისა, რომ ეს
ცოტა გამარტივებას დღეს, სტუდენტი არსებითად აპირებს
თვალი მოსწონს ეს.
მისი იქნება ბლოკი მეხსიერება ID, სახელი
მოედანზე და სახლში სფეროში.
და ჩვენ შევძლებთ გამოიყენოს იმ მოცულობით მეხსიერება და შეღწევის ასეთია.
>> თუ მე წასვლას struct0.c, აქ არის შედარებით ხანგრძლივი, მაგრამ შემდეგ
ნიმუში, კოდექსი, იყენებს ამ ახალი შეასრულა.
ასე რომ, პირველ რიგში, ნება მომეცით თქვენი ყურადღება გავამახვილო to საინტერესო ნაწილების up დასაწყისში.
Sharp განსაზღვრავს სტუდენტები 3, აცხადებს მუდმივი მოუწოდა სტუდენტებს და ასიგნებების
იგი თვითნებურად 3, უბრალოდ ასე რომ მე მაქვს სამი სტუდენტის გამოყენებით
ამ პროგრამის არის.
აქ მოდის მთავარი.
და შეამჩნია, როგორ უნდა განაცხადოს მასივი სტუდენტი?
მე უბრალოდ გამოიყენოთ იგივე სინტაქსი.
სიტყვა სტუდენტი აშკარად ახალი.
მაგრამ სტუდენტი, კლასის, bracket სტუდენტებს.
>> ასე რომ, სამწუხაროდ, არსებობს უამრავი საქართველოს reuse ვადების აქ.
ეს არის მხოლოდ ნომერი.
ასე რომ, ეს არის როგორც ამბობდა სამი.
კლასი არის მხოლოდ ის, რაც მე მინდა მოვუწოდებთ განსხვავებულია.
მე ვერ ვუწოდებ სტუდენტებს.
მაგრამ კლასში, ეს არ კლასი ობიექტის ორიენტირებული ჯავის სახის გზა.
უბრალოდ კლასი სტუდენტებს.
და მონაცემთა ტიპის ყველა ელემენტის ამ მასივი სტუდენტი.
ასე რომ, ეს ცოტა განსხვავებული და ამბობდა რაღაც
ასე, უბრალოდ -
მე ამბობდა მომეცი სამი სტუდენტის და მოვუწოდებთ, რომ მასივი კლასის.
>> ყველა უფლება.
ახლა აქ ოთხი ციკლი.
ეს ბიჭი ნახვა ნაცნობი - iterate ნულიდან მდე სამი.
აი ახალი ნაწილი სინტაქსი.
პროგრამის აპირებს გამოიწვიოს me, ადამიანური, რათა ეს სტუდენტი
პირადობის მოწმობა, რომელიც int.
აი syntax რომლითაც შეგიძლიათ შესანახად რაღაც ID დარგის
საიდან კლასი bracket I. ასე რომ, ამ syntax ახალი არ არის.
ეს მხოლოდ იმას ნიშნავს, მომეცი მერვე სტუდენტი კლასში.
მაგრამ ეს სიმბოლო არის ახალი.
აქამდე ჩვენ ვერ გამოიყენება dot, მაინც კოდი მოსწონს ეს.
ეს ნიშნავს წასვლა struct ცნობილია, როგორც სტუდენტი და ამით რაღაც არსებობს.
ანალოგიურად, ამ მეორე ხაზზე, 31, წავიდეთ წინ და დააყენა, რაც არ უნდა შესახებ ტიპები
ამისთვის სახელი აქ და რას აკეთებს ამისთვის სახლი, იგივე, წავიდეთ წინ და
ამას. სახლში.
>> რას ამ პროგრამის საბოლოოდ გავაკეთოთ?
თქვენ ხედავთ პატარა teaser არსებობს.
ნება მომეცით წავიდეთ წინ და არ მიიღოს structs 0 dot ხაზი struct 0, სტუდენტის ID 1,
ამბობენ, დავით Mather, სტუდენტი ID 2.
Rob KIRKLAND, სტუდენტი ID 3.
ლორენ Leverit -
და ერთადერთი, რაც ამ პროგრამის გააკეთა, რაც არის სრულიად უკანონო, არის
მინდოდა, რომ რამე ამ მონაცემებით, ახლა რომ მე გვასწავლა, თუ როგორ უნდა
გამოყენება structs, არის მე მქონდა ამ დამატებითი მარყუჟის აქ.
მე iterate მეტი მასივი სტუდენტებს.
მე ჩვენი, ალბათ ახლა ნაცნობი მეგობარი, სიმებიანი შედარება, stircomp to
ჩეკი არის მე -8 სტუდენტის სახლი ტოლია Mather?
და თუ, უბრალოდ ბეჭდვა რაღაც თვითნებურად მინდა, დიახ, ის არის.
თუმცა ისევ და ისევ, მხოლოდ მაძლევს შესაძლებლობები გამოყენება და reuse და
reuse ამ ახალი dot notation.
>> ასე რომ, ვინ ზრუნავს, არა?
მალე ერთად სტუდენტის პროგრამა გარკვეულწილად თვითნებური, მაგრამ აღმოჩნდება,
რომ ჩვენ შეგვიძლია გავაკეთოთ სასარგებლო რამ ერთად ამ მაგალითად ასეთია.
ეს არის ბევრად უფრო რთული struct in C. ეს მივიღე ათეული ან მეტი სფეროებში,
გარკვეულწილად cryptically დაასახელა.
მაგრამ თუ თქვენ ოდესმე გამიგია გრაფიკა ფორმატში მოუწოდა bitmap, BMP, ეს
გამოდის, რომ bitmap ფორმატში საკმაოდ ბევრი ჰგავს, რომ ეს.
ეს სულელური პატარა ღიმილი სახეზე.
ეს პატარა სურათი, რომელიც მე zoomed წელს მე საკმაოდ დიდი იმისთვის, რომ მე ვერ ვხედავ ყოველ
ინდივიდუალური წერტილების ან pixels.
ახლა, თურმე ჩვენ შეგვიძლია წარმოადგენს შავი dot, ვთქვათ, ნომერი 0.
და თეთრი dot ნომრით 1.
>> ასე რომ, სხვა სიტყვებით, თუ გსურთ მიაპყროს ღიმილი სახეზე და გადარჩენა, რომ იმიჯი
კომპიუტერი, ეს suffices შესანახად zeros და პირობა, რომ ასე გამოიყურება, სადაც,
ერთხელ, პირობა არის თეთრი და zeros არის შავი ფერის.
და ერთად, თუ ეფექტურად აქვს gird of პირობა და zeros, თქვენ გაქვთ
ქსელში პიქსელი, და თუ ქმნის მათ, თქვენ გაქვთ cute
ცოტა ღიმილი სახეზე.
ახლა, bitmap ფორმატში, BMP, არის ეფექტურად რომ ქვეშ Hood,
მაგრამ უფრო pixels sot, რომ თქვენ სინამდვილეში წარმოადგენს ფერები.
>> მაგრამ როდესაც თქვენ უფრო დახვეწილი ფაილი ფორმატში BMP და JPEG და GIF
რომელთანაც შეიძლება იყოს ნაცნობი, იმ ფაილი დისკზე, როგორც წესი, არა მხოლოდ
აქვს zeros და პირობა pixels, მაგრამ ისინი რაღაც მეტადატის, ასევე -
meta იმ გაგებით, რომ არ არის ნამდვილად მონაცემთა მაგრამ ეს სასარგებლოა აქვს.
ასე რომ, ამ სფეროში აქ გულისხმობს და ჩვენ დავინახავთ ამ დეტალურად P-ნაკრები
5, რომ მანამ, სანამ zeros და პირობა, რომ წარმოადგენს pixels in იმიჯი,
არსებობს რამოდენიმე მეტამონაცემების მოსწონს ზომის სურათი და
სიგანე იმიჯი.
და შეამჩნია მე plucking off რამდენიმე თვითნებური რამ აქ -
სიგანე და სიმაღლე.
Bit რაოდენობა და ზოგიერთი სხვა რამ.
ასე რომ ზოგიერთი მეტამონაცემების in ფაილი.
>> მაგრამ გაგება თუ როგორ ფაილი ასახული out ამ გზით, თქვენ შეგიძლიათ რეალურად
შემდეგ მანიპულირება გამოსახულება, ფეხზე images ეხლა დისკზე, შეცვლის images.
მაგრამ ვერ აუცილებლად აძლიერებს მათ.
მე საჭირო ფოტოსურათი.
ასე რომ, მე დაუბრუნდა RJ აქ, რომელიც თქვენ ნახეთ ეკრანზე საკმაოდ ცოტა ხნის წინ.
და თუ გახსნა კონფერენციის მონაწილეებს აქ არის, ეს რა მოხდება თუ თქვენ ცდილობენ მასშტაბის გასაზრდელად და
აძლიერებს RJ.
ის არ მიღების რაიმე უკეთესი ნამდვილად.
ახლა კონფერენციის მონაწილეებს ერთგვარი დაბინდვა ეს ცოტა, მხოლოდ სიპრიალის მეტი
ის ფაქტი, რომ RJ ვერ განსაკუთრებით გაძლიერებული როდესაც თქვენ zoom სისტემაში
და თუ ამის გაკეთება ამ გზით, ვხედავ მოედნებზე?
ჰო, შეგიძლიათ ნამდვილად ვხედავ სკვერების on პროექტორს.
>> ეს არის ის, რაც თქვენ, როდესაც თქვენ გაზარდოს.
მაგრამ გაგება, თუ როგორ ხდება RJ ან ღიმილი სახეზე ხორციელდება შევძლებთ
რეალურად დაწეროს კოდი, რომელიც მანიპულირებს ეს ყველაფერი.
და მეგონა, მე მინდა დასრულდება ეს შენიშვნა, რომელიც 55 წამი აძლიერებს, რომ,
მე გაბედავდა, ვთქვათ საკმაოდ შეცდომა.
>> [ვიდეო აღწარმოების]
>> -ის ცრუობს.
შესახებ, თუ რა, არ ვიცი.
>> ისე, რა ვიცით?
>> -რომ 9:15 Ray Santoya იყო ბანკომატების.
>> ისე კითხვა, რა იყო ის აკეთებს 9:16?
>> -სროლა ცხრა მილიმეტრიანი ერთი რაღაც.
შესაძლოა, მან დაინახა, სნაიპერი.
>> ან მუშაობდა მასთან ერთად.
>> -მოითმინეთ.
დაბრუნება ერთი.
>> რა ხედავთ?
>> -მოტანა მისი სახე up, სრულ ეკრანზე.
>> -მისი მინები.
>> -არის ასახვა.
>> -ეს Neuvitas ბეისბოლის გუნდი.
სწორედ მათი ლოგო.
>> და ის საუბარი, ვინც არ არის ტარება რომ jacket.
>> [END ვიდეო აღწარმოების]
>> დევიდ ჯ Malan: ეს იყოს პრობლემა Set 5.
ჩვენ ვნახავთ თქვენ მომავალ კვირას.
>> MALE სპიკერი: მომდევნო CS50.
>> [CRICKETS CHIRPING]
>> [მუსიკალური სათამაშო]