[Powered by Google Translate] [ნაწილი 6] [უფრო კომფორტული]
[Rob Bowden] [ჰარვარდის უნივერსიტეტის]
[ეს არის CS50.] [CS50.TV]
>> ჩვენ შეგვიძლია უხელმძღვანელებს ჩვენი მონაკვეთის კითხვები.
მე გაგზავნილი URL for სივრცის წინაშე.
დასაწყისში მონაკვეთზე კითხვები ამბობენ-
აშკარად არ ვარ მთლიანად unsick-არის ძალიან ადვილი კითხვა
მხოლოდ იმას, რაც valgrind?
რას valgrind გავაკეთო?
ვინმე მინდა ვთქვა, რა valgrind აკეთებს?
[სტუდენტური] ჩეკები მეხსიერების გაჟონვის.
Yeah, valgrind არის ზოგადად მეხსიერების შემოწმება.
ეს, საბოლოო ჯამში, გიჩვენებთ თუ თქვენ გაქვთ რაიმე მეხსიერების ტბები,
რაც ძირითადად, რაც ჩვენ იყენებთ მას, რადგან თუ გსურთ
კარგად პრობლემა კომპლექტი ან, თუ გნებავთ
კიდევ დიდი საბჭო, უნდა გქონდეს არ მეხსიერების გაჟონვის განაწილებაზე,
და იმ შემთხვევაში, თუ მეხსიერების გაჟონვის რომ ვერ პოულობთ,
ასევე გახსოვდეთ, რომ ნებისმიერ დროს გახსნა ფაილი
და თუ არ ვხურავთ მას, რომ მეხსიერების გაჟონვის.
>> ბევრი ადამიანი ეძებს ზოგიერთი კვანძის, რომ ისინი არ ათავისუფლებს
როცა ნამდვილად, არ დახუროთ ლექსიკონი წელს ძალიან პირველი ნაბიჯი.
იგი ასევე გიჩვენებთ თუ თქვენ გაქვთ რაიმე არასწორი ნათქვამია ან წერს,
რაც იმას ნიშნავს, თუ თქვენ ცდილობენ და მითითებული ღირებულება
რომ მიღმა ბოლოს ბევრი და ეს არ მოხდება, რათა seg ბრალია
მაგრამ valgrind იჭერს მას, როგორც არ უნდა იყოს რეალურად წერა იქ,
და ასე რომ თქვენ აუცილებლად უნდა არ გვაქვს იმ შემორჩენია.
როგორ იყენებთ valgrind?
>> ეს ზოგადად საკითხი
სახის გაუშვით და შევხედოთ გამომუშავება.
გამომავალი არის აბსოლუტური ბევრი ჯერ.
არსებობს ასევე გართობა შეცდომები აქ თუ გაქვთ საშინლად არასწორი რამ
ხდება მარყუჟის, მაშინ იგი საბოლოოდ ამბობენ, "გზა ძალიან ბევრი შეცდომები.
მე ვაპირებ შეწყვიტოს დათვლის ახლა. "
ეს ძირითადად ტექსტური გამომავალი რომ თქვენ გაქვთ გარჩევის.
საბოლოო ჯამში, იგი გეტყვით ნებისმიერი მეხსიერების გაჟონვის რომ თქვენ გაქვთ,
რამდენი ბლოკები, რომელიც შეიძლება იყოს სასარგებლო, რადგან
თუ ერთი ბლოკი unfreed, მაშინ ეს ჩვეულებრივ ადვილია იპოვოს
ვიდრე 1,000 ბლოკები unfreed.
1,000 ბლოკები unfreed ალბათ იმას ნიშნავს, თქვენ არ ათავისუფლებს
თქვენი უკავშირდება სიები სათანადოდ ან რამე.
რომ valgrind.
>> ახლა ჩვენ გვაქვს ჩვენი მონაკვეთის კითხვები,
რომელიც თქვენ არ უნდა ჩამოტვირთოთ.
დააკლიკეთ ჩემი სახელი და გაიყვანოს ისინი სივრცეში.
ახლა დააჭირეთ ჩემთვის.
ცვლილებათა 1 იქნება დასტის, რომელიც ვაკეთებთ პირველი.
ცვლილებათა 2 იქნება რიგში, და ცვლილებათა 3 იქნება საგნით უკავშირდება სიაში.
დაწყებული off ჩვენს Stack.
როგორც ამბობს აქ, დასტის არის ერთ ერთი ყველაზე ძირითადი,
ფუნდამენტური მონაცემები სტრუქტურების კომპიუტერული მეცნიერებების.
ძალიან prototypical მაგალითია
Stack of ქაღალდის წელს სასადილოს.
ეს ძირითადად როდესაც თქვენ მიმდინარეობს გააცნო დასტის,
ვინმე აპირებს ამბობენ, "ო, როგორიცაა Stack of უჯრები".
თქვენ დააწყობს ქაღალდის up.
მაშინ, როდესაც მიდიხარ დახევის უჯრა,
პირველი უჯრა რომ მიღების გამოყვანილია არის ბოლო, რომელიც განთავსდება Stack.
დასტის ასევე მსგავსი ნათქვამია აქ-
ჩვენ გვაქვს სეგმენტი მეხსიერების მოუწოდა Stack.
და რატომ არის ეს მოუწოდა დასტის?
>> რადგან მოსწონს დასტის მონაცემები სტრუქტურის,
ეს უბიძგებს და pops დასტის ფარგლებში on დასტის,
აქ დასტის ფარგლებში არიან როგორც კონკრეტული Call of ფუნქცია.
მსგავსად დასტის, თქვენ ყოველთვის უნდა დაბრუნდეს
საწყისი ფუნქციის ზარის ადრე შეგიძლიათ მიიღოთ ქვემოთ შევიდა ქვედა დასტის ფარგლებში კიდევ ერთხელ.
შეგიძლიათ არ აქვს მთავარ ზარის foo ზარის ბარი და ბარი დაბრუნება მთავარი პირდაპირ.
ის ყოველთვის მივიღე დაიცვას სწორი დასტის უბიძგებს და popping.
ორი ოპერაციები, როგორიც მე ვთქვი, არის ბიძგი და საესტრადო.
ეს ის საყოველთაო თვალსაზრისით.
თქვენ უნდა იცოდეთ, ბიძგი და საესტრადო თვალსაზრისით stacks არ აქვს მნიშვნელობა რა.
ჩვენ დავინახავთ, რიგები არის სახის სხვადასხვა.
ეს ნამდვილად არ აქვს უნივერსალური ტერმინი, მაგრამ ბიძგი და საესტრადო ვართ უნივერსალური ამისთვის stacks.
Push უბრალოდ ჩაიცვი Stack.
Pop არის გამეხადა Stack.
და ვხედავთ აქ ჩვენ გვაქვს ჩვენი typedef struct დასტის,
ამიტომ ჩვენ გვაქვს char ** სტრიქონები.
ნუ ეშინია ნებისმიერი **.
ეს აპირებს დასრულდება მდე მიმდინარეობს მასივი სტრიქონები
ან მასივი მითითებას გმირები, სადაც
მითითებას გმირები ტენდენცია იყოს სიმები.
იგი არ უნდა იყოს სიმები, მაგრამ აქ, ისინი იქნება სტრიქონები.
>> ჩვენ გვყავს მასივი სტრიქონები.
ჩვენ გვყავს ზომა, რომელიც წარმოადგენს რამდენი ელემენტები ამჟამად დასტის,
და მაშინ ჩვენ გვაქვს პოტენციალი, რომელიც რამდენი ელემენტები შეიძლება იყოს Stack.
მოცულობა უნდა დაიწყოს off როგორც რაღაც მეტია 1,
მაგრამ ზომა იწყებს off როგორც 0.
არის, არის ძირითადად სამი სხვადასხვა გზით შეგიძლიათ წარმოიდგინოთ, რომ დასტის.
ისე, არსებობს ალბათ მეტი, მაგრამ ორი ძირითადი გზები
შეგიძლიათ განახორციელოს მისი გამოყენება მასივი, ან შეგიძლიათ განახორციელოს მისი გამოყენება დაკავშირებულია სიაში.
უკავშირებს სიები სახის ტრივიალური რათა stacks საწყისი.
ძალიან ადვილია, რათა დასტის გამოყენებით დაკავშირებული სიები
ამიტომ, ჩვენ ვაპირებთ, რათა დასტის გამოყენებით მასივები,
და შემდეგ გამოყენებით მასივები, არის კიდევ ორი ​​გზა შეგიძლიათ დაფიქრდით.
მანამდე, როდესაც ვთქვი, ჩვენ გვაქვს შესაძლებლობა დასტის,
ამიტომ ჩვენ შეგვიძლია ჯდება ელემენტს on Stack.
>> ერთი გზა ეს შეიძლება მოხდეს არის, როგორც კი თქვენ მოხვდა 10 ელემენტებს, მაშინ თქვენ გაკეთდეს.
მოგეხსენებათ, რომ არსებობს ზედა შეკრული of 10 რამ მსოფლიოში
რომ თქვენ არასოდეს არ აღემატება 10 რამ თქვენს დასტის,
ამ შემთხვევაში თქვენ შეგიძლიათ ზედა შეკრული on ზომა თქვენი დასტის.
ან თქვენ შეიძლება თქვენი დასტის იყოს unbounded,
მაგრამ თუ თქვენ აკეთებთ მასივი, რაც ნიშნავს, რომ თითოეული დროს თქვენ მოხვდა 10 ელემენტები,
მაშინ თქვენ აპირებს აქვს ზრდა დან 20 ელემენტებს, და როდესაც თქვენ მოხვდა 20 ელემენტები,
თქვენ აპირებს იზრდება თქვენი მასივი 30 ელემენტები ან 40 ელემენტებს.
თქვენ აპირებთ უნდა გაიზარდოს მოცულობა, რაც ჩვენ ვაპირებთ აქ.
თითოეული დრო მივაღწევთ მაქსიმალური ზომა ჩვენი დასტის,
როდესაც ჩვენ დააყენებს რაღაც შემდეგ, ჩვენ ვაპირებთ უნდა გაიზარდოს მოცულობა.
აქ, ჩვენ არ ბიძგი გამოცხადდა bool ბიძგი (char * ქ).
ჩარ * ქ არის სიმებიანი რომ ჩვენ უბიძგებს გადატანა დასტის,
და bool უბრალოდ ამბობს თუ არა ჩვენ მოვახერხეთ ან ჩაიშალა.
>> როგორ შეიძლება ვერ შევძლებთ?
რა არის მხოლოდ გარემოება, რომ შეგიძლიათ წარმოიდგინოთ, რომ
აქ ჩვენ უნდა დაბრუნდეს ყალბი?
Yeah.
[სტუდენტური] თუ ეს სრული და ჩვენ გამოყენებით ესაზღვრება განხორციელება.
ჰო, ისე, როგორ უნდა განსაზღვროს-პასუხობს
თუ სრული და ჩვენ გამოყენებით ესაზღვრება განხორციელება.
მაშინ ჩვენ აუცილებლად დაბრუნდებიან ყალბი.
როგორც კი მოხვდა 10 რამ მასივი, ჩვენ ვერ ჯდება 11, ასე რომ ჩვენ დაბრუნების ცრუ.
რა, თუ იგი unbounded? Yeah.
თუ ვერ გაფართოებას მასივი რატომღაც.
ჰო, ასე რომ მეხსიერება არის შეზღუდული რესურსი,
და საბოლოოდ, თუ ჩვენ შევინარჩუნოთ უბიძგებს რამ გადატანა დასტის უსასრულოდ,
ჩვენ ვაპირებთ შევეცადოთ და გამოყოფს უფრო დიდი მასივი, რათა შეწყობოდა
უფრო დიდი ტევადობის და malloc ან რასაც ჩვენ გამოყენებით დაბრუნებას აპირებს ყალბი.
ისე, malloc დაბრუნდება null.
>> გახსოვდეთ, ყოველი დრო ოდესმე მოვუწოდებთ malloc, თქვენ უნდა შემოწმების თუ იგი
დააბრუნებს null ანდა რომ არის სისწორის გამოქვითვას.
მას შემდეგ, რაც ჩვენ გვინდა unbounded დასტის,
მხოლოდ შემთხვევაში, ჩვენ ვაპირებთ იყოს დაბრუნების ცრუ არის, თუ ჩვენ ვცდილობთ
გაზრდის შესაძლებლობები და malloc ან რასაც დააბრუნებს false.
მაშინ pop იღებს არანაირი არგუმენტი,
და ის დააბრუნებს string რომ არის ზევით Stack.
როგორი იყო ბოლოს აიძულა on დასტის არის ის, რაც პოპ ბრუნდება,
და მას ასევე შლის მას Stack.
და შენიშნავს, რომ ის დააბრუნებს null თუ არაფერი Stack.
ყოველთვის შესაძლებელია, რომ დასტის არის ცარიელი.
ჯავაში, თუ თქვენ გამოიყენება, რომ, ან სხვა ენებზე,
ცდილობს პოპ საწყისი ცარიელი დასტის შეიძლება გამოიწვიოს გამონაკლისის ან რამე.
>> მაგრამ C, null არის სახის ბევრი შემთხვევებში, თუ როგორ გაუმკლავდეს ამ პრობლემებს.
დავბრუნდეთ null არის, თუ როგორ ვაპირებთ ნიშნავდეს, რომ დასტის ცარიელი იყო.
ჩვენ გათვალისწინებული კოდი, რომელიც შეამოწმოთ თქვენი დასტის ფუნქციების,
განახორციელოს დააყენებს და საესტრადო.
ეს არ იქნება ბევრი კოდი.
მე-ფაქტობრივად, სანამ ჩვენ გავაკეთოთ, მინიშნება, მინიშნება-
თუ თქვენ არ მინახავს ეს, malloc არ არის ერთადერთი ფუნქცია
რომ გამოყოფს მეხსიერების შესახებ ბევრი თქვენთვის.
არსებობს ოჯახი alloc ფუნქციები.
პირველი არის malloc, რომელიც თქვენ გამოიყენება.
მაშინ არსებობს calloc, რომელიც იგივე როგორც malloc,
მაგრამ ეს ნულის ყველაფერს თქვენთვის.
თუ თქვენ ოდესმე სურდა მითითებული ყველაფერი null შემდეგ mallocing რაღაც
თქვენ უნდა მხოლოდ გამოყენებული calloc პირველ რიგში ნაცვლად წერა
ამისთვის loop ნულის მთელი ბლოკი მეხსიერება.
>> Realloc ჰგავს malloc და აქვს ბევრი განსაკუთრებულ შემთხვევებში,
მაგრამ ძირითადად რა realloc არ არის
სჭირდება მაჩვენებელი, უკვე გამოიყო.
Realloc ფუნქცია გსურთ გადამხდელი ყურადღებას აქ.
იგი იღებს მაჩვენებელი, უკვე დაბრუნდა malloc.
ვთქვათ თქვენ მოითხოვოს malloc მაჩვენებელი საქართველოში 10 ბაიტი.
შემდეგ ხვდები, თქვენ სურდა 20 ბაიტი,
ასე რომ თქვენ მოვუწოდებთ realloc რომ მომცეთ გამოიტანე 20 ბაიტი,
და realloc ავტომატურად კოპირება მეტი ყველაფერი თქვენთვის.
თუ თქვენ უბრალოდ მოუწოდა malloc კვლავ, ისევე როგორც მე ბლოკი 10 ბაიტი.
ახლა მჭირდება ბლოკი 20 ბაიტი,
ასე რომ, თუ მე malloc 20 ბაიტი, მაშინ მე ხელით კოპირება მეტი 10 bytes from პირველი რაც
მეორე რამ და შემდეგ თავისუფალი პირველი რაც.
Realloc იქნება გაუმკლავდეს, რომ თქვენთვის.
>> გაითვალისწინეთ ხელმოწერა იქნება ბათილად *,
რომელიც მხოლოდ დაბრუნების მომცეთ ბლოკი მეხსიერება,
მაშინ ბათილად * ptr.
შეგიძლიათ წარმოიდგინოთ, რომ ბათილად * როგორც generic მაჩვენებელი.
ზოგადად, თქვენ არასდროს გაუმკლავდეთ ბათილად *,
მაგრამ malloc ბრუნდება ბათილად * და შემდეგ უბრალოდ გამოიყენება მოსწონს
ეს რეალურად იქნება char *.
წინა ბათილად * რომ იყო დაბრუნდა მიერ malloc
არის აპირებს გადაეცემა realloc და შემდეგ ზომა
არის ახალი ბაიტების რაოდენობას გსურთ გამოყოფას, ამიტომ თქვენი ახალ ამპლუაში.
მე მივცემ თქვენ რამდენიმე წუთი, და ამის გაკეთება ჩვენს სივრცეში.
დაწყება ცვლილებათა 1.
მე შეჩერება შემდეგ იმედია შესახებ საკმარისი დრო განახორციელოს ბიძგი,
და მაშინ მე მივცემ თქვენ კიდევ ერთი შესვენება გავაკეთოთ Pop.
მაგრამ ეს ნამდვილად არ არის, რომ ბევრი რამ კოდი ყველა.
საუკეთესო კოდი ალბათ გაფართოების პერსონალის, გაფართოების შესაძლებლობებით.
Okay, არ ზეწოლა უნდა გაკეთდეს მთლიანად,
მაგრამ რადგან თქვენ თავს თქვენ სწორ გზას ადგას, რომ კარგია.
>> ვინმეს აქვს რაიმე კოდი ისინი თავს კომფორტულად ჩემთან გამწევ up?
ჰო, მე, მაგრამ ჯერ არავის აქვს რაიმე კოდი შემიძლია დახევის up?
Okay, შეგიძლიათ დაიწყოს, გადაარჩენს, რაც არ არის?
მე ყოველთვის დაგვავიწყდეს, რომ ნაბიჯი.
Okay, ეძებს ბიძგი,
გსურთ ასახსნელად თქვენი კოდი?
[სტუდენტური] უპირველეს ყოვლისა, მე გაიზარდა ზომა.
ვფიქრობ იქნებ მე უნდა ჰქონდეს, რომ-ყოველ შემთხვევაში, მე გაიზარდა ზომა,
და მე ვერ ვხედავ თუ ნაკლები ტევადობის.
და თუ ნაკლები სიმძლავრის, მე დაამატოთ მასივს, რომ ჩვენ უკვე გვაქვს.
და თუ ეს ასე არ არის, მე გამრავლების მოცულობა მიერ 2,
და მე reallocate სიმები მასივი რაღაც შედარებით მეტი ტევადობის ზომა არის.
და შემდეგ, თუ ეს ვერ მოხერხდა, მე გეტყვით მომხმარებლის და დაბრუნების ცრუ,
და თუ ეს ჯარიმა, მაშინ მე ზუსტად სიმებიანი ახალ ადგილზე.
>> [Rob ბ] ასევე შეამჩნევთ, რომ ჩვენ გამოიყენება ლამაზი bitwise ოპერატორის აქ
უნდა გავამრავლოთ მიერ 2.
გახსოვდეთ, მარცხენა Shift ყოველთვის იქნება გამრავლებული 2.
მარჯვენა Shift იყოფა 2 რადგან გახსოვთ, რომ ეს იმას ნიშნავს,
დაყოფის მიერ 2 როგორც მთელი რიცხვი იყოფა 2.
ეს შეიძლება truncate 1 აქ ან იქ.
მაგრამ ცვლა მიერ დატოვებული 1 ყოველთვის იქნება გამრავლებული 2,
თუ თქვენ overflow ფარგლებში მთელი რიცხვი, და შემდეგ ეს არ იქნება.
მხარეს კომენტარი.
მე მიყვარს do-ეს არ შეიცვლება კოდირების ნებისმიერი ფორმით,
მაგრამ მე მინდა, რომ რამე მოსწონს ეს.
ეს ფაქტიურად ხდება, რათა ის ოდნავ აღარ.
იქნებ ეს არ არის სრულყოფილი შემთხვევაში რათა ნახოთ ამ,
მაგრამ მე მიყვარს სეგმენტი იგი ამ ბლოკებს-
okay, თუ ეს თუ მოხდება, მაშინ მე ვაპირებ, რომ რამე,
და შემდეგ ფუნქცია კეთდება.
მე არ გვჭირდება მაშინ გადახვევა ჩემი თვალით ყველა გზა ქვემოთ ფუნქცია
უნდა ვნახოთ, რა მოხდება მას შემდეგ, რაც სხვას.
ეს თუ ეს თუ მოხდება, მაშინ მე უბრალოდ დააბრუნოს.
მას ასევე ლამაზი დასძინა სასარგებლოდ ყველაფერს მიღმა ამ
არის გადაინაცვლებს დაუტოვებიათ ერთხელ.
მე აღარ უნდა თუ ოდესმე ახლოს ridiculously ხანგრძლივი ხაზები,
მაშინ ის 4 ბაიტი შეუძლია დაეხმაროს, და ასევე უფრო მარცხენა რაღაც არის,
ნაკლებია გადაატვირთული გრძნობთ თუ like-okay, მე უნდა გვახსოვდეს
მე ამჟამად ხოლო loop შიგნით სხვას შიგნით ამისთვის loop.
ნებისმიერ ადგილას შეგიძლიათ ამის გაკეთება დაბრუნების დაუყოვნებლივ, I ტიპის მოსწონს.
ეს სრულიად არჩევით და მოსალოდნელი არ არის არანაირად.
>> [სტუდენტური] უნდა იყოს ზომა - ში ვერ მდგომარეობა?
Fail მდგომარეობა აქ ჩვენ ვერ realloc, ისე კი.
შეამჩნევთ, თუ როგორ წელს ვერ მდგომარეობა, სავარაუდოდ,
თუ ჩვენ თავისუფალი პერსონალის შემდეგ, ჩვენ ყოველთვის აპირებს ვერ
არ აქვს მნიშვნელობა რამდენჯერ ვცდილობთ დააყენებს რაღაც.
თუ ჩვენ შევინარჩუნოთ უბიძგებს, ჩვენ გააგრძელეთ დამატება ზომა,
მიუხედავად იმისა, რომ ჩვენ არ აყენებს არაფერს გადატანა Stack.
ჩვეულებრივ ჩვენ არ იყოს ზომა სანამ
შემდეგ ჩვენ წარმატებით Put It On Stack.
ჩვენ გვინდა ამის გაკეთება, ვთქვათ, არც აქ და აქ.
და შემდეგ ნაცვლად ამბობდა s.size ≤ ტევადობა, ეს ნაკლები მოცულობა,
მხოლოდ იმიტომ, რომ გადავედით სადაც ყველაფერი იყო.
>> და მახსოვს, ერთადერთი ადგილი, რომ ჩვენ შეიძლება დაბრუნდეს ყალბი
აქ არის, სადაც realloc დაბრუნდა null,
და თუ მოხდება უნდა გვახსოვდეს სტანდარტული შეცდომა,
იქნებ თქვენ შეიძლება განიხილონ ამ შემთხვევაში, სადაც გსურთ ბეჭდვა სტანდარტული შეცდომა,
ასე fprintf stderr ნაცვლად მხოლოდ ბეჭდვას პირდაპირ სტანდარტულ out.
ისევ და ისევ, ეს არ არის მოლოდინი, მაგრამ თუ ეს შეცდომა,
აკრიფოთ printf, მაშინ დაგვჭირდება რათა ის ბეჭდვა სტანდარტული შეცდომა ნაცვლად სტანდარტული გარეთ.
>> ვინმეს აქვს არაფერი აღვნიშნო? დიახ.
[სტუდენტური] შეგიძლიათ წასვლა მეტი [inaudible]?
[Rob ბ] დიახ, ფაქტობრივი binariness, ან უბრალოდ რა არის?
[სტუდენტური] ასე, რომ თქვენ გავამრავლოთ ის მიერ 2?
[Rob ბ] ჰო, ძირითადად.
In ორობითი მიწის, ჩვენ ყოველთვის გვაქვს ჩვენი ნაკრები თანრიგისაგან.
გადავიდა ეს მიერ დატოვებული 1 ძირითადად ჩანართები აქ მარჯვენა მხარეს.
თავში ამ, უბრალოდ დამახსოვრების, რომ ყველაფერი ორობითი
არის ძალა 2, ასე რომ ეს წარმოადგენს 2 ​​დან 0,
ამ 2 დან 1, ამ 2 დან 2.
By ჩასმა 0 მარჯვენა მხარეს არის, ჩვენ უბრალოდ გადაიტანოს ყველაფერი დასრულდა.
რა გამოყენებული იქნება 2 დან 0 არის 2 დან 1, არის 2 დან 2.
მარჯვენა მხარეს, რომ ჩვენ ჩასმული
აუცილებლად იქნება 0,
რაც გრძნობა.
თუ თქვენ ოდესმე გავამრავლოთ ნომერი მიერ 2, ეს არ აპირებს დასრულდება მდე უცნაური,
ასე 2 დან 0 ადგილი უნდა იყოს 0,
და ეს არის ის, რაც მე ნახევარი გააფრთხილა შესახებ ადრე არის თუ მოხდება გადაეტანა
მიღმა რაოდენობის ბიტი წელს მთელი რიცხვი,
მაშინ ეს 1 აპირებს დასრულდება მდე მიმდინარეობს off.
სწორედ მხოლოდ შეშფოთება თუ მოხდება უნდა საქმე მართლაც დიდი შესაძლებლობები.
მაგრამ იმ ეტაპზე, მაშინ თქვენ საქმე მასივი მილიარდობით რამ,
რაც შეიძლება არ ჯდება მეხსიერებაში მაინც.
>> ახლა ჩვენ შეგვიძლია მოხვედრა pop, რაც კი ადვილია.
თქვენ ეს მოსწონთ თუ ემართება პოპ მთელი bunch,
და ახლა თქვენ ნახევარ მოცულობა ერთხელ.
თქვენ შეიძლება realloc to shrink ოდენობით მეხსიერება გაქვთ,
მაგრამ თქვენ არ უნდა ფიქრი, რომ, ასე მხოლოდ realloc შემთხვევაში იქნება
მზარდი მეხსიერება, არასდროს არ მცირდება მეხსიერება,
რომელიც აპირებს პოპ სუპერ მარტივია.
არის რიგები, რომლებიც იქნება, როგორიც stacks,
მაგრამ იმისათვის, რომ თქვენ მიიღოს ნივთების არის საპირისპიროა.
Prototypical მაგალითი მდგომ არის ხაზი,
ამიტომ ვფიქრობ, თუ იყო ინგლისური, მე იტყოდა
prototypical მაგალითი მდგომ არის რიგიდან.
ასე მოსწონს ხაზი, თუ თქვენ პირველი ადამიანი ხაზი,
თქვენ მოველით, რომ იყოს პირველი პირი მიცემულია ხაზი.
თუ თქვენ ბოლო პირი ხაზი, თქვენ იქნება ბოლო პირი ემსახურებოდა.
ჩვენ მოვუწოდებთ, რომ FIFO ნიმუში, ხოლო დასტის იყო LIFO ნიმუში.
ეს სიტყვები საკმაოდ უნივერსალური.
>> Like stacks და განსხვავებით მასივები, რიგები, როგორც წესი, არ დაუშვას, რომ ელემენტები შუა.
აქ, დასტის, ჩვენ გვაქვს ბიძგი და საესტრადო.
აქ, ჩვენ არ უნდა მოუწოდა მათ enqueue და dequeue.
ისიც გავიგე, მათ მოუწოდა ცვლა და unshift.
მე მოვისმინე ამბობენ ბიძგი და საესტრადო ასევე ვრცელდება რიგები.
მე მოვისმინე ჩადეთ, ამოიღოთ
ასე დააყენებს და საესტრადო, თუ ვსაუბრობთ stacks, თქვენ დააჭერთ და popping.
თუ თქვენ საუბრობთ რიგები, შეგიძლიათ აირჩიოთ სიტყვა, რომლის გამოყენებაც გსურთ
ამისთვის Insertion და მოცილება, და არ არსებობს კონსენსუსი, თუ რას უნდა მოეთხოვოს.
მაგრამ აქ, ჩვენ გვაქვს enqueue და dequeue.
ახლა, struct გამოიყურება თითქმის იდენტურია დასტის struct.
მაგრამ ჩვენ უნდა ტრეკზე ხელმძღვანელი.
ვფიქრობ ნათქვამია ქვემოთ აქ, მაგრამ რატომ გვჭირდება ხელმძღვანელი?
პროტოტიპები ძირითადად იდენტურია დააყენებს და საესტრადო.
შეგიძლიათ წარმოიდგინოთ, რომ მას, როგორც ბიძგი და საესტრადო.
ერთადერთი განსხვავება არის Pop ბრუნდება-ის ნაცვლად ბოლო, ის დაბრუნების პირველი.
2, 1, 3, 4, ან რაღაც.
და აქ დაწყება.
ჩვენი მდგომ სრულიად სრული, ასე რომ ოთხი ელემენტები მასში.
ბოლოს ჩვენი მდგომ არის გაკეთებული 2,
და ახლა ჩვენ წასვლა ჩადეთ რაღაც.
>> როდესაც ჩვენ გვინდა ჩადეთ რომ რაღაც, რაც ჩვენ გააკეთა დასტის ვერსია
ჩვენ გაგრძელდეს ჩვენი ბლოკი მეხსიერება.
რა არის პრობლემა?
[სტუდენტური] თქვენ გადატანა 2.
რა ვთქვი დაახლოებით ბოლოს მდგომ,
ეს არ აქვს აზრი, რომ ჩვენ იწყება 1,
მაშინ ჩვენ გვინდა dequeue 1, მაშინ dequeue 3, მაშინ dequeue 4,
მაშინ dequeue 2, მაშინ dequeue ეს ერთი.
ჩვენ არ შეგვიძლია გამოვიყენოთ realloc ახლა,
ან სულ მცირე, თქვენ უნდა გამოიყენოთ realloc სხვაგვარად.
მაგრამ როგორც ჩანს არ უნდა მოხდეს გამოიყენოთ realloc.
აპირებთ ხელით კოპირება თქვენს მეხსიერებაში.
>> არსებობს ორი ფუნქციები კოპირება მეხსიერება.
არსებობს memcopy და memmove.
მე გაკეთებული კითხულობს კაცი გვერდებზე, თუ რომელი ერთი თქვენ აპირებს გინდათ გამოიყენოთ.
Okay, memcopy, განსხვავება არის
რომ memcopy და memmove, ერთი სახელურები შემთხვევაში სწორად
აქ თქვენ კოპირება შევიდა რეგიონში, რომ მოხდება გადახურვა რეგიონში
თქვენ კოპირება საწყისი.
Memcopy არ ამუშავებს მას. Memmove აკეთებს.
შეგიძლიათ წარმოიდგინოთ, რომ პრობლემა, როგორც-
ვთქვათ მინდა კოპირება ამ ბიჭს,
ამ ოთხი ამ ბიჭს მეტი.
და ბოლოს, რა მასივი უნდა გამოიყურებოდეს
შემდეგ ასლი არის 2, 1, 2, 1, 3, 4, და შემდეგ რაღაცები დასასრულს.
მაგრამ ეს დამოკიდებული იმისათვის, რომელშიც ჩვენ რეალურად კოპირება,
რადგან, თუ არ ჩავთვლით იმ ფაქტს, რომ რეგიონში ჩვენ გადაწერა შევიდა
ემთხვევა ერთი ჩვენ კოპირება საწყისი,
მაშინ ჩვენ შეიძლება გავაკეთოთ მოსწონს დაწყება აქ, კოპირება 2 შევიდა ადგილი გვინდა წასვლა,
მაშინ გადატანა ჩვენი პოინტერები ნაბიჯია.
>> ახლა ჩვენ ვაპირებთ იყოს აქ და აქ, და ახლა ჩვენ გვინდა კოპირება
ამ ბიჭს მეტი ამ ბიჭს და გადატანა ჩვენი პოინტერები ნაბიჯია.
ის, რასაც ჩვენ ვაპირებთ დასრულდება up მიღების არის 2, 1, 2, 1, 2, 1
ნაცვლად შესაბამისი 2, 1, 2, 1, 3, 4 რადგან
2, 1 overrode ორიგინალური 3, 4.
Memmove სახელურები რომ სწორად.
ამ შემთხვევაში, ძირითადად უბრალოდ ვიყენებთ memmove
იმიტომ, რომ ეს ემსახურება ეს სწორად.
ეს ზოგადად არ განახორციელებს რაიმე სახის უარესი.
იდეა არის ის ნაცვლად დასაწყისიდან და გადაწერა ამ გზით
როგორც ჩვენ უბრალოდ გააკეთეს აქ, იგი იწყება ბოლოს და ასლი,
და ამ შემთხვევაში, შეგიძლიათ არასდროს პრობლემა.
არ არსებობს შესრულების დაკარგა.
ყოველთვის გამოიყენეთ memmove. არასოდეს ფიქრი memcopy.
და ეს სადაც თქვენ აპირებთ უნდა ცალკე memmove
გახვეული-გარშემო ნაწილი თქვენი რიგიდან.
არარის შეშფოთება თუ ბოლომდე არ გაკეთებულა.
ეს არის უფრო რთული, ვიდრე დასტის, ბიძგი, და საესტრადო.
>> ვინმეს აქვს რაიმე კოდი შეგვეძლო მუშაობა?
მაშინაც კი, თუ მთლიანად არასრული?
[სტუდენტური] ჰო მთლიანად არასრული, თუმცა.
სრულიად არასრული კარგად არის, სანამ ჩვენ, შეგიძლიათ შეინახოთ შეტანილი?
მე დაგვავიწყდეს, რომ თითოეული დრო.
Okay, იგნორირება, რა მოხდება მაშინ, როდესაც ჩვენ გვჭირდება ზომის შეცვლა რამ.
მთლიანად იგნორირება Resize.
ახსენით ეს კოდი.
მე შემოწმების პირველ რიგში, თუ ზომა ნაკლებია, ვიდრე ასლი, პირველ რიგში,
და შემდეგ ამის შემდეგ, მე ჩადეთ-მე უფროსი + ზომა,
მე და დარწმუნდით, რომ იგი დასრულდება გარშემო რანგში მასივი,
მე და ჩადეთ ახალი სიმებიანი იმ თანამდებობაზე.
მერე გაზრდის ზომა და დაუბრუნოს ჭეშმარიტი.
>> [Rob ბ] ეს არის ნამდვილად ერთი იმ შემთხვევებში, როდესაც თქვენ აპირებთ უნდა გამოყენებით mod.
ნებისმიერი სახის შემთხვევაში, როდესაც თქვენ არ შესაფუთი გარშემო, თუ ფიქრობთ, შესაფუთი გარშემო,
დაუყოვნებლივ აზრის უნდა იყოს mod.
როგორც სწრაფი ოპტიმიზაცია / გააკეთოთ თქვენი კოდი ერთ ხაზს მოკლეა,
თქვენ შეამჩნევთ, რომ ხაზი დაუყოვნებლივ შემდეგ ამ ერთი
უბრალოდ ზომა + +, ასე რომ თქვენ შერწყმა, რომ ამ ხაზზე, ზომა + +.
ახლა ქვევით აქ, ჩვენ გვაქვს საქმე
სადაც ჩვენ არ გვაქვს საკმარისი მეხსიერება,
ასე რომ, ჩვენ გავაძლიერებთ ჩვენს მიერ მოცულობა 2.
ვფიქრობ, თქვენ შეიძლება იგივე პრობლემა აქ, მაგრამ შეგვიძლია იგნორირება ეს არის,
აქ თუ ვერ მოხერხდა გაზრდის თქვენს მოცულობა,
მაშინ ვაპირებთ გვინდა შეამცირებს თქვენს მიერ მოცულობა 2 ერთხელ.
კიდევ ერთი მოკლე შენიშვნა არის, ისევე, როგორც თქვენ შეგიძლიათ + =,
ასევე შეგიძლიათ გააკეთებს << =.
თითქმის ყველაფერი შეიძლება წავიდეს ადრე შეადგენს, + =, | =, = &, << =.
ჩარ * ახალი არის ჩვენი ახალი ბლოკი მეხსიერება.
ოჰ, მეტი აქ.
>> რას ფიქრობს ხალხი შესახებ გაცნობის ჩვენი ახალი ბლოკი მეხსიერება?
[სტუდენტური] უნდა იყოს char **.
ფიქრი თავში ჩვენი struct აქ,
სიმები არის ის, რაც ჩვენ reallocating.
ვაკეთებთ მთელი ახალი დინამიური შენახვისა და ელემენტების რიგში.
ის, რასაც ჩვენ ვაპირებთ იყოს მინიჭების თქვენს სიმები არის ის, რაც ჩვენ mallocing ახლავე,
და ა.შ. ახალი იქნება char **.
ეს იქნება მასივი სტრიქონები.
მაშინ, რა არის საქმე, რომელსაც ჩვენ ვაპირებთ დაბრუნებას ყალბი?
[სტუდენტური] უნდა ვიყოთ აკეთებს char *?
[Rob ბ] დიახ, კარგი ზარი.
[სტუდენტური] რა იყო ეს?
[Rob ბ] ჩვენ გვინდოდა ჯანმრთელობის სფეროში გაგვეკეთებინა ზომა char * იმიტომ, რომ ჩვენ აღარ-
ეს რეალურად იქნება ძალიან დიდი პრობლემა, რადგან sizeof (char) იქნება 1.
Sizeof char * იქნება 4,
ასე ბევრი დრო, როდესაც თქვენ საქმე ints,
თქვენ ტენდენცია მიიღოს away მასთან რადგან ზომა int და ზომის int *
on 32-bit სისტემა იქნება იგივე.
მაგრამ აქ, sizeof (char) და sizeof (char *) ახლა იქნება იგივე.
>> რა არის გარემოება, სადაც ჩვენ დაბრუნების ყალბი?
[სტუდენტური] ახალი არის null.
ჰო, თუ ახალი არის null, ვბრუნდებით ყალბი,
და მე ვაპირებ ჩააგდოს ქვემოთ აქ-
[სტუდენტური] [inaudible]
[Rob ბ] ჰო, ეს არის ჯარიმა.
თქვენ შეიძლება არც გააკეთონ 2 ჯერ ტევადობა ან მოცულობა Shift 1 და შემდეგ მხოლოდ მითითებული მისი დანგრევა აქ ან რასაც.
ჩვენ გავაკეთებთ, როგორც ჩვენ გვქონდა ეს.
მოცულობა >> = 1.
და თქვენ არასოდეს გვექნება ფიქრი დაკარგვის 1 ადგილს
იმიტომ, რომ თქვენ დაუტოვებიათ გადავიდა მიერ 1, ასე რომ 1 ადგილი აუცილებლად 0,
ამიტომ უფლებას თავიანთ მიერ 1, თქვენ მაინც იქნება ჯარიმა.
[სტუდენტური] თქვენ უნდა გავაკეთოთ, რომ ადრე დაბრუნების?
[Rob ბ] დიახ, ეს ხდის აბსოლუტურად აზრი არ აქვს.
>> ახლა ვივარაუდოთ ჩვენ ვაპირებთ დასრულდება მდე დაბრუნების ჭეშმარიტი ბოლომდე.
გზა ჩვენ ვაპირებთ ამ memmoves,
ჩვენ უნდა ფრთხილად თუ როგორ გავაკეთოთ ისინი.
ვინმეს გაქვთ რაიმე შემოთავაზება თუ როგორ გავაკეთოთ ისინი?
აი ჩვენი დაწყება.
აუცილებლად, ჩვენ გვინდა, რომ დაიწყოს დასაწყისში კვლავ
და ასლი რამ იქიდან, 1, 3, 4, 2.
როგორ გავაკეთოთ ეს?
პირველ რიგში, მე უნდა შევხედოთ მამაკაცს გვერდი memmove ერთხელ.
Memmove, ბრძანებით არგუმენტები ყოველთვის მნიშვნელოვანია.
გვსურს, ჩვენი დანიშნულების პირველი წყარო მეორე, მესამე ზომა.
არსებობს უამრავი ფუნქციები, რომელიც შეცვალოს წყარო და დანიშნულების.
დანიშნულების წყარო აპირებს იყოს თანმიმდევრული გარკვეულწილად.
ნაბიჯი, რა არის ეს დაბრუნების?
ის დააბრუნებს მომცეთ დანიშნულების, სხვადსხვა მიზეზის გამო დაგვჭირდება, რომ.
შემიძლია ნახატის წაიკითხავს, ​​მაგრამ გვინდა ვიაროთ ჩვენი დანიშნულების.
>> რა არის ჩვენი დანიშნულების იქნება?
[სტუდენტური] ახალი.
[Rob ბ] დიახ, და სადაც ჩვენ კოპირება საწყისი?
პირველი, რაც ჩვენ გადაწერა ეს 1, 3, 4.
რა არის ეს-1, 3, 4.
რა არის მისამართი ამ 1?
რა არის მისამართი, რომელიც 1?
[სტუდენტური] [inaudible]
[Rob ბ] უფროსი + მისამართი პირველი ელემენტს.
როგორ მივიღებთ პირველ ელემენტს მასივი?
[სტუდენტური] რიგიდან.
[Rob ბ] დიახ, q.strings.
გახსოვდეთ, აქ, ჩვენი ხელმძღვანელი არის 1.
Darn იგი. მე უბრალოდ ვფიქრობ, რომ magically-
აქ, ჩვენი ხელმძღვანელი არის 1. მე ვაპირებ შევცვალო ჩემი ფერი ძალიან.
აქ არის სიმები.
ეს, ჩვენ შეგვიძლია ან წერენ, როგორც გავაკეთეთ მეტი აქ
თავაკებით + q.strings.
ბევრი ადამიანი ასევე დაწერა და q.strings [ხელმძღვანელი].
ეს არ არის ნამდვილად ნებისმიერი ნაკლებად ეფექტური.
თქვენ ალბათ ფიქრობთ, ეს როგორც თქვენ dereferencing და მერე მიღების მისამართს,
მაგრამ შემდგენელი აპირებს თარგმნოს ის, თუ რა გვქონდა ადრე მაინც, q.strings + ხელმძღვანელი.
ნებისმიერ შემთხვევაში გსურთ ვფიქრობ იგი.
>> და რამდენი ბაიტი გვინდა კოპირება?
[სტუდენტური] სიმძლავრე - ხელმძღვანელი.
სიმძლავრე - ხელმძღვანელი.
და მაშინ შეიძლება ყოველთვის წერენ გარეთ მაგალითად
გაერკვნენ თუ ეს უფლება.
[სტუდენტური] უნდა იყოფა 2 შემდეგ.
ჰო, ისე, ვფიქრობ, ჩვენ შეგვიძლია გამოვიყენოთ ზომა.
ჩვენ კვლავ გვაქვს ზომა მყოფი-
გამოყენებით ზომა, ჩვენ გვაქვს ზომა ტოლია 4.
ჩვენი ზომა არის 4. ჩვენი ხელმძღვანელი არის 1.
ჩვენ გვინდა, რომ კოპირება ამ 3 ელემენტებს.
სწორედ საღი აზრის შესამოწმებლად, რომ ზომა - ხელმძღვანელი არის სწორად 3.
და ბრუნდება აქ, როგორც ჩვენ დაწყებამდე განაცხადა,
თუ ჩვენ გამოყენებული სიმძლავრე, მაშინ ჩვენ ავღნიშნო უნდა დაყოს მიერ 2
იმიტომ, რომ ჩვენ უკვე გაიზარდა ჩვენი მოცულობა, ამიტომ ჩვენ ვაპირებთ გამოვიყენოთ ზომა.
რომ ასლები, რომ ნაწილი.
ახლა ჩვენ გვჭირდება კოპირება სხვა ნაწილი, ნაწილი, რომელიც დარჩა დაწყება.
>> რომ აპირებს memmove შევიდა რა პოზიცია?
[სტუდენტური] Plus ზომა - ხელმძღვანელი.
დიახ, ასე რომ ჩვენ უკვე გადაწერილი ზომის - უფროსი ბაიტი,
და ასე თუ სად გვინდა კოპირება დარჩენილი ბაიტი არის ახალი
და მერე ზომა მინუს-კარგად, ბაიტების რაოდენობას ჩვენ უკვე გადაწერილი სისტემაში
და მაშინ სად ვიმყოფებით კოპირება საწყისი?
[სტუდენტური] Q.strings [0].
[Rob ბ] დიახ, q.strings.
ჩვენ შეგვეძლო არც გააკეთებს და q.strings [0].
ეს არის მნიშვნელოვნად ნაკლებია ვიდრე საერთო ამ.
თუ ეს უბრალოდ იქნება 0, მაშინ თქვენ ტენდენცია ვხედავ q.strings.
სწორედ აქ ჩვენ კოპირება საწყისი.
რამდენი ბაიტი ჩვენ არ დაუტოვებიათ კოპირება? >> [სტუდენტური] 10.
მარჯვენა.
[სტუდენტური] გვაქვს, რომ გავამრავლოთ 5 - 10 ჯერ ზომა ბაიტებში ან რაღაც?
ჰო, ასე რომ ეს არის სადაც რას ზუსტად ჩვენ გადაწერა?
[სტუდენტური] [inaudible]
რა არის გაცნობის რამ ჩვენ გადაწერა?
[სტუდენტური] [inaudible]
ჰო, ისე, char * s რომ ჩვენ გადაწერა, არ ვიცით, სადაც მოდის.
, სადაც ისინი მიუთითებს, როგორიცაა სიმები, ჩვენ დასრულდება მდე ზრდის ის გადატანა მდგომ
ან enqueuing გადატანა რიგიდან.
სადაც მოდის, არ ვიცით.
ჩვენ უბრალოდ უნდა ტრეკზე char * s თავს.
ჩვენ არ გვინდა კოპირება ზომა - უფროსი bytes.
ჩვენ გვინდა, რომ კოპირება ზომა - უფროსი char * s,
ამიტომ ჩვენ ვაპირებთ გავამრავლოთ ამ მიერ sizeof (char *).
იგივე ქვემოთ აქ ხელმძღვანელმა * sizeof (char *).
>> [სტუდენტური] რა [inaudible]?
ეს უფლება აქ?
[სტუდენტური] არ არის, ქვემოთ, რომ ზომა - ხელმძღვანელი.
[Rob ბ] ეს უფლება აქ?
Pointer არითმეტიკული.
როგორ მაჩვენებელი არითმეტიკული იმუშავებს არის
ეს ავტომატურად multiplies მიერ ზომის ტიპის, რომ ჩვენ საქმე გვაქვს.
ისევე აქ, ახალი + (ზომა - უფროსი)
სწორედ ექვივალენტური და ახალი [ზომა - უფროსი]
სანამ ჩვენ ვიმედოვნებთ, რომ მუშაობა სწორად,
რადგან თუ ჩვენ საქმე გვაქვს int array, მაშინ რა ინდექსი მიერ GEO-
ან, თუ ის საქართველოს ზომა 5 და გინდათ მე -4 ელემენტს, მაშინ ჩვენ ინდექსი შევიდა
int array [4].
თქვენ don't-[4] * ზომა int.
მოდული ავტომატურად, და ამ შემთხვევაში
არის სიტყვასიტყვით ექვივალენტი, ამიტომ bracket სინტაქსი
უბრალოდ იქნება მოაქცია ამ როგორც კი შეადგინოს.
რომ რაღაც თქვენ უნდა ფრთხილად, რომ
როდესაც თქვენ დასძინა ზომა - უფროსი
თქვენ დასძინა არა ერთი ბაიტი.
თქვენ დასძინა ერთი char *, რომელიც შეიძლება ერთი ბაიტი ან რასაც.
>> გაქვთ სხვა კითხვები?
Okay, dequeue იქნება ადვილი.
მე მივცემ თქვენ წუთიანი განახორციელოს.
ოჰ, და მე ვფიქრობ, ეს არის იგივე სიტუაცია, სადაც
რა enqueue შემთხვევაში, თუ ჩვენ enqueuing null,
იქნებ გვინდა გაუმკლავდეს მას, იქნებ ჩვენ არ.
ჩვენ არ გავაკეთებთ ერთხელ აქ, მაგრამ იგივე, რაც ჩვენი დასტის შემთხვევაში.
თუ ჩვენ enqueue null, ჩვენ დაგვჭირდება იგნორირება მას.
ვინმეს აქვს გარკვეული კოდი შემიძლია დახევის up?
[სტუდენტური] მე უბრალოდ dequeue.
ვერსია 2 არის, რომ-okay.
თქვენ მინდა განვმარტო?
[სტუდენტური] პირველი, თქვენ დარწმუნდით, არსებობს რაღაც მდგომ
და რომ ზომა მიდის ქვემოთ მიერ 1.
თქვენ უნდა გავაკეთოთ, და მერე დაბრუნდნენ ხელმძღვანელი
და მაშინ გადატანა Head Up 1.
Okay, ასე რომ, კუთხეში შემთხვევაში ჩვენ უნდა განიხილოს. Yeah.
[სტუდენტური] თუ თქვენი უფროსი არის ბოლო ელემენტს,
მაშინ არ მინდა უფროსი აღვნიშნო გარეთ მასივი.
>> ჰო, ისე, როგორც კი უფროსი ჰიტები ბოლოს ჩვენი მასივი,
როდესაც ჩვენ dequeue, ჩვენი ხელმძღვანელი უნდა modded თავში 0.
სამწუხაროდ, ჩვენ არ შეგვიძლია გავაკეთოთ, რომ ერთი ნაბიჯით.
ვფიქრობ გზა მინდა ალბათ გაასწორონ ის არის
ეს იქნება char *, რა ჩვენ დაბრუნებას,
რასაც თქვენი ცვლადის სახელი სურს.
მაშინ ჩვენ გვინდა თავდაცვის სამინისტროს ხელმძღვანელი ჩვენი მოცულობა
და შემდეგ დაბრუნდნენ ret.
ბევრი ადამიანი აქ მათ შეიძლება გავაკეთოთ-
ეს შემთხვევა-you'll ხალხს, თუ ხელმძღვანელი
მეტია მოცულობა, გავაკეთოთ ხელმძღვანელი - ტევადობა.
და ეს მხოლოდ სამუშაო გარშემო რა mod არის.
უფროსი mod = ტევადობა ბევრად სუფთა
საქართველოს შესაფუთი გარშემო, ვიდრე თუ ხელმძღვანელი მეტი ტევადობის ხელმძღვანელი - ტევადობა.
>> კითხვები?
Okay, ბოლო რამ ჩვენ არ დაუტოვებიათ არის ჩვენი დაკავშირებული სიაში.
თქვენ შეიძლება გამოყენებულ იქნას ზოგიერთი უკავშირდება სია ქცევის თუ გააკეთეს
უკავშირდება სიები თქვენს hash მაგიდები, თუ რა გააკეთეთ hash მაგიდასთან.
გირჩევთ აკეთებს hash მაგიდასთან.
თქვენ ალბათ უკვე გაკეთდა trie,
მაგრამ ცდილობს უფრო რთულია.
თეორიულად, ისინი asymptotically უკეთესი.
მაგრამ შევჩერდეთ დიდი საბჭო,
და ცდილობს არასდროს უკეთესად, და მათ დასჭირდეს მეტი მეხსიერება.
ყველაფერი ცდილობს დამთავრდა თუ არა უარესი მეტი მუშაობა.
ეს არის ის, რაც დავით Malan მისი გადაწყვეტა ყოველთვის არის
არის ის ყოველთვის შეტყობინება მისი trie გადაწყვეტა და ვნახოთ სადაც გაკეთებული არის.
რა იყო ის ქვეშ, დავით J?
ის # 18, ისე, რომ არ საშინლად ცუდი,
და ეს იქნება ერთ ერთი საუკეთესო ცდილობს შეგიძლიათ წარმოიდგინოთ, რომ
ან ერთ ერთი საუკეთესო ცდილობს of trie.
არის თუ არა არც კი მისი ორიგინალური გადაწყვეტა?
ვგრძნობ, როგორიცაა trie გადაწყვეტილებები უფრო ამ სპექტრს RAM გამოყენება.
>> ზემოთ ქვემოთ ძალიან ზევით, და RAM გამოყენება არის ერთჯერადი თანრიგისაგან.
მჯდომარე მიმართ ბოლოში, და მერე დაიწყოს ხედავს ცდილობს
სადაც თქვენ მიიღოს აბსოლუტურად მასიური RAM გამოყენება,
და ცდილობს უფრო რთულია.
მთლიანად არ ღირს, მაგრამ საგანმანათლებლო გამოცდილებას, თუ რა გააკეთეთ ერთი.
ბოლო რამ არის ჩვენი დაკავშირებული სიაში,
და ეს სამი რამ, stacks, რიგები, და დაკავშირებული სიები
ნებისმიერი მომავალი რამ ოდესმე გააკეთოს კომპიუტერულ მეცნიერებათა
აიღებს გაქვთ მნიშვნელოვანია იმ ეს ყველაფერი.
ისინი არა იმდენად ფუნდამენტურია ყველაფერი.
>> უკავშირებს სიებს და აქ ჩვენ საგნით უკავშირდება სია იქნება ჩვენი განხორციელება.
რას უკავშირდება საგნით ნიშნავს ნაცვლად ორმაგად უკავშირდება? დიახ.
[სტუდენტური] ეს მხოლოდ მიუთითებს შემდეგი მაჩვენებელი, ვიდრე გჭირდებათ,
მოსწონს ერთი წინა და ერთი მის შემდეგ.
ჰო, ისე სურათში ფორმატში, რა მე უბრალოდ?
მე ორი რამ. მაქვს სურათი და ნახატი.
სურათების ფორმატი, ჩვენი საგნით უკავშირდება სიები
აუცილებლად, ჩვენ გვაქვს გარკვეული სახის მომცეთ ხელმძღვანელი ჩვენს სიაში,
და შემდეგ შიგნით ჩვენს სიაში, ჩვენ უბრალოდ უნდა პოინტერები,
და იქნებ ეს მიუთითებს null.
ეს იქნება თქვენი ტიპიური ნახაზი საგნით უკავშირდება სიაში.
ორმაგად უკავშირდება სიაში, შეგიძლიათ გადასვლა უკან.
თუ მე გაძლევთ ნებისმიერი კვანძის სიაში, მაშინ აუცილებლად მისაღებად
ნებისმიერი სხვა კვანძის სიაში თუ ის ორმაგად უკავშირდება სიაში.
მაგრამ თუ მივიღებ თქვენ მესამე კვანძის სიაში და ეს საგნით უკავშირდება სია,
არანაირად არ თქვენ ოდესმე აპირებს მისაღებად პირველი და მეორე კვანძების.
და არსებობს სარგებელი და detriments, და ერთი აშკარა ერთი
არის თქვენ დასჭირდეს მეტი ზომის, და თქვენ უნდა ტრეკზე, სადაც ეს ყველაფერი მიუთითებს არის.
მაგრამ ჩვენ მხოლოდ აინტერესებს საგნით უკავშირდება.
>> ცოტა რამ ჩვენ ვაპირებთ უნდა განახორციელოს.
შენი typedef struct კვანძში, int i: struct კვანძის * შემდეგი; კვანძში.
რომ typedef უნდა დაწვეს თქვენს გონებაში.
Quiz 1 უნდა იყოს მისცეს typedef of უკავშირდება სია კვანძში,
და თქვენ უნდა შეეძლოს დაუყოვნებლივ scribble რომ ქვევით
გარეშე კი ფიქრობდა იგი.
ვფიქრობ წყვილი კითხვები, რატომ გვჭირდება struct აქ?
რატომ არ შეუძლიათ ჩვენ ვამბობთ კვანძის *?
[სტუდენტური] [inaudible]
Yeah.
ერთადერთი, რაც განსაზღვრავს კვანძის როგორც რამ
არის typedef თავად.
მაგრამ, როგორც ამ ეტაპზე, როცა ჩვენ სახის დამუშავება ამ struct კვანძის განმარტება,
ჩვენ არ დასრულებულა ჩვენი typedef გაუკეთებია, რადგან typedef არ დასრულებულა,
კვანძი არ არსებობს.
მაგრამ struct კვანძის აკეთებს, და ამ კვანძის აქ,
ამ შეიძლება მოუწოდა არაფერი.
ეს შეიძლება ეწოდოს n.
ეს შეიძლება ეწოდოს დაკავშირებული სიაში კვანძში.
შეიძლება მოუწოდა არაფერი.
მაგრამ ეს struct კვანძის საჭიროებს მოუწოდა იგივე როგორც ამ struct კვანძში.
რა რეკავთ ამ აქვს ასევე აქ,
და ისე, რომ ასევე პასუხობს მეორე წერტილი კითხვა
რის გამოც-უამრავი ჯერ როდესაც ხედავთ structs და typedefs of structs,
დაინახავთ ანონიმური structs სადაც თქვენ უბრალოდ ნახეთ typedef struct,
განხორციელების struct, ლექსიკონი, ან რასაც.
>> რატომ აქ გვჭირდება ვთქვა კვანძის?
რატომ არ შეიძლება ეს იყოს ანონიმური struct?
თითქმის იგივე პასუხი.
[სტუდენტური] თქვენ უნდა უწოდებს ფარგლებში struct.
Yeah, ფარგლებში struct, თქვენ უნდა მიმართოს struct თავად.
თუ არ მისცეს struct სახელი, თუ ის ანონიმური struct, ვერ უწოდებს.
და ბოლოს მაინც-ეს უნდა იყოს გარკვეულწილად მარტივია,
და მათ უნდა დაეხმაროს ხვდები თუ თქვენ წერა ამ ქვევით
რომ თქვენ აკეთებთ რაღაც თუ ეს სახის რამ არ აქვს აზრი.
ბოლო მაგრამ არა მაინც, რატომ ამ უნდა იყოს struct კვანძის *?
რატომ არ შეიძლება ეს უბრალოდ უნდა struct კვანძის შემდეგი?
[სტუდენტური] მომცეთ შემდეგი struct.
სწორედ აუცილებლად რაც გვინდა.
რატომ შეიძლება იგი არასოდეს არ იქნება struct კვანძის შემდეგი?
რატომ უნდა იყოს struct კვანძის * შემდეგი? Yeah.
[სტუდენტური] ეს მოსწონს უსასრულო ციკლი.
Yeah.
[სტუდენტური] უმჯობესი იქნება ერთ.
ჰო, უბრალოდ ფიქრობთ, როგორ მოიქცევიან ზომა ან რამე.
ზომა struct ძირითადად + ან - ზოგიერთი ნიმუში აქ ან იქ.
ეს ძირითადად იქნება თანხა ზომის რამ struct.
ეს უფლება აქ, შეცვლის გარეშე არაფერი, ზომა იქნება ადვილი.
ზომა struct კვანძის იქნება ზომა i + ზომა შემდეგი.
ზომა I იქნება 4. ზომა შემდეგი იქნება 4.
ზომა struct კვანძის იქნება 8.
თუ ჩვენ არ გვაქვს *, ფიქრი sizeof,
მაშინ sizeof (I) იქნება 4.
ზომა struct კვანძის შემდეგი იქნება ზომა i + ზომა struct კვანძის შემდეგი
+ ზომა i + ზომა struct კვანძის შემდეგი.
კარგი იქნება უსასრულო უკან კვანძების.
ამიტომ ასე რამ უნდა იყოს.
>> ერთხელ, აუცილებლად გვემახსოვრება, რომ,
ან თუნდაც გაგება საკმარისი რომ თქვენ შეგიძლიათ შეძლებს
მიზეზი მეშვეობით, თუ რას უნდა გამოიყურებოდეს.
რამ ჩვენ ვაპირებთ სურთ განახორციელონ.
თუ სიგრძეზე სიაში-
თქვენ შეიძლება მოატყუო და შეინახოს გარშემო
გლობალური სიგრძის ან რაღაც, მაგრამ ჩვენ არ ვაპირებთ გავაკეთოთ, რომ.
ჩვენ ვაპირებთ ითვლიან სიგრძეზე სიაში.
ჩვენ შეიცავს, ასე რომ ძირითადად მოსწონს ძებნა,
ამიტომ ჩვენ გვაქვს უკავშირდება სიაში რიცხვებით თუ ამ რიცხვის არის დაკავშირებულია სიაში.
Prepend აპირებს ჩადეთ დასაწყისში სიაში.
დამატება აპირებს ჩადეთ დასასრულს.
Insert_sorted აპირებს INSERT INTO დახარისხებული თანამდებობა სიაში.
Insert_sorted სახის ვარაუდობს, რომ თქვენ არასოდეს არ გამოუყენებია prepend ან დამატება ცუდ გზებს.
>> Insert_sorted როცა თქვენ განხორციელების insert_sorted-
ვთქვათ გვაქვს უკავშირდება სიაში.
ეს არის ის, რაც მას გაკეთებული ჰგავს, 2, 4, 5.
მინდა ჩადეთ 3, ასე რომ სანამ სიაში თავად უკვე დახარისხებული,
ადვილი მოძიების, სადაც 3 ეკუთვნის.
მე იწყება 2.
Okay, 3 მეტია 2, ასე რომ მინდა შენარჩუნება აპირებს.
ოჰ, 4 ძალიან დიდი, ასე რომ მე ვიცი 3 აპირებს წავიდეს შორის 2 და 4,
და მე უნდა დააფიქსიროს მაჩვენებლებისა და ყველა რომ პერსონალი.
მაგრამ თუ ჩვენ არ მკაცრად გამოიყენოს insert_sorted,
მინდა მოდით უბრალოდ, ვამბობთ მე prepend 6,
მაშინ ჩემი დაკავშირებული სიაში აპირებს გახდეს ამ.
ახლა აზრი არ აქვს, ისე insert_sorted, შეგიძლიათ უბრალოდ ვივარაუდოთ
რომ სიაში დალაგებულია, თუმცა ოპერაციების არსებობს
რომელიც შეიძლება გამოიწვიოს იგი არ იყოს დახარისხებული, და ამით ყველაფერი მთავრდება.
მოძებნა გამოსადეგი ჩანართით ისე ეს ის ძირითადი რამ, რაც სხვებისათვის უნდა განახორციელოს.
>> ახლა მიიღოს წუთის გავაკეთოთ სიგრძე და შეიცავს,
და იმ უნდა იყოს შედარებით სწრაფი.
Nearing დახურვის დრო, ასე რომ ვინმეს აქვს რამე სიგრძე ან შეიცავს?
ისინი იქნება თითქმის იდენტურია.
[სტუდენტური] სიგრძე.
ვნახოთ, გადასინჯვის.
Okay.
თქვენ მინდა განვმარტო?
[სტუდენტური] მე უბრალოდ შექმნათ კურსორი კვანძის და ინიციალიზაცია მას პირველი, რომელიც ჩვენი გლობალური ცვლადი,
და მერე შეამოწმეთ თუ null ასე რომ არ მიიღოთ seg ბრალია და დაბრუნების 0 თუ ეს საქმე.
წინააღმდეგ შემთხვევაში, მე loop მეშვეობით, შენახვა ტრეკზე ფარგლებში მთელი რიცხვი
რამდენჯერ მე შემოწმდა შემდეგი ელემენტის სიაში
და იმავე ნამატი ოპერაცია ასევე წვდომას, რომ ფაქტობრივი ელემენტს,
და მერე მუდმივად მიიღოს შეამოწმეთ, რომ ეს null,
და თუ ეს null, მაშინ ხერხდება და მხოლოდ ბრუნდება რაოდენობის ელემენტები მე შემოწმდა.
>> [Rob ბ] ვინმეს აქვს რაიმე კომენტარს არაფერი?
ეს გამოიყურება ჯარიმა სისწორის ჭკვიანი.
[სტუდენტური] არა მგონია, თქვენ უნდა კვანძის == null.
ჰო, ასე რომ, თუ კვანძის == null დაბრუნების 0.
მაგრამ თუ კვანძის == null მაშინ ამ-oh, არსებობს სისწორის საკითხი.
ეს იყო მხოლოდ თქვენ დაბრუნების მე, მაგრამ ეს არ ფარგლებს ახლავე.
თქვენ უბრალოდ უნდა int i, ასე რომ = 0.
მაგრამ თუ კვანძის არის null, მერე ისევ იქნება 0,
და ჩვენ ვაპირებთ დაბრუნებას 0, ასე რომ ამ შემთხვევაში იდენტურია.
კიდევ ერთი საერთო რამ არის შენარჩუნება დეკლარაცია
საქართველოს კვანძის შიგნით ამისთვის loop.
თქვენ შეიძლება ითქვას-ო, არა.
მოდით შეინახოს იგი როგორც ამ.
მე ალბათ დააყენა int i = 0 აქ,
შემდეგ კვანძის * node = პირველი აქ.
და ეს არის ალბათ ასე, მოშორების ეს ახლა.
ეს არის ალბათ როგორ მინდა არ წერია ეს.
თქვენ შეიძლება ასევე-ეძებს ის მოსწონს ეს.
ამ loop სტრუქტურა უფლება აქ
უნდა იყოს თითქმის როგორც ბუნებრივი თქვენ როგორც int i = 0
მე ნაკლებია, ვიდრე სიგრძეზე მასივი მე + +.
თუ ასე თქვენ iterate მეტი მასივი, ასე თქვენ iterate მეტი უკავშირდება სიაში.
>> ეს უნდა იყოს მეორე ბუნება რაღაც მომენტში.
ამის გათვალისწინებით, ეს იქნება თითქმის იგივე.
თქვენ ვაპირებთ გვინდა iterate მეტი დაკავშირებული სიაში.
თუ node-არ ვიცი რა ღირებულება ეწოდება.
Node მე.
თუ ღირებულება, რომ კვანძის = ვბრუნდები ასეა, და ამით ყველაფერი მთავრდება.
გაითვალისწინეთ, რომ ერთადერთი გზა ჩვენ უნდა დააბრუნოს ყალბი
არის თუ ჩვენ iterate მთელ უკავშირდება სიაში და არასდროს დაბრუნდება ასეა,
ასე რომ რა ეს იმას.
როგორც მინიშნება-ჩვენ ალბათ ვერ მიიღებენ, რათა დამატება ან prepend.
>> სწრაფი ბოლო შენიშვნა.
თუ ხედავთ სტატიკური სიტყვით, ასე ვთქვათ სტატიკური int რაოდენობა = 0,
შემდეგ ვაკეთებთ რაოდენობა + +, შეგიძლიათ ძირითადად ვფიქრობ, რომ ეს გლობალური ცვლადი,
მიუხედავად იმისა, რომ მე უბრალოდ განაცხადა, რომ ეს არ არის, თუ როგორ ვაპირებთ განვახორციელოთ სიგრძე.
მე ამით აქ და შემდეგ ითვლიან + +.
არანაირად შეგვიძლია შემოსვლა კვანძის ჩვენს დაკავშირებული სიაში ჩვენ დამატება ჩვენი რაოდენობა.
წერტილი ეს რა სტატიკურ სიტყვით ნიშნავს.
თუ მე უბრალოდ ჰქონდა int რაოდენობა = 0, რომელიც იქნება რეგულარული წლის გლობალური ცვლადი.
რა სტატიკურ int რაოდენობა ნიშნავს, რომ ეს არის გლობალური ცვლადი ამ ფაილის.
შეუძლებელია, რომ ზოგიერთი სხვა ფაილი,
მინდა იფიქრონ pset 5, თუ თქვენ არ დაიწყო.
თქვენ გაქვთ ორივე speller.c, და თქვენ dictionary.c,
და თუ უბრალოდ განაცხადოს რამ გლობალური, მაშინ არაფერი speller.c
შეიძლება გამოიყენოთ in dictionary.c და პირიქით.
გლობალური ცვლადები ხელმისაწვდომია ნებისმიერი. გ ფაილი,
მაგრამ სტატიკური ცვლადები მხოლოდ ხელმისაწვდომი შიგნიდან ფაილი თვით,
ასე შიგნით მართლწერის შემოწმება ან შიგნით dictionary.c,
ეს არის ერთგვარი როგორ მინდა განვაცხადო ჩემი ცვლადი ამისთვის ზომა ჩემი მასივი
ან ზომის ჩემი პუნქტების სიტყვების ლექსიკონი.
მას შემდეგ, რაც მე არ მინდა განვაცხადო გლობალური ცვლადი, რომ ვინმეს ხელი მიუწვდება,
მე ნამდვილად მხოლოდ მაინტერესებს, ჩემი საკუთარი მიზნებისთვის.
>> კარგი რამ შესახებ ეს არის ასევე მთელი სახელი შეჯახების პერსონალი.
თუ რაიმე სხვა ფაილი ცდილობს გლობალური ცვლადში რაოდენობა, რამ წასვლა ძალიან, ძალიან არასწორი,
ასე რომ ეს ლამაზად ინარჩუნებს რამ უსაფრთხო, და მხოლოდ თქვენ შეგიძლიათ თქვათ ეს,
და არავინ შეიძლება და, თუ ვინმე აცხადებს გლობალური ცვლადში რაოდენობა,
მაშინ ხელს არ შეუშლის თქვენი სტატიკური ცვლადში რაოდენობა.
რაც სტატიკური არის. ეს ფაილი გლობალური ცვლადი.
>> კითხვები შესახებ არაფერი?
ყველა კომპლექტი. Bye.
[CS50.TV]