DOUG LLOYD: თუ ვნახე ვიდეო უკან,
მთელი პროცესი შეიძლება ჰქონდეს როგორც ჩანს, ცოტა ჯადოსნური.
როგორ მუშაობს იგი?
როგორ ფუნქციების ვიცით, რომ ისინი უნდა დაველოდოთ და დაველოდოთ, სხვა მნიშვნელობა
დაბრუნებულიყო სხვადასხვა ფუნქცია მოვუწოდებთ, რათა მიიღოთ შედეგი გვინდა?
>> ისე, მიზეზი ამ მუშაობს იმიტომ რაღაც ცნობილია როგორც სტეკი.
როცა რეკავთ ფუნქცია, სისტემა ადგენს განზე ფართი მეხსიერება
რომ ფუნქცია გააკეთებს თავის საქმეს.
ჩვენ მოვუწოდებთ ამ მოცულობით მეხსიერება, მიმდინარეობს გათვალისწინებულია თითოეული ფუნქცია
მოვუწოდებთ დასტის ჩარჩო ან ფუნქცია ფარგლებში.
და როგორც თქვენ შეიძლება ველოდოთ, ამ დასტის ფარგლებში
ცხოვრობს დასტის ნაწილი მეხსიერება.
>> მეტი ფუნქცია დასტის ჩარჩო შეიძლება არსებობდეს მეხსიერება მოცემულ დროს.
თუ მთავარ მოუწოდებს ფუნქცია ნაბიჯი, და ნაბიჯი მოუწოდებს მიმართულებით,
ყველა სამი ფუნქცია აქვს ღია ფარგლებში.
მაგრამ ისინი არ ყველა აქტიურ ფარგლებში.
ეს ფარგლებში მოწყობილი დასტის.
და ჩარჩოს საწყისი ყველაზე ცოტა ხნის წინ მოუწოდა
ფუნქცია ყოველთვის თავზე Stack.
და რომ ყოველთვის აქტიური ჩარჩო.
არსებობს მხოლოდ ნამდვილად ოდესმე ერთი ფუნქცია, რომელიც არის აქტიური დროს.
ეს არის ერთ-ერთი ყველაზე Stack.
>> როდესაც ფუნქცია მოუწოდებს სხვა ფუნქცია, ეს ერთგვარი აჭერს პაუზის.
ეს ერთგვარი შეჩერებულია, ელოდება.
და კიდევ ერთი დასტის ჩარჩო მივიღებთ გადატანა დასტის თავზე მას.
და რომ ხდება აქტიური ჩარჩო.
და ჩარჩო დაუყოვნებლივ ქვემოთ სჭირდება ლოდინი
მანამ, სანამ იგი კვლავ აქტიურ კარკასი ადრე მას შეუძლია განაახლოს თავისი მუშაობა.
როდესაც ფუნქცია სრული და ეს კეთდება,
მისი ჩარჩო popped off Stack.
სწორედ ტერმინოლოგია.
და ჩარჩო დაუყოვნებლივ ქვემოთ, როგორც უბრალოდ განაცხადა,
ხდება ახალი აქტიური ჩარჩო.
>> და თუ ეს მოუწოდებს სხვა ფუნქცია, ის აპირებს პაუზის ერთხელ.
ეს ახალი ფუნქცია დასტის ჩარჩო იქნება უნდა აიძულა გადატანა ზევით Stack.
იგი ყველაფერს გააკეთებს თავის საქმეს.
ეს შეიძლება პოპ უკან off.
და სხვა ფუნქცია ქვემოთ შეიძლება განაახლონ ერთხელ.
>> მოდით გავლა ამ ერთხელ, ეძებს იდეა, რომ factorial ფუნქცია
რომ ჩვენ განსაზღვრული უკან ვიდეო დაინახოს
რამდენად ჯადოსნური უკან ეს რეკურსიული პროცესი მიმდინარეობს.
ასე რომ, ეს არის ჩვენი მთელი ფაილი, უფლება?
ჩვენ განისაზღვრება ორი ფუნქციები ძირითადი და, ფაქტობრივად.
და როგორც ჩვენ შეიძლება ველოდოთ, ნებისმიერი C პროგრამის აპირებს
უნდა დაიწყოს პირველი ხაზი მთავარი.
>> ასე რომ, ჩვენ შევქმნით ახალ დასტის ჩარჩო მთავარი.
და ის აპირებს დაიწყოს გაშვებული.
მთავარი მოუწოდებს printf.
და printf აპირებს ბეჭდვა ფაქტორიალი 5.
ისე, ეს არ ვიცი რა ფაქტორიალი 5 არის,
და ეს ზარი უკვე დამოკიდებულია სხვა ფუნქცია ზარი.
ასე რომ, მთავარი აპირებს პაუზის უფლება არსებობს.
მე კარგად დატოვოს თავისი arrow უფლება არსებობს, ფერი
ის იმავე ფერის, როგორც დასტის ჩარჩო მარჯვენა
მიუთითებს იმაზე, რომ მთავარი აპირებს გაყინვას აქ, ხოლო ის ფაქტორიალი 5 ეწოდება.
>> ასე რომ, ის ფაქტორიალი 5 ეწოდება.
და ის აპირებს დაიწყოს ძალიან დასაწყისში factorial ფუნქცია.
იგი სთხოვს კითხვაზე მე გაუტოლდება 1?
5 = 1?
ისე, არ.
ასე რომ, ის აპირებს დაცემას სხვაგან ნაწილი, დაბრუნების N ჯერ
factorial of n მინუს 1.
ისე, OK.
>> ახლა, ის ფაქტორიალი 5 არის დამოკიდებულია სხვა ზარი
რომ factorial, ჩაბარების 4 როგორც პარამეტრი.
ასე რომ, ის ფაქტორიალი of 5 ჩარჩო, რომ წითელი ჩარჩოში,
აპირებს გაყინვას უფლება არსებობს რომ ხაზი მე მითითებული
და დაველოდოთ ფაქტორიალი 4 დასრულება ის, რაც უნდა გააკეთოს იმისათვის, რომ მაშინ ეს
შეიძლება გახდეს აქტიური ჩარჩო ერთხელ.
>> ასე რომ, Factorial 4 იწყება დასაწყისში ის ფაქტორიალი.
4 უდრის 1?
არა, ასე რომ, ის აპირებს გააკეთოს იგივე.
ის აპირებს დაცემას სხვა ფილიალში.
იგი აპირებს მიიღოს, რომ ხაზი კოდი.
დიახ, მე ვაპირებ დაბრუნებას ოთხჯერ.
Oh, factorial of -3 ასე factorial of 4 დამოკიდებულია factorial 3 დამთავრებული.
>> ასე რომ, მას სჭირდება, რომ მოვუწოდო factorial 3.
და რომ კარგად გავლა იგივე პროცესი კიდევ ერთხელ.
იგი იწყება მეშვეობით, იღებს აქ.
Factorial 3 დამოკიდებული on ფაქტორიალი 1.
ასე რომ, ის ფაქტორიალი 2 იწყება, იღებს აქ.
ეს დამოკიდებულია ფაქტორიალი 1.
Factorial 1 იწყება.
>> OK.
ასე რომ, ახლა, ჩვენ ვიღებთ სადღაც საინტერესოა, არა?
ახლა, 1 უდრის 1.
ასე რომ, ჩვენ დაბრუნდნენ 1.
ამ ეტაპზე, ჩვენ ვუბრუნებთ.
ფუნქცია კეთდება.
ეს ქცევა is-- იქ სხვა არაფერი ეს უნდა გააკეთოს,
და ასე დასტის ჩარჩო ფაქტორიალი 1 pops off.
ეს დასრულდა.
იგი დაბრუნდა 1.
და ახლა, ის ფაქტორიალი 2, რომელიც იყო ჩარჩო დაუყოვნებლივ ქვემოთ
დასტის, ხდება აქტიური ჩარჩო.
>> და მას შეუძლია შეარჩიო სწორედ იქ, სადაც შეჩერდით.
ის ელოდა ფაქტორიალი 1 დასრულება მისი მუშაობა.
ეს უკვე დასრულდა.
ასე რომ, აქ ვართ.
>> Factorial 1 დაბრუნდა ღირებულების 1.
ასე რომ, ის ფაქტორიალი 2 can ვთქვათ დაბრუნდეს 2-ჯერ 1.
მისი მუშაობა არის შესრულებული.
ის დაბრუნდა 2 factorial 3, რომელიც ელოდა კიდეც მას.
Factorial 3 არის ყველაზე ფარგლებში, აქტიური ჩარჩო დასტის.
ასე რომ, ის ამბობს, OK, ასევე, მე ვაპირებ დაბრუნებას 3-ჯერ 2, რომელიც არის 6.
და მე ვაპირებ მისცეს, რომ ვაფასებთ უკან ფაქტორიალი
4, რომელიც უკვე მელოდება.
მე გაკეთდეს.
Factorial 3 pops off დასტის, და ფაქტორიალი 4 არის აქტიური ჩარჩო.
>> 4 ამბობს, OK, მე ვაპირებ დაბრუნებას 4 ჯერ factorial 3, რომელიც ექვსი.
ეს იყო ღირებულება, factorial 3 დაბრუნდა.
ასე რომ 4-ჯერ 6 არის 24.
და მე ვაპირებ გაივლის რომ უკან factorial
5, რომელიც უკვე მელოდება.
Factorial 5 არის აქტიური ჩარჩო.
ის აპირებს დაბრუნებას 5 ჯერ factorial of 4-- 5 ჯერ 24, ან 120--
და მისცეს, რომ მნიშვნელობა უკან მთავარი, რომელსაც აქვს
ელოდა ძალიან მოთმინებით ამისთვის დიდი ხანია ბოლოში დასტის.
>> ეს არის სადაც დაიწყო.
ეს გააკეთა ამ მოწოდებას.
რამდენიმე ფარგლებში აიღო ზედა.
ეს არის უკან ზევით Stack.
ეს არის აქტიური ჩარჩო.
ასე რომ, მთავარი მიიღო ღირებულება 120 უკან ფაქტორიალი 5.
ეს უკვე ელოდება ბეჭდვა, რომ მნიშვნელობა.
და მერე ეს კეთდება.
არ არსებობს უფრო მეტი ხაზი კოდი მთავარ.
ასე რომ, მთავარი ის ფარგლებში pops off დასტის, და ჩვენ გავაკეთეთ.
>> და ასე უკან მუშაობს.
ეს არის ის, თუ როგორ დასტის ფარგლებში მუშაობს.
იმ ფუნქციას რომ მოხდა მანამდე
არიან მხოლოდ პაუზის ელოდება შემდგომი მოუწოდებს
დასრულება, რათა მათ შეიძლება გახდეს აქტიური ვიზრუნოთ და დასრულდება, რაც მათ უნდა გავაკეთოთ.
>> მე Doug Lloyd.
ეს არის CS50.