>> დავით J Malan: ყველა უფლება, ასე რომ ეს არის CS50.
და ეს აშკარად პარასკევი.
და ეს არის ბოლომდე კვირაში ერთი.
ასე, რომ თქვენ შეიძლება გავიხსენოთ, რომ ჩვენ შეჩერდით, ბოლო დროს, ერთად cliffhanger ჯიშები.
ამასთან, ჩვენ გამოვლენა ამ ტყუილი, რომელიც არ მნიშვნელობა რა თქვენ უკვე ისწავლება იზრდება
up, 1 იყოფა 10 არ არის, ფაქტობრივად, 0.1 და 0,100 ან 0,10000.
რეალურად, თუ ჩვენ შეადგინონ ამ პროგრამა, როგორც ჩვენ გავაკეთეთ გუშინ,,
მიიღოს ორაზროვნება და შემდეგ ამის dot, სლეში, ორაზროვნება,
გავიგეთ, რომ ეს არის ის, რაც 1 იყოფა 10 რეალურად არის.
ასე რომ ნამდვილად არ არის საკმაოდ შემთხვევაში.
მაგრამ ეს იმას მინიშნება რაღაც ფუნდამენტური შეზღუდვის კომპიუტერები.
მართლაც, მათ შორის რამ ჩვენ ვაპირებთ, რომ
დღეს შევხედოთ, თუ რატომ ეს მოხდა, რა შედეგებზე ეს,
კაცობრიობის ვერ დაჯექი ამ რამდენიმე ძალიან
სერიოზული situations-- შედეგი, რომელიც
უკვე საკმაოდ ტრაგიკული და expensive-- და ასევე
შევხედოთ, თუ როგორ შეიძლება რეალურად დაიცავს
წინააღმდეგ ასეთი სახის შეზღუდვები.
ასე რომ, ინტუიციურად, ალბათ, რატომ არის 1 იყოფა 10,
ჩემი კომპიუტერი აქ, არა მხოლოდ 1/10, 0.10?
ჰო.
რას ფიქრობთ?
>> აუდიტორიის წევრი: საქართველოს წყაროებიდან არის განსხვავებული?
>> DAVID J Malan: რა არის?
ოჰ, კოდის განსხვავდება?
ასე რომ არ საკმაოდ.
ეს, ფაქტობრივად, მეტი ფუნდამენტური ტექნიკა.
სხვა აზრები?
ჰო.
აუდიტორიის წევრი: ისინი წარმოადგენს ნომრები განსხვავებულად?
დავით J Malan: ასე they-- უფლება.
ისინი წარმოადგენენ ნომრები განსხვავებულად.
არასწორად, როგორც ჩანს.
ასე, რომ არის ისე, განსხვავებულად რა?
ან ვისგან?
ჩვენთან?
აუდიტორიის წევრი: ჰო.
ისინი არ იყენებენ ათობითი სისტემის [INAUDIBLE].
დავით J Malan: OK.
ასე რომ, ამ თვალსაზრისით, ისინი არ გამოყენება ათობითი სისტემა.
ქვეშ Hood, ყველაფერი, რა თქმა უნდა, ორობითი,
და ეს დაკავშირებული, ფაქტობრივად.
მაგრამ ეს კიდევ უფრო მარტივი ახსნა, ვიდრე.
ჰო.
>> აუდიტორიის წევრი: ისინი მხოლოდ ამდენი ბიტი.
მათ შეუძლიათ მხოლოდ შესანახად მდე გარკვეული იმდენად, რამდენადაც, როგორც ერთად decimals.
>> დავით J Malan: ჰო.
ეს არის ის, რაც ნამდვილად მისაღებად მას.
გამოდის, რომ კომპიუტერები როგორც წესი, ყოველთვის მხოლოდ
გამოყენება სასრული რაოდენობით ინფორმაცია წარმოადგენს რაღაც.
მარჯვენა?
ყოველივე ამის შემდეგ, ჩვენ მხოლოდ ფიქსირებული თანხის მყარ დისკზე.
ჩვენ მხოლოდ ფიქსირებული თანხა of RAM, ან კომპიუტერის მეხსიერებაში.
და თუ თქვენ მხოლოდ ფიქსირებული თანხის რაღაც,
აუცილებლად თქვენ შეგიძლიათ რეალურად არ ითვლიან უსასრულობა ან ნებისმიერი რაოდენობის გსურთ.
თქვენ, სახის, უნდა აირჩიოთ და აირჩიეთ რა დიაპაზონი
ღირებულებათა თქვენ აპირებს მხარი დაუჭიროს.
>> ასე რომ, მაგალითად, ერთი კვირის ან ორი წინ, როდესაც ჩვენ ვისაუბრეთ ASCII,
და ჩვენ ვისაუბრეთ 8 ბიტი, ან byte, ასე ვთქვათ,
ყველაზე მეტი შეგვეძლო წარმოადგენს 8 ბიტი რა?
255.
და ჩვენ შეგვიძლია წარმოადგენს 256 სულ ღირებულებები მაგრამ თუ ჩვენ გაატაროთ ერთი მათგანი
on 0- ისე, მაგრამ თუ ჩვენ გაატარონ ერთი მათგანი 0,
მაშინ ყველაზე მეტი არის, რა თქმა უნდა, 255.
>> ასე რომ, თურმე, რომ ეს არის იმ შემთხვევაში, ძალიან, ამ კონტექსტში.
ჩვენ დავიწყეთ საუბარი, ბოლო დროს, მცურავი პუნქტიანი ნომრები, რომელიც
განსხვავებული რიცხვებით, in რომ მათ აქვთ ათობითი წერტილი
და, იმედია, ზოგიერთი ნომრები ამის შემდეგ, მაგრამ ისინი ძალიან.
კომპიუტერული მხოლოდ, როგორც წესი, ხდება გამოიყენოთ 32 ბიტი, შესაძლოა, 64 ბიტი
წარმოადგენს მცურავი წერტილი ღირებულება.
ასე რომ, მიუხედავად იმისა, რომ ჩვენ გაიზარდა სწავლის მათემატიკის და იცის
რომ თქვენ შეგიძლიათ აბსოლუტურად უსასრულო რაოდენობის ნომრები
შემდეგ ათობითი წერტილი, არ თუ თქვენ გაქვთ სასრულ მეხსიერება.
თქვენ, სახის, უნდა გარშემო, ან აირჩიოთ და აირჩიეთ რომელიც
ნომრები ვაპირებთ წარმოადგენს.
და ასე რომ თქვენ შეგიძლიათ ვფიქრობ, ამ თვალსაზრისით, ეს იყო კომპიუტერული უახლოესი
დაახლოებას ღირებულება 1/10, რომ მას შეუძლია მიიღოს, მხოლოდ 32 ან იმდენად ბიტი.
და ეს არ არის მხოლოდ 1/10.
>> მაგალითად, თუ მე შეცვლის ამ 1/3, რომელიც ჩვენ მიგვაჩნია, რომ კიდევ უფრო მარტივია.
ასე რომ 1 გაყოფილი 3.
მიადევნე თვალი ფაილის შენახვა.
ნება მომეცით წავიდეთ წინ და recompile იგი.
ნება მომეცით ხელახლა გაუშვით.
აქაც, როგორც ჩანს, 1/3 არ არის 0.3 და შემდეგ უსასრულო რაოდენობის 3-ის
შემდგომ.
თქვენ ამ ორაზროვნება ბოლოს.
ასე რომ, ჩვენ ადამიანები ვართ სწორი და რა თქვენ ისწავლა არის, ფაქტობრივად, სწორი,
მაგრამ ჩვენ bumping up წინააღმდეგ გარკვეული შეზღუდვები.
>> და რა ვიფიქრე ჩვენ გვინდა გავაკეთოთ დღეს, დაიწყოს
ეძებს, სიმართლე გითხრათ, ტრაგიკული შედეგები ამ
ზოგჯერ, როდესაც კაცობრიობა არ საკმაოდ განახორციელოს
ამ რეალობას და ეს შეზღუდვები.
ჩვენ დავინახავთ, სერია vignettes ისტორიის არხი, რომელიც იღებს
შევხედოთ, თუ როგორ არ წავიდა არასწორი.
ეს არის დაახლოებით 8 წუთი ხანგრძლივი, და ჩვენ დავბრუნდებით შემდეგ ეს
და შევხედოთ ზუსტად რა შეიძლება წავიდეთ არასწორი.
თუ ჩვენ ვერ dim lights--
>> [ვიდეო აღწარმოების]
>> -Computers, ჩვენ ყველა მოდის მიიღოს ხშირად სამწუხარო პრობლემები რომ
მათთან ერთად წასვლა.
Bugs, ვირუსებს, და პროგრამული უზრუნველყოფის glitches ეს არის პატარა ფასები
გადაიხადოს ფონდის.
მაგრამ მაღალტექნოლოგიური და მაღალი სიჩქარით სამხედრო და სივრცეში პროგრამა განცხადებები,
პატარა პრობლემის განდიდდება შევიდა უბედურება.
4 ივნისს, 1996, მეცნიერები მზად დაიწყოს უპილოტო Ariane 5 რაკეტა.
ეს იყო დატვირთული სამეცნიერო თანამგზავრების შექმნილია
ჩამოყალიბება, ზუსტად როგორ დედამიწის მაგნიტური ველი ურთიერთქმედებს
ერთად მზის ქარი.
სარაკეტო აშენდა ევროპული კოსმოსური სააგენტო
და გააუქმა off მისი დაწესებულებაში სანაპიროზე საფრანგეთის გვიანა.
>> თუკი დაახლოებით 30 წამი ფრენის, ისინი პირველი
შენიშნა რაღაც ხდებოდა არასწორია.
რომ საქშენები იყო swiveling ისე, რომ მათ ნამდვილად არ უნდა.
დაახლოებით 40 წამი შევიდა ფრენის, ნათლად მანქანა იყო უბედურება,
და ეს მაშინ, როდესაც ისინი გააკეთა გადაწყვეტილება გაანადგუროს იგი.
სპექტრს უსაფრთხოების ოფიცერი ერთად უზარმაზარი guts დაპრესილი ღილაკს,
ააფეთქეს სარაკეტო, სანამ ეს შესაძლებელი იქნებოდა გახდება საშიშროების საჯარო უსაფრთხოებას.
>> -ეს იყო maiden voyage საქართველოს Ariane 5,
და მისი განადგურება მიიღო განათავსეთ იმიტომ, რომ ნაკლი
ჩართული ამ სარაკეტო ის პროგრამული უზრუნველყოფა.
-The პრობლემა Ariane იყო, რომ იქ
ნომერი რომ საჭირო 64 bits, გამოხატონ,
და მას სურდა დააკონვერტიროთ მას 16 bit ნომერი.
ისინი ფიქრობდნენ, რომ ნომერი არასოდეს იქნება ძალიან დიდი,
რომ უმრავლესობა ციფრისგან 64 bit ნომერი იყო 0 ს.
ისინი არასწორია.
>> -The უუნარობა ერთ პროგრამული პროგრამა, მიიღოს
სახის ნომერი მიერ კიდევ ერთი ქართველი ერთი ძირი უკმარისობა.
პროგრამული უზრუნველყოფის დამუშავების გახდა ძალიან ძვირადღირებული ნაწილი ახალი ტექნოლოგია.
Ariane 4 სარაკეტო იყო ძალიან წარმატებული, იმდენად, რამდენადაც პროგრამული უზრუნველყოფა
ის, რომ ეს იყო ასევე გამოიყენება Ariane 5.
>> -The ძირითადი პრობლემა იყო ის, რომ Ariane 5 იყო სწრაფად, დააჩქარა სწრაფად.
და პროგრამული უზრუნველყოფის არ ჰქონდა აღრიცხული, რომ.
>> -The განადგურების სარაკეტო იყო დიდი ფინანსური კატასტროფის
ყველა გამო წუთი პროგრამული შეცდომა.
მაგრამ ეს არ იყო პირველი შემთხვევა მონაცემები კონვერტაციის პრობლემები
ჰქონდა ხშირია თანამედროვე სარაკეტო ტექნიკა.
>> -in 1991 დაწყების პირველი ყურის ომი,
პატრიოტის რაკეტა გამოცდილი მსგავსი
პუნქტების კონვერტაციის პრობლემა.
შედეგად, 28 ადამიანი, 28 ამერიკელი ჯარისკაცი
დაიღუპა და დაახლოებით 100 დაიჭრა,
როდესაც პატრიოტთა, რომელიც უნდა დაიცვას შემოსულ Scuds,
ვერ ცეცხლი სარაკეტო.
>> როცა ერაყში შეიჭრა ქუვეითსა და ამერიკაში დაიწყო Desert Storm დასაწყისში 1991,
Patriot სარაკეტო ბატარეები განალაგეს დასაცავად საუდის არაბეთი და ისრაელს
ერაყის Scud სარაკეტო თავდასხმები.
პატრიოტის არის აშშ, საშუალო რადიუსის მიწა-ჰაერის სისტემა
მიერ წარმოებული RAYTHEON კომპანია.
>> -The ზომა პატრიოტის interceptor, თავისთავად, დაახლოებით, დაახლოებით 20 ფუტი სიგრძის.
და ეს იწონის დაახლოებით 2000 ფუნტი.
და იგი ახორციელებს ქობინი შესახებ მე ვფიქრობ, რომ დაახლოებით 150 ფუნტი.
და ქობინით, თავისთავად, მაღალი ასაფეთქებელი,
რომელსაც აქვს ფრაგმენტები გარშემო.
გარსაცმები of ქობინით არის განკუთვნილია იმოქმედოს მოსწონს buckshot.
>> -The რაკეტები განახორციელა, 4 პროცენტი კონტეინერი,
და არიან ტრანსპორტირება ნახევრად trailer.
>> -The Patriot ანტი-სარაკეტო სისტემა მიდის უკან მინიმუმ 20 წელია.
თავდაპირველად შექმნილია როგორც საჰაერო თავდაცვის სარაკეტო
ჩამოაგდებენ მტრის თვითმფრინავები.
პირველ ყურის ომი, როდესაც ომი მოვიდა გასწვრივ,
არმიის სურდა გამოვიყენოთ რომ ჩამოაგდებენ Scuds, არ თვითმფრინავები.
ერაყის ძალები არ იყო იმდენად დიდი პრობლემა,
მაგრამ არმიის იყო აწუხებს Scuds.
ასე რომ, ისინი ცდილობდნენ განახლება პატრიოტია.
>> -Intercepting მტერი სარაკეტო მოგზაურობა at Mach ხუთ
მიდიოდა იწვევს საკმარისი.
მაგრამ როდესაც პატრიოტთა იყო შევარდა მომსახურება,
არმია არ იცის ერაყის მოდიფიკაცია რომ გააკეთეს
Scuds თითქმის შეუძლებელია მოხვდა.
>> რა მოხდა, არის Scuds, მოდიოდნენ, იყო არასტაბილური,
ისინი wobbling.
ამის მიზეზი, იყო ერაყელებს, რათა
რომ 600 კილომეტრის გარეთ 300 კილომეტრიანი რადიუსის რაკეტა,
აიღო წონა გარეთ წინა ქობინით და გააკეთა ქობინით მსუბუქია.
ასე რომ, ახლა პატრიოტთა ცდილობს მოვა at Scud, ყველაზე მეტი დრო,
აბსოლუტური უმრავლესობა დროს, ის უბრალოდ ფრენა მიერ Scud.
>> -Once პატრიოტის სისტემის ოპერატორები მიხვდა პატრიოტის გაშვებული მისი სამიზნე,
მათ აფეთქდა პატრიოტთა ქობინით, რათა თავიდან ავიცილოთ შესაძლო მსხვერპლი, თუ იგი
ეძლეოდა დაეცემა, რათა ადგილზე.
>> -ეს იყო, რაც ყველაზე ხალხი დაინახა, იმ დიდი fireballs ცაში,
და არასწორად როგორც საუბრების საქართველოს Scud ქობინი.
მიუხედავად იმისა, რომ იმ ღამეს, ცა, პატრიოტთა აღმოჩნდა
წარმატებით განადგურება Scuds საათზე Dhahran,
არ შეიძლება იყოს შეცდომა მის შესრულება.
იქ, პატრიოტთა სარადარო სისტემის დაკარგა სიმღერა შემომავალი Scud,
და არ დაიწყო, იმის გამო, რომ პროგრამული ხარვეზი.
ეს იყო ისრაელის, რომელმაც პირველად აღმოაჩინა რომ აღარ სისტემა იყო,
დიდი დრო განსხვავება გახდა, გამო საათის ჩართული
სისტემაში კომპიუტერში.
>> გამოტოვებულია 2 კვირით ადრე ტრაგედიის Dhahran,
ისრაელის იტყობინება თავდაცვის დეპარტამენტს,
რომ სისტემა დაკარგვის დროს, მას შემდეგ, რაც დაახლოებით 8 საათის გაშვებული,
მათ შენიშნეს, რომ ეს სისტემა შესამჩნევად ნაკლები სიზუსტით.
თავდაცვის დეპარტამენტის გამოეხმაურა ვეუბნებოდი ყველა პატრიოტის ბატარეები
რომ არ დატოვებს სისტემები დიდი ხნის განმავლობაში.
ისინი არ ამბობს, რა დიდი დრო იყო.
8 საათი?
10 საათის განმავლობაში?
1000 საათი?
არავინ იცოდა.
-The პატრიოტის ბატარეის დისლოცირებული ზე ყაზარმებში
at Dhahran და მისი ყალბი შიდა საათი, იყო დაახლოებით 100 საათი
ღამეს 25 თებერვალს.
>> -ეს დააფიქსირა, დრო სიზუსტით დაახლოებით 1/10 მეორე.
ახლა 1/10 მეორე არის საინტერესო ნომერი
იმიტომ, რომ ეს არ შეიძლება იყოს გამოთქმული ორობითი, ზუსტად.
რაც იმას ნიშნავს, მას არ შეუძლია იყოს გამოხატული, ზუსტად,
ნებისმიერ თანამედროვე ციფრული კომპიუტერი.
ძნელი დასაჯერებელია, მაგრამ გამოიყენოს ეს როგორც მაგალითად.
ავიღოთ ნომერი, 1/3.
1/3 არ შეიძლება იყოს გამოხატული ათობითი ზუსტად.
1/3 0,333 გრძელდება უსასრულობამდე.
არ არსებობს გზა უნდა გააკეთოს, რომ, აბსოლუტური სიზუსტით, ათობითი.
ეს არის ზუსტად იგივე სახის პრობლემა, რომელიც მოხდა პატრიოტია.
აღარ სისტემა გაიქცა, უარესი დრო შეცდომა გახდა.
>> მას შემდეგ რაც 100 სამუშაო საათები, შეცდომა იყო მხოლოდ 1/3 მეორე.
მაგრამ თვალსაზრისით სამიზნედ სარაკეტო მოგზაურობა at Mach 5,
ეს შედეგად თვალთვალის შეცდომა მეტი 600 მეტრია.
ეს იქნება ფატალური შეცდომა ამისთვის ჯარისკაცებთან Dhahran.
>> რა მოხდა, არის Scud დაწყებას იყო გამოვლინდა ადრეული გაფრთხილების თანამგზავრების,
და ისინი new რომ Scud მოდის მათი საერთო მიმართულებით.
მათ არ იციან, სადაც იგი მოდიოდა.
>> -ეს იყო ახლა მდე სარადარო კომპონენტი პატრიოტის სისტემის,
დაცვითი Dhahran, იქნებიან და შეინახოს სიმღერა შემომავალი მტრის რაკეტა.
>> -The სარადარო იყო ძალიან ჭკვიანი.
ეს რეალურად აკონტროლოთ პოზიცია Scud
და შემდეგ პროგნოზირება, სადაც ეს ალბათ იქნება,
შემდეგი დროს, სარადარო გაგზავნილი პულსი გარეთ.
რომ ერქვა Range კარიბჭე.
>> მერე, ერთხელ პატრიოტის გადაწყვეტს საკმარისი დრო აქვს
გავიდა წასვლა უკან და შეამოწმოთ შემდეგი ადგილმდებარეობა ამ აღმოჩენილი ობიექტი,
იგი მიდის უკან.
ასე რომ, როდესაც იგი დაბრუნდა არასწორი ადგილი, მაშინ ვერ ხედავს ობიექტი
და ეს გადაწყვეტს, რომ არ არსებობს ობიექტი, ეს იყო ყალბი გამოვლენის
და წვეთების სიმღერა.
შემომავალი Scud გაქრა სარადარო ეკრანზე,
და წამის შემდეგ, ის გააკრიტიკა შევიდა ყაზარმები.
Scud დაიღუპა 28 და იყო ბოლო ერთი გასროლა დროს პირველი ყურის ომი.
ტრაგიკულია, რომ განახლებული პროგრამული უზრუნველყოფა მივიდა Dhahran მომდევნო დღეს.
პროგრამული ხარვეზი ჰქონდა უკვე დაფიქსირდა, იხურება
ერთი თავი პრობლემური ისტორია პატრიოტის რაკეტა.
>> [END აღწარმოების]
>> დავით J Malan: ასე რომ, ჩვენ შევხედოთ ზოგიერთი მსგავსი შეზღუდვები მხოლოდ ცოტა.
მაგრამ პირველი, მოდით გადასვლის რამდენიმე FYI არის.
ასე რომ, one-- ამ კვირას, იქნება სუპერ სექციები,
რომლებიც განკუთვნილია შევცვალოთ რეგულარული სექციები, რომელიც
დაიწყება კვირაში აქედან გამომდინარე.
შეხედეთ იმ CS50 ნახვა დამატებითი ინფორმაცია იმ.
ისინი ასევე იქნება გადაღებული და streamed ცხოვრება მათთვის ვერ დაესწრება.
პრობლემა კომპლექტი 1 არის რა თქმა უნდა ნახვა უკვე,
და ჩვენ შევხედოთ რომ უბრალოდ ცოტა.
და საოფისე საათი ძალიან, მიიღებს განათავსებს ამ ორშაბათიდან ხუთშაბათი.
>> ასე რომ, ეს იყო ყველაზე კანონიკური პროგრამა ჩვენ შევხედე ბოლო დროს.
ეს იგივეა, რომ უმარტივესი პროგრამის საშუალებით თქვენ შეგიძლიათ დაწეროთ C,
და მიუხედავად იმისა, რომ ცოტა თამამი პრეტენზია.
მარჯვენა?
იმის გამო, რომ ბევრი მოჩვენებითი სირთულე ამ.
მოდით მიიღოს სწრაფი შევხედოთ რა ზოგიერთი ელემენტი
იყო და შემდეგ ცდილობენ, რათა უზრუნველყოს ფსიქიკური მოდელი, თუ როგორ
ეს მარტივი პროგრამების მუშაობა, და შემდეგ დავიწყებთ
ეძებს რამ უფრო რთული.
ასე რომ, ეს ხაზი აქ, ხაზგასმით არის, ყვითელი, რა არ ვამბობთ, ბოლო დროს,
, რომ ეს არ არის ჩვენთვის?
რა არის მიზანს ემსახურება?
ვინმეს უფრო უკან?
ჰო.
>> აუდიტორიის წევრი: [INAUDIBLE]
დავით J Malan: კარგი.
ასე რომ, ეს გაძლევთ ხელმისაწვდომობის ბრძანებები, ან მოდით
მოვუწოდებთ მათ ფუნქციებს, რომ ვინმე სხვამ დაწერა, რომ განაცხადა,
ასე ვთქვათ, ზოგიერთ სხვა ფაილი.
ამიტომ, ჩვენ დავინახავთ, ზუსტად რა თ ფაილი არის წინააღმდეგ გ ფაილი, საბოლოოდ.
მაგრამ ახლა, უბრალოდ ვიცი რომ printf, მაგალითად,
მათ შორის არის ფუნქცია, რომელიც არ ყოფილა დეკლარირებული სხვა ფაილი, სადღაც
სხვა ღრუბელი მყარ დისკზე, რომ საშუალებას გვაძლევს, რათა შეამოწმონ printf და გამოიყენოს იგი
გარეშე ხელახლა რომ წამყვანი საკუთარ თავს.
იმავდროულად, მთავარი.
რა იყო ანალოგი მთავარი, გასულ კვირას?
ჰო.
>> აუდიტორიის წევრი: მწვანე დროშა დააწკაპებთ.
>> დავით J Malan: ჰო.
ნულიდან, როდესაც მწვანე დროშა დააწკაპებთ.
ეს იგივეა, თავსატეხი ცალი რომ ჩათვლით რამ off.
ასე რომ, ასევე, გააკეთა მსოფლიოში გადაწყვიტა რამდენიმე წლის წინ, რომ C,
და რამოდენიმე სხვა ენებზე, თუ გსურთ დაწეროთ პროგრამა,
თქვენი პირველი ფუნქცია უნდა ეწოდოს, მთავარი.
და მას მოსწონს ეს.
მაგრამ ჩვენ დავბრუნდებით, სხვა დროს, რა, int,
და ბათილად, ნიშნავს იმას, რომ ამ კონტექსტში.
ახლა, curly აფრთხილებს სახის მოსწონს Scratch თავსატეხი ცალი ფორმა
რომ encapsulates გარკვეული რაოდენობის ხაზები.
მათ შორის ხაზები აქ არის ერთი აქ.
printf ფუნქცია, რომლის მიზანია ცხოვრება ბეჭდვა ფორმატირებული სიმებიანი.
და ფორმატირებული, ვგულისხმობ შეგიძლიათ დანამატის placeholder ღირებულებები,
და თქვენ შეგიძლიათ მიუთითოთ რამდენი ათობითი რაოდენობა, რამდენი ნომრები ბეჭდვა
მას შემდეგ, რაც ათობითი წერტილი და ასე შემდეგ.
და printf, რა თქმა უნდა, ერთი იღებს ან მეტი არგუმენტები ან პარამეტრების,
წინააღმდეგ შემთხვევაში, ცნობილია, უფრო მარტივად, როგორც საშუალებებით.
>> ამიტომ printf, როგორც ბევრი ფუნქციები, იღებს საშუალებებით.
და იმ საშუალებებით მოიცვა ორი ფრჩხილებში აქ.
და შიგნით იმ ერთ-ერთი შეყვანა.
ეს არის ტექსტი, როგორც ჩვენ მას, რაც არის თანმიმდევრობა გმირები,
მოსწონს სიტყვა ან ფრაზა, ან მთლიანად ესსე კი, შორის ორმაგი შეთავაზებები.
და რომ ის, რაც ხდება, რომ ზეგავლენა ქცევის printf, რადგან, რა თქმა უნდა,
ეს მხოლოდ ზოგადი ბეჭდვის ფუნქცია.
ის არ აპირებს ვიცი, რა ბეჭდვა, თუ თქვენ გითხრათ.
და შემდეგ, რამდენიმე წვრილმანებში.
რა ვამბობთ, ამ უცნაური თანმიმდევრობა სიმბოლოების?
ჰო.
>> აუდიტორიის წევრი: New ონლაინ.
>> დავით J Malan: ახალი ონლაინ.
ასე რომ, თურმე, თქვენ ვერ მოხვდა, შევა, როდესაც თქვენ წერილობით პროგრამა.
საერთოდ, შემდგენელი აპირებს ცოტა დაბნეული, რას ნიშნავს.
პირიქით, თქვენ უნდა სიტყვასიტყვით ვთქვა, მომეცი ახალი ხაზი აქ.
ასე რომ, / n არის ის, რაც ჩვენ ზოგადად დარეკეთ გაქცევის ხასიათი.
ასე რომ, ო, ახალი ხაზი.
და შემდგენელი იცის რომ როდესაც ის ხედავს / n,
რეალურად უნდა გამოიწვიოს კომპიუტერი, საბოლოო ჯამში, ან printf, ამ შემთხვევაში,
ამობეჭდოთ ფაქტობრივი ახალი ხაზი, როგორც დარტყმის, მიუთითოთ,
კლავიშს.
და ბოლოს, რა ვამბობთ, ამ ნაჭერი სინტაქსის არის?
რას წარმოადგენს?
ჰო.
>> აუდიტორიის წევრი: [INAUDIBLE]
>> დავით J Malan: ეს არის მხოლოდ ბოლოს ხაზი.
ეს ბოლოს განცხადებაში.
და გააცნობიეროს, რომ ჩვენ არ ამით მათ ყველგან.
ჩვენ, რა თქმა უნდა არ დააყენა მათ დროს შაბათ ყველა ხაზი.
მაგალითად, არსებობს არცერთი შესახებ პირველი ხაზი, არსებობს არცერთი ხაზი
ერთად, მთავარი, არსებობს არცერთი მას შემდეგ, რაც Curly braces,
მაგრამ თქვენ დავიწყებთ და მიიღეთ იცნობს, სადაც ის მოუწოდა.
და ეს თითქმის ყოველთვის შემდეგ ფუნქცია დარეკეთ ან განცხადება, ზოგიერთი ქმედება
რომ თქვენ რეალურად იღებენ.
>> და ვიცი, ახლა, მით უმეტეს, თუ იმ ნაკლებად კომფორტული,
ეს არის სახის სულელური რამ რომ თქვენ დასრულდება up შემთხვევით ბრახუნი
თქვენი უფროსის წინააღმდეგ კედლის მეტი.
იმის გამო, რომ თქვენ უნდა იყოს ლოგიკურად დარწმუნებული ზოგიერთი პრობლემა
თქვენ მოგვარდეს პრობლემა კომპლექტი, და რა რამ მხოლოდ
არ კომპილირდება ან თუნდაც აწარმოებს.
ასე რომ, ხშირად, დასაწყისში, ის აპირებს იმის გამო, რომ თქვენ გაშვებული ფრჩხილებში,
ან თქვენ გაშვებული მძიმით.
ასე რომ, უბრალოდ მავიწყდება ამ სახის რამ,
და ცდილობენ რომ არ იმედგაცრუებული მიერ მათ, რადგან ძალიან სწრაფად აკეთებს ამას
გახდეს ძველი ქუდი.
მაგრამ ეს ძალიან მარტივია მისაღებად იმედგაცრუებული დასაწყისში, შედეგად.
>> ასე რომ, ახლა, მოდით, შევხედოთ, თუ როგორ ამ ხაზის რეალურად მუშაობს
და შემდეგ შეხედეთ ოდნავ უფრო რთული.
ასე რომ, ჩვენ აქ, უნარი მიაპყროს ამ ეკრანზე.
და მოდით ვივარაუდოთ, რომ ეს არის ჩემი კომპიუტერის ეკრანზე,
მაგრამ ვწერ, hello პროგრამა, და მე არ განხორციელდა, printf.
ვინმეს აქვს განხორციელებული, printf.
ვინ მინდა აცხადებენ, რომ არ განხორციელდა, printf?
თუ შეიძლება?
ყველა უფლება, რა გქვია?
>> STUDENT 1 [? Copal. ?]
>> დავით J Malan Copal, მოდის up.
კარგით up.
ყველა უფლება.
ასე რომ, ჩვენ, აქ, რამდენიმე სახელი tags, მას შემდეგ, რაც ჩვენ, რათა პატარა თამაში ამ.
და ჩვენ მოვუწოდებთ თქვენ, printf.
და თუ გვინდა, რომ მეტი აქ, რაც მე უბრალოდ შედგენილი ეკრანზე,
ეს უბრალოდ, არ არსებობს ჩემთვის, ეს.
>> ყველა უფლება, ასე, hello ჩემი სახელი არის, printf, თუ გსურთ დააყენა, რომ.
ყველა უფლება.
და თუ შეგიძლიათ სტენდი მიერ კომპიუტერის ეკრანზე
თითქოს თქვენ ფუნქცია მოვიდა ამ კომპიუტერული სისტემა.
და თქვენი მიზანი ცხოვრებაში რეალურად ბეჭდვა რაღაც.
მაგრამ ჰგავს პროგრამაში ჩვენ უბრალოდ იძულებული ეკრანზე, აქ,
ჩვენ ვაპირებთ, რომ უნდა ფაქტობრივად, გადმოგცეთ ზოგიერთი შეყვანა.
>> ასე რომ, თუ ჩემი შეყვანის, აქ არის როგორც ჩანს, რა გავიდა printf,
მოდით სახის იმიტირებულ ეს მოსწონს ეს.
მე ვაპირებ ფაქტიურად წერენ ნაჭერი ქაღალდი, "Hello, World"
წარმატებული N. და იყოს ნათელი, თუ რა მე უბრალოდ შედგენილი ამ ნაჭერი ქაღალდი,
ასე გამოიყურება.
ასე რომ, როდესაც მე აწარმოებს ამ პროგრამის, და ეს ყვითელი ხაზი კოდი იღებს დასაჯეს,
ეს თითქოს მე, მიესალმები პროგრამა, ვარ გადაცემის გარკვეული შეყვანის off ფუნქცია
რომ ვინმე წერდა.
>> და თუ თქვენ, თქვენი თითი, შეიძლება რეალურად, თითის,
მიაპყროს ეკრანზე რასაც ეს თქვენ უკვე გადასცა,
ეფექტი, საბოლოო ჯამში, არის ის, რომ ვხედავთ ზუსტად რომ, ეკრანზე.
და პატარა კუთხეში შემთხვევაში აქ.
და კარგი, ჩვენ არ უნდა დაინახოს ის, ახალი ხაზი, ამ ეტაპზე.
არასწორი იქნება თქვენთვის მკაფიოდ მიაპყროს newline.
მაგრამ თუ ჩვენ ინახება წერა სიტყვა ეკრანზე, ისინი დასრულდება მდე ქვემოთ რომ.
>> ასე რომ, დიდი მადლობა, მაგრამ ჯოხი გარშემო აქ მხოლოდ ერთი მომენტი.
ჩვენ ახლა გვჭირდება ერთი სხვა მოხალისე, თუ შეგვეძლო,
რომ აპირებს უნდა ითამაშოს როლი of-- ეს მხოლოდ ადამიანი ორკესტრი
ახლავე.
როგორ შესახებ OK.
სწორედ აქ.
კარგით up.
რა გქვია?
>> სტუდენტური 2 [? IVAY. ?]
დავით J Malan უკაცრავად?
სტუდენტური 2 [? IVAY. ?]
დავით J Malan: Ethan, მოდის up.
არ არის?
მივიღებ, რომ არასწორი, თუნდაც მას შემდეგ, რაც განაცხადა, რომ ის ორჯერ?
კარგით up.
ძნელი მოვისმინოთ აქ.
OK.
და მე ვწუხვარ, რა გქვია?
>> სტუდენტური 2 [? IVAY. ?]
>> [? დავით J Malan IVAY. ?] OK.
ახლა, თუ არ გონება, თქვენ GetString.
>> სტუდენტური 2 OK.
ზემოთ.
დავით J Malan: ასე რომ, თუ გსურთ, ვდგავარ მხოლოდ ერთი წუთით,
მოდით შევხედოთ ოდნავ უფრო რთული პროგრამა, რომელიც
უკვე სამი ხაზი კოდი.
ასე რომ, ჩვენ, ერთი, განვაცხადო თქვენი სახელი გამოყენებით printf; ორი ზარი GetString,
მოჰყვა დავალება, რომ ცვლადში, სიმებიანი s, და მოუწოდა;
და შემდეგ კიდევ ერთი ზარი, printf, მაგრამ ამ დროს ორი საშუალებებით.
>> ასე რომ, ჩვენ უკვე გავაკეთეთ სახელმწიფო თქვენი სახელი, უფრო სწორად, ჩვენ
უკვე გაკეთდა printf ზარი.
ამიტომ, მე ვაპირებ დაწერა, აცხადებენ თქვენი სახელი.
ასე რომ, რა მე ვაპირებ გაივლის, printf, რაღაც მომენტში,
საკმაოდ უბრალოდ, ამ.
ასე რომ, თუ გსურთ წავიდეთ წინ და მიაპყროს ამ ეკრანზე, რომ თქვენი შეყვანის ახლა.
ყველა უფლება.
და დავივიწყოთ სიმებიანი, ჩვენ ახლა აქვს ჩვენი საკუთარი ხაზი კოდი აქ.
ასე რომ, GetString, ჩვენ გვჭირდება სინამდვილეში, GetString.
ასე რომ, თქვენი მიზანი ცხოვრებაში არის მხოლოდ ფეხით შევიდა ორკესტრი, თუ შეიძლება,
და მიიღეთ ვინმეს სახელი.
მაგრამ მოდით მოგცემთ რაღაც დააყენა იგი.
თუ გსურთ, წავიდეთ წინ და მიიღოს სიმებიანი,
ვინმეს სახელზე, რომ ნაჭერი ქაღალდი, თუ შეიძლება.
>> ყველა უფლება.
და ჩვენ დავინახავთ, რაღაც მომენტში, რომლის სახელი ჩვენ ვიღებთ.
ამავდროულად, რა მე ვაპირებ მზად არის ცარიელი ცალი
ქაღალდი, რომელიც, მე ვაპირებ შესანახად რასაც ღირებულების
ის არის, რომ GetString ბრუნდება ჩემთვის, მე, როგორც სიმებიანი ცვლადში, ს.
ყველა უფლება.
ასე რომ, რა გაქვთ?
Nik.
ყველა უფლება.
ასე რომ, ჩვენ Nik სახელი აქ.
ასე რომ, ეს არის ის, რაც სიტყვასიტყვით უკვე დაბრუნდა
ჩემთვის, ასე ვთქვათ, GetString.
>> მე, ახლა, ვაპირებ შეასრულოს მარცხენა მხარეს
რომ გამოხატვის, სადაც მე, უბრალოდ, ასლი ქვემოთ, დღევანდელი მიზნებისათვის, ნიკო.
ასე რომ, ახლა მე მაქვს ცვლადი მოუწოდა, s, შენახვის Nik სახელი.
მე უკვე გადასცა printf, წინა არგუმენტი.
მაგრამ ჩვენი მესამე და საბოლოო ხაზი კოდი, მე რეალურად უნდა ხელის printf
რაღაც პატარა სხვადასხვა "hello,% s" წარმატებული ო.
>> ასე რომ, ბოლო ხაზი მე ვაპირებ რომ send-- ბოლო რაც მე ვარ
ვაპირებ დავწერო ახლა, ეს არის.
ასე რომ, ორი ხაზი კოდი, ან საკმაოდ ბოლო ხაზი კოდი,
მოუწოდებს ორ საშუალებებით ერთი, ეს, და ორი, ამ.
ასე რომ, თუ ჩვენი printf ფუნქცია შეუძლია მიიღოს ამ არგუმენტად,
მიადევნე თვალი გარკვევა ეკრანზე თქვენთვის.
რეალურად არ არის, თქვენ შეგიძლიათ წავიდეთ წინ.
ჩვენ დავტოვებთ მას, რადგან, ეს იგივე პროგრამა.
ჩვენ უნდა დავინახოთ, hello, Nik.
ყველა უფლება.
ასე რომ, ეს იყო საკმაოდ hoops რომ ხტომა მეშვეობით, უბრალოდ
დაწერა, აცხადებენ, თქვენი სახელი, და, hello, Nik.
მაგრამ ეს მარტივი იდეა გაგზავნა მიღება, შეყვანის მიღება და გამომავალი მიღების,
არის ზუსტად ის მოდელი, რომელსაც ჩვენ ვაპირებთ აქვს ამისთვის კი ყველაზე რთული ფუნქციები.
ასე რომ, დიდი მადლობა, რომ თქვენ ორივე.
ჩვენ გვყავს ლამაზი სტრესი ბურთი აქ თქვენ.
და მადლობას გიხდით ჩვენს GetString და printf მოხალისეები alike.
დიდი მადლობა.
ყველა უფლება.
დიდი მადლობა, რომ თქვენ ორივე.
>> ასე რომ, ჩვენ ვლაპარაკობდით დღემდე, ძირითადად სიმები.
და აღმოჩნდება, რომ C შეიძლება რეალურად მესმის, რამდენიმე სხვადასხვა ტიპის მონაცემები.
ფაქტობრივად, ავიღოთ შევხედოთ ამ აქ.
ასე რომ, C, და ბევრი ენების, მესმის, რამ მოუწოდა სიმბოლო.
Char არის ზოგადად ერთი ბაიტი, რვა ბიტი.
და იგი წარმოადგენს ერთი ხასიათი, როგორც ასო A, ან დედაქალაქში
წერილი, ან ამას წერილი A, ან ძახილის წერტილი,
ან ხასიათი, რომ თქვენ შეგიძლიათ აკრიფოთ თქვენს კლავიატურაზე, და ზოგჯერ კიდევ უფრო.
ჩვენ ასევე არ უნდა დაინახოს მოძრავი.
Float არის, ზოგადად, 32-bit ღირებულება, ან ოთხი ბაიტი
რადგან ერთხელ, ერთი ბაიტი არის რვა ბიტი.
>> ასე რომ float არის მცურავი წერტილი ღირებულება, რაღაც ათობითი წერტილი.
და მართლაც, რომ ის, რაც ფილმის საუბარი
როდესაც ისინი ისაუბრა მცურავი პუნქტიანი ღირებულებებს, გარკვეული ფიქსირებული რაოდენობის ბიტი
გამოიყენება წარმოადგენს რეალური რაოდენობა.
მაგრამ ასევე რამ მოუწოდა ორადგილიანი.
ეს არსებობს Java, თუ თქვენ მიღებული APCS,
და ორმაგი, როგორც სახელი საბედნიეროდ ვარაუდობს, არის ორჯერ დიდი, როგორც float.
ეს არის კიდევ ნამდვილი რიცხვი, ეს უბრალოდ მეტი ბიტი
, რომელიც, როგორც არასდროს, უფრო სწორად, ან შესანახად უფრო დიდი რაოდენობით.
int არის ადვილი.
ჩვენ ვისაუბრეთ, რომ ბოლო დროს.
ეს უბრალოდ რიცხვი.
და ეს არის ზოგადად 32 ბიტი, და ოთხი ბაიტი.
>> ასე რომ, თუ თქვენ გაქვთ, ვნახოთ ახლა, 32 ბიტი და ჩვენ ეს კვირაში 0,
ოდესმე ასე briefly-- თუ თქვენ გაქვთ 32 ბიტი, რა არის ყველაზე დიდი
პუნქტების შეგიძლიათ წარმოადგენს, როგორც მთელი რიცხვი?
მისცეს ან?
ეს იგივეა, 4 მილიარდი, და ეს მხოლოდ იმ შემთხვევაში, თუ ჩვენ
წარმოადგენს დადებითი ციფრები მხოლოდ.
თუ თქვენ გაქვთ 32 ბიტი, და გსურთ წარმოადგენს უარყოფითი ნომრები, ასევე,
თქვენი სპექტრი არის, არსებითად, უარყოფითი 2 მილიარდი დადებითი 2 მლრდ.
მაგრამ ზოგადად, ჩვენ დავიწყებთ 0 ახვიდეთ 4 მილიარდი.
>> თქვენ არ ვიცი ზუსტად, მაგრამ ჩვენ ვხედავთ ამ, ფაქტობრივად, თუ უბრალოდ
ქმნის პატარა კალკულატორი, აქ.
მე შემიძლია ამის გაკეთება, 2, 32, და ეს არის ის, თუ რამდენად დიდი,
რამდენი ღირებულებების შეგიძლიათ წარმოადგენს, 32 ბიტი.
და ეს დაახლოებით 4 მილიარდი.
ამიტომ ჩვენ გავაგრძელებთ ვხედავთ, რომ ნომერი რამდენიმე სხვადასხვა ადგილებში.
მაგრამ თუ თქვენ უკვე აღარ ციფრები, ვიდრე ის, რომ
ის თურმე არსებობს რაღაც მოუწოდა ხანგრძლივი ხანგრძლივი.
და ხანგრძლივი ხანგრძლივი არის ზოგადად 64 ბიტი, რომელიც
იმას ნიშნავს, რომ ბრძანებით მასშტაბები კიდევ უფრო დიდი, ვიდრე int.
>> ასე რომ, მე კი არ შეხედულებებსა დიდი ნომერი, რომელიც თქვენ შეიძლება წარმოადგენს,
მაგრამ ეს საგრძნობლად დიდია.
ახლა, როგორც განზე, ისტორიულად, თუ int არის 32 ბიტი,
და ხანგრძლივი ხანგრძლივი არის 64 ბიტი, როგორ დიდი დიდი, არ არის დიდი ხანი?
ნეტავ ვფიქრობ, რომ ეს უფრო მეტია, ვიდრე int მაგრამ იქნებ ნაკლებად ხანგრძლივი, ვიდრე ხანგრძლივი ხანგრძლივი,
მაგრამ ეს რეალურად დამოკიდებულია.
>> ასე რომ, გამოდის, ერთ-ერთი იმედგაცრუებები ძალიან,
წერა კოდი გარკვეულ სისტემები, არის, რომ ყველა ამ მონაცემთა ტიპები
აქვს წინასწარ განსაზღვრული ფასეულობები.
ზოგჯერ ამ ბევრი ბიტი.
ზოგჯერ ის, რომ ბევრი ბიტი.
ასე, რომ თქვენ რეალურად უნდა იცოდეს, ზოგჯერ, რა აპარატურა
თქვენ გაშვებული თქვენი პროგრამული უზრუნველყოფა.
საბედნიეროდ, სხვა ენებზე და სხვა მონაცემთა ტიპები, რომ ახლა არსებობს,
გაძლევთ საშუალებას უფრო ზუსტად.
ისე, ჩვენ ვნახეთ, სიმებიანი, და ჩვენ ვნახეთ, bool, ძალიან,
მაგრამ აღმოჩნდება, რომ იმ მოდის მხოლოდ CS50 ბიბლიოთეკა.
ასე რომ, ეს არ აშენდა შევიდა C. ისინი ნაცვლად,
მოდის, რომ ფაილი სახელად CS50.h, რომ ჩვენ საბოლოოდ
კანი უკან ფენების.
მაგრამ ახლა, ისინი მხოლოდ დამატებითი მონაცემები ტიპის.
Bool, არის ჭეშმარიტი ან მცდარი, და სიმებიანი არის თანმიმდევრობა გმირები,
ისევე როგორც სიტყვა.
ახლა printf, ჩვენ ვნახეთ, არ აქვს placeholders,% s არის ერთი.
და თქვენ შესაძლოა, ახლა, დასკვნის ამ სხვა მაგალითები, თუ როგორ
თქვენ შეიძლება ჰქონდეს placeholder სხვადასხვა მონაცემთა ტიპები.
მაგალითად, ვხვდები, თუ მინდოდა ამობეჭდოთ ერთი char გამოყენებით
printf, ჩანაცვლების ალბათ% გ.
და თუ გვინდა ამობეჭდოთ რიცხვი ერთად placeholder,% i.
% LLD არის დიდი ხნის ათობითი მნიშვნელობა, მაგრამ ხანგრძლივი ხანგრძლივი, ამიტომ, რუკები, რომ.
და მაშინ% f მცურავი წერტილი ღირებულება ან ორმაგი,
ასე რომ, ზოგჯერ ისინი ხელახლა გამოიყენება სხვადასხვა კონტექსტში.
ამიტომ, ჩვენ დავინახავთ და გამოყენება ზოგიერთი იმ დროთა განმავლობაში.
და printf და სხვა ფუნქციების ასევე მხარდაჭერა სხვისი გაქცევის sequences,
და ზოგჯერ, ეს აუცილებელია.
ასე რომ, წარმატებული ო არის ახალი ხაზი.
წარმატებული t, ვინმემ მინდა მიიღოს stab?
აუდიტორიის წევრი: Tab.
დავით J Malan Tab.
ასე რომ, თუ თქვენ ნამდვილად გსურთ ამობეჭდოთ tab, არ
ფიქსირებული რაოდენობის ფართები მაგრამ ფაქტობრივი tab ხასიათი, თქვენ არ მოხვდა თქვენი,
tab, გასაღები წლის კლავიატურის, ზოგადად, თქვენ ნამდვილად წარმატებული ტ.
წარმატებული ორმაგი გაცემა, რატომ მე ოდესმე გვინდა, რომ?
მარჯვენა?
რატომ არ შემიძლია უბრალოდ აკრიფოთ ორმაგი ციტირებით ჩემს კლავიატურაზე?
აუდიტორიის წევრი: იმის გამო, რომ წინააღმდეგ შემთხვევაში, ეს
აპირებს ვფიქრობ, რომ ეს არის ის, ბოლოს მოსწონს ბეჭდვითი [? ტექსტი. ?]
>> DAVID J Malan: ზუსტად.
გახსოვდეთ, ჩვენი printf მაგალითები, როდესაც ჩვენ
გადიოდნენ printf, შეყვანის, მარცხენა რომ შეყვანის სიმებიანი
და უფლება, რომ შეყვანის გაზაფხულზე, რა თქმა უნდა, იყო ორმაგი ციტირებით.
თუ საკუთარი input აქვს ორმაგი პასუხის შუა, რომ
კომპიუტერული შესაძლოა დაბნეული, როგორც,
ჯერ ეს ორმაგი ციტირებით მიეკუთვნება შუა?
ს ეკუთვნის, მარცხენა ერთი?
ს ეკუთვნის, უფლება ერთი?
ასე რომ, თუ გსურთ, რომ ეს სუპერ ნათელი, თქვენ backslash ორმაგი გაცემა,
ასე რომ ის გაიქცა, ასე ვთქვათ, და ის conflated რაღაც.
და იქ რამდენიმე სხვა აქ, წარმატებული r, ერთჯერადი შეთავაზებები, 0,
რომ ვნახოთ, დროთა განმავლობაში, ისევე.
ახლა, რაც შეეხება ფუნქციებს?
>> ასე რომ ქმედებები, რომ შეგვიძლია დღემდე ამ ენაზე, C, ასევე, ჩვენ ვნახეთ,
printf, რა თქმა უნდა, და ყველა სხვები ეკრანზე,
აქ, რომ ჩვენ ვიყენებთ რა თქმა უნდა, პირველი რამდენიმე კვირის განმავლობაში მხოლოდ,
მოვა დრო, როცა CS50 ბიბლიოთეკა.
და ისინი მას ბევრად უფრო ადვილია, და C, რეალურად მიიღოს მომხმარებლის შეყვანის.
გამოდის, რომ C, და გულწრფელად რამდენიმე ენაზე,
ეს არის რეალური ტკივილი კისრის უნდა გააკეთოს რაღაც მარტივი, როგორიც შეეკითხება მომხმარებელს
კლავიატურის, მისი შეყვანა.
ასე რომ, ამ ფუნქციების გაუადვილებს.
>> და მას ასევე აქვს შეცდომა შემოწმების მასშტაბით,
ასე რომ, როდესაც თქვენ გავიხსენოთ, ოთხშაბათს, ჩვენ
დაინახა, გაიმეორეთ, გაფრთხილება, როდესაც მე არ ითანამშრომლებს,
მე და აკრეფილი სიტყვა, ნაცვლად ნომერი?
ჩვენ გავაკეთეთ მძიმე მოხსნას დასაწყისში რათა დავრწმუნდეთ შესახებ თანამშრომლობს.
მაგრამ ეს მხოლოდ სასწავლო დისკები, რომ ჩვენ საბოლოოდ,
და სწრაფად, გამეხადა.
>> ასე რომ recap, მაშინ, მოდით მიიღოს სწრაფი შევხედოთ,
ჰგავს ჩვენ გავაკეთეთ Scratch, at ზოგიერთი კანონიკური კონსტრუქტების C.
ეს ნიშნავს, რომ, ერთგვარი საქართველოს, იყოს ელვისებურ ტურს,
ასე, რომ თქვენ გაქვთ მინიშნება და რომ ვნახე რამ პირველ რიგში.
მაგრამ მაშინ ჩვენ შევხედოთ ფაქტობრივი კოდირება გამოყენება ზოგიერთი შენობა ბლოკად.
ასე რომ, ისევე, როგორც Scratch, როდესაც ჩვენ განცხადებები მინდა,
ამბობენ, ან, დაველოდოთ, C, ჩვენ გვაქვს ფუნქციები, ისევე, როგორც printf.
>> თუ გვინდა, რომ გამოხატოს მდგომარეობა C, ის მსგავსია, სულითა,
რომ თავსატეხი ცალი რომ ჩანდა ამ ნულიდან.
მაგრამ ამის ნაცვლად, ჩვენ ფაქტიურად მხოლოდ წერენ, თუ.
და მაშინ, ფრჩხილებში, ჩვენ დააყენა მდგომარეობაში,
სადაც ეს პირობა არის ის, რაც ჩვენ მოვუწოდებთ, კიდევ ერთხელ, ლოგიკური გამოხატვის.
ისევ და ისევ, ეს არის ერთგვარი pseudocode.
და, ფაქტობრივად, // არის კომენტარი.
ეს მხოლოდ ინგლისური სიტყვა თავს.
მაგრამ ეს არ არის ზოგადი სტრუქტურა, თუ მდგომარეობა.
მაგრამ ჩვენ დავინახავთ კონკრეტულ მაგალითები რაღაც მომენტში.
>> თუ გსურთ აქვს ორი გზა გზის გასაყარი,
ჰგავს ჩვენ გავაკეთეთ ჩვენი მოხალისე ოთხშაბათი, თქვენ შეიძლება ჰქონდეს, სხვაგან თუ.
და თუ გვინდა, რომ აქვს მესამე და საბოლოო მდგომარეობა, ან რა სიტუაცია,
თქვენ შეგიძლიათ მხოლოდ სხვა ბლოკი, არ არსებობს.
და ანალოგიურად, ერთად ლოგიკური გამოთქმები, თქვენ შეგიძლიათ, და, მათ ერთად.
და ჩვენ ვხედავთ, ოთხშაბათს, რომ ეს არ არის ერთი ampersand,
ეს ორი, ქვედა დონის მიზეზის გამო, რომ ჩვენ საბოლოოდ ვხედავთ და ითამაშოს.
ან-Ing რამ ერთად 2 ვერტიკალური ბარები.
აშშ-კლავიატურის, ამ ზოგადად გასაღები
ერთად Shift გასაღები ზემოთ თქვენი შეიყვანეთ გასაღები ან დაბრუნების გასაღები.
>> მაშინ არსებობს ასეთი რამ, რომ ჩვენ ვიყენებთ იქნებ ერთხელ ან ორჯერ.
ისინი ფუნქციურად ექვივალენტური რა შეგიძლიათ გააკეთოთ, რომელზეც, თუ სხვაგან, თუ,
სხვაგან, თუ სხვაგან, მშენებლობა, მაგრამ ისინი უწოდებენ შეცვლა.
ისინი ძალიან განსხვავებული, მაგრამ ჩვენ იხილეთ ჩვენი ზოგიერთი განაწილების კოდი,
მომავალში პრობლემა კომპლექტი, სავარაუდოდ, ის, რომ ზოგჯერ უბრალოდ გალამაზებაში
გზა გამოხატავს მთელი bunch of პირობებში,
გარეშე ბევრი Curly braces და ბევრი ფრჩხილებში და წანაცვლება.
მაგრამ ისინი გვაძლევენ, არც მეტი ძალა, ვიდრე ჩვენ უკვე.
ახლა მარყუჟების.
და ეს ერთი, ჩვენ შევხედოთ ერთი პატარა უფრო ნელა.
მაგრამ შემდეგ, ჩვენ დავიწყებთ გამოიყენოს ეს, განსაკუთრებით მათთვის უკვე იცნობს.
ეს არის კანონიკური გზა, თუ ძალიან arcane გზა, დაწერა loop in C.
>> ახლა loop in Scratch იყო საკმაოდ მარტივია.
თქვენ გაქვთ, სამუდამოდ ბლოკი.
თქვენ გაქვთ, განმეორებით, ბლოკი მხოლოდ ნომერი უნდა აკრიფოთ.
და, ამისთვის მარყუჟის, თქვენ შეგიძლიათ განახორციელოს ორივე იმ იდეებს,
მაგრამ ეს ცოტა უფრო ტექნიკური.
მაგრამ გულწრფელად, ასევე, შედარებით მარტივი.
მას შემდეგ, რაც თქვენ იცით, ბრძანებით ოპერაციების, ფაქტიურად
უბრალოდ აპირებს დანამატის ღირებულებები და ვუთხრა კომპიუტერი რა უნდა გააკეთოს.
ასე რომ, აქ არის მაგალითი.
ეს არის მარყუჟის, რომ, საკმაოდ უბრალოდ, ითვლის ერთი მდე
კიდევ ერთი.
და მხოლოდ glancing მას, მაშინაც კი, თუ თქვენ გაქვთ
ადრე გამოცდილება ამ ენაზე, თუ რა რაოდენობის
ამჯამად ეს, ალბათ, დაიწყება დათვლის დროს?
OK, 0.
და მე გამოცნობა, რომ ეს იმიტომ, რომ თქვენ ვხედავთ, რომ იქ int და მე,
რომელიც ცვლადი.
ეს ინიციალიზაცია 0.
>> და შემდეგ, როგორც ჩანს, ჩვენ ავლით printf, მნიშვნელობა.
და, ფაქტობრივად, მე ცოტა შეცდომას აქ.
მაგრამ რომ იოლად დაფიქსირდა.
ნება მომეცით, მე აქ.
ახლა ჩვენ გვაქვს printf ყოფნა გავიდა, რომ ჩანაცვლების ღირებულება.
და რა ხდება ითვლიან up მეშვეობით?
აუდიტორია: 50.
50.
49.
დავით J Malan: 49.
ასე რომ, 50, ერთი შეხედვით, როგორც ჩანს, უფლება.
მაგრამ, რომ, თურმე, იქნება ჩვენი პირობით, რომ ჩვენ შევინარჩუნოთ შემოწმების.
და ჩვენ ვაპირებთ, ერთხელ i აღარ არის 50-ზე ნაკლები.
ასე რომ, ამ მარყუჟის, პირიქით, უნდა შეასრულოს, ასე რომ სანამ მე ნაკლებია 50.
მაგრამ, როგორც კი ეს ხდება 50, ან 51, ან უარესი, რომ უნდა შეწყვიტოს ავტომატურად.
ყველა უფლება.
>> ასე რომ, რა ხდება აქ?
ასე რომ, ეს არის ბრძანებით ოპერაციების loop.
ერთ-ერთი, თქვენ გაქვთ ე.წ. ინიციალიზაციისას.
ეს ყვითელი მონიშნულია ბლოკი კოდი არის შესრულებული პირველი,
და მას აქვს ეფექტი, რომ პოსტი ოთხშაბათი, ალბათ წარმოსადგენია.
ეს ქმნის ცვლადში მე და ის მაღაზიები რომ ცვლადი ღირებულების 0.
ასე რომ, მე არის 0 ამ ეტაპზე ამბავი.
>> შემდეგი რამ, რომ ხდება ამ მშენებლობა,
ის არის, რომ მდგომარეობა იღებს შემოწმდება.
ასე რომ, მე შემოწმება დაუყოვნებლივ, არის მე 50-ზე ნაკლები?
და რა თქმა უნდა, პასუხი ახლა არის, რა თქმა უნდა, დიახ.
დიახ, იმიტომ, რომ მე არის 0, რომ აუცილებლად არანაკლებ 50.
მაშინ რა ხდება, არის ის, რომ ამ ხაზი კოდი იღებს დასაჯეს.
და სინამდვილეში, თუ არსებობს მრავალი ხაზების კოდი იმ Curly braces,
ისინი ყველა შესრულებული ერთმანეთის მიყოლებით.
>> და ეფექტი აქ, როგორც ჩანს, ამობეჭდოთ
რაოდენობის i, რომელიც აპირებს იქნება 0, და შემდეგ 1 და 2.
მაგრამ რატომ?
რატომ მისაღებად incremented?
ისე, მეოთხე, რაც ხდება, რომ ეს სინტაქსი
იღებს შესრულებული, შემდეგ მძიმით.
i ++ არის სტენოგრამის გზა ამბობდა; მიიღოს ღირებულება მე და დაამატეთ 1;
და მაშინ მომავალი დრო გარშემო, დაამატოთ 1 მას; და მომავალი დრო გარშემო,
დაამატეთ 1.
>> ასე რომ, თუ ჩვენ ვაპირებთ შენარჩუნება, რა მოხდება
მომდევნო მე არ ვაპირებ ინიციალიზაცია მე ოდესმე ისევ.
თუ მე ინახება ინიციალიზაციისას i 0, ეს მაგალითი
არასოდეს არ დასრულდება, რადგან i დავრჩებოდით 0.
მაგრამ რა მოხდება რომ მდგომარეობა მოწმდება,
ხაზი კოდი მიიღებენ შესრულებული, ი იქნება incremented,
მდგომარეობა მოწმდება, კოდი მიიღებენ შესრულებული.
და იგი ინახება cycling ერთხელ, და ისევ და ისევ,
სანამ ++ იწვევს ღირებულება 50.
>> მდგომარეობა მაშინ ამბობს, 50 50-ზე ნაკლები?
პასუხი, რა თქმა უნდა, არ არის და ისე მთელი კოდი აჩერებს შესრულებაში.
და თუ თქვენ გაქვთ უფრო კოდი ეკრანზე ქვემოთ, რომ ის, რაც ხდება შემდეგი.
ეს pops out ამ Curly braces და გრძელდება ბეჭდვა შემდეგ.
>> ასე ხუმრობა ახლა, ფოქსტროტი, რომ თქვენ ალბათ ახლა მესმის.
ის ყოველთვის მხიარული.
ეს იგივეა, რომ chuckles სახის percolate,
და მაშინ ხვდები, თქვენ არ უნდა იყოს დასცინის იუმორი მოსწონს ეს.
თუმცა, არსებობს გარკვეული takeaway აქ, პედაგოგთა, ძალიან.
გამოდის, რომ მე ვარ დაკარგული ნაჭერი სინტაქსი,
ან Foxtrot ის დაკარგული ნაჭერი სინტაქსი აქ.
რა აკლია, რომ ჩვენ გვქონდა ყველა სხვა, მაგალითად, დღემდე?
დაბრუნება, არის, ასე რომ არის რაღაც,
რომ ჩვენ დავბრუნდებით ადრე ხანგრძლივი.
რა აკლია, თუმცა?
ჰო.
>> აუდიტორიის წევრი: საქართველოს პარაფირებას [INAUDIBLE].
>> დავით J Malan: OK.
ასე რომ, yeah.
ასე რომ, რეალურად, ეს is-- ისე, და იმედი ინიციალიზაცია
ზემოთ, უფრო სწორად, განაცხადა ზემოთ.
ასე რომ, ეს არის კიდევ ერთი გზა ამის გაკეთება.
მაგრამ არა ერთი ხაზი ეს მოქმედებს, თუმცა.
როგორ აქ?
>> აუდიტორიის წევრი: ეს curly აფრთხილებს?
>> დავით J Malan: ჰო.
ასე რომ, curly აფრთხილებს აკლია.
მაგრამ ეს კოდი, ვგულისხმობ, რომ მათი საკრედიტო, რეალურად, სინტაქსურად მოქმედებს.
გამოდის, თქვენ არ უნდა curly აფრთხილებს
თუ თქვენ გაქვთ მხოლოდ ერთი ხაზი კოდი, რომ თქვენ მინდა შეასრულოს შიგნით loop.
ახლა ჩვენ ყოველთვის, კლასის და ყველა ჩვენი განაწილების კოდი,
მოიცავს curly აფრთხილებს მაინც, უბრალოდ სიცხადე გულისთვის.
მაგრამ გვესმის, რომ სახელმძღვანელოები და ონლაინ მაგალითები,
თქვენ შეიძლება ძალიან კარგად ვხედავთ curly braces დაკარგული შუალედში.
და ეს კარგია, თუ რას არ დაზუსტებისათვის და განკუთვნილია
არის მხოლოდ ერთი ხაზი კოდი, და არა მრავალი ხაზი კოდი, პოტენციურად.
ყველა უფლება.
ასე რომ, დაკავშირებული საკითხი ორაზროვნება, არის საკითხი overflow,
იმ გაგებით, რომ, ასევე, არ რიცხვებით შეზღუდვები მათ
ისევე, როგორც მცურავი პუნქტიანი ღირებულებებს?
მსოფლიოში მცურავი წერტილი ღირებულებები, ჩვენ შეგვიძლია მხოლოდ იმდენად ზუსტი,
მას შემდეგ, რაც, ზოგჯერ ცუდი რამ შეიძლება მოხდეს,
და ჩვენი პროგრამების შეიძლება buggy და შეცდომა.
ახლა კი მთელი რიცხვები, თქვენ შეგიძლიათ გადაეყარონ პრობლემებს.
ახლა რიცხვი არ გააჩნია ათობითი წერტილი ან ნომრები მას შემდეგ.
ეს არის მხოლოდ ნატურალური რიცხვი, როგორც წესი.
რა შეიძლება წავიდეთ არასწორი int?
თუ მე გამოყენებით int to ითვლიან, თუ რა შეიძლება წავიდეთ არასწორი?
როგორც ჩანს, ბევრი მარტივი.
ჰო.
>> აუდიტორიის წევრი: იმ შემთხვევაში, თუ ნომერი იღებს [INAUDIBLE]
>> დავით J Malan: ჰო.
რა მოხდება, თუ თქვენ იმედი იმდენად მაღალია, რომ თქვენ ვერ გამოხატავენ, რომ მართლაც დიდი რაოდენობის.
მარჯვენა?
რაღაც მომენტში, თქვენ აპირებს უნდა აღემატებოდეს საზღვრები
ერთი 32-bit ღირებულება ან 64-bit მნიშვნელობა.
ახლა, მე არ ვარ დარწმუნებული, თუ როგორ შეხედულებებსა 64-ბიტიანი მნიშვნელობა,
მაგრამ მე ვიცი, 32-bit რიცხვი, ყველაზე დიდი მნიშვნელობა შეიძლება იყოს,
იმ შემთხვევაში, თუ ეს მხოლოდ დადებითად ღირებულებები, დაახლოებით 4 მილიარდი.
ასე რომ, თუ მე ვცდილობ ითვლიან 5 მილიარდი, რაღაც უნდა მოხდეს.
მაგრამ ვნახოთ, რა, ფაქტობრივად, შეიძლება მოხდეს.
მსოფლიოში რიცხვი overflow, სადაც თქვენ, გრძნობა,
overflow რანგში რიცხვი, რა შეიძლება მოხდეს?
>> ასე რომ, აქ ბინარული ნომერი, ეს თითქოს 0.
ეს ყველაფერი 1-ის და placeholders იქ არის უფლებამოსილების 2,
ასე რომ, ეს არის ორობითი.
ასე რომ, ეს არის 8, 1 ბიტი ეკრანზე.
და თუ გავიხსენებთ, ან თქვენ სწრაფად მათემატიკის,
რა მნიშვნელობა წარმოდგენილი აქ ამ რვა 1 ბიტი?
255.
და მაშინაც კი, თუ თქვენ არ იყვნენ სრულიად დარწმუნებულია მათემატიკის, თქვენ შეიძლება იგი out.
ან შეიძლება უბრალოდ სახის მიზეზი მეშვეობით,
დაველოდოთ წუთში, თუ მე წარმოადგენს 8 ბიტიანი მნიშვნელობა,
და მაქვს 256 შესაძლო მნიშვნელობებია, მაგრამ პირველი, რომელიც არის 0,
მე მხოლოდ ის ვიცი, რომ დიდი იქნება 255,
და ის, რაც ამ ერთი შეიძლება იყოს.
>> ასე რომ, ვფიქრობ, ვცდილობ, რომ დაამატოთ 1 მნიშვნელობა.
რას იზამდით კლასის სკოლა, როდესაც დასძინა 1, და ეს
ნამდვილად არ ჯდება, რადგან თქვენ უნდა შეასრულოს 1?
რა არის ეს ნომერი აპირებს გახდეს, როდესაც თქვენ დაამატოთ 1?
ის აპირებს გახდეს 0.
მარჯვენა?
იმის გამო, რომ თუ უფრო ბიტი და მე ცდილობენ, სახის, აკრიფოთ ის აქ
თუ ჩვენ გვქონდა უფრო ბიტი, რაც ჩვენ შეიძლება ამის გაკეთება აქ რჩეულებში 1,
და მაშინ ჩვენ მინდა ეს.
Whoops.
გვსურს აქვს 1 bit ყველა გზა აქ.
>> მაგრამ თუ ეს არის სასრული მნიშვნელობა, ეს მხოლოდ 8 ბიტი,
და ეს წინასწარ განსაზღვრული კომპიუტერი,
რომ 1 არის ეფექტურად არ არსებობს.
უბრალოდ სახის მოდის off cliff.
ასე რომ, თუ თქვენ დაამატოთ 1 255, რა მნიშვნელობა თქვენ, როგორც ჩანს, კიდევ?
0.
ასე რომ, ნომრები შემთხვევით, და შესაძლოა, უნებლიეთ,
დასრულდება მდე შესაფუთი გარშემო მოსწონს ეს.
ასე რომ, რა შეიძლება იყოს გულისხმობს ეს?
ისე, არსებობს რამდენიმე სხვადასხვა რამ.
ასე რომ, ერთი, ეს არ დასრულდება მდე ეძებს მოსწონს 0, უნებლიეთ,
მაგრამ შეგიძლიათ სახის ვხედავ, მაშინაც კი, რეალურ სამყაროში,
უკეთესი ან უარესი, მანიფესტაციების ეს იდეა ლიმიტი.
მაგალითად, ნებისმიერი, ვინც ოდესმე ითამაშა Lego Star Wars,
ვინმეს არ უნდა იცოდეს მაქსიმალური რაოდენობის მონეტები
შეგიძლიათ შეაგროვოთ Lego Star Wars?
მიიღეთ ვხვდები საფუძველზე დღევანდელი წამყვანი შეკითხვებს.
ეს უფრო დიდია, ვიდრე 256 ან 255.
ეს 4 მილიარდი.
ასე რომ, თურმე, და არსებობს ზოგიერთი ადამიანი
ზოგიერთი googling დაადასტურა ბოლო ღამე მიღებული 4 მილიარდი ოქროს მონეტები,
ან whatnot, ამ Lego Star Wars.
მიუხედავად იმისა, რომ როგორც ჩანს, არ არის გზა შეასრულა თამაში,
არსებობს ხარვეზის ან ფუნქცია, რომელიც საშუალებას გაძლევთ უბრალოდ დაერიცხება უამრავი და უამრავი რაოდენობა.
მაგრამ უდიდესი შესაძლო ღირებულება, შესაბამისად
ამ ეკრანზე გადაღებული ვინმე მე ი შემოსული, მართლაც, 4 მილიარდი.
>> ახლა რატომ არის, რომ?
ეს არის ზუსტად 4 მილიარდი, ალბათ იმიტომ, რომ ვიღაცამ გადაწყვიტა,
რომელიც წერდა, ამ თამაშში, ის, რომ შეიძლება 4 მილიარდი,
რაღაც, რაღაც, რაღაც, როგორც ღირებულება მე დაფასოებული
ერთად კალკულატორი ადრე, მაგრამ ეს უბრალოდ ცოტა სუფთა ადამიანები
ვთქვა, მაქსიმალური რაოდენობა საქართველოს coins-- ან უხეშად,
როგორც მათ მოვუწოდებთ მათ, რომ თქვენ შეუძლია შეაგროვოს არის 4 მილიარდი.
ასე რომ, რატომ არის ეს?
როგორ არის კომპიუტერული თამაში ახორციელებს counter
რომ შენახვა ტრეკზე რაოდენობის მონეტები გაქვთ?
ისინი გამოყენებით რა?
აუდიტორიის წევრი: იგი აჩერებს დათვლის შემდეგ 4 მილიარდი.
დავით J Malan იგი აჩერებს დათვლის შემდეგ 4 მილიარდი,
რაც იმას ნიშნავს, თქვენ შეგიძლიათ დასკვნის, როგორც პროგრამისტი,
რომ ისინი ალბათ გამოყენებით 32 bit რიცხვი.
ისევე როგორც პროგრამისტი ფაქტიურად აკრეფილი, int, მისი კოდი,
და რომ ის ტიპის ცვლადი, ისინი იყენებენ შესანახად ვიღაცის კოდი.
ასე რომ, არსებობს სხვა გამოვლინებები ამ სახის ფარგლებს გარეთ.
>> ასე რომ, მე არ ითამაშა ამ game-- და ვკითხულობდი up ისტორიაში
იმის დასადასტურებლად, რადგან much-- მაგრამ ორიგინალური ვერსია ცივილიზაციის, სადაც
თქვენ, როგორც ჩანს, ერთმანეთთან ურთიერთობა სხვა და ომს და მშვიდობას,
Gandhi უნდა იყოს ერთ-ერთი ყველაზე მშვიდობიანი გმირები, როგორც მე
მესმის, რომ ეს, პირველ მობილური ცივილიზაციის.
და სინამდვილეში, ისეთი მასშტაბის 1 დან 10, მისი აგრესია იყო მხოლოდ 1.
ასე რომ, ოდესმე ასე ვთქვათ აგრესიული, როგორც ჩანს.
>> მაგრამ რაღაც მომენტში, თქვენ, როგორც ჩანს, ინსტალაცია დემოკრატიას თქვენს გეოგრაფია.
და თუ თქვენ დააყენოთ დემოკრატია თქვენი ვერსია თამაში,
მაშინ თქვენი აგრესია დონეზე მიდის ქვემოთ.
ეს კარგია.
ხალხი უფრო მშვიდი როგორც ჩანს, ამ სიტუაციაში.
მაგრამ, როგორც ჩანს, ვიღაცამ არ აქვს, თუ მდგომარეობა
ორიგინალური ვერსია კოდი.
>> ასე რომ, Gandhi აგრესიის დონე წავიდა დადებითი 1, -2, -1,
მაგრამ თამაში ჯერ არ მესმის, უარყოფითი რიცხვები.
ასე რომ, რა მოხდა, Gandhi აგრესია დონე წავიდა 1, 0, -1,
რომელიც ჰქონდა ეფექტი შესაფუთი გარშემო მყოფი
ყველაზე აგრესიული ხასიათი თამაში, ერთი ღირებულება 255,
ისეთი მასშტაბის 1 დან 10.
და მას შემდეგ, იქ იყო უფრო ინკარნაციაში ამ თამაშში,
და ისინი ინახება ეს როგორც ერთგვარი აღდგომის კვერცხი,
რომ Gandhi, როგორც ჩანს, ასე საშინლად აგრესიული.
მაგრამ ეს იყო შედეგი ძალიან მარტივი პროგრამირების შეცდომა
რომ ძალიან ადრეული ვერსია თამაში.
>> ახლა უფრო შემაშფოთებელია, უფრო ცოტა ხნის წინ, Boeing 787
დოკუმენტურად მქონე bug, არ ნიშნავს, რომ მოწყობილობა
განსაკუთრებით გვინდა, რომ აქვს ხარვეზი.
და სიმპტომები, რომელიც მე წავიკითხე აქ, სტატია შემოსული,
იყო ეს მოდელი 787 თვითმფრინავი რომ უკვე იკვებება მუდმივად
248 დღის შეიძლება დაკარგოს ყველა ცვლადი დენის, კონდიცირება,
ელექტროენერგიის, იმის გამო, რომ გენერატორი კონტროლის ერთეული,
GCUs, ერთდროულად შესვლის Fail-Safe რეჟიმში.
ასე რომ, ეს იყო გაფრთხილება გაცემული როდესაც ეს პრობლემა აღმოაჩინეს.
ეს მდგომარეობა გამოწვეულია მიერ პროგრამული counter,
შიდა to GCUs, ასე რომ მთელი რიცხვი ან ცვლადი,
რომ ნება overflow შემდეგ 248 დღის უწყვეტი დენის.
ბოინგი პროცესში განვითარებადი GCU პროგრამული განახლება, რომელიც
გამოსასწორებლად სახიფათო მდგომარეობაში.
>> იმდენად მოსწონს სარაკეტო სცენარი, სადაც
მათ ჰქონდათ გარკვეული სახის ცვლადი რომ იმედი და იმედი,
და იმედი, მაგრამ თანდათან სავსე საზღვრების შესაძლებლობა,
ანალოგიურად გააკეთა რა თვითმფრინავი ცვლადი overflow
მას შემდეგ, რაც საკმარისი დრო გაშვებული.
ასე რომ, ენა-in-cheek გზა სამუშაო ამ საკითხის ირგვლივ
არის ნამდვილად, გადატვირთვისას, თქვენი თვითმფრინავი ყოველ 247 დღის განმავლობაში, ისე, რომ მეხსიერების იღებს წაშლილია
და ცვლადი მიდის უკან 0.
მაგრამ გააცნობიეროს, რომ ეს არის ძალიან დიდი განსახიერება პროგრამული უზრუნველყოფა,
მაგრამ განსაკუთრებით როგორც ჩვენ გვესმის Apple- ის ოპერაციული სისტემები შესვლის მანქანები,
და თვითმმართველობის მამოძრავებელი მანქანა Google, და ნებისმიერი რაოდენობის ინკარნაციაში პროგრამული უზრუნველყოფა
ჩვენი ყოველდღიური ცხოვრება, ტელევიზორები და საათები და სხვა,
გააცნობიეროს, გარშემორტყმული პროგრამული უზრუნველყოფა, ყველაფერი, რაც არის დაწერილი ჩვენთვის ადამიანები.
>> და როგორც ჩვენ ყველა მალე აღმოაჩენთ, ეს არის ძალიან მარტივი და ძალიან ტიპიური
რათა შეცდომები, როდესაც წერა პროგრამული უზრუნველყოფა.
და თუ თქვენ არ დაჭერა მათ, ზოგიერთი ცუდი რამ შეიძლება მოხდეს.
ახლა ხანდახან ზოგიერთი სასაცილო რამ შეიძლება მოხდეს,
ან ხანდახან მაინც ჩვენ ვიცი, რომ ველოდებით გარკვეული ბოროტება.
ასე რომ, 0 იყოფა 0, კლასის სკოლა, ზოგადად ცუდი რამ.
ეს გაურკვეველია.
და თურმე out-- და ვნახოთ, თუ ჩემი mic შეგიძლიათ აირჩიოთ ამ up-- რომ Apple
გარკვეული fun ამ ცოტა ხნის წინ.
ასე რომ, მე მაქვს iPhone აქ.
მე ვაპირებ გაიგო Siri და ვთხოვთ მას, მომეცი პასუხი 0 იყოფა 0.
რა არის 0 იყოფა 0?
>> SIRI: წარმოიდგინეთ, რომ თქვენ გაქვთ 0 cookies, და გაყოფილი მათ თანაბრად
შორის 0 მეგობარი.
რამდენი cookies ამჯამად თითოეულ ადამიანს მისაღებად?
ვხედავ?
ეს არ აქვს აზრი.
And Cookie Monster არის სამწუხარო რომ არ არსებობს cookies.
და თქვენ სამწუხაროა, რომ თქვენ არ გაქვთ მეგობარი.
დავით J Malan: ეს არის ერთგვარი უსიამოვნო.
ასე რომ, ეს არის ის, რაც თქვა, რომ არსებობენ.
ეს გაურკვეველი, ეს არ არის განსაზღვრული, და მართლაც, მრავალი პროგრამირების ენებზე
ან, მართლაც, შემდგენლები იქნება აღმოაჩინოს, როდესაც თქვენ, პროგრამა,
ცდილობენ გაყოფა 0 0.
სიამოვნება, ვიდრე ეს, თუმცა, არის რომელიც, როგორც ჩანს, Cookie Monster
არის Twitter ამ დღეებში.
და მან უპასუხა, რომ ეს, ეს, რომელიც აბსოლუტურად adorable.
მაგრამ მოდით მიიღოს სწრაფი შევხედოთ რამდენიმე სხვა აშენებს,
და შემდეგ დააყენოს ზოგიერთი ამ კოდი გამოყენება, კარგი გზა.
გამოდის, რომ, გარდა ამისა, მარყუჟების, არსებობს
რაღაც მოუწოდა ხოლო მარყუჟის, რომ გამოიყურება სხვადასხვა და ხორციელდება
პატარა differently-- და ჩვენ საბოლოოდ ვხედავთ examples--
მაგრამ გარკვეული თვალსაზრისით, ეს მარტივი, რადგან ეს
არ იძლევა საშუალებას, რომ ვრთავთ და განახლება ფარგლებში საზღვრის loop.
თქვენ შეგიძლიათ კვლავ განახორციელოს იგი.
ასე რომ თქვენ შეგიძლიათ ზუსტად იგივე რამ ხოლო loop, როგორც ამისთვის მარყუჟის,
მაგრამ თქვენი სინტაქსი, ultimately-- როგორც ჩვენ საბოლოოდ
see-- იქნება განსხვავებული.
იქ კი do ხოლო loop, რომელიც რეალურად ცოტა განსხვავებული,
რომ მაშინ, როცა ამისთვის მარყუჟის და ხოლო loop ყოველთვის
შეამოწმეთ მათი მდგომარეობა, პირველ რიგში, იმ შემთხვევაში, თუ თქვენ ამ რამ ზემოდან,
ეს ერთგვარი ჰგავს ის აპირებს შეამოწმეთ იგი მდგომარეობა ბოლო იმიტომ, რომ ეს
მართლაც ბოლო ხაზი კოდი.
მართლაც, რომ იქნება სასარგებლო გარკვეული პროგრამები, რომ ჩვენ წერენ,
თუ გვინდა, რომ უბრალოდ ბრმად, რომ რამე და საბოლოოდ შეამოწმოს მდგომარეობა.
ეს არ არის აუცილებლად ცუდი რამ.
თუ ჩვენ გვინდა ცვლადები, ჩვენ შეგვიძლია გავაკეთოთ მას რამდენიმე სხვადასხვა გზა.
და ჩვენ ვნახეთ Foxtrot მულტფილმი, ერთი გზა ამის გაკეთება,
სადაც თქვენ განაცხადოს თქვენი ცვლადი, როგორც int counter მძიმით,
და შემდეგ later-- შესაძლოა, მომდევნო ხაზი, შესაძლოა, 10 ხაზები later--
თქვენ ნამდვილად ინიციალიზაცია იგი.
ასე რომ, ეს 2 ხაზი კოდი განაცხადოს ცვლადი ტიპის int
და მას counter, ასე რომ აძლევს ჩემთვის საკმარისი ბიტი გამართავს int.
და მაშინ საბოლოოდ, ეს აყენებს ღირებულების 0 შევიდა, რომ ცვლადი.
ეს აწყობს 0 და 1 ს in a ნიმუში, რომ ჩვენ ვიცით, გასულ კვირას,
წარმოადგენს პუნქტების ჩვენ ვიცით, როგორც 0.
ან გულწრფელად, თქვენ შეგიძლიათ ამის გაკეთება ბევრად უფრო მოკლედ, ისევე, როგორც ეს.
>> ახლა ჩვენ ასევე გვაქვს უნარი მოვუწოდებთ ფუნქციები.
და რეალურად, აქ არის 2 ონლაინ პროგრამა, ან ამონაწერი მისი,
რომელიც საშუალებას გვაძლევს რეალურად დაწერა რამდენიმე კოდი, რომელიც
იღებს ნახატზე user-- ბევრი ისევე როგორც ჩვენი მოხალისე მომენტში ago--
შენახვის შედეგი ცვლადში სახელი,
და შემდეგ, ისევე როგორც ჩვენი მოხალისე ერთად printf-- ბეჭდავს იმ ფასეულობების
გავლით ორ არგუმენტები, სიმებიანი, რასაც მოჰყვა ცვლადი
უწოდებენ, სახელი, თავად.
მოდით შევხედოთ, სანამ ჩვენ დავბრუნდებით Mario იქ,
დროს რამდენიმე ახლა, მაგალითია.
>> მე ვაპირებ წავიდეთ წინ და გახსნა up, ვთქვათ, ფუნქცია 0.c.
და როგორც ყოველთვის, ეს კოდი არის შესაძლებელია, რა თქმა უნდა ნახვა,
ასე რომ თქვენ შეუძლია გასწვრივ სახლში და შევხედოთ მას შემდეგ.
მაგრამ აქ არის პროგრამა ეს არსი, ხაზს 17 22.
მთავარი პროგრამა არის სადაც პროგრამა ყოველთვის დაწყებას აპირებს.
ეს პროგრამა, როგორც ჩანს, აპირებს ამობეჭდოთ თქვენი სახელი, ნაწლავის.
ეს მაშინ ხდება მოვუწოდებთ GetString, ისევე, როგორც ჩვენ გავაკეთეთ ჩვენი მოხალისეები.
და მაშინ, ეს არის საინტერესო, ის აპირებს მოვუწოდებთ PrintName.
გამოდის, ყველა ამ დროს, როგორც ჩანს, ფუნქცია მოუწოდა PrintName.
ბეჭდავს რომ ვინმეს სახელი.
ჩვენ არ უნდა გამოვიყენოთ printf საწყისი წარსულის, იქ PrintName.
>> მაგრამ ეს დეზინფორმაციულ იმიტომ, რომ PrintName არ
მოდის C. ადამიანები არ გამოგონება დაახლოებით 40 ან 50 წლის წინ,
მე, ნაცვლად.
და სინამდვილეში, თუ მე გადახვევა ქვემოთ შემდგომი, ცნობა
როგორ შემიძლია დაწერა საკუთარი ფუნქციების C. ჩვენ საბოლოოდ
რატომ ჩვენ შევინარჩუნოთ ამბობდა, ბათილად, რამდენიმე ადგილას,
მაგრამ დღეს, მოდით უბრალოდ შეხედეთ სახელი.
>> On line 24, თუ გვინდა, რომ შექმნათ თქვენი საკუთარი ფუნქცია,
თქვენ ფაქტიურად დაწერა სახელი ფუნქცია.
მე აირჩია PrintName.
ფრჩხილებში, თქვენ მაშინ დააკონკრეტა, თუ რა სახის
საშუალებებით, და რამდენი გვინდა, რომ ეს ფუნქცია მიიღოს.
ამ შემთხვევაში, მე მინდა, რომ 1 ცვლადში, სახელი,
და ეს იქნება საქართველოს ტიპის, სიმებიანი, ასე რომ, ის აპირებს
უნდა იყოს გარკვეული თანმიმდევრობა სიმბოლო.
და მაშინ, ამ პროგრამის ჰგავს Scratch,
თქვენ შეიძლება ჰქონდეს საბაჟო თავსატეხი pieces-- აპირებს აქვს ამ საბაჟო ქცევა.
იგი აპირებს მოვუწოდებთ printf გავლის შემდეგ, hello, placeholder,
და შემდეგ ის აპირებს plug რასაც მომხმარებელს მოუწოდა.
>> ასე რომ, ეს არის მაგალითი იმისა, თუ რა კომპიუტერული მეცნიერი იქნებოდა
დარეკეთ აბსტრაქცია და ფუნქციური რღვევა, რომელიც მხოლოდ
ლამაზი გზები ამბობდა არის თუ გსურთ ამ მაღალი დონის იდეა,
როგორიც მე მინდა ფუნქცია, რომელიც ბეჭდავს ვინმეს სახელი, აბსოლუტურად თქვენ
შეგიძლიათ სიტყვასიტყვით დაწერა printf და შემდეგ კორიდორი არგუმენტები გსურთ,
და პროგრამა მუშაობს, როგორც ეს მას შემდეგ განაცხადა.
მაგრამ თქვენ შეგიძლიათ დაიწყოს აბსტრაქტული მოშორებით ცნება ბეჭდვის სახელი.
თქვენ შეგიძლიათ მისცეს მას სახელი, ისევე როგორც PrintName, და ეს
ამ იდეას layering კვირაში 0.
>> ამიერიდან, მე და თქვენ არ უნდა იცოდეს ან მაინტერესებს, რამდენად PrintName ხორციელდება.
დიახ, იყენებს printf, შესაძლოა, არ არის, ვინც იცის, რა იყენებს?
ვინ ზრუნავს?
ახლა მე ვსაუბრობ აქ, ნაცვლად ქვემოთ აქ.
და მართლაც, როგორც ჩვენი პროგრამების კიდევ მოწინავე და დახვეწილი,
ჩვენ ვაპირებთ, რომ აღების მიანიჭა რომ ქვედა დონის თავსატეხი ცალი არსებობს.
იმიტომ, რომ ჩვენ წერდა მათ ან ვინმეს გააკეთა, ასე რომ
რომ ჩვენ შეგვიძლია მაშინ დაეყრდნონ თავზე მათ.
მოდით შევხედოთ ამ ვარიანტი, ფუნქციონირებას ერთი.
>> ასე რომ, ეს ერთი პატარა უფრო მოწინავე, მაგრამ აღმოჩნდება,
რომ CS50 ბიბლიოთეკა, იქ მხოლოდ GetInt ფუნქცია.
ჩვენ არ ვფიქრობ, წლის წინ, განახორციელოს GetPositiveInt ფუნქცია.
და ეს ცოტა შემაშფოთებელი იმიტომ, რომ თუ თქვენ ბიჭები არიან პროგრამის წერა, სადაც
გსურთ მიიღოთ დადებითი რიცხვი საწყისი მომხმარებელს,
თქვენ შეგიძლიათ სრულიად გამოყენება GetInt.
და თქვენ შეგიძლიათ სრულიად შეამოწმოთ მდგომარეობა და შესაძლოა loop
თუ ეს int არის დიდი ვიდრე 0 დაწეროთ შესახებ
თუ იგი არ მისცემს თქვენ დადებითი რიცხვი.
მაგრამ მოდით ავაშენოთ ეს შენობის ბლოკირება თავს,,
საბაჟო Scratch ცალი, თუ გნებავთ.
მე ვაპირებ აქვს პროგრამა აქ, რომ საბოლოო ჯამში, მე
გსურთ შეძლებს მოვუწოდებთ GetPositiveInt, და მე მინდა, რომ იყოს
შეძლებს ამობეჭდოთ რასაც int არის.
მაგრამ ეს რეფერირებადი მოშორებით არის.
უბრალოდ მიეცა მაღალი დონის სახელი, რომელიც ამბობს, თუ რას აკეთებს,
რომელიც მშვენიერი, რადგან ეს ძალიან ინტუიტიური ახლა წავიკითხე.
და თუ მე მაინტერესებს, რა არის ქვეშ Hood, ნება მომეცით გადახვევა ქვემოთ.
და ეს ცოტა დაშინებას პირველი, განსაკუთრებით
თუ ეს თქვენი პირველი პროგრამა, მაგრამ მოდით შევხედოთ.
>> მე აღარ ამბობდა, ბათილია, იმიტომ, რომ თურმე ფუნქციები,
ჰგავს GetString, შეუძლია დაბრუნების მნიშვნელობა ჩემთვის.
ისინი არ არიან ბეჭდვა ეკრანზე,
მათ შეუძლიათ რეალურად გადასცემს მე რაღაც უკან.
და თუკი ადრე PrintName, მე არ უნდა არაფერი უკან.
მე საჭირო გვერდითი ეფექტი რაღაც გვიჩვენებს up ეკრანზე,
მაგრამ მე არ უნდა ადამიანის გადასცემს ჩემთვის რაღაც უკან.
აქ, GetPositiveInt, ისევე GetInt,
მინდა გადაეცემა რაღაც უკან.
ასე რომ, მე ვამბობ, არ, ბათილად, on line 23, მაგრამ int,
რომელიც ამბობს, ამ ფუნქციის რომ გწერთ,
მოუწოდა GetPositiveInt აპირებს გადასცემს ჩემს უკან მთელი რიცხვი, არაფერი,
არ ბათილად.
>> იმავდროულად, იგი აპირებს არსებობს საშუალებებით, ასე რომ მე, სახის, შეცვალა იგი.
მე არ აძლევდა GetPositiveInt ნებისმიერი input, მე მინდა, რომ მომეცი მისი გამომუშავება.
და მერე რა ხდება ახლა?
ასე რომ, აქ არის თუ როგორ შემიძლია განვაცხადო, ცვლადი.
მე ვაკეთებ გარეთ მარყუჟის, მიზეზების გამო, ჩვენ საბოლოოდ ვხედავთ,
მაგრამ ეს მხოლოდ აძლევს მე 32 ბიტი მოუწოდა, n,
და მე წინასწარ განსაზღვრის მათ შესანახად რიცხვი.
აქ არის ის, რომ ამის გაკეთება, ხოლო მშენებლობა, და ეს არის, თუ რატომ არის სასარგებლო.
ფაქტიურად ამისათვის, ხოლო n ნაკლებია, ვიდრე 1.
ასე რომ, ვნახოთ, რა მოხდება.
მე ბეჭდვა, გთხოვთ მაძლევს დადებითი int.
მე მაშინ კიდევ int გამოყენებით CS50 ს ფუნქციონირებს და ინახება n.
>> და მაშინ, რა ხაზი კოდი, ალბათ, იღებს შესრულებული შემდეგი, ლოგიკურად?
რომელი ხაზის ნომერი?
ჰო, ისე 31.
თქვენ არ ვიცი, სანამ თქვენ უკვე განუცხადა, ან სახის დასკვნის გაკეთება,
მაგრამ, რომ მართალია.
იგი მიდის ზედა და ქვედა და შემდეგ იმეორებს.
ასე რომ, თუ მე აკრეფილი ვთქვათ, ნომერი უარყოფითი 1, არის N ნაკლებია, ვიდრე ნეგატიური 1?
ჰო.
იმის გამო, რომ უარყოფითი 1 ნაკლებია, ვიდრე 1.
ასე რომ, რა უნდა მოხდეს?
მე ვაპირებ ამის გაკეთება ხოლო N ნაკლებია, ვიდრე 1,
ასე რომ, მე ვაპირებ დავუბრუნდეთ ხაზი 28.
>> და თითოეული time-- და მოდით აწარმოებს ამ ფუნქციის 1 კომპილირება,
და ახლა dot slash ფუნქცია 1.
თუ მე აკრიფოთ -1, ეს ვაპირებ შენარჩუნება ყვირილი at me
სანამ მე თანამშრომლობაზე, ვინაიდან თითოეულ ჩემი საშუალებებით ნაკლებია, ვიდრე 1
და თუ ის, ხოლო 1-ზე ნაკლები, მე ვაპირებ შენარჩუნება ამით.
თუ მე საბოლოოდ მისცეს მას რაოდენობის, როგორიცაა 50, საბედნიეროდ, ის ამბობს, მადლობა 50.
რატომ?
იმის გამო, რომ, როგორც კი n ნაკლები არ არის 1, მე შეჩერება ვებმებით ამ loop,
და ამ ახალი სიტყვით, დღეს, სანაცვლოდ, ფაქტიურად აკეთებს, რომ.
ასე რომ, მე უბრალოდ განხორციელდა, ამ გრძნობა, ეკვივალენტს GetString,
სადაც მე გადაცემის უკან ვინც იყენებთ ჩემთვის, გარკვეული მნიშვნელობა.
ეს არ უნდა იყოს სიმებიანი, ეს int.
ასე მარტივი, სწრაფი მაგალითად, მაგრამ ჩვენ მალე
ზოგიერთი უფრო დახვეწილი ვერსიები მაინც.
ფაქტობრივად, ავიღოთ შევხედოთ numeric ერთი, რომელსაც return.c.
და ეს ერთი, ფაქტობრივად, ცოტა მარტივი.
ასე რომ ამ პროგრამის მიზანი life-- მოდით კომპილირდება და აწარმოებს,
ასე რომ დაბრუნების, dot ხაზი, დაბრუნდება ცნობა
პროგრამა უბრალოდ კუბურები ღირებულება 2.
ეს საკმაოდ სულელური, ძნელია კოდი, ეს არ მიიღოს ნებისმიერი საშუალებებით,
მაგრამ ეს იმას დემონსტრირება სხვა ფუნქცია, რომელიც მე დაწერილი თავს.
ასე რომ, აქ, მე გამოაცხადა ცვლადი, მოუწოდა x, ტიპის int,
ტოლი ნომერი 2, სრულიად უკანონო.
ეს არის რამოდენიმე fluffy ბეჭდვა.
იგი აცხადებს, რომ x არის, ასეთი და ასეთი, cubing dot dot dot.
და ჯადოსნური, როგორც ჩანს, შეესაბამება 21.
მე მოუწოდებდა ფუნქცია მოუწოდა, cube, მე გადაცემის ფურცელი
რაოდენობის 2 წერია მასზე, და რა მნიშვნელობა, მათემატიკურად,
მინდა გავიდნენ ეს?
ისევე, როგორც საღი აზრის შემოწმება?
8.
მარჯვენა?
მე მინდა 2 კუბში უკან, 2 ძალა 3, 8 უკან.
>> ისე სად არის cube ხორციელდება?
ისე, შენიშნავს, რომ ის ხორციელდება ქვემოთ აქ.
და ისევე, როგორც ადრე, ლოგიკურად, მიუხედავად იმისა, რომ სინტაქსი, ალბათ,
ძალიან ახალი ბევრი თქვენგანი, მე მინდა ამ ფუნქციის
გადასცემს ჩემს უკან ფურცელი ქაღალდი რომელზეც int იგი.
ასე რომ, მე მაქვს int, სახელი თვითნებურად,
მაგრამ მოხერხებულად მოუწოდა კუბი.
შეყვანის მას, არის ნ ჩაწერეთ რიცხვი, ასე რომ
როგორ შემიძლია კორიდორი ნომერი 2 ფურცელზე.
და მაშინ გამოდის, C მხარს უჭერს მათემატიკის, ასე რომ თქვენ არ აქვს x ს ჯერ,
უბრალოდ გამოიყენოთ ვარსკვლავით გამრავლება.
ეს ბრუნდება N ჯერ N ჯერ n, რომელიც უბრალოდ cubed ღირებულება.
>> ასე რომ, სად მივდივართ ყველა ამ?
ეს არის ნამდვილად ელვისებურ ტურს, დანარჩენი დავრწმუნდი,
რომ სუპერ სექციები და ამ პრობლემის მითითებული 1,
თქვენ უნდა დადიოდა ყველა ეს ყველა სხვა.
და ამ პრობლემის მითითებული 1, ჩვენ გადასვლას საწყისი გრაფიკული სამყაროში Scratch
რაღაც უფრო command line C. მაგრამ ჩვენ სულისკვეთება
ამ აქ თამაში საწყისი წარსულის, სადაც
გამოყენებით C და სტანდარტული გამოცემა P კომპლექტი თქვენ განხორციელების Mario პირამიდის.
და ჰაკერი გამოცემა P მითითებული, თუ ისე აირჩიოს აირჩევს,
თქვენ განახორციელოს უფრო მეტი რთული პირამიდის ორი მწვერვალები.
თქვენ ასევე განახორციელოს ალგორითმი, ხარბი ალგორითმი.
თურმე არსებობს ის რამდენიმე საინტერესო ლოგიკა
უკან პროცესი გაშვებული სალარო სადგური
და რეალურად გადაცემის ვინმე უკან ცვლილება.
არ არის ალგორითმი რომელიც არის საკმაოდ მარტივია, რომ თქვენ, შესაძლოა,
დაჯექი ინტუიციურად, როცა პირველად წავიკითხე it-- ხვდებიან, რომ ის, რაც მე ყოველთვის
გაკეთდეს ნებისმიერ დროს მე მოცემული ვინმე ზოგიერთი ფული back--, რომელიც საშუალებას გაძლევთ, რომ ყოველთვის
რაოდენობის შემცირების ქაღალდის აღნიშნავს და ლითონის მონეტები
რომ თქვენ გადაცემის უკან შესახებ.
და ეს, რა თქმა უნდა, არის მყარი იმიტომ, რომ თუ წასვლა CVS ან whatnot,
თქვენ არ მინდა, რომ იყოს გადასცა მთელი bunch of პირობა
ან მთელი bunch of pennies.
გსურთ ნაკლები მონეტები, ალბათ, შესაძლებელია.
>> და ბოლოს, თქვენ ასევე უნდა დადგა უნდა ჩაერიოს მსოფლიოში წყლის
და რეალურად კიდევ მადლიერება ამისთვის რუკების შორის განაკვეთების ნაკადი,
მოსწონს, წყლის შხაპი, უბრალოდ რამდენად წყალი გამოიყენება.
და ალუზია მასში, იქნება ეს კლიპი აქ,
რომელიც ჩვენ დასრულდება for მხოლოდ 60 წამი, რომ
ხატავს სურათს დაბალი ნაკადის საშხაპე ხელმძღვანელები.
>> [ვიდეო აღწარმოების]
-ყველა უფლება.
მე მივიღე ყველაფერი აქ.
მე მივიღე Cyclone F სერია, Hydra, Jetflow, სტოკჰოლმში
Supersteam, თქვენ დაარქვით.
>> ისე, თავად რას მირჩევთ?
>> რა ეძებ?
>> -Power კაცი.
სიმძლავრე.
მსგავსი Silkwood.
-სწორედ რადიაციული.
-სწორედ უფლება.
-ახლა რა არის ეს?
-სწორედ კომანდოს 450.
მე არ ვყიდი, რომ ერთი.
>> აბა, რომ ის, რაც ჩვენ გვინდა.
ეს არის commando 450.
>> -არ მჯერა მე.
ის გამოიყენება მხოლოდ ცირკის.
ეს სპილოები.
>> -I'll გადაიხადოს არაფერი.
>> რა ჯერი?
>> დააკავეს ვერ უმკლავდება, რომ.
ის დახვეწილი.
Oh yeah.
[END აღწარმოების]
დავით J Malan ყველა უფლება.
ეს არის ის, თუ CS50.
ჩვენ დავინახავთ, თქვენ მომავალ კვირას.
>> დინამიკები 1: [? Scully?] [? Ian,?] რამდენადაც ეს outro პროექტი,
რა თქვენ ბიჭები ამუშავება?
>> დინამიკები 2: ისე, ჩვენ მოცემული ის სხვადასხვა აზრის,
და ვფიქრობთ, რომ საუკეთესო გზა, რომელთა მიზანია:
>> დინამიკები 3: მაისი მე?
>> დინამიკები 2: ჰო.
ყველა საშუალებით, რეალურად.
>> დინამიკები 3: ვფიქრობ, ჩვენ შეგვიძლია შევაჯამოთ ჩვენი იდეა
იმ outros ერთი word-- არაფერი.
>> დავით J Malan: არაფერი?
დინამიკები 3: არაფერი.
დავით J Malan: რას ნიშნავს?
დინამიკები 3: outros დაახლოებით არაფერი.
დინამიკები 2: ისე, მე ვგულისხმობ, ფილოსოფიის, ვგულისხმობ, არაფერი არ არის ყოველთვის რაღაც.
დინამიკები 1: ასე what's-- რა არის შენობა?
დინამიკები 3: ასე რომ, როგორც ცხოვრებაში.
OK.
რა გავაკეთოთ დღეს?
>> დავით J Malan ავდექი, ჰქონდა საუზმე და მოვიდა მუშაობა.
>> დინამიკები 3: ეს outro.
დინამიკები 2: მაგრამ, მე ვგულისხმობ, არ უნდა რაღაც მოხდება მას the--
დინამიკები 3: არა, არა, არა, არა.
არაფერი ხდება.
>> დინამიკები 1: რატომ ვართ ჩვენ თვალს?
>> დინამიკები 3: იმის გამო, რომ ეს outro CS50.
>> დავით J Malan: ჯერ არ არის.