>> დინამიკები 1: Hi ყველას.
ჩვენ ვაპირებთ დავიწყოთ.
მე ვფიქრობ, ხალხს ჯერ კიდევ გრძელდება უნდა იყოს ფილტრაცია in.
მაგრამ ინტერესი, ამიტომ ჩვენ შეგიძლიათ მისაღებად თქვენ ბიჭები აქედან დროს,
ჩვენ ვაპირებთ დავიწყოთ.
ასე რომ, კეთილი იყოს CS50 Quiz 0 მიმოხილვა.
იმ თქვენ, რომლებიც არ მიხვდა, ჯერჯერობით, თქვენ გაქვთ კითხვა, ოთხშაბათს.
Woo-hoo.
>> თუ თქვენ არ დაიწყო სწავლა ჯერ ან არ მიხვდა, რომ ეს არსებობს ჯერ კიდევ,
წარსულში ტესტებში და ყველა ინფორმაცია თქვენი Quiz არიან cs50.net/quizzes.
არსებობს რამდენიმე საკმაოდ კარგი პერსონალი იქ, წარსულში ტესტებში ბოლო 10
წლის განმავლობაში, ასევე ინფორმაცია ამ ვიქტორინაში და თემა
დაიფარება.
ასე რომ, მოდით დავიწყოთ.
>> ასე რომ თქვენ ბიჭები შეიძლება გახსოვთ, პირველი დღეს კლასის დავითი იმ ნათურები.
ასე რომ, არსებითად, ყველაფერი, რაც მიდის ქვეშ hood of კომპიუტერი
გაკეთდეს ორობითი.
ორობითი რას ნიშნავს ეს ჟღერს, როგორიცაა, 0 და 1 ს.
მას აქვს ორი ღირებულებები, რომელიც შეიძლება წარმოდგენილი.
>> ამიტომ ისევე როგორც პირველ დღეს განყოფილებიანი როდესაც დავით აღმოჩნდა სინათლის
ნათურა წარმოადგენს, ან 1, ჩვენი კომპიუტერი ესმის ორობითი როგორც 0 და
1 ს, ან გამოსართავად.
საფუძვლები ორობითი.
ყველა ადგილი არის წარმოდგენილი ბაზის ორი.
ასე რომ თქვენ დაამატოთ 2 დან 0 დან 1 2 ყველა გზა მდე.
>> გამოვთვალოთ რა ორობითი არის ათობითი, უბრალოდ მიყევით ამ განტოლების
ტიპი რამ.
თუ თქვენ გაქვთ 1 და იმ ადგილებში, თქვენ გავამრავლოთ იგი ნებისმიერი
ბაზის ის წელს, დაამატოთ it up, და თქვენ მიიღებთ ათობითი.
ასე რომ, ეს არის, თუ როგორ ითვლიან დან 5 ორობითი.
ისევე, როგორც ის, რასაც ჩვენ ვაკეთებთ ბოლო slide, ეს არის, თუ როგორ
წარმოადგენს 1 მეშვეობით 5.
>> ანალოგიურად, ისევე, როგორც თქვენ შეგიძლიათ დაამატოთ და სხვაობა ათობითი ან ბაზის 10, ან
მართლაც რაიმე ბაზა, შეგიძლიათ დაამატოთ და სხვაობა ორობითი.
ზუსტად ის, რაც თქვენ მოელოდა, როდესაც თქვენ დაამატეთ ორი, თუ იგი შეადგენს დიდი
ვიდრე 1, თქვენ განახორციელოს 1, იგი 0, და ამის გარდა, რომ გზა, მხოლოდ
როგორც თქვენ მოელოდა რეგულარული ათობითი ან სხვა ბაზის.
ზემოთ.
>> ასე რომ, როგორც ვთქვი, ყველაფერი, რაც მიდის ქვეშ hood ჩვენი კომპიუტერი
კეთდება 0 და 1 ს, ან ორობითი.
ასე როგორ უნდა გამოხატოს, მაგალითად, წერილები, ან ნომრები, ან სიმბოლოების?
და პასუხი რომ ASCII.
>> ASCII არის რუკების შორის გმირები რომ ჩვენ ჩვეულებრივ ვხედავთ
ინგლისური ენის მსგავსად ის, B-ს, C-ს უსვამს, dashes და
არაფერი რომ.
და ეს რუკები, რომ ASCII ღირებულება.
ASCII არც მხოლოდ ნომერი, რომელიც გასაგებია თქვენი კომპიუტერის.
და ისევე, როგორც თქვენ შეგიძლიათ ამის გარდა და გამოკლებაში ნომრები, შეგიძლიათ გააკეთოთ
მათ ASCII ღირებულებებს.
>> ასე რომ, ამ მაგალითად, რა იქნება ეს ამობეჭდოთ?
ჰო, ისე, უბრალოდ სივრცეში B სივრცე C ფართი დ სად ჩემს მაუსის წასვლა?
ყურადღება მიაქციეთ, შეგიძლიათ განსაზღვროს int 65.
და როდესაც თქვენ ბეჭდვა გამოყენებით პროცენტი C, ის ყველაფერს ინტერპრეტაცია, რომ როგორც
ხასიათი და ამობეჭდოთ ა
>> ასევე, თქვენ შეიძლება ითქვას, როგორც char.
და როდესაც თქვენ ამობეჭდოთ გამოყენებით პროცენტს C, ის ყველაფერს ინტერპრეტაცია, რომ როგორც
პროცენტი D. და ისევე, როგორც თქვენ შეგიძლიათ დაამატოთ ნომერი, შეგიძლიათ დაამატოთ სიმბოლოები
ASCII ღირებულებებს, ამ შემთხვევაში.
>> ასე რომ, პატარა მაჩვენებელი ყველასთვის.
5, როგორც სიმებიანი, არ რეალურად ტოლი 5.
ასე როგორ შეიძლება ჩვენ დააკონვერტიროთ string 5 რიცხვი 5?
ნებისმიერი იდეები?
Yeah.
>> ასე რომ, თუ ჩვენ გვაქვს 5, როგორც ტექსტი, ჩვენ შეგვიძლია გამოვაკლოთ 0.
და რომ მივცემ us 5.
და ანალოგიურად, თუ ჩვენ გვაქვს 5, რიცხვი, დავამატებთ, რომ სიმებიანი 0.
და რომ გვაძლევს სიმებიანი 5.
ზემოთ.
>> ახლა, გავიხსენოთ თავში ლექცია, სადაც ჩვენ ვისაუბრეთ ალგორითმები.
ასე რომ, ჩვენ რეალურად გვინდა კომპიუტერი გავაკეთოთ საინტერესო რამ?
თქვენ იცით, უბრალოდ დასძინა და subtracting ნომრები და ბეჭდვა რამ, არ არის
საინტერესოა.
როგორც წესი, ჩვენ გვინდა ჩვენი კომპიუტერიდან შეასრულოს გარკვეული ალგორითმის.
რაღაც ცოტა უფრო რთული ვიდრე უბრალოდ არითმეტიკული.
>> ალგორითმი არის მხოლოდ ეტაპობრივად კომპლექტი ინსტრუქციები, თუ როგორ ასრულებს
გარკვეული task--
ისევე როგორც რეცეპტი.
გახსოვთ, ალბათ, პირველ დღეს კლასი, სადაც დავითმა ითვლიან ოთახი
ადამიანი და რამდენი ადამიანი ოთახში.
თქვენ შეიძლება გამოყენებულ იქნას დათვლა ერთი.
1, 2, 3, 4.
იმ შემთხვევაში, წრფივი ალგორითმი.
>> მაგრამ დავით გააცნო ალგორითმი თქვენ ითვლიან ადამიანი ოთახში
სადაც ყველას დგას up, თქვენ ამბობთ, თქვენი ნომერი სხვა პირს, დავამატებთ, რომ
ნომერი, და ერთი ადამიანი ზის ქვემოთ.
და ვიმეორებ, რომ.
ეს არის ერთ ერთი ტიპის ალგორითმი.
ჩვენ შეგვიძლია ანალიზი, თუ რამდენად ეფექტური ალგორითმი ეფუძნება ის აწარმოებს დროს.
მაგრამ ჩვენ ამაზე ცოტა ამის შესახებ მოგვიანებით.
>> ასე რომ ყველა ალგორითმები ასევე შეგიძლიათ უნდა ჩაიწეროს pseudocode.
Pseudocode მხოლოდ ინგლისური, როგორიცაა სინტაქსი გამოიყენება წარმოადგენს
პროგრამირების ენა.
მაგალითად, თუ ჩვენ მინდოდა ვთხოვო შესახებ მისახვედრია, ჩემი საყვარელი ნომერი, ჩვენ
შესაძლოა, pseudocode, როგორც ასეთი.
>> მიიღეთ მომხმარებლები ვხვდები.
თუ ვხვდები სწორია, ვუთხრა ისინი სწორი, სხვას ვუთხრა,
ისინი არ არის სწორი.
და pseudocode არის გზა ადვილად წარმოადგენს იდეა ან ალგორითმი.
ასე რომ, ახლა ჩვენ დაგვჭირდება რეალურად წერენ ამ ენაზე, კომპიუტერული
შეიძლება გაგება.
ასე რომ ჩვენ შეგვიძლია დავწეროთ ჩვენი pseudocode და ინტერპრეტაცია, რომ შევიდა კოდის.
>> ჯერჯერობით, კოდის უნდა დაიცვას გარკვეული syntax of
პროგრამირების ენა.
და ჯერჯერობით, წელს CS50, ჩვენ გამოყენებით ძირითადად გ.
ასე რომ, ეს შეიძლება იყოს კოდის გ.
მოგვიანებით, რა თქმა უნდა, ღამით მოდის კონტაქტი სხვა პროგრამირების
ენებს, როგორიცაა PHP.
ან თუ კი მიიღოს სხვა კლასების, თქვენ შეიძლება ამის გაკეთება Java, Python, ან თუნდაც OCML.
მაგრამ ჩვენს c პროგრამა ენაზე, ეს არის როგორ შეიძლება დაწერა კოდის
pseudocode ალგორითმი, რომელიც უბრალოდ აღწერილია ადრე.
>> ასე როგორ თქვენი კომპიუტერი რეალურად მესმის, რომ?
როგორც მანამდე ვთქვი, ეს მხოლოდ მართლაც ესმის zeros და პირობა.
ასე როგორ მიიღონ წყარო კოდი, რაც შეიძლება იყოს
ამის გაგება?
ასევე, ჩვენ გვაქვს რაღაც ე.წ. შემდგენელი.
>> თუ გავიხსენებთ თავში უმეტეს თქვენი psets, თქვენ უნდა გარკვეული სახის პროგრამა
დაწერილი dot გ ფაილი.
და მაშინ აკრიფოთ მიიღოს.
ასე რომ, რა უნდა გააკეთოს აკეთებს?
>> შეგიძლიათ აკრიფოთ მიიღოს კომპილაციის თქვენი პროგრამა, რადგან someone--
ვინც დაწერა თქვენი P კომპლექტი; ალბათ David--
განთავსებულია მიიღოს ფაილი.
და რომ ეუბნება, რათა იცოდეთ, რომ აწარმოებს თქვენს შემდგენელი, ეწოდება clang, რომ იქნება
შემდეგ ადგენენ თქვენი კოდის გააპროტესტებენ კოდი, რომელიც zeros და პირობა
რომ თქვენი კომპიუტერი ესმის.
მაგრამ ცოტა მოგვიანებით, წავალთ მეტი სიღრმისეული შესახებ compilers.
>> ასე რომ გავიხსენოთ, pset 0, where-- დიახ, თქვენ გაქვთ შეკითხვა?
>> აუდიტორია: [INAUDIBLE]?
>> დინამიკები 1: დიახ.
მე ვფიქრობ, რომ ისინი, ფაქტობრივად, უნდა იყოს ონლაინ რეჟიმში.
Yeah.
>> აუდიტორია: რა არის ეს, როგორიცაა [INAUDIBLE]?
>> დინამიკები 1: ეს არ არის.
არიან cs50.net/quizzes.
>> აუდიტორია: Slash ტესტები, ხაზი 2013, slash 0, და დაწკაპეთ მეშვეობით
ტესტები 2013 და ვიქტორინაში 0, მიმოხილვა მონაკვეთზე სლაიდები.
>> დინამიკები 1: ჰო, ასე რომ, თუ თქვენ ბიჭები მინდა გაიყვანოს ეს და შევხედოთ მას თქვენი
კომპიუტერი, რომ ძალიან ჯარიმა.
ამბობენ, რომ ერთხელ.
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: Yeah, [INAUDIBLE] არის რაღაც განსხვავებულია.
Oh, დიახ?
>> აუდიტორია: [INAUDIBLE]?
>> დინამიკები 1: არა, გაფიცვების არ არის გამოცდა.
უკაცრავად, მის კითხვაზე, იყო იერიშის გამოცდა.
და ეს არ არის.
ასე რომ pset 0, თქვენ ბიჭები უნდა ჰქონდეს ყველა განხორციელებული რაღაც გამოყენებით ნულიდან.
და გავიგეთ, რომ ზოგიერთი ძირითადი პროგრამირების სამშენებლო ბლოკების გამოყენებით ნულიდან.
>> მოდით შევხედოთ ზოგიერთი ამ სამშენებლო ბლოკები
რომ შეადგინოს პროგრამა.
პირველი არის ის ლოგიკური გამოხატულებაა.
ლოგიკური გამონათქვამები პირობა და 0 ან რამე რომ აქვს
ორი შესაძლო მნიშვნელობებია.
ამ შემთხვევაში, ჭეშმარიტი ან მცდარი, ან გამოსართავად, და არა.
უბრალო მაგალითი, ძალიან მარტივია, პროგრამა, რომელიც იყენებს ლოგიკური
გამოხატვის აქ.
>> ამიტომ იმისათვის, ლოგიკური გამონათქვამები სასარგებლო იქნება, ჩვენ გვაქვს ლოგიკური ოპერატორები.
ეს არის ოპერატორები, რომ შეიძლება გამოყენებულ იქნას შედარების გარკვეული ღირებულებები.
ასე რომ, ჩვენ გვაქვს და ან არ არის ტოლი, ნაკლებად მეტი ან ტოლია მეტია ან
ტოლია და ნაკლები ან მეტი.
მაგრამ ეს ოპერატორი არ არის ძალიან სასარგებლო თუ არ შეგვიძლია დააკავშიროთ მათ
პირობები.
>> ასე რომ თქვენ ბიჭები შეიძლება გახსოვთ ნულიდან და თქვენი p ადგენს, რომ ჩვენ
მქონდა პირობები.
ისინი, ძირითადად, როგორიცაა ჩანგლები ლოგიკა თქვენი პროგრამა, რომელიც
ახორციელებს დამოკიდებულია თუ არა მდგომარეობა შეხვდა.
ასე რომ, ერთი პირობა, რომ ჩვენ გვქონდა გამოიყენება ბევრჯერ ეს კურსი არის
თუ სხვაგან, თუ, და სხვა პირობები.
>> აი მაგალითი, თუ როგორ თქვენ შეიძლება გამოვიყენოთ რომ.
ვინმეს ვიცი განსხვავება მხოლოდ გამოყენებით თუ განცხადებებს ყველა
გზა ქვემოთ ლექსები თუ სხვაგან, თუ, და სხვა კომბინირებული?
დიახ?
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: ზუსტად.
ასე რომ, თუ მე მქონდა თუ ყველა გზა ქვემოთ ამ მაშინაც კი, თუ ეს მდგომარეობა ბრუნდება
მართალია, ეს კვლავაც გაგრძელდება ტესტირების მომდევნო ორი.
ვინაიდან, სხვაგან თუ, სხვას განცხადება, თუ ერთი დააბრუნებს ასეა,
სხვები არ ტესტირება.
რაიმე შეკითხვები, რომ?
ზემოთ.
>> ასე, რომ თქვენ იყენებთ თუ სხვას- სხვას განცხადება, თუ თქვენ იცით, რომ ეს მხოლოდ
ერთი ამ შემთხვევაში.
ასე რომ, ჩვენ ვიცით, თუ x ნაკლებია, ვიდრე 0, ეს ნამდვილად არ იქნება
უფრო მეტი, ვიდრე 0.
>> შემდეგი, კიდევ ერთი შენობა ბლოკი შევიტყვეთ, მარყუჟების.
ჩვენ გვაქვს სამი ტიპის მარყუჟების.
ამისთვის მარყუჟების, ხოლო მარყუჟების, და ნუ ხოლო მარყუჟების.
და საერთოდ, როდესაც დასხდნენ რაღაც დავწერო, თქვენ უნდა გადაწყვიტოს,
რომელიც სამი გსურთ გამოიყენოთ.
ასე როგორ უნდა გადაწყვიტოს, რომელი ერთი?
>> ჩვენ ზოგადად გამოიყენოს ამისთვის loop თუ ჩვენ ვიცით, რამდენი ჯერ ჩვენ გვინდა iterate
მეშვეობით რაღაც ან რამდენჯერ ჩვენ გვინდა, რომ შეასრულოს დავალება.
ჩვენ ვიყენებთ ხოლო მარყუჟების თუ ჩვენ გვჭირდება მდგომარეობა უნდა იყოს ნამდვილი შენარჩუნება გაშვებული.
ჩვენ ვიყენებთ გააკეთოს, ხოლო ძალიან ჰგავს ხოლო, მაგრამ ჩვენ გვინდა, რომ ჩვენი კოდი გარბოდა
მინიმუმ ერთ დროს.
>> ასე რომ, ნუ ხოლო, რაც წელს გავაკეთებთ ყოველთვის აწარმოებს მინიმუმ ერთი დრო.
ვინაიდან, ხოლო, ის შეიძლება არ აწარმოებს ყველა, თუ
მდგომარეობა არ დაკმაყოფილდა.
ნებისმიერი კითხვები რომ?
>> ასე სტრუქტურა ამისთვის loop.
თქვენ ბიჭები არ მინახავს ყველა ეს.
თქვენ ინიციალიზაცია იგი.
თქვენ უნდა გარკვეული სახის მდგომარეობა.
ასე, მაგალითად, ჩვენ შეიძლება ინიციალიზაცია როგორც მე შეადგენს 0.
i ნაკლებია, ვიდრე 10.
და მე ++.
ძალიან მარტივია, რომ ჩვენ გავაკეთეთ.
>> ხოლო მარყუჟის, ანალოგიურად, თქვენ უნდა აქვს რაიმე სახის ინიციალიზაციისას,
გარკვეული სახის მდგომარეობა და გარკვეული სახის განახლება.
ასე რომ, ჩვენ შეგვიძლია განვახორციელოთ ჩვენი ამისთვის loop ასევე ხოლო მარყუჟის გამოყენებისას.
და მსგავსად do ხოლო მარყუჟის, ჩვენ შეიძლება გვაქვს ინიციალიზაციისას,
შეასრულოს რაიმე, განახლება, და შემდეგ შეამოწმოს მდგომარეობა.
>> ასე რომ, ახლა ფუნქციები.
ჩვენ ყველაფერს ერთად.
ჩვენ დაგვჭირდება წერა რამდენიმე სახის ფუნქცია.
საერთო ფუნქცია, რომ თქვენ შეიძლება ვნახეთ უკვე არის მთავარი.
მთავარი არის ფუნქცია.
მას დაბრუნების ტიპის, int.
მას აქვს ფუნქცია სახელი, მთავარი.
და მას აქვს არგუმენტები, argc და argv.
ასე რომ მთავარი მხოლოდ ფუნქცია.
>> სხვა ფუნქციები შეიძლება არ გამოიყენება, printf-- printf არის ფუნქცია
GetInt, toupper.
მაგრამ ეს მოხდება, რომ არ ყოფილიყო განხორციელებული ჩვენს მიერ
გარკვეული სახის ბიბლიოთეკა.
თუ ბიჭები გახსოვთ, მათ შორის ამ CS50.h ბიბლიოთეკის ან
სტანდარტული I / O ბიბლიოთეკაში.
დიახ, კითხვის ნიშნის ქვეშ?
>> აუდიტორია: რა არის მთავარი მხოლოდ თანდაყოლილი გ?
იმას, რომ ეს მხოლოდ სახის [INAUDIBLE]?
>> დინამიკები 1: ეს საკითხი არ არის თუ ძირითადი თან ახლავს გ.
და დიახ, ყველა ფუნქცია მთავარი ფუნქცია.
ეს არის სახის საჭირო კომპიუტერული ვიცი, სად უნდა დაიწყოს
გაშვებული კოდი.
>> აუდიტორია: ასე რომ თქვენ არ [INAUDIBLE]?
>> დინამიკები 1: არა
ნებისმიერი სხვა კითხვები?
ზემოთ.
ასე რომ, ისევე, როგორც თქვენ შეგიძლიათ გამოიყენოთ ფუნქცია რომ წერია, თქვენ ასევე შეგიძლიათ
დაწეროთ ფუნქცია.
ეს არის ფუნქცია, რომ ვინმე არ წერია, რომ მოცულობის გამოთვლა
საქართველოს q, მაგალითად.
იქ დაბრუნების ტიპის, აქ, ამ შემთხვევაში, int, ჩვენი ფუნქციის სახელი q და ჩვენი
სია პარამეტრები.
>> და აღნიშნავენ, რომ თქვენ უნდა დაწეროთ მონაცემები ტიპის პარამეტრი გსურთ
გამოყენება ან სხვა ფუნქცია არ ვიცით, თუ როგორი
პარამეტრების უნდა მე მიღება.
ასე რომ, ამ შემთხვევაში, ჩვენ გვინდა რიცხვი, როგორც ჩვენი დასტური.
ასე რომ, რატომ გვინდა, რომ ფუნქციები?
>> პირველ რიგში, დიდი ორგანიზაცია.
მათ დაეხმარება გაწყვეტის თქვენი კოდი შევიდა უფრო ორგანიზებული მოცულობით და
ეს უფრო ადვილი წასაკითხი.
გამარტივებას.
ეს არის კარგი დიზაინი.
როდესაც თქვენ კითხულობთ ნაჭერი კოდი და მისი მთავარი ფუნქცია მართლაც,
მართლაც დიდი, ეს შეიძლება იყოს უფრო რთული, მიზეზი, თუ რა ხდება.
ასე რომ, თუ თქვენ შესვენება მას down შევიდა ფუნქციები, ეს შეიძლება იყოს უფრო ადვილი წასაკითხი.
და reuse უნარი.
თუ თქვენ გაქვთ ბლოკი კოდი, რომელიც მიმდინარეობს მოუწოდა ან აწარმოებს რამდენჯერმე,
ნაცვლად გადაწერა რომ კოდი 10 ჯერ თქვენს მთავარ ფუნქციას, თქვენ შეიძლება
მინდა, რომ reuse ეს.
და შემდეგ ყოველ დროს, თქვენ უნდა გამოვიყენოთ, რომ ნაჭერი კოდი, მოვუწოდებთ ფუნქცია.
>> ახლა, თუ ჩვენ გვახსოვს უკან ნულიდან, ჩვენ ასევე ვისაუბრეთ რამდენიმე კონცეფციები,
რომელთაგან ერთი ნაკადებზე.
თემა კონცეფციის სხვადასხვა sequences of კოდი
შესრულებაში, ამავე დროს,.
ასე რომ, ვფიქრობ, უკან ერთი დღე, სადაც დავითი თქვენ ბიჭები ითვლიან off ნომერი
ადამიანი ოთახში.
>> არსებითად, რა ხდებოდა არის ყველა თქვენ ბიჭები იყვნენ
გაშვებული ცალკე თემა.
და იმ თემა იყო მომავალი ერთად მიიღოს გარკვეული პასუხი.
ანალოგიურად, Scratch, როდესაც თქვენ გაქვთ რამდენიმე sprites, თქვენ შეიძლება
კატა და ძაღლი.
და ისინი ერთდროულად გაშვებული საკუთარი სკრიპტები.
რომ არის მაგალითი threading.
>> და სხვა კონცეფცია, რომელიც იყო დაინერგა ნულიდან იყო მოვლენები.
და მოვლენები, როდესაც მრავალჯერადი ნაწილები თქვენი კოდი დაუკავშირდეს ერთმანეთს.
Scratch, ეს იყო, როდესაც გამოყენებულია სამაუწყებლო კონტროლი და როცა
მიიღეთ ბლოკები.
>> და ასევე, რომ პრობლემა Set 4, დავინახეთ ცოტა მოვლენების, ასევე.
თქვენ ბიჭები შესაძლოა გამოყენებული Gevent ბიბლიოთეკა.
და იყო ფუნქციის waitForClick რომელშიც თქვენ ელოდნენ
მომხმარებელს დაჭერით.
და თქვენი click, ამ შემთხვევაში იქნება ღონისძიება და დაველოდოთ click თქვენი
ღონისძიება დამმუშავებლის.
>> და ასევე, მთელი გაშვებული თქვენი psets და მუშაობს თქვენს psets, თქვენ
შეიძლება არ მოვიდეს კონტაქტში ზოგიერთი ეს ბრძანებები.
ეს არის ის, რაც თქვენ აკრეფილი თქვენს ტერმინალის ფანჯარაში ან რასაც window
ჩანს, რომ თქვენი g რედაქტირება, არსებითად, ნავიგაცია თქვენს კომპიუტერში.
>> ასე მაგალითად, LS ჩამოთვლილია შინაარსი დირექტორია.
მიიღოს დირექტორია ქმნის ახალ საქაღალდეში.
CD, შეცვალოს დირექტორია.
RM, წაშლა, წაშლის ფაილების ან რაიმე დირექტორია.
და შემდეგ ამოიღონ კატალოგი ხსნის დირექტორია.
>> აუდიტორია: [INAUDIBLE]?
>> დინამიკები 1: ჰო, რა თქმა უნდა.
ბოდიში, კითხვაზე იყო თუ მინდა ვარაუდობენ აყენებს
on cheat ფურცელი.
ეს შეიძლება დაეხმაროს.
თუ თქვენ გაქვთ ოთახში, თქვენ შეგიძლიათ განათავსოთ.
ეს არის ასევე მხოლოდ ზოგადად არის საკმარისი უნდა გვახსოვდეს, რომ როდესაც თქვენ გამოიყენოს იგი
დაგვჭირდება მხოლოდ აქვს ეს.
რომ გავაკეთებ თქვენი ცხოვრება ბევრი ადვილია.
არც მე უპასუხოს თქვენს კითხვაზე?
>> ახლა, ჩვენ ვისაუბრეთ ცოტა მოკლედ ბიბლიოთეკები.
მაგრამ ორი ძირითადი პირობა, რომ ჩვენ გამოყენებით ამ დრომდე რა თქმა უნდა,
სტანდარტული I / O და cs50.
რა სახის რამ შედის სტანდარტული I / O ბიბლიოთეკაში?
>> ჰო, ჯერჯერობით ჩვენ გამოიყენება printf.
CS50, ჩვენ გამოიყენება GetInt და GetString.
და მონაცემების ტიპის სიმებიანი ასევე მოხდება უნდა გამოცხადდეს ამ CS50 ბიბლიოთეკაში.
ჩვენ გაიგო უფრო სიღრმისეული შესახებ როგორ ბიბლიოთეკების მუშაობა და როგორ
ურთიერთქმედება დანარჩენი თქვენი კოდი.
მაგრამ ეს ის ორი ძირითადი პირობა, რომ ჩვენ არ შეხება ამ დრომდე
რა თქმა უნდა.
>> სახის.
ეს არის კარგი გვახსოვს რამდენად თითოეული სახის წარმოდგენილია ან როგორ
ბევრი bytes თითოეული ტიპის requires--
int, 4 ბაიტი; char, 1 ბაიტი.
Float არის 4 ბაიტი.
რა არის ორმაგი?
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: ჰო, ასე რომ float მაგრამ ორჯერ უფრო დიდია.
რაც შეეხება ხანგრძლივი?
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: OK.
რა არის გრძელი?
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: Yeah, ორმაგი int.
დიახ.
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: Long [INAUDIBLE].
და შემდეგ ხანგრძლივი ხანგრძლივი ორჯერ.
>> აუდიტორია: არა, არა.
ხანგრძლივი მხოლოდ int.
ეს დამოკიდებულია არქიტექტურა ადრე [INAUDIBLE]
და int აქვს იგივე ზომის.
[INAUDIBLE].
>> დინამიკები 1: ასე ხანგრძლივი და int არის იგივე.
და შემდეგ ხანგრძლივი ხანგრძლივი ორმაგი int.
ზემოთ.
და მაშინ, რა არის ბოლო ტიპის?
>> აუდიტორია: Pointer.
>> დინამიკები 1: ჰო, ჩვენ ვისწავლეთ ცოტა შესახებ მითითებას.
და მიუხედავად იმისა, რა კურსორი არის მიუთითებს, რომელთა მიზანია: ეს შეიძლება იყოს char ვარსკვლავი
ან int star--
ის ყოველთვის 4 ბაიტი მაჩვენებელი.
კითხვა რომ?
დიახ?
>> აუდიტორია: [INAUDIBLE]?
>> დინამიკები 1: ასე ხანგრძლივი და int არის იგივე ამ CS50 ელექტრო მოწყობილობების.
>> აუდიტორია: ელექტრო სრულიად ურთიერთშემცვლელნი.
>> დინამიკები 1: Yeah.
ასე რომ, შემდეგ ხანგრძლივი ხანგრძლივი ორმაგი int.
>> აუდიტორია: ეს არის 32 ბიტიანი?
>> დინამიკები 1: 32 bit, yeah.
>> აუდიტორია: ასე რომ [INAUDIBLE]?
>> დინამიკები 1: დიახ, თუ იგი არ მკაფიოდ ვთქვა,
უნდა ვივარაუდოთ, რომ 32 ბიტიანი.
>> აუდიტორია: ეს ვიტყოდი რაღაც როგორიცაა ვთქვათ,
არქიტექტურა, როგორიცაა ელექტრო.
64 bit, ერთადერთი რამ, ცვლილება longs და მითითებები.
ორივემ [INAUDIBLE].
>> დინამიკები 1: დიახ?
>> აუდიტორია: კითხვა.
ასე რომ, ერთი პრაქტიკა ტესტები, ის სთხოვს ხელმოუწერელი int.
ისე როგორ იქნებოდა, რომ უნდა განისაზღვროს, საწყისი int [INAUDIBLE]?
>> დინამიკები 1: ხელმოუწერელი წელს არის ასევე 4 ბაიტი.
მაგრამ რა არის განსხვავებული გაფორმდა int და ხელმოუწერელი int?
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: Right.
ერთი შეუძლია წარმოადგენს უარყოფითი ღირებულებებს.
მაგრამ როგორ გავაკეთოთ ეს?
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: ჰო, ეს ზოგავს 1 ცოტა წარმოადგენს ნიშანი.
ხელმოწერილი აქვს ერთი ცოტა რომ წარმოადგენს ნიშანი.
და ხელმოუწერელი უბრალოდ ყველა დადებითი.
>> აუდიტორია: OK.
ასე, რომ თქვენ აცხადებენ, რომ ორმაგი ორჯერ ზომა float?
>> დინამიკები 1: Double ორჯერ ზომა float, დიახ.
>> აუდიტორია: როგორ მაჩვენებელი ხანგრძლივი ხანგრძლივი [INAUDIBLE]?
>> დინამიკები 1: ასე რომ, კითხვა, თუ როგორ აკეთებს მომცეთ ხანგრძლივი ხანგრძლივი
როგორ არის, რომ მხოლოდ ოთხი ბაიტი, როდესაც ხანგრძლივი ხანგრძლივი მისი 8 ბაიტი.
ასე მახსოვს რა არის მაჩვენებელი, არსებითად, სწორედ ბაზა ღირებულება.
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: ჰო, ასე რომ მომცეთ მხოლოდ მეხსიერებაში.
ასე რომ არ აქვს მნიშვნელობა, თუ რამდენად სივრცეში ეს მაჩვენებელი მიუთითებს.
ეს მხოლოდ სჭირდება 4 bytes შენარჩუნება სიმღერა რომ მეხსიერებაში.
ნებისმიერი სხვა კითხვები?
ზემოთ.
>> ასე რომ, ბოლო რაც მაქვს, არის სტანდარტული გამომავალი.
თქვენ უნდა გამოიყენოთ ისინი ხშირად საკმარისი, რომ თქვენ მახსოვს.
მაგრამ ეს არის, როდესაც ჩვენ ვიყენებთ printf, მაგალითად.
და ჩვენ გვაქვს ამ მფლობელები, რომ დაიბარეს ფორმატის კოდები.
>> ამიტომ პროცენტს c char, პროცენტი i for int, და ჩვენ შეგვიძლია ასევე გამოვიყენოთ პროცენტი დ.
ეს იგივე.
მაგრამ, ზოგადად, CS50 ჩვენ ცდილობენ გამოიყენონ პროცენტი i.
პროცენტი f for float.
პროცენტი ld ხანგრძლივი ხანგრძლივი და პროცენტი s სიმებიანი.
>> ანალოგიურად, ჩვენ უკვე გამოყენებით რამდენიმე ამ გაქცევის sequences.
მაგალითად, წარმატებული n ახალი ხაზი.
ეს არის მხოლოდ მაშინ, როდესაც თქვენ გაფორმებით თქვენი კოდი ბეჭდვითი ვ.
დიახ?
>> აუდიტორია: რა არის პროცენტს დ?
>> დინამიკები 1: ასე რომ, კითხვა , რა არის პროცენტი დ?
პროცენტი d არის ints.
პროცენტი d და პროცენტი i იგივეა.
>> აუდიტორია: რა სხვაობაა წარმატებული ო და წარმატებული r?
>> დინამიკები 1: ასე რომ, კითხვა, თუ რა არის განსხვავება საწინააღმდეგოდ n და
საწინააღმდეგოდ r?
ვფიქრობ, წარმატებული r is--
>> აუდიტორია: ასე რომ წარმატებული r მხოლოდ გულისხმობს ბრუნდება ხაზის დასაწყისში
გარეშე რეალურად მიმდინარეობს ახალი ხაზი.
ასე რომ, თუ თქვენ ბეჭდვა წარმატებული r და თქვენ დაბრუნდეს დასაწყისში ხაზი
მაშინ ბეჭდვა მეტი პერსონალი, თქვენ გადავაწერო პერსონალი, რომ უკვე
[INAUDIBLE].
მაშინ, როდესაც n რეალურად მიდის ახალ ონლაინ და მიდის [INAUDIBLE].
>> დინამიკები 1: ისე, ნებისმიერი სხვა კითხვები?
ყველა უფლება.
მე ვაპირებ ხელის ეს off to Dan, რომელიც გაგრძელდება.
>> [ტაში]
>> DAN: ყველა კეთილი.
ასე რომ, მე უნდა ლაპარაკი კიდევ ფართო სპექტრი იდეები კლასს, რომლებიც
დაახლოებით წარმომადგენელი კვირაში ორი და დაწყების კვირაში სამი დაწყებული off
ჩამოსხმის, რომელიც მხოლოდ გზას მკურნალობის ღირებულება გარკვეული ტიპის, როგორც
ღირებულება სხვადასხვა ტიპის.
ასე რომ, ჩვენ შეგვიძლია გავაკეთოთ ამ სიმბოლო ints, მოძრავი to ints და
ხანგრძლივი longs გაორმაგდება.
>> ეს ყველაფერი შეიძლება გამოყენებულ იქნას, როგორც გზა მკურნალობის ზოგიერთი რიცხვითი მნიშვნელობა
მინუს char, როგორც ზოგიერთი სხვა რიცხვითი მნიშვნელობა.
ასე რომ, არსებობს გარკვეული საკითხები ამ, რა თქმა უნდა, რომელიც მოდის მაშინ, როდესაც მსახიობი
რამ, როგორიცაა float to ints.
ასე რომ, ეს ცოტა უცნაურია.
ჩვენ გვაქვს float, რომ არის 1.31.
ჩვენ გავამრავლოთ ის მიერ 10,000.
და მაშინ ჩვენ ბეჭდვა, როგორც int.
რას ნიშნავს ეს გამომავალი?
10,000 ჯერ 1.31.
ასე რომ, 13,000, არის ის, რომ ვხვდები?
>> აუდიტორია: მე ვფიქრობ, რომ ეს 10,000.
>> DAN: ასე რომ, მე გამრავლებით ეს 10,000 ადრე მე აძლევენ მას.
>> აუდიტორია: Oh.
რომ არ იყოს, ერთი 9 და ზოგიერთი 0 ნომრები?
>> DAN: ალბათ რაღაც უცნაური ციფრები.
ასე რომ უფლება, ის 1.3-ჯერ 10,000.
ასე რომ, ეს 13,000.
და ეს ზედმეტი weird--
>> აუდიტორია: 13.100.
>> DAN: 13.100.
გმადლობთ, Rob.
და ეს ზედმეტი weirdness--
ამ 9,9--
უბრალოდ იმიტომ, რომ ეს casting დასრულდა დამრგვალება ქვემოთ, სადაც
ეს არ უნდა.
Yeah.
>> აუდიტორია: casting ხდება შემდეგ არაფერი?
>> DAN: ასე იმიტომ, რომ მე ეს ბეჭდვითი, ჯერ ეს გამრავლება, სანამ ის
ჯერ ეს გააპროტესტეს.
>> აუდიტორია: [INAUDIBLE].
>> DAN: ვფიქრობ, ეს იქნებოდა მიცემული პირველი, yeah, რომელიც იქნება 10,000.
არაფერი?
ზემოთ.
ასე რომ, ეს არის 13.099.
რატომ ხდება ეს?
ორაზროვნება.
>> მოძრავი არ არის სრულყოფილი.
მათ შეუძლიათ მხოლოდ წარმოადგენს ნომრები გარკვეული რაოდენობის მნიშვნელოვანი მოღვაწეები.
ასე რომ, თუ ჩვენ ამობეჭდოთ 8 sig ლეღვის on ამ float, მივიღებთ სახის
მახინჯი ეძებს ნომერი.
და ეს იმიტომ, 1.31 არ შეუძლია ზუსტად შეიძლება წარმოდგენილი იყოს მარტივი
უფლებამოსილების ორი მანქანა.
ასე რომ მთავრდება აღების უახლოესი ვხვდები, რომელიც მთავრდება
რომ ცოტა დაბალია.
აზრი?
OK.
>> ახლა, გადავიდა სხვადასხვა გზა აკეთებს პირობითი, სადაც ყველა
ჩვენ აღელვებს ის არის ერთი ცვლადის.
ასე რომ, ამ კონკრეტულ მაგალითს, ჩვენ მიღების რიცხვი შესახებ.
და შემდეგ ჩვენ შევხედავთ რა, რომ მთელი რიცხვი.
სავარაუდოდ, ეს ნომერი ერთი და ოთხი.
რომ ის, რაც ჩვენ ითხოვს.
>> ასე რომ თქვენ გადართვის of ცვლადის სახელი.
მაშინ შეიქმნა ფაქტებზე აფასებს ეს შეიძლება იყოს.
ასე რომ, საქმე ერთი, ამბობენ, რომ ეს დაბალი.
და მაშინ შესვენება გავიდნენ შეცვლა მდგომარეობა, ამიტომ
თქვენ არ გაქვთ აპირებს.
>> მომდევნო case--
ასე შემთხვევაში ორი და საქმის three--
თუ ეს საქმე ორ უბრალოდ წვეთები ქვემოთ პირველი ხაზი კოდი, რომ ხედავს ერთად
შემთხვევაში სამი, სანამ ის ხედავს შესვენების.
ასე რომ, იმ მიზეზით, თქვენ მიიღებთ შემთხვევაში ერთი მხოლოდ ბეჭდვა დაბალი იმიტომ, რომ მე
აქვს ამ შესვენების აქ.
თუ მე, ვთქვათ, იგნორირებული ამ break-- თუ გადააგდეს ეს breakaway--
ეს იქნებოდა ბეჭდვა დაბალია, და მაშინ ბეჭდვა შუა და შემდეგ ეს იქნებოდა შესვენება.
>> ასე რომ, შეღავათები მნიშვნელოვანი ნაწილი შეცვლა პირობები და
მათ უნდა იქ.
ნებისმიერი შემთხვევები, რომ არ უთქვამს მკაფიოდ, სიფრთხილით მიერ ნაგულისხმები
შემთხვევაა შეცვლა და უნდა მისცეს.
>> აუდიტორია: ასე რომ 1, 2, 3, 4 იქნება n?
>> DAN: ფასეულობები, რომელიც n შეიძლება იყოს.
დიახ.
ჰო?
>> აუდიტორია: ასე რომ, როდესაც თქვენ გაქვთ რომ [INAUDIBLE]?
>> DAN თქვენ ბეჭდვა დაბალია, და მაშინ ეს იქნებოდა ბეჭდვა შუა და
მაშინ ეს იქნებოდა შესვენება.
>> აუდიტორია: რატომ უნდა ბეჭდვა შუა [INAUDIBLE]?
>> DAN: So ყველაფერი შემთხვევაში ადრე შესვენების ქვეშ ექცევა.
ასე რომ, საქმე ბეჭდვითი ქვევმოთ შემთხვევაში ერთი, როგორც ეს შემდეგ ბეჭდვა.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: ასე რომ, ეს არის მხოლოდ კონკრეტული ღირებულება, რომელიც ამ ცვლადი
შეუძლია, არა?
ამჯამად რომ აზრი?
Yeah.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ, საქმე ორი ბეჭდვა შუა და შემდეგ შესვენება.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: ვფიქრობ, არა?
რა სხვა მონაცემთა ტიპები შეგიძლიათ გადართოთ მეტი?
>> აუდიტორია: თქვენ შეგიძლიათ გადახვიდეთ მეტი ნებისმიერი ტიპის მონაცემები.
მაგრამ ეს მხოლოდ იმას ნიშნავს, არაფერი მეტი სიმბოლო და ints და პერსონალის იგრძნობა, რადგან
თუ თქვენ გადართვის მეტი მაჩვენებელი ეს ნამდვილად არ აქვს აზრი,
გადართვის მეტი ტვირთის გადატანა, თუ ის კიდევ მოდით თქვენ, რომ, იმის გამო, რომ მცურავი წერტილი
სიზუსტით, თქვენ ნამდვილად არ მინდა, რომ მაინც.
ასე რომ, საკმაოდ ბევრი, უბრალოდ ints და სიმბოლო და პერსონალის მსგავსი.
>> DAN: ჰო, როდესაც თქვენ გაქვთ გამოკვეთილ ღირებულებები, რომ თქვენ იცით, ვფიქრობ, შეიძლება იყოს
რომ შეცვლა ფაქტობრივად სასარგებლო.
კარგი?
OK.
>> Scope არის სპექტრი, დეკლარირებული ცვლადი ვრცელდება.
ასე რომ, ამ პატარა ბლოკი კოდი მაქვს, ეს იქნება სრული შეცდომები.
და მიზეზი ის არის, რომ მე განაცხადა int i ფარგლებში ამ for loop.
და მაშინ ვცდილობ მითითებას, რომ i გარეთ რომ მარყუჟი ფარგლებს.
>> ასე რომ, ძირითადად, შეგიძლიათ ვიფიქროთ ფარგლებში როგორც ყველაფერი, რაც თქვენ გამოაცხადოს
შიგნით კომპლექტი curly braces მხოლოდ არსებობს ფარგლებში იმ Curly braces.
და თუ თქვენ ცდილობენ და გამოიყენოს ცვალებად გარეთ იმ Curly braces, თქვენ
მიიღოს შეცდომა შემდგენელი.
ჰო?
>> აუდიტორია: ასე რომ, ეს ერთი არ მუშაობს?
>> DAN: ეს არ მუშაობს, დიახ.
სიმები.
სიმებიანი char *.
ისინი ზუსტად იგივე.
ისინი მხოლოდ მითითებას გმირები.
და ნებისმიერი strings, რომ თქვენ უნდა უნდა დასრულდეს ერთად წარმატებული ნულოვანი, რაც არის
c კონვენციას.
>> მას უწოდებენ null terminator.
და NULL--
კაპიტალის N კაპიტალური, U, დედაქალაქის L, დედაქალაქში L--
არ არის იგივე, რაც Null terminator.
ეს არის მაჩვენებელი.
ეს არის გმირი.
ისინი ძალიან მკაფიო.
მახსოვს.
ეს იქნება ინტელექტუალური, ალბათ.
მე არ მინახავს ვიქტორინა.
ჰო?
>> აუდიტორია: ასე რომ NULL არის, ვთქვათ, მაჩვენებელი?
>> DAN: დიახ.
>> აუდიტორია: რა [INAUDIBLE]?
>> DAN: თუ, ვთქვათ, malloc ეწოდება, როდესაც თქვენ არ არის საკმარისი მეხსიერება მისაღებად
რაც ზომა თქვენ ითხოვს, malloc დაბრუნდება NULL.
ეს, ძირითადად, როდესაც ფუნქცია უნდა დაბრუნდეს კურსორი, თქვენ
უნდა შეამოწმოთ წინააღმდეგ NULL რადგან NULL არის საკმაოდ good--
ეს, ერთგვარი, ნაგვის ღირებულება.
ის ნულოვანი რამდენადაც მითითებას წასვლა.
>> ყოველთვის, როცა რეკავთ ფუნქცია, რომ ბრუნდება მაჩვენებელი.
თქვენ აპირებს გვინდა შევამოწმოთ იყოს დარწმუნებული ვარ, რომ ეს მაჩვენებელი არ არის NULL
იმიტომ, რომ NULL არის ძალიან საერთო.
ეს ერთგვარი ნაგვის დაბრუნებას.
ასე რომ, თუ რამე არ წასვლა უფლება, დააბრუნებს NULL ნაცვლად.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ, და რომ ეს.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: Spell, როგორც ეს.
ის NULL terminator.
ის ამას N-U-L-L თუ თქვენ მართლწერის მას.
>> აუდიტორია: მე უბრალოდ წავიდა უკან და ტესტირება.
და თუ თქვენ ცდილობენ დააყენა მცურავი წერტილი ღირებულება შევიდა შეცვლა, რომ თქვენ დაწეროთ თქვენ
განაცხადა, რომ განცხადებაში მოითხოვს გამოხატვის რიცხვი ტიპის.
>> DAN: წავიდეთ.
მაგრამ ჰო, რა იყო კითხვა ისევ?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: So კაპიტალის N კაპიტალური, U, დედაქალაქის L, დედაქალაქში L ფაქტობრივი c რამ.
ეს არის NULL მაჩვენებელი და იქნება მხოლოდ განიხილება, როგორც ასეთი.
თქვენ არ ოდესმე ცდილობენ და სიტყვიერად NULL ხასიათი და ვხედავ
სხვა გზა, ვიდრე ეს.
ჰო?
>> აუდიტორია: ასე რომ დაბრუნების char max ან რაღაც აღნიშნავს, რომ მას
განასახიერებს იგივე ფუნქცია როგორც [INAUDIBLE]?
>> აუდიტორია: ასე რომ თქვენ გულისხმობდა დაბრუნების char max საწყისი getchar, ან
რაც არ არის?
>> აუდიტორია: Yeah.
>> აუდიტორია: ჰო, ისე, ზოგადად, ტერმინი ყველა იმ რამ
არის Sentinel ღირებულებების.
ასე რომ, როგორც დაბრუნების int max საწყისი GetInt და char max საწყისი getchar, ეს
უნდა იყოს, ყველა უფლება, თუ ეს ყველაფერი უბრუნდება us,
რაღაც წავიდა არასწორი.
>> ამისთვის პოინტერები, ჩვენ უბრალოდ არ უნდა ჰქონდეს ამ Sentinel ღირებულება, რომ ყველას
შეათანხმებს.
და ეს არის ის, რაც თქვენ დაბრუნდება როდესაც რამ წავიდეთ არასწორი.
ასე რომ char max არის ის, რაც ჩვენ გამოყენებით , წარმოადგენს რაღაც
ისევე როგორც NULL ან getchar.
>> აუდიტორია: ასე რომ, თუ თქვენ ტესტირების getchar, შეიძლება უბრალოდ დააყენა NULL?
რომ რომ განსხვავება?
>> DAN თქვენ ვერ მხოლოდ შესამოწმებლად NULL.
ნეტავ უნდა შეამოწმოს char max რადგან დაბრუნების ღირებულება ფუნქცია
ხასიათი არ მომცეთ.
ჰო?
>> აუდიტორია: ეს კითხვა სთხოვს სიმებიანი სიგრძე.
იმას, რომ მოიცავს NULL ხასიათი?
>> DAN: არა
და ეს რეალურად როგორ სიმებიანი სიგრძე იცის, რომ შეწყვიტოს, რადგან ეს გადის
თქვენი მასივი გმირები სანამ ის ხედავს NULL ხასიათი.
და შემდეგ ეს იგივეა, ყველა მარჯვენა, მე გაკეთდეს.
>> აუდიტორია: [INAUDIBLE] ხუთ?
>> DAN: Hello იქნება ხუთ.
Yep.
ასე რომ კოლექტორები არის უწყვეტი ბლოკები მეხსიერება.
ისინი მყისიერი ხელმისაწვდომობის და განაცხადა, მომხმარებლის სახელი მასივი და შემდეგ, curly
braces, რასაც ინდექსი გსურთ წავიდეთ რომ, ისინი ინდექსირებული ნულიდან მეშვეობით
სიგრძეზე მასივი მინუს 1.
>> და ისინი განაცხადა ტიპის რამ, რომ თქვენ შენახვის
მასივი, სახელი მასივი, და შემდეგ მიუხედავად ზომა არის, რომ მასივი.
ასე რომ, ეს არის char array სიგრძე ექვსი, რომელსაც აქვს ამ ღირებულებებს.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: ჰო.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: თუ თქვენ გაქვთ, რა ხდება მასივი უკვე გააკეთა.
ასე რომ თქვენ ვერ აკონკრეტებს, ეს ნაცვლად, როგორც, ვთქვათ, char, რასაც სახელი თქვენი
array არის, ცარიელი ფრჩხილები ტოლია curly გაუწიოს H მძიმე E მძიმე L მძიმე L მძიმით
O მძიმე NULL ხასიათი და curly გაუწიოს.
რომ ასევე მუშაობა როგორც დეკლარაცია.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: მაშინ თქვენ უნდა ზომა უკვე გააკეთა.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ.
ყველა კეთილი.
ბრძანების ხაზი არგუმენტები არის გზა მიღების შეიტანენ შესახებ,
არგუმენტები ძირითადი.
მთავარი იღებს ორ არგუმენტს.
რიგი არგუმენტები, რაც მიმდინარეობს გადაიარეს ბრძანების და
string ვექტორი ან სიმებიანი მასივი ყველა არგუმენტები.
>> ასე რომ, თუ, ვთქვათ, მოუწოდა ფუნქცია, როგორიცაა dot out 1 ფართი, 2 ფართი, სამი,
argc იქნება 4.
და argv 0 იქნებოდა dot out.
Argv1 იქნება 1.
argv2 იქნება 2 argv3 იქნება 3, ამ კონკრეტულ შემთხვევაში.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: ბოლო ელემენტს მასივი იმის გამო, რომ მასივი სიგრძე argc plus
ერთი argb, ბოლო ელემენტს null მაჩვენებელი.
ეს არის argc პლუს 1.
ასე რომ იმ შემთხვევაში, რომ მე განაცხადა, რომ ეს იქნება argv 0 dot out.
argv 1 არის 1 argv2 არის 2 argv 3 3.
argv 4, რომელიც არის ერთ ერთი დიდი ვიდრე argc იქნება NULL.
>> და ეს არის NULL მაჩვენებელი.
დიახ.
და ეს იმიტომ, რომ სიმებიანი char ვარსკვლავი მაჩვენებელმა.
ასე რომ, ეს უნდა იყოს იგივე ტიპის.
ჰო?
>> აუდიტორია: ორი კითხვა.
ასე რომ, ერთი რა სხვაობაა ამ და GetString, გარდა ერთი ტიპის
ამ მომხმარებლის სისტემაში?
და ორი, იგი ინახება თქვენი ბოლო მეხსიერება?
ამიტომ მინდა, GetString რომ იქნება [INAUDIBLE]?
>> DAN: სად ინახება?
მე არ ვიცი, სადაც იგი ინახება.
>> აუდიტორია: ასე რომ, ფაქტობრივად, იცით, რამდენი ფუნქცია რეკავთ ეს არგუმენტები
ინახება დასტის?
ისე argc და argv არგუმენტები to main და ისინი დასტის, ან მართლაც
მაღლა რას ფიქრობთ თქვენ, როგორც დაწყების Stack.
რა იყო მეორე ნაწილი კითხვა?
>> აუდიტორია: ასე რომ რა [INAUDIBLE]?
>> DAN: ჰო, უბრალოდ, სხვაგვარად, მიღების შეტანის შესახებ.
ამ ერთი ოდნავ უფრო ეფექტური და ეს handier სკრიპტები, რადგან თქვენ
შეგიძლიათ უბრალოდ გაივლის არგუმენტებით მთავარი ფუნქცია, ვიდრე მქონე დაველოდოთ
მომხმარებლებს, თუ არ გაქვთ რაიმე მომხმარებლებს.
>> აუდიტორია: და ჰო, კიდევ strings იქნება [INAUDIBLE].
ის შესანახად პერსონალის გჭირდებათ.
>> DAN: ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ, argv 0 ყოველთვის მოიცავს dot slash ფუნქცია ზარი.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ, თითოეულ არგუმენტებია დასრულდა NULL ხასიათი, რადგან ისინი
სიმები.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ, argv argc არის NULL მაჩვენებელი.
>> აუდიტორია: [INAUDIBLE]?
>> DAN: Oh yeah.
ჰო, ბოდიში.
>> აუდიტორია: ასე რომ [INAUDIBLE]?
>> DAN: ასე რომ, კითხვა, თუ თქვენ გქონდათ ბრძანების ხაზი dot slash dot out 1, 2,
რომ რაოდენობის command line არგუმენტები იყოს ორი ან უნდა იყოს, სამი?
>> აუდიტორია: ვფიქრობ, რომ ეს არ ნამდვილად აქვს.
მე, როგორც წესი, უი, თქვენ არ უნდა გაიაროს ნებისმიერი ბრძანების ხაზი არგუმენტები, როდესაც
ცხადია, რომ თქვენ მოუწოდა ფუნქცია.
ასე რომ, ხშირად ხმამაღლა გამორიცხავს ფუნქცია იმ ბრძანების
არგუმენტები მიუხედავად იმისა, რომ შედის argv.
>> DAN: მაგრამ თუ ეს იყო Test--
yeah-- და ასევე თუ ამბობენ, რომ რაღაც როგორიცაა argc უდრის 3
თქვენ უსაფრთხო იდგა.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: მე ვფიქრობ, თუ ნაცვლად მოუწოდებდა ამ in argc და სიმებიანი argv ფრჩხილებში
მაგრამ ინახება იმავე ტიპის და უბრალოდ მოუწოდა მათ რაღაც განსხვავებული
და ბ, რომ ეს ჯერ კიდევ მუშაობს?
და ეს მაინც იმუშავებს, თქვენ უნდა just--
ნაცვლად გამოყენებით argc-- მინდა გამოიყენოს და ბ.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: ასე რომ, კითხვა GetString არის აპირებს შესანახად მეხსიერება ბევრი
რადგან GetString არის char *.
იგი ინახავს მეხსიერება ბევრი იმიტომ, რომ ეს მოუწოდებს ახლა malloc ფარგლებში ფაქტობრივი
განხორციელების GetString.
OK, მოძრავი.
>> უსაფრთხოება.
ასე რომ, ნამდვილად უსაფრთხო, იმედი არ ერთი და მისცეს არავის მიუწვდება ნებისმიერ
თქვენი ინფორმაცია, რის გამოც ყველას აშენებს საკუთარი მანქანები,
საკუთარი ოპერაციული სისტემა, მთელი თავისი პროგრამები ნულიდან, და, ცხადია,
არ დაკავშირება ნებისმიერ სხვა მანქანები ინტერნეტით.
ისე კომპიუტერები დაუცველად.
ისინი მართლაც არიან.
ჩვენ უნდა ენდობა სხვა ადამიანები.
>> და იდეა, რომ უსაფრთხოების, რომ თქვენ ცდილობს შეზღუდოს ოდენობით
ნდობა, რომელიც თქვენ გჭირდებათ.
და ერთი საშუალება გავაკეთოთ, რომ მეშვეობით კრიპტოგრაფიის.
კრიპტოგრაფიის არის, არსებითად, ჩვენ საიდუმლოებას.
>> ზოგჯერ ჩვენ უნდა გაიაროს ჩვენი საიდუმლოების ერთად მეშვეობით, ვთქვათ, ინტერნეტით ან
სხვა რამ.
და ჩვენ არ გვინდა, რომ ადამიანები ვიცი ამ საიდუმლოებას.
ასე რომ, ჩვენ დაშიფვრა ჩვენი საიდუმლოების შევიდა გზა ჩვენ იმედი გვაქვს, რომ ვერავინ ვერ გაერკვნენ.
>> ასე რომ, ჩვენ used--
მეშვეობით რა თქმა უნდა ამ class--
რამ, როგორიცაა კეისრის და [INAUDIBLE], რომლებიც ორივე ძალიან, ძალიან
არასაიმედო გზა encrypting რამ.
ისინი ადვილად გაერკვნენ, რასაც ისინი და რა თქვენი საიდუმლოებას არიან.
რეალურ სამყაროში იყენებს ბევრად უფრო რთული კოდირების სქემები.
და ჩვენ არ მოხვდება უფრო მეტი, ვიდრე, რომ.
>> გამართვის.
GDB არის საუკეთესო.
მე ვაპირებ აღვნიშნო ეს კიდევ ერთხელ.
გამოყენება GDB ყველა დროის ყველა ამჯერად თქვენ გაქვთ პრობლემა.
ბრძანებები, რომლებიც სასარგებლო GDB არის შესვენება, რომელიც თქვენ გაივლის ან ხაზი
ნომერი, ფუნქციის სახელი, არსებითად სადაც თქვენი კოდი გსურთ შეჩერება,
და შეძლებს აღებას.
>> Print იღებს ცვლადი და ბეჭდავს რაც არ უნდა იყოს ცვლადი, რომ
წერტილი თქვენს აღსრულება.
შემდეგი მოძრაობს თქვენს აღსრულება ერთად ერთი ნაბიჯია.
და ნაბიჯ ნაბიჯები შიგნით ფუნქცია თქვენს აღსრულება.
>> სხვა რამ პერსპექტივაში, რომელიც, როგორ თქვენ რეალურად აწარმოებს თქვენი კოდი.
გაგრძელება იღებს ყველა საჭირო ნაბიჯი, მიიღოს შემდეგი შესვენების წერტილი.
და ბევრი, ბევრი სხვა.
შეხედეთ მათ.
ისინი დიდი.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ, რაც debugger.
ასე რომ, debugger არის პროგრამა, რომელიც გაძლევთ გამართვის თქვენი პროგრამა.
ეს არ არის პროგრამა, რომელიც დაადგენს შეცდომები თქვენ, მიუხედავად იმისა, რომ ძალიან კარგი იქნება.
>> და ბოლოს ჩემთვის არის ძებნა.
ასე რომ სახის ძიების, რომ ჩვენ ვისაუბრეთ დაახლოებით ამ კლასში ხაზოვანი ძებნა,
რაც არის, რომ თქვენ გაეცნონ თითოეული ელემენტის ძებნის სივრცეში, ერთი
ელემენტს დროს, სანამ თქვენთვის რა ვეძებთ და სანამ მიაღწევს
ბოლოს თქვენი ძებნა სივრცეში, სადაც აღვნიშნო ამბობენ, რომ თქვენ ვერ იპოვა
ელემენტს, რომ თქვენ ეძებს.
და ეს მაშინ, საუკეთესო მუდმივ დრო, რაც 0 1 და უარეს ხაზოვანი
დრო, რომელიც 0 ო.
>> ორობითი ძებნა, რაც საჭიროებს ბინძური ელემენტებს.
თქვენ წასვლა შუა თქვენი ელემენტები, თუ ელემენტი თქვენ ეძებთ
არის უფრო დიდი ან მცირე, ვიდრე ელემენტი რომ თქვენ ცენტრიდან.
ეს ის დიდი, თქვენ ამბობთ, რომ ბოლოში თქვენი ძებნა სივრცე თქვენი
ადგილსამყოფელი, შუა, და გადატვირთვის პროცესი.
თუ ეს არის პატარა, გადავხედავთ ამბობენ რომ the-- yeah, რა ხდება?
>> აუდიტორია: [INAUDIBLE]?
>> DAN: დიახ.
ნებისმიერ სახის რომ ასწავლიან კლასი არის სამართლიანი თამაში ტესტი.
>> [სიცილი]
>> DAN: ის ფაქტი, რომ თქვენ არ ჰქონდა ამის პრობლემა კომპლექტი,, სამართლიანი
თამაშის ტესტი.
>> აუდიტორია: ჩვენ მივდივართ ის, თუ როგორ უნდა
>> DAN: ეს იქნება წავიდა.
>> დინამიკები 2: ფაქტობრივი კოდი [INAUDIBLE] არის study.cs50.net.
ასე რომ, თუ გადავხედავთ პრაქტიკას პრობლემა იმ შერწყმა დალაგების გვერდი
study.cs50.net, არის კოდი განხორციელების შერწყმა ჯიშია.
ასე რომ თქვენ არ უნდა განახორციელოს ის თავს დღეს.
მაგრამ დარწმუნდით გესმით, რომ საკმაოდ მეტი, ვიდრე უბრალოდ იმახსოვრებდა მას.
>> აუდიტორია: [INAUDIBLE]?
>> დინამიკები 2: The შერწყმა დალაგების გვერდი, study.cs50.net, არსებობს პრაქტიკა
პრობლემა, რომ, თუ თქვენ დააჭირეთ მეშვეობით პრობლემა, ბოლომდე არ არის
გამოსავალი, რომელიც შერწყმა სახის განხორციელება.
მაგრამ დარწმუნდით, რომ გესმით ვიდრე უბრალოდ იმახსოვრებდა მას
ან კოპირება მას.
>> აუდიტორია: და კარგად მოქმედებს პრობლემა გამოცდა იქნება
რაღაც აქ არის სია.
რას ნიშნავს ეს სია ასე შემდეგ ერთი ნაბიჯია არჩევანი დალაგების ან
Insertion დალაგების ან რასაც.
ერთი სრული iteration სიაში.
ასე რომ, მაშინაც კი, თუ თქვენ არ დასრულდება up სჭირდება კოდი ის, თქვენ უნდა გვესმოდეს, რომ ეს
საკმარისი ვიცი, როგორ აპირებს რომ შეცვლის ამ მასივი.
>> DAN: ეს არის ის ჩემთვის.
>> [ტაში]
>> LUCAS: Hey ყველას.
ჩემი სახელი არის ლუკასი.
მე ვაპირებ ვისაუბრო უკან, ყველა სახის, რომ ჩვენ ვისწავლეთ, და
ცოტა ყველა მითითებას.
OK?
ასე რომ, პირველ რიგში, უკან.
რას ნიშნავს ეს ვთქვა, რომ ფუნქცია რეკურსიული?
>> აუდიტორია: მოუწოდებს თავად.
>> LUCAS: OK, მოუწოდებს თავად, yeah.
ისე, როგორც ეს სურათზე, მაგალითად.
ეს იგივეა, რომ სურათზე შიგნით სურათის და ასე შემდეგ.
ასე მაგალითად, შეგიძლიათ აქვს დენ რომ ვსაუბრობთ ორობითი ძებნა.
ერთი გზა, რომელიც ბინარული ძებნის რეკურსიული არის ის ფაქტი, რომ თქვენ
ცდილობს იპოვოს ნომერი.
ასე, რომ თქვენ წასვლა შუა.
და შემდეგ თქვენ შეამოწმეთ თუ ნომრები არ მარცხენა და მარჯვენა.
>> და შემდეგ თუ თქვენ გაირკვეს, ნომერი იქნება მარცხენა, ის იგივე
რამ, როგორც აკეთებს ძებნის ერთხელ, მაგრამ მხოლოდ მარცხენა სიაში.
ასე რომ, როგორ ჟღერს როგორც ეს რეკურსიული.
ასე რომ, ამიტომ ბიჭებს რეკურსიული გადაწყვეტილება შერწყმა ჯიშია.
>> OK, ასე რომ აქ არის მაგალითი.
ასე ვთქვათ, მინდა აირჩიონ ყველა ციფრები 1 დან n.
მე გააცნობიეროს, რომ თანხა n რიცხვი n plus N მინუს 1 მდე 1.
მაგრამ შემდეგ, თუ გავითვალისწინებთ N მინუს 1 plus n-2 plus 1, რომელიც იგივეა,
რამ, როგორც შემაჯამებელი ნომრები მდე N მინუს 1.
ასე რომ, შემიძლია ვთქვა, რომ ეს თანხა თანაბრად თანხა უდრის n პლუს თანხა n მინუს 1.
ამჯამად რომ აზრი?
>> და ასევე, მინდა რაღაც ე.წ. ბაზის საქმე, რომელიც არის ის, რომ
თანხა ნომრები მდე ნულოვანი იქნება ნულოვანი.
ამიტომ, როგორც კი მივიღებ ნომერი ნულოვანი, მე შეწყვიტოს დათვლის.
ამჯამად რომ აზრი?
>> ასე რომ, აქ არის მაგალითი იმისა, თუ როგორ შეიძლება განახორციელოს, რომ.
ასე რომ, მე ამ ფუნქციის ზოგიერთი.
რომელიც იღებს მთელ რიცხვს n.
ასე რომ აქ მე შევამოწმოთ, თუ N არის ნაკლები ან ნულის ტოლია.
ასე რომ, თუ ის ნაკლებად ან ნულის ტოლია, I დაბრუნების ნულოვანი, რომელიც არის ჩვენი ბაზის შემთხვევაში.
წინააღმდეგ შემთხვევაში, მე უბრალოდ დააბრუნოს n plus თანხა ნომრები
ერთი n მინუს ერთი.
აზრი?
OK.
>> ასე რომ, აქ არის ის, რაც გამოიყურება.
თქვენ გაქვთ თანხა 2 ტოლობის 2 plus თანხა 1.
და ზოგიერთი 1 1 Plus თანხა 0, რომელიც არის 0.
აზრი?
ასე რომ, თუ ჩვენ შევხედავთ იმ დასტის თქვენი პროგრამა, ეს არის, თუ რას ჰგავს.
>> პირველ რიგში, ჩვენ ძირითად ფუნქციას.
და შემდეგ, მთავარი ფუნქცია ე.წ. თანხა 2.
და შემდეგ ეს თანხა 2 თქმას, oh, თანხა 2 უდრის 2 პლუს თანხა ერთი.
ასე რომ დავამატო თანხა 1 Stack.
და თანხა 1 ვაპირებ მოვუწოდო თანხა 0, რომელიც ასევე იქნება დამატებული
Stack.
და მაშინ თითოეული ამ პირობა, რომ თავზე კიდევ ერთი უნდა დაბრუნდეს
ადრე სხვა პირობა შეიძლება შენარჩუნებას აპირებს.
>> ასე მაგალითად, აქ, თანხა 0, პირველი, აპირებს დაბრუნებას 0.
და შემდეგ აირჩიოს თანხა 1.
მაშინ თანხა 1 აპირებს დაბრუნდეს 1 თანხა 2.
და ბოლოს, თანხა 2 აპირებს დაბრუნების 3 ძირითადი.
ამჯამად რომ აზრი?
>> ეს მართლაც მნიშვნელოვანია, გვესმოდეს, თუ როგორ დასტის მუშაობს და ცდილობენ
ვნახოთ, თუ ეს აზრი.
OK, ასე დახარისხება.
რატომ არის დახარისხება მნიშვნელოვანია, პირველ რიგში?
რატომ უნდა იზრუნოს?
ვინმეს?
მომეცი მაგალითი?
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: Yeah, OK.
ასე რომ თქვენ შეგიძლიათ მოძებნოთ უფრო ეფექტურად.
ეს არის კარგი გზა.
ასე, მაგალითად, ჩვენ გვაქვს ძალიან ბევრი რამ, ფაქტობრივად, ჩვენი ცხოვრება, რომ
დახარისხებული.
მაგალითად, ლექსიკონები.
>> ეს ძალიან მნიშვნელოვანია, რომ ყველა სიტყვა რაღაც იმისათვის, რომ ჩვენ
შეუძლიათ ადვილად.
ასე რომ, რასაც ამბობდა.
თქვენ შეგიძლიათ მოძებნოთ უფრო ეფექტურად.
ვფიქრობ, რა მძიმე იქნებოდა, რომ აქვს ლექსიკონი, რომელშიც სიტყვები
შემთხვევითი მიზნით.
თქვენ უნდა შევხედოთ, საკმაოდ ბევრი, თითოეული სიტყვა, სანამ თქვენთვის
სიტყვა, რომ თქვენ ეძებთ.
>> თუ თქვენ იყენებთ Facebook ასევე, როცა თქვენ ეძებთ თქვენი მეგობრები, თქვენ
ვაპირებთ, რომ Facebook განათავსოთ თქვენი დაახლოება მეგობარს თავზე პირობა
რომ თქვენ არ გაიგო, რომ ბევრი რამ.
თუ თქვენ წავიდეთ ყველა გზა ბოლოში მეგობრების სია, თქვენ აპირებს,
ხალხს, რომ თქვენ ალბათ არც კი გახსოვდეთ, რომ თქვენ მეგობრებს.
და ეს იმიტომ, რომ Facebook სახის თქვენს მეგობრებს საფუძველზე, თუ როგორ
მჭიდრო თქვენ მათ.
>> ასე აწყობს მონაცემები.
ასევე Pokemon.
ასე რომ, ხედავთ, რომ ყველა Pokemons აქვს ნომრები.
და ასეთი მარტივი გზა წვდომის მონაცემები.
>> აუდიტორია: წვდომის Pokemon.
>> LUCAS: ჰო.
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: Yep.
OK, ასე რომ შერჩევის ჯიშია.
შერჩევის დალაგების აპირებს შერჩევა პატარა ქალაქის დაუხარისხებელი ღირებულება სიაში ყოველ
დრო თითოეულ iteration.
ეს არის სახის, როგორიცაა სახის, რომ თქვენ ამის გაკეთება თქვენი უფროსი, როდესაც თქვენ ცდილობთ
დასალაგებლად სიაში მხრივ.
>> ძირითადად, თქვენ არ არის გადავხედავთ პატარა ნომერი.
თქვენ ამას დახარისხებული სია.
და მაშინ გადახედეთ შემდეგი ყველაზე პატარა ნომერი.
და შემდეგ თქვენ აკეთეთ რომ და ასე შემდეგ.
>> ასე შერჩევა დალაგების ძირითადად თქვენ შეარჩიეთ ყველა დროის ყველაზე პატარა
დაუხარისხებელი ღირებულება.
დააყენა დასასრულს დახარისხებული ნაწილი სიაში.
და აკეთეთ, რომ.
ასე რომ, მოდით სწრაფად ნახოთ თუ რა ამ ჰგავს.
ასე რომ აქ დალაგებულია და დაუხარისხებელი სიაში.
>> ასე რომ, დახარისხებული სია, ის თავდაპირველად ცარიელი.
და შემდეგ მე ვაპირებ აირჩიოთ ყველაზე პატარა ნომერი აქ, 2.
ასე რომ მე რიცხვი 2 და მე დააყენა წინა სიაში.
და მერე ვეძებოთ მომავალი პატარა ელემენტს, რომელიც 3.
ასე რომ, თქვა ბოლოს დახარისხებული სია.
და მერე აკეთეთ, რომ.
მე 4 და დააყენოს ის ბოლოს.
ს 5 და დააყენოს ის ბოლოს.
>> და შევხედოთ, თუ როგორ ყველა ამ დროს, რომ მე ვამბობ, რომ ეს დასასრულს,
ძირითადად, შევცვალე ორი ღირებულებებს.
OK?
და შემდეგ ბოლო ერთი, თქვენ უბრალოდ კიდევ ერთი ელემენტს.
ასე რომ, ეს უკვე დახარისხებული.
>> OK, ასე რომ Insertion ჯიშია.
Insertion დალაგების თქვენ ვაპირებთ აქვს ასევე რომ რამ, რაც დახარისხებული და
არასორტირებული სიაში.
მხოლოდ ის არის, რომ ყოველ ჯერზე, რომ თქვენ დასძინა ელემენტს დახარისხებული
სია, თქვენ უბრალოდ აირჩიოთ ელემენტი, რომელიც არის თვალწინ არასორტირებული სიაში.
და მაშინ თქვენ აპირებს იპოვოს ის, რაც პოზიცია უნდა იყოს დახარისხებული
ნაწილი სიაში.
>> ვნახოთ, თუ რა არის ეს ასე ეს ხდის უფრო გრძნობა.
ასე რომ თავდაპირველად, მაგალითად, ვცდილობ ჩადეთ ნომერი სამი
დახარისხებული ნაწილი სიაში.
ასე რომ სია არ აქვს არაფერს.
ასე რომ, მე მხოლოდ დააყენა ნომერი 3.
>> ახლა, მე მინდა რომ დაამატოთ ნომერი 5 დახარისხებული ნაწილი სიაში.
ასე რომ შევხედოთ ნომერი 5.
ვამჩნევ, რომ უფრო მეტი, ვიდრე 3.
მე ვიცი, რომ ეს უნდა იყოს შემდეგ 3.
ასე რომ მე ზუსტად 3 და 5.
>> მაშინ მინდა ჩადეთ ნომერი 2.
ვამჩნევ, რომ ნომერი 2, ფაქტობრივად, გაგრძელდება შემდეგ ორივე 3 და 5.
ასე რომ რეალურად უნდა დააყენოს ყველა გზა დასაწყისში სიაში.
ამიტომ უნდა, სახის, გადაეტანა ყველა ელემენტების დახარისხებული სია ასე, რომ შეიძლება
ოთახში ნომერი 2.
>> მაშინ მე ვერ ვხედავ ნომერი 6.
მე ვხედავ, რომ ეს უნდა იყოს შემდეგ 5.
ასე რომ, მე ამას იქ.
და ბოლოს, მე შევხედოთ ნომერი 4.
და მე ეს უნდა იყოს 3 და 5.
და მერე ვთქვათ არსებობს და ცვლა ყველა სხვა ელემენტს.
აზრი?
>> Bubble დალაგება.
ამიტომ ბუშტი დალაგების ძირითადად ის, რაც თქვენ აპირებს გააკეთოს, რომ ჩვენ მას bubble
სახის რადგან თქვენ გაიაროს list-- ეს რეალურად, თუ მე მხოლოდ აჩვენებს
გნებავთ ამას
და თქვენ ვაპირებთ შედარების ნომერზე.
და თქვენ აპირებს სვოპ მათი პოზიციებზე, თუ ისინი არ
სწორი მიზნით.
>> ასე რომ, ძირითადად, რა ხდება მოხდება ის, აქ, მაგალითად,
თქვენ გაქვთ 8 და 6.
თქვენ იცით, რომ დახარისხებული მიზნით იქნება რეალურად იყოს 6 და 5, არა?
ასე რომ თქვენ აპირებს სვოპ ბრძანებებს.
მაშინ მე ვერ ვხედავ 8 და 4 აქ.
და მე იგივე.
სვოპ ერთხელ.
და ბოლოს, 2 და 8.
მე ასევე სვოპ მათ.
>> ეს მოუწოდა Bubble Sort რადგან მას შემდეგ, თითოეული ამ გამეორების, ფაქტობრივად,
უდიდესი ნომერი სიაში იღებს გზა დასასრულს სიაში.
ამჯამად რომ აზრი?
რადგან იგი ინახავს შევცვალე ეს და მოძრავი უფლება.
>> OK, ასე რომ ეს არის მეორე iteration.
ეს იქნება იგივე.
მე გავაკეთებ ერთი swap და შემდეგ ბოლო ერთი.
მე რომ არ არსებობს სვოპების და სია დალაგებულია.
ასე რომ, Bubble დალაგების, ჩვენ ძირითადად შენარჩუნება გადის სიაში და შევცვალე
რამ, სანამ, მე რომ მე არ გავაკეთებ ნებისმიერი სვოპების აკეთებს, რომ გამეორების, რომელიც
იმას ნიშნავს, რომ სიაში უკვე დახარისხებული.
აზრი?
>> მოდით ვისაუბროთ ცოტა იმაზე ქრონომეტრაჟი.
ასე რომ ბიჭები გახსოვთ დიდი O, Omega, და Theta?
ჰო?
მაშ, რა არის დიდი O, პირველ რიგში?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: ჰო, ეს ე.წ. უარეს შემთხვევაში runtime, რომელიც მხოლოდ იმას ნიშნავს, რომ ის
რამდენად თქვენ ველით პროგრამა მიიღოს აწარმოებს.
Like თვალსაზრისით of--
ამ შემთხვევაში n.
რაოდენობის ელემენტების სია ყველაზე ცუდ შემთხვევაში.
მსგავსად, ყველაზე უარესი შემთხვევაში.
>> ასე Bubble Sort, მაგალითად, ჩვენ გვაქვს დიდი O of n კვადრატში.
რატომ გვაქვს, რომ?
რატომ არის Bubble Sort დიდი O n მოედანზე?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: ჰო, უარეს შემთხვევაში იქნება რომ მე უნდა გავაკეთოთ n iterations.
ასე რომ, თითოეული გამეორების აპირებს მოუტანს უდიდესი ელემენტი ბოლომდე
სიაში.
ასე რომ, ყველაზე ცუდი ის არის, რომ მე არ მაქვს გავაკეთოთ, რომ, რაც n-ჯერ.
და თითოეული იმ დროს, მე უნდა ამის გაკეთება n გაცვლებს იმიტომ, რომ მე უნდა შეადაროთ
ყოველი ორი ელემენტები.
ამიტომაც ის n კვადრატში იმიტომ, რომ ეს n-ჯერ n.
>> მაშინ, შერჩევის დალაგების ასევე n მოედანზე იმიტომ, რომ თითოეული iteration, მე უნდა
შევხედოთ თითოეული ელემენტი სიაში.
და შემდეგ მოვძებნოთ პატარა, რაც იმას ნიშნავს, რომ მე უნდა
გაეცნონ n ელემენტებს.
და მე უნდა გავაკეთოთ, რომ n-ჯერ, რადგან მე უნდა აირჩიოთ ყველა n ელემენტებს.
>> Insertion დალაგების, ასევე n მოედანზე იმიტომ, რომ ყველაზე ცუდი სცენარი იქნება
შეიძლება, ერთი, მე უნდა ჩაწეროთ n ციფრები, უფლება?
ასე რომ, მე უკვე ვიცი, რომ მე ვაპირებ აქვს n iterations.
არამედ თითოეული იმ ნომრებს, თუ მქონდა შევხედოთ ყველა ნომრები
დახარისხებული სია და ამით მას ყველა გზა წინ, რომ იქნება n მოედანზე
რადგან ეს იქნება N ჯერ N ერთხელ.
აზრი?
რაც შეეხება omega?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: საუკეთესო შემთხვევაში სცენარი.
ასე რომ, ეს იგივეა, ბევრი ჯერ დახარისხება, საუკეთესო სცენარი
როდესაც სიაში უკვე დახარისხებული.
ასე, რომ თქვენ ნამდვილად არ აქვს არაფერი.
Bubble Sort აქვს საუკეთესო სცენარით n.
თუ ბიჭები ვიცი, რატომ?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: ჰო, თუ თქვენ შენარჩუნება სიმღერა არა მონაცემები რაციონი ჰქონდა გაცვლებს ან
არა, თუ თქვენ გაქვთ რაღაც მითითებული ნამდვილი იყო თუ iteration, თუ
სიაში უკვე დახარისხებული, ძირითადად, რა მოხდება, რომ მე ვაპირებ
ცდილობენ, რომ სვოპ ყოველი ორი მიმდებარე ელემენტები.
მე ვაპირებ, რომ არსებობს სვოპების.
და მე უბრალოდ დააბრუნოს დაუყოვნებლივ.
>> ასე რომ, ეს იმას ნიშნავს, რომ მე მქონდა გავლა სიაში ერთ დროს.
ასე რომ, ეს n იმიტომ, რომ მე მოუთმენლად at n ელემენტებს.
რატომ შერჩევის დალაგების n კვადრატში?
>> ჰო, მაშინაც კი, თუ სია დალაგებულია, for ყოველ iteration შერჩევის დალაგების, I
უნდა აირჩიოთ მინიმალური ელემენტს.
ეს კი იმას ნიშნავს, რომ მე მაქვს, რათა გამოიყურებოდეს ყველა ელემენტების დაუხარისხებელი
სიაში და მინიმალური თითოეული iteration.
ამჯამად რომ აზრი?
>> და ჩასმა ხმალი არის n რადგან საქმე, რომ მე ვცდილობ ჩასმა
ნომრები და ყველა რიცხვი, როდესაც მე ცდილობენ ჩადეთ მათ, მე ვხედავ, რომ მათ
არის სწორი პოზიცია.
მე არ მაქვს წასვლა შეამოწმეთ ყველა სხვა ნომრები არასორტირებული სიაში.
ასე რომ, ამიტომ ეს იქნება n.
აზრი?
და რა არის Theta?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: რა ბოდიში?
ამას კიდევ ერთხელ.
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: ზუსტად.
ასე რომ თქვენ ხედავთ, რომ მხოლოდ შერჩევა შენახული შერწყმა დალაგების აქვს thetas.
და ეს იმიტომ, რომ თქვენ მხოლოდ თეტა თუ ორივე დიდი O და ომეგა იგივეა.
OK.
და ბოლოს, შერწყმა დალაგების არის ჟურნალის n.
>> შემდეგ კი, როგორც Dan ამბობდა, შერწყმა დალაგების არის სახის მოსწონს იგივე გზა, რომელიც
თქვენ აკეთებთ ორობითი ძებნა.
ასე რომ თქვენ მიიღოთ სიაში.
და თქვენ აპირებს განახევრდა.
და შემდეგ მოჭრილი მათ ამ პატარა halves.
და მაშინ შერწყმა მათ.
ბიჭები გახსოვთ, არა?
OK, როგორც ამბობდა.
>> OK, პოინტერები.
რა არის მაჩვენებელი?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: მისამართზე.
OK.
მე ვიცი, რომ დავით გვიჩვენებს რამოდენიმე ვიდეო binky და რამ მიუთითებს
ერთმანეთს.
მაგრამ მე მიყვარს ფიქრი პოინტერები როგორც უბრალოდ მისამართზე.
ასე რომ, ეს ცვლადი, რომ აპირებს შესანახად მისამართზე.
>> ასე რომ, ეს მხოლოდ ამ სპეციალური ცვლადი რომ არის ოთხი ბაიტი ხანგრძლივი.
გახსოვდეთ, რომ მომცეთ რამე ყოველთვის ოთხი ბაიტი ხანგრძლივი ჩვენი 32-bit
მანქანა ისე, რომ საქმე ელექტრო.
და ეს უბრალოდ განთავსების ცვლადი შიგნით მას.
>> OK, ასე რომ ეს მეხსიერება, ძირითადად.
ასე რომ, თითოეული ბლოკი მეხსიერება რეალურად აქვს ეტიკეტების, რომელიც მისამართი
slotty მეხსიერება.
ეს კი იმას ნიშნავს, რომ შემიძლია აქვს მაჩვენებელი მიუთითებს
რომელიმე ამ მისამართებზე.
ასე რომ, მიზეზი, რის გამოც ჩვენ ვიყენებთ მითითებები არის თუ მე უნდა გვახსოვდეს მდებარეობა
რომ კონკრეტული ცვლადი მეხსიერებაში.
>> და ბიჭები გახსოვთ, რომ ერთი იმ შემთხვევა იყო, თუ მაქვს ფუნქცია
თუ მაქვს რეალურად მინდა swap for reals, მე რეალურად
უნდა გააგზავნოთ მაჩვენებელი.
არ ცვლადი.
ბიჭებს გვახსოვდეს, რომ?
განსხვავება between--
რა არის სახელი?
დარეკვის ღირებულება და მოუწოდებს მინიშნება, არა?
>> OK, yeah.
ამიტომ მოვუწოდებთ ღირებულება.
როდესაც თქვენ უბრალოდ გამოგვიგზავნეთ ცვლადი ფუნქცია თქვენ უბრალოდ გაგზავნის ღირებულება.
ასე, რომ თქვენ რეალურად გაგზავნის ასლი ცვლადი.
და თქვენი პროგრამა ვერ ზრუნვა ნაკლებად შესახებ, თუ იგივე ცვლადი რეალურად
იღებს ასლი.
>> და მოუწოდებს მინიშნება იმას ნიშნავს, რომ მე რეალურად გაგზავნის ასლი
მომცეთ, რომ ცვლადი.
ასე რომ, ეს იმას ნიშნავს, რომ მე ვაგზავნი მდებარეობა რომ ცვლადი.
ასე რომ იგრძნოს მაქვს მდებარეობა ცვლადი, როცა რეკავთ ფუნქცია
პოინტერები, მე შეუძლია რეალურად შეცვალოს მონაცემები, რომელიც იყო მთავარი.
აზრი?
>> თუმცა, მაჩვენებელი არის ასლი, მაჩვენებელი ჯერ კიდევ აქვს რეალური მისამართი
ცვლადი, რომ მინდა, რომ შეიცვალოს.
აზრი?
>> ასე შექმნა მითითებას.
გახსოვდეთ, მაჩვენებელი ყოველთვის უნდა ტიპის, რომ ეს მიუთითებს
და შემდეგ ვარსკვლავი.
და მაშინ დააყენა სახელი.
ასე რომ გვახსოვდეს, რომ როდესაც თქვენ გაქვთ რასაც star, ეს როგორც მომცეთ
რომ რაც არ უნდა ცვლადი ტიპი რომ ჰქონდა.
>> ასე რომ აქ ვარსკვლავი, მაგალითად, ეს მაჩვენებელი და რიცხვი.
და შემდეგ char ვარსკვლავი მაჩვენებელი char ვარსკვლავი და სხვ.
ჰო?
>> აუდიტორია: რა მოხდება, თუ ჩვენ გვაქვს მომცეთ n to ვარსკვლავი x.
მე ვიცი, რომ ქმნის მაჩვენებელი x.
ნიშნავს თუ არა ეს, ასევე, ვაცხადებთ x რიცხვი?
>> LUCAS: OK, ასე რომ, როდესაც თქვენ ამბობთ n star x, თქვენ არ შექმნის მომცეთ
ცვლადი x.
თქვენ შექმნით მაჩვენებელი დაასახელა x.
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: ამიტომ როდესაც ვამბობ n star x, მე ამბობს, hey, მეხსიერება, მე ვაპირებ
კიდევ ერთი ამ სამი ყუთები.
და მე ვაპირებ ვთქვა, რომ იქნება x, რომელიც
იქნება მაჩვენებელი.
და რაღაც საინტერესო პოინტერები არის, რომ ჩვენ ვამბობთ, რომ მათ აქვთ
4 bytes for 32-bit მანქანა.
და მიზეზი ის არის, რომ 4 ბაიტი არის 32 ბიტი.
>> და მანქანები, რომელიც 64 ბიტი რეალურად პოინტერები მისამართები
რომ 64 ბიტი ხანგრძლივი.
ასე რომ, ეს მხოლოდ იმას ნიშნავს, რომ ზომა მისამართები მანქანა არის სხვადასხვა.
>> ასე რომ, მითითება და dereferencing.
არსებობს ორი ოპერატორები, თქვენ ბიჭები უნდა გვახსოვდეს.
პირველი არის ampersand.
მეორე არის ვარსკვლავი.
ნუ დაბნეული, რომ ვარსკვლავი და ამ ვარსკვლავი, რადგან გვახსოვდეს, რომ,
ამ შემთხვევაში, თქვენ უნდა n star.
>> ეს იგივეა მთელი რამ ერთად.
არ არსებობს n სივრცეში ვარსკვლავი.
ეს იმას ნიშნავს, რომ ის ტიპის.
გახსოვდეთ, რომ როდესაც თქვენ გაქვთ ცვლადი ვარსკვლავი, თქვენ
ვსაუბრობთ ტიპის.
>> როდესაც თქვენ მხოლოდ ვარსკვლავი და შემდეგ ცვლადის სახელი, ეს ნიშნავს, რომ
თქვენ dereferencing მაჩვენებელი, რომელიც ნიშნავს, რომ თქვენ ეძებს
მაჩვენებელი, მოძიებაში მისამართზე ეს მიუთითებს, აპირებს, რომ მისამართი,
და ეძებს, როდესაც თქვენ უნდა იქ.
მე გეტყვით ჩემს სტუდენტებს, რომ როდესაც თქვენ ვარსკვლავი, თქვენ უნდა ვიფიქროთ, რომ ეს
აბრევიატურა შინაარსი.
>> ასე რომ, თუ თქვენ გაქვთ მომცეთ და ამის გაკეთება ვარსკვლავი მაჩვენებელი, ის
content მაჩვენებელი.
ასე, რომ თქვენ წასვლა რასაც ის მიუთითებს და შევხედოთ მუდმივი შინაარსი.
და ampersand არის იგივე რამ, როგორც მისამართი.
>> ასე რომ, თუ გვაქვს ცვლადი a--, როგორიცაა, მოდით ამბობენ, რომ მე int ტოლია 3--
თუ მინდა, რომ იპოვოთ მისამართი, რომელიც ცვლადი მეხსიერება, მე შემიძლია უბრალოდ
ampersand.
ასე რომ, ეს მისამართი.
აზრი?
>> ასე რომ, აქ არის მაგალითი.
ეს არის დაკარგული int b და int გ.
ასე int შეადგენს 3 იმას ნიშნავს, რომ მე ვაპირებ წასვლა მეხსიერება.
და მე ვაპირებ, რათა იპოვოს slot და ბოლო ნომერი 3 აქ.
>> და მაშინ int b შეადგენს 4.
მე ვაპირებ, რომ იგივე რამ.
გადადით მეხსიერების და დააყენოს ნომერი 4 ერთი ყუთები.
და int შეადგენს 5.
ს სხვა ყუთი და დააყენოს ნომერი 5.
>> რა არის ეს ხაზი აკეთებს out? n star pa ტოლია ampersand.
ასე რომ, პირველ რიგში, n star pa.
რა არის ეს აკეთებს?
>> აუდიტორია: [INAUDIBLE].
>> LUCAS: ჰო, ისე n star pa, პირველ რიგში, აცხადებს მაჩვენებელი მოუწოდა pa.
და მაშინ ის მინიჭების ღირებულება რომ მომცეთ მისამართი.
ასე ampersand.
მაშინ, თუ ამის გაკეთება ვარსკვლავი pb, რა არის ვარსკვლავი pb?
>> ოჰ, უკაცრავად.
ეს ასევე არის დაკარგული. n star pb.
ვგულისხმობ ვარსკვლავი pc.
მე ასე ვარ.
ეს იგივე.
მაგრამ ახლა მე ვარ კარგი ar შექმნის მაჩვენებელი ბ და შემდეგ მაჩვენებელი გ.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> LUCAS: დიახ.
ასე რომ, თუ მეხსიერების და თქვენ გადასვლა ყუთი რომ არის აღმნიშვნელის for pa,
თქვენ რეალურად აპირებს ვხედავ მისამართი.
OK?
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> LUCAS: Yeah, მაჩვენებელი მისამართზე.
არასოდეს დაივიწყებს.
ეს იგივეა, რომ ყველაზე მნიშვნელოვანი ნაწილი მითითებას.
არსებობს შენახვისა და მისამართი ზოგიერთი ცვლადი.
არაფერი?
ნებისმიერი სხვა კითხვები?
OK.
>> ასე პოინტერები და მასივები.
გახსოვდეთ, რომ, როდესაც მე int array 3, ძირითადად, რასაც მე ვაკეთებ არის მე, სახის
საქართველოს, განაცხადა, მაჩვენებელი.
ამიტომ მასივი სახის როგორც მომცეთ კონკრეტული ადგილი მეხსიერებაში, რომელიც მე
გამოყოფილი სამი სლოტი რიცხვებით.
ამჯამად რომ აზრი?
>> ასე რომ, როდესაც მე int array 3, რაც მე ამით, პრაქტიკულად, ვქმნით სამი
slots მეხსიერებაში.
ამიტომ მე მხოლოდ სამი slots მეხსიერებაში.
ასე რომ, თუ, მაშინ, ვარსკვლავი მასივი, ის ძირითადად, ეს ნიშნავს, რომ შინაარსი მასივი,
რაც იმას ნიშნავს, წაშალოს მაჩვენებელმა, მე იმ ადგილას, რომ ეს მიუთითებს,
მე და ნომერ პირველი.
>> და შემდეგ, თუ ამის გაკეთება ვარსკვლავი მასივი პლუს 1, რომ არის იგივე როგორც აკეთებს მასივი
ფრჩხილებში ერთი, რომელიც მხოლოდ იმას ნიშნავს, მე წასვლა იმ ადგილას, რომ ის მიუთითებს.
და შემდეგ პლუს 1 მარკა me გადაიტანოს ერთი პოზიცია.
ასე რომ მე ამ თანამდებობაზე, ფაქტობრივად, და ამით ნომერი ორი.
>> და მაშინ, საბოლოოდ, როცა ამის array plus 2, მე წასვლა, სადაც
array მიუთითებს.
და მერე გადავა მეხსიერების ბლოკები.
და მერე დააყენოს ნომერი სამი აქ.
ჰო?
>> აუდიტორია: ასე რომ ვარსკვლავი array უბრალოდ განაცხადა, რომ პირველი პუნქტი.
და თქვენ შეგიძლიათ დაამატოთ 1, მხოლოდ იმიტომ, ჩვენ მხოლოდ ნამდვილად
მითითება, რომ პირველ მისამართზე.
>> LUCAS: ჰო.
რატომ ჩვენ, მაგალითად, ამბობენ, მასივი 0 მასივი 1, და array 2?
მე ვამბობ, რატომ აკეთებთ ამას: 0, 1, 2, 3, ნაცვლად 1, 2, 3?
ერთი მიზეზი ის არის, რომ, ერთი, კომპიუტერული პროგრამისტები ურჩევნია დაიწყოს
დათვლის საწყისი 0.
ორი იმიტომ, რომ როდესაც თქვენ აკეთებთ მასივი 0, ეს არის იგივე როგორც აკეთებს მასივი
+0, რაც იმას ნიშნავს, მე წასვლა ამ თანამდებობაზე, და მე არ
გამოტოვოთ ნებისმიერი მეხსიერების ბლოკები.
ასე რომ არ გადავიდეს ნებისმიერი მეხსიერების ბლოკები.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> LUCAS: ასე რომ, ის ეკითხება, თუ რა არის შორის სხვაობა აკეთებს
ამ დროს ან აკეთებს malloc.
ერთი განსხვავებები არის, რომ int array 3 შექმნა
array Stack.
და როდესაც მე malloc, იგი ქმნის ბევრი.
ამჯამად რომ აზრი?
>> ასე რომ, როგორ ამჯამად malloc რეალურად მუშაობს?
რატომ ჩვენ კი უნდა გამოვიყენოთ malloc?
თქვენი შემდგენელი სახის ფიგურები ყველა ცვლადები, რომ თქვენ განაცხადა.
და ის ქმნის სივრცეს ყველა მათგანი Stack.
ასე რომ, ყველა თქვენი ცვლადები ვაპირებთ სადღაც უნდა იყოს Stack.
ასე რომ აქ არის გარემოს ცვლადი.
>> ასე რომ, ძირითადად, ფართი ცვლადები მეხსიერების გამოყო,
კომპილირების დროს.
ასე რომ, ეს იმას ნიშნავს, რომ თქვენი კომპიუტერი ვიცი, ყველა იმ ცვლადების
წინასწარ.
ეს არ უნდა იცოდეს, თუ რა ღირებულების თქვენ აპირებს დააყენოს მათ.
მაგრამ ეს უნდა იცოდეს, თუ როგორ რამდენად მეხსიერების თქვენ გჭირდებათ.
>> მაგრამ ახლა ვთქვათ, რომ, მაგალითად, თქვენ შექმნით მასივი ან მიღების
სიმებიანი რომ თქვენ იღებენ შესახებ.
თუ თქვენ არ იცით, თუ როგორ ხანგრძლივი string იქნება, მაგალითად.
ასე რომ თქვენ არ იცით ზუსტად რამდენი მეხსიერების ბლოკები, რომ თქვენ გამოყოფს, არა?
>> ასე რომ, ეს ნამდვილად არ აქვს აზრი თქვენ ვთქვა მა 100 სიმბოლო.
და მერე რა, თუ მომხმარებელს წერს 150?
თქვენ აპირებს უნდა ბრალია.
>> ასე რომ, ძირითადად, თქვენ შეგიძლიათ დარწმუნებული უნდა იყოს, თუ როგორ რამდენად მეხსიერების თქვენ უნდა გამოყოს
როდესაც თქვენ შედგენის პროგრამა.
თქვენ იცით, რომ პერსპექტივაში დრო.
ასე რომ, ამიტომ თქვენ გაქვთ ბევრი.
ასე რომ, ბევრი აპირებს მეხსიერება რომ თქვენ გამოყოფის დროს
პროგრამის ხანგრძლივობა გაშვებული.
>> ასე რომ, ძირითადად, როდესაც თქვენ malloc, რა რას აკეთებს გამოყოფის მეხსიერება
runtime, რაც იმას ნიშნავს, რომ თქვენ გადამწყვეტი იმ მომენტში, რომ თქვენ
უნდა ჰქონდეს, რომ მეხსიერებაში.
ასე რომ, როდესაც თქვენ გამოყოფის იგი.
ამჯამად რომ აზრი?
>> ასე მახსოვს, დასტის აქვს ცვლადები რომ იქმნება კომპილირების დროს.
და მაშინ ბევრი აქვს ცვლადები რომელიც იქმნება, როგორც თქვენ გადასვლა
ერთად malloc, მაგალითად.
>> აუდიტორია: [INAUDIBLE]?
>> LUCAS: ამიტომ GetString ვაპირებ მოვუწოდო malloc.
მიადევნე თვალი საუბრობენ malloc, და მე ახსნას GetString.
ასე malloc არის იგივე, რაც მეხსიერების გამოყოფის.
ასე რომ, ეს აპირებს გამოყოს მეხსიერების შესახებ ბევრი.
და ის აპირებს დააბრუნოს მომცეთ რომ მეხსიერება დაეთმო.
>> ასე რომ, როდესაც თქვენ გააკეთოს
აქ example--
n star მაჩვენებელი.
და შემდეგ მაჩვენებელი შეადგენს malloc ზომა inch ჯერ 10.
მე შექმნის მაჩვენებელი.
და შემდეგ მე მინიჭება რომ მომცეთ ღირებულება მაჩვენებელი, რომ malloc
მაძლევს.
>> ასე რომ, მე გეკითხებით malloc შეგიძლიათ გამოყოფს ფართი 10 რიცხვებით.
ეს არის ის, რასაც ის ამბობდა.
და malloc მაძლევს უკან მაჩვენებელი იმ ადგილას.
აზრი?
OK.
I და GetString არის, ძირითადად, აკეთებს მოვუწოდებთ malloc, ასე რომ თქვენ შეგიძლიათ გამოყოფს
მეხსიერების დროს Runtime.
>> ყოველთვის გვახსოვდეს, შევამოწმოთ null რადგან malloc დაბრუნებას აპირებს null
თუ მას არ შეუძლია გამოყოს მეხსიერება.
მოდით ვთქვათ, რომ ითხოვენ სასაცილოა თანხის მეხსიერება.
თქვენს კომპიუტერში არ იქნება შეუძლია გამოყოს რომ ბევრი რამ.
>> ასე malloc მხოლოდ აპირებს დაბრუნების null.
ასე რომ, ყოველთვის გვახსოვდეს, რომ შეამოწმოთ, თუ მაჩვენებელი, რომ თქვენ მიიღო malloc არის
null ან არა იმიტომ, რომ ამ შემთხვევაში, თქვენ შეიძლება შეიძლება dereferencing მაჩვენებელი და
რამაც მხარეს ხარვეზი.
და ბოლოს, არ უნდა დაგვავიწყდეს თქვენი თავისუფალი მეხსიერება.
>> Malloc ქმნის მეხსიერება ბევრი.
და თქვენ უნდა გასათავისუფლებლად მეხსიერების ადრე პროგრამა მთავრდება.
OK, ეს ყველაფერი ჩემთვის.
უკაცრავად, Rob.
მადლობა.
>> [ტაში]
>> LUCAS: ნებისმიერი ბოლო შეკითხვები ადრე Rob მოდის?
არა?
ჰო?
>> აუდიტორია: მე ვერ ვხედავ ეს ერთი ონლაინ რეჟიმში.
არ თქვენ აიტვირთა ამაზე?
>> ლუკასი: ვფიქრობ, Dave არის ატვირთვა მალე.
>> DAVE: ეს უნდა გამოქვეყნდა.
>> LUCAS: ეს იქნება ონლაინ რეჟიმში.
>> აუდიტორია: ეს up.
>> LUCAS: up?
OK.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> LUCAS: დიახ, თქვენ უნდა გავათავისუფლოთ ყველა მეხსიერება, რომელიც დააყენა ბევრი.
>> აუდიტორია: [INAUDIBLE]?
>> LUCAS: დიახ.
ნებისმიერ დროს, რომ თქვენ გაქვთ კულტურის malloc, თქვენ უნდა ჰქონდეს კულტურის free
მას შემდეგ, რაც თქვენ შეწყვიტოს გამოყენებით, რომ ცვლადი.
ასე malloc და თავისუფალი არიან ყოველთვის ერთად.
მათი საუკეთესო მეგობარი.
Yeah.
Rob?
>> ROB: მე წავიდეთ სწრაფად.
და ასევე ვიდეო გატანილი იქნება.
მე მაქვს მიკროფონი on.
>> OK, ასე კვირაში ხუთი პერსონალი.
პირველი, რაც უნდა დასტის.
ასე რომ გვახსოვდეს, რომ არსებობს მხოლოდ ერთი დასტის კადრი აქტიური ფუნქცია ზარი.
ჩვენ დავინახავთ, რომ მეორე.
და გვახსოვდეს, რა რეალურად მიდის თითოეული დასტის ჩარჩო ვაპირებთ იყოს
ადგილობრივი ცვლადები ჩვენი ფუნქციები, არგუმენტები, რომლებიც შევიდა ჩვენი
ფუნქციები, ისევე, როგორც რამდენიმე სხვა რამ, რაც ნამდვილად არ
უნდა ფიქრი.
>> ასე რომ, აქ არის მაგალითი პროგრამა, სადაც, ცნობა, მთავარი printfing დაბრუნება
ღირებულება foo 4.
foo მხოლოდ დაბრუნებას აპირებს ღირებულება ბარი 4 მძიმით 6.
და ბარი შექმნას აპირებს ზოგიერთი ადგილობრივი ცვლადი n = 4 ჯერ 6.
ხოლო შემდეგ დაბრუნდნენ n.
>> ასე რომ, მოდით შევხედოთ დასტის მასშტაბით ფაქტობრივი iteration ამ პროგრამის.
ასე რომ იქ ბოლოში ჩვენი Stack.
გახსოვდეთ, რომ დასტის იზრდება.
ასე რომ ბოლოში ჩვენი დასტის, აქვს დასტის ჩარჩო მთავარი.
როდესაც პროგრამა იწყება, მთავარი ყოველთვის იქნება ზე
ბოლოში ჩვენი Stack.
>> და რა არის შიგნით ჩვენი დასტის ჩარჩო მთავარი?
ასე რომ, მიუხედავად იმისა, რომ არ არსებობს ადგილობრივი ცვლადების მთავარი, როგორც უკვე ვთქვი,
ჩვენ argc და rgv აღების up სივრცეში შიგნით ძირითადი დასტის ჩარჩო.
ასე რომ მთავარი არის აპირებს მოვუწოდებთ ფუნქცია foo.
ეს ნიშნავს, რომ foo აპირებს საკუთარი დასტის ჩარჩო.
>> ასე რომ, ახლა ჩვენ შიგნით ფუნქცია foo.
და რა უნდა წავიდეს foo-ს დასტის ჩარჩო?
ასევე, foo აქვს არგუმენტი, n.
და n = 4 რადგან ეს არის ის, რაც მთავარი გავლით, როგორც foo არგუმენტი.
>> ასე რომ, ახლა foo ვაპირებ მოვუწოდო ბარი.
რა არის ბარი აპირებს შიგნით მისი "დასტის ჩარჩო?
მას აქვს x უდრის 4 y უდრის ექვსი.
ეს არ არის ყველა, რომ ჩვენ ვაპირებთ აქვს დასტის ჩარჩო, რადგან ბარი
ასევე აქვს ადგილობრივი ცვლადი n.
და n, ჩვენ ვაპირებთ, რომ თანაბარი 24.
>> ასე რომ, ახლა ბარი დაბრუნებას აპირებს n.
ასე ბარი ბრუნდება 24 დასტის ჩარჩო foo.
და რადგან ბარი არის დაბრუნების, რომელიც ნიშნავს, რომ ჩვენ popping დასტის ჩარჩო
ბარი off დასტის.
ასე რომ, ყველა, მეხსიერება, ბარი იყო გამოყენებით არის off დასტის.
>> ახლა, foo ასევე აპირებს დაბრუნების 24 ძირითადი.
ახლა რომ foo ბრუნდება, მეხსიერების რომ foo გამოყენებით თავის "
დასტის ჩარჩო ასევე წავიდა.
და ახლა, მთავარი აპირებს მოვუწოდებთ printf.
ამიტომ printf უბრალოდ კიდევ ერთი ფუნქცია.
როცა ჩვენ მოვუწოდებთ printf, ეს იქნება ერთი დასტის ჩარჩო printf
ფუნქცია ზარი.
>> რა ჩვენ გავლის printf?
რომ ის, რაც ხდება წასვლა მისი დასტის ჩარჩო.
სულ ცოტა, ჩვენ გავლის რომ პროცენტი i წარმატებული ო და
არგუმენტი 24.
ალბათ, ეს უფრო ის დასტის ჩარჩო თუ printf ხდება იყენებთ
ადგილობრივი ცვლადები.
ჩვენ არ ვიცით.
>> მაგრამ ყველა რომ მიდის printf ს დასტის ჩარჩო.
ის აპირებს შეასრულოს printf.
მაშინ printf კეთდება.
ის დაბრუნდება.
და ბოლოს, მთავარი კეთდება.
მთავარი დაბრუნდება.
და მაშინ ჩვენი პროგრამა კეთდება.
ჰო?
>> აუდიტორია: თქვენ ხედავს [INAUDIBLE]
არგუმენტები [INAUDIBLE]
პარამეტრები?
>> ROB: ასე რომ, არსებობს დახვეწილი განსხვავება შორის არგუმენტები და პარამეტრებს.
და მართლაც, საერთო საუბარი, ხალხი ტენდენცია უბრალოდ აურიეთ მათ ყველა დროის.
მაგრამ პარამეტრების ფორმალური ასახელებს რამ.
>> ისე argc და argv არის პარამეტრების მთავარ.
არგუმენტები, რაც თქვენ რეალურად გაივლის, როგორც იმ პარამეტრებს.
ასე რომ, როდესაც მე მოვუწოდებ foo 4, 4 არის არგუმენტი მე გადადის.
და პარამეტრი n შიგნით, foo, იღებს ღირებულების 4
მას შემდეგ, რაც 4 იყო არგუმენტი.
>> აუდიტორია: [INAUDIBLE]?
>> ROB: n არის ლოკალური ცვლადი ბარი.
n კვლავ ადგილობრივი foo, მაგრამ ეს პარამეტრი foo.
ეს არ არის ადგილობრივი ცვლადი.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: foo არის მხოლოდ მოუწოდებდა ბარი და დაბრუნების რასაც ბარი ბრუნდება.
>> აუდიტორია: [INAUDIBLE]?
>> ROB: ჰო, უბრალოდ უნდა ნახოთ მრავალი დასტის ფარგლებში.
ჰო?
>> აუდიტორია: რატომ იყო foo მოუწოდა ადრე printf?
>> ROB: რატომ იყო foo წარსდგება printf?
ამიტომ შეეძლო, ნაცვლად, ისეთი რამ გააკეთა, როგორიცაა int x უდრის foo 4
და მერე დაბეჭდილი x.
მაგრამ ამის ნაცვლად, მე კომბინირებული ფუნქცია შემოუერთდნენ printf არგუმენტი.
>> მაგრამ გაითვალისწინეთ, რომ ჩვენ არ შეგვიძლია რეალურად შეასრულოს ზარი printf სანამ ჩვენ
გაერკვნენ, რა foo 4 არის.
ამიტომ, ჩვენ ვაპირებთ, რათა შეფასდეს ეს.
და მხოლოდ ერთხელ რომ კეთდება ვაპირებთ დავბრუნდებით და შევაფასოთ ეს.
ჰო?
>> აუდიტორია: მას შემდეგ, რაც ორივე ბარი [INAUDIBLE]
ღირებულება, თუ რატომ არ აქვს [INAUDIBLE]?
>> ROB: ისინი სრულიად უნდა იყოს int.
რომ არ იყო დაჭერილი მეტი მრავალჯერადი შეჭრა.
ასე რომ უნდა იყოს int ბარი და int foo რადგან ორივე
ბრუნდებიან რიცხვებით.
ბათილად, თუ ისინი არ ვაპირებთ დაბრუნების რეალურ ღირებულებებს.
ჰო?
>> აუდიტორია: თუ ჰქონდა ხაზის ზემოთ სანაცვლოდ, [INAUDIBLE]?
>> ROB: A ხაზის ზემოთ სანაცვლოდ?
>> აუდიტორია: Yeah.
Like თუ თქვენ არ printf და [INAUDIBLE], რომ ის ბეჭდვა ორჯერ?
>> ROB: ასე რომ შიგნით foo?
თუ ჩვენ გვქონდა printf აქ?
>> აუდიტორია: Yeah.
>> ROB: ასე რომ, თუ ჩვენ გვქონდა printf უფლება აქ, ეს იქნებოდა ბეჭდვა ერთხელ.
მას შემდეგ, რაც ჩვენ მოვუწოდებთ foo ერთხელ უფლება აქ, მაშინ ჩვენ მოხვდა printf.
მაშინ ჩვენ მოვუწოდებთ ბარი.
და შემდეგ foo დაბრუნდება.
და ეს არის ის.
ჩვენ მხოლოდ ოდესმე ექმნებათ printf ერთხელ.
ჰო?
>> აუდიტორია: [INAUDIBLE]
printf მოუწოდებს foo, რადგან ჩვენ პირველი მოუწოდებდა printf და შემდეგ ჩვენ გავლის
არგუმენტები.
>> ROB: ასე რომ, თეორიულად, არ არის printf მოუწოდებს foo?
ასე არ არის.
მხოლოდ იმისათვის, რომ c აპირებს შეასრულოს ეს ყველაფერი არის, სანამ ჩვენ შეგვიძლია
მოვუწოდებთ ფუნქცია, ყველა არგუმენტები ფუნქცია უნდა
მთლიანად უნდა შეფასდეს.
ასე რომ ეს სრულიად შეაფასეს?
დიახ, ეს მხოლოდ სიმებიანი.
უბრალოდ ღირებულება.
>> მაშინ ჩვენ უნდა მთლიანად შევაფასოთ ეს.
მას შემდეგ, რაც ამ საქმეს, ახლა ყველა მისი არგუმენტები არსებობს.
და ახლა ჩვენ შეგვიძლია მოვუწოდებთ printf.
ჰო?
>> აუდიტორია: ერთი შეკითხვა.
თუ თქვენ გაქვთ ბათილად ფუნქცია, უნდა თქვენ უნდა დაბრუნება მძიმით?
>> ROB: თქვენ არ დაბრუნების მძიმით თუ თქვენ გაქვთ ბათილად ფუნქცია.
OK.
ასე რომ, ახლა ზოგიერთი ბევრი პერსონალი.
ასე რომ, ბევრი არის, თუ როგორ ვაპირებთ გაუმკლავდეთ დინამიური მეხსიერების მართვა.
და ეს პირდაპირ წინააღმდეგობაში მოდის დასტის, რომელიც ჩვენ მოვუწოდებთ ავტომატიკა
მეხსიერების მართვა.
>> ასე რომ, დასტის, თქვენ არასდროს ნამდვილად აქვს გამკლავება, თუ როგორ ადგილობრივი ცვლადები
მიმდინარეობს მივიღებთ და popped off ყველა ამ დასტის ფარგლებში და ყველა რომ პერსონალი.
თქვენ არ უნდა ფიქრი, რომ.
ეს არის ავტომატური.
ასე რომ, ბევრი არის სახელმძღვანელო.
და [INAUDIBLE]
მოდის ეს ფუნქციები malloc და თავისუფალი.
>> ასე რომ, აქ არის კიდევ ერთი პროგრამა.
ყველა ვაკეთებთ არის mallocing მთელი რიცხვი.
ჩვენ თქვენ შენახვა ეს ვარსკვლავი x.
რა თქმა უნდა, ჩვენ უნდა შეამოწმოთ ვნახოთ, თუ x არის null.
მაშინ ჩვენ ვაპირებთ მითითებული, თუ რა x მიუთითებს 50.
ბეჭდვა რა x მიუთითებს, ბეჭდვითი x, და შემდეგ უფასოდ x.
>> მაშ როგორ არის ეს რეალურად აპირებს გამოიყურებოდეს თუ დავაკვირდებით ჩვენი დასტის და ბევრი?
ასე რომ დავიწყოთ თავიდან.
ბოლოში ჩვენი დასტის, როგორც ადრე.
გახსოვდეთ, რომ შენ heap პირდაპირ ეწინააღმდეგება დასტის?
ამიტომ, ჩვენ ვაპირებთ აქვს ზედა ჩვენი ბევრი up there.
>> ისე ბოლოში ჩვენი დასტის, ჩვენ გვაქვს ჩვენი დასტის ჩარჩო მთავარი.
მას აქვს ფართი argc, argv, და ჩვენ ახლა უკვე ადგილობრივი ცვლადი x, რომელიც
არის int ვარსკვლავი.
ასე რომ, ჩვენ ვაპირებთ iterate ამ პროგრამის.
პირველი, რაც ჩვენ გვაქვს არის ზარი malloc.
>> ასე რომ, ჩვენ დარეკვით malloc.
Malloc არის ფუნქცია.
ის აპირებს დასტის ჩარჩო.
რა ჩვენ გავლის malloc?
რომ აპირებს წავიდეთ შიგნით დასტის ჩარჩო.
ჩვენ გავლის ზომის n, რომელიც 4.
ასე რომ გავიდა malloc.
>> რას malloc გავაკეთოთ?
ის grabs გარკვეული სივრცე ბევრი.
ამიტომ, ჩვენ ვაპირებთ წასვლა ბევრი.
და ჩვენ ვაპირებთ დაიბრუნოს 4 bytes from ბევრი.
მოდით მივცეთ, რომ თვითნებური მისამართზე.
0x123 უბრალოდ ვიტყვი, რომ ეს არის მისამართი, რომელიც ბევრი.
>> რა არის რეალურად შიგნით რომ რეგიონში მეხსიერების მისამართი Ox123?
ნაგავი.
ასე რომ, ჩვენ არ ინახება არაფერი ეს.
ასე რომ როგორც ვიცით, შეიძლება იყოს რამე.
თქვენ არ უნდა ვივარაუდოთ, რომ ეს ნულოვანი.
ეს, სავარაუდოდ, არ არის ნულოვანი.
>> ასე რომ, ახლა malloc ბრუნდება.
და რა ვქნათ, როდესაც malloc ბრუნდება?
ჩვენ მითითებული, თუ რა ის დააბრუნებს.
ჩვენ დავსახეთ x ტოლია, რაც იგი ბრუნდება.
რა არის ეს დაბრუნების?
ის დაბრუნების 0x123 რადგან ეს არის მისამართი ბლოკი მეხსიერება, რომ ეს
უბრალოდ გამოყოფილი ბევრი.
>> ასე იქნება 0x123 x არის იქნება მითითებული, ტოლი 0x123, რომელიც, pictorially,
ჩვენ ხშირად ხატავდა x მქონე ფაქტობრივი arrow მიუთითებს, რომ ბლოკი.
მაგრამ x მხოლოდ შენახვის, რომ მისამართზე.
ახლა ჩვენ უნდა შეამოწმოთ, თუ x არის null.
ეს არ არის null.
ჩვენ პრეტენზია, რომ malloc შეძლო.
>> ასე რომ, ახლა ვარსკვლავი x უდრის 50.
ასე ვარსკვლავი ახსოვს ეს იმას ნიშნავს, რომ მისამართი.
ასე რომ, 0x123 ჩვენ ვაპირებთ რომ მისამართი.
ასე რომ მოაქვს აქ.
რას ვაკეთებთ, რომ მისამართი?
ჩვენ შენახვის 50.
>> ასე რომ, ამის შემდეგ ხაზი, რომ ის, რაც ვაპირებთ ჰგავს.
ასე რომ, ახლა აღარ ნაგვის იქ.
ახლა ჩვენ ვიცით, რომ 50 არის, რომ კონკრეტულ მისამართზე, რადგან
ჩვენ ვაყენებთ მას, რომ.
OK?
ახლა ჩვენ ვაპირებთ ბეჭდვა ვ.
>> ასე რომ, პირველ რიგში, ჩვენ ვაპირებთ ბეჭდვა ვარსკვლავი x.
რა არის ვარსკვლავი x?
ერთხელ, ვარსკვლავი x ნიშნავს წასვლა , რაც x მიუთითებს.
ასე რომ, x შენახვის 0x123 Go რომ.
მივიღებთ 50.
ასე ბეჭდვა f რომ.
ეს ნიშნავს, რომ ის აპირებს ბეჭდვა 50.
და შემდეგ, რომ დააბრუნებს.
>> და შემდეგ ჩვენ გვაქვს მეორე printf.
ჩვენ ახლა პროცენტი გვ.
თუ თქვენ არ მინახავს ის, რომ უბრალოდ, თუ როგორ ბეჭდვა მაჩვენებელი.
ამიტომ ჩვენ გვაქვს პროცენტი i, პროცენტი f, და ყველა იმ უკვე.
ამიტომ პროცენტს p, ბეჭდვა მაჩვენებელი.
>> ასე რომ X არის მაჩვენებელი.
ასე რომ, თუ ჩვენ ვაპირებთ ბეჭდვა x თავად, ჩვენ ბეჭდვის რა არის შიგნით
x, რომელიც 0x123 ასე რომ, პირველი ბეჭდვითი ვ აპირებს ბეჭდვა 50.
მეორე ბეჭდვითი ვ აპირებს ბეჭდვა 0x123 ჰო?
>> აუდიტორია: ნუ გამოიყენებთ პროცენტი x ბეჭდვა მაჩვენებელი?
>> ROB: ასე რომ თქვენ გამოიყენოთ პროცენტი x ბეჭდვა მაჩვენებელი?
ასე, რომ თქვენ შეგიძლიათ, მაგრამ პროცენტი x სამართლიანია, ზოგადად, როგორიცაა, თუ გაქვთ
რიცხვი და გსურთ ბეჭდვა მას, როგორც თექვსმეტობითი.
ის, თუ რამდენად თქვენ, რომ.
>> ხოლო, პროცენტი d გვინდა ბეჭდვა ათობითი.
რომ ის იყო მივიღებთ პროცენტი დ. მე უბრალოდ რიცხვი.
პროცენტი p კონკრეტულად ამისთვის პოინტერები.
>> ასე რომ X არის მაჩვენებელი.
ჩვენ გვინდა გამოვიყენოთ პროცენტი გვ.
მაგრამ პროცენტი x ვერ იმუშავებს.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: Yeah.
ყოველ შემთხვევაში ამ მოვუწოდებთ, ასე რომ მე არ მოიცავს მას აქ.
მაგრამ ეს ორი არგუმენტი აუცილებლად შიგნით ამ დასტის ჩარჩო
ერთად რაიმე ადგილობრივი ცვლადები printf ხდება გამოყენებით.
ხოლო შემდეგ მომდევნო ზარი printf ახლა შიგნით printf დასტის ჩარჩო არის
პროცენტი p წარმატებული ო და რაც ღირებულება x არის, რაც 0x123.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: ეს კიდე ბეჭდვა რაღაც რომელიც ასე გამოიყურება.
>> აუდიტორია: [INAUDIBLE].
>> ROB: ასე რომ ბეჭდავს ეს მისამართი ფორმა.
ეს ჰგავს მისამართზე.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: რატომ, რა ხდება?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: რატომ არის ეს მაჩვენებელი 4 ბაიტი?
ასე რომ, არსებობს მთელი bunch 0 ს წინაშე ამ.
ასე რომ, ეს ნამდვილად 0x0000000123.
64 ბიტიანი სისტემა, არ იქნება მთელი bunch მეტი zeros.
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> ROB: ასე რომ, პირველი printf აპირებს print--
>> აუდიტორია: [INAUDIBLE].
>> ROB: დიახ, ის აპირებს ბეჭდვა რა x მიუთითებს.
ვარსკვლავი ამბობს, რა არის ეს რაც მიუთითებს.
დაიბრუნოს ის.
ასე რომ, რა არის ეს მიუთითებს?
50.
დაიბრუნოს ის.
ის, რასაც ჩვენ ვაპირებთ ბეჭდვა.
ხოლო, შემდეგ, ჩვენ უბრალოდ ბეჭდვის x თავად.
რა არის შიგნით ვ?
0x123.
OK.
>> და მაშინ, საბოლოოდ, ჩვენ გვაქვს უფასო.
რა ჩვენ გავლის გასათავისუფლებლად?
ჩვენ გავლის x.
იმ დროს მე რეალურად ნაჩვენები ის დასტის ჩარჩო.
>> ასე რომ, ჩვენ გავლის ღირებულება 0x123 გასათავისუფლებლად.
ასე რომ, ახლა free იცის, ყველა უფლება, მე უნდა წავიდეს ბევრი
და თავისუფალი, რომ მეხსიერებაში.
ეს უკვე აღარ იყენებენ რა არის მისამართი 0x123.
>> ასე რომ თავისუფალი აპირებს გამოაქვეყნოს რომ ბევრი.
ახლა ჩვენი ბევრი არის ისევ ცარიელი.
ჩვენ არ გვაქვს მეხსიერების გაჟონვის.
ახლა თავისუფალი დაბრუნდება.
გაითვალისწინეთ, რომ x არის კიდევ 0x123.
მაგრამ ეს არ არის ახლა მოქმედებს მეხსიერების.
ჩვენ აღარ უნდა dereference x.
ჰო?
>> აუდიტორია: არის დაბრუნებას 0 ზედმეტი?
>> ROB: returen 0 ზედმეტი?
დიახ.
ჩვენ უბრალოდ, რომ არსებობს, რადგან ჩვენ გვაქვს დაბრუნების ერთი ცის ქვეშ.
ასე რომ მოსწონს, yeah, საშუალებას მოიცავს დაბრუნების 0.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: ასე რომ, მას შემდეგ, რაც free x, რა მოხდება, თუ ვცდილობთ dereference მაჩვენებელი?
შესაძლებელია, რომ არაფერი მიდის არასწორი.
შესაძლებელია, რომ ჩვენ მაინც 50.
>> შესაძლებელია, ასევე, რომ რომ მეხსიერება არის ახლა გამოიყენება რაღაც.
ასე რომ, ეს გაურკვეველი ქცევა.
და გაურკვეველი არაფერს ნიშნავს შეიძლება მოხდეს.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: არა, ასე რომ, თუ თქვენ მივანიჭოთ x რაღაც.
ასე რომ, თუ სწორი აქ ჩვენ ვთქვით x უდრის malloc რაღაც else--
malloc ზომა ღონისძიება
მაშინ, რომ ორიგინალური ბლოკი მეხსიერება არ გაათავისუფლა.
და ჩვენ ოფიციალურად დაკარგა.
რომ არის მეხსიერების გაჟონვის.
ჩვენ დავკარგეთ ყველა ცნობას რომ ბლოკი მეხსიერება.
ასე რომ არ არსებობს გზა, ჩვენ ოდესმე მას.
OK, ასე რომ შემდეგ დაბრუნდნენ 0 საშუალებით კეთდება.
>> ყველა უფლება, ასე დასტის overflow.
რა არის იდეა აქ?
ასე მახსოვს, ბევრი მიდის ქვემოთ.
დასტის იზრდებოდა.
ასე რომ, ეს იყო მაგალითი ლექცია, ჩემის აზრით, სადაც მთავარი მხოლოდ აპირებს
მოვუწოდებთ ამ ფუნქციის foo, რომელიც აპირებს დარეკვა თავად რეკურსიული მეტი და
თავიდან.
>> ასე დასტის ფარგლებში ვაპირებთ მუშაობა ზუსტად იგივე.
ამიტომ, ჩვენ ვაპირებთ, რომ დაიწყოს მთავარი როგორც ბოლოში დასტის ჩარჩო.
შემდეგ მთავარ აპირებს მოვუწოდებთ foo, რომელიც აპირებს დასტის ჩარჩო.
>> შემდეგ foo აპირებს მოვუწოდებთ foo ერთხელ, რომელიც აპირებს
ერთი დასტის ჩარჩო.
და მერე ისევ, და ისევ და ისევ, და ისევ, სანამ, საბოლოოდ, ჩვენ აწარმოებს
შევიდა ბევრი.
ასე რომ, ეს არის, თუ როგორ მივიღებთ დასტის overflow.
და ამ ეტაპზე, თქვენ seg ბრალია.
ან ნეტავ მართლა seg ბრალია, სანამ ამ ეტაპზე, მაგრამ yeah.
>> აუდიტორია: არის ძირითადი ნაგავსაყრელი იგივე, რაც seg ბრალია?
>> ROB: ასე რომ დაინახავთ სეგმენტაცია ბრალი core მოხვდა.
თქვენ core ნაგავსაყრელი როდესაც თქვენ seg ბრალია.
და ეს როგორც ნაგავსაყრელი ყველა შინაარსი თქვენი არსებული მეხსიერების ასე
რომ თქვენ შეგიძლიათ ცდილობენ და იდენტიფიცირება ამიტომ თქვენ seg გააკრიტიკა.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: So სეგმენტაცია ბრალია საშუალებით არსებობს დასტის overflow.
ასე რომ, არ არის აუცილებელი.
სეგმენტაცია ბრალია ნიშნავს, რომ თქვენ ეხება მეხსიერების ისე,
თქვენ არ უნდა იყოს.
ასე რომ ერთი გზა, რომ ხდება, როდესაც თქვენ დასტის overflow, ჩვენ ვიწყებთ ეხება
მეხსიერების ისე, რომ ჩვენ არ უნდა ვიყოთ.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: ასე რომ შიგნით უსასრულო ციკლი.
ისევე, როგორც ეს არის, როგორიც რეკურსიული უსასრულო loop ამიტომ ჩვენ კიდევ სხვა
დასტის ჩარჩო ყოველ ჯერზე.
მაგრამ მხოლოდ შიგნით რეგულარული უსასრულო ხოლო one--
კარგად, მოდით კი არ ბეჭდვა ვ
რაღაც.
როგორიც არ უნდა იყოს.
>> ჩვენ არ ვაპირებთ, მიღების ერთი დასტის ჩარჩო.
ჩვენ უბრალოდ აპირებს შეინარჩუნოს looping მეტი ამ ერთ დავალებით.
დასტის არ იზრდება.
ის ფაქტი, რომ თითოეული რეკურსიული დარეკეთ გვაძლევს დასტის ჩარჩო.
სწორედ ამიტომ, ჩვენ დასტის overflow.
ჰო?
>> აუდიტორია: ასე რომ, თუ თქვენ თქვით, რომ მიიღოს ხოლო მარყუჟის და შემდეგ [INAUDIBLE]?
>> ROB: ასე რომ, თუ შიგნით, ხოლო მარყუჟის იყო printf, თქვენ კვლავ
არ seg ბრალია.
მე უბრალოდ არ მინდა, რომ აღრეული რამ.
ეს იქნებოდა loop.
ნეტავ კიდევ ერთი დასტის ვიზრუნოთ, რომ printf.
>> მაშინ printf დაბრუნდნენ.
მაშინ ნეტავ loop ერთხელ.
ნეტავ კიდევ ერთი დასტის ვიზრუნოთ, რომ printf.
რომ დაბრუნდნენ.
ერთი დასტის ჩარჩო.
ასე რომ თქვენ არ მიღების ამ უსასრულო პილინგი up დასტის ფარგლებში.
>> აუდიტორია: [INAUDIBLE]?
>> ROB: დიახ.
ასე რომ, ამ დასტის overflow ხდება იმიტომ, რომ არც ერთი ამ
ზარები foo ბრუნდებიან.
ასე რომ, თუ დავუბრუნდებით, მაშინ ჩვენ დაიწყოს დაკარგვის დასტის ფარგლებში.
და მაშინ ჩვენ არ დასტის overflow.
და სწორედ ამიტომ თქვენ გჭირდებათ ბაზის შემთხვევაში თქვენი პირადი ფუნქციები.
ჰო?
>> აუდიტორია: არის პოტენციალი და ზომის დასტის ბევრი იგივე
ყველა პროგრამა?
>> ROB: დაახლოებით.
პოტენციური ზომა დასტის და ბევრი ერთი და იგივე ყველა, პროგრამები?
უხეშად.
არსებობს რამდენიმე randomization to სადაც დასტის იწყება და
სადაც ბევრი იწყება.
თუ მოხდება მთელი ბევრი გლობალური ცვლადები და ნივთები, თქვენ შეიძლება
წართმევას გარკვეული სივრცე თქვენი ბევრი.
>> 64 ბიტიანი სისტემა, პრაქტიკულად უსასრულო მეხსიერება.
არსებობს მხოლოდ იმდენად.
შორის 32 ბიტი და 64 ბიტი, რომ მნიშვნელოვანი განსხვავება.
>> თქვენ აპირებს მიიღოს მთელი ბევრი უფრო დასტის და ბევრი სივრცე 64-bit
სისტემაში, რადგან არსებობს მხოლოდ მეტი მიმართავს, რომ მათ შეუძლიათ გამოიყენონ.
მაგრამ ინდივიდუალური სისტემით, იგი იქნება დაახლოებით იგივე თანხა დასტის
და ბევრი სივრცეში.
ყველა უფლება.
>> ასე რომ, ბოლო რამ არის კოლექცია.
ასე, რომ თქვენ უნდა იცოდეს, რომ ეს პროცესი.
არსებობს ოთხი დიდი ნაბიჯები.
ასე რომ, პირველი უნდა იყოს ადვილად დასამახსოვრებელი.
წინასწარი დამუშავება.
მას აქვს პრეფიქსი წინასწარი მას.
ასე საქმე ადრე ყველაფერი.
>> რამ უნდა გვახსოვდეს არის hash.
ასე რომ hash განსაზღვრავს და hash შედის ყველა იმ.
ეს ყველაფერი წინასწარ პროცესორი დავალებები მისცა.
ეს ყველაფერი, რომ წინასწარ პროცესორი ზრუნავს.
>> ასე რომ, რა წინასწარ პროცესორი გავაკეთოთ?
ეს მართლაც dumb რამ.
ყველა ის, რომელსაც შეუძლია ყველა ამ ასლი და მოჭრილი და პასტა ოპერაციებში.
>> ასე რომ hash შედის სტანდარტული i0 dot h.
რა არის ეს აკეთებს?
ის grabbing სტანდარტული i0 dot h ფაილი და pasting ის ზედა
იქ, სადაც ის ამბობს, რომ hash შედის სტანდარტული i0 dot h.
>> და ნებისმიერი hash განსაზღვრავს, რომ ჩვენ ჩანს, თუ რა რომ აკეთებს?
მისი გადაწერა ღირებულება, რომ hash განსაზღვრული განისაზღვრება, როგორც და pasting, რომ
სადაც თქვენ იყენებთ ღირებულება.
ამიტომ preprocessor უბრალოდ რეალურად მარტივი ტექსტი დაფუძნებული ოპერაციებში.
იგი არაფერს აკეთებს ჭკვიანი.
ასე რომ ყველაფერი არის უფრო რთული.
>> ახლა რომ preprocessor არის კეთდება, რეალურად ადგენენ.
ასე რომ, რას შედგენა ნიშნავს?
ჩვენ ახლა ვაპირებთ საწყისი C კოდი შეკრების კოდი.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: Yeah, ჩვენ დაჭერილი, რომ.
ამიტომ შედგენას.
ჩვენ ვაპირებთ C შეკრებისა.
ასე რომ, ეს არის ფაქტობრივი ენის შეცვლა.
შედგენის თავისთავად ნიშნავს აპირებს საწყისი მაღალ დონეზე ენის to
ქვედა დონის ენა.
>> და c არის მაღალი დონის ენა შედარებით ასამბლეის.
რა არის შეკრების?
მის მითითებებს, რომლებიც, საკმაოდ ბევრი, გააკეთა თქვენი CPU.
მაგრამ თქვენს კომპიუტერში ჯერ კიდევ არ მესმის ასამბლეის.
ეს მარტო ესმის, პირობა და zeros.
ასე რომ შემდეგი ნაბიჯი იკრიბებიან, რომელიც მოაქვს ამ ინსტრუქციას, რომ
თქვენი CPU ესმის და რეალურად თარგმნის მათ,
პირობა და zeros.
>> ასე რომ, C შეკრებისა ორობითი.
მაგრამ მე არ მაქვს შესრულებადი ამჟამად.
ასე რომ, ვფიქრობ CS50 ბიბლიოთეკაში.
ჩვენ გათვალისწინებული თქვენ ორობითი ეს არის CS50 ბიბლიოთეკა, რომელსაც აქვს GetString
და GetInt და ყველა რომ.
>> მაგრამ cs50 ბიბლიოთეკა
in და თავად არ არის შესრულებადი.
მას არ გააჩნია ძირითადი ფუნქცია.
ეს მხოლოდ რამოდენიმე ორობითი რომ თქვენ შეგიძლიათ გამოიყენოთ.
ასე რომ აკავშირებს, თუ როგორ შევუწყოთ ყველა ამ სხვადასხვა ორობითი ფაილი
შევიდა ფაქტობრივი შემსრულებელი.
ერთი, რომ თქვენ შეგიძლიათ აკრიფოთ dot slash dot out.
>> ასე რომ, ეს, როგორიცაა ფაილი, რომელიც თქვენ წერდა, - რაც თქვენი პროგრამა is--
Ceaser dot გ.
მაგრამ ახლა ეს უკვე შედგენილი ქვემოთ ორობითი.
ასე Ceaser dot o.
და ეს არის ჩვენი CS50 ბიბლიოთეკები ორობითი.
და ისინი შეეხამება ერთ შემსრულებელი.
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: ასე რომ, პირველი მოიცავს, გახსოვდეთ, hash მოიცავს ფაქტიურად
წინასწარ პროცესორი ნაბიჯი.
მაგრამ ეს ცალკე.
თუ თქვენ არ იყენებთ ნებისმიერი ფუნქციები, გარეთ თქვენი ერთი ფაილი შემდეგ,
არა, თქვენ არ უნდა უკავშირებენ არაფერს მას შემდეგ, რაც თქვენ გაქვთ ყველაფერი.
>> რომ განაცხადა, printf მიმდინარეობს უკავშირდება.
თუ თქვენ ოდესმე გამოიყენოს printf, რომ რაღაც , რომელიც უნდა უკავშირდება
იმიტომ, რომ თქვენ არ დაწერა.
და, ფაქტობრივად, printf ავტომატურად უკავშირდება.
თქვენ იცით, როგორ ბრძანების ან, როდესაც აკრიფოთ მიიღოს, თქვენ ხედავთ მას აქვს
dash ლ cs50, რომელსაც აქვს ლინკი CS50 ბიბლიოთეკა?
Printf და პერსონალის მოსწონს, რომ აპირებს უკავშირდება ავტომატურად.
ნებისმიერი სხვა კითხვები არაფერი?
>> აუდიტორია: [INAUDIBLE]?
>> ROB: აკავშირებს?
ჩვენ გვაქვს მთელი თაიგული სხვადასხვა ორობითი ფაილი.
ეს არის კანონიკური მაგალითად რომ ჩვენ ვიყენებთ არის CS50 ბიბლიოთეკაში.
ჩვენ შევიკრიბეთ და იმის გათვალისწინებით, რომ თქვენ ორობითი ამ CS50 ბიბლიოთეკაში.
>> გსურთ გამოიყენოთ GetString თქვენი პროგრამა.
ასე, რომ თქვენ და გამოიყენოს GetString.
მაგრამ გარეშე ჩემი ორობითი კოდი GetString, როდესაც თქვენ კომპილაციის თქვენი კოდი
ქვემოთ, თქვენ შეგიძლიათ რეალურად არ აწარმოებს თქვენი პროგრამა, რადგან GetString სიმებიანი არის
ჯერ კიდევ არ არის ბოლომდე ნათელი.
>> ეს მხოლოდ მაშინ, როდესაც ბმული ჩემი ორობითი რომელიც შეიცავს GetString, რომ ახლა, ყველა
უფლება, მე შეიძლება რეალურად შეასრულოს GetString.
ჩემი ფაილი არის სრული.
და შემიძლია აწარმოებს ამ.
ჰო?
>> აუდიტორია: არა აკავშირებს გადაიყვანო ორობითი შესრულებადი?
ასე რომ, მაშინაც კი, თუ თქვენ არ გაქვთ სხვა ბიბლიოთეკების, არ მაინც იყოს
აუცილებელია თარგმნა [INAUDIBLE]?
>> ROB: ასე შემსრულებელი კვლავ ორობითი.
უბრალოდ აერთიანებს მთელი bunch of binaries.
>> აუდიტორია: დიდი მადლობა, რომ.
>> ROB: პრობლემა არ არის.
ნებისმიერი სხვა კითხვები?
წინააღმდეგ შემთხვევაში, ჩვენ ყველა მითითებული.
ყველა უფლება.
მადლობა.
>> [ტაში]
>> აუდიტორია: დიდი მადლობა.
>> ROB: Yeah.