DOUG LLOYD: როგორც თქვენ დაიწყოს მუშაობის ფუნქციები,
კიდევ ერთი რამ უნდა გახდეს მართლაც მნიშვნელოვანია იმის გაგება,
რომელიც არის კონცეფცია ცვლადი ფარგლებს.
ასე ფარგლებს არის დამახასიათებელი ცვლადი
რომელიც განსაზღვრავს, რომლის ფუნქციები რომ ცვლადი შეიძლება ხელმისაწვდომი იყოს.
>> არსებობს ორი ძირითადი scopes C, ადგილობრივი ცვლადები და გლობალური ცვლადები.
ახლა, ადგილობრივი ცვლადები მხოლოდ ხელმისაწვდომი იყოს ფარგლებში ფუნქციები
რომელშიც ისინი შეიქმნა.
ისინი არ შეიძლება იქნეს ყოველი სხვა ფუნქცია, რომელიც არსებობს თქვენს პროგრამაში,
მხოლოდ ფუნქცია რომლის ის შეიქმნა.
გლობალური ცვლადები წლის მეორე მხრივ, შესაძლებელია
ნებისმიერი ფუნქცია პროგრამა.
და მიზეზი ის არის, იმიტომ, რომ ისინი არ შექმნილა შიგნით
კონკრეტული ფუნქცია.
ჩვენ ვაცხადებთ, მათ გარეთ ყველა ფუნქცია, რომელიც
იმას ნიშნავს, რომ ყოველი ფუნქცია იცის, სადაც ეს არის და შეუძლია და მართვას.
>> ჯერჯერობით, რა თქმა უნდა თქვენ საკმაოდ ბევრი უკვე მუშაობს მხოლოდ
ადგილობრივი ცვლადები.
აი, მაგალითად, ძალიან, ძალიან მარტივი მთავარი ფუნქცია და ძალიან მარტივი
დამატებითი ფუნქცია, რომელიც ჩვენ იწერება.
ამ შემთხვევაში, x, რომელიც მე მწვანეა მხოლოდ
ხაზი გავუსვა რაიონი ან ფარგლებს, რომ ცვლადი,
ადგილობრივი ფუნქცია სამჯერ.
მთავარი ვერ ეხება x ყველა.
ეს არ ვიცი რა არის.
არც ერთი სხვა ფუნქცია, ფაქტობრივად, თუ ჩვენ ჰქონდა დამატებითი ფუნქციები აქ,
შეიძლება მიმართოს x.
>> ანალოგიურად, შედეგები, რომელიც მე ლურჯი, ადგილობრივი მხოლოდ ძირითადი.
მხოლოდ ძირითადი იცის, რა ცვლადი შედეგი არის.
სამჯერ ვერ გამოიყენებს.
>> ახლა, როგორც აღვნიშნე, გლობალური ცვლადები არ არსებობს.
თუ თქვენ აცხადებენ, რომ ცვლადი გარეთ ნებისმიერი ფუნქცია,
ყველა ფუნქციების პროგრამას შეუძლია მიმართოს მას.
ასე რომ, ამ შემთხვევაში, მე მონიშნულია მწვანე გლობალური ცვლადი დეკლარაცია.
ამ შემთხვევაში, ცვლადი ცხადდება
ეწოდება გლობალური, უბრალოდ ძალიან ნათელი შესახებ.
ეს არის ტიპის float.
და მე დაავალოს ეს ღირებულება 0,5050.
>> თქვენ შეამჩნევთ, რომ მთავარ და სამჯერ, მე შეუძლია ეხება გლობალური.
და სინამდვილეში, თუ მე გავლა პროგრამა როგორც მითითებულია, მთავარი, პირველი ზარები სამჯერ,
სამმაგი მრავლდება გლობალური 3, რომელიც ადგენს მისი ღირებულება 1,5 რაღაც,
1.51 ან რამე მაგდაგვარს და შემდეგ მთავარ ასევე ბეჭდავს out ღირებულება
გლობალური.
ასე რომ, მთავარი არ ამობეჭდოთ 0,5050, ეს ამობეჭდოთ გლობალური ჯერ 3, 1.51.
ასე, რომ თქვენ მოხვდით ფრთხილად, როდესაც თქვენ მუშაობის გლობალური ცვლადები.
მიუხედავად იმისა, რომ ისინი ძალიან მოქნილი მიმდინარეობს შეუძლია გაიაროს ინფორმაცია
დაახლოებით ისე, რომ ყოველ ფუნქცია შეგიძლიათ გამოიყენოთ იგი,
იგი ასევე შეიძლება ჰქონდეს საშიში შედეგები
იმ შემთხვევაში, თუ ერთი ფუნქცია ცვლილებები ღირებულება ცვლადი
სანამ ველოდებით, რომ ეს უნდა შეიცვალოს.
>> რატომ ეს განსხვავება აქვს?
რატომ აღელვებს თუ არა ზოგიერთი ცვლადის ადგილობრივი და სხვები არიან გლობალური?
ისე, უმეტესწილად, ადგილობრივი ცვლადები დო ვართ რასაც მიერ მიღებულ ღირებულება
როდესაც ჩვენ ფუნქცია ზარი.
რას ნიშნავს ეს?
>> ისე, როცა ცვლადი გავიდა მიერ ღირებულება, Callee, რომელიც
არის კიდევ ერთი გზა ამბობდა ფუნქცია რომ იღებს ცვლადი, რომ
იღებს გავიდა, როგორც შეყვანის, ის რეალურად არ მიიღებს, რომ ცვლადი თავად.
იგი იღებს თავისი ასლი მუშაობა.
ეს არის ძალიან მნიშვნელოვანი განსხვავება.
დავინახეთ, მეორე წინ რომ გლობალური ცვლადები,
თუ ჩვენ მანიპულირება გლობალური ცვლადი ერთი ფუნქცია, ეფექტი
რომ ერთი ფუნქცია ახორციელებს გადის ყოველ მეორე ფუნქცია.
>> მაგრამ ადგილობრივი ცვლადები, ეს არ არის ჭეშმარიტი.
თითოეული ფუნქცია, როდესაც ის იღებს ცვლადები, როგორც შეყვანის
ასლი იმ ცვლადების, არ ცვლადები თავს.
რა არის გვერდითი ეფექტი, რომ?
ეს ნიშნავს, რომ ცვლადი აბონენტის, ფუნქცია, რომელიც
არის მიღების ფუნქცია ზარი, არის უცვლელი თუ არ override იგი.
>> მაგალითად, ეს კოდი foo არ შეცვლილა.
Int foo შეადგენს 4, დარეკეთ triple foo, შიგნით სამჯერ,
ჩვენ ველით, რომ foo გვინდა მრავლდება 3 და დაბრუნდა,
მაგრამ იქ რეალურად არ ახდენს.
>> აქ, თუმცა, ძალიან დახვეწილი განსხვავება.
ეს იმას აქვს ეფექტი ჩვენ გვინდა.
მიგაჩნიათ თუ არა, რატომ?
ჩვენ მნიშვნელოვანი foo მთავარ ამ დროს.
>> ასე int foo შეადგენს 4, foo ტოლია სამმაგი foo, როდესაც ჩვენ, რომ ზარის,
სამჯერ იღებს საკუთარი ასლი foo, საკუთარი ასლი 4.
იგი აცხადებს, რომ დაბრუნდეს 4 ჯერ 3, ან რასაც ცვლადი იღებს გავიდა ჯერ 3.
და მაშინ ჩვენ მივანიჭოთ დაბრუნების ღირებულება სამჯერ უნდა foo ერთხელ.
ასე რომ, ეს რეალურად გადაწერა foo.
ეს არის ერთადერთი გზა ამის გაკეთება ეს ადგილობრივი ცვლადი.
ასე რომ, ახლა თუ დავუმატებთ კიდევ ხაზი კოდი აქ
ბოლოს მთავარ ამობეჭდოთ ღირებულება foo,
ეს საკითხი ფაქტობრივად ბეჭდვა 12.
>> ცვლადი ფარგლებს ზოგადად არ არის ძალიან ბევრი პრობლემა
თუ თქვენ დაარქვით ყველა თქვენი ცვლადები სხვადასხვა რამ.
მაგრამ მას შეუძლია მიიღოს სახის nasty თუ იგივე ცვლადის სახელი
როგორც ჩანს, მრავალი ფუნქციები, რომელიც მოხდება ბევრი.
თუ თქვენ ოდესმე არ მუშაობენ რეალურ სამყაროში, სადაც
ვმუშაობთ ერთობლივი პროგრამები და ადამიანები სხვადასხვა გუნდები
ვმუშაობთ ერთად დაწერა იგივე პროგრამა ან იგივე კომპლექტი პროგრამები,
ისინი ხშირად reuse ცვლადი სახელები, განსაკუთრებით საერთო პირობა
ისევე როგორც x, y, i, j, და ასე შემდეგ.
>> მაგრამ როდესაც ცვლადები ამავე სახელწოდების, ფარგლებს საკითხი
შეიძლება კიდევ ცოტა უფრო რთული გარჩევის.
მაგალითად, თქვენ იცით, რა იქნება დაბეჭდილი,
ბოლოს ამ კონკრეტული პროგრამა?
მიიღეთ წუთი.
პაუზის ვიდეო და წაიკითხა ამ პროგრამის.
თქვენ ხედავთ ზედა ჩვენ აქვს ფუნქცია დეკლარაცია
ფუნქცია მოუწოდა იყოს.
ეს ფუნქცია იღებს ერთი პარამეტრი, რიცხვი, რომელიც ჩვენ მოვუწოდებთ x.
და ეს შედეგები რიცხვი.
სწორედ დაბრუნების ტიპის დასაწყისში.
>> მაშინ ჩვენ გვაქვს მთავარი, რამდენიმე ხაზები კოდი მთავარ, ბოლო რომლის
ბეჭდვითი განცხადებაში.
და მახსოვს, რომ კითხვა აქ.
რა არის რეალურად იქნება ნაბეჭდი ბოლოს ეს ფუნქცია?
და მაშინ ჩვენ რეალურად აქვს განმარტება წუთობრივი ქვემოთ.
>> ასე რომ, ერთი წუთით, ნაბიჯ მეშვეობით კოდი, კვალი რამ.
იცით, რა დაიბეჭდება ბოლოს ამ კონკრეტული პროგრამა?
>> ყველა უფლება.
იმედია, თქვენ გადაღებული რამდენიმე წამში ცდილობენ და გარჩევის ეს ერთი.
მოდით ერთად.
>> ასე რომ, მე გადახაზა ნამატი მიერ დეკლარაციის ზედა არსებობს.
ეს იყო ერთგვარი განადგურების.
ეს არ არის საკუთარი ცვლადი.
მას არ აქვს თავისი ფარგლები.
ეს მხოლოდ ფუნქცია დეკლარაცია, ასე მიზნებისათვის
ცდილობს გარჩევის, თუ რა არის ხდება ამ პროგრამაში,
ჩვენ შეიძლება ასევე მხოლოდ თავიდან აცილება.
>> ახლა ჩვენ გვაქვს ამ შემთხვევაში, მიზეზი ეს პრობლემა არის სახიფათო
იმიტომ, რომ ჩვენ გვაქვს ადგილობრივი ცვლადები ორივე ძირითადი და ნამატი, რომელთაგან თითოეული
ეწოდება x.
და რა თქმა უნდა არსი ეს საკითხი ცდილობს, რომ მიხვდე, რომელიც x შეიცვლება
და როგორ უნდა შეიცვალოს.
ასე რომ, მე ფერადი ყველა ინსტანციის of x, რომ ადგილობრივი მთავარ წითელი.
და მე ფერადი ყველა ინსტანციის x, რომ ადგილობრივი ნამატი ლურჯი.
>> ცნობა, რომ მესამე ხაზი მთავარი, y ტოლია ნამატი
x, რომ ნამატი არ მიმდინარეობს გავიდა ძირითად x, ან წითელი x.
ეს არც გავიდა მას ასლი.
და ეს მხოლოდ იმუშავებს რომ ასლი, ლურჯი x.
თუ თქვენ მათემატიკურად დახრილი, თქვენ შეიძლება
ამის ნაცვლად ფიქრობდა, როგორც x sub მ ძირითადი და x sub მე იყოს.
მაგრამ ეს იმავე იდეას.
x sub m, ან წითელი x მიერ წინა slide,
არიან ცვლადები, რომლებიც local-- არის ინსტანციის x უფრო, რომ
არის ადგილობრივი მთავარ, და x sub i, ან ლურჯი ცვლადები წინა slide,
არის შემთხვევები, x, რომ არიან ადგილობრივი ნამატი.
>> ასე რომ, იყავით შეუძლია გაერკვნენ, თუ რა ამ ფუნქციის დაბეჭდილი ბოლოს?
მე Doug Lloyd, და ეს არის CS50.