>> [მუსიკის დაკვრა]
>> [ვიდეო აღწარმოების]
>> დააკავეს ცრუობს.
>> გამოტოვებულია რა?
>> მე არ ვიცი.
>> ისე, რა ვიცით?
>> -რომ 9:15, Ray Santoya იყო ბანკომატი.
-ჰო.
ასე რომ, კითხვა, რა იყო ის აკეთებს 9:16?
>> -სროლა 9 მილიმეტრიანი ერთი რაღაც.
შესაძლოა, მან დაინახა, სნაიპერი.
>> ანუ იყო მასთან მუშაობა.
>> -Wait.
დავბრუნდეთ ერთი.
>> რას ხედავთ?
>> -მოტანა მისი სახე up სრულ ეკრანზე.
>> მოგვწერა სათვალე.
>> -არის ასახვა.
>> -ეს არის Nuevitas ბეისბოლის გუნდი.
სწორედ მათი ლოგო.
>> და ის საუბარი, რომ ვინც ის ტარება რომ ქურთუკი.
>> [END აღწარმოების]
>> DAVID Malan ყველა უფლება.
ეს არის CS50 და ეს არის ცოტა მეტი [INAUDIBLE], რომელიც თქვენ
dabbling ერთად პრობლემა მითითებული ოთხი.
დღეს ჩვენ განვუცხადეთ ცოტა მეტი ღრმად ეს რამ მოუწოდა მითითებას,
რომელიც მიუხედავად იმისა, რომ საკმაოდ arcane თემაზე,
აღმოჩნდება, რომ ის აპირებს უნდა იყოს საშუალება, რომლითაც ჩვენ
შეგიძლიათ შეიქმენით და იკრიბებიან ბევრად უფრო დახვეწილი პროგრამები.
მაგრამ ჩვენ ეს გავაკეთეთ გასულ ოთხშაბათს გზით ზოგიერთი claymation პირველი.
ასე რომ, ეს, გავიხსენოთ, Binky და ჩვენ მას,
უნდა შევხედოთ პროგრამა, რომელიც არ ნამდვილად არაფერი საინტერესო,
მაგრამ ეს არ გამოავლენს რამდენიმე პრობლემა.
ასე იწყება, რატომ არ დავდივართ სწრაფად მეშვეობით რამდენიმე ამ ნაბიჯებს,
ცდილობენ გამოიხადოს ადამიანის პირობები ზუსტად რა ხდება აქ
და რატომ არის ეს ცუდი, და შემდეგ გადაადგილება და რეალურად დაიწყოს მშენებლობის რაღაც
ეს ტექნიკა?
ასე რომ, ეს იყო პირველი ორი ხაზი ამ პროგრამაში
და ერისკაცად წარმოგვიდგება მისი თვალსაზრისით, რა არიან ეს ორი ხაზი აკეთებს?
ადამიანი, რომელიც გონივრულად კომფორტული თუ რა განაცხადა ეკრანზე?
რა არის ეს ორი ხაზი აკეთებს?
ეს არ არის ყველა, რომ განსხვავებული კვირაში ერთი,
მაგრამ არსებობს რამდენიმე ახალი სპეციალური სიმბოლო.
ჰო?
უკან არსებობს.
>> აუდიტორია: გამოცხადების პოინტერები?
დავით Malan: ამბობენ, რომ კიდევ ერთხელ?
აუდიტორია: გამოცხადების პოინტერები?
დავით Malan გამოცხადება მითითებას და მოდით დახვეწა, რომ ცოტა მეტი.
აუდიტორია: [INAUDIBLE] მისამართი x და შემდეგ y.
დავით Malan: მაშინ მიმართონ.
ასე რომ, კონკრეტულად, რას ვაკეთებთ არის ჩვენ ვაცხადებთ ორი ცვლადი.
ეს ცვლადები, თუმცა, ვაპირებთ იყოს ტიპის int ვარსკვლავი, რომელიც
უფრო კონკრეტულად იმას ნიშნავს, ისინი აპირებენ შესანახად
მისამართი int, შესაბამისად, x და y.
ახლა არსებობს რაიმე ღირებულებები?
არსებობს რაიმე ფაქტობრივი მისამართები ამ ორი ცვლადის ამ მომენტში?
No.
უბრალოდ ე.წ. ნაგვის ღირებულებებს.
თუ თქვენ არ რეალურად მივანიჭოთ ცვლადი, რაც არ იყო RAM
ადრე აპირებს შეავსოთ zeros და პირობა ორივე ცვლადი.
მაგრამ ჩვენ ჯერ არ ვიცით, რასაც ისინი და რომ ის,
იქნება გასაღები, თუ რატომ Binky დაკარგა თავის არეში გასულ კვირას.
>> ასე რომ, ეს იყო claymation განსახიერება ამ
რომლის დროსაც თქვენ გაქვთ მხოლოდ ორი ცვლადის, პატარა მრგვალი ცალი თიხის,
რომ შეგიძლიათ შეინახოთ ცვლადები, მაგრამ, როგორც შეფუთული up ისრებით ვარაუდობენ,
ისინი რეალურად არ მიუთითებს ყველგან ცნობილია, თავისთავად.
ასე რომ, ჩვენ გვქონდა ამ ხაზი, და ეს ახალი იყო გასულ კვირას, malloc მეხსიერება
გამოყოფა, რომელიც უბრალოდ ლამაზი გზა ვეუბნებოდი ოპერაციული სისტემა, Linux
ან Mac OS და Windows, hey, მომეცი მეხსიერება,
და ყველა თქვენ უნდა ვუთხრა ოპერაციული სისტემა
არის ის, რაც, როდესაც სვამს ის მეხსიერებაში.
ეს არ აპირებს მაინტერესებს, რა თქვენ აპირებს შუაშია,
მაგრამ თქვენ უნდა ვუთხრა ოპერაციული სისტემა, რა გზით malloc.
ჰო?
>> აუდიტორია: რამდენი?
დავით Malan: რამდენი?
რამდენი ბაიტი, და ასე რომ, ეს, კიდევ ერთხელ, contrived მაგალითია, უბრალოდ ვამბობ,
მომეცი ზომის int.
ახლა, ზომის int არის ოთხი ბაიტი ან 32 ბიტი.
ასე რომ, ეს უბრალოდ გზა ამბობდა, hey, ოპერაციული სისტემა,
მომეცი ოთხი ბაიტი მეხსიერება რომ შემიძლია ჩემს განკარგულებაშია,
და კონკრეტულად, რა malloc დაბრუნებას მიმართ
რომ ბლოკი ოთხი ბაიტი?
აუდიტორია: მისამართი?
დავით Malan: მისამართი.
მისამართი, რომ ბლოკი ოთხი ბაიტი.
ზუსტად.
და ისე, რომ ის, რაც ინახება საბოლოო x და სწორედ ამიტომ, ჩვენ ნამდვილად არ
მაინტერესებს, რა რაოდენობის, რომ მისამართი, თუ არა ის ox1 ან ox2
ან რაღაც cryptic თექვსმეტობითი მისამართზე.
ჩვენ, უბრალოდ, მაინტერესებს, ხატოვნად , რომ ცვლადი x არის
მიუთითებს, რომ ბლოკი მეხსიერება.
ასე ისარი წარმოადგენს მაჩვენებელი, ან უფრო კონკრეტულად, მეხსიერების მისამართზე.
მაგრამ ერთხელ, ჩვენ არ, როგორც წესი, მაინტერესებს რა იმ ფაქტობრივი მისამართები.
ახლა, ამ ხაზის ამბობს რა layman პირობები?
Star x იღებს 42 მძიმით.
რას ნიშნავს ეს?
თქვენ გინდათ წასვლა?
არ ნულიდან თქვენი კისრის.
>> აუდიტორია: მისამართი x არის 42.
>> დავით Malan: მისამართი x არის 42.
მთლად ასე არა.
ასე ახლოს, მაგრამ არა საკმაოდ, იმიტომ, რომ იქ ვარსკვლავი, რომელიც prefixing x.
ასე რომ, ჩვენ უნდა tweak ცოტა.
ჰო?
>> აუდიტორია: ღირებულება, რომელიც მაჩვენებელი x მიუთითებს, რომ 42 წლისაა.
დავით Malan: OK.
ღირებულება რომ მომცეთ x არის მიუთითებს, ვთქვათ, უნდა იყოს 42,
ან დააყენა სხვა გზა, ვარსკვლავი x ამბობს, გადადით რასაც მისამართი
არის x, თუ არა ის 1 Oxford Street ან 33 Oxford Street
ან ox1 ან ox33, რაც რომ რიცხვითი მისამართი,
ვარსკვლავი x არის Dereferencing x.
ასე რომ მისამართი და შემდეგ დააყენა ნომერი 42 არსებობს.
ასე რომ, ეს იქნება ექვივალენტი გზას ვამბობ, რომ.
ასე რომ, ყველა ჯარიმა და შემდეგ ჩვენ გვინდა წარმოადგენს სურათი
ასეთია, სადაც ჩვენ დასძინა 42 რომ ბლოკი ოთხი
bytes მარჯვენა მხარეს, მაგრამ ეს ხაზი, სადაც ყველაფერი წავიდა awry
და Binky ხელმძღვანელი გამოჩნდა off ამ ეტაპზე,
რადგან ცუდი რამ ხდება, როდესაც თქვენ dereference ნაგვის ღირებულებები
ან თქვენ dereference ბათილად პოინტერები, და მე ვიტყვი, არასწორი
იმიტომ, რომ ამ ეტაპზე ამბავი, რა არის შიგნით y?
რა არის ღირებულება y დაფუძნებული წარსულში რამდენიმე ნაბიჯი?
ჰო?
რა არის ეს?
>> აუდიტორია: მისამართი.
დავით Malan: მისამართი.
ეს უნდა იყოს მისამართი მაგრამ მე ინიციალიზაცია?
ასე რომ, მე არ გაუკეთებია.
ასე რომ, რა არის ცნობილი, რომ იქ?
ეს არის რამოდენიმე ნაგვის ღირებულება.
ეს შეიძლება იყოს ნებისმიერ მისამართზე ნულიდან 2 მილიარდი თუ თქვენ გაქვთ ორი gigs of RAM,
ან ნულოვანი 4 მილიარდი, თუ თქვენ ოთხი გბ ოპერატიული მეხსიერება.
ეს არის ზოგიერთი ნაგვის ღირებულება, მაგრამ პრობლემა ის არის,
რომ ოპერაციული სისტემა, თუ ეს არ მიეცა თქვენ
რომ ბლოკი მეხსიერება კონკრეტულად რომ თქვენ ცდილობთ წასვლა,
ეს ზოგადად აპირებს გამოიწვიოს, რასაც ჩვენ ვნახეთ, როგორც სეგმენტაცია ბრალია.
ასე რომ, ფაქტობრივად, ნებისმიერი, ვინც არ იბრძვის პრობლემები ოფისში საათი
ან პრობლემა, რომელიც უფრო ზოგადად ცდილობენ გაერკვნენ
სეგმენტაცია ბრალია, რომ ზოგადად ნიშნავს,
თქვენ ეხება სეგმენტი მეხსიერება, რომ თქვენ არ უნდა იყოს.
თქვენ ეხება მეხსიერება რომ ოპერაციული სისტემა არ აქვს
საშუალებას გაძლევთ შეეხოთ, თუ არა ის ძალიან შორს წავიდნენ თქვენს მასივი
ან დაწყებული ახლა, თუ არა ეს იმიტომ, რომ თქვენ ეხება
მეხსიერების რომ მხოლოდ ზოგიერთი ნაგვის ღირებულება.
>> ამით ვარსკვლავი x აქ სახის გაურკვეველი ქცევა.
არასოდეს არ უნდა გააკეთოს, რადგან შანსები არიან, პროგრამა უბრალოდ აპირებს ავარიული,
იმიტომ, რომ თქვენ და განაცხადა, გადადით ამ მისამართზე
და თქვენ არ ვიცი სად რომ მისამართზე რეალურად არის.
ასე რომ, ოპერაციული სისტემა, სავარაუდოდ, აპირებს Crash თქვენი პროგრამის
შედეგად და მართლაც, რომ თუ რა მოხდა იქ Binky.
ასე რომ, საბოლოო ჯამში, Binky დაფიქსირდა ეს პრობლემა.
ასე რომ, თავად პროგრამის გაყალბდა.
მაგრამ თუ სახის გაყალბებას წინ და შეასრულოს ამ ხაზის ნაცვლად,
Y ტოლია x მხოლოდ იმას ნიშნავს, რასაც მისამართი x, ასევე, რომ ეს y.
>> და ასე ხატოვნად, ჩვენ სწორედ ამ ორი ისრებით
საწყისი x და y მიუთითებს ერთი და იგივე ადგილზე.
ასე რომ, სემანტიკურად, x უდრის წ, რადგან ორივე
შენახვის იგივე მისამართი, ergo მიუთითებს 42,
და ახლა, როდესაც ამბობენ, რომ ვარსკვლავი y, გადადით მისამართზე წ,
ეს საინტერესო გვერდითი ეფექტი.
ასე რომ, მისამართი y არის იგივე, რაც მისამართი x.
ასე რომ, თუ ვიტყვი, რომ წავიდეს მისამართი ამ y და შეცვლის ღირებულება 13,
ვინ არის დაზარალებული?
X არის, წერტილი D, ასე ვთქვათ, უნდა შეეხო ასევე.
>> და მართლაც, როგორ Nick მიიპყრო ამ სურათს ამ claymation სწორედ ეს იყო.
მიუხედავად იმისა, რომ დაიცვას მაჩვენებელი y, ჩვენ დასრულდა იმავე ადგილას,
და ასე რომ, თუ ჩვენ უნდა ბეჭდვა გარეთ x და y ის pointee,
მაშინ ჩვენ ვხედავთ ღირებულება 13.
ახლა, მე ვიტყვი, pointee იყოს შეესაბამება ვიდეო.
პროგრამისტები, ჩემი ცოდნა, არასოდეს რეალურად
ამბობენ, რომ სიტყვა pointee, რომ რაც აღნიშნა
დროს, მაგრამ თანმიმდევრულობა ვიდეო, გააცნობიეროს,
ეს ყველაფერი, რომ იყო იგულისხმება, რომ სიტუაცია.
ასე რომ, რაიმე შეკითხვები claymation ან მითითებას ან malloc უბრალოდ არ არის?
არ არის?
ყველა უფლება.
>> ასე რომ, გარეშე ado, მოდით შევხედოთ
, სადაც ეს ფაქტიურად გამოიყენება გარკვეული დროის განმავლობაში.
ასე რომ, ჩვენ გვქონდა ამ CS50 ბიბლიოთეკა რომ მივიღე ყველა ამ ფუნქციას.
ჩვენ გამოიყენება GetInt ბევრი, GetString, ალბათ GetLongLong ადრე
ჩემი PSet ერთი ან ასე, მაგრამ რაც რეალურად უკვე მიმდინარეობს?
ისე, მოდით მიიღოს სწრაფი შევხედოთ ქვეშ Hood პროგრამა, რომელიც
შთააგონებს, რის გამოც ჩვენ გაძლევთ CS50 ბიბლიოთეკა, და მართლაც, როგორც გასულ კვირას,
ჩვენ დავიწყე იმ სასწავლო თვლები off.
ასე რომ, ეს არის გადანაწილებული ერთი სიკვდილის რა
უკვე მიმდინარეობს შიგნით CS50 ბიბლიოთეკა,
მიუხედავად იმისა, რომ ჩვენ ახლა დაიწყება მოძრავი დაშორებული, საუკეთესო პროგრამები.
>> ასე რომ, ეს არის პროგრამის მოუწოდა scanf 0.
ეს სუპერ მოკლე.
უბრალოდ აქვს ამ მიმართულებით, მაგრამ ეს წარუდგენს ფუნქცია მოუწოდა scanf
რომ ჩვენ რეალურად აპირებს ვხედავ მომენტი შიგნით CS50 ბიბლიოთეკა,
თუმცა ოდნავ განსხვავებული ფორმით.
ასე რომ ამ პროგრამის on line 16 არის გამოცხადების ცვლადი x.
მომეცი ოთხი ბაიტი int.
ეს უკვე ვეუბნებოდი შესახებ, ნომერი გთხოვთ, ხოლო შემდეგ
ეს არის საინტერესო ხაზი, რომელიც რეალურად კავშირები ერთად გასულ კვირას
და ეს.
Scanf და შემდეგ შეამჩნევთ სჭირდება სტრიქონში, ისევე printf,
% i ნიშნავს int, და მაშინ იგი იღებს მეორე არგუმენტი, რომელიც გამოიყურება ცოტა
ხმაურიანი.
ეს ampersand x, და გავიხსენოთ, ჩვენ მხოლოდ ის დავინახე, რომ ეს კიდევ ერთხელ გასულ კვირას.
რას ampersand x წარმოადგენს?
რას ampersand გავაკეთოთ C?
ჰო?
>> აუდიტორია: მისამართი.
დავით Malan: მისამართი.
ასე რომ, პირიქით საქართველოს ვარსკვლავი ოპერატორი,
იმის გამო, რომ ვარსკვლავი ოპერატორი ამბობს, გადადით ამ მისამართზე, ampersand ოპერატორი
ამბობს, გაერკვნენ მისამართი ეს ცვლადი,
და ეს ძალიან მნიშვნელოვანია, რადგან scanf მიზანი ცხოვრებაში
არის სკანირებას მომხმარებლის შეიტანენ კლავიატურაზე,
დამოკიდებულია რასაც იგი სახის, და მაშინ წავიკითხე, რომ მომხმარებლის შეყვანის
შევიდა ცვლადი, მაგრამ ჩვენ დაინახა, რომ ბოლო ორი კვირის განმავლობაში
, რომ swap ფუნქცია, რომ ჩვენ ცდილობდა ძალისხმევის განხორციელება
მხოლოდ გატეხილი.
შეგახსენებთ, რომ swap ფუნქციის, თუ ჩვენ უბრალოდ გამოაცხადა A და B ints,
ჩვენ წარმატებით სვოპ ორი ცვლადის შიგნით swap
უბრალოდ მინდა რძე და OJ, მაგრამ, როგორც კი swap დაბრუნდა,
რა იყო შედეგი მიმართ რომ x და y, ორიგინალური ღირებულებებს?
არაფერი.
ჰო.
არაფერი არ მომხდარა, რომ დრო, რადგან სვოპების შეცვლა მხოლოდ მისი ადგილობრივი ასლები,
რაც უნდა ვთქვა, ყველა ამ დროს, როდესაც ჩვენ
უკვე გადადის არგუმენტები ფუნქციები, ჩვენ
მხოლოდ გავლით ასლები იმ არგუმენტებს.
ამის გაკეთება შეგიძლიათ, რომ რაც გაგიხარდებათ, მათ შორის,
მაგრამ ისინი აპირებენ, არ აქვთ ეფექტი ორიგინალური ღირებულებებს.
ასე რომ, ეს პრობლემატურია, თუ გვინდა, რომ აქვს ფუნქცია, როგორიცაა scanf
ცხოვრებაში, რომლის მიზანია სკანირების მომხმარებლის შეიტანენ კლავიატურა
და შემდეგ შეავსოთ ბლანკები, ასე საუბარი, რომ არის, მისცეს ცვლადი, როგორიც x
მნიშვნელობა, იმიტომ, რომ, თუ მე უბრალოდ გაივლის x to scanf,
თუ გავითვალისწინებთ, ლოგიკა ბოლო კვირას, scanf შეუძლია გააკეთოს რაც არ სურს
ასლი x, მაგრამ ეს ვერ მუდმივად შეცვალოს x, თუ ვაძლევთ
scanf საგანძური რუკა, ასე ვთქვათ, სადაც x აღნიშნავს ადგილზე, რომლის დროსაც
ჩვენ კორიდორი მისამართი x ისე, რომ scanf შეიძლება იქ და რეალურად ცვლილება
ღირებულება x.
ასე რომ, რა თქმა უნდა, ყველა რომ ეს პროგრამა აკეთებს
თუ მე scanf 0, ჩემი წყარო 5m დირექტორია, რომ scanf 0,
dot slash scanf, ნომერი გთხოვთ, 50, მადლობა 50.
>> ასე რომ, ეს არ არის ყველა, რომ საინტერესო, მაგრამ რა მართლაც ხდება
ის არის, რომ, როგორც კი მოვუწოდებ scanf აქ, ღირებულება x
მიმდინარეობს მუდმივად იცვლება.
ახლა, ეს, როგორც ჩანს, ლამაზი და კარგი, და, ფაქტობრივად, ეს
როგორც ჩანს, ჩვენ ნამდვილად არ გვჭირდება CS50 ბიბლიოთეკა ყველა აღარაა.
მაგალითად, მოდით აწარმოებს ეს კიდევ ერთხელ აქ.
ნება მომეცით, რისთვისაც მას მეორე.
შევეცადოთ ნომერი, გთხოვთ, და ნაცვლად ამბობდა 50 როგორც ადრე,
მოდით უბრალოდ, ვამბობთ არ არის.
OK, ეს ცოტა უცნაური.
OK.
და მხოლოდ რაღაც სისულელე აქ.
ასე რომ, ეს არ ჩანს, გაუმკლავდეს მცდარი სიტუაციებში.
ამიტომ, ჩვენ უნდა მინიმალურად დაწყება დამატებით რამდენიმე შეცდომის შემოწმება
დარწმუნდით, რომ მომხმარებელს აქვს აკრეფილი ფაქტობრივი რაოდენობის, როგორიცაა 50,
იმიტომ, რომ, როგორც ჩანს, აკრეფით სიტყვა არ არის აღმოჩენილი, როგორც პრობლემური,
მაგრამ ეს, ალბათ უნდა იყოს.
>> მოდით შევხედოთ ეს ვერსია არის, რომ ჩემი მცდელობა reimplement GetString.
თუ scanf ყველა ამ ფუნქციონირება აშენდა,
რატომ ჩვენ უკვე dabbling ამ სასწავლო დისკები GetString?
ისე, აქ, ალბათ, ჩემი საკუთარი მარტივი ვერსია GetString
რომლის დროსაც ერთი კვირის წინ, მე შეიძლება არ განაცხადა, მომეცი სიმებიანი და მას ბუფერში.
დღეს, მე ვაპირებ, რომ დაიწყოს მხოლოდ ამბობდა char ვარსკვლავი, რომელიც, გავიხსენოთ,
ეს უბრალოდ სინონიმი.
როგორც ჩანს, scarier, მაგრამ ეს ზუსტად იგივე რამ.
ასე რომ მომეცი ცვლადში ბუფერული რომ აპირებს შესანახად სიმებიანი,
ვუთხრა შესახებ სიმებიანი გთხოვთ, და შემდეგ, ისევე, როგორც ადრე,
მოდით ცდილობენ სესხება ეს გაკვეთილი scanf % s ამ დროს და შემდეგ გაივლის ბუფერული.
ახლა, სწრაფი საღი აზრის ქვითარი.
რატომ ვარ მე არ ვამბობ, ampersand ბუფერული ამ დროს?
დასკვნის წინა მაგალითი.
აუდიტორია: Char ვარსკვლავი არის მაჩვენებელი.
დავით Malan: ზუსტად, იმის გამო, რომ ამ დროს, char
ვარსკვლავი უკვე მაჩვენებელი, მისამართი, ზოგადად, რომ ვარსკვლავი იქ ყოფნა.
და თუ scanf ელოდება მისამართი, საკმარისია, უბრალოდ უნდა გაიაროს ბუფერული.
მე არ უნდა ვთქვა, ampersand ბუფერული.
იყიდება ცნობისმოყვარე, თქვენ შეიძლება რაღაც მოსწონს ეს.
ეს იქნებოდა სხვადასხვა მნიშვნელობა აქვს.
ეს გაძლევთ მაჩვენებელი მაჩვენებელი, რომელიც, ფაქტობრივად,
მოქმედებს, რაც C, არამედ ახლა, მოდით შეინახოს იგი მარტივი
და შენარჩუნება ამბავი თანმიმდევრული.
მე უბრალოდ აპირებს გაიაროს ბუფერული და ეს სწორია.
პრობლემა იმისა ამ.
ნება მომეცით წავიდეთ წინ და აწარმოებს ამ პროგრამა შემდეგ შედგენა მას.
ჩადება scanf 1.
Damn, ჩემი შემდგენელი ის არეალიდან ჩემი შეცდომა.
მომეცი ერთი მეორე.
Clang.
მოდით ვთქვათ scanf-1.გ.
OK.
იქ ჩვენ წავიდეთ.
მე სჭირდება.
CS50 ID სხვადასხვა კონფიგურაციის პარამეტრები
რომ დაიცავს თქვენ წინააღმდეგ თავს.
მე საჭირო გამორთოთ ის მიერ გაშვებული clang ხელით ამ დროს.
ასე რომ, სიმებიანი გთხოვთ.
მე ვაპირებ წავიდეთ წინ და ტიპის ჩემი საყვარელი hello მსოფლიოში.
OK, null.
ეს არ არის ის, რაც მე აკრეფილი.
ასე რომ, ეს მიუთითებს რაღაც რომ არასწორია.
ნება მომეცით წავიდეთ წინ და ტიპის მართლაც ხანგრძლივი string.
მადლობა null და მე არ ვიცი, თუ მე ვაპირებ შეძლებს ავარიის იგი.
შევეცადოთ ცოტა ასლი პასტა და თუ ეს ეხმარება.
უბრალოდ ჩასვით ბევრი ამ.
ეს ნამდვილად დიდი სიმებიანი, ვიდრე ჩვეულებრივი.
მოდით, უბრალოდ ნამდვილად დაწერა.
No.
რა იგი.
ბრძანება არ არის ნაპოვნი.
ასე რომ, არ უკავშირდება.
ეს იმიტომ, რომ მე გაკრული ცუდი პერსონაჟი,
მაგრამ ეს თურმე არ იმუშავებს.
>> შევეცადოთ ეს კიდევ ერთხელ, იმიტომ, რომ ეს სიამოვნება, თუ ჩვენ რეალურად ავარიის იგი.
მოდით აკრიფოთ ამ და ახლა, მე ვარ ვაპირებ კოპირება მართლაც ხანგრძლივი string
და ახლა ვნახოთ, თუ ჩვენ ავარიული ამ რამ.
ყურადღება მიაქციეთ, მე გამოტოვებული ფართები და ახალი ხაზები და semicolons
და ყველა ხმაურიანი სიმბოლო.
შეიტანეთ.
ახლა ქსელში უბრალოდ მიმდინარეობს ნელა.
გავმართე ქვემოთ Command-V ძალიან დიდი ხანია, ნათლად.
Damn it!
ბრძანება არ არის ნაპოვნი.
>> OK.
ისე, საქმე ისაა, მიუხედავად ამისა, შემდეგი.
ასე რომ, რა არის რეალურად აპირებს წლის ამ დეკლარაციას
საქართველოს char ვარსკვლავი ბუფერული on line 16?
ასე რომ, რა ვარ მე მისაღებად როდესაც მე განაცხადოს მაჩვენებელი?
ყველა მე მიღების არის ოთხი ბაიტი მნიშვნელობა ბუფერული, მაგრამ რა არის შიგნით
ამ მომენტში?
ეს არის რამოდენიმე ნაგვის ღირებულება.
იმის გამო, რომ ნებისმიერ დროს განაცხადოს ცვლადი დო, უბრალოდ ზოგიერთი ნაგვის ღირებულება,
და ჩვენ ვიწყებთ მოგზაურობა მეტი ეს რეალობა.
ახლა, როდესაც მე გეტყვით scanf, გადადით ამ მისამართზე
და ამით რასაც მომხმარებლის ტიპის.
იმ შემთხვევაში, თუ მომხმარებლის ტიპის მიესალმები მსოფლიოში, ისევე, სადაც მე ამას?
ბუფერული არის ნაგვის ღირებულება.
>> ასე რომ, სახის მოსწონს arrow რომელიც მიუთითებს, ვინ იცის, სად.
იქნებ ეს მიუთითებს სწორედ აქ ჩემს მეხსიერებაში.
ასე რომ, როდესაც მომხმარებელი სახეები hello მსოფლიოში,
პროგრამა ცდილობს დააყენა სიმებიანი hello მსოფლიოში წარმატებული 0
რომ ბლოკი მეხსიერება.
მაგრამ დიდი ალბათობით, მაგრამ აშკარად არ 100% ალბათობით,
კომპიუტერული აპირებს შემდეგ ავარიის პროგრამა, რადგან ეს არ არის
მეხსიერების მე უნდა დაშვებული შეეხოთ.
მოკლედ, ამ პროგრამის გაყალბდა ზუსტად რომ მიზეზი.
მე ფუნდამენტურად არ აკეთებს რა?
რა ნაბიჯები უნდა მე გამოტოვებული, ისევე, როგორც ჩვენ გამოტოვებული ერთად Binky პირველი მაგალითად?
ჰო?
>> აუდიტორია: მეხსიერების გამოყოფის?
>> დავით Malan: მეხსიერების გამოყოფა.
მე არ რეალურად გამოყოფილი ნებისმიერი მეხსიერების რომ სიმებიანი.
ასე რომ, ჩვენ შეგვიძლია დაფიქსირება ამ რამდენიმე გზები.
ერთ-ერთი, ჩვენ შეგვიძლია შევინარჩუნოთ ის მარტივი და რეალურად, ახლა თქვენ
აპირებს დაიწყოს ვხედავ დაბინდვა ხაზები შორის რა
მასივი, რა სიმებიანი, რა char ვარსკვლავი, რა მასივი სიმბოლო
არის.
აი მეორე მაგალითი ჩართვის და სიმები ცნობა
ყველა მე ვაკეთებ ხაზი 16, ნაცვლად გამოთქმისა
რომ ბუფერული იქნება char ვარსკვლავი, მომცეთ ბლოკი მეხსიერება,
მე ვაპირებ ძალიან აქტიურად მისცეს თავს ბუფერული 16 პერსონაჟი,
და სინამდვილეში, თუ თქვენ იცნობს ერთად ტერმინი buffering,
ალბათ მსოფლიოში ვიდეო, სადაც ვიდეო შეფერხებებით, ბუფერულ,
ბუფერული.
ისე, რა კავშირი აქ?
ისე, შიგნით YouTube და შიგნით ვიდეო მოთამაშე
ზოგადად მასივი რომ უფრო დიდია, ვიდრე 16.
ეს შეიძლება იყოს მასივი ზომა მეგაბაიტი, შესაძლოა, 10 მბ,
და შევიდა, რომ მასივი აკეთებს თქვენი ბრაუზერის ჩამოტვირთვა მთელი bunch of bytes,
მთელი bunch მბ ვიდეო და video player,
YouTube- ის და ვინც არის, იწყება კითხულობს bytes რომ მასივი,
და ნებისმიერ დროს ხედავთ სიტყვა buffering, ბუფერულ,
ეს ნიშნავს, რომ მოთამაშეს აქვს მიღებული ბოლომდე რომ მასივი.
ქსელი იმდენად ნელი რომ მას არ შევსება მასივი უფრო bytes
და ასე რომ თქვენ გარეთ ბიტი არაა შესახებ.
>> ასე რომ ბუფერული არის apt ტერმინი აქ, რომ ეს მხოლოდ მასივი, ბლოკი მეხსიერება.
და ეს იქნება გაასწორონ ის იმიტომ, რომ თურმე
რომ თქვენ შეიძლება მკურნალობა მასივები, თითქოს ისინი მისამართები, მიუხედავად იმისა, რომ ბუფერული
უბრალოდ სიმბოლო, ეს არის თანმიმდევრობა გმირები, ბუფერული,
რომ არის სასარგებლო ჩემთვის, პროგრამისტი, შეგიძლიათ გაიაროს მისი სახელი მთელს
თითქოს ეს იყო მაჩვენებელი, თითქოს ეს
იყვნენ მისამართი ბლოკი მეხსიერების 16 სიმბოლო.
ასე რომ, უნდა ვთქვა, მე ვერ გაივლის scanf სწორედ ეს სიტყვა
და ახლა, თუ მე ამ პროგრამას, რომ scanf 2, dot ხაზი scanf 2,
და აკრიფოთ მიესალმები მსოფლიოში, შეიყვანეთ, რომელიც time--
>> Hmm, რა მოხდა?
სიმებიანი გთხოვთ.
რა დავაშავე?
Hello world, ბუფერული.
Hello world.
Ah, მე ვიცი, რასაც ის აკეთებს.
OK.
ასე რომ, ის კითხულობს მდე სანამ პირველი სივრცეში.
მოდით მოტყუებას მხოლოდ ერთი წუთით და ამბობენ, მე უბრალოდ მინდოდა აკრიფოთ რაღაც
მართლაც დიდი, როგორც ეს არის დიდი სასჯელი ერთი, ორი, სამი, ოთხი, ხუთი,
ექვსი, შვიდი, რვა, ცხრა, 10, 11, 12, 13, 14, 15, 16.
OK.
ეს მართლაც დიდი ხნის სასჯელი.
ასე რომ, ეს წინადადება არის უმეტეს 16 სიმბოლოს
და ასე რომ, როდესაც მე დააჭიროთ რა მოხდება?
ისე, ამ შემთხვევაში, ამბავი, მე გამოაცხადა ბუფერული
რეალურად მიმდინარეობს მასივი 16 სიმბოლო მზად ვართ წავიდეთ.
ასე რომ, ერთი, ორი, სამი, ოთხი, ხუთი, ექვსი, შვიდი, რვა, ცხრა, 10, 11, 12, 13, 14,
15, 16.
ასე რომ, 16 სიმბოლო, და ახლა, როდესაც მე წაიკითხონ რაღაც ეს არის დიდი ხნის
წინადადება, რა მოხდება არის რომ მე ვაპირებ, რომ წაიკითხონ ეს ხანგრძლივი
S-E-N-T-E-N-C-E, სასჯელი.
>> ასე რომ, ეს არის მიზანმიმართულად ცუდი რამ, რომ მე
შენარჩუნება წერილობით მიღმა საზღვრების ჩემი მასივი,
საზღვრებს გარეთ ჩემი ბუფერული.
მე ვერ გაუმართლა და პროგრამა გავაგრძელებთ გაშვებული და არ მაინტერესებს,
მაგრამ ზოგადად, ამ მართლაც ავარიული ჩემი პროგრამა,
და ეს არის bug ჩემი კოდექსის მომენტში მე ნაბიჯ
საზღვრებს გარეთ რომ მასივი, იმიტომ, რომ მე
არ ვიცი, თუ ის აუცილებლად აპირებს ავარიული
ან თუ მე უბრალოდ აპირებს გაუმართლა.
ასე რომ, ეს არის პრობლემატური, რადგან ამ შემთხვევაში, ეს არ ჩანს მუშაობა
და მოდით ეცადა ბედი აქ, მიუხედავად იმისა, და IDE, როგორც ჩანს, შეეგუება საკმაოდ მწირი
of--
>> იქ ჩვენ წავიდეთ.
და ბოლოს.
ასე რომ, მე მხოლოდ ერთი, რომ ხედავთ ამ.
ასე რომ, მე მქონდა ბევრი fun აკრეფა out მართლაც დიდი ფაქტობრივი ფრაზა
რომ ის ნამდვილად გადააჭარბა 16 ბაიტი, იმიტომ, რომ მე
აკრეფილი ეს გიჟები ხანგრძლივი მრავალ ხაზის ფრაზა, და შემდეგ შეამჩნია, რა მოხდა.
პროგრამა ცდილობდა ბეჭდვა და მაშინ მივიღე სეგმენტაცია ბრალია
და სეგმენტაცია ხარვეზებით არის, როდესაც მსგავსი რამ ხდება
და ოპერაციული სისტემის ამბობს არა, არ შეიძლება შეეხოთ, რომ მეხსიერებაში.
ჩვენ ვაპირებთ, რომ კლავს პროგრამა საერთოდ.
>> ასე რომ, ეს, როგორც ჩანს, პრობლემატურია.
მე გაუმჯობესდა პროგრამა, რომლის მიხედვით მინიმუმ, მეხსიერება,
მაგრამ ეს, როგორც ჩანს, შეუზღუდოს ფუნქციის GetString მიღების
strings ზოგიერთი სასრულ სიგრძე 16.
ასე რომ, თუ გსურთ მხარდაჭერა აღარ სასჯელს ვიდრე 16 პერსონაჟი,
რა ვქნათ?
ასევე, შეგიძლიათ გაზრდის ზომა ბუფერული 32
ან, რომ, როგორც ჩანს, სახის მოკლე.
რატომ არ გვაქვს მხოლოდ ის 1000 მაგრამ დააყენებს უკან.
რა არის პასუხი ინტუიციურად of უბრალოდ თავიდან ეს პრობლემა მიღების
ჩემი ბუფერული დიდია, 1000 სიმბოლო?
განხორციელებით GetString ამ გზით.
რა არის კარგი ან ცუდი აქ?
ჰო?
აუდიტორია: თუ სავალდებულოა ბევრი სივრცე და არ გამოიყენოს იგი,
მაშინ არ გამოდის, რომ სივრცეში.
დავით Malan: აბსოლუტურად.
ეს არარაციონალური იმდენად, რამდენადაც, თუ თქვენ არ რეალურად უნდა 900 იმ bytes
და კიდევ თქვენ ითხოვს 1,000 სულ მაინც,
თქვენ მხოლოდ მოიხმარს უფრო მეხსიერება მომხმარებლის კომპიუტერში, ვიდრე თქვენ უნდა,
და მას შემდეგ, რაც ყველა, ზოგიერთი თქვენ უკვე შეექმნა
ცხოვრებაში, რომ, როდესაც თქვენ გაშვებული უამრავი პროგრამების
და ისინი ჭამს უამრავი მეხსიერება, ეს შეიძლება რეალურად ზემოქმედება შესრულება
და მომხმარებლის გამოცდილება კომპიუტერზე.
ასე რომ, ერთგვარი ზარმაცი გადაწყვეტა, დარწმუნებული ვარ, და პირიქით,
ეს არ არის მხოლოდ მფლანგველი, რა პრობლემა კვლავ რჩება, მაშინაც კი, თუ მე ჩემი ბუფერული
1000?
ჰო?
>> აუდიტორია: სიმებიანი სიგრძე 1,001.
დავით Malan: ზუსტად.
თუ თქვენი სიმებიანი სიგრძე 1,001, თქვენ გაქვთ ზუსტად იგივე პრობლემა,
და ჩემი არგუმენტი, მე მხოლოდ მაშინ, რომ მას 2000 წელს,
მაგრამ თქვენ არ იცით წინასწარ, თუ რამდენად დიდი უნდა იყოს,
და კიდევ, მე უნდა კომპილაციის ჩემი პროგრამა ადრე გაქირავების ადამიანი გამოიყენებს და ჩამოტვირთვა
მას.
ასე რომ, ეს არის ზუსტად სახის პერსონალის რომ CS50 ბიბლიოთეკა ლელო
დაგვეხმაროს და ჩვენ მხოლოდ ერთი შეხედვით ზოგიერთი ძირითადი განხორციელებას
აქ, მაგრამ ეს არის CS50 dot C. ეს არის ფაილი, რომელიც უკვე CS50 IDE
ყველა ამ კვირის რომ თქვენ უკვე გამოყენებით.
ეს წინასწარ შედგენილი და თქვენ იყენებს მას ავტომატურად
ბუნების მქონე dash ლ CS50 დროშა clang,
მაგრამ თუ მე გადახვევა ქვემოთ მთელი ეს ფუნქციები, აქ GetString,
და მხოლოდ გადმოგცეთ გემოს რა ხდება,
ავიღოთ სწრაფი შევხედოთ ნათესავი სირთულის.
ეს არ არის სუპერ გრძელი ფუნქცია, მაგრამ ჩვენ არ
უნდა ვიფიქროთ, რომ ყველა მძიმე შესახებ როგორ უნდა წავიდეს მიღებაზე სიმები.
>> ასე რომ, აქ არის ჩემი ბუფერული და მე როგორც ჩანს, ვრთავ, რომ null.
ეს, რა თქმა უნდა, არის იგივე, როგორც char ვარსკვლავი,
მაგრამ მე გადავწყვიტე, ამ ახორციელებს CS50 ბიბლიოთეკა
იმ შემთხვევაში, თუ ჩვენ ვაპირებთ იყოს სრულიად დინამიური,
მე არ ვიცი, წინასწარ როგორ დიდი სიმებიანი წევრებს არ ვაპირებთ გსურთ მიიღოთ.
ამიტომ, მე ვაპირებ, რომ დაიწყოს მხოლოდ ცარიელ ველს
და მე ვაპირებ დაამყარონ იმდენი მეხსიერებაში, მე უნდა მოერგოს შესახებ string
და თუ მე არ მაქვს საკმარისი, მე ვაპირებ ვკითხო
ოპერაციული სისტემის უფრო მეხსიერების.
მე ვაპირებ გადაადგილება მათი string შევიდა დიდი ბლოკი მეხსიერება
და მე ვაპირებ გათავისუფლების ან გასათავისუფლებლად საკმარისად დიდი ბლოკი მეხსიერება
და ჩვენ უბრალოდ აპირებს უნდა გავაკეთოთ ეს iteratively.
>> ასე სწრაფად, ერთი შეხედვით, აქ მხოლოდ ცვლადი
რომელიც მე ვაპირებ შენარჩუნება სიმღერა სიმძლავრის ჩემი ბუფერული.
რამდენი ბაიტი შემიძლია ჯდება?
აი ცვლადი n ერთად რომელიც მე ვაპირებ შენარჩუნება
სიმღერა რამდენი ბაიტი რეალურად ბუფერული და რომ მომხმარებელს აქვს აკრეფილი.
თუ თქვენ არ მინახავს ეს ადრე, თქვენ შეგიძლიათ მიუთითოთ, რომ ცვლადი როგორც int
არის ხელმოუწერელი, რომელიც, როგორც სახელი ვარაუდობს, იმას ნიშნავს, რომ არასამთავრობო უარყოფითი, და რატომ
მე ოდესმე მინდა შეწუხება მითითებით რომ int არ არის მხოლოდ int,
მაგრამ ეს ხელმოუწერელი int?
ეს არის არასამთავრობო უარყოფითი int.
რას [INAUDIBLE] ნიშნავს?
>> აუდიტორია: ეს აღწერილია თანხა მეხსიერება, რომელიც შეიძლება იყოს [INAUDIBLE].
>> დავით Malan: ჰო.
ასე რომ, თუ მე ვიტყვი, ხელმოუწერელი, ეს არის რეალურად გაწვდით ერთი ცოტა დამატებითი მეხსიერება
და როგორც ჩანს, სახის სულელური, მაგრამ თუ აქვს ერთი ცოტა დამატებითი მეხსიერება, რომელიც
იმას ნიშნავს, თქვენ ორჯერ მეტი ღირებულებები შეგიძლიათ წარმოადგენს,
იმიტომ, რომ ეს შეიძლება იყოს 0 ან 1.
ასე რომ იყოს, int შეიძლება უხეშად უარყოფითი 2 მილიარდი ყველა გზა
მდე დადებითი 2 მლრდ.
ეს არის დიდი მერყეობს, მაგრამ ეს ჯერ კიდევ სახის არარაციონალური
თუ თქვენ მხოლოდ აინტერესებს ზომის, რომელიც მხოლოდ ინტუიციურად
უნდა იყოს არასამთავრობო უარყოფითი ან დადებითი ან 0, ასევე მაშინ,
რატომ გაყვანაა 2 მილიარდი შესაძლებელია ღირებულებების უარყოფითი ნომრები
თუ თქვენ არასდროს მათი გამოყენება?
ასე განაცხადა ხელმოუწერელი, ახლა ჩემი int შეუძლია იყოს 0 და დაახლოებით 4 მილიარდი.
>> ასე რომ, აქ მხოლოდ int C მიზეზების გამო ჩვენ არ მოხვდება მხოლოდ ახლა, როგორც
თუ რატომ ეს int ნაცვლად char, მაგრამ აქ არის
არსი რა ხდება , და ზოგიერთ თქვენგანს
შეიძლება გამოყენებით, მაგალითად, fgetc ფუნქცია კი PSet ოთხ
ან შემდგომში, ჩვენ დავინახავთ, ეს ერთხელ პრობლემა მითითებული ხუთ,
fgetc არის კარგი, რადგან, როგორც სახელი სახის, სახის arcanely ვარაუდობს,
ეს არის ფუნქცია, რომელიც იღებს ხასიათი და ასე შემდეგ,
რა არის ფუნდამენტურად განსხვავებული ის, რაც ჩვენ ვაკეთებთ GetString
არის ჩვენ არ იყენებს scanf იგივე გზით.
ჩვენ, უბრალოდ, მცოცავი გასწვრივ ნაბიჯ ნაბიჯ მეტი, რასაც მომხმარებელს ჯერ აკრეფილი,
იმიტომ, რომ ჩვენ ყოველთვის გამოყოფს ერთ char, და ამიტომ ჩვენ ყოველთვის უსაფრთხოდ
შევხედოთ ერთი char დროს, და ჯადოსნური იწყება მოხდება აქ.
მე ვაპირებ, გადაფურცლეთ ქვემოთ შუა ამ ფუნქციის
უბრალოდ დანერგვა მოკლედ ამ ფუნქციას.
ისევე, როგორც არ არის malloc ფუნქცია, არსებობს
realloc ფუნქცია, სადაც realloc გაძლევთ გადაანაწილოს ბლოკი მეხსიერება
და რათა ის უფრო დიდი ან პატარა.
ცოტა ხნის ამბავი მოკლედ და ტალღის ჩემი ხელი, დღეს,
ვიცი, რომ რა GetString აკეთებს ეს ერთგვარი
საქართველოს magically იზრდება და მცირდება ბუფერული როგორც შესახებ
სახის მისი სიმებიანი.
>> ასე რომ, თუ მომხმარებლის ტიპის მოკლე ტექსტი, ეს კოდი
მხოლოდ გამოყოფს საკმარისი მეხსიერება, რათა შეწყობოდა სიმებიანი.
იმ შემთხვევაში, თუ შესახებ ინარჩუნებს აკრეფა როგორც მე ეს ისევ და ისევ
და კიდევ ერთხელ, ასევე, თუ ბუფერული ის თავდაპირველად ამ დიდი
და პროგრამა აცნობიერებს, რომ დაველოდოთ წუთში, მე გარეთ სივრცეში,
ის აპირებს გაორმაგდება ზომა ბუფერული
და შემდეგ ორჯერ ზომა ბუფერული და კოდი, რომელიც აკეთებს გაორმაგება,
თუ დავაკვირდებით აქ, მხოლოდ ამ ჭკვიანი ერთი ლაინერი.
თქვენ შეიძლება არ მინახავს ეს სინტაქსი ადრე, მაგრამ თუ ამბობენ, რომ ვარსკვლავი უდრის,
ეს არის იგივე მნიშვნელობა, როგორც განაცხადა, მოცულობა 2-ჯერ.
ასე რომ, ეს მხოლოდ ინარჩუნებს გაორმაგდა ტევადობის ბუფერული
და შემდეგ ეუბნება realloc მისცეს თავად რომ ბევრად უფრო მეხსიერება.
>> ახლა, როგორც განზე, არსებობს სხვა ფუნქციები აქ
რომ ჩვენ არ შესასწავლად ნებისმიერი დეტალი გარდა ნახოთ GetInt,
ჩვენ ვიყენებთ GetString წელს GetInt.
ჩვენ შეამოწმოს, რომ ეს არ არის null, რომელიც, გავიხსენოთ,
განსაკუთრებული მნიშვნელობა, რომელიც ნიშნავს რაღაც წავიდა არასწორია.
ჩვენ მეხსიერება ღალატობს.
უკეთესი შეამოწმოს, რომ.
და ჩვენ დაუბრუნოს Sentinel ღირებულება.
მაგრამ მე დაელოდება კომენტარები, როგორც რატომ და მაშინ ჩვენ გამოვიყენებთ ამ ბიძაშვილი scanf
მოუწოდა sscanf და თურმე sscanf, ან სიმებიანი scanf,
გაძლევთ შევხედოთ ხაზი, რომელიც მომხმარებელს აქვს აკრეფილი და მოგცემთ
ანალიზი ეს არსებითად და რა ვარ აკეთებს აქ მე ვეუბნებოდი sscanf,
ანალიზი, რასაც მომხმარებელს აქვს აკრეფილი და დარწმუნდით% i,
არ არის მთელი რიცხვი, და ჩვენ არ შეღწევას დღეს, სწორედ ამიტომ არსებობს ასევე
% გ აქ, მაგრამ მოკლედ საშუალებას ჩვენს აღმოაჩინოს თუ მომხმარებელს აქვს აკრეფილი
რაღაც ყალბი შემდეგ ნომერზე.
ასე რომ, იმ მიზეზით, რომ GetInt და GetString გითხრათ, გაიმეორეთ, გაიმეორეთ, გაიმეორეთ
იმიტომ, რომ ყველა რომ კოდი დავწერეთ,
ეს სახის ეძებს მომხმარებლის შეყვანის მიღების დარწმუნებული ვარ, ეს მთლიანად რიცხვითი
ან ის ფაქტობრივი მცურავი წერტილი ღირებულება ან მოსწონს,
დამოკიდებულია რა მნიშვნელობა ფუნქციონირებს თქვენ იყენებთ.
>> ავე.
OK.
ეს იყო mouthful მაგრამ საქმე ისაა, რომ
რომ მიზეზი გვქონდა იმ სასწავლო დისკები
იმიტომ, რომ ყველაზე დაბალი დონე, არსებობს მხოლოდ ამდენი რამ რომ
შეიძლება არასწორი, რომ გვინდოდა წინასწარ გაუმკლავდეს
იმ რამ, რა თქმა უნდა, ადრეული კვირის კლასის,
მაგრამ ახლა PSet ოთხი და PSet და ხუთ მიღმა ხედავთ, რომ ეს უფრო უთხრა
თქვენ, არამედ თქვენ უფრო შეუძლია გადაჭრის იმ სახის პრობლემები
თავს.
ნებისმიერი კითხვები GetString და GetInt?
ჰო?
>> აუდიტორია: რატომ თქვენ ორმაგად ტევადობის ბუფერული
ვიდრე უბრალოდ იზრდება ეს ზუსტი ოდენობა?
>> დავით Malan: კარგი კითხვაა.
რატომ ჩვენ ორჯერ მოცულობა ბუფერული როგორც ეწინააღმდეგებოდა
უბრალოდ გაზრდა ზოგიერთი მუდმივი მნიშვნელობა?
ეს იყო დიზაინი გადაწყვეტილება.
ჩვენ უბრალოდ გადაწყვიტა, რომ რადგან ეს ტენდენცია შეიძლება ცოტა ძვირი დროის ბრძენი ვთხოვო
ოპერაციული სისტემა მეხსიერება, ჩვენ არ
მინდა დასრულდება მდე მისაღებად შევიდა სიტუაცია დიდი სიმები
რომ ჩვენ ვიკვლევდით ოპერაციული ისევ და ისევ
და ისევ და ისევ სწრაფი მემკვიდრეობას მეხსიერება.
ასე რომ, ჩვენ უბრალოდ გადაწყვიტა, გარკვეულწილად თვითნებურად მაგრამ იმედი გვაქვს, გონივრულად,
რომ თქვენ იცით, რა, მოდით ცდილობენ მიიღონ წინ საკუთარ თავს
და უბრალოდ შეინახოს გააორმაგოს ისე, რომ ჩვენ შეამციროს ოდენობით ჯერ
ჩვენ მოვუწოდებთ malloc ან realloc, მაგრამ სულ გადაწყვეტილება
დარეკეთ არარსებობის იცის რა მომხმარებლებს დაგვჭირდება ჩაწერეთ.
ორივე გზა შეიძლება იყოს სადავო.
სავარაუდოდ კარგი.
>> მოდით შევხედოთ რამდენიმე სხვა გვერდითი მოვლენები მეხსიერება,
რამ, რაც შეიძლება წავიდეთ არასწორი და ინსტრუმენტები, რომ შეუძლია
გამოყენება დაჭერა ამ სახის შეცდომები.
გამოდის, რომ ყველა თქვენ, მიუხედავად იმისა, check50 არ უთხრა თქვენ, როგორც ბევრი,
უკვე წერდა buggy კოდი წლიდან კვირაში ერთი,
მაშინაც კი, თუ ყველა check50 ტესტები გავიდა და მაშინაც კი, თუ თქვენ და თქვენი TF
სუპერ დარწმუნებულია, რომ თქვენი კოდი მუშაობს, როგორც გამიზნული.
შენი კოდი უკვე buggy და გაყალბდა, რომ ყველა თქვენგანი,
გამოყენებით CS50 ბიბლიოთეკა, უკვე ჩამოდის მეხსიერება.
თქვენ უკვე სვამს ოპერაციული სისტემა მეხსიერება უმეტეს პროგრამები
თქვენ წერილობითი, მაგრამ თქვენ არასოდეს რეალურად მისცა მას უკან.
თქვენ მოუწოდა GetString და GetInt და GetFloat,
მაგრამ GetString, თქვენ არასოდეს მოუწოდა ungetstring და მიეცით
სიმებიანი უკან ან მოსწონს, მაგრამ ჩვენ ვნახეთ რომ GetString ამჯამად გამოყოს მეხსიერება
გზით malloc ან ამ ფუნქცია realloc, რომელიც მხოლოდ
ძალიან მსგავსი სულისკვეთება, და მაინც, ჩვენ უკვე
გეკითხებით ოპერაციული სისტემა მეხსიერება და მეხსიერების ისევ და ისევ
მაგრამ არასოდეს ვაძლევთ მას უკან.
>> ახლა, როგორც განზე, გამოდის, რომ როდესაც პროგრამა ტოვებს, ყველა მეხსიერების
ავტომატურად გათავისუფლდა.
ასე რომ, ეს არ იყო დიდი გარიგება.
ის არ აპირებს დაარღვიოს IDE და ნელი რამ down,
მაგრამ როდესაც პროგრამების ზოგადად გაჟონვის მეხსიერება
და ისინი გაშვებული დიდი ხანია.
თუ თქვენ ოდესმე მინახავს სულელური პატარა beach ბურთი Mac OS ან hourglass
on Windows, სადაც ეს არის სახის შენელებისა ან ფიქრი და აზროვნება
ან უბრალოდ რეალურად იწყება ნელი Crawl,
ეს ძალიან შესაძლოა შეიძლება იყოს შედეგად მეხსიერების გაჟონვის.
პროგრამისტები, რომელმაც დაწერა პროგრამული უზრუნველყოფა თქვენ იყენებთ
ვთხოვთ ოპერაციული სისტემის მეხსიერება ყოველ რამდენიმე წუთში, საათში ერთხელ.
მაგრამ თუ თქვენ გაშვებული პროგრამული უზრუნველყოფა, მაშინაც კი, თუ ეს
შემცირებით თქვენს კომპიუტერში საათი ან დღის ბოლოს,
თქვენ შეიძლება ითხოვს უფრო და უფრო მეხსიერება და არასოდეს რეალურად გამოყენება
და ასე რომ თქვენი კოდი შეიძლება იყოს, ან პროგრამები შეიძლება ჩამოდის მეხსიერება,
და თუ დაიწყება გაჟონვის მეხსიერება, იქ ნაკლები მეხსიერების სხვა პროგრამები,
და ეფექტი ნელი ყველაფერი ქვევით.
>> ახლა, ეს არის გაცილებით ერთი ყველაზე სასტიკი პროგრამები
თქვენ გექნებათ შესაძლებლობა აწარმოებს CS50 იმდენად, რამდენადაც
როგორც მისი გამომავალი კიდევ უფრო ეზოთერულ ვიდრე clang ის ან ის ან რომელიმე ბრძანება
ხაზის პროგრამების ჩვენ აწარმოებს ადრე, მაგრამ საბედნიეროდ, ჩართული მისი გამომუშავება
არის რაღაც სუპერ სასარგებლო რჩევა, რომ სასარგებლო იქნება არც PSet ოთხ
ან რა თქმა უნდა pset ხუთ.
ასე რომ, valgrind არის ინსტრუმენტი რომელიც შეიძლება იქნას გამოყენებული უნდა ვეძებოთ
მეხსიერების ტბები თქვენი პროგრამა.
ეს შედარებით მარტივი აწარმოებს.
თქვენ აწარმოებს valgrind და შემდეგ, მიუხედავად იმისა, მიუხედავად იმისა, რომ ეს არის პატარა verbose,
dash dash გაჟონვის გამშვები უდრის სრული, და შემდეგ dot
სლეში და სახელი თქვენი პროგრამა.
ასე რომ, valgrind მაშინ აწარმოებს თქვენი პროგრამის და ძალიან დასასრულს თქვენი პროგრამა
გაშვებული სანამ იგი ტოვებს და გაძლევთ კიდევ ერთი სწრაფი,
ის აპირებს ანალიზი თქვენი პროგრამა ხოლო ის გაშვებული
და გითხრათ, არც თქვენ გაჟონვის ნებისმიერი მეხსიერების და კიდევ უკეთესი,
არ შეეხოთ მეხსიერება, არ გეკუთვნის?
მას არ შეუძლია დაჭერა ყველაფერი, მაგრამ ეს საკმაოდ კარგად გამოჭერის საუკეთესო რამ.
>> ასე რომ, აქ არის მაგალითი ჩემი რომელსაც პერსპექტივაში ეს პროგრამა, რომელსაც აწარმოებს valgrind,
პროგრამას მოუწოდა მეხსიერება, და მე ვაპირებ
ხაზი გავუსვა ხაზი, რომ საბოლოოდ ინტერესი ჩვენთვის.
ასე რომ, კიდევ უფრო distractions რომ მე წაიშლება slide.
მაგრამ მოდით უბრალოდ ვნახოთ რა ეს პროგრამა შეუძლია გვეუბნებოდა.
ეს შეუძლია გვეუბნება, რამ როგორიცაა არასწორი ჩაწერის საქართველოს ზომა 4.
სხვა სიტყვებით, თუ შეეხოთ მეხსიერება, კონკრეტულად 4 ბაიტი მეხსიერება
რომ თქვენ არ უნდა ჰქონდეს, valgrind შემიძლია გითხრათ, რომ.
არასწორი ჩაწერის საქართველოს ზომა 4.
თქვენ შეეხო ოთხი ბაიტი რომ თქვენ არ უნდა ჰქონდეს.
სად ამის გაკეთება?
ეს არის სილამაზე.
Memory dot გ ხაზი 21, სადაც თქვენ ბრალია და ამიტომ სასარგებლოა.
ისევე GDB, მას შეუძლია დაეხმაროს აღვნიშნო, რომ თქვენ ფაქტობრივი შეცდომა.
>> ახლა, ამ ერთი ცოტა მეტი verbose, თუ არა გაუგებარია.
40 bytes in 1 ბლოკები ნამდვილად დაკარგული ზარალის ჩანაწერი 1 1.
რას ნიშნავს ეს?
ისე, ეს მხოლოდ იმას ნიშნავს, თქვენ სთხოვა 40 bytes და უკან არ დაუბრუნებიათ.
თქვენ მოუწოდა malloc ან თქვენ მოუწოდა GetString და ოპერაციული სისტემა
მისცა თქვენ 40 ბაიტი, მაგრამ თქვენ არასოდეს გამოთავისუფლებული ან გაათავისუფლეს, რომ მეხსიერება,
და იყოს სამართლიანი, ჩვენ არასოდეს თუ როგორ, რათა უკან მეხსიერება.
თურმე არსებობს სუპერ მარტივი ფუნქცია მოუწოდა უფასოდ.
იღებს ერთი არგუმენტი, რაც გსურთ გასათავისუფლებლად და მისცეს უკან,
მაგრამ 40 ბაიტი, როგორც ჩანს, ამ პროგრამაში
დაიკარგა ხაზი 20 მეხსიერების dot გ.
>> მოდით ვნახოთ ეს პროგრამა.
ეს არის სუპერ აზრი არ აქვს.
ეს მხოლოდ იმაზე მეტყველებს, ეს შეცდომა.
მოდით შევხედოთ.
აქ არის ძირითადი და მთავარი, შეტყობინება, ზარები ფუნქცია მოუწოდა ვ და შემდეგ ბრუნდება.
ასე რომ, არ არის ყველა, რომ საინტერესო.
რას ვ გავაკეთოთ?
ყურადღება მიაქციეთ, მე არ გადაიტვირთოთ პროტოტიპი.
მინდოდა, რომ შევინარჩუნოთ კოდი მინიმალური, რაც შეიძლება.
ასე რომ, მე დააყენა f ზემოთ ძირითადი და ეს ჯარიმა, რა თქმა უნდა,
მოკლე პროგრამების მოსწონს ეს.
ასე რომ, ვ არ დაბრუნდება, და აკეთებს არა არაფერი, მაგრამ ეს არ გააკეთოს ეს.
იგი აცხადებს, ჰგავს ამ Binky მაგალითად,
მაჩვენებელი მოუწოდა x, რომ აპირებს შესანახად მისამართი int.
ასე რომ მარცხენა მხარეს.
ინგლისური, რა არის მარჯვენა მხარეს აკეთებს?
ვინმე?
რა არის ეს აკეთებენ?
ჰო?
>> აუდიტორია: [INAUDIBLE] ჯერ ზომა int
რაც 10 ჯერ რომ [INAUDIBLE]
დავით Malan: კარგი და ნება მომეცით შეაჯამებს.
ასე რომ გამოყოს საკმარისი სივრცე 10 რიცხვებით ან 10, რა ზომის int,
ეს ოთხი ბაიტი, ამიტომ 10 ჯერ 4 40, ისე, რომ მარჯვენა მხარეს, რომ მე
ხაზგასმით მომეცი 40 bytes და შესანახად მისამართი პირველი byte
შევიდა x.
და ახლა, ბოლოს, და აქ, სადაც ამ პროგრამის buggy, რა არის
არასწორი line 21 საფუძველზე, რომ ლოგიკა?
რა არის არასწორი ხაზი 21?
ჰო?
აუდიტორია: თქვენ ვერ ინდექსი შევიდა x [INAUDIBLE].
დავით Malan: ჰო.
მე არ უნდა ინდექსი შევიდა x როგორიცაა, რომ.
ასე რომ, სინტაქსურად, რომ კარგადაა.
რა არის ლამაზი არის, ჰგავს თუ არა შეიძლება მკურნალობა სახელი მასივი
თითქოს ეს მაჩვენებელი, ასეთივე შეგიძლიათ მკურნალობა მაჩვენებელი, თუმცა ეს
მასივი, და ასე შემიძლია სინტაქსურად ამბობენ x bracket რაღაც, x bracket i,
მაგრამ 10 არის პრობლემატური.
რატომ?
>> აუდიტორია: იმიტომ, რომ ეს არ არის შიგნით.
>> დავით Malan: ეს არ არის შიგნით რომ ბლოკი მეხსიერება.
რა არის უდიდესი მნიშვნელობა მე უნდა აყენებს იმ კვადრატულ ფრჩხილებში?
9, 0 მეშვეობით 9.
იმის გამო, რომ ნულოვანი ინდექსირებას.
ასე რომ, 0 მეშვეობით 9 იქნება ჯარიმა.
Bracket 10 არ არის კარგი და მაგრამ გავიხსენოთ, მიუხედავად იმისა, რომ, ყოველ ჯერზე
მე, როგორც ჩანს ცდილობენ, რათა CS50 IDE ავარიის აკრეფით ყალბი ფასეულობების,
ეს ყოველთვის არ ითანამშრომლებს, და მართლაც, ხშირად
მიიღეთ გაუმართლა მხოლოდ იმიტომ, რომ ოპერაციული სისტემა არ
შეამჩნია, რომ თქვენ ოდესმე ისე ოდნავ გაივლის რამდენიმე ბლოკი მეხსიერება,
იმიტომ, რომ თქვენ დარჩა ფარგლებში ტექნიკურად თქვენი სეგმენტი, მაგრამ უფრო, რომ
ოპერაციული სისტემები კლასი, და ამიტომ რაღაც ეს
შეიძლება ძალიან ადვილად წავიდეს undetected.
შენი პროგრამა არასდროს ავარიული თანმიმდევრულად, მაგრამ იქნებ ერთხელ awhile.
>> ასე რომ, მოდით ცდილობენ valgrind ამ, და აქ არის
სადაც ჩვენ კიდევ overwhelmed გამოშვება მომენტალურად.
ასე რომ მეხსიერება valgrind გაჟონვის გამშვები შეადგენს სავსე dot ხაზი მეხსიერება.
და აი რატომ მე გპირდებით, ეს ბევრად გადააჭარბებს.
აი რა valgrind, აქ არის ის, რაც პროგრამისტი, რამდენიმე წლის წინ-
გადაწყვიტა, რომ ეს იქნება კარგი იდეა გამომავალი გამოიყურებოდეს.
მოდით აზრი ამ.
ასე რომ, ყველა გზა მარცხენა მხარეს არ არის კარგი მიზეზი
არის პროცესი ID პროგრამა ჩვენ მხოლოდ აწარმოებს, უნიკალური იდენტიფიკატორი
იმ პროგრამას, უბრალოდ გაიქცა.
ჩვენ წაიშალოს, რომ slide, მაგრამ არსებობს
არის რამდენიმე სასარგებლო ინფორმაციას აქ.
>> მოდით გადახვევა მდე ძალიან ზევით.
აქ, სადაც ჩვენ დავიწყეთ.
ასე რომ, ეს არ არის, რომ ბევრი გამომუშავება.
აი, რომ არასწორი ჩაწერის ზომა 4 on line 21.
ისე, რა იყო ხაზი 21?
Line 21 იყო ზუსტად და ეს აზრი
რომ მე საფუძვლიანად წერა 4 ბაიტი, რადგან მე ვარ
ცდილობს, რომ ეს რიცხვი, რომელიც შეიძლება იყოს არაფერი,
ეს რაღაც უნდა იყოს ნულოვანი, მაგრამ ვცდილობ
იმისათვის, რომ ეს იმ ადგილას, რომ არ მეკუთვნის.
უფრო მეტიც, აქ ქვემოთ, 40 bytes ერთ ბლოკის ნამდვილად წააგო ჩანაწერი 1.
ეს იმიტომ, რომ, როდესაც მე მოვუწოდებ malloc აქ, მე არასოდეს რეალურად გასათავისუფლებლად მეხსიერება.
>> ასე როგორ შეიძლება მოვაგვაროთ ეს პრობლემა?
ნება მომეცით წავიდეთ წინ და იყოს ცოტა უფრო უსაფრთხო და ამის გაკეთება 9 იქ და მე აქ უფასოდ x.
ეს არის ახალი ფუნქცია დღეს.
თუ მე ახლა გამეორება მიიღოს მეხსიერება dot ხაზი, მოდით აწარმოებს valgrind on კიდევ ერთხელ,
მაქსიმალურად ჩემი ფანჯრის და დააჭიროთ.
ახლა, ეს არის კარგი.
მათ დასამარხავად კარგი ამბავი ყველა ამ გამომავალი.
ყველა ბევრი ბლოკად თავისუფალი იყო.
ჩვენ დავბრუნდებით, თუ რა ბევრი არის, მაგრამ არ გაჟონვის შესაძლებელია.
ასე რომ, ეს არის კიდევ ერთი ინსტრუმენტი თქვენი ინსტრუმენტი ნაკრები
რომლითაც შეგიძლიათ დაიწყოს მოვძებნოთ ახლა შეცდომები, როგორიცაა, რომ.
>> მაგრამ ვნახოთ, რა კიდევ შეიძლება წავიდეთ არასწორი აქ.
მოდით გარდამავალი ახლა რეალურად გადაჭრის პრობლემას.
როგორც განზე, თუ ეს იქნება გაათავისუფლოს ცოტა დაბნეულობა და დაძაბულობა,
ეს არის სასაცილო.
ჰო.
ეს არის საკმაოდ კარგი.
იმის გამო, რომ მითითებები მისამართები და მისამართები
ზოგადად კონვენციის დაწერილია თექვსმეტობითი.
ჰა, ჰა, ეს არის სასაცილო ახლა.
ყოველ შემთხვევაში, ასე რომ, მოდით ახლა რეალურად პრობლემის გადაჭრას.
ეს უკვე სუპერ, სუპერ დაბალი დონის დღემდე,
და ჩვენ შეგვიძლია რეალურად სასარგებლო რამ ამ დაბალი დონის დეტალები.
>> ამიტომ, ჩვენ გააცნო რამდენიმე კვირის განმავლობაში წინ ცნება მასივი.
მასივი იყო ლამაზი იმიტომ, რომ ძნელია გაწმენდა ჩვენი კოდი
იმიტომ, რომ თუ ჩვენ მინდოდა დაწერა პროგრამა მრავალჯერადი სტუდენტები
ან მრავალჯერადი სახელები და სახლები და dorms და კოლეჯებში და ყველა რომ,
ჩვენ შეგვიძლია შესანახად ყველაფერი უფრო სუფთად შიგნით მასივი.
მაგრამ შესთავაზოს ერთი downside მასივი დღემდე.
მაშინაც კი, თუ თქვენ არ განიცადა, რომ საკუთარ თავს პროგრამა, მხოლოდ ინსტინქტურად,
რა არის ცუდი რამ მასივი, ალბათ?
მე მესმის, ზოგიერთი murmurs.
აუდიტორია: ეს არის რთული შეცვალოს ზომა.
დავით Malan: ეს არის რთული შეცვალოს ზომა.
თქვენ არ შეგიძლიათ შეცვალოთ ზომა მასივი, ფაქტობრივად, თავისთავად
C. თქვენ შეიძლება გამოიყოს ერთი მასივი, გადაადგილება ყველაფერი ძველის
ახალ, და ახლა აქვს რამდენიმე დამატებითი ფართი,
მაგრამ ეს იმას არ ნიშნავს, ენის როგორიცაა Java და Python
ან ნებისმიერი რაოდენობის სხვა ენების რომელთანაც ზოგიერთ თქვენგანს
შეიძლება იყოს ნაცნობი, სადაც თქვენ შეგიძლიათ უბრალოდ შეინახოს დასძინა რამ
რეკლამა nauseam ბოლომდე მასივი.
როდესაც თქვენ გაქვთ მასივი ზომა 6, რომ არის მისი ზომა,
და იმდენად მოსწონს იდეა ადრე რომელსაც ბუფერული გარკვეული ზომა,
თქვენ უნდა გამოვიცნოთ გარეთ კარიბჭე რა ზომა გინდა, რომ იყოს?
თუ მიხვდები ძალიან დიდი, თქვენ გაყვანაა სივრცეში.
თუ მიხვდები ძალიან მცირე, თქვენ ვერ შეინახავს, ​​რომ მონაცემები, მინიმუმ
გარეშე გაცილებით მეტი მუშაობა.
>> ასე რომ, დღეს, მადლობა მითითებას, ჩვენ შეგვიძლია დაიწყოს stitching ერთად ჩვენი საკუთარი
მონაცემთა სტრუქტურები და ფაქტობრივად, აქ არის ის,
რომ გამოიყურება ცოტა მეტი cryptic ერთი შეხედვით,
მაგრამ ეს არის ის, რაც ჩვენ მოვუწოდებთ უკავშირდება სია, და მისი სახელი სახის შეაჯამა
მას.
ეს არის ჩამონათვალი ნომრები, ან ამ შემთხვევაში, სიაში ნომრები,
მაგრამ ეს შეიძლება იყოს სიაში არაფერი, მაგრამ ის გაერთიანებულს გზა ისრებით,
და უბრალოდ ვხვდები ერთად რა ტექნიკა
ჩვენ ვაპირებთ, რომ შეძლებს სტიჩი ერთად,
ერთგვარი მოსწონს პოპკორნი ძაფი, დაკავშირებული სიები ოთხკუთხედს აქ?
მისი ნომრები?
რა არის ძირითადი ენის ფუნქცია?
>> აუდიტორია: A მაჩვენებელი.
>> DAVID Malan: მაჩვენებელი.
ასე რომ თითოეული ეს ისრები აქ წარმოადგენს მომცეთ ან უბრალოდ მისამართზე.
სხვა სიტყვებით, თუ მინდა, შესანახად სიაში ნომრები,
მე არ შემიძლია უბრალოდ შეინახოს იგი, თუ მინდა, უნარი იზრდება და მცირდება
ჩემი მონაცემები სტრუქტურა მასივი.
ასე რომ, მე უნდა ცოტა უფრო დახვეწილობის,
მაგრამ შეამჩნია, რომ ეს სურათი სახის ვარაუდობს
იმ შემთხვევაში, თუ თქვენ უბრალოდ მიიღო პატარა თემა დამაკავშირებელი ყველაფერი ერთად,
ალბათ არ არის, რომ იმისთვის, რომ სივრცე შორის ორი ამ ოთხკუთხედს
ან ორი იმ კვანძების, როგორც ჩვენ დავიწყებთ მოუწოდებდა მათ, დააყენა ახალი კვანძის,
და შემდეგ რამდენიმე ახალი თემა, უბრალოდ ditch სამი კვანძების ერთად,
პირველი, ბოლო ერთი, და ერთი რომ თქვენ უბრალოდ ჩასმული შევიდა შუა.
>> და მართლაც უკავშირდება სია, განსხვავებით მასივი, არის დინამიური.
ეს შეიძლება გაიზარდოს და მას შეუძლია შემცირება და თქვენ არ
უნდა ვიცი და არც მაინტერესებს, წინასწარ როგორ რამდენად მონაცემები თქვენ ვაპირებთ იყოს შენახვის,
მაგრამ აღმოჩნდება, რომ ჩვენ უნდა იყოს პატარა ფრთხილად, თუ როგორ უნდა განახორციელოს ეს.
ასე რომ, პირველი მოდით განიხილავს, თუ როგორ განვახორციელოთ ერთი ამ პატარა ოთხკუთხედს.
ეს არის მარტივი განხორციელება int.
თქვენ უბრალოდ ამბობენ int n და შემდეგ თქვენ 4 ბაიტი int,
მაგრამ როგორ მივიღებ int, ეძახით n, და მაშინ მაჩვენებელი, მოდით, მას შემდეგ.
ჩვენ ხომ ამ რამ არაფერი გვინდა
მაგრამ მე უნდა საბაჟო მონაცემთა სტრუქტურას.
ჰო?
>> აუდიტორია: Ampersand [INAUDIBLE].
>> დავით Malan: ასე ampersand ჩვენ გამოვიყენებთ მიიღეთ მისამართი კვანძის პოტენციურად.
მაგრამ ჩვენ გვჭირდება კიდევ ერთი თვისება C, რათა
მომეცი უნარი შექმნას ამ საბაჟო მართკუთხედი, ამ საბაჟო
ცვლადი თუ გნებავთ, მეხსიერებაში.
აუდიტორია: A struct.
DAVID Malan: struct.
შეგახსენებთ, გასულ კვირას, ჩვენ გააცნო struct, ეს შედარებით მარტივი სიტყვით
რომელიც საშუალებას გვაძლევს, რათა მსგავსი რამ.
C არ მოდის მონაცემები სტრუქტურა მოუწოდა სტუდენტი.
მას გააჩნია int და ათწილადი და char და ასეთი, მაგრამ ეს არ მოვა სტუდენტი,
მაგრამ ჩვენ შეგვიძლია შევქმნათ სტუდენტი მონაცემები ტიპის, სტუდენტი სტრუქტურა, ეს სინტაქსი
აქ.
და დაინახავთ ეს ისევ და ისევ.
ასე რომ არ ინერვიულოთ შესახებ იმახსოვრებდა სიტყვა,
მაგრამ სიტყვით რომ მნიშვნელოვანია, მხოლოდ ის ფაქტი, რომ ჩვენ განაცხადა struct
და მაშინ ჩვენ მას სტუდენტი და შიგნით სტუდენტი იყო სახელი და სახლის
ან საცხოვრებლის ან მოსწონს.
>> ასე რომ, ახლა, დღეს, მოდით შესთავაზოს ამ.
მე დასძინა რამდენიმე სიტყვა, მაგრამ მე მინდა, განახორციელოს ამ მართკუთხედის, რომ
მივიღე ორივე int და მაჩვენებელი, თქვენ იცით, რა, მე ვარ
აპირებს გამოაცხადოს struct მოუწოდა კვანძის.
მე ასევე, შიგნით, ვაპირებ ვთქვა რომ კვანძის, ეს ოთხკუთხედი, აქვს int
და ჩვენ ამას ეძახით n და მას აქვს შემდეგი მაჩვენებელი.
ეს არის პატარა verbose, მაგრამ თუ თქვენ ფიქრობთ ამის შესახებ,
ისრებით, რომლებიც სურათზე მომენტში წინ არიან რა მონაცემების ტიპის?
სადაც თითოეული ისრებით მიუთითებს რა ტიპის სტრუქტურის მონაცემები?
ეს არ მიუთითებს მხოლოდ int, თავისთავად.
ეს მიუთითებს, რომ მთელი მართკუთხა რამ
და რომ მართკუთხა რამ, ჩვენ ვთქვით, ეწოდება კვანძის.
ასე რომ, ჩვენ ასეთი უნდა რეკურსიული განსაზღვრავს ასეთი
რომ კვანძში, ჩვენ უნდა ვთქვა, შეიცავს int მოუწოდა N
და კურსორი მოუწოდა შემდეგი და ტიპის მონაცემთა სტრუქტურის, რომლის
რომ მაჩვენებელი მიუთითებს, როგორც ჩანს, იქნება struct კვანძში.
>> ასე რომ, ეს არის annoyingly verbose და უბრალოდ უნდა იყოს pedantic,
მიზეზი, რის გამოც ჩვენ არ შეგვიძლია უბრალოდ ვიტყვი, რომ ეს, რაც გულწრფელად
გამოიყურება უფრო იკითხება, იმიტომ, რომ შეგახსენებთ, რომ C წაკითხული
რამ ზემოდან, მარცხნიდან მარჯვნივ.
ეს არ არის, სანამ ჩვენ მძიმით რომ სიტყვით კვანძის რეალურად არსებობს.
ასე რომ, თუ ჩვენ გვინდა, რომ ამ სახის ციკლური მინიშნება შიგნით მონაცემთა
სტრუქტურა, ჩვენ უნდა გავაკეთოთ ეს, სადაც ვთქვათ struct კვანძის ზედა, რომელიც
გვაძლევს აღარ გზას აღწერს ამ რამ, მაშინ შიგნით ვთქვათ struct კვანძის,
და შემდეგ ძალიან ბოლო ხაზი ჩვენ ვამბობთ, ყველა უფლება, C, სხვათა შორის,
დარეკეთ მხოლოდ ამ მთელი რა რამ კვანძის და შეწყვიტოს
გამოყენებით სიტყვით struct საერთოდ.
ასე რომ, ეს მხოლოდ ერთგვარი სინტაქსური შეასრულა, რომელიც, საბოლოო ჯამში, საშუალებას გვაძლევს შევქმნათ
რაღაც რომ გამოიყურება ზუსტად მოსწონს ეს.
>> ასე რომ, თუ ჩვენ ვივარაუდოთ, ახლა ჩვენ შეგვიძლია განხორციელების რამ C,
როგორ გავაკეთოთ ჩვენ, ფაქტობრივად დაიწყოს გადიოდა ეს?
ისე, ფაქტია, რომ ყველა ჩვენ უნდა გავაკეთოთ არის iterate მარცხნიდან მარჯვნივ და მხოლოდ
სახის ჩადეთ კვანძების ან წაშლა კვანძების ან მოძებნოთ ნივთები, სადაც ჩვენ გვინდა,
მაგრამ ამის გაკეთება, მოდით, წავიდეთ წინ და რამ ცოტა უფრო რეალური, რადგან ეს
უკვე სუპერ დაბალი დონის დღემდე.
არავის სიტყვასიტყვით მინდა იყოს პირველი?
OK.
კარგით up.
რა გქვია?
>> DAVID: დავით.
დავით Malan: დავით.
კარგია თქვენთან შეხვედრა.
მეც.
ყველა უფლება.
და ჩვენ გვჭირდება 9 ნომერი.
არ არის, როგორც პირველი, ალბათ.
OK, ნომერი 9.
ნომერი 17, გთხოვთ.
ნება მომეცით დაბრუნდეს მცირედ.
ხმების 22, გთხოვთ, და როგორ შესახებ უფრო უკან
თუ შემიძლია ვხედავ ხელში ყველა ნათელი და არ არის.
ვინმეს მიმდინარეობს მოხალისეებად უფლება არსებობს.
გსურთ ამუშავება?
შენი მხარის მიერ იძულებით იზრდებოდა.
OK, 17.
22.
26 მოდის ქვემოთ.
განა ვინმეს მინდა forcefully-- ამოდი.
ფაქტობრივი მოხალისე.
>> ასე რომ ძალიან სწრაფად, თუ თქვენ ბიჭები შეიძლება მოეწყოს
საკუთარი თავი, ისევე, როგორც კვანძების ეკრანზე.
დიდი მადლობა.
და თქვენ უნდა 26.
ყველა უფლება და სწრაფი გაცნობა.
ასე რომ, მე დავით თქვენ ასევე?
DAVID: დავით.
დავით Malan: თქვენ?
Jake: Jake.
SUE: Sue.
ALEX: ალექს.
RAPHAEL: რაფაელ.
TAYLOR: Taylor.
დავით Malan: Taylor.
შესანიშნავი.
ასე რომ, ეს არის ჩვენი მოხალისეები დღეს და წავიდეთ წინ
და გადაიტანოს ცოტა რომ გზა, და მხოლოდ წავიდეთ წინ და შენარჩუნება
ჩატარების თქვენი ნომრები, როგორც თქვენ და თქვენი პირველი ნიშანი და გამოყენებით თქვენი მარცხენა ხელის,
წავიდეთ წინ და მხოლოდ განახორციელოს ამ ისრებით, უბრალოდ
ისე, რომ თქვენი მარცხენა ხელის ფაქტიურად მიუთითებს, რასაც თქვენ უნდა აღვნიშნო,
ზე, და მისცეს საკუთარ თავს გარკვეული ოთახში ისე, რომ ჩვენ შეგვიძლია ვიზუალურად ვხედავ თქვენი იარაღი რეალურად
მიუთითებს, და თქვენ შეგიძლიათ უბრალოდ აღვნიშნო ერთგვარი ადგილზე კარგად არის.
>> ასე რომ აქ გვაქვს უკავშირდება სიაში ერთი, ორი, სამი, ოთხი, ხუთი კვანძების თავდაპირველად,
და შენიშნავს, ჩვენ ამ სპეციალური მაჩვენებელი დასაწყისში ვინ არის
გასაღები იმიტომ, რომ ჩვენ უნდა შევინარჩუნოთ სიმღერა საქართველოს მთელ სიგრძეზე სიაში რატომღაც.
ეს ბიჭები, მიუხედავად იმისა, რომ ისინი დატოვა მარჯვნივ, უკან დაბრუნება მეხსიერება,
მათ შეუძლიათ რეალურად იყოს სადმე კომპიუტერის მეხსიერებაში.
ასე რომ, ეს ბიჭები შეიძლება იდგა ყველგან სცენაზე
და ეს ჯარიმა, ასე რომ სანამ ისინი რეალურად მიუთითებს ერთმანეთს,
მაგრამ შენარჩუნება რამ სუფთა და მარტივი, ჩვენ გამოგიგზავნით
უბრალოდ მიაპყროს მათ მარცხნიდან მარჯვნივ, როგორიცაა ეს, მაგრამ არ შეიძლება იყოს მასიური ხარვეზები
შორის იმ კვანძების.
>> ახლა, თუ გვინდა, რომ რეალურად ჩადეთ ზოგიერთი ახალი ღირებულება, მოდით წავიდეთ წინ და ამის გაკეთება.
ჩვენ გვაქვს შესაძლებლობა ახლა აირჩიეთ სხვა კვანძის.
ამბობენ, რომ დავიწყოთ off ერთად mallocing 55.
ნუთუ ვინმე იბადება, რომ malloc?
OK, მოდის up.
რა გქვია?
RAINBOW: Rainbow.
დავით Malan: Rainbow?
ყველა უფლება.
Malloc Rainbow.
კარგით up.
ასე რომ, ახლა ჩვენ უნდა ვკითხოთ საკუთარ თავს, ალგორითმულად, სადაც ჩვენ შეგვიძლია ვთქვათ 55.
ასე რომ, ყველამ იცის, ცხადია, სადაც ის, ალბათ,
ეკუთვნის თუ ჩვენ ვცდილობთ, შენარჩუნება ამ დახარისხებული
და თუ ბიჭები შეიძლება ერთი უკან დახევას ასე რომ, ჩვენ არ დაეცემა
ეტაპზე, რომ კარგი იქნება.
ასე რომ, რეალურად, Rainbow, დაიწყოს დასრულდა აქ ჩემთან ერთად,
იმიტომ, რომ ჩვენ, როგორც კომპიუტერული ახლა შეუძლია მხოლოდ ერთი ცვლადის დროს.
ასე რომ, თუ ეს არის პირველი კვანძი.
გაითვალისწინეთ, ის არ არის კვანძი, ის მხოლოდ მაჩვენებელი,
და ამიტომაც ის შედგენილი უნდა იყოს მხოლოდ ზომის მაჩვენებელი, არ
ერთ-ერთი იმ სრული ოთხკუთხედს.
ასე რომ, ჩვენ ვაპირებთ, რათა შეამოწმოს ყოველ იტერაციული 55 ნაკლებია, ვიდრე 9?
No.
55-ზე ნაკლები 17?
No.
ნაკლებია, ვიდრე 22?
ნაკლებია, ვიდრე 26?
ნაკლებია, ვიდრე 34?
ასე რომ, ახლა, ცხადია, Rainbow ეკუთვნის დასასრულს.
ასე უნდა იყოს მკაფიო და რა იყო თქვენი სახელი, Taylor?
>> TAYLOR: Taylor.
დავით Malan: ასე შორის ტეილორის მარცხენა და Rainbow ხელში აქ,
რომლის მხრივ უნდა აღვნიშნო, რა შეკვეთა ჩადეთ 55 შევიდა ამ სიაში?
ჩვენ რა უნდა გავაკეთოთ?
ჰო?
>> აუდიტორია: Taylor ხელი უნდა აღვნიშნო მარცხენა.
>> დავით Malan: ზუსტად.
ასე რომ ჩასმა კვანძის შევიდა ბოლოს სია
არის საკმაოდ მარტივია, რადგან Taylor მხოლოდ უნდა აღვნიშნო, ნაცვლად ადგილზე
ან ჩვენ მოვუწოდებთ მას null, null არის ერთგვარი არარსებობის
მაჩვენებელი ან სპეციალური ნულოვანი მაჩვენებელი, თქვენ
აპირებს აღვნიშნო თქვენი მარცხენა ხელი Rainbow და შემდეგ Rainbow,
სადაც უნდა თქვენი მარცხენა მხრივ, ალბათ, აღვნიშნო?
Down.
ეს არ არის კარგი, თუ თავის მხრივ, არის ერთგვარი მიუთითებს off აქ და სახის ნებისმიერი
რომელიც გზას.
რომ განიხილება ნაგვის ღირებულება,
მაგრამ თუ იგი მიუთითებს, რომ ზოგიერთი ცნობილი მნიშვნელობა, ჩვენ
ეძახით ნულოვანი ან null, რომ კარგადაა იმიტომ რომ ჩვენ გვაქვს ტერმინის ამ
და ჩვენ ვიცით, სიაში ახლა არის სრული.
>> ასე რომ, რა არის კიდევ ერთი შედარებით მარტივი საქმე?
შეიძლება ჩვენ malloc 5?
კარგით up.
რა გქვია?
TIFFANY: Tiffany.
დავით Malan: მე ბოდიში?
TIFFANY: Tiffany.
დავით Malan: Tiffany.
ყველა უფლება.
Tiffany უკვე malloced ღირებულების 5.
კარგით up.
ეს ერთ-ერთი შედარებით ადვილია, მაგრამ განვიხილოთ ბრძანებით ოპერაციების ახლა.
ეს საკმაოდ ადვილი იყო ტეილორი ბოლოს.
ნომერი 5, რა თქმა უნდა ნაკლები 9, და ამიტომ ჩვენ უნდა David, ჩვენ Tiffany,
და რა იყო თქვენი სახელი?
>> Jake: Jake.
>> დავით Malan: Jake.
Tiffany, Jake და დავით.
ვისი ხელით უნდა განახლდეს პირველი?
რა გინდა აქ?
არსებობს რამდენიმე შესაძლო გზები, მაგრამ არსებობს ასევე ერთი ან მეტი არასწორი გზა.
>> აუდიტორია: დაწყება leftmost.
>> დავით Malan: დაწყება leftmost.
ვინ არის leftmost აქ?
აუდიტორია: პირველი.
>> დავით Malan: OK.
ასე იწყება პირველი და სად გსურთ განაახლოთ დავითის ხელში უნდა იყოს?
აუდიტორია: Towards 5.
დავით Malan: OK.
დავითმა, პუნქტი ხუთ ან Tiffany აქ და ახლა?
>> აუდიტორია: Tiffany მიუთითებს 9?
დავით Malan: Perfect, გარდა Binky ს უფროსი უბრალოდ სახის დაეცა off, არა?
იმის გამო, რომ, რა არის ცუდი ამ სურათს ფაქტიურად?
აუდიტორია: არაფერი მიუთითებს.
დავით Malan: არაფერი არ არის მიუთითებს Jake ახლა.
ჩვენ სიტყვასიტყვით ობოლი 9 და 17 და ჩვენ ფაქტიურად
გაჟონა ყველა ამ მეხსიერების, რადგან ის მიერ განახლება დავითს ხელში პირველი, რომ
ჯარიმა იმდენად, რამდენადაც ეს არის სწორად მიუთითებს Tiffany ახლა,
მაგრამ თუ არავის ჰქონდა foresight აღვნიშნო Jake,
მაშინ ჩვენ დავკარგეთ მთლიანად რომ სიაში.
მოდით გაუქმება.
ასე რომ, კარგია მოგზაურობა დასრულდა მაგრამ მოდით გამოსწორებას ახლა.
რა უნდა გავაკეთოთ, პირველ ნაცვლად?
ჰო?
>> აუდიტორია: Tiffany უნდა აღვნიშნო 9?
დავით Malan: მე არ შემიძლია მიიღოს, რომ ახლოს თქვენ.
ვინ უნდა აღვნიშნო 9?
>> აუდიტორია: Tiffany.
>> DAVID Malan ყველა უფლება.
ასე რომ, Tiffany უპირველეს პუნქტი 9.
ასე რომ, Tiffany უნდა მიიღოს იდენტური მნიშვნელობა
დავით, რომელიც, როგორც ჩანს, გადაჭარბებული ერთი წუთით,
მაგრამ ეს ჯარიმა, რადგან ახლა, მეორე ნაბიჯი, ჩვენ შეგვიძლია განახლება დავითს ხელში
აღვნიშნო, Tiffany, და თუ ჩვენ უბრალოდ სახის სუფთა რამ up
იმისა, რომ ეს არის ერთგვარი გაზაფხულზე მსგავსი, ახლა, რომ სწორი ჩანართი.
ასე რომ, შესანიშნავი.
ასე რომ, ახლა ჩვენ თითქმის არ არსებობს.
მოდით ჩადეთ ერთი საბოლოო ღირებულება, როგორიცაა ღირებულება 20.
თუ ჩვენ ვერ malloc ერთი საბოლოო მოხალისე?
კარგით up.
ასე რომ, ეს ერთი არის ცოტა უფრო რთული.
მაგრამ რეალურად, კოდი ჩვენ წერილობით, თუმცა სიტყვიერი,
ისევე, როგორც მქონე bunch საქართველოს თუ პირობებს, უფლება?
ჩვენ გვქონდა მდგომარეობაში შემოწმების თუ მას ეკუთვნის
ბოლოს, შესაძლოა, დასაწყისია.
ჩვენ გვჭირდება გარკვეული სახის მარყუჟის მოძიების ადგილზე შუა.
ასე რომ, მოდით გავაკეთოთ, რომ, რა გქვია?
>> ERIC: Eric.
>> დავით Malan: ერიკ?
ერიკ.
კარგია თქვენთან შეხვედრა.
ასე რომ, ჩვენ გვაქვს 20.
ნაკლებია, ვიდრე ხუთი?
No.
ნაკლებია, ვიდრე ცხრა?
No.
ნაკლებია, ვიდრე 17?
No.
OK.
მას ეკუთვნის აქ და თქვენი სახელები ერთხელ არის?
SUE: Sue.
დავით Malan: Sue.
ALEX: ალექს.
დავით Malan: Sue, ალექსი და?
ERIC: Eric.
დავით Malan: ერიკ.
რომლის ხელში უნდა მიიღოს განახლებული პირველი?
>> აუდიტორია: ერიკ.
OK.
ასე რომ, ერიკ უნდა აღვნიშნო საიდან
22.
კარგი.
და ახლა რა არის შემდეგი?
Sue შემდეგ შეგიძლიათ აღვნიშნო ერიკ და ახლა, თუ ბიჭები მხოლოდ
გარკვეული ოთახი, რომელიც კარგად არის ვიზუალურად, ახლა ჩვენ გავაკეთეთ ჩასაგდები.
მოდით ახლა განიხილოს საკითხი, მაგრამ დიდი მადლობა, რომ ჩვენი მოხალისეები.
ძალიან კარგად გაკეთდეს.
თქვენ შეგიძლიათ შეინახოთ იმ შემთხვევაში, თუ გსურთ.
და ჩვენ გვაქვს ლამაზი განშორება საჩუქარი თუ ნეტავ თითოეული like მიიღოს სტრესი დაადასტურა.
ნება მომეცით, უბრალოდ გაივლის ამ ქვემოთ.
რა არის takeaway ეს?
როგორც ჩანს, ეს იქნება საოცარი იმდენად, რამდენადაც ჩვენ ახლა
გააცნო ალტერნატივა მასივი, რომ ასე არ არის შემოიფარგლება
მასივი გარკვეული ფიქსირებული ზომა.
მათ შეუძლიათ იზრდება დინამიურად ვითარდება.
>> მაგრამ ჰგავს ჩვენ ვნახეთ ამ კვირაში წარსულში, ჩვენ არასოდეს მიიღოთ რამე უფასო,
მოსწონს აუცილებლად არსებობს ვაჭრობის აქ.
ასე რომ, თავდაყირა უკავშირდება სია, ეს დინამიზმი?
ეს უნარი იზრდება და გულწრფელად, შეგვეძლო გავაკეთეთ წაშლა
და ჩვენ შეგვიძლია შემცირება, როგორც საჭიროა.
რა ფასი ჩვენ გადამხდელი?
ორჯერ იმდენი სივრცე, პირველ რიგში.
თუ გადავხედავთ სურათზე, აღარ ვარ შენახვის სიაში რიცხვებით.
მე შენახვის სია რიცხვებით პლუს მითითებას.
ასე რომ, მე გააორმაგოს თანხის სივრცეში.
ახლა, შესაძლოა, ეს არ არის ისეთი დიდი გარიგება 4 ბაიტი, 8 ბაიტი,
მაგრამ ეს შეიძლება რა თქმა უნდა დაემატოს up დიდი მონაცემები კომპლექტი.
რა არის კიდევ ერთი მინუსი?
ჰო?
>> აუდიტორია: ჩვენ უნდა კვეთენ მათ ერთ-by-ერთი.
დავით Malan: ჰო.
ჩვენ უნდა traverse მათ ერთ-by-ერთი.
იცით რა, ჩვენ დათმო ამ სუპერ მოსახერხებელი ფუნქცია კვადრატული ფრჩხილი
ნოტაცია, უფრო სწორად ცნობილია, როგორც შემთხვევითი წვდომის,
სადაც შეგვიძლია მხოლოდ ხტომა ინდივიდუალური ელემენტი
მაგრამ ახლა თუ მე მაინც ჰქონდა ჩემი მოხალისეები აქ,
თუ მინდოდა, რათა იპოვოს 22, მე არ შემიძლია მხოლოდ
გადადით bracket რაღაც რაღაც.
მე უნდა გამოიყურებოდეს მეტი სია, ბევრად ისევე როგორც ჩვენი სამძებრო მაგალითები ხაზოვანი,
მოვძებნოთ ნომერი 22.
ასე რომ, ჩვენ, როგორც ჩანს, არ გადაიხადა ფასი არსებობს.
მაგრამ ჩვენ მაინც სხვა ამოცანების ამოხსნას.
>> ფაქტობრივად, ნება მომეცით წარმოგიდგინოთ მხოლოდ რამდენიმე ვიზუალური.
ასე რომ, თუ თქვენ უკვე ქვემოთ Mather ის სასადილოს ცოტა ხნის წინ,
თქვენ გავიხსენოთ, რომ მათი stacks ქაღალდის, როგორც ეს,
ჩვენ ნასესხები ამ ქვეყნიდან Annenberg ადრე კლასის.
ასე რომ, ეს დასტის ქაღალდის, თუმცა, წარმომადგენელი რეალურად
კომპიუტერულ მეცნიერებათა მონაცემების სტრუქტურას.
არსებობს მონაცემები სტრუქტურა კომპიუტერულ მეცნიერებათა
ცნობილია როგორც დასტის, რომელიც ძალიან ლამაზად lends თავს სწორედ ამ ვიზუალური.
ასე რომ, თუ თითოეული ამ ქაღალდის არ არის უჯრა, მაგრამ ისევე როგორც მთელი რიგი და მინდოდა
შესანახად ნომრები, მე ვერ დააყენა ერთი ქვემოთ აქ,
და მე ვერ დააყენა მეორე ქვემოთ აქ, და გაგრძელდება დაწყობა ნომრები
თავზე ერთმანეთს და რა არის პოტენციურად სასარგებლო ამ
ის არის, რომ რა გავლენა ამ მონაცემების სტრუქტურას?
რომელი ნომერი შემიძლია გაიყვანოს პირველი ყველაზე მოხერხებულად?
ყველაზე ცოტა ხნის წინ ერთ-ერთი დააყენა იქ.
>> ასე რომ, ეს არის ის, რაც ჩვენ მოვუწოდებთ ამ კომპიუტერული მეცნიერების lifo მონაცემთა სტრუქტურას.
ბოლო წელს, პირველი out.
ჩვენ დავინახავთ, სანამ ხანგრძლივი რატომ რომ შეიძლება იყოს სასარგებლო, მაგრამ ახლა,
უბრალოდ განიხილოს ქონება.
და ეს არის ერთგვარი სულელური, თუ ფიქრობთ, იმაზე, თუ როგორ სასადილოს აკეთებს.
ყოველთვის, როდესაც ისინი სუფთა ქაღალდის და ბოლო უახლეს პირობა თავზე,
თქვენ შეიძლება ჰქონდეს ადრე სუფთა მაგრამ საბოლოოდ ძალიან ბინძური და მტვრიან
უჯრა ძალიან ბოლოში თუ თქვენ არასდროს პრაქტიკულად
მისაღებად ბოლოში რომ დასტის, იმიტომ, რომ თქვენ მხოლოდ
შენარჩუნება აყენებს ახალ და სუფთა, ვინც თავზე მას.
იგივე შეიძლება მოხდეს სუპერმარკეტში ძალიან.
თუ თქვენ გაქვთ ჩვენების შემთხვევაში რძე და ყოველ ჯერზე CVS
ან ვინც იღებს უფრო რძე, უბრალოდ მისწვდომოდა რძით
თქვენ უკვე გაქვთ უკან და დააყენა ახლის up წინ,
თქვენ ვაპირებთ აქვს ზოგიერთი საკმაოდ nasty რძე ბოლოს მონაცემთა სტრუქტურა,
რადგან ის ყოველთვის ბოლოში ან ექვივალენტური ის ყოველთვის უკან.
>> მაგრამ არსებობს კიდევ ერთი გზა ვიფიქროთ უგულებელყოფა მონაცემები და მაგალითად, ეს.
თუ თქვენ ერთი იმ ხალხს, ვისაც უყვარს გამოდიან გარეთ Apple მაღაზიები
როდესაც ახალი პროდუქტი მოდის გარეთ, თქვენ ალბათ
არ იყენებთ დასტის მონაცემები სტრუქტურა იმიტომ, რომ თქვენ
გასხვისების ყველას, ვინც არის უგულებელყოფა მდე შეძენა რაღაც ახალი სათამაშო.
უფრო მეტიც, თქვენ ალბათ გამოყენებით რა სახის მონაცემები სტრუქტურა
ან როგორი სისტემა რეალურ სამყაროში?
იმედია, რომ ეს ხაზი, ან მეტი სათანადოდ ან უფრო დიდი ბრიტანეთის მსგავსად, რიგიდან.
და აღმოჩნდება მდგომ ასევე მონაცემთა სტრუქტურის კომპიუტერული მეცნიერების,
მაგრამ რიგი აქვს ძალიან სხვადასხვა ქონება.
ეს არ არის LIFO.
ბოლო წელს, პირველი out.
ღმერთმა ნუ ქნას.
ეს ნაცვლად FIFO.
პირველი, პირველი გარეთ.
და ეს კარგია სამართლიანობისა გულისთვის
რა თქმა უნდა, როდესაც თქვენ უგულებელყოფა up super დილით ადრე.
თუ თქვენ იქ პირველი, თქვენ გსურთ გავიდნენ პირველი ისევე.
>> ასე რომ, ყველა ამ მონაცემების სტრუქტურები, რიგები და stacks
და მტევნების სხვები, თურმე, შეიძლება ვიფიქროთ, რომ ეს მხოლოდ მასივი.
ეს არის მასივი, შესაძლოა, ფიქსირებული ზომა 4, მაგრამ ეს მინდა
იქნება ერთგვარი ლამაზი თუ ჩვენ შეგვიძლია მხოლოდ წყობის ქაღალდის თითქმის უსასრულოდ სიმაღლის თუ ჩვენ
აქვს, რომ ბევრი ქაღალდის ან ციფრები.
ასე რომ, შესაძლოა, ჩვენ გვინდა გამოვიყენოთ დაკავშირებული სიაში აქ,
მაგრამ ვაჭრობის იქნება პოტენციურად, რომ ჩვენ გვჭირდება მეტი მეხსიერების,
იღებს ცოტა მეტი დრო, მაგრამ ჩვენ არ ზღუდავს სიმაღლე დასტის,
ჰგავს Mather ჩვენების შემთხვევაში შეიძლება შეზღუდოს ზომის დასტის,
და ასე რომ ეს არის დიზაინი გადაწყვეტილებები ან პარამეტრები ჩვენს ხელთ არსებული საბოლოოდ.
ასე რომ, ეს მონაცემები სტრუქტურები, ჩვენ დავიწყეთ
ხედავს ახალი ზედა საზღვრები პოტენციურად თუ რა ადრე იყო სუპერ სწრაფი
და სადაც ჩვენ დავტოვებთ off დღეს და სადაც
ჩვენ იმედი გვაქვს, რომ მიიღოს ოთხშაბათს, ჩვენ
დაიწყოს შევხედოთ მონაცემები სტრუქტურა, რომელიც საშუალებას გვაძლევს ძიება
მონაცემების ჟურნალის დასრულების დრო ერთხელ.
და ჩვენ ვნახეთ, რომ, გავიხსენოთ, კვირაში ნულოვანი და ერთი ორობითი ძებნა ან გათიშე
და დაიპყროთ.
ის ბრუნდება და კიდევ უკეთესი, წმინდა გრაალი ამ ოთხშაბათს
იქნება ამუშავება მონაცემთა სტრუქტურა, რომელიც ეშვება ნამდვილად
ან თეორიულად მუდმივი დროს, რომლის დროსაც
არა აქვს მნიშვნელობა, რამდენი მილიონობით და მილიარდობით რამ
ჩვენ ამ მონაცემების სტრუქტურას, ის მიიღოს ჩვენთვის მუდმივი დროს, შესაძლოა, ერთი ნაბიჯი
ან ორი ნაბიჯი და 10 ნაბიჯები, მაგრამ მუდმივი ნომრები ნაბიჯები
ძებნის მეშვეობით მონაცემების სტრუქტურას.
სწორედ ეს იქნება წმინდა გრაალი მაგრამ უფრო, რომ ოთხშაბათს.
იხილეთ ya შემდეგ.
>> [მუსიკის დაკვრა]