[მუსიკის დაკვრა]
>> DOUG LLOYD: OK ისე წინადადება დაწყებამდე აქ.
თუ თქვენ არ უყურებს ვიდეო პოინტერები დაგვჭირდება ამის გაკეთება პირველი.
იმის გამო, რომ ეს ვიდეო არის კიდევ ერთი გზა სამუშაო მითითებას.
>> ასე რომ, ის აპირებს გაიგო ზოგიერთი ცნებები
რომ ჩვენ საფარი პოინტერები ვიდეო, და ჩვენ
აპირებს სიპრიალის ახლა, თუ გავითვალისწინებთ, რომ ისინი უკვე
ერთგვარი ესმოდა.
ასე რომ, მხოლოდ თქვენი სამართლიანი გაფრთხილება რომ, თუ თქვენ ხედავს ამ ვიდეო
და თქვენ არ მინახავს პოინტერები ვიდეო, შესაძლოა, ერთგვარი
ფრენა მეტი თქვენი უფროსი ცოტა.
ასე რომ, ეს შეიძლება იყოს უკეთესი უყურებს, რომ ამ მიზნით.
>> ასე რომ, ჩვენ უკვე ვნახეთ, ერთ-ერთი გზა მუშაობა მითითებას,
რომელიც ვაცხადებთ ცვლადი, და მაშინ ჩვენ
აცხადებენ, კიდევ ერთი ცვლადი, მომცეთ ცვლადი, რომელიც მიუთითებს, რომ იგი.
ასე რომ, ჩვენ შევქმენით ცვლადი ერთად სახელი, ჩვენ
ის მეორე ცვლადი ერთად სახელი, და ჩვენ აღვნიშნო, რომ მეორე ცვლადი
რომ პირველი.
ეს ერთგვარი აქვს პრობლემა, თუმცა, იმის გამო, რომ
მოითხოვს, რომ ვიცი ზუსტად რამდენი მეხსიერება ჩვენ
აპირებთ უნდა მომენტში ჩვენი პროგრამა შედგენილი.
>> რატომ არის, რომ?
იმიტომ, რომ ჩვენ უნდა შეეძლოს ასახელებს და იდენტიფიცირება ყველა შესაძლო ცვლადები
ჩვენ შეიძლება ექმნებათ.
ჩვენ შეიძლება მასივი, რომელიც შეიძლება იყოს შეუძლია ჩაატაროს უამრავი ინფორმაცია,
მაგრამ ეს ჯერ კიდევ არ არის ზუსტად ზუსტი საკმარისი.
რა მოხდება, თუ ჩვენ არ ვიცით, რა მოხდება, თუ ჩვენ არ ვიცით,
რამდენად ჩვენ უნდა კომპილირების დროს?
ან თუ ჩვენი პროგრამა აწარმოებს ძალიან დიდი ხნის განმავლობაში,
მიღება სხვადასხვა მომხმარებლის მონაცემები და ჩვენ ნამდვილად ვერ
შეაფასებს თუ არა ჩვენ აპირებთ უნდა 1,000 ერთეული?
>> ეს იმას არ ნიშნავს, რომ შეგვიძლია ამბობენ ბრძანებათა ზოლს
შესვლის რამდენი ელემენტი როგორ ფიქრობთ, თქვენ გჭირდებათ.
ისე რა, რომ ვხვდები, არასწორია?
დინამიური მეხსიერების გამოყოფის ერთგვარი საშუალებას გვაძლევს გზა
მიიღოთ დაახლოებით ამ კონკრეტული პრობლემა.
და ისე, როგორც ეს მას გამოყენებით მითითებას.
>> ჩვენ შეგვიძლია გამოვიყენოთ პოინტერები მიიღოთ დაშვება დინამიურად
გამოყოფილი მეხსიერება, მეხსიერება, რომელიც არის გამოყოფილი თქვენი პროგრამა მიმდინარეობს.
ეს არ არის გამოყოფილი კომპილირების დროს.
როდესაც თქვენ დინამიურად გამოყოფს მეხსიერება მოდის აუზი
მეხსიერების ცნობილია, როგორც ბევრი.
მანამდე ყველა მეხსიერების ჩვენ მუშაობს რა თქმა უნდა,
უკვე მოდის აუზი მეხსიერების ცნობილია, როგორც Stack.
კარგი გზა ზოგადად შევინარჩუნოთ გონება და ეს წესი
ყოველთვის არ ეხება, მაგრამ საკმაოდ ბევრი თითქმის
ყოველთვის ფლობს ჭეშმარიტი, რომ ნებისმიერი დრო მისცეს ცვლადის სახელი, რომ
ალბათ ცხოვრობს Stack.
და ნებისმიერ დროს, თქვენ არ მისცეს ცვლადი სახელი,
თქვენ შეგიძლიათ დინამიური მეხსიერება გამოყოფა, იგი ცხოვრობს ბევრი.
>> ახლა მე სახის წარდგენის ეს როგორც თუ არსებობს ამ ორი აუზი მეხსიერება.
მაგრამ თქვენ შეიძლება არ ჩანს ეს სქემა, რომელიც, როგორც წესი,
წარმომადგენლობა რა მეხსიერების ჰგავს,
და ჩვენ არ ვაპირებთ, რომ აინტერესებს ყველა პერსონალის ზედა და ქვედა.
ის, რასაც ჩვენ აინტერესებს ამ მონაწილეობა შუა აქ, ბევრი და დასტის.
როგორც ხედავთ მიერ შევხედავთ ამ სქემა,
ეს, ფაქტობრივად, არ არის ორი ცალკე აუზი მეხსიერება.
ეს არის ერთ ერთი საერთო აუზი მეხსიერება სადაც თქვენ დაიწყოს, ამ ვიზუალური
თქვენ დაიწყება ბოლოში და დაიწყოს შევსება
ბოლოში დასტის, და თქვენ იწყება ზედა და დაიწყოს შევსება
ზემოდან ქვემოთ ერთად ბევრი.
მაგრამ ეს ნამდვილად არის იგივე აუზი, უბრალოდ
სხვადასხვა წერტილში, სხვადასხვა ადგილას მეხსიერებაში, რომელიც გამოიყოფა.
და თქვენ შეგიძლიათ ამოიწურა მეხსიერების ან რომელსაც
ბევრი წავიდეთ ყველა გზა ბოლოში, ან აქვს
დასტის წავიდეთ ყველა გზა დაბრუნება, ან რომელსაც ბევრი და დასტის
შეხვდება up ერთმანეთის წინააღმდეგ.
ყველა იმ შეიძლება იყოს პირობები რომ გამოიწვიოს თქვენი პროგრამა
ამოიწურა მეხსიერება.
გააგრძელეთ, რომ გონება.
როდესაც ვსაუბრობთ ბევრი და დასტის
ჩვენ ნამდვილად ვსაუბრობთ იმავე ზოგადი ბლოკი მეხსიერება, უბრალოდ
სხვადასხვა ნაწილი, რომ მეხსიერებაში.
>> ასე რომ, ჩვენ კიდევ დინამიურად გამოყოფილი მეხსიერება პირველ რიგში?
როგორ ამჯამად ჩვენი პროგრამის მისაღებად მეხსიერება, როგორც ეს გაშვებული?
ისე C უზრუნველყოფს ფუნქცია მოუწოდა malloc, მეხსიერების Allocator, რომელიც
ზარი, და თქვენ გაივლის რამდენი ბაიტი მეხსიერება, რომელიც გსურთ.
ასე რომ, თუ თქვენი პროგრამა მიმდინარეობს და გსურთ რიცხვი runtime,
თქვენ mallock ოთხი ბაიტი მეხსიერება, malloc ფრჩხილებში ოთხ.
>> mallock გაივლიან გადახედეთ ბევრი,
იმიტომ, რომ ჩვენ დინამიურად გამოყოფის მეხსიერება,
და ეს დაგიბრუნდებით მომცეთ, რომ მეხსიერებაში.
ეს არ გაძლევთ, რომ memory-- ეს არ მისცეს მას სახელი,
ეს გაძლევთ მომცეთ იგი.
და ამიტომაც ისევ მე ვთქვი რომ მნიშვნელოვანია, რომ, შესაძლოა,
არ უყურებს მითითებას ვიდეო სანამ არ მივიღებთ ძალიან შორს ამ.
ასე malloc აპირებს მოგცემთ უკან მაჩვენებელი.
>> თუ mallock ვერ მოგცემთ ნებისმიერი მეხსიერების იმიტომ, რომ თქვენ ამოიწურა,
ეს მოგცემთ უკან null მაჩვენებელი.
გახსოვთ, რა მოხდება, თუ ჩვენ ცდილობენ და dereference null მაჩვენებელი?
ჩვენ განიცდიან seg ბრალია, არა?
ეს, ალბათ, არ არის კარგი.
>> ასე რომ, ყოველ დროს, თქვენ მიიღოს ზარი malloc თქვენ ყოველთვის, ყოველთვის
უნდა შეამოწმოს თუ არა მაჩვენებელი რამაც თქვენ უკან null.
თუ ეს, თქვენ უნდა დასრულდეს თქვენი პროგრამა იმიტომ, რომ თუ თქვენ ცდილობენ და dereference
null მაჩვენებელი თქვენ აპირებს განიცდიან სეგმენტაცია ბრალია
და თქვენი პროგრამა აპირებს ავარიული მაინც.
ასე რომ, ჩვენ statically მიიღოს რიცხვი?
>> int x.
ჩვენ, ალბათ კეთდება, რომ რამოდენიმე ჯერ, არა?
ეს ქმნის ცვლადში x, რომელიც ცხოვრობს დასტის.
როგორ უნდა დინამიურად მიიღოს რიცხვი?
Int ვარსკვლავი px ტოლია malloc 4.
>> ან მეტი სათანადოდ ჩვენ ვიტყოდი int ვარსკვლავი px
შეადგენს malloc ზომა int, მხოლოდ იმისათვის, რომ რაღაც ნაკლები
ჯადოსნური ნომრები გარშემო ჩვენი პროგრამა.
ეს აპირებს მიიღოს ჩვენთვის ოთხი ბაიტი მეხსიერების საწყისი ბევრი,
და მაჩვენებელი მივიღებთ უკან მას უწოდებენ px.
და შემდეგ, ისევე, როგორც ჩვენ გავაკეთეთ ადრე ჩვენ
შეგიძლიათ dereference px, რომ შეამოწმონ, რომ მეხსიერება.
როგორ მივიღოთ რიცხვი მომხმარებელი?
შეიძლება ითქვას, int x უდრის int.
ეს არის საკმაოდ მარტივია.
რა მოხდება, თუ ჩვენ გვინდა შევქმნათ მასივი საქართველოს x მოძრავი რომ ცხოვრობს დასტის?
ათწილადი stack_array-- რომ სახელი ჩვენი მასივი კვადრატულ ფრჩხილებში x.
რომ შევქმნით ჩვენთვის მასივი საქართველოს x მოძრავი რომ ცხოვრობს დასტის.
ჩვენ შეგვიძლია შევქმნათ მასივი მოძრავი რომ ცხოვრობს ბევრი, ძალიან.
სინტაქსი შეიძლება გამოიყურებოდეს ცოტა მეტი cumbersome,
მაგრამ შეიძლება ითქვას, float ვარსკვლავი heap_array ტოლია
malloc x ჯერ ზომა float.
მე უნდა საკმარისი ოთახი გამართავს x მცურავი პუნქტიანი ღირებულებებს.
ასე ვთქვათ, მე უნდა 100 მოძრავი, ან 1,000 მოძრავი.
ასე რომ, ამ შემთხვევაში ეს იქნება 400 ბაიტი 100 მოძრავი,
ან 4000 ბაიტი 1,000 მოძრავი, იმიტომ, რომ თითოეული float იკავებს
ოთხი ბაიტი სივრცეში.
>> მას შემდეგ, რაც ამით შემიძლია კვადრატული ფრჩხილი სინტაქსი heap_array.
უბრალოდ როგორც მე stack_array, მე შეგიძლიათ თქვათ მისი ელემენტების ინდივიდუალურად
გამოყენებით heap_array ნულოვანი, heap_array ერთი.
მაგრამ გავიხსენოთ, იმ მიზეზით, ჩვენ შეგვიძლია გავაკეთოთ, რომ იმიტომ, რომ სახელი მასივი C
მართლაც მომცეთ რომ მასივი პირველი ელემენტს.
ასე რომ, ის ფაქტი, რომ ჩვენ ვაცხადებთ მასივი მოძრავი დასტის აქ
რეალურად ცოტა დამაბნეველი.
ჩვენ ნამდვილად არიან მეორე ხაზი კოდი არსებობს
ასევე შექმნაში მომცეთ ბლოკი მეხსიერება, რომ ჩვენ მაშინ ნუ ზოგიერთი მუშაობა.
>> აი დიდი პრობლემა დინამიურად გამოყოფილი მეხსიერება, თუმცა,
და ამიტომ ეს მართლაც მნიშვნელოვანია, რომ განვითარდეს გარკვეული კარგი ჩვევების
როდესაც თქვენ მუშაობა მას.
განსხვავებით statically განაცხადა მეხსიერება, თქვენი მეხსიერება
არ არის ავტომატურად უბრუნდება სისტემა, როცა თქვენი ფუნქციის კეთდება.
ასე რომ, თუ ჩვენ გვაქვს მთავარი, და მთავარ მოუწოდებს ფუნქცია
f, როდესაც ვ სრულდება, რასაც ის აკეთებს, და დააბრუნებს კონტროლის პროგრამა
უკან მთავარ, ყველა მეხსიერების რომ ვ გამოიყენება ენიჭება უკან.
ეს შეიძლება იყოს გამოყენებული ერთხელ ზოგიერთი სხვა პროგრამა,
ან სხვა ფუნქცია, რომელიც იღებს მოუწოდა შემდეგ მთავარ.
მას შეუძლია გამოიყენოს, რომ იგივე მეხსიერების თავიდან.
>> თუ თქვენ დინამიურად გამოყოს მეხსიერება, თუმცა
თქვენ უნდა მკაფიოდ ვუთხრათ სისტემა, რომელიც თქვენ გაკეთდეს ეს.
ეს თქვენ გამართავს გადატანა იგი თქვენთვის, რამაც გამოიწვევს პრობლემა თქვენ გაშვებული out
მეხსიერება.
და სინამდვილეში, ჩვენ ზოგჯერ ეხება ეს, როგორც მეხსიერების გაჟონვის.
და ზოგჯერ ეს მეხსიერების ტბები შეიძლება რეალურად იყოს ნამდვილად დამანგრეველი
სისტემის შესრულება.
>> თუ თქვენ ხართ ხშირი ინტერნეტ შესახებ თქვენ შეიძლება გამოიყენოთ გარკვეული ბრაუზერების,
და მე არ ასახელებს სახელები აქ, მაგრამ არსებობს გარკვეული ბრაუზერების იქ
რომ განთქმულნი არიან, ფაქტობრივად, რომელსაც მეხსიერების გაჟონვის, რომელიც არ დაფიქსირდა.
და თუ თქვენ დატოვოთ თქვენი ბრაუზერი ღია ძალიან დიდი დროის განმავლობაში, დღის
და დღის ან კვირის განმავლობაში, თქვენ ზოგჯერ ალბათ შეამჩნევთ, რომ თქვენი სისტემა
არის გაშვებული, რეალურად, მართლაც ნელა.
და მიზეზი ის არის, რომ ბრაუზერის გამოყო მეხსიერება,
მაგრამ მაშინ არ უთხრა სისტემა რომ ეს გაკეთდეს ეს.
და ისე, რომ ტოვებს ნაკლები მეხსიერება ხელმისაწვდომია ყველა თქვენი სხვა პროგრამები
უნდა იზიარებს, იმიტომ, რომ თქვენ leaking-- რომ ბრაუზერში
პროგრამა ჩამოდის მეხსიერება.
როგორ ვაძლევთ მეხსიერების უკან როდესაც ჩვენ გავაკეთეთ ეს?
ისე, საბედნიეროდ, ის ძალიან მარტივი გზა ამის გაკეთება.
ჩვენ უბრალოდ გასათავისუფლებლად იგი.
არსებობს ფუნქცია მოუწოდა უფასო, იგი იღებს მომცეთ მეხსიერება,
და ჩვენ კარგი წასვლა.
>> ასე ვთქვათ ჩვენ ვართ შუა ჩვენი პროგრამა,
ჩვენ გვინდა malloc 50 სიმბოლო.
ჩვენ გვინდა malloc მასივი, რომ შეუძლია ჩატარება შეუძლია 50 სიმბოლო.
და როდესაც ჩვენ მომცეთ უკან რომ, რომ კურსორი სახელი არის სიტყვა.
ჩვენ ამას ვაკეთებთ, რასაც ჩვენ ვაპირებთ გავაკეთოთ სიტყვა,
და მაშინ, როდესაც ჩვენ კეთდება მხოლოდ გასათავისუფლებლად იგი.
და ახლა ჩვენ არ დაბრუნდა იმ 50 ბაიტი მეხსიერების უკან სისტემა.
ზოგიერთი სხვა ფუნქცია შეიძლება მათი გამოყენება.
ჩვენ არ უნდა ფიქრი, ტანჯვა მეხსიერების გაჟონვის იმიტომ, რომ ჩვენ არ გაათავისუფლა სიტყვა.
ჩვენ მოცემული მეხსიერების უკან, ასე რომ, ჩვენ გავაკეთეთ მუშაობა მას.
ასე რომ, არსებობს სამი ოქროს წესი, რომელიც უნდა
იყოს დაცული გონება ყოველთვის, როცა თქვენ დინამიურად გამოყოფის მეხსიერება
malloc.
ყოველი ბლოკი მეხსიერება, რომელიც თქვენ malloc უნდა გათავისუფლდეს
სანამ თქვენი პროგრამა სრულდება გაშვებული.
ახლა კიდევ ერთხელ, ელექტრო ან IDE ეს ერთგვარი ხდება თქვენ მაინც
როდესაც you-- ეს მოხდება მაინც მაშინ, როდესაც წყდება,
ყველა მეხსიერება იქნება.
მაგრამ ეს ზოგადად კარგი კოდირების პრაქტიკა გვიჩვენებს, რომ ყოველთვის, როდესაც თქვენ გაკეთდეს,
გასათავისუფლებლად, რა თქვენ mallocd.
>> რომ განაცხადა, ერთადერთი რამ, რომ თქვენ mallocd უნდა გათავისუფლდეს.
თუ თქვენ statically განაცხადოს რიცხვი, int x ნახევრად მსხვილი ნაწლავის,
რომ ცხოვრობს დასტის, თქვენ არ მაშინ გვინდა გასათავისუფლებლად x.
ასე რომ, ერთადერთი რამ, რომ თქვენ mallocd უნდა გათავისუფლდეს.
>> და ბოლოს, არ უფასოდ რაღაც ორჯერ.
რომელიც შეიძლება გამოიწვიოს სხვა უცნაური სიტუაცია.
ასე რომ, ყველაფერი, რომ თქვენ mallocd უნდა გათავისუფლდეს.
ერთადერთი რამ, რომ თქვენ malloc უნდა გათავისუფლდეს.
და ამის გაკეთება არ არის თავისუფალი რაღაც ორჯერ.
>> მოდით გავლა მაგალითი აქ რასაც ზოგიერთი დინამიურად გამოყოფილი
მეხსიერების შეიძლება გამოიყურებოდეს შერეული წელს რამდენიმე სტატიკური მეხსიერება.
რა შეიძლება მოხდეს აქ?
აგრეთვე, თუ შეგიძლიათ დაიცვას გასწვრივ და ვხვდები, რა არის
მოხდება, როგორც ჩვენ წავიდეთ ყველა ამ ხაზების კოდი.
>> ამიტომ ვამბობთ int მ.
რა ხდება აქ?
ისე ეს არის საკმაოდ მარტივია.
შევქმნა რიცხვი ცვლადში მ.
მე ფერი მწვანე, იმიტომ, რომ ის ფერი
რომ გამოვიყენო ვსაუბრობ შესახებ მთელი ცვლადები.
ეს არის ყუთში.
ეს ე.წ. მ, და თქვენ შეგიძლიათ მაღაზია რიცხვებით შიგნით მას.
>> რა მოხდება, თუ მე ვიტყვი, int ვარსკვლავი?
ისე, რომ საკმაოდ მსგავსია.
მე შექმნის ყუთი მოუწოდა.
ეს შეუძლია ჩატარების int ვარსკვლავები, მითითებას რიცხვებით.
ასე რომ, მე შეღებვა მწვანე-ish ისევე.
>> მე ვიცი, რომ რაღაც უნდა გავაკეთოთ რიცხვი,
მაგრამ ეს არ არის თავად რიცხვი.
მაგრამ ეს საკმაოდ ბევრი იგივე იდეას.
მე შეიქმნა ყუთში.
ორივე ეს უფლება ახლა ცხოვრობს დასტის.
მე მოცემული მათ, როგორც სახელები.
>> int ვარსკვლავი ბ შეადგენს malloc ზომა int.
ეს შეიძლება იყოს პატარა სახიფათო.
მიიღეთ მეორე და ვიფიქროთ, თუ რა მოელოდა, რომ მოხდეს ამ დიაგრამაზე.
int ვარსკვლავი ბ შეადგენს malloc ზომა int.
>> ისე ეს არ არის მხოლოდ შევქმნათ ერთი ყუთი.
ეს რეალურად ქმნის ორ ყუთები.
და ეს კავშირები, იგი ასევე ადგენს წერტილი ურთიერთობა.
ჩვენ გამოყოფილი ერთი ბლოკი მეხსიერების შესახებ ბევრი.
გაითვალისწინეთ, რომ ზედა მარჯვენა ყუთი იქ არ აქვს სახელი.
>> ჩვენ mallocd იგი.
იგი არსებობს ბევრი.
მაგრამ ბ სახელი აქვს.
ეს მაჩვენებელი ცვლადში ბ.
რომ ცხოვრობს Stack.
>> ასე რომ, ეს ნაჭერი მეხსიერების რომელიც მიუთითებს კიდევ ერთი.
ბ ცხრილში მისამართი რომ ბლოკი მეხსიერება.
მას არ გააჩნია სახელი მიიღო.
მაგრამ ეს მიუთითებს, რომ იგი.
ასე რომ, როდესაც ჩვენ ვამბობთ int ვარსკვლავი ბ უდრის malloc ზომა int, რომ იქ,
arrow რომ გამოჩნდა, რომ მარჯვენა მხარეს, რომელიც მთელი რამ,
მე მას, როგორც ჩანს, კიდევ ერთხელ, რა ხდება.
ყველა რომ ხდება რომ ერთი ხაზი კოდი.
ამჟამად ჩვენ კიდევ ცოტა მეტი პირდაპირი ერთხელ.
შეადგენს ampersand მ.
გახსოვთ, რა შეადგენს ampersand მ?
ისე, რომ ის იღებს მ მისამართი.
ან უფრო მეტი diagrammatically, ქულების მ.
>> უდრის ბ.
OK, ასე რომ აქ არის კიდევ ერთი.
უდრის ბ.
რა მოხდება რომ სქემა ამ დროს?
>> კარგად გავიხსენოთ, რომ დავალება ოპერატორი სამუშაოები
მინიჭებით ღირებულება უფლება ღირებულების მარცხენა.
ასე რომ ნაცვლად მიუთითებს მ, ახლა მიუთითებს, რომ ერთსა და იმავე ადგილზე, რომ ბ რაოდენობა.
ამჯამად არ აღვნიშნო, რომ B, მიუთითებს, სადაც ბ რაოდენობა.
>> თუ აღნიშნა ბ რომ იქნებოდა უკვე შეადგენს ampersand ბ.
არამედ უდრის ბ მხოლოდ იმას ნიშნავს, რომ ბ ახლა
მიუთითებს იმავე მისამართზე, რადგან შიგნით b მხოლოდ მისამართზე.
ახლა შიგნით არის იგივე მისამართზე.
მ უდრის 10, ალბათ, ყველაზე პირდაპირი რამ
ჩვენ გავაკეთეთ ცოტა.
განათავსეთ 10 ყუთში.
Star ბ უდრის მ + 2, გავიხსენოთ ჩვენი პოინტერები ვიდეო რა ვარსკვლავი ბ ნიშნავს.
ჩვენ ვაპირებთ, რომ dereference ბ და დააყენა გარკვეული მნიშვნელობა, რომ მეხსიერებაში.
ამ შემთხვევაში 12.
>> ასე რომ, როდესაც ჩვენ dereference წერტილი გავიხსენოთ, რომ ჩვენ უბრალოდ გამგზავრება ქვემოთ arrow.
ან დააყენა სხვა გზა, ჩვენ წასვლა რომ მეხსიერების მისამართი
და ჩვენ მანიპულირება რამდენიმე გზა.
ჩვენ დააყენა გარკვეული მნიშვნელობა არსებობს.
ამ შემთხვევაში ვარსკვლავი ბ უდრის მ პლუს 2 არის მხოლოდ
წასვლა ცვლადი აღნიშნა, რომ ბ, წასვლა მეხსიერება აღნიშნა, ბ,
და მ პლუს 2 იქ, 12.
>> ახლა მე გასათავისუფლებლად ბ.
რა ხდება, როდესაც მე გასათავისუფლებლად b?
მახსოვს რა ვთქვი უფასო საშუალებით.
რა ვარ მე ამბობდა როდესაც მე გასათავისუფლებლად b?
>> მე გაკეთდეს მუშაობს ის, არა?
მე არსებითად დავთმობთ მეხსიერება.
მე ვაძლევ მას უკან სისტემა.
მე არ უნდა აღარ არის რა მე ვეუბნებოდი მათ, OK?
>> ახლა თუ მე ვთქვა ვარსკვლავი ტოლია 11 თქვენ ალბათ შეუძლია
უკვე გითხრათ, რომ რაღაც ცუდი მოხდება აქ, არა?
მართლაც, თუ მე შევეცადე, რომ მე, ალბათ, დაიტანჯებოდა სეგმენტაცია ბრალი.
იმის გამო, რომ ახლა, მიუხედავად იმისა, რომ ადრე რომ ბლოკი მეხსიერება
იყო ის, რაც მე მქონდა ხელმისაწვდომობა, ამ ეტაპზე
ახლა მე წვდომის მეხსიერება, არ არის იურიდიული ჩემთვის, რათა შეამოწმონ.
>> და, როგორც ჩვენ, ალბათ, გავიხსენოთ, როდესაც ჩვენ მეხსიერება
რომ ჩვენ არ უნდა შეეხოთ, ეს არის ის, ყველაზე გავრცელებული მიზეზი
საქართველოს სეგმენტაცია ბრალია. ასე რომ, ჩემი პროგრამა
რომ ავარიის შემთხვევაში, თუ მე შევეცადე ამის გაკეთება.
ასე რომ კიდევ ერთხელ, რომ ეს არის კარგი იდეა, რომ მიიღოთ კარგი პრაქტიკა და კარგი ჩვევები ღრმა
როდესაც მუშაობა malloc და თავისუფალი, ისე, რომ თქვენ არ განიცდიან სეგმენტაცია
ხარვეზებით, და რომ თქვენ გამოიყენოთ თქვენი დინამიურად გამოყოფილი
მეხსიერების პასუხისმგებლობით.
>> მე Doug Lloyd ეს არის CS50.