[Powered by Google Translate] დევიდ ჯ Malan: ყველა უფლება, ეს არის CS50 და ეს არის
დასასრულს კვირა 1, ისე სასწავლო ბარათები და საერთო რაოდენობის
თანაკლასელები, რომ თქვენ ეს წელი არის 745.
და ჩვენ ძალიან thrilled ჰქონდეს ბევრი თქვენ რა თქმა უნდა
ამ სემესტრში, მაგრამ მიუხედავად იმისა, რომ ეს კურსი არის იმდენად დიდი,
გააცნობიეროს, რომ ეს ყველაფერი მოსწონს პარასკევი lunches, როგორიცაა
სამუშაო საათებში, 15 კაციანი სექციები, და ა.შ. რომ
ნამდვილად ნიშნავდა, რომ შევქმნათ უფრო ინტიმური
გარემოს.
ასე რომ მიუხედავად იმისა, რომ ჩვენ შეიძლება შევიკრიბოთ ერთხელ ან ორჯერ კვირაში, აქ
Sanders, ვიცი, რომ ბევრი თქვენი გამოცდილება ამ კურსში
იქნება ძალიან ბევრი იყოს პრაქტიკული on ერთად თქვენი თანაკლასელები
და აკადემიური პერსონალის.
>> ასე რომ აქ ჩვენ გადასვლა, Fall 2012.
ასე რომ გავიხსენოთ, რომ ბოლო დროს ჩვენ დასრულდა ნოტა
ორაზროვნება, ვსაუბრობთ წარმომადგენლობა ნომრები.
და ჩვენ შევხედე ერთ ჩავარდნებს, რაც მოხდა, წელს
რეალურ ცხოვრებაში, როდესაც საქმე გაუგებრობა
როგორ კომპიუტერები მუშაობენ.
ისე, დღეს ჩვენ დავუბრუნდეთ კიდევ ერთი იმ იდეებს, როგორც
ასევე გავაგრძელებთ განხილვას CS50 კლიენტი
და C და რას ნიშნავს ნამდვილად პროგრამის.
მაგრამ პირველი, მხოლოდ რამდენიმე Whirlwind განცხადებები.
>> სექცია იწყება ამ კვირას და პირველ კვირას ყოველთვის
ცოტა სწრაფი დაწყება, რადგან ჩვენ უბრალოდ მიიღო წელს
თქვენი მონაკვეთზე ფორმები.
ვაკეთებთ იგივე, ახლა, როდესაც სწავლების პრაქტიკის, ახლა
მათ იცოდნენ, მათი გრაფიკების, ამიტომ ჩვენ, რომლის მიზანია, რომელსაც
შაბათს დილით, თვალყური თქვენთან ერთად თქვენი სექციაში
დავალება და TF.
გააცნობიერონ, რომ ისინი დავიწყებთ მეორე დღეს, კვირა
ან ორშაბათს ან სამშაბათს.
და შემდეგ ჩვენ განთავსდება მონაკვეთზე ცვლილებების რადგან ისინი წარმოიქმნება
წელს, ამ დღეებში.
ოფისი საათის იმავდროულად, არიან, კიდევ ერთხელ, ამაღამ, 8 საათზე, 11 წლის
Annenberg, ისევე როგორც ხვალ.
მიუხედავად იმისა, რომ პრობლემა კომპლექტი ზოგადად გამო ხუთშაბათს
შუადღისას, გააცნობიეროს გაქვთ ხუთამდე გვიან დღეების გასატარებლად,
აქედან გამომდინარე ხელმისაწვდომობის საათებში ხუთშაბათს, თუ
თქვენ ფულადი ერთ იმ გვიან დღე და ამით, წარუდგინოს
რაღაც პარასკევს.
ნება მომეცით ვარაუდობენ, რომ Scratch შორის არის სიამოვნება, შორის
უფრო დაბალი გასაღები პრობლემა კომპლექტი.
და მინდა გათიშეთ გადატანა იმ გვიან დღით, სტრატეგიულად, უბრალოდ
მოგვიანებით წელს სემესტრის როდესაც ცხოვრებაში იწყებს მიიღონ გზა
ერთად შუალედური და სხვა კლასებს.
პრობლემა Set 1, იმავდროულად, იქნება განთავსებული კურსის
ნახვა ამ პარასკევს, როგორც იქნება, რა თქმა უნდა სავალზე
მეშვეობით ვიდეო, რომელიც იქნება გადაღებული საათზე 2:30 PM პარასკევს
და შემდეგ posted ონლაინ მეორე დღეს.
>> ამიტომ, ჩვენ დასრულდა ორშაბათს.
მინდა - ფაქტობრივად, ერთი აღვნიშნო აქ.
იმის გამო, რომ კლასების - რადგან Sanders არ ზუსტად lend
თავს შემთხვევით Q & უკან და მეოთხე საშინლად კარგად, ჩვენ
აპირებს ძიებასა ცოტა ახალი წელს, რომლის დროსაც
თუ თქვენ არ კომფორტული ამაღლების თქვენი ხელი ან უბრალოდ
უმჯობესია არ დააყენოს თქვენი ხელით ოთახი მოსწონს,
ჩვენ ვაპირებთ აქვს ზოგიერთი სწავლების პრაქტიკის და CAS
საშტატო cs50.net/discuss დროს ლექციას.
ასე რომ, თუ თქვენ გაქვთ კითხვა, რადგან მე ვიყავი სრულიად
გაურკვეველია შესახებ რამე ან თქვენ ცნობისმოყვარე შესახებ რამდენიმე
თემის, ვცდილობთ განთავსებით მას იქ.
საკვანძო იგი იარლიყი ლექცია, და ჩვენ გავაკეთებთ
დღეს და მომავალ კვირას - we'll ცდილობენ ამ გარეთ - მდე გამოჰყავთ ეს
ან ელექტრონულად, შემოსული, ან თუ იგი იგრძნობა უნდა
მართლაც მიმართოს იგი მასობრივად, ერთ სწავლების პრაქტიკის ან
CAS დააყენებს მათი ხელი და ვთხოვოთ
ანონიმურად თქვენი სახელით.
ამიტომ, ჩვენ მივცემ ამ ცდილობენ და ვხედავთ, თუ რამდენად კარგად ეს სამუშაოები.
მაგრამ, ყველა საშუალებით, განვაგრძობთ ხელში როგორც გსურთ.
>> ასე რომ ბოლო დროს ჩვენ გამოვლინდა, რომ 10% ან ერთი მეათედი არ არის, in
ფაქტობრივად, 0.1, თქვენნაირი ასწავლიდნენ მრავალი წლის წინ.
ეს ფაქტობრივად, ღირებულება მოსწონს ეს.
მაგრამ ეს არ არის მთლიანად ჭეშმარიტი, არა?
ჩვენ უბრალოდ უნდა ამ შეზღუდვით in კომპიუტერები რის, თუ
მხოლოდ აქვს სასრული რაოდენობით მეხსიერება, RAM, ან მეტი
კონკრეტულად ბიტი, ასევე, არსებობს მხოლოდ სასრულ ნომერი
რამ შეგიძლიათ წარმოადგენენ.
მაგალითად, თუ გვაქვს ხმების ნულოვანი, და გვინდა
წარმოადგენენ ორობითი გამოყენებით რვა ბიტი, სადაც ცოტა,
ერთხელ, არის ნულოვანი ან ერთი, ჩვენ შეიძლება
წარმოადგენს მას როგორც 00000000.
და ეს პატარა ზედმეტად verbose.
ისევე, როგორც ათობითი სისტემის რეალურ ცხოვრებაში,
ზოგადად, თუ გსურთ დაწეროთ ნომერი 123, ჩვენ
ადამიანები ალბათ არ წერენ 00000123 მიუხედავად იმისა,
ფუნქციურად, რომ ზუსტად იგივე ნომერი.
ჩვენ მხოლოდ ვარდნა წამყვანი zeros, ასე ვთქვათ.
>> In ორობითი, ჩვენ შეგვიძლია გავაკეთოთ იგივე.
ორობითი და ნულოვანი, ნულოვანი და ბინარული მხოლოდ ნულოვანი.
თქვენ მხოლოდ გჭირდებათ ერთი bit.
მაგრამ ერთხელ, ყველაზე გავრცელებული ერთეული ზომის მსოფლიოში
გამოთვლითი არის ბაიტი, რვა ბიტი.
მხოლოდ იმიტომ, რომ ერთი bit, საკმაოდ უსარგებლო.
რვა ბიტი, არ საშინლად სასარგებლო, მაგრამ მაინც ეს უფრო
სასარგებლო ვიდრე ერთი ერთეული ზომის.
ასე რვა ბიტი, ჩვენ, როგორც წესი, წარმოადგენენ ორობითი.
ასე რომ აქ გვაქვს ნომრები ნულოვანი, ერთი, ორი, შემდეგ კი, როგორც
Nate გააკეთა ჩვენი ვიდეო ბოლო ოთხშაბათს, ჩვენ შეგვიძლია გავაგრძელოთ
დათვლის მდე შვიდი, რვა.
ხოლო შემდეგ, თუ ჩვენ ვიყენებთ უფრო და უფრო ბიტი, ჩვენ
შეგიძლიათ ითვლიან მდე Infinity.
მაგრამ თუ თქვენ მხოლოდ სასრულ რიგი ამ ბიტი, როგორც არის
შემთხვევაში ნებისმიერ კომპიუტერულ სისტემაში, ან თუნდაც სარაკეტო
სისტემა, ისევე, მართლაც თქვენ მხოლოდ
სასრულ თანხის სიზუსტით.
ასე რომ, თუ გსურთ წარმოადგენს რაოდენობა, როგორიცაა 0.1, ისევე,
კომპიუტერი უნდა აირჩიოთ და აირჩიეთ.
და თუ ეს მხოლოდ სასრულ რაოდენობის ნომრები შეიძლება
წარმოადგენს, მას შეუძლია მოვიდეს ახლოს 0.1 თქვენთვის, მაგრამ მას არ შეუძლია
აუცილებლად მოგცემთ ზუსტად ღირებულება, რომელიც გსურთ.
და ეს არის მხოლოდ ერთი გამოწვევები კომპიუტერები,
ქვევმოთ hood, საბედნიეროდ.
>> როგორც ჩვენ გადაადგილება შემდგომი წელს სემესტრის ამ ქვედა დონის
დეტალები გაცილებით ნაკლებად საინტერესო, მაგრამ, რა თქმა უნდა
განაცხადის ამ იდეებით შეუძლიათ რამდენიმე ძალიან რეალური სამყაროს
ramifications.
ერთი არის ცოტა გართობა.
როგორ ბევრ თქვენგანს არ უნახავს საოცარი ფილმი საოფისე ფართი?
თუ თქვენ არა გაქვთ, რომ თქვენი არაოფიციალური
საშინაო დავალებების შესასრულებლად კვირაში.
მაგრამ საოფისე ფართი, სტიპენდიანტები, რომ ფილმის მიიღოს
უპირატესობა სწორედ ამ იდეას, მაგრამ ისინი ფაქტობრივად მოიპარეს
იგი მეორე ფილმი, რომ თქვენ ალბათ
ჩანს, თუნდაც წლით ადრე.
ნება მომეცით, გადმოგცეთ რამდენიმე წამში ამ trailer საწყისი
ამ საოცარი ფილმი და ეს არის ძალიან
აკადემიური შესაბამისი.
>> [ნათამაშები MOVIE]
სინამდვილეში მე მიმდინარეობს დააწინაურეს.
მე შემიძლია პროგრამა ვირუსი, რომელიც დააკოპიროთ რომ
განათავსეთ off დიდი დრო.
ისე, როგორ მუშაობს იგი?
ყოველ ჯერზე იქ ბანკის გარიგება, სადაც ინტერესი არის
კომპიუტერული, არის ათასობით დღეში, კომპიუტერულ მთავრდება
ამ ფრაქციების შეადგინა.
მაგრამ მე არ ვაპირებ არაფრის უკანონოა.
უკანონო? Samir, ეს არის ამერიკა.
თქვენ უნდა ფიცს ღმერთს.
თუ არავინ იცის ამის შესახებ, მაგრამ ჩვენ, ყველა უფლება? არარის ოჯახის წევრები, არ
მეგობარ, არავინ.
[INAUDIBLE].
არ ინერვიულოთ, ეს კაცი, მე არ გეტყვით არავის ჰქონია.
[ფილმის დამთავრდა]
>> ყველა უფლება და იქნებ მე ამ ფილმის უკეთ, ვიდრე ყველაზე
ხალხი აქ, მაგრამ ნებისმიერ შემთხვევაში, ვირუსის, რომ ისინი
ცდილობს შექმნას -
და ფილმები, ნებისმიერ დროს მათ მინდა მოვუწოდო რაღაც ვირუსი,
ეს ზოგადად არ რეალურად ვირუსი.
უბრალოდ პროგრამა, რომელიც ვინმე წერს, რომ რამე.
და ამ შემთხვევაში, ბიჭები ცდილობდნენ წერენ პროგრამა
რომ ისარგებლეს მათი კომპანია მოუწოდა Innotech ს
Computing სისტემა, რომლის დროსაც კომპიუტერები, ძალიან, მაშინაც კი, როდესაც ეს
მოდის ფული, ვერ აუცილებლად
წარმოადგენს ფული ზუსტად.
ასე რომ, მიუხედავად იმისა, თქვენ ალბათ $ 0.10 თქვენს საბანკო ანგარიშზე,
0.10, ისევე, კომპიუტერი შეიძლება რეალურად ვფიქრობ, რომ თქვენ გაქვთ
ამ ბევრი ცენტი თქვენს საბანკო ანგარიშზე.
და მერე რა ეს ბიჭები იყვნენ მიისწრაფვიან გააკეთოს - და ისინი
მოიპარეს იდეა, თურმე საწყისი Superman III, სადაც
რიჩარდ PRYOR გააკეთა იგივე - ისინი არსებითად
წერილობით პროგრამებს, ისწრაფვიან მიიღონ ყველა გადმოკიდული
ნომრები, ყველა პატარა, პატარა, პატარა ფრაქციების
pennies და siphoning იმ off ისე, რომ ადამიანები მხოლოდ
აზრის, oh, ეს მხოლოდ $ 0.10 იქ, მაგრამ ყველა იმ
გადმოკიდული ციფრები საბოლოოდ დაამატოთ მდე.
ასე რომ მშვენიერი იდეა და იგი backfired hilariously ამ
კერძოდ ფილმი.
>> მაგრამ რეალურ ცხოვრებაში, ძალიან, არის ბევრად უფრო დაკავშირებით
გამოძახილი ამ სახის ნივთები.
და ერთი მიზეზი ჩაყვინთვის შევიდა სფეროში კომპიუტერი
მეცნიერების, კიდევ ერთხელ, მისი გამოყენებადობა არ
საინჟინრო მეცნიერებათა მარტო, მაგრამ მხოლოდ
სხვა სფეროებში, ასევე.
ასე რომ, ეს ნაკლებად lighthearted შევხედოთ რა შეიძლება არასწორი, მაგრამ
ეს საკმაოდ თვალის გახსნის, ვფიქრობ, როდესაც საქმე
გაგება ზუსტად როგორ omnipresent ტექნოლოგიების მოსწონს
კომპიუტერები და პროგრამირების ან ამ დღეებში,
სახით პროგრამული უზრუნველყოფა.
ასე რომ, ეს მორიგი კლიპი არის მხოლოდ ექვსი წუთი, აგრძელებს
სადაც ჩვენ შეჩერდით ბოლო დროს, მაგრამ საშუალებას გვაძლევს თვალი პატარა
უფრო სიღრმისეული ერთ ასეთ ამ საკითხებზე.
ნება მომეცით გამოტოვოთ მანამდე სადაც ჩვენ შეჩერდით,
რაც სწორი იყო აქ.
და ჩვენ გვაქვს ორი ნაწილი, ორი, დაახლოებით ექვსი წუთის აქ.
>> [PLAY MOVIE]
ხშირია თანამედროვე სარაკეტო ტექნიკა.
1991 წელს ერთად დაწყების პირველი ყურის ომი, პატრიოტი
სარაკეტო გამოცდილი მსგავსი
პუნქტების კონვერტაციის პრობლემა.
ამის შედეგად, 20 ადამიანი, 20 ამერიკელი ჯარისკაცი დაიღუპა
და დაახლოებით 100 დაიჭრა, როდესაც პატრიოტთა, რომელიც სავარაუდოდ
რომ დაიცვას წინააღმდეგ შემომავალი Scuds,
ვერ შეძლო ცეცხლი სარაკეტო.
>> როდესაც ერაყში შეიჭრა ქუვეითსა და ამერიკაში დაიწყო Desert
Storm დასაწყისში 1991, პატრიოტის სარაკეტო ბატარეები იყო
განლაგდნენ დასაცავად საუდის არაბეთი და ისრაელს ერაყის
Scud სარაკეტო თავდასხმებს.
პატრიოტის არის აშშ საშუალო დამიზნების ზედაპირზე-to-air სისტემა,
მიერ წარმოებული RAYTHEON კომპანია.
ზომა პატრიოტის interceptor თავად, ეს დაახლოებით
დაახლოებით 20 ფუტი სიგრძის და იგი იწონის დაახლოებით 2,000 ფუნტი.
და იგი ახორციელებს ქობინით დაახლოებით - ვფიქრობ, უხეშად
150 ფუნტი.
და ქობინით თავისთავად მაღალი ასაფეთქებელი, რომელსაც აქვს
ფრაგმენტები გარშემო.
გარსაცმები of ქობინით განკუთვნილია იმოქმედოს მოსწონს buckshot.
რაკეტები ხორციელდება ოთხი შეადგენს კონტეინერ და არიან
ტრანსპორტირება ნახევრად trailer.
>> პატრიოტის რაკეტსაწინააღმდეგო სისტემის მიდის უკან მაინც
20 წელია.
თავდაპირველად დაპროექტებული როგორც საჰაერო თავდაცვის სარაკეტო to
ჩამოაგდებენ მტრის თვითმფრინავები, პირველ ყურის ომი.
როდესაც რომ ომი მოვიდა გასწვრივ, არმიის სურდა გამოვიყენოთ რომ სროლა
ქვემოთ Scuds, არ თვითმფრინავები.
საჰაერო ძალების ერაყის არ იყო იმდენად, რამდენადაც პრობლემაა, მაგრამ არმიის
იყო აწუხებს Scuds.
ამდენად, მათ შეეცადა განახლება პატრიოტია.
Intercepting მტრის სარაკეტო მოგზაურობა საათზე MACH 5 ხდებოდა
უნდა იწვევს საკმარისი.
მაგრამ როდესაც პატრიოტთა იყო შევარდა სამსახურის, არმიის
არ იყო საქმის კურსში ერაყის მოდიფიკაცია რომ გააკეთეს
Scuds თითქმის შეუძლებელია მოხვდა.
>> რა მოხდა არის Scuds რომ იყო
შემოდიოდნენ იყო არასტაბილური.
ისინი wobbling.
მიზეზი ის იყო ერაყელებს, რათა მიიღოთ 600
კილომეტრის გარეთ 300 კილომეტრიანი Range სარაკეტო, აიღო
წონა გარეთ წინა ქობინით და
გააკეთა ქობინით მსუბუქია.
ახლა პატრიოტთა ცდილობს მოდის at Scud, ყველაზე მეტად
ახლა, აბსოლუტური უმრავლესობის დრო, ეს იქნებოდა
უბრალოდ ფრენა მიერ Scud.
ერთხელ პატრიოტის სისტემის ოპერატორები მიხვდა პატრიოტის
გაშვებული მისი სამიზნე, მათ ქვეითსაწინაააღმდეგო პატრიოტის ქობინით.
, რათა თავიდან ავიცილოთ შესაძლო მსხვერპლი, მას ეძლეოდა
ჩავარდნას, რათა ადგილზე.
ეს იყო ის, რაც ხალხის უმრავლესობას დაინახა, როგორც დიდი fireballs ცაში,
და არასწორად როგორც საუბრების of Scud ქობინი.
>> თუმცა, ღამის ცა, პატრიოტთა აღმოჩნდა
წარმატებით გაანადგურა Scuds საათზე Dhahran, იქ შეიძლება არ
შეცდომის შესახებ მისი შესრულება.
არსებობს, პატრიოტთა სარადარო სისტემის დაკარგა კვალს
შემომავალი Scud და არასოდეს დაიწყო გამო
to პროგრამული უზრუნველყოფის ხარვეზი.
ეს იყო ისრაელის, რომელმაც პირველად აღმოაჩინა, რომ აღარ
სისტემა იყო, უფრო დიდი დრო შეუსაბამობა გახდა,
გამო საათის ჩართული სისტემის კომპიუტერში.
დაახლოებით ორი კვირით ადრე ტრაგედიას Dhahran,
ისრაელის განუცხადა თავდაცვის დეპარტამენტის, რომ
სისტემის დაკარგვის დროს.
შემდეგ დაახლოებით რვა საათის გაშვებული, მათ შენიშნეს, რომ
სისტემაში ხდებოდა შესამჩნევად ნაკლები სიზუსტით.
თავდაცვის დეპარტამენტის გამოეხმაურა ვეუბნებოდი ყველა
პატრიოტის ბატარეები რომ არ დატოვებს სისტემები
on დიდი ხნის განმავლობაში.
ისინი არ ამბობს, რა დიდი დრო იყო - 8 საათი, 10
საათები, 1,000 საათი.
არავინ იცის.
>> პატრიოტის ბატარეის განლაგებული დროს ყაზარმებში საათზე Dhahran
და მისი ყალბი შიდა საათის იყო დაახლოებით 100 საათი
ღამეს 25 თებერვალს.
იგი tracked დრო და სიზუსტე დაახლოებით მეათედი მეორე.
ახლა მეათე მეორე არის საინტერესო ხმების რადგან
არ შეიძლება გამოთქმული ორობითი, ზუსტად, რაც იმას ნიშნავს,
მას არ შეუძლია იყოს გამოხატული ზუსტად ნებისმიერ
თანამედროვე ციფრული კომპიუტერი.
ძნელი დასაჯერებელია.
მაგრამ გამოიყენოს ეს როგორც მაგალითად.
>> ავიღოთ ნომერ მესამე.
ერთი მესამედი არ შეიძლება გამოიხატოს ათობითი ზუსტად.
ერთი მესამედი არის 0,333 გრძელდება უსასრულობამდე.
არ არსებობს გზა ამის, რომ აბსოლუტური სიზუსტით წელს ათობითი.
სწორედ მსგავსი პრობლემა, რომ მოხდა
პატრიოტია.
აღარ სისტემა გაიქცა, უარესი დრო შეცდომა გახდა.
შემდეგ 100 სამუშაო საათები, შეცდომა იყო მხოლოდ
დაახლოებით ერთი მესამედი მეორე.
მაგრამ თვალსაზრისით სამიზნედ სარაკეტო მოგზაურობა საათზე MACH 5,
მას შედეგად თვალთვალის შეცდომა მეტი 600 მეტრია.
ეს იქნება ფატალური შეცდომა ამისთვის ჯარისკაცებთან Dhahran.
>> რა მოხდა არის Scud დაწყებას გამოვლინდა მიერ ადრეული გაფრთხილების
თანამგზავრების და მათ იცოდნენ, რომ Scud მოდიოდა მათი
ზოგადად მიმართულებით.
არ იცოდნენ, სადაც იგი მოდიოდა.
ეს იყო ახლა მდე სარადარო კომპონენტი პატრიოტის
სისტემის დაცვითი Dhahran, განთავსების და ტრეკზე
შემომავალი მტრის რაკეტა.
რადარზე ძალიან ჭკვიანი.
თქვენ რეალურად აკონტროლოთ პოზიცია Scud და შემდეგ
პროგნოზირება, სადაც ეს ალბათ იქნება შემდეგი დრო
სარადარო გაგზავნილი პულსი გარეთ.
რომ ერქვა Range კარიბჭე.
მაშინ, ერთხელ პატრიოტის გადაწყვეტს საკმარისი დრო გავიდა წასვლა
უკან და შეამოწმოთ შემდეგი საიდან ამ გამოვლინდა
ობიექტი, იგი მიდის უკან.
ასე რომ, როდესაც იგი დაბრუნდა არასწორი ადგილი, მაშინ ვერ ხედავს
ობიექტი, და ეს გადაწყვეტს, რომ არ იყო წინააღმდეგი.
ეს იყო ყალბი აღმოჩენისა და წვეთების სიმღერა.
>> შემომავალი Scud გაქრა სარადარო ეკრანზე.
და წამის შემდეგ, ის გააკრიტიკა შევიდა ყაზარმები. Scud
დაიღუპა 28 და იყო ბოლო ერთი გასროლა დროს
პირველი ყურის ომი.
ტრაგიკულია, რომ განახლებული პროგრამული მივიდა Dhahran
მომდევნო დღეს.
და პროგრამული უზრუნველყოფის ხარვეზი უკვე დაფიქსირდა, იხურება ერთი თავი
პრობლემური ისტორიაში პატრიოტის სარაკეტო.
PATRIOT ფაქტიურად აბრევიატურა for "ეტაპობრივი Array Tracking
Intercept სამიზნე. "
>> ყველა უფლება, ასე რომ ბევრად უფრო სავალალო შედეგს არ საკმაოდ
გაგება ამ სამყაროში.
და takeaway, მართლაც, საწყისი ფილმი არის, რომ გამოსავალი
იქ იყო გადატვირთეთ თქვენი რაკეტსაწინააღმდეგო თავდაცვის სისტემის
ყოველ ერთხელ ხოლო.
და ა.შ. ერთხელ, ერთ მიზანს ამ კურსის, რა თქმა უნდა
უფრო მოკრძალებული მასშტაბის, ვიდრე ეს განცხადებები, არის
მართლაც ღია ყველას თვალში ზუსტად როგორ მიდიხარ შესახებ
საცხობი დანადგარები რა გსურთ მათ ამის გაკეთება და როგორ დადიან
შესახებ აკეთებს, რომ სწორად, ხოლო გზაზე აკეთებს ამას
კარგად, ელეგანტურად და სხვ.
და დღეს, მოდით ჩაყვინთვის შევიდა ცოტა მეტი, მაგრამ
ასე, რომ ჩვენ არ წავიდეთ ძალიან სწრაფად, განსაკუთრებით იმ ნაკლებად
კომფორტული, არამედ ისე, რომ ჩვენ შეგვიძლია შეინარჩუნებს ინტერესს
იმ უფრო კომფორტული, მოდით უბრალოდ სწრაფად დაიწყოს bit
საქართველოს recap ზოგიერთი ამ იდეებს.
ისევ და ისევ, ვთხოვ მოშორებით, როგორც ადამიანი ან შემოსული, თუ თქვენ გაქვთ
კითხვები ასე შეგვიძლია შევინარჩუნოთ ყველას იმავე გვერდზე.
>> ამიტომ CS50 ელექტრო მოწყობილობების, სწრაფი ნაბიჯი უკან, არის
რა, თქვენი სიტყვებით?
ეს OK, თუ თქვენ არ ვიცი რა ეს სიტყვები შეიძლება იყოს ამჟამად.
[INAUDIBLE]
Okay, ასე საყოველთაო ინტერფეისით -
რომ ჩვენ შეგვიძლია ყველა ვიზიარებთ.
აბსოლუტურად.
ამიტომ ვერ მაგალითად, გითხრათ, წასვლა რაღაც
ნახვა გადმოწერეთ ეს პროგრამული უზრუნველყოფა for Mac OS.
ჩამოტვირთეთ ეს პროგრამული უზრუნველყოფა: Windows, კონფიგურაცია წელს
ამ გზით და რომ.
მაგრამ რეალობა მაშინ ჩვენ გადაეყარონ უამრავი ტექნიკური
მხარდასაჭერად საკითხები.
და ასევე ამ დღეებში, ბევრი რამ თუ რა კეთდება სერვერის მხარეს,
მსოფლიოში გამოთვლითი, განსაკუთრებით, როდესაც საქმე
ვებ უზრუნველყოფა და ვებ დაფუძნებული განაცხადების, ფაქტიურად
ხშირად კეთდება Unix ან Linux კომპიუტერები, როგორც ეწინააღმდეგებოდა
Macs ან Windows pcs.
>> ამიტომ შორის upsides, მაშინ, გამოყენების ამ რამ მოუწოდა
CS50 ელექტრო მოწყობილობების არის ჩვენ ყველას გვაქვს ერთი და იმავე გარემოში.
ასე რომ ყველას იმავე გვერდზე არ აქვს მნიშვნელობა რა აპარატურა თქვენ
მოვიდა კამპუსში ერთად არამედ იქნება dabbling ზუსტად
იგივე გარემო, რომელიც თქვენ გამოიყენებთ მიმართ
სემესტრის ბოლოს, ასევე ვებ განვითარება, ისევე როგორც
მომავალი რეალური სამყაროს განაცხადების შესახებ.
ამიტომ უფრო კონკრეტულად, CS50 ელექტრო მოწყობილობების არის უფასო ნიმუში
პროგრამული უზრუნველყოფის, რომელიც საშუალებას გაძლევთ აწარმოებს კიდევ ერთი ოპერაციული სისტემა,
Linux, ამ შემთხვევაში, საკუთარ კომპიუტერში, წელს ფანჯარაში.
ახლა თქვენ შეგიძლიათ არა მხოლოდ ჩამოტვირთოთ ელექტრო მოწყობილობების.
თქვენ გჭირდებათ პროგრამა, რომელიც უნდა ითამაშოს ან აწარმოებს ელექტრო მოწყობილობების.
და რომ ნაჭერი პროგრამული უზრუნველყოფა არის ზოგადად ცნობილი როგორც
hypervisor.
Hypervisors მოდის სახით პროდუქტები, როგორიცაა VMware,
ვირტუალური ყუთი, პარალელები.
ყველა სახის კომპანიების მიიღოს პროგრამული უზრუნველყოფა, როგორც თავისუფალი და
კომერციული, alike.
რა დაინახავთ პრობლემების Set 1 are ინსტრუქციებით თუ როგორ უნდა
მიიღოს უფასო კომპიუტერული პროგრამა რომელიც
აწარმოებს CS50 ელექტრო მოწყობილობების.
და კიდევ თუ თქვენ ჩვენგან, თქვენ, ამ ფანჯარაში თქვენს Mac ან PC,
დესკტოპის გარემოში, რომელიც გამოიყურება საკმაოდ მოსწონს, სადაც
მას დაწყება მენიუ მსგავსი რამ
ქვედა მარცხენა კუთხეში.
მას აქვს მთავარი ფოლდერი, ან მთავარი დირექტორია, ზედა მარცხენა
იქ, ნაგვის შეუძლია, და სხვ.
ამიტომ ჩვენ აჯავრებენ გარდა საჭირო დეტალები, როგორც ჩვენ წავიდეთ.
>> მაგრამ ახლა მოდით დავიწყოთ ჩაყვინთვის შევიდა C.
ასე რომ C არის ამ პროგრამირების ენა, იგივე სულისკვეთებით, რათა
Scratch, მაგრამ ნაკლებად გრაფიკული, თუმცა ირონიულად, შორს
უფრო ძლიერი ერთხელ თქვენ საზრიანი იგი.
ასე რომ, C, ჩვენ წერენ პროგრამებს წერილობით წყაროს კოდი, რომელიც
ამ ინგლისურ მსგავსი სინტაქსი, მსგავსი წინდები
დემონსტრირება, რომ ჩვენ ბოლო დროს, რომელიც საშუალებას გაძლევთ
გამოხატოს თავის საკმაოდ ზუსტად, თუ
arcanely, კომპიუტერს.
>> ასე რომ, თუ რა სახის პროდუქტის პროგრამული გაქვთ რეალურად სჭირდება
დაწერა პროგრამების ენა მოსწონს C, ეფუძნება ჩვენი
საუბარი ორშაბათს?
[INAUDIBLE]
OK, თქვენ უბრალოდ უნდა ტექსტური რედაქტორი.
თქვენ არ გჭირდებათ რაიმე სპეციალური პროგრამული
თავისთავად დაწერა პროგრამები.
თქვენ უბრალოდ უნდა ტექსტური რედაქტორი, როგორიცაა ჩასაწერი, on Windows,
TextEdit on Mac, ან რაღაც მოუწოდა gedit, სამყაროში
Linux, რომელიც ჩვენ აქ გამოიყენოს.
და ამით ყველაფერი, დაწერა პროგრამები.
>> მაგრამ წერილობით მხოლოდ ნახევარი განტოლება.
თქვენ მაშინ უნდა აწარმოებს მათ.
მაგრამ იმისათვის, რომ პროგრამების გასაშვებად -
შეგიძლიათ არ აწარმოებს კოდის.
თქვენს ნაცვლად უნდა გავაკეთოთ, რა უნდა ის პირველი?
Yeah.
დევიდ ჯ Malan: თქვენ უნდა
კომპილირება.
და, ვინმეს, შედგენის კოდის ნიშნავს -
[INAUDIBLE]
დევიდ ჯ Malan: ზუსტად.
თარგმნა მას zeros და პირობა.
რადგან ყველა ჩვენგანი, ამ დღეებში, კომპიუტერები აქვთ, რომ აქვს პროცესორები,
თითქმის ყველა მათგანი დამზადებული კომპანია მოუწოდა Intel, და
Intel Inside, ნიშნავს არსებობს ამ ტვინის შიგნით თქვენი
კომპიუტერი, რომელიც ცნობილია როგორც CPU.
და ერთი რამ, რომ თავის ტვინზე არის, იგი დარწმუნებულია
როგორ ესმით ნიმუში zeros და პირობა.
ეს იცის, რა ნიმუში ბიტი წარმოადგენს ამისა, რა
ნიმუში წარმოადგენს subtractions, რა ნიმუში
ბიტი წარმოადგენენ ბეჭდვა, და შექმნის Audible sound.
>> ასე მოკლედ, CPU, coupled ოპერაციული სისტემა,
რაც ნაჭერი პროგრამული უზრუნველყოფა, რომელიც ეშვება ზევით CPU,
ასე ვთქვათ.
ერთად, ეს ორი ცალი ვიცი როგორ პროგრამების გასაშვებად, რომ
ჩვენ ადამიანები წერენ.
>> ასე რომ, თუ მე წასვლას CS50 ელექტრო აქ, მე უნდა გახსნა
მდე ტექსტური რედაქტორი და შემიძლია გავქთ ამ
რამდენიმე გზა არსებობს.
შემიძლია არც წასვლა მენიუ, პროგრამირება,
და მაშინ შემიძლია აირჩიეთ -
nope, არ, რომ მენიუში.
შემიძლია წასვლა აქსესუარები / gedit აქ გახსნა
ჩემი პატარა ტექსტური რედაქტორი.
ან მეტი უბრალოდ, შემიძლია დააჭირეთ ამ პატარა ხატი ქვედა
მარცხენა კუთხეში.
და ახლა ამ გარემოში აქ.
ეს საკმაოდ თქვენში მარტივი ტექსტური რედაქტორი, სადაც მხოლოდ
ერთი ან ორი განსხვავებები.
ზედა, სადაც კურსორი არის მოციმციმე არის, ეს არის, სადაც
მე შემიძლია წერა ჩემი კოდი.
ქვედა არის ეს საგანი მოუწოდა ტერმინალის ფანჯარაში.
და რა სახის რამ გავაკეთო ამ
ე.წ. ტერმინალის ფანჯარაში?
[INAUDIBLE]
>> Okay, ასე მე აწარმოებს ბრძანებები.
და ზოგიერთი ბრძანებები ჩვენ გაიქცა ორშაბათს იყო პატარა
cryptic თავდაპირველად, მაგრამ ამისთვის ls სია, CD ცვლილების დირექტორია,
rm, ამისთვის ამოიღონ.
ასე რომ ერთგვარი ძველი სკოლის გზა ნავიგაცია თქვენი
კომპიუტერის გამოყენებით მხოლოდ თქვენს კლავიატურაზე და ტექსტობრივი ბრძანებები,
და არა, ზოგადად, გამოყენებით მაუსის.
მაგრამ ჩვენ დავინახავთ, სანამ ხანგრძლივი, ამ რეალურად გვაძლევს
ცოტა მეტი ძალა და ცოტა უფრო მეტი სიზუსტით, რომლითაც
გამოხატოს საკუთარ თავს.
და მაშინ მეტი აქ მარცხენა, ჩვენ უბრალოდ აპირებს ვხედავ,
როგორც ჩვენ ვიწყებთ წერა პროგრამული უზრუნველყოფა, პატარა რეზიუმე
პროგრამა, რომელიც ჩვენ იწერება ზედა მარცხენა.
მაგრამ ჩვენ ვხედავთ, რომ ერთხელ, სანამ ხანგრძლივი.
>> მოდით რაღაც საკმაოდ მარტივია აქ.
ნება მომეცით პირველი წავიდეთ წინ, გადადით ფაილი, შენახვა, და მე უბრალოდ
აპირებს დააწკაპუნეთ jharvard აქ, ზე მარცხნივ, და
jharvard არის, კიდევ ერთხელ, სახელი ჩემი მთავარი ფოლდერი, ჩემი
პირადი საქმეები, ჩემთვის, ამჟამად მიმდინარეობს ჯონ ჰარვარდის, როგორც ყველა თქვენგანს
მალე ჯონ ჰარვარდის ამ გარემოში.
ის მოხდა ეს მთავარი დირექტორია, ჩემი დოკუმენტები და ა.შ.,
რომ მინდა შენახვა, ახლა, ამ ფაილის სისტემაში
ამიტომ, მე ვაპირებ მოვუწოდო მას hello.c. მაშინ მე ვაპირებ წასვლა
ადრე და დააჭირეთ Save და ახლა რა მაქვს აქ tab
მოუწოდა hello.c, იმდენად მოსწონს სხვა ტიპის რედაქტორი.
>> ახლა ნება მომეცით წავიდეთ წინ და დაიწყოს პროგრამის წერა.
int ძირითადი (void).
და მერე უბრალოდ გააკეთა ბოლო დროს, printf, ბეჭდური დაფორმატებას,
("Hello, World!"
);.
თითქმის.
მაგრამ მე დაკარგული რამდენიმე დეტალი.
რა აკლია ამ პროგრამის, რომ მე ნამდვილად საჭიროა
მას რეალურად ადგენენ?
Yeah.
[INAUDIBLE]?
>> დევიდ ჯ Malan: ჰო, მე უნდა შეიცავდეს სტანდარტული
I / O ბიბლიოთეკაში.
ასე რომ ეს უნდა წავიდეს ზემოთ ძირითადი, ისე მე უბრალოდ აპირებს
გარკვეული ოთახი ამისთვის არსებობს.
და მე ვაპირებ ამის გაკეთებას # მოიცავს .
და შეამჩნია დახრილი ფრჩხილები არსებობს.
და როგორც განზე, gedit არის პატარა მოსახერხებელი, თუ
ხანდახან ცოტა დამაბნეველი, რომ ის ცდილობს დაეხმაროს თქვენი
თვალების შეამჩნია რა ხაზები ერთად რა.
ასე რომ ის ფაქტი, რომ ჩემი კურსორი არის სწორი შემდეგი ამ დახრილი
bracket, შეამჩნევთ, თუ როგორ იგი ხაზს უსვამს სხვა დახრილი
bracket პლუს ერთი.
და ეს მხოლოდ გავამახვილო ჩემი ყურადღება იმაზე, რომ მე
აქვს სიმეტრია.
და სიმეტრია პროგრამირებაში ზოგადად კარგია.
ანალოგიურად, თუ გადავა ჩემი კურსორი ბოლომდე, შეამჩნევთ, თუ როგორ
Curly braces გამოდიან იმის ჩვენება, რომ, დიახ, მე მაქვს ღია ერთი
და დახურული ერთი, ასე ვთქვათ.
>> ყველა უფლება და შემიძლია ერთი რამ სხვა.
ეს არ არის მკაცრად აუცილებელი, მაგრამ კარგი პრაქტიკა, ვთქვა
დაბრუნებას 0.
და დაბრუნების 0 აკეთებს იმას ჩვენთვის აქ?
ან ნიშნავს, რა?
[INAUDIBLE]
დევიდ ჯ Malan: არაფერი არასწორი.
და გულწრფელად ძნელია დიდი წასვლა შეცდომა
პროგრამის მოკლე.
ასე რომ მე უბრალოდ მყოფი super სიცოცხლისუნარიანობა, რომ ყველა კარგად არის.
მე, ადამიანური, როცა აწარმოებს ამ პროგრამის ალბათ არასოდეს
ვხედავთ, რომ 0.
საერთოდ, ამ ნომრებზე, რომლებიც დაბრუნდნენ მთავარი
მხოლოდ უკანა მათი მიემართება ადამიანები, როდესაც
რაღაც მიდის არასწორი.
და თქვენ მიიღებთ პატარა pop up ამბობდა სისტემის შეცდომა, ერთი,
ორი, სამი, ან რასაც ნომერი რომ
სინამდვილეში დაბრუნდა.
ასე რომ არაფერი ცუდი ეს?
[INAUDIBLE]
>> დევიდ ჯ Malan: ასე რომ, ეს არ არის იმდენად ფუნქციური შეცდომა
მაგრამ ესთეტიკური ერთი.
მე, ალბათ დასვა სტრიქონების გადატანით ხასიათი იქ
ბოლოს ამ სტრიქონს ისე, რომ ჩვენ რეალურად გადაიტანოთ კურსორი
შემდეგი ხაზი, და პროგრამა უბრალოდ გამოიყურება პატარა გალამაზებაში.
>> ახლა ნება მომეცით დაცემას ჩემს ტერმინალის ფანჯარაში
და მასშტაბის უკან შემოსული
და ეს საგანი აქ, ეს ე.წ. ზოლზე.
უბრალოდ ახსენებს, ვინ ვარ, jharvard @ ელექტრო მოწყობილობების, სადაც
ელექტრო მოწყობილობების არის სახელი კომპიუტერის ვარ მე.
ფრჩხილებში არის ამ tilde, squiggle სიმბოლო, რომელიც
წარმოადგენს რა?
აუდიტორია: მთავარი დირექტორია.
დევიდ ჯ Malan: მთავარი დირექტორია.
ასე რომ უბრალოდ სტენოგრამის ნოტაცია ამას თქვენ ხართ
თქვენი პირადი საქაღალდე სადაც ყველა თქვენი ფაილი წასვლა იყოს.
ახლა, აქ, მე შემიძლია აკრიფოთ ls ამისთვის სიაში.
და ერთადერთი, რაც მე ვერ ვხედავ აქ, ამ დროისთვის არის hello.c.
და ეგ კარგია, რადგან მე უბრალოდ დაწერა ეს.
>> ნება მომეცით, წავიდეთ წინ და მიიღოს hello.
და შენიშნავს, მე არ აკრეფით მიიღოს hello.c.
სამაგიეროდ, მე მხოლოდ აკრეფით ბაზის სახელით ფაილი, hello.
და მიიღოს, როგორც დავინახეთ, ორშაბათს, იქნება მხოლოდ infer რომ მინდა
. გ ფაილი.
ახლა მე აკრეფილი მიიღოს hello.
ახლა ვხედავ ამ საკმაოდ ხანგრძლივი ბრძანება და გაგრძელდება
ვხედავთ ამ ისევ და ისევ.
მაგრამ უნდა იყოს მკაფიო, clang, სიტყვა, რომელიც მხოლოდ გაჩნდა,
რომ ფაქტობრივი შემდგენელი.
ჩადება მხოლოდ Build სასარგებლო.
უბრალოდ უფრო მოსახერხებელი პროგრამა, რომელიც ზოგავს მე, წელს
გრძელვადიან პერსპექტივაში, საწყისი მქონე აკრიფოთ გარეთ წარმოუდგენლად რუტინული ხანგრძლივი
ბრძანებები როგორიც არის.
ასე, რომ თქვენ შეიძლება აწარმოებს Clang ხელით.
თქვენ შეიძლება აკრიფოთ ყველა რომ ხელით.
უბრალოდ იღებს ძალიან რუტინული.
და ასე რომ მხოლოდ პროგრამა, რომელიც ამარტივებს ჩვენი ცხოვრება და
გადის უფრო რთული ბრძანებები ჩვენთვის.
>> ყველა უფლება, ასე რომ ახლა რა ფაილი უნდა მაქვს
ჩემი მიმდინარე დირექტორიაში?
არა მხოლოდ hello.c, არამედ hello.
ასე რომ, თუ მინდა აწარმოებს hello, გავიხსენოთ, რომ ვამბობ dot ხაზი,
სადაც dot საშუალებით წასვლას მიმდინარე საქაღალდეში, სადაც არ უნდა იყოთ
არიან, და შემდეგ გაუშვით პროგრამა მოუწოდა hello, და მართლაც, ახლა,
მაქვს Hello world.
ყველა უფლება, ნებისმიერი შეკითხვა ან workflow სინტაქსის შესახებ
რაც ჩვენ უბრალოდ გააკეთეს?
>> ყველა უფლება, ასე რომ ავიღოთ რამ up მაღალი დონის ერთხელ.
ასე რომ, ეს იყო underwhelming უბრალოდ წერენ პროგრამა, რომელიც მხოლოდ
ოდესმე ამბობს hello, world.
ამიტომ, ჩვენ შეიცვალა მას, ორშაბათს, ვთქვა, hello, დავით.
ეს უფრო პიროვნული, ისევე როგორც მძიმე კოდირებული როგორც
პირველი ვერსია.
ასე რომ არა ყველა, რომ მყარი.
მაგრამ არსებობს, დო, ფუნქციები, რა თქმა უნდა გარდა
ბეჭდვითი, ფუნქციების, რომ ნება თქვენ მომხმარებლის შეყვანის.
და გზა ეს გავაკეთეთ, მეორე დღეს, იყო შემდეგნაირი.
სანამ რეალურად ამობეჭდოთ რაღაც, მე პირველად მიიღეს
რამ მომხმარებლის.
ნება მომეცით, ეს კიდევ ერთხელ გავაკეთოთ.
>> სიმებიანი s, სადაც მხოლოდ თვითნებური სახელი, აქ, ამისთვის
სიმებიანი, ტოლობის GetString.
მერე რა იყო GetString?
ეს აშკარად იღებს ტექსტი, დაფუძნებული მისი სახელი.
მაგრამ რა არის ეს, უფრო ტექნიკურად?
ეს ფუნქცია.
ასე რომ ფუნქცია, რომელიც არ მოდის და C თავისთავად.
CS50 პერსონალის დაწერა ეს.
და ასე გამოიყენოს ეს, შეგიძლიათ არა მხოლოდ მოიცავს stdio.h,
თქვენ ასევე უნდა შეიცავდეს რა?
Yeah.
ამიტომ cs50.h, რაც არის ფაილის ჩვენ წერდა რამდენიმე წლის წინ.
ჩვენ დაყენებული ეს ელექტრო თქვენთვის ერთად
ყველა სტანდარტის ფაილი.
და ა.შ. ამ პირველი რამდენიმე კვირის კლასის, ჩვენ ვიყენებთ
ამ უბრალოდ გამარტივების პროცესი აკეთებს ძალიან ძირითადი
რამ, როგორიცაა მიღების მომხმარებლის შეყვანის.
რადგან, როგორც ვნახავთ, რამდენიმე კვირის განმავლობაში, მიღების მომხმარებლის შეყვანის წელს
ენა მოსწონს C ფაქტიურად საოცრად რთული,
განსაკუთრებით იმიტომ, რომ თქვენ არ ვიცი წინასწარ, როგორც წესი, თუ როგორ
ბევრი პერსონალი მომხმარებლის აპირებს აკრიფოთ სისტემაში
და როდის არ ვიცი, რამდენად მონაცემები უნდა ველოდოთ, მაგრამ თქვენ არ
ვიცი რამდენად მეხსიერების გამოყოფას.
და თუ თქვენ ნამდვილად აქვს შეჯიბრებითობის მომხმარებლის რომელიც ცდილობს
to hack თქვენს სისტემას, Crash თქვენი კომპიუტერი, ისევე,
ზოგადად პირველი მეთოდით შეტევა, როგორც მე მოახერხა
ორშაბათი, აკრიფოთ მთელი ხანგრძლივი თანმიმდევრობა შემთხვევითი გმირები,
'Enter, და ვნახოთ, რა არღვევს.
იმის გამო, რომ ზოგადად, თუ პროგრამა წყვეტები, რომ მინიშნებები ზე
უსაფრთხოების ხარვეზი, პოტენციურად.
რა თქმა უნდა, მინიშნებები თქვენ, პროგრამისტი, რომელმაც
შეცდომა, მაგრამ უფრო სახიფათოდ, თქვენ ალბათ არ გააკეთა
უსაფრთხოებასთან დაკავშირებულ შეცდომა, და საერთოდ ჩვენ ვხედავთ, რომ
ასე მანქანა კომპრომეტირებული ამ დღეს, როგორც
სამყაროში ვებ და პროგრამების
ბრძანების სტრიქონში, მოსწონს ეს.
>> ყველა უფლება.
ამიტომ string s უდრის GetString.
ამიტომ უფრო კონკრეტულად, ახლა, რა ხაზის 6 აქ?
ასე ფუნქცია მარჯვენა იღებს ტექსტი,
იღებს რამდენი არგუმენტები?
Okay.
ასე რომ არა.
ცოტა საღი აზრის შეამოწმოს.
არგუმენტი, კიდევ ერთხელ, მხოლოდ input to ფუნქცია შეცვალოს
ნაგულისხმევი ქცევის რამდენიმე გზა.
მაგრამ ამ შემთხვევაში, მე არ მინდა შეცვალოს
ქცევის GetString.
მე უბრალოდ სურდა მიიღოს სიმებიანი.
ასე რომ მე ზუსტად არაფერი ფრჩხილებში, და მერე დააყენოს
მძიმით demarking დასასრულს ხაზი კოდი.
ახლა, ტოლობის ნიშანი არ ნიშნავს თანასწორი, თავისთავად.
ეს იმას ნიშნავს, დავალება, რაც იმას ნიშნავს, რომ ვთქვათ რასაც იღებს
outputted მარჯვენა შიგნით რაც მარცხენა.
>> ამიტომ მარცხნივ, ჩვენ ვამბობთ, რომ არ გამოცხადდა
სიმებიანი მოუწოდა s.
და უფრო კონკრეტულად, ჩვენ გამოყოფილი მეხსიერების შიგნით
რაც ჩვენ დააყენა ბიტი, რომელიც წარმოადგენს თანმიმდევრობა
სიმბოლო.
მაგრამ დღეს ჩვენ გვაქვს გამოყოფილი
ან გამოაცხადა სიმებიანი.
ყველა უფლება.
ახლა კიდევ ერთხელ მე ვაკეთებ ამ, მინდა შეაერთედ ღირებულებაში
s, არ ღირებულება დავით.
ასე რომ, ეს არის არასწორი, რატომ?
ასე რომ, ეს უბრალოდ სიტყვასიტყვით მყარი კოდირებული s.
ეს ვთქვა, "Hello, S", რომელიც არ არის ის რაც მე მინდა.
ასე, რომ შეიძლება ამის გაკეთება.
პროცენტი ნიშანი არის placeholder, მაგრამ ახლა მე უნდა
გაივლის შევიდა ბეჭდვა მეორე არგუმენტი.
შეგახსენებთ, რომ არგუმენტები ფუნქციები გამოყოფილი
მძიმეები, ამიტომ შემდეგი მძიმით აქ მე ზუსტად ამის შემდეგ წერილში s.
და ამ კონტექსტში არის, S არის ცვლადი, და printf,
მიღების იმ ორ საშუალებებით -
სიმებიანი მარცხენა და ცვლადის სახელი s მარჯვენა -
იგი შეაერთედ უკანასკნელის შევიდა ყოფილი ჩვენთვის, და
უბრალოდ ამობეჭდოთ ლამაზი ლამაზი string შემცველი
რაც არ არის, რომ ჩვენ აკრეფილი შემოსული
>> მოდით ცდილობენ ამ.
აპირებს წავიდეთ წინ და დააშორებს, უკან
ჩემს ტერმინალის ფანჯარაში.
მიუახლოვდით ბოლოში აქ.
გაიმეორეთ მიიღოს hello.
Clang ჩანს უკვე გამეორება.
მე ვაპირებ ტიპის. / Hello, შეიყვანეთ.
არაფერი ჩანს ხდება ჯერჯერობით, მაგრამ ამ სწრაფი
რომ შემიძლია აკრიფოთ რაღაც Nate, შეიყვანეთ და ახლა ჩვენ გვაქვს
Hello, Nate.
და მე შემიძლია ამის გაკეთება კვლავ რობ და სხვ.
ასე რომ იმედია ახლა ამ პროგრამის behaving როგორც ვაპირებ.
>> ახლა, ყველა რომ მომხმარებლის მეგობრული.
მე არ ვიცი, რა ელოდებიან ჩემთვის.
ასე რომ ჩვენ შეგვიძლია ნამდვილად სუფთა ეს ყველაფერი ცოტა.
ნება მომეცით დაბრუნდეს აქ, და ნაცვლად მხოლოდ სიმულაციისათვის და
გეკითხებით მომხმარებლის ამისთვის სიმებიანი, ნება მომეცით მკაფიოდ ვუთხრათ
მომხმარებლის რა მე ელოდება.
ამიტომ printf ("შეიყვანეთ string:"
);
ასე რომ არ ცვლადები აქ.
არარის პროცენტს ნიშნები.
უბრალოდ მარტივი English ფრაზა.
ნება მიბოძეთ ახლა გადადით ბოლოში და გამეორება ჩემი პროგრამა.
მაგრამ არაფერი ჩანს შეიცვალა.
რატომ?
მე უნდა recompile იგი.
ისე ადვილია შეცდომის მიიღოს.
მაგრამ თქვენ უნდა არა მხოლოდ ფაილის შენახვა, მაგრამ
recompile პროგრამა.
და ასე თუ ხელახლა აწარმოებს მიიღოს hello, ახლა Clang გადის.
ახლა შემიძლია აწარმოებს. / Hello. და ახლა ვხედავ "შეიყვანეთ string:".
Okay.
ახლა კი ცოტა უფრო მოსახერხებელი.
Nate, მიუთითოთ, hello, Nate.
>> კარგად, მოდით ვცდილობთ ეს კიდევ ერთხელ და დაიწყოს ფიქრი
დაახლოებით კუთხეში შემთხვევებში.
ამიტომ ისევე როგორც Scratch, თქვენ წახალისება ან მიმდინარეობს
წახალისებული წელს სპეც to სახის ვიფიქროთ რა შეიძლება გადასვლა
არასწორი თუ არ გავუსწრო ყველაფერი მომხმარებლის შეიძლება გავაკეთოთ.
Bugs, აქედან გამომდინარე, შესაძლოა მოჰყვეს.
ასე რომ შევა string -
რა კუთხეში შემთხვევაში აქ?
რა არის სცენარი, რომ მე, პროგრამისტი, შეიძლება არ აქვს
მოსალოდნელია?
Yeah.
Okay.
მერე რა რომ აკრიფოთ ნომერი ასე?
ყველა უფლება.
ასე რომ ჯერ კიდევ მუშაობს.
Gramatically აზრი არა აქვს.
მაგრამ არანაკლებ პროგრამა მუშაობს.
>> რა არის კიდევ ერთი კუთხეში შემთხვევაში?
რაღაც არ მეგონა.
ჰო?
Okay.
ასე რომ, ჩვენ შეიძლება არ რაღაც მართლაც, მართლაც დიდი რაოდენობის.
ასე რომ მოდით ეს აქ.
ნება მომეცით დააშორებს მეორე, ნება მომეცით ხაზი გავუსვა.
ვერ დააკოპირეთ და ჩასვით ქვემოთ აქ.
ყველა უფლება.
ასე რომ მე ვერ დააკოპირეთ და ჩასვით ამ ტერმინალის ფანჯარაში, ასე რომ ჩვენ გამოგიგზავნით
უბრალოდ სიმულაციის.
ნება მომეცით დააშორებს, აპირებს გადაიტანოთ.
მე არ ვაპირებ ამის გაკეთება დიდი ხანია, რადგან იგი არ
რეალურად შესვენება ამ პროგრამის.
მაგრამ.
შეიყვანეთ.
მაგრამ არ.
ყველა უფლება.
მაგრამ ეს ნამდვილი კუთხეში შემთხვევაში.
და ერთადერთი მიზეზი, რომ მოიქცა სწორად, ასე
საუბარი, იმიტომ CS50 ფუნქცია GetString არის რეალურად
შექმნილია ქვეშ Hood, როგორც ვნახავთ, რამდენიმე კვირის განმავლობაში,
ავტომატურად გამოყოფს უფრო და უფრო RAM, უფრო და უფრო
მეხსიერების საწყისი ოპერაციული სისტემა, როდესაც ის აცნობიერებს, wow,
თქვენ ნამდვილად აკრეფილი რაღაც საკმაოდ ხანგრძლივი.
ახლა, ეს ცოტა თეთრი სიცრუეა.
თუ ჩვენ რეალურად ათვისება საკმაოდ ხოლო მე და აკრეფილი
რაღაც 5 მილიარდი პერსონაჟების კლავიატურის
აქ, ან მართლაც მოხვდა ასლი პასტა საკმაოდ მწირი, ჩვენ საკმაოდ შესაძლოა
გამოიწვევს პროგრამის მისაწოდებლად.
უბრალოდ ცოტა უფრო რთული სიმულაცია, რომ სასრულ
დროის.
>> რა არის კიდევ ერთი კუთხეში შემთხვევაში ჩვენ შეიძლება შევეცადოთ?
ჰო?
Yeah.
მაშ რატომ არ გვაქვს არაფერი უპასუხოს?
ამიტომ, ჩვენ რეალურად უნდა მიიღოს გარკვეული ქმედება, რადგან, წინააღმდეგ შემთხვევაში
პროგრამის აპირებს იჯდეს იქ მოციმციმე მთელი დღის.
მაგრამ თუ უბრალოდ დააჭიროთ -
OK, ახლა, მაინც გამოიყურება არასწორია.
არ ავარიის, მაგრამ იქნებ იქ არის შესაძლებლობა
დაიწყოს განხორციელების უფრო მკაცრი პროგრამა
რომ რეალურად ამოწმებს.
და თუ სიმებიანი, განაჩენი, სიტყვა, რომელიც მე
აკრეფილი აქვს სიგრძე 0, კარგად, იქნებ მე უნდა დაწეროთ ზე
მომხმარებელი, ან ვუთხრა მას შესვლის სიმებიანი ერთხელ, ასე რომ
ჩვენ რეალურად რა ჰგავს სწორი საქციელი და არ
უბრალოდ სრული ზედამხედველობას ჩემი ნაწილი.
>> კითხვა თავში?
ათობითი რიცხვი.
ამიტომ ვერ ვცდილობთ, რომ ძალიან.
1,10000005.
როგორც ჩანს, რომ აპირებს მხოლოდ მუშაობა ფაქტობრივად okay.
და რომ რეალურად მოსალოდნელია.
მიუხედავად იმისა, რომ ჩვენ შეიძლება არ აკრეფილი, რომ ნომერი არსებობს, ან
უფრო დიდი რაოდენობის ადრე, გააცნობიეროს, რომ როდესაც ჩვენ აკრეფით მომხმარებლის
შეყვანის და ჩვენ გამოყენებით GetString ფუნქცია, არ
მნიშვნელობა, თუ რა მე აკრეფის ჰგავს ნომერი.
შეგახსენებთ, რომ მიხედვით ASCII, ყველაფერი თქვენს
კლავიატურის აქვს რიცხვითი მნიშვნელობა, რომელიც შეიძლება mapped to
ხასიათი, char.
ასე რომ, ამ შემთხვევაში, მიუხედავად იმისა, რომ მე შეიძლება აკრიფოთ ნომერი,
კომპიუტერის აპირებს ვფიქრობ ეს, ასე ვთქვათ, როგორც სიმებიანი -
რაღაც რომ ჰგავს ნომერი, მაგრამ არის
რეალურად არ ნომერი.
მაგრამ ეს რეალურად სრულყოფილი segue, რადგან ახლა ჩვენ შეგვიძლია
რეალურად გადასვლის წერილობით პროგრამები
გამოვიყენოთ სხვა მონაცემთა ტიპები.
>> ასე რომ გარდა გამოყენებით სიმბოლო, უფრო სწორად, გარდა გამოყენებით სიმები,
გააცნობიეროს, რომ ჩვენ გვაქვს სხვა მონაცემები სახის დო ისევე როგორც
სხვა ენებზე.
Char, როგორც სახელი ვარაუდობს, არის მხოლოდ ერთი ხასიათი.
Float არის მცურავი წერტილი ღირებულება, და ეს მხოლოდ ლამაზი
გზა ამბობდა რეალური რაოდენობა - რაღაც რომ აქვს ათობითი
წერტილი იგი გარკვეული ნომრის მარცხენა და / ან უფლება.
Int არის მთელი რიცხვი, რომელიც მხოლოდ ხმების მოსწონს 123.
და ახლა უფრო საინტერესოდ არის რამ, როგორიცაა ორმაგი.
რა მივიღეთ ამბობენ ორმაგი იყო ბოლო დროს?
ეს 64, უფლება.
ასე რომ, როგორც წესი, ხოლო float არის 32-bit -
ამიტომ ამ ხანგრძლივი მეხსიერებაში, მას იყენებს 32 zeros და ვინც
წარმოადგენს ღირებულებების - ორმაგი არის სიტყვასიტყვით ორჯერ რომ, რომელიც
ნიშნავს, რომ თქვენ შეგიძლიათ ან წარმოადგენს უფრო დიდი ციფრები, ან
შეგიძლიათ წარმოადგენენ უფრო ზუსტი ციფრები.
ასე რომ თქვენ შეგიძლიათ უფრო ნომრები შემდეგ ათობითი წერტილი, მაგრამ
როგორც თანამემამულე განაცხადა ვიდეო, თუნდაც რაღაც მარტივი
კონცეპტუალურად, როგორიცაა 1/3 არ შეიძლება წარმოდგენილია ზუსტად მიერ
კომპიუტერი, რადგან საბოლოოდ ამოიწურა ბიტი, და
ამიტომ შეგიძლიათ მხოლოდ .33333333 იმდენჯერ, ზე
რომელიც წერტილი უბრალოდ უნდა ვთქვა მე გარეთ წარმომადგენლობა
სივრცეში, უნდა მხოლოდ მას დღე და წარმოადგენს მას
გარკვეულწილად imprecisely იგრძნობა.
და ხანგრძლივი ხანგრძლივი -
სულელური სახელი, მაგრამ რადგან არსებობს მონაცემები ტიპის ცნობილია, როგორც
ხანგრძლივი დო რომელიც ერთსა ხშირად 32 ბიტი, ისევე, როგორც
int არის 32 ბიტი, მაგრამ ხანგრძლივი ხანგრძლივი არის
ზოგადად 64 ბიტი.
ასე რომ, ეს მხოლოდ იმას ნიშნავს, თქვენ შეგიძლიათ წარმოადგენს უფრო დიდი
ციფრები, ვიდრე ეს.
>> ყველა უფლება.
ასე რომ, თუ ჩვენ რეალურად გვინდა დავიწყოთ წარმოადგენს რამ, ჩვენ
ალბათ საჭიროა უფრო დახვეწილი სახის, და
ამიტომაც ჩვენ გვაქვს სიმებიანი.
ასე რომ, CS50 ბიბლიოთეკა, რომ ფაილი სახელად cs50.h, ჩვენ
რეალურად გამოაცხადა მონაცემები ტიპის, ასე ვთქვათ, მოუწოდა სიმებიანი,
მაგრამ string ფაქტობრივად არ არსებობს.
ეს არის, კიდევ ერთხელ, ერთი ამ ფენების ჩვენ ვაპირებთ კანი
უკან ორი კვირის და გადაყარეთ ის დაშორებით, და რეალურად
გამოიყურებოდეს ქვეშ Hood რა სიმებიანი ფაქტობრივად, და
როგორ ის წარმოდგენილია.
ჩვენ ასევე ვაპირებთ შევხედოთ ლოგიკური ღირებულებებს.
>> მერე რა იყო bool კონტექსტში Scratch?
მართალია ან ცრუ.
ასე რომ ეს მხოლოდ ღირებულება, რომელიც მართალია ან ყალბი, ან გამოსართავად, 1 ან
0, თუმცა გსურთ მსოფლიოში.
ასე რომ C წყალობით CS50 ბიბლიოთეკა, რაც თავის მხრივ
მოიცავს სხვა ბიბლიოთეკის ქვეშ Hood, ჩვენ გვაქვს
ხელმისაწვდომობის მონაცემები ტიპის რომ ე.წ. bool, რომელიც
სიტყვასიტყვით საშუალებას გვაძლევს მივუთითოთ ფასეულობების ნამდვილი ან ყალბი to
რამ პროგრამა.
>> მოდით წავიდეთ წინ აქ და წერენ პატარა პროგრამა, რომელიც
აკეთებს რაღაც ჩართვის ნომრები ნაცვლად.
ნება მომეცით, დავუბრუნდე CS50 ელექტრო მოწყობილობების, ნება მომეცით წავიდეთ წინ და
შევქმნათ ახალი ფაილი აქ მოუწოდა -
მოდით უბრალოდ, ვამბობთ რაღაც მარტივი, როგორიც math.c.
ყველა უფლება.
და ახლა ახვიდეთ ზევით ჩემი პროგრამა, მე
აპირებს ჩვეული -
# Include , ასე რომ შემიძლია
printf, int ძირითადი (void) -
ჩვენ დაბრუნებას, საბოლოოდ, რა int ნიშნავს
აქ, რა ბათილად ნიშნავს აქ, მაგრამ ახლა, მხოლოდ ის ვიცი, რომ
თქვენ უნდა დაიწყოს პროგრამების მოსწონს ეს.
ახლა მე ვაპირებ წავიდეთ წინ და ვთქვათ რაღაც პატარა
სხვადასხვა - printf ("მომეცი ნომერი:"
);.
მაშინ მე აპირებს int n = GetInt, რადგან იგი
თურმე GetInt კიდევ ერთი ფუნქცია CS50 ბიბლიოთეკა
გარდა ამისა GetString.
და ახლა მე ვაპირებ რაღაც სულელური, როგორიცაა "წყალობით
ამისთვის% d ", ამისთვის ათობითი რიცხვი, შემდეგ მძიმით n, და
შემდეგ დაბრუნდნენ 0.
ასე რომ კიდევ ერთხელ, დაბრუნდნენ 0 არაფერი აქვს მთელ რიგ ვარ
გეკითხებით მომხმარებლის შეეხება.
უბრალოდ ნიშნავს დასასრულს, რომ ყველა, სავარაუდოდ, კარგად.
>> ნება მომეცით, ქვევით ჩემს ტერმინალის ფანჯარაში აქ.
ნება მომეცით აკრიფოთ მიიღოს მათემატიკის, შეიყვანოთ.
და რაღაც არასწორი.
ჩადება მათემატიკის არ მუშაობდა.
აი პირველი ჩვენი შეცდომის შეტყობინებები.
რატომ?
პატარა cryptic, მაგრამ -
Yeah.
ამიტომ cs50.h.
ასე რომ კიდევ ერთხელ, განსაკუთრებით დილით, თქვენ დაწეროთ თქვენი პირველი
პროგრამის pset 1 ქვეპუნქტებში, ოფისში საათის განმავლობაში, და
გულწრფელად ვამბობ, ეს იქნება დიდი ზოგჯერ რა ეს ყველაფერი
ფაქტობრივად დაყრდნობით.
მაგრამ თქვენ გააცნობიეროს ძალიან სწრაფად ისინი დაიწყება ჩავარდნას
შევიდა თაიგულების რომლითაც ამ ერთი იმას ნიშნავს, რომ თქვენ შეჩერდით ერთი
საქართველოს # მოიცავს ზედა ფაილი.
და Clang, შემდგენელი, რომელიც გაცნობებთ ამ მიერ
ამბობდნენ, საკმაოდ fancifully, დაფარული დეკლარაცია
ფუნქციის GetInt არასწორია.
>> ყველა უფლება.
ასე რომ რას ნიშნავს ეს?
ეს უბრალოდ ნიშნავს, თქვენ მინიშნებით განაცხადა GetInt წელს
გრძნობა, რომ თქვენ არ არის მკაფიოდ გამოაცხადა.
მკაფიოდ ვაცხადებ int, თქვენ უნდა ასწავლონ
Clang რომ ის არსებობს.
და ძალიან მარტივი გადაწყვეტა, რომელიც ასწავლის მას
მათ შორის, ამ სხვა ფაილი, cs50.h, ზე
ზევით თქვენი ფაილი.
რადგან სიტყვასიტყვით, რა # მოიცავს ამჯამად არის ეს ეუბნება Clang
საკმაოდ ბევრი წასვლა სასურველი ფაილი მოუწოდა cs50.h, ასლი,
ჩასვით ავტომატურად შევიდა ზევით ჩემი პროგრამა ჩემთვის,
და შემდეგ გადაიყვანოთ კოდის to zeros და პირობა.
მაგრამ ეს აშკარად ძალიან რუტინული თუ ჩვენ ადამიანებს ჰქონდათ
წასვლა კოპირება და pasting ამ დიდი ფაილი ყველა დროის,
ასე # include უბრალოდ ჯერ ყველა რომ ავტომატურად გარეშე
muddying ჩემი კოდექსი სხვისი ბიბლიოთეკაში.
და ბიბლიოთეკაში არის კიდევ ერთი ფაილი, რომელიც შეიცავს ფუნქციებს და
სხვა რამ, რომ ვინმეს არ გაუკეთებია, რომ ჩვენ ვართ
leveraging ჩვენი გულისთვის.
>> ყველა უფლება.
მოდით კვლავ სცადეთ.
ჩადება მათემატიკის.
შეიყვანეთ.
კარგი.
ასე რომ, როგორც ჩანს, არ მუშაობდა.
ნება მომეცით, ახლა აწარმოებს მათემატიკის;. / მათემატიკის.
შეიყვანეთ მაძლევს ნომერი, 123.
მადლობა 123.
ახლა მოდით სცადოთ სხვა კუთხეში შემთხვევაში.
სიმებიანი საკმაოდ გულუხვი, რადგან
სტრინგი შესაძლოა არაფერი.
შეგიძლიათ გამოიყურებოდეს ნომრები, ჰგავს
გმირები, როგორი სიტყვა.
მაგრამ int არის int.
ახლა თუ მე რთული მომხმარებელი, და ის რომ "მომეცი
ნომერი, "მე ვფიქრობ ცდილობენ რაღაც მოსწონს 0.1?
ისე, რომ ნომერი, და ეს შეესაბამება
გრამატიკა მე აქ, არამედ ქვეშ Hood, მე of
რა თქმა გამოყენებით ფუნქციის GetInt.
>> მოდით ვნახოთ, რა მოხდება.
შეიყვანეთ, გაიმეორეთ.
ყველა უფლება.
ნება მომეცით გაუჭირდება და მხოლოდ დააჭიროთ ერთხელ.
შეიყვანეთ, შეიყვანეთ.
ახლა, როგორც ჩანს, GetInt არის ცოტა მეტი
ძლიერი ვიდრე GetString.
ჩვენ, პერსონალი, რომელიც ხორციელდება იმგვარად, რომ თუ ჩვენ შეამჩნევთ
თქვენ არ მოგვცა int - და int არის ათობითი რიცხვი
შემცველი zeros, პირობა, twos, threes, fours, fives, sixes,
შვიდკაცა, eights, ან nines.
და ამით ყველაფერი.
არარის ათობითი ქულა, არ გმირები, არ პუნქტუაციის.
როგორც ჩანს, ჩვენ უნდა ვითანამშრომლოთ.
ნება მომეცით, ვცდილობთ ოთხი, ხუთი, ექვსი, და რომ იღებს ჩემთვის მეშვეობით.
ასე რომ, რეალურად, უნდა იყოს anal აქ, მე უნდა ვთქვა, ალბათ "მომეცი
მთელი რიცხვი ", რათა მიაწოდოთ იმ მომხმარებლის
ზუსტად რა ვაპირებ.
>> ახლა მოდით ვიფიქროთ ქვეშ hood.
ჩვენ არ ვაპირებთ გაიხსენოთ cs50.h ხორციელდება დღეს,
რომ ბიბლიოთეკაში.
მაგრამ თუ იგი ინარჩუნებს ამბობდა გაიმეორეთ, გაიმეორეთ, გაიმეორეთ, რა პროგრამირების
მშენებლობა მე სავარაუდოდ გამოყენებით ქვეშ hood to
განახორციელოს, რომ?
ასე რომ მხოლოდ მარყუჟის, არა?
ერთი მარტივი იდეები, რომ ჩვენ ვნახეთ on Scratch.
სამუდამოდ მშენებლობა, გაიმეორეთ მშენებლობა.
სავარაუდოდ, ამ პროგრამაში, ქვევმოთ hood, თუნდაც
თუმცა დაწერილი C და არა ნულიდან, მას აკეთებს
რაღაც მოუწოდა ექვივალენტი სამუდამოდ თუ მომხმარებელს ჯერ არ
აკრეფილი მთელი რიცხვი, ამბობენ გაიმეორეთ, გაიმეორეთ, გაიმეორეთ, გაიმეორეთ, ისე
მაშინ საბოლოოდ, როდესაც ჩვენ გავაკეთებთ კიდევ მთელი რიცხვი, მაშინ
შესვენება გარეთ რომ მარყუჟი.
>> მერე რა სხვა ფუნქციებს შეგვიძლია გამოვიყენოთ აქ CS50 ბიბლიოთეკაში?
ისე, სახის აშკარა პირობა, მინიმუმ ეფუძნება
მონაცემთა ტიპები, რომ ახლა ჩვენ ვიცით, არსებობს.
განვახორციელეთ GetString, GetInt, არამედ მთელ
პირველი კვირის ვადით, ასევე, შეგიძლიათ გამოიყენოთ GetFloat და
GetDouble და GetLongLong მისაღებად ზუსტად
მონაცემთა ტიპები, რომ გსურთ.
რადგან გასაღები დეტალურად აქ არის ის, რომ განსხვავებით ზოგიერთი ენებზე,
მოსწონს Python და Ruby, სადაც აუცილებელი არ არის უნდა
განაცხადოს მონაცემები ტიპის ცვლადი -
თქვენ არ ვუთხრა კომპიუტერი რა სახის პერსონალი
თქვენ აპირებს ამოქმედებული ცვლადი -
დო, თქვენ უნდა იყოს ოდესმე ასე ზუსტი.
ასე რომ, თუ გსურთ ცვლადში N, ბლოკი შენახვის
რომ ამ შემთხვევაში ხდება, რომ იყოს 32 ბიტი მიერ კონვენციის, თქვენ
უნდა ვუთხრათ კომპიუტერი რომ ეს ბიტი are
აპირებს შესანახად ნომერი -
არ ხასიათი, არ სტრინგი, არ float.
და ეს ეხება საკითხი ჩვენ ეფექტურად
შეუვარდნენ გასულ კვირას.
თუ ჩვენ გამოყენებით zeros და პირობა ნომრები წარმოადგენს არა მხოლოდ
ნომრები, მაგრამ როგორც და BS და Cs, თუ როგორ მსოფლიოში არის
კომპიუტერის აპირებს იცით, რომ ეს ნიმუში ბიტი რეალურად
წარმოადგენს ნომერი 65, როგორც ეწინააღმდეგებოდა წარმოადგენს
წერილში, რომელიც ერთსა თანახმად,
ASCII, გავიხსენოთ, იყო ექვივალენტური 65?
>> ასე რომ ამ მონაცემთა ტიპები უზრუნველყოფს კონტექსტში კომპიუტერს, ისე
რომ იგი დარწმუნებულია, თუ ეს ბიტი უნდა განიმარტოს, როგორც
int ან string.
ნებისმიერი კითხვები, მაშინ, ამ?
ჰო?
დევიდ ჯ Malan: კარგი კითხვაა.
თუ ჩვენ აიღოს stdio.h, ჩვენ ფაილის შენახვა -
ნება მომეცით წასვლა ქვემოთ ტერმინალის ფანჯარაში და აწარმოებს მიიღოს მათემატიკის, Zoom
და შევა -
ახლა მივიღებ სხვადასხვა შეცდომა, რადგან მე ვარ მინიშნებით
გამოცხადების რა ფუნქცია არის?
Printf.
ახლა მე შექმნილი ახალი პრობლემა, რომლის გადაწყვეტა
არსებითად იგივე.
მე უნდა დააყენოს, რომ უკან.
აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: Oh.
ასე რომ, თუ მე აიღოს -
Okay, yeah.
ასე რომ, თუ მოვხსნა სტანდარტული I / O ბიბლიოთეკა ჩართვის up
აქ, და შემდეგ თქვენ ამბობდა თუ დავაღწიოთ printf, მიიღონ
ჩამოშორებას printf?
დიახ.
ეს უნდა მუშაობდეს, რადგან მე აღარ გამოყენებით ნებისმიერი - whoops.
არ ვამბობ, უბრალოდ მოტყუება?
ოჰ, okay.
ეს არ იმუშავებს, რადგან ახალი შეცდომა ჩვენ უბრალოდ გააცნო.
და ეს ერთი არის ცოტა მეტი თვითმმართველობის განმარტებითი.
>> რა არის პრობლემა?
გამოუყენებელი ცვლადი n.
ასე რომ, ეს შეცდომა არის შედეგი ჩვენი რომელმაც კონფიგურაცია
ელექტრო უნდა იყოს განსაკუთრებით pedantic, ნამდვილად დაწეროთ ზე
თქვენ ყველა შესაძლო შეცდომა, მაშინაც კი, თუ მისი სახის
არასამთავრობო საბედისწერო შეცდომა მოსწონს ეს - არის ეს მართლაც ასეთი დიდი
გარიგება, მე გამოყოფილი int, დაუსვან ნომერი და შემდეგ
უბრალოდ არაფერი მას?
ასე რომ ფუნქციურად არ.
ეს არ აპირებს დაარღვიოს პროგრამის.
უბრალოდ სახის სულელური, არა?
არ არსებობს ღირებულების მქონე სთხოვა, რომ ნომერი, ინახება
ეს ცვლადი, თუ თქვენ არასდროს არაფერი
მას, თუ არა ბეჭდვა ან შეინახოთ.
ასე რომ, ამ შემთხვევაში, Clang არის აღიარებით იმდენი, და
ის ამბობდა გამოუყენებელი ცვლადი n.
>> ასე რომ ჩვენ შეგვიძლია დაფიქსირება ამ თუ ჩვენ მართლაც გვინდა.
თუმცა ისევ და ისევ, ეს არ არის კარგი პროგრამირების არის.
ასე რომ მე ვერ უბრალოდ ამ -
ქვევით აქ, ნება მომეცით გარკვევა ეკრანზე, მიიღოს მათემატიკის.
რომ მუშაობს.
ახლა კი შეგიძლიათ გაუშვათ ჩემი მათემატიკის პროგრამა, იღებს შეყვანის -
კარგად, რომ იყო ცუდი.
იღებს შეყვანის და ეს ყველა ეს ასეა, ამ შემთხვევაში.
>> ასე რომ, რეალურად, მოდით ვცდილობთ ერთ სხვა კუთხეში შემთხვევაში, რომ ჩვენ
არ ვფიქრობ, ადრე.
ამ შემთხვევაში - აქ, მოდით დავუბრუნდეთ ერთი რომ
ცოტა უფრო მოსახერხებელი.
ნება მომეცით დაბრუნდეს აქ და აწარმოებს მიიღოს მათემატიკის ერთხელ.
Whoops, რა გავაკეთო არასწორი?
რაღაც უნდა გააფართოვოს უკან შემდგომი.
Okay.
ახლა ჩვენ უკან ორიგინალური სახელმწიფო, სადაც ყველა
არის იმედია კარგად.
და ახლა თუ აწარმოებს მათემატიკის, 123 როგორც ჩანს მუშაობა.
მაგრამ ეს ნამდვილად არ ეფექტური მტკიცებულება, უბრალოდ ამბობენ
okay, რომ მუშაობს.
789, რომელიც მუშაობს.
ახლა წარუდგინოს.
იმიტომ, რომ იქ სხვა კუთხეში შემთხვევებში აქ.
სიმებიანი არ ნამდვილად გვაძლევს გაცილებით trouble ის აკრეფით
მთელი უამრავი სიმბოლო.
მაგრამ რა მოხდება თუ მე აკრიფოთ ამ?
Hitting ნომერი 1 მთელი ლოტი, მთელი ბევრი აქ -
ყველა უფლება, ის მიღების ცოტა მოსაწყენი, ასე რომ მე ვაპირებ
შეწყვიტოს აქ, და მე ვაპირებ დააჭიროთ.
>> რა ჯოჯოხეთი უბრალოდ მოხდა?
ასე რომ, ეს შეიძლება რეალურად იყოს განმარტა.
ასე რომ ეს გააკეთა, მას როგორც ორობითი?
კარგი აზრის, მაგრამ არა, ეს არ ის ფაქტი, რომ მას
როგორც ორობითი, რადგან მართლაც, რომ იყო მხოლოდ სახის
დამთხვევა.
ჩვენ შეგვიძლია ეს კიდევ ერთხელ გავაკეთოთ.
ასე რომ იქ არ არის 2 in ორობითი სისტემა, რომ
ალბათ საკმარისი.
შეიყვანეთ.
ასე რომ არ იყო პრობლემა.
რა?
სწორედ.
>> ასე მგონია თავში რა int რეალურად არის.
ეს 32 ბიტი რომელიც ერთობლივად განმარტებული
როგორც ნომერი.
თუ თქვენ გაქვთ 32 ბიტიანი, რაც იმას ნიშნავს, თითოეული ბიტი შეიძლება იყოს
0 ან 1, 0 ან 1.
ასე რომ, რაც იმას ნიშნავს არსებობს ორი გზა ამ bit,
ორი შესაძლებლობები ამ ორი შესაძლებლობები ამ
bit - ასე რომ 2 ჯერ 2 ჯერ -
ასე რომ 2 დან 32 ძალა საერთო რაოდენობა
permutations of zeros და პირობა თუ თქვენ გაქვთ 32
placeholders, zeros ან პირობა, თქვენს წინაშე.
ასე რომ, თუ მაქვს 2 დან 32, მათემატიკურად, რომ ის, რასაც?
ასე რომ ბევრი.
ეს 4 მილიარდი, მისცეს ან მიიღოს.
და 4 მილიარდი არ ჩანს, თუ რა დაიბეჭდა აქ.
ფაქტობრივად, ეს გამოიყურება უფრო ახლოს 2 მლრდ.
მაგრამ ეს არ არის დამთხვევა.
ის ფაქტი, რომ კომპიუტერი არ misinterpreted ჩემი დიდი რაოდენობით,
ჩემი უზარმაზარი თანმიმდევრობა პირობა და შემდეგ ჩემი დიდი თანმიმდევრობა twos,
როგორც უხეშად 2 მილიარდი, ახსნილია თუ როგორ?
არსებობს cap on int.
იქ რა თქმა უნდა, მაქსიმალური მნიშვნელობა, რომ თქვენ შეგიძლიათ წარმოადგენენ.
მაგრამ ეს, როგორც წესი, 4 მილიარდი, არა?
თუ 2 დან 32 დაახლოებით 4 მილიარდი, რომ თითქოს
რომ ყველაზე მეტი.
ასე რომ არ დარჩენილი, მაგრამ კარგი აზრის.
უარყოფითი რიცხვები.
ასე რომ, თუ თქვენ გაქვთ 4 მილიარდი შესაძლო რამ რისი გაკეთებაც შეგიძლიათ
წარმოადგენენ ამ სხვადასხვა permutations of 32 0S და
1s, ასევე, იგი დგას, რომ მიზეზი, რომ ჩვენ ადამიანები დაგვჭირდება
წარმოადგენს არა მხოლოდ დადებითი რიცხვებით
მაგრამ უარყოფითი რიცხვებით.
მართლაც, რომ ვარაუდი, რომ C ხდის.
ამრიგად, 32 ბიტი, შეგიძლიათ წარმოადგენენ უხეშად უარყოფითი 2
მილიარდი ყველა გზა მდე დადებითი 2 მლრდ.
და ა.შ. ამ შემთხვევაში, რა ჩვენ ნამდვილად ვხედავთ მხოლოდ
Fringe საქართველოს ტევადობის მთელი რიცხვი, და ჩვენ გვაქვს, ასე
საუბარი, overflowed რიცხვი.
ჩვენ შეეცადა cram მეტი ბიტი მივანიჭო ვიდრე შეიძლება რეალურად ჯდება.
ასე რომ საბოლოო ჯამში ჩვენ არსებითად ყველა 1 ბიტი.
ჩვენ flipped ყველა ჩვენი ბიტი შესახებ, ჩვენ შევეცადეთ, რათა წარმოადგინოს
ყველაზე მეტი, რაც შეიძლება, მაგრამ ეს აშკარად არ თითქმის
დიდი საკმარისი წარმოადგენს ორი რამ მე უბრალოდ აკრეფილი შემოსული
ჰო?
აუდიტორია: [INAUDIBLE]
>> დევიდ ჯ Malan: კარგი კითხვაა.
რატომ არ შეიძლება ჩვენ მხოლოდ იმას, რომ უარყოფითი
ნიშნად მხოლოდ ხასიათი?
ამიტომ, ჩვენ აბსოლუტურად შეეძლო, და ჩვენ შეგვიძლია შემდეგ გადარჩენა
დამატებითი bit.
მაგრამ თქვენ მაინც გეგმავს უნდა წარმოადგენდეს, რომ ტირე, და
რომ აპირებს დაგიჯდებათ მინიმუმ ბევრი რაღაცა,
სავარაუდოდ bit.
ასე რომ დიახ, ჩვენ შეგვეძლო 32 ბიტი გამოიყენება ჩვენი ნომერი, მაგრამ ახლა
ჩვენ გვჭირდება კიდევ ერთი ცოტა გამოიყენება ჩვენი dash
სიმბოლო, მინუსის სიმბოლოსაგან.
ახლა ჩვენ გვაქვს 33 bit ღირებულებები, რომელიც ჩვენ შეგვიძლია გავაკეთოთ, მაგრამ
უბრალოდ არ გზით კეთდება.
ჩვენ მივიღეთ გადაწყვეტილება ზარის წლის წინ, 32 ბიტი არის ერთგვარი
ერთეული ზომის აქ.
ამიტომ, ჩვენ ვაპირებთ, გამოვიყენოთ ერთ იმ ბიტი ეფექტურად
წარმოადგენენ ნეგატიურობის და 31 ბიტი წარმოადგენს ნომერი.
გაქვთ სხვა კითხვები?
ყველა უფლება.
სწორედ ლოტი.
რატომ არ ვართ წავიდეთ წინ და მიიღოს ჩვენი ხუთი წუთის შესვენების აქ?
>> ყველა უფლება.
ასე რომ, კიდევ ერთხელ, რომ არ overemphasize მათემატიკური განაცხადების
პროგრამირების, მოდით უბრალოდ pluck off ამ ერთი მაგალითი
სანამ ჩვენ გადაინაცვლოს სხვა აშენებს, მხოლოდ იმიტომ, რომ იგი
იქნება საილუსტრაციოდ რამდენიმე საერთო stumbling რაოდენობა ზოგიერთ
საფუძვლებს, როდესაც საქმე წერა პროგრამები.
ამ შემთხვევაში, აკეთებს არითმეტიკული გამოთქმები, რომ გარკვეული
საინტერესო შეესატყვისება სინტაქსი.
>> ასე რომ, ეს უბრალოდ ფორმულა, რომლითაც შეგიძლიათ დააკონვერტიროთ
ტემპერატურის საწყისი Fahrenheit to გრადუსი.
თუ არ გავიხსენებთ, ეს მხოლოდ ფორმულით.
ასე რომ, თუ ჩვენ შეაერთედ წელს Fahrenheit ღირებულება 32 გრადუსი, რაც
გაყინვა, რომ იქნება 32 მინუს 32 არის 0, და მართლაც,
0 წელს გრადუსი ასევე გაყინვა.
ამიტომ სწრაფი საღი აზრის შეამოწმოს იქ - ეს ნაცნობი ფორმულით.
ნება მომეცით წასვლა მეტი ელექტრო მოწყობილობების, თუმცა, და დაიწყოს
პროგრამის წერა მოუწოდა, ისევე, f2c; "ფარენგეიტი to
გრადუსი dot გ ".
და ზედა აქ, მე ვაპირებ დაიწყება off ერთად # include
stdio.h და მე ვაპირებთ int ძირითადი (void), და
ერთხელ, ჩვენ დავბრუნდებით მომავალში, თუ რა int ნიშნავს
იქ და რა ბათილად ნიშნავს იქ.
და ახლა ნება მომეცით წავიდეთ წინ და განახორციელოს პროგრამა, რომელიც
არსებითად აკეთებს ამას კონვერტაციის ჩვენთვის.
>> ამიტომ printf, ვთქვათ, ტემპერატურა Fahrenheit.
და მაშინ ნება მომეცით წავიდეთ წინ და მიიღოს მნიშვნელობა მომხმარებლის.
როგორი ღირებულების უნდა მიიღონ მომხმარებლის თუ მინდა
მათ მომეცი ტემპერატურა Fahrenheit?
ჰო?
რას შესთავაზოს?
Yeah.
ასე რომ float გრძნობს საკმაოდ გონივრული.
ჩვენ გვყავს, კიდევ ერთხელ, მხოლოდ რამდენიმე პარამეტრები რომ
ჩვენ ვნახეთ დღემდე.
ჩვენ გვყავს რამ, როგორიცაა char, ორმაგი, ათწილადი, int, ხანგრძლივი ხანგრძლივი,
bool, სიმებიანი.
ასე რომ ამ, ათწილადი გრძნობს საკმაოდ გონივრული.
ჩვენ შეგვეძლო გამოიყენოთ ორმაგი, უფლება, რადგან თუ ჩვენ ნამდვილად გვინდა
წარმოადგენენ ადამიანის ტემპერატურა -
98,60000 -
ჩვენ შეგვიძლია გამოვიყენოთ 64 ბიტი ამისათვის, მაგრამ ეს იგრძნობა
overkill ამისთვის ტემპერატურაზე.
მოდით უბრალოდ წავიდეთ ერთად მიმოქცევაში.
ახლა მჭირდება ცვლადი.
უბრალოდ შენარჩუნება რამ მარტივი, მე ვაპირებ მოვუწოდო მას F, მაგრამ მე
შეიძლება ისევე როგორც სწორად ეძახით ტემპერატურა,
მაგრამ არც კარგად არის.
ასე რომ ათწილადი f = GetFloat.
როგორც კი ახლა არ გადაწყვიტა გამოეყენებინა GetFloat, თუმცა, მე
მოგიწევთ ერთ კორექცია.
Yeah.
ამიტომ, ჩვენ უნდა შეიცავდეს # , წინააღმდეგ შემთხვევაში შემდგენელი არის
აპირებს დაწეროთ ჩვენთან.
ახლა რომ მაქვს float, ნება მომეცით წავიდეთ წინ და ნუ
კონვერტაცია.
>> ამიტომ პირველ ნება მიბოძეთ, ასევე მოხვდნენ ჩვევა აქ
კომენტირებისას ჩემი კოდი.
ასე რომ კიდევ ერთხელ, კომენტარი მხოლოდ ნოტაცია ადამიანის რომ
არ შედის პროგრამის თავისთავად, მაგრამ ეს ერთი, გეხმარებათ
გვესმის თუ რა გააკეთეთ თქვენ დილით, ან შემდეგი
თვის, ის ეხმარება თქვენი სწავლების თანამემამულე გვესმის თუ რა გააკეთეთ თქვენ
ან რა თქვენ აპირებდით გავაკეთოთ, ამიტომ
ზოგადად ძალიან კარგი პრაქტიკა.
ყოველ რამდენიმე ხაზი კოდი, წერენ კომენტარი
თავის ან თქვენი კოლეგა.
ასე რომ აქ, მე ვაპირებ ვთქვა, "ჰკითხეთ მომხმარებლის ტემპერატურის."
არ უნდა იყოს სრულ სასჯელს, უბრალოდ მოკლე ფრაზა.
მაგრამ იდეა უკან კომენტირებისას დო არის ის, რომ თითოეული თქვენი
კომენტარი უნდა მისცეს თქვენ - ან, ვთქვათ, TF ან კოლეგა -
to skim თქვენი პროგრამა და ვიცი ზუსტად რა ეს ასეა, არ
იმდენად კითხულობს კოდი, არამედ კითხულობს კომენტარი, რომელიც
უნდა იყოს ლაკონური და მკაფიო.
ყველა უფლება, ასე რომ, ახლა ნება მომეცით წავიდეთ წინ და ვთქვათ, "Convert
Fahrenheit to გრადუსი. "ამიტომ მე ვაპირებ წავიდეთ წინ და გავაკეთებთ,
ვთქვათ, ათწილადი გ.
ჩვენ გავაგრძელებთ გრადუსი როგორც მცურავი წერტილი ღირებულება.
>> და ნება მომეცით მიიღოს stab ამ.
ფორმულა, კიდევ ერთხელ, აქ.
როგორც 5/9 ჯერ F მინუს 32.
ასე რომ მოდით ეს.
ასე 5 იყოფა 9, მინუს -
whoops, მე messed ეს უკვე.
Times.
ასე რომ 5/9 ჯერ F მინუს 32.
ასე F მინუს 32, მძიმით.
და ახლა, აქ ქვემოთ, მე ვაპირებ წავიდეთ წინ
და აცხადებენ, ბეჭდვა შედეგი.
და ამ ნაწილში ადვილი. Printf.
როგორ შემიძლია წასვლა შესახებ ბეჭდვა ამ?
ისე, მე შეიძლება ითქვას, "ეს ნომერი გრადუსი არის% F \ n",
მხოლოდ ზოგიერთი ესთეტიკას.
და მაშინ რა ღირებულება არ მინდა შეაერთედ აქ როგორც printf ს
მეორე არგუმენტი?
Okay.
ასე რომ მხოლოდ გ.
ასე რომ დავიწყოთ ამ და შემდეგ დააბრუნებს 0.
ერთხელ, მას არაფერი აქვს საერთო მათემატიკის.
ეს უბრალოდ ნიშნავს, ყველა კარგად არის.
>> ახლა არის ეს სწორი, ამ პროგრამის?
ყველა უფლება.
ასე რომ მე გარკვეული შეცდომები.
მაშინაც კი, თუ თქვენ არ ვიცი რა არის პროგრამირების, შეგიძლიათ დაალაგოთ
საქართველოს infer თავში Grade სკოლაში რა
შეცდომები აქ შეიძლება იყოს.
რა არის ერთერთი პირველი?
აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: ჰო.
ასე რომ ჩვენ დაკარგული ფრჩხილებში.
ეს იყო მიზანმიმართული, რომ მე ფრჩხილებში წელს კონფერენციის მონაწილეებს
ლღობას აქ, რადგან სინამდვილეში ეს ცნება მიზნით
ოპერაციების, ან უპირატესი, რომლის დროსაც გარკვეული ოპერაციები -
გამრავლება -
უმაღლესი ამკინძავი, ჰქონდეს უმაღლესი პრეცენდენტის, ვიდრე რამ
მოსწონს გარდა ან გამოკლება.
ამიტომ, ჩვენ გავაკეთეთ ამ წლების განმავლობაში მხოლოდ გაარკვიოს ზუსტად
რა მათემატიკური ოპერაცია უნდა გაკეთდეს პირველი.
ასე რომ, ალბათ mimic სწორედ ეს არის.
წინააღმდეგ შემთხვევაში, კომპიუტერი, სავარაუდოდ აპირებს ცდილობენ გააკეთონ
მსგავსი რამ გათიშე 5 by 9, მაშინ გავამრავლოთ F, მაშინ სხვაობა
32 მთელი რამ.
რომელი არ არის, ფაქტობრივად, რაც გვინდა გავაკეთოთ.
მოდით parenthesize.
მოდით დამატება ჩემი ფრჩხილებში აქ, ბრჭყალების აქ.
მოდით დააყენა ამ მეტი აქ.
აქ, უბრალოდ შენიშნა კიდევ ერთი შეცდომა მივიღე გასწვრივ გზა.
ჰო?
აუდიტორია: [INAUDIBLE]
>> დევიდ ჯ Malan: Ah.
კარგი.
ამიტომ, ჩვენ რეალურად იგივე რიცხვი
გაყოფის საკითხს ადრე.
მე გამოსწორებას, რომ, ვნახოთ, რა სიმპტომია არის.
მაგრამ ჩვენ ვაპირებთ აქვს გამოსწორების ერთი
სხვა შეცდომა აქ.
ჰო?
აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: დიახ.
ასე რომ, სულელური შეცდომა მივიღე, მაგრამ წარმოუდგენლად მნიშვნელოვანია.
კომპიუტერი არ აპირებს უბრალოდ თვალის დახუჭვას და მოდით
ჩემთვის გამოიყენოთ Capital F, როცა რეალურად განაცხადა ცვლადი
როგორც ამას ვ აქ, ხაზი 8.
ასე რომ მე უნდა სწორი ხაზი 11 ჩემი კაპიტალიზაცია, რომელიც
მომენტში წინ იყო Capital F შეცდომით.
რაც შეეხება აქ?
უნდა ეს იყოს ამას ისევე?
ასეც უნდა იყოს, მაგრამ ეს დამთხვევა.
რომ% ვ არაფერი აქვს ერთად ცვლადი.
ასე რომ მხოლოდ უნდა იყოს სუპერ წმინდა აქ, ნება მომეცით წავიდეთ წინ და
გადარქმევა ამ, მოკლედ, "ტემპერატურა". ნება მომეცით გადარქმევა
ამ "ტემპერატურის". ნება მომეცით არ გადაარქვათ ამ.
რადგან, კიდევ ერთხელ,% ვ გლობალური ნიშნავს, "მცურავი წერტილი ღირებულება."
არაფერი აქვს, რომ ჩემს ცვლადი.
მაგრამ "ტემპერატურის" მთელ ადგილი არის მხოლოდ პატარა wordy,
ამიტომ მე ვაპირებ დავუბრუნდე ჩემს ამას "ვ" s.
>> ახლა ნება მიბოძეთ, წავიდეთ წინ ქვემოთ ჩემი ფანჯრის აქ.
ჩადება f2c -
რაც იყო, კიდევ ერთხელ, თვითნებური სახელი მე
მისცა ამ ფაილზე.
როგორც ჩანს, არ შედგენილი.
ნება მომეცით აწარმოებს f2c.
შეიყვანეთ.
ტემპერატურა Fahrenheit - მოდით ადვილი.
32.
OK, შეასწოროს.
მაგრამ, თუ მე ახლა 212 შეეხება დუღილის -
Damn.
ყველა უფლება.
ასე რომ, აშკარად არ არის სწორი, თუ თქვენი TF ცდილობს
მინიმუმ ორი ღირებულებებს.
ამიტომ რა პრობლემა აქ?
ისე, თქვენ უკვე დააყენა თითის რა საკითხი.
მაგრამ რატომ არის, რომ საქმე?
აქ, როცა მე ვაკეთებ მათემატიკის, 5 იყოფა 9.
ასე რომ კონცეპტუალურად, რომ შესანიშნავად სწორი.
მთლიანად შეესაბამება ფორმულა.
მაგრამ კომპიუტერები მხოლოდ ზუსტად ის, რაც თქვენ
ვუთხრა, უნდა გააკეთოს.
და რა ჩვენ ეფექტურად ვეუბნებოდი კომპიუტერი აქ არის
დაყოს მთელი რიცხვი 5 მიერ რიცხვი 9
და მომეცი შედეგი.
პრობლემა ისაა, თუმცა, როდესაც თქვენ ჩვენგან სამმართველოს გამოყენებით მონაცემები
სახის, გამომავალი არის იგივე ტიპის მონაცემის როგორც საშუალებებით.
და თუ ორ საშუალებებით ორივე ints, გამომავალი აპირებს
უნდა იყოს int.
და ა.შ. 5 იყოფა 9 არის წერტილი რაღაც.
მაგრამ რა არის უახლოესი რიცხვი აღვნიშნო რაღაც?
ასე რომ, ეს რეალურად 0.
ასე რომ, როგორც ჩვენ განვიხილეთ ორშაბათს, ყველაფერი შემდეგ ათობითი
ქულა იღებს truncated.
ეს უბრალოდ იღებს დააგდეს დაშორებით.
ასე რომ, ეს სრული შეცდომაა, რადგან მე შეიძლება ასევე მხოლოდ
გავამრავლოთ ყველაფერს 0 აქ.
>> ეხლა უკვე შემიძლია დაფიქსირება ამ რამდენიმე გზები.
შემეძლო ამის გაკეთება.
5.0 იყოფა 9.0.
ტექნიკურად, ისიც კი არ უნდა გავაკეთოთ, რომ.
ეს არ გვაძლევს, მხოლოდ ერთი მიზნით ნომრები float -
ან ორმაგი - გამოსული ათობითი წერტილი აქ.
რადგან რა ხდება ახლა, როდესაც თქვენ დაყოფის რიცხვი მიერ
float, ან ორმაგი, კომპიუტერის აპირებს გააცნობიეროს
OH, ერთი იმ უფრო ზუსტი.
ნება მომეცით err მხარეს გაწვდით მეტი სიზუსტით, ვიდრე
თქვენ აპირებდით.
ასე რომ, ეს იქნება კონვერტირება შედეგი -
იგი დაბრუნდება შედეგი როგორც მცურავი წერტილი ღირებულება ისევე.
ასე რომ იმუშავებს.
ეს იმუშავებს.
წინ კიდევ ერთი სხვა მექანიზმი, რომელიც ჩვენ ვხედავთ
უფრო მეტი დეტალი მომავალი კვირის.
თქვენ შეგიძლიათ რეალურად, როგორც პროგრამისტი, ვუთხრა კომპიუტერი
რეალურად მკურნალობა ერთი ტიპის მონაცემის როგორც
თუმცა ეს იყო კიდევ ერთი.
>> ასე რომ მე ვერ რეალურად ამის გაკეთება.
ფრჩხილებში, შემიძლია ვთქვა რაღაც (float), ღია
PAREN, მჭიდრო PAREN.
და ეს არის ის, რაც ე.წ. "კასტინგი". ერთხელ, უფრო
ამ მომავალ კვირას.
მაგრამ ეს მხოლოდ პროგრამული გზა ვეუბნებოდი
კომპიუტერი, yeah ვიცი 9 არის მთელი რიცხვი ან ხანგრძლივი.
მე ვიცი ეს არ მცურავი წერტილი ღირებულება.
მაგრამ მკურნალობა, როგორც ასეთი მაინც.
ასე რომ მიცემული მონაცემები ტიპის ნიშნავს გადაიყვანოთ
ერთი, მეორე მხარეს.
გულწრფელად ვამბობ, ეს მხოლოდ პატარა მახინჯი, ამიტომ მინდა შესთავაზოს ჩვენ წავიდეთ
თავში ორიგინალური წინადადებით მხოლოდ კონვერტაცია
ეს ყველაფერი უნდა მცურავი პუნქტიანი ღირებულებების ხელით.
რადგან ახლა ეს მხოლოდ სუპერ გარკვევა რა ხდება, და
ეს არ არის ყველა, რომ ყურადღების გადასატანი.
>> მოდით ახლა დავუბრუნდეთ ჩემს ტერმინალის ფანჯარაში.
ჩადება f2c.
ნება მომეცით წავიდეთ წინ და აწარმოებს ამ.
და, როგორც განზე, მოგწყინდება აკრეფით ეს ბრძანებები
ისევ და ისევ, გააცნობიეროს, რომ კომპიუტერები, როგორიცაა Linux აქ,
ტენდენცია იყოს საკმაოდ ჭკვიანი.
და თუ მოხვდა, შეიძლება გავლა ჩემი მთელი ისტორია
ბრძანებები, ზემოთ და ქვემოთ.
ასე რომ, ამ შემთხვევაში აქ, მე შემიძლია უბრალოდ ახვიდეთ აწარმოებს მიიღოს f2c.
მე მიმდინარეობს yelled ზე, რადგან მე უბრალოდ გააკეთეს, რომ მეორე წინ.
ეს უკვე დღემდე.
ახლა შემიძლია აწარმოებს f2c ერთხელ.
მოდით ვეცადოთ 32 ფარენგეიტი.
ახლა მოდით შევეცადოთ 212 ფარენგეიტი.
>> Phew.
როგორც ჩანს მუშაობა.
ახლა, ეს არის კარგი, მაგრამ ეს გრძნობს პატარა თვითნებური რომ
მე გვიჩვენებს ექვსი ნომერი შემდეგ ათობითი რაოდენობა.
მარჯვენა?
თუ თქვენ ამინდის პირი ტელევიზიით, თქვენ სახის doofus
თუ თქვენ კითხულობს ტემპერატურა უნდა
ამ ხარისხის სიზუსტით.
მოდით გაამარტივებს ამ.
მოდით რეალურად ახვიდეთ აქ, ჩემი printf.
და ჰო, მინდა ათწილადი.
მაგრამ მე მინდა ახლა დააკონკრეტა სიზუსტით.
და მე ვაპირებ იყოს ცოტა ლაკონური.
მე ვაპირებ ვთქვა, მომეცი ერთი ქულა შემდეგ ათობითი ადგილი.
ასე რომ, ვიდრე ამბობენ% f, მე ვაპირებ ვთქვა% .1 f.
და ეს მხოლოდ იმას ნიშნავს, მომეცი ერთი პოზიცია
შემდეგ ათობითი წერტილი.
ყველა უფლება.
მოდით ვეცადოთ ეს კიდევ ერთხელ.
ნება მომეცით ხელახლა გაუშვით შემდეგ შედგენა.
და ახლა აკრიფოთ 32, და არ დავიბრუნებ
უფრო ლაკონური ღირებულება.
და შემიძლია აკრიფოთ, ახლა, 212, და დაუბრუნდება უფრო ლაკონური
ღირებულება ისევე.
და არსებობს სხვა რამ რომ თქვენ printf.
თქვენ შეგიძლიათ რეალურად დააკონკრეტა, თუ როგორ ფართო ნომერი უნდა.
თუ გსურთ აქვს padding მასზე, ასე რომ თქვენ შეგიძლიათ მარჯვენა გასწორება ან
მარცხენა გასწორება ყველა თქვენი ნომრები ან
ცდილობენ ცენტრი რამ.
ასე რომ მიხვდებიან, არსებობს პატარა ხრიკების შეგიძლიათ ესაქმებათ.
მაგრამ ისინი უბრალოდ მოვხარშოთ ქვემოთ ფორმატის კოდები,
როგორც ჩვენ გვყავს იქ.
>> ამიტომ თვალსაზრისით ამ საკითხის უპირატესი.
ეს არის ძალიან მოსაწყენი მაგიდა გავლა მეთოდურად.
მაგრამ გვესმის, რომ ავტორები C არ ამუშავება
წესები რომ მიუთითოს, თუ რომელი ოპერატორების უმაღლესი
პრეცენდენტის, მეტი ამკინძავი ძალა, ვიდრე სხვები.
ასე ხოლო Grade სკოლა, ჩვენ ზოგადად იცოდა, რომ ეს იყო
გამრავლება და გაყოფა, მაშინ ამისა და გამოკლება,
მაშინ რაიმე სხვა პერსონალი.
მსოფლიოში პროგრამირების, არსებობს ბევრი
აღარ სიაში რამ.
და ეს არ არის რაღაც ღირს იმახსოვრებდა არის.
თქვენ მიიღებთ acclimated მას ადრე ხანგრძლივი.
მაგრამ ისევე, როგორც კლასის სკოლა, ბრჭყალების ზოგადად გადაჭრას
საკითხები პრეცენდენტის, მიერ მიღების სუპერ ნათელი
კომპიუტერი და ადამიანის მსგავსად რა განკუთვნილია.
ამიტომ მიგვაჩნია, რომ ეს მხოლოდ პატარა cheat ფურცელი არსებობს.
მაგრამ ყველაზე მეტად იმ დეტალებზე ჩვენ არ მიიღოთ გარკვეული დროის განმავლობაში.
>> ყველა უფლება.
ახლა, მოდით, დაამყარონ და გადაადგილება დაშორებით ამ სულელური პატარა
მათემატიკის მაგალითები.
კვლავ გამოიყენოთ იგივე საფუძვლები, მაგრამ დაიწყება
გამოხატავს საკუთარ თავს ცოტა მეტი მოსწონს Scratch.
ასე რომ, Scratch, ჩვენ გვქონდა ამ ლოგიკური გამონათქვამები.
და ინგლისურ, ლოგიკური გამოხატვის რა?
True ან ყალბი.
ეს რაღაც, რომ აფასებს ჭეშმარიტი ან ცრუ.
1 ან 0.
ან გამოსართავად.
რასაც თქვენ გსურთ ეძახით.
ახლა Scratch, თავსატეხი ცალი ჩანდა მოსწონს ეს.
და ეს კომბინაცია, ქვედა არსებობს, სამი
თავსატეხი ცალი.
ერთი ერთობლიობაში -
რაღაც რომ აქვს ცარიელი და ცარიელი.
და შემდეგ ორი ლოგიკური გამონათქვამები შიგნით მას.
ასე რომ თქვენ შეგიძლიათ ბუდე ლოგიკური გამონათქვამები უფრო
გართულებულია ლოგიკური გამონათქვამები.
მაგალითად, თუ ეს შაბათი და ეს ლამაზი
ამინდის, მაშინ გარეთ.
ან რამე თვითნებური იგრძნობა.
ასე, რომ თქვენ შეგიძლიათ შეუერთდება ლოგიკური გამონათქვამები ამუშავება ერთად
უფრო დიდი სიმართლე ღირებულება, რომლის პასუხი ეფუძნება
on მცირე ზომის.
>> ახლა კი, C, საბედნიეროდ, ამ რუკების არის
რეალურად საკმაოდ მარტივია.
ფრჩხილებში დაეხმარება მიიღოს რამ გამოიკვეთა აქ.
&& არის ის, რაც იმას ნიშნავს, "და". ასე რომ ასე
ჩვენ ვაპირებთ კონვერტირება იმ ბლოკების ნულიდან უნდა C.
და პირობები ვნახეთ Scratch, მარცხენა
მხარეს, მე შემიძლია დააწყობს მათ მსგავსად in C. თუ x ნაკლებია
ვიდრე Y, მაშინ ამის გაკეთება.
Else თუ x მეტია y, მაშინ ამის გაკეთება.
Else ლოგიკურად უნდა იყოს თანასწორი, ისე ამბობენ
რომ ისინი არიან თანაბარი.
ასე რომ ჩვენ შეგვიძლია ახლა დავიწყოთ აშენება ეს ყველაფერი მდე.
>> ასე რომ მოდით მაგალითს.
ნება მომეცით გახსენით ფაილი რომ on რა თქმა უნდა ნახვა, რომ
დავწერე წინასწარ.
რომ ჰქვია nonswitch.c.
და ვნახავთ, თუ რატომ მხოლოდ მომენტში.
ასე რომ ამ ფაილის - nonswitch.c--
პირველი გააცნობიეროს, რომ არსებობს მთელი bunch of
კომენტარები ზედა.
ეს მხოლოდ ხსნიდა სახელით ფაილი, თუ რას
აკეთებს და სხვ.
და ეს აშკარად მეტყველებს გამოყენების ლოგიკური და ING -
conjoining ორი გამონათქვამები.
>> მოდით ვნახოთ, როგორ ეს პროგრამა მუშაობს.
მე მოიცავს ჩემი ორი ფაილი, cs50.h და stdio.h.
თუ მე გადახვევა down, ახლა, რომ პროგრამა, ეს პატარა აღარ
ვიდრე ჩვენ წერილობითი ადრე, მაგრამ საკმაოდ იკითხება.
ასე რომ პირველი ბეჭდვა მომხმარებელი, on line 18,
"მომეცი რიცხვი შორის 1 და 10." ასე
რომ უფლება არსებობს.
ახლა მივიღებ მთელი რიცხვი.
მაგრამ ვაცნობიერებთ, რომ GetInt - საკმაოდ მარტივია.
უბრალოდ აპირებს მიიღოს int.
ეს ხდება იმის უზრუნველსაყოფად, რომ ეს სულაც კიდევ int და არა
სიმებიანი ან float.
მაგრამ არ ვაპირებთ რაიმე სახის საზღვრის შემოწმება.
ის არ აპირებს გავფილტროთ ნომრის იყოს
გარკვეული დიაპაზონი.
ამიტომ, ჩვენ უნდა განვახორციელოთ, რომ საკუთარ თავს.
ამიტომ ისევე როგორც Scratch, სადაც მე შეეძლო conjunction of
ორი გამოთქმები, შემიძლია, რომ C შემდეგნაირად.
თუ n მეტია ან ტოლია 1, N და ნაკლებია, ვიდრე და
ან ტოლია 3, ვაპირებ ძალიან თვითნებურად განკარგულებით, რომ
ნომერი უნდა იყოს მცირე რაოდენობის.
მხოლოდ გულისთვის განცხადებაში.
Else თუ N არის 4 და 6, ბეჭდვითი "თქვენ აიყვანეს საშუალო
ნომერი. "Else თუ N არის შორის 7 და 10, ბეჭდვითი" თქვენ აიყვანეს
დიდი რაოდენობით. "Else ბეჭდვა" თქვენ შეარჩიო არასწორი ნომერი. "
იმის გამო, რომ ლოგიკურად, რომ შემდეგნაირად თუ ჩვენ
ამოწურა ჩვენი დიაპაზონი.
>> ასე რომ მიხვდებიან, ეს არ არის საკმაოდ, თუ როგორ წერენ მეტია ან
ტოლია წელს მათემატიკის კლასის.
მარჯვენა?
ჩვეულებრივ მიაპყროს მას მოსწონს, ერთად ხაზის ქვეშ.
მაგრამ არ არსებობს ასეთი გასაღები ჩემს კლავიატურაზე.
ამიტომ სიმბოლოდ C გამოთქმის მეტია ან
ტოლი არის ორი პერსონაჟი, და სიმბოლო ნაკლები
ან ტოლია არის ორი გმირები ისევე.
ყველა უფლება.
ასე რომ, თუ მე აწარმოებს ამ პროგრამის საშუალებით თქვენ შეგიძლიათ ალბათ მიხვდები რასაც ის
გაკეთებას აპირებს.
თუ მე წავიდეთ წინ და მიიღოს nonswitch, შეიყვანეთ.
და შემდეგ აწარმოებს nonswitch.
მომეცი რიცხვი 1 და 10.
მე ვაპირებ მისთვის 11.
მე აიყვანეს არასწორი ნომერი.
ნება მომეცით ვცდილობთ ნომერი 3.
მე აიყვანეს მცირე რაოდენობით.
ასე რომ საკმაოდ მარტივია არსებობს.
>> თუ გსურთ შეცვალოთ ქცევა ამ პროგრამის შესახებ და
რაღაც პატარა სხვადასხვა ნაცვლად?
ნება მომეცით წავიდეთ წინ და ამბობენ, რომ ეს.
ნება მომეცით დავაღწიოთ ყველა ამ.
და მინდა ვთქვა, თუ (n == 42).
და შემდეგ მე ვაპირებ წავიდეთ წინ და ვთქვათ ბეჭდვითი "თქვენ აიყვანეს
სწორად უნდა უპასუხოს ". Else ჩვენ ვაპირებთ წავიდეთ წინ და აცხადებენ,
printf ("თქვენ აიყვანეს
არასწორი პასუხი. "); Okay.
მხოლოდ იმიტომ, რომ.
>> ახლა, რამდენიმე რაოდენობა შეიძლება გავაკეთოთ აქ.
ერთი, მე არ აკრიფოთ სიმბოლო, რომ თქვენ ვფიქრობ არის
ყველაზე გონივრული.
როდესაც მე მინდა შევამოწმო თანასწორობის, თურმე, ჩვენ არ ვიყენებთ
თანაბარი ნიშანი.
თქვენს ნაცვლად გამოიყენოთ თანაბარი თანაბარი ნიშანი.
და რატომ შეიძლება რომ იყოს, უბრალოდ ინტუიციურად?
Yeah.
აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: სწორი.
თანაბარი ნიშანი უკვე გამოიყენება დავალება.
ვიღაცამ არ ნამდვილად ვფიქრობ, რომ ეს მეშვეობით.
და ახლა, როდესაც საქმე თანასწორობის ტესტირება, ჩვენ უნდა
უფრო ზუსტად რომ ვთქვათ, და ვთქვათ შეადგენს შეადგენს.
ძალიან ჩვეულებრივი შეცდომა არის ამის გაკეთება.
და, თუ სამუშაო საათებში ან მომავალ კვირას ან
მომდევნო ორი კვირის განმავლობაში, რასაც აკეთებთ რაღაც მსგავსი და შემდეგ
ბრძოლა მას 10, 20 წუთის ცდილობს გაერკვნენ
რა Damn შეცდომა, გააცნობიეროს, რომ თქვენ ერთი იმ
ადამიანი რომელმაც ეს შეცდომა.
ასე რომ, სუპერ მარტივი მიიღოს.
მაგრამ მიზანია Ward off ეს შეცდომა.
ეს შეიძლება შევაფასოთ, რადგან რა არის ეს მართლაც ამბობდა?
თუ n იღებს 42.
ასე რომ ზმნის ადამიანი სარგებლობს, სიტყვიერი, გამოთქვას
ცნება დავალება "იღებს." ასე რომ, თუ n იღებს 42.
ასე რომ, რაც იმას ნიშნავს დაავალოს 42 დან n.
ახლა ლოგიკური გამოხატვის ფრჩხილებში,
შიგნით ამ მდგომარეობის, რომლის ღირებულება არის 42.
მარჯვენა?
რადგან თუ შეაფასებთ მას შიგნიდან გარეთ, სულ
პასუხი, ახლა, 42 წლისაა.
>> ასე რომ, თუ ვკითხე თქვენ კითხვაზე, "თუ (42)," რა არის
რომ მართლაც ამბობდა?
ისე, ლოგიკური გამონათქვამები იყოს მხოლოდ ჭეშმარიტი ან ცრუ.
1 ან 0.
ან გამოსართავად.
ამიტომ, ჩვენ, როგორც ჩანს, აქვს კუთხეში შემთხვევაში აქ, სადაც ყველა
უეცარი, მე რომ "თუ (42)". ეს არ არის ლოგიკური მნიშვნელობა.
მერე რა კომპიუტერები გააკეთოს, თუმცა, არის ეს არსებითად წელს
არაფერი რომ არ არის 0 ინტერპრეტირებული უნდა იყოს ჭეშმარიტი.
1.
On.
ისინი ყველა ფუნქციურად ექვივალენტური.
მხოლოდ ღირებულების 0, ან სიტყვით ყალბი, როგორც ჩვენ გამოგიგზავნით
საბოლოოდ ვხედავთ, ფაქტიურად სიცრუეა.
ასე რომ, "თუ (42)" რომ რეალურად იყოს ჭეშმარიტი, რადგან ეს არის არასამთავრობო ნულოვანი.
ასე უფრო სწორედ აქ, ლოგიკური ღირებულება მართლაც არც ისე
ბევრად ჭეშმარიტი ან მცდარი, მაგრამ ამ
შემთხვევაში, თუ არის 0 ან არასამთავრობო ნულოვანი.
ასე რომ ყალბი ან არ ცრუ.
და რომ საშუალებას გვაძლევს მოიცავს ყველა მეტი
შესაძლებლობები ჩართული გამოხატვის.
ამიტომ ჩვენ გვჭირდება, ოდესმე ასე ყურადღებით, ამბობენ, რომ ეს -
თუ (n == 42).
უბრალოდ იმიტომ, რომ ჩვენ გვჭირდება დააკონკრეტა ტესტი თანასწორობის,
არ მინიჭებული მნიშვნელობა.
>> რა არის აღსანიშნავია აქ?
ეს Curly braces რეალურად საჭირო არ არის.
მე უკვე აკეთებს უბრალოდ უნდა იყოს Nit-picky აქ.
მაგრამ როდესაც თქვენ გაქვთ პირობით, რომ მხოლოდ ერთი ხაზი
კოდი, როგორც მოხერხებულობისთვის, პროგრამისტები არ უნდა გამოვიყენოთ
Curly braces.
ეს suffices მხოლოდ აბზაცის, ამისთვის ესთეტიკური მიზეზების გამო, და
მაშინ დაწეროთ თქვენი ხაზი კოდი.
მხოლოდ მაშინ, როდესაც გსურთ წერენ ორ ზოლს კოდი - ამისთვის
მაგალითად, სხვაგან printf ("Bye!"). თუ გსურთ
იმაში, რომ ეს არის გატეხილი.
შეგიძლიათ აბზაცის ყველა გსურთ, მაგრამ ფაქტია, რომ თქვენ გაქვთ
აკრეფილი ორი ხაზი კოდი გამოყენების გარეშე Curly braces
იმას ნიშნავს, რომ ამ პროგრამას არ აწარმოებს სწორად ან შეიძლება
კი არ კომპილირდება სწორად.
ასე რომ ახლა, რომ იყოს პატიოსანი, ვფიქრობ საუკეთესო ჩვევა მხოლოდ
გამოყენება Curly braces, და თქვენ ნახავთ, რომ ისინი
სუპერ წმინდა რა ხდება.
>> ასევე, როგორც განზე - განსაკუთრებით თუ თქვენ შორის, ვინც გამოიყენოს
რეკომენდირებული წიგნების ან რესურსების ონლაინ -
გააცნობიეროს, რომ არსებობს ამ ცნება სტილის
პროგრამირების.
და ზოგიერთი ადამიანი რეალურად ურჩევნია დააყენა Curly გაუწიოს
მეტი აქ ხაზი.
ზოგიერთი ადამიანი ამჯობინებს გააკეთოს სასაცილოა რამ,
მინდა დააყენა ისინი აქ.
იქ არ არის არასწორი პასუხი, როდესაც საქმე
სტილი, მაგრამ ეს არასწორია.
მაგრამ ზოგიერთი ადამიანი აკეთებს.
[სიცილი]
დევიდ ჯ Malan: ასე რომ აღარაფერი ვთქვათ ეს ახლა, უბრალოდ იმის გამო, როგორც
წაიკითხოთ up on რამ წიგნების ან შემოსული, თქვენ აპირებს მიიღოს
სხვადასხვა შეტყობინებები სხვადასხვა პედაგოგებს და
სხვადასხვა ავტორები.
და მხოლოდ გააცნობიეროს, რომ ფუნქციურად ისინი
ზოგადად ექვივალენტი, მაგრამ იყოს თანმიმდევრული.
ასე რომ, ამ შემთხვევაში, ჩვენ standardize on Curly
braces დოლომიტ აქ მარცხნივ.
>> ყველა უფლება.
მოდით წავიდეთ წინ არის და აწარმოებს ამ, და ვნახოთ, რა მოხდება
ამ პროგრამით.
ჩადება nonswitch.
მაშინ აწარმოებს nonswitch.
მომეცი რიცხვი შორის 0 და - ისე, რომ არ შესაბამისი
აღარ, მაგრამ მე უბრალოდ აპირებს თვითნებურად ამბობენ 42.
მე აღებული უფლება პასუხი.
კარგად არის, მოდით პრაქტიკულად ეს სხვადასხვა მიმართულებით.
თურმე არსებობს რამდენიმე სხვა სინტაქსის ჩვენ
შეგიძლიათ გამოიყენოთ პროგრამა.
აქ ახალი ნაჭერი სინტაქსი რომ არის ფუნქციურად იგივე,
მაგრამ გაგაცნობთ სხვა გზა გამოხატვის საკუთარ თავს.
ასე რომ, ეს არის ის, რაც ე.წ. "შეცვლა განცხადებაში." და
შეცვლა განაცხადი მოქმედებს შემდეგნაირად.
იგი იღებს, ფრჩხილებში, ღირებულება, რომელიც გსურთ
"შეცვლა" შესახებ.
გსურთ იქცევიან განსხვავებულად ეფუძნება მისი ღირებულება.
ასე რომ, ეს იმას ნიშნავს, ჩართეთ ღირებულება n.
და რას ნიშნავს ეს?
ისე, თუ N არის 1 ან 2 ან 3, წავიდეთ წინ და ამობეჭდოთ "თქვენ
აიღო დიდი რაოდენობით "და შემდეგ შესვენება.
მიზეზი შესვენების არის ის, რომ გზა C მუშაობს არის როგორც
მალე იგი აღმოაჩენს შემთხვევაში, რომ სიას, იგი იწყება შესრულებაში
ყველა ლოდი იგი.
ასე რომ, თუ მაქვს ერთი ხაზი კოდი, როგორც მე აქ ხაზი 27, მას
იღებს დასაჯეს.
თუ დავამატო მეორე ხაზი აქ, იგი იღებს დასაჯეს.
მეორე ხაზი აქ, იგი იღებს დასაჯეს.
პროგრამა მხოლოდ აჩერებს შესრულებაში რა ქვემოთ
მოქმედი შემთხვევაში განაცხადი როდესაც მე მკაფიოდ
ამბობენ "დაარღვიოს." ასე არასწორია.
მარჯვენა, ამ შემთხვევაში, როგორც შედეგი.
საქმე 4 ან 5 ან 6, ანალოგიურად, ხდება
უნდა ამობეჭდოთ გაგზავნა.
ამ შემთხვევაში, საშუალო რაოდენობას.
დაარღვიე.
საქმე 7, 8, 9, 10, ის აპირებს ამობეჭდოთ "თქვენ აიყვანეს დიდი
ნომერი. "დაარღვიე.
და მაშინ არსებობს სიტყვასიტყვით სიტყვით მოუწოდა "default"
რომ ეფექტურად მოსწონს "სხვაგან" ააშენებს.
ასე რომ ახალი სინტაქსი, მაგრამ ინტელექტუალურად,
არაფერი ახალი აქ.
უბრალოდ მოსწონს Scratch.
თუ სხვაგან, თუ სხვაგან, თუ სახის ბლოკში.
>> ასე რომ გადაერთო ვერსია ამ პროგრამის.
მაგრამ შეამჩნია, რომ ჩვენ ეს გავაკეთეთ ერთად ნომრები აქ.
ნება მომეცით გახსენით მეორე ვერსია, უბრალოდ რათა ნახოთ
რაღაც ცოტა უფრო კონკრეტული.
ასე რომ აქ გვაქვს კლასის ნაცვლად.
თურმე შეგიძლიათ გამოიყენოთ კონცენტრატორები არ მხოლოდ მთელი რიცხვები, არამედ
სიმბოლო.
არა ყველა მონაცემთა ტიპები, მაგრამ ყოველ შემთხვევაში სიმბოლო.
ასე რომ, ჩვენ შეიძლება რაღაც მოსწონს თუ ღირებულება C რომ
მომხმარებლის აკრეფილი, შეესაბამება 19, გამოყენებით GetChar ფუნქცია,
არის კაპიტალური ან მხედრულ, მოდით ინტერპრეტაცია, როგორც კლასის,
და აცხადებენ, რომ მათ იციან შესანიშნავი კლასის.
და ქვემოთ გასწვრივ შეცვლა განაცხადი, გვაქვს სხვა
შემთხვევაში "B" და "C" s, და სხვ.
მაგრამ მოდით ახლა გარშემო ერთი სხვა რამ.
ისევ და ისევ, სახის საფრენი მეშვეობით
ზოგიერთი მაგალითი.
მაგრამ ეს მართლაც ასეა, რომ ჩვენ შეგვიძლია ერთდროულად მიმართოთ მათ, ახლა -
ან ნამდვილად, უბრალოდ ვთარგმნით მათ ახლა -
to C.
>> ნება მომეცით, წავიდეთ წინ და ამის გაკეთება.
მე ვაპირებ ქმნის ახალ ფაილს.
და მე ვაპირებ ამის გაკეთებას მოიცავს .
და შემდეგ მე ვაპირებ ამის გაკეთებას int ძირითადი (void).
ნება მომეცით გადარჩენა ამ ფაილის როგორც loop.c.
მაგალითისათვის.
და მე ვაპირებ წავიდეთ წინ და ნუ შემდეგ.
მინდა დაწერა ძალიან რუტინული პროგრამა.
ასე 10.
მოდით ეს.
9.
ყველა უფლება.
როგორც კი დაიწყება ამით პროგრამირებაში, თქვენ
ალბათ აკეთებს რაღაც.
მაგრამ ჩვენ დავიწყებთ იქ მაინც.
Oops.
სწორედ რეალურად არასწორია.
7.
6.
5.
4.
არაფერი ხდება მოხდება, როდესაც ჩვენ მისაღებად 0.
3.
2.
1.
Okay.
0.
წაშალე.
>> ყველა უფლება.
ასე დაბრუნდნენ 0.
ასე რომ, ეს პროგრამა აშკარად აპირებს რა ძალიან
tediously ამტკიცებს, რომ აპირებს.
იგი აპირებს ბეჭდვა ყველა იმ
ღირებულებები, ზემოდან უნდა ბოლოში.
ნება მომეცით გააკეთებს გააკეთოს მარყუჟი.
ხოლო შემდეგ - whoops.
ჩადება loop.
მე ვიყავი არასწორი დირექტორია.
და ახლა ნება მომეცით აწარმოებს loop.
შეიყვანეთ.
Woohoo.
ძალიან ლამაზი.
Nice, ხანგრძლივი პროგრამა.
>> ყველა უფლება, მაგრამ ახლა მოდით ეს უკეთესი.
ისევე, Scratch, როცა გამოყენება დაიწყო looping
მშენებლობა, ნაცვლად მხოლოდ კოპირება და pasting ყველა
თავსატეხი ცალი, მინდა წარმოგიდგინოთ ამ რამ.
ასე რომ, C, არსებობს სხვადასხვა looping აშენებს,
რომელთაგან ერთი ასე გამოიყურება.
"ამისთვის" მარყუჟის აქვს სამი რამ, გამოყოფილი ორი semicolons.
და მაშინ, შიგნით ორგანო მარყუჟის, ასე ვთქვათ -
პერსონალის შიგნით Curly braces -
ჩვენ შეგვიძლია გავაკეთოთ რაღაც ისევ და ისევ.
მერე რა მე აქ ეკრანზე, ეს
სიტყვასიტყვით უბრალოდ კომენტარი.
/ / ნიშნავს აქ მოდის კომენტარი.
ეს არ არის კოდი.
ეს არის მხოლოდ ინგლისურ აღწერა, ჩემთვის, ადამიანის.
>> ამიტომ initializations, პირობები, და განახლება.
ისე, ვნახოთ, თუ როგორ ეს სამუშაოები.
ეს საშუალებას ჩემთვის გადაწერას ამ პროგრამის შემდეგნაირად.
იყიდება -
ამიტომ აქ მოდის ჩემი loop -
int i -
აქ მოდის ცვლადში "მე" -
იღებს ინიციალიზაცია დან 10.
ასე რომ არსებობს ჩემი ინიციალიზაციისას.
მინდა ამის გაკეთება მარყუჟი იმდენად რამდენადაც "მე" მეტია ან
ტოლია 0.
და თითოეულ iteration ამ მარყუჟის, მინდა
უნდა შევიდე -.
ამიტომ, ჩვენ ვნახეთ + + ორშაბათს.
- არის საპირისპირო.
ეს decrements ღირებულება 1.
შიგნით ამ მარყუჟის, მინდა რეალურად რაიმეს.
ამიტომ მე ვაპირებ ვთქვა რაღაც printf.
მე არ მინდა ვთქვა, 10 არის, რადგან ეს აშკარად მხოლოდ
აპირებს ბეჭდვა იგივე ღირებულება.
რა მინდა ბეჭდვა ნაცვლად, ალბათ?
Yeah.
ასე რომ "მე". ასე% d, i.
>> ამიტომ მე ვაპირებ მოიპაროს ერთი იმ იდეების ადრე -
ამ ჩანაცვლების ამისთვის ფორმატის კოდები -
და შემდეგ ქვევით აქ, ბოლოში, მე დაბრუნებას 0, უბრალოდ
კარგი ღონისძიება.
მაგრამ ახლა, მე უფრო ლაკონური პროგრამა.
ეს მხოლოდ რამდენიმე ხაზი, და არა რომელიმე 10 ან 11 ხაზები.
ნება მომეცით გადასვლა ჩემს სწრაფი ქვემოთ აქ.
რიმეიკი loop.
გამეორება loop.
და ეს, როგორც ჩანს, იგივე.
ახლა, პროგრამა არ უფრო საინტერესო.
მაგრამ ახლა შემიძლია აკრიფოთ მსგავსი რამ.
მე შეგიძლიათ შეცვალოთ ეს დან 100.
შემიძლია მაშინ recompile ჩემი პროგრამა.
და მერე შეიძლება ხელახლა აწარმოებს ჩემი პროგრამა.
და ახლა მიდის სუპერ სწრაფი დღევანდელ კომპიუტერები.
მაგრამ მე -
და ფაქტობრივად, ჩემი scrollback ბუფერულ არ
კი დადიან, რომ შორს.
იქ ჩვენ წავიდეთ.
ასე რომ, ჩვენ გვაქვს ყველა 100.
მაგრამ ადვილი რათა შეცდომები აქ.
რა იქნება მოსალოდნელი ქცევა თუ
შემთხვევით ეს?
ასე რომ იგრძნობა უსასრულო.
მოდით ვნახოთ, თუ კომპიუტერი იქცევა.
>> ნება მომეცით, წავიდეთ წინ და მიიღოს loop.
და მოდით ჩემთან აწარმოებს loop.
მოდით, დაუბრუნდეს, რომ სულ რაღაც მომენტში.
ჩვენ ნება, რომ აწარმოებს.
რადგან მთავარი, რაც უნდა ქონოდა მდე, მინიმალურად?
ალბათ მინიმუმ 2 მილიარდი, თუ გვაქვს, რომ ბევრი ბიტი, და
ჩვენ გამოყენებით დადებითი მნიშვნელობები.
მოდით ხტომა უკან აქ.
გარდა ამისა, ამგვარი მარყუჟების, ჩვენ გვაქვს რა ეწოდება, ხოლო
მარყუჟების. ასე რომ, ისევე, როგორც Scratch, გქონდათ სამუდამოდ
ბლოკები და გქონდათ გაიმეორეთ ბლოკები.
ანალოგიურად, დო, უბრალოდ აქვს სხვა გზები
გამოხატვის თავს.
ასე, რომ თქვენ ეს ცნება, ხოლო loop, რომელიც საშუალებას გაძლევთ
გამოხატოს თავის პატარა განსხვავებულად.
და მაშინ აქვს რაღაც მოუწოდა do-ხოლო მარყუჟის,
რომელიც მოქმედებს ოდნავ განსხვავებულად ისევე.
და ჩვენ აჯავრებენ ამ გარდა, დროთა განმავლობაში.
>> მაგრამ მოდით შევხედოთ ამ ბოლო ერთი აქ.
თუ ჩვენ წასვლას -
ჯერ კიდევ გაშვებული.
ეს საკმაოდ უსასრულო.
ნება მომეცით წასვლას დადებითი, და აჩვენებს როგორ შეგვიძლია რეალურად
არეგულირებს მომხმარებლის შეყვანის პატარა უფრო ეფექტურად.
ეს საკმაოდ მოკლე პროგრამა.
აქ ჩვენ გვაქვს, მთავარ, int n დეკლარაციას.
ასე რომ მომეცი ცვლადში n. ახლა, მე სიტყვასიტყვით ამბობენ
"ნუ". და შემდეგ მაქვს ღია Curly
გაუწიოს, მჭიდრო Curly გაუწიოს.
და მაშინ შეამჩნევს, შემდეგ, რომ, ის ამბობს, ხოლო n
ნაკლებია, ვიდრე 1.
ასე რომ ამ ხაზების -
19 დან 24 -
დაკომპლექტებას ერთობლივად do-ხოლო loop.
ისევ და ისევ, ახალი სინტაქსი, არ ახალი იდეა.
უბრალოდ სხვა გზა looping, syntactically.
ასე რომ რას გააკეთებს?
Do შემდეგი ხოლო N ნაკლებია, ვიდრე 1.
ასე რომ რა გსურთ?
მე მოვითხოვ რომ თქვენ მაძლევს დადებითი მთელი რიცხვი.
მერე რეალურად ცდილობენ მიიღონ მთელი რიცხვი საწყისი მომხმარებელს.
მაგრამ თვალსაზრისით ბრძანებით ოპერაციების აქ, რადგან
ხოლო პირობა არის ქვემოთ აქ, მე მაშინ აპირებს შეამოწმოს, არის N
ნაკლებია, ვიდრე 1?
ამიტომ ვარაუდობენ, რომ მომხმარებლის -
შემდეგ მოითხოვა ამ გზით -
ტიპების ღირებულების 0.
ეს მდგომარეობა იქნება ჭეშმარიტი ან მცდარი?
ისე, ეს რეალურად იქნება ჭეშმარიტი.
რადგან N არის 0 და 0 ნაკლებია, ვიდრე 1.
რას გვეუბნება, რომ გულისხმობს?
ამის გაკეთება კიდევ ერთხელ.
მხოლოდ ერთხელ, რომ მდგომარეობა აფასებს მცდარია.
თუ მე აკრიფოთ 42.
კარგად არა, 42 არის არანაკლებ 1.
ამიტომ ამ მარყუჟი კეთდება შესრულებაში.
და ა.შ. ამ დროს, პროგრამის იტყვის, მადლობა
42, ამ შემთხვევაში.
არის, რომ თქვენ გაქვთ ამ გზით გამოხატვის თავის -
ჩვენ არ უნდა დაველოდოთ ამ დასრულება.
იგი აპირებს გარკვეული დრო დაჭირდეს.
გაგრძელება იქნება მომავალში, ალბათ.
>> მაგრამ ახლა, თქვენ გაქვთ უნარი იმედია იმის გაგება
ცოტა GEEK იუმორი.
Apologies.
ეს არ არის წარმომადგენლობითი იუმორის წელს კომპიუტერულ მეცნიერებათა
მსოფლიოში, მაგრამ ეს cute.
[იცინის] მოდით დასრულდება, რომ შენიშვნა.
და ვნახავთ თქვენ ორშაბათს.
[ტაში]