>> [მუსიკის დაკვრა]
დევიდ ჯ Malan: ყველა უფლება.
ეს არის CS50, და ეს არის დაწყების კვირაში ორი.
ასე რომ, მოდით, დავიწყოთ დღეს შეცდომა.
Bug, რა თქმა უნდა, შეცდომა პროგრამა,
და თქვენ მიიღებთ ძალიან იცნობს ამ კონცეფცია
თუ თქვენ არ პროგრამირდება ადრე. pset0 და ახლა pset1.
მაგრამ მოდით განიხილავს რაიმე პატარა, მარტივი პირველი.
ამ პროგრამის, რომ მე ესროლა ერთად წინასწარ,
მე და აცხადებენ, რომ ეს უნდა ბეჭდვა 10 ვარსკვლავი ეკრანზე გამოყენებით printf,
მაგრამ ეს, როგორც ჩანს, buggy რამდენიმე გზა.
>> იმის გათვალისწინებით, რომ დაზუსტება, ეს უნდა ბეჭდვა 10 ვარსკვლავი,
მაგრამ ეს არ ჩანს, თუ რა რომ თქვენ აცხადებენ, რომ შეცდომის?
ჰო?
ასე რომ, ეს off ერთი შეცდომა, და რას ნიშნავს რომ?
OK.
შესანიშნავი.
ასე რომ, ჩვენ მითითებული დაიწყოს ღირებულება ნულს i,
და ჩვენ მითითებული n ღირებულება 10, მაგრამ ჩვენ გამოიყენება ნაკლები ან ტოლია.
და მიზეზი, რომ ეს არის ორი გმირები და არა მხოლოდ ერთი სიმბოლო,
ისევე როგორც მათემატიკის წიგნი, არის, რომ თქვენ არ გაქვთ
გზა გამოხატავს ერთი ხასიათი ექვივალენტი.
>> ასე რომ, რაც იმას ნიშნავს, ნაკლები, მაგრამ თუ დაიწყება დათვლის დროს ნულოვანი,
მაგრამ იმედი ყველა გზა მეშვეობით და შეადგენს 10,
თქვენ, რა თქმა უნდა აპირებენ იმედი 11 რამ შეადგენს.
და ასე რომ თქვენ აპირებს ბეჭდვა 11 ვარსკვლავი.
რა შეიძლება იყოს სარემონტო, ამ?
ჰო?
>> ასე რომ, უბრალოდ შეცვალოს ნაკლები ან ტოლია უბრალოდ იყოს ნაკლები,
და იქ, მე პრეტენზია, ალბათ, სხვა გამოსავალი, ძალიან.
რა შეიძლება დანარჩენი თქვენ?
ჰო?
>> ასე რომ დავიწყოთ რითაც მას 1 და დატოვება ნაკლები ან ტოლია.
და მე გულწრფელად აცხადებენ ის ფაქტი, რომ ტიპიური ადამიანის,
ეს, ალბათ, უფრო მარტივია.
დაიწყება დათვლის დროს 1 და იმედი მეშვეობით 10.
არსებითად გავაკეთოთ, რას ნიშნავს.
>> მაგრამ რეალობა არის პროგრამირების, როგორც ჩვენ ვნახეთ,
კომპიუტერის მეცნიერები და პროგრამისტები საერთოდ არ დაიწყება დათვლის დროს ნულოვანი.
და ისე, რომ ჯარიმა კიდევ თქვენ შეეგუება იგი.
თქვენი მდგომარეობა ზოგადად იყოს რაღაც ნაკლები.
ასე, უბრალოდ ლოგიკური შეცდომა, რომ ჩვენ შეგვიძლია ახლა
დაფიქსირება და საბოლოოდ გადააკომპილეთ ამ და კიდევ მხოლოდ 10.
>> ისევე როგორ ამ bug აქ?
აქ, ერთხელ, მე ვამტკიცებ, რომ მე არ მაქვს მიზანი ბეჭდვა 10 stars--
თითო ხაზი ამ დროს, მაგრამ ეს არ.
ადრე ჩვენ ვთავაზობთ რა სარემონტო არის, რას ნიშნავს ეს
ბეჭდვა ვიზუალურად თუ მე კომპილაციის და აწარმოებს ამ პროგრამის ფიქრობთ?
ჰო?
>> Star.
ასე რომ ყველა ვარსკვლავს იგივე ხაზი არის ის, რაც მე გავიგე,
და შემდეგ ახალი ხაზი ხასიათი.
მოდით ვეცადოთ, რომ.
ასე რომ buggy-1, შევა, და ვხედავ clang ბრძანება
რომ ჩვენ ვისაუბრეთ ბოლო დროს.
./buggy-1, და მართლაც, რომ ყველა 10 ვარსკვლავი იგივე ხაზი, მიუხედავად იმისა, რომ აცხადებენ,
ჩემი დაზუსტება მხოლოდ კომენტარი atop კოდი, რომელიც მე გაკეთებას აპირებს ერთ
ონლაინ.
მაგრამ ეს გამოიყურება უფლება.
>> ახლა line 15 როგორც ჩანს მე ვარ ბეჭდვის ვარსკვლავი, და შემდეგ ხაზი 16
ეს ჰგავს მე ბეჭდვა ახალი ხაზი ხასიათი,
და ისინი ორივე indented ასე მე შიგნით მარყუჟის ნათლად.
ასე რომ არ უნდა მე უნდა აკეთებს ვარსკვლავი, ახალი ხაზი, ვარსკვლავი, ახალი ხაზი, ვარსკვლავი, ახალი ხაზი?
დიახ?
>> ჰო, განსხვავებით ენა მოსწონს Python, თუ თქვენ იცნობს,
წანაცვლება არ მიუხედავად იმისა, რომ კომპიუტერი.
ეს მხოლოდ მნიშვნელოვანია, რომ ადამიანის.
ასე რომ, მაშინ აქ მე გამოიგონა ხაზები 15 და 16--, რომელიც გამოიყურება ლამაზი,
მაგრამ კომპიუტერი არ აინტერესებს.
კომპიუტერული ზრუნავს ფაქტობრივად, რომელსაც curly braces
დაახლოებით ამ ხაზების კოდი.
>> ისე, რომ ეს clear-- ისევე, როგორც Scratch--, რომ ეს ორი ხაზი კოდი
უნდა იყოს შესრულებული.
როგორც ერთი იმ ყვითელი Scratch თავსატეხი ცალი ისევ და ისევ და ისევ.
>> ახლა თუ ხელახლა აწარმოებს ამ პროგრამა ./buggy-2-- Hm.
მაქვს შეცდომა არის.
რა მე უნდა დაგვავიწყდეს?
ჰო, მე არ კომპილირება.
ასე რომ buggy-2.
ასეთი ფაილი რადგან მე არ რეალურად ადგენენ მეორე ვერსია.
ასე რომ, ახლა საინტერესო გამოუცხადებელი ცვლადი არა 2.
ვაკეთებთ 1.
რათა buggy-1-- ./buggy-1-- და ახლა თითოეული მათგანი ერთსა და იმავე ხაზზე.
>> ახლა არ არის გამონაკლისი ეს უნდა სარჩელი აფეთქდა
რომ თქვენ უნდა ამ Curly braces.
როდესაც სინამდვილეში ეს OK--, თუ თქვენ შენიშნა ნაწილში ან textbooks--
რომ გამომრჩეს Curly braces?
ჰო?
>> ზუსტად.
როდესაც არსებობს მხოლოდ ერთი ხაზი კოდი, რომ თქვენ
მინდა, რომ იყოს დაკავშირებული loop, როგორც ჩვენი პირველი მაგალითი.
ეს სავსებით ლეგიტიმური რომ გამომრჩეს Curly braces
ისევე როგორც ერთგვარი ფონდის საწყისი შემდგენელი თქვენ.
ჰო?
კარგი კითხვაა.
რომ ეს ჩაითვალოს სტილი შეცდომა?
ჩვენ გვინდა promote-- როგორც CS50 სტილის სახელმძღვანელო, URL, რომელიც
არის pset1--, რომ ყოველთვის გამოყენება Curly braces.
რა თქმა უნდა, თუ თქვენ ახალი პროგრამირების.
რეალობა ის არის, რომ ჩვენ არა ვართ აპირებს აუკრძალოს თქვენ
აკეთებს ეს კომფორტული.
მაგრამ თუ თქვენ მხოლოდ მიღების შევიდა swing რამ,
აბსოლუტურად უბრალოდ ვიყენებთ curly braces სანამ არ მიიღებთ HANG იგი.
კარგი კითხვაა.
>> ყველა უფლება.
ასე რომ მაშინ იყო შეცდომა.
მაინც რაღაც საკმაოდ მარტივია.
მაგრამ თქვენ ალბათ ფიქრობთ, ეს საკმაოდ rudimentary, არა?
ეს არის ერთგვარი პირველი კვირის ეძებს ენა
როგორიცაა, თქვენი შეცდომები მასში.
მაგრამ რეალობა ეს არის სინამდვილეში წარმომადგენელი
ზოგიერთი საკმაოდ საშიში პრობლემები , რომელიც შეიძლება წარმოიშვას რეალურ სამყაროში.
>> ასე რომ, ზოგიერთ თქვენგანს შეიძლება გავიხსენოთ თუ თქვენ დაიცვას ტექნიკური სიახლეები,
ან იქნებ კიდევ დაიჭირეს ქარი ამ წლის თებერვალში
ამ ბოლო ერთი წლის განმავლობაში, რომ Apple ჰქონდა გააკეთა ცოტა შეცდომა ორივე iOS,
ოპერაციული სისტემა ტელეფონის, და ასევე
Mac OS ოპერაციული სისტემა მათი კომპიუტერები და ლაპტოპები.
და დაინახა ასეთი სათაურები ამ.
და მას შემდეგ, Apple დაჰპირდნენ ამ bug,
და ძალიან სწრაფად გააკეთა დაფიქსირება ის iOS, მაგრამ მაშინ საბოლოოდ დაფიქსირდა ის Mac OS
ასევე.
>> ახლა, არც ამ სათაურების მარტო ნამდვილად გამოვლენა, თუ რა ძირითადი პრობლემა იყო,
მაგრამ ამ ხარვეზის საბოლოოდ შემცირდა ხარვეზის SSL, სოკეტების ფენის.
და მოკლედ, ეს არის პროგრამული უზრუნველყოფა
რომ ჩვენი ბრაუზერები და სხვა პროგრამული უზრუნველყოფა გამოიყენება, რა?
>> თუ ვთქვი, რომ SSL არის ჩართული, როდესაც თქვენ
ეწვევა URL, რომელიც იწყება HTTPS, მერე რა შეიძლება SSL იყოს დაკავშირებული?
შიფრაცია.
ასე რომ, ჩვენ ვსაუბრობთ ამ დღეებში.
შიფრაცია, ხელოვნების scrambling ინფორმაციას.
>> მაგრამ ხანგრძლივი ამბავი მოკლედ, Apple შუალედში წინ დაუშვა შეცდომა
მათი განხორციელების SSL, პროგრამული უზრუნველყოფა, რომელიც საბოლოოდ ახორციელებს
მისამართები, როგორიცაა HTTPS ან მაქს კავშირები არსებობს ძალიან.
შედეგად, რომელიც არის ის, რომ თქვენი კავშირები შესაძლოა
მოიპოვა.
და თქვენი კავშირები არ არის აუცილებელი, დაშიფრული
თუ გვქონდა ცუდი ბიჭი შორის თქვენ და დანიშნულების ნახვა, რომლებიც
იცოდა, თუ როგორ უნდა ისარგებლოს ამ.
>> ახლა Apple საბოლოოდ გამოქვეყნდა დაფიქსირება ამ ბოლოს,
და აღწერა მათი fix იყო ეს.
უსაფრთხო ტრანსპორტი ვერ შეამოწმოს ნამდვილობა დაკავშირებით.
საკითხი მიმართა მიერ აღდგენის დაკარგული დადასტურება ნაბიჯები.
>> ასე რომ, ეს არის ძალიან მხრივ wavy ახსნა უბრალოდ ვამბობ, რომ ჩვენ ბრალია.
არსებობს ფაქტიურად ერთი ხაზი კოდი, რომ იყო buggy
მათი განხორციელების SSL და თუ თქვენ წავიდეთ ონლაინ და ძიება ამ
თქვენ შეგიძლიათ რეალურად ორიგინალური წყარო კოდი.
მაგალითად, ეს არის ეკრანზე გადაღებული მხოლოდ ნაწილი საკმაოდ დიდი ფაილი,
მაგრამ ეს ფუნქცია აშკარად მოუწოდა SSL გადამოწმების ნიშანი სერვერზე გასაღები გაცვლა.
და ეს ხდება რამოდენიმე არგუმენტები და საშუალებებით.
და ჩვენ არ ვაპირებთ ფოკუსირება ძალიან ბევრი minutia არსებობს,
მაგრამ თუ თქვენ ფოკუსირება კოდი შიგნით რომ უმაღლეს ფუნქცია მოდით
მიუახლოვდით რომ.
თქვენ ალბათ უკვე ეჭვი რა შეცდომა შეიძლება
იქნება მაშინაც კი, თუ თქვენ არ ვიცი საბოლოო ჯამში, რაც თქვენ ეძებთ.
არსებობს სახის ანომალია აქ, რა?
>> ჰო, მე ნამდვილად არ მინდა სახე ორი goto ვერ.
გულწრფელად ვამბობ, მე არ ვიცი, რა goto ვერ საშუალება, მაგრამ აქვთ ორი მათგანი
უკან დაბრუნება.
რომ მხოლოდ სახის rubs me ინტელექტუალურად არასწორი გზა,
და მართლაც, თუ ჩვენ მიუახლოვდით მხოლოდ იმ ხაზები, ეს არის C.
>> ასე, რომ ბევრი Apple კოდექსი თავისთავად დაწერილი C,
როგორც ჩანს, მართლაც equivalent--
არ არის, რომ ლამაზია წანაცვლება ვერსია, მაგრამ თუ აღიარებთ თუ არა,
რომ არ არსებობს curly braces, რა Apple ნამდვილად დაწერა კოდი, რომელიც გამოიყურება
მოსწონს ეს.
ასე რომ, მე zoomed out და მე ფიქსირებული წანაცვლება იმ გაგებით,
იმ შემთხვევაში, თუ არ არსებობს curly აფრთხილებს, რომ მეორე goto ვერ, რომ არის ყვითელი
აპირებს შეასრულოს არა აქვს მნიშვნელობა რა.
ის არ ასოცირდება თუ მდგომარეობა ზემოთ.
>> ისე კი, კიდევ ერთხელ, თუ თქვენ არ საკმაოდ მესმის რა ამ, შესაძლოა,
ვაკეთებთ, ვიცით, რომ თითოეული ამ conditions-- თითოეულ ამ ხაზები
არის ძალიან მნიშვნელოვანი ნაბიჯი, in გადამოწმების პროცესს
თუ თქვენი მონაცემები, ფაქტობრივად, დაშიფრული.
ასე რომ, skipping ერთი ასეთი ნაბიჯები, არ საუკეთესო იდეა.
>> არამედ იმიტომ, რომ ჩვენ გვაქვს ეს მეორე goto ვერ ​​ყვითელი,
და რადგან, როდესაც ჩვენ სახის ესთეტიურად
გადატანა მარცხენა, სადაც იგი ლოგიკურად არის იმ მომენტში, რა
ნიშნავს ეს ხაზი კოდი ქვემოთ რომ მეორე goto
ვერ ვფიქრობ?
ის ყოველთვის იქნება გამოტოვებენ.
ასე gotos ზოგადად მიუღებელი იყო მიზეზების გამო, ჩვენ ნამდვილად არ წასვლას,
და მართლაც CS50, ჩვენ, როგორც წესი, არ ასწავლოს ამ განცხადებას goto,
მაგრამ შეგიძლიათ წარმოიდგინოთ, goto ვერ აზრი წასვლა ხტომა
ზოგიერთი სხვა ნაწილი კოდი.
>> სხვა სიტყვებით ნახტომი მეტი ამ ბოლო ხაზის საერთოდ,
და ა.შ. შედეგად ეს სულელური მარტივი შეცდომა, რომ მხოლოდ
შედეგი ალბათ ადამიანი, გადაწერა და pasting ერთი ძალიან
ბევრჯერ იყო, რომ მთელი უსაფრთხოების iOS და Mac OS
იყო დაუცველი თვალთვალი ცუდი ბიჭები საკმაოდ გარკვეული დრო.
სანამ Apple საბოლოოდ დაფიქსირდა ამ.
>> ახლა, თუ ზოგიერთი თქვენ რეალურად გაშვებული ძველი ვერსიები iOS და Mac OS,
შეგიძლიათ წასვლა gotofail.com რომელიც არის ნახვა, რომ ვინმე შეიქმნა
არსებითად განსაზღვრავს პროგრამულად
თუ თქვენს კომპიუტერში ჯერ კიდევ დაუცველი.
და გულწრფელად, თუ ეს, ეს ალბათ კარგი იდეა
განახლება თქვენი ტელეფონი ან თქვენი Mac ამ ეტაპზე.
მაგრამ, მხოლოდ პატივისცემის რამდენად მადლიერება ამ ქვედა დონის
დეტალები და სამართლიანად მარტივი იდეები ნამდვილად
გარდაქმნა გადაწყვეტილებები და პრობლემები, რომელიც
affected-- ამ შემთხვევაში მილიონობით ადამიანი.
>> ახლა სიტყვა ადმინისტრაციას.
სექციაში დაიწყება მომავალი კვირა.
თქვენ მიიღებთ ელ მიერ weekend შესახებ განყოფილებიანი, რომელსაც წერტილი
resectioning პროცესი დაიწყება, თუ თქვენ
მიხვდა, თქვენ ახლა აქვს ზოგიერთი ახალი კონფლიქტები.
ასე რომ, ეს ხდება ყოველ წელს, და ჩვენ განთავსდება იმ დღეებში.
>> საოფისე hours-- შენარჩუნება თვალის გრაფიკი აქ.
ცვლის ცოტა ამ კვირაში, განსაკუთრებით დაწყების დრო
და ადგილმდებარეობა, ასე რომ კონსულტაციები რომ ადრე სასაქონლო საათებში
ნებისმიერი მომდევნო ოთხი ღამე.
და ახლა სიტყვა შეფასებით, კერძოდ, როგორც თქვენ ჩაყვინთვის შევიდა პრობლემა
ადგენს ერთი და მის ფარგლებს გარეთ.
>> ასე რომ, per დაზუსტება, ეს ზოგადად
ცულები ერთად, რომელიც ჩვენ შეაფასოს თქვენი სამუშაო.
სფერო ეხება რა რამდენად თქვენი კოდი იარაღები
თვისებები საჭირო ჩვენი დაზუსტება.
სხვა სიტყვებით, თუ რამდენად ცალი კომპლექტი გააკეთა თქვენ bite off.
ის, რომ თქვენ მესამედი, ამის ნახევარი, 100% იგი.
მაშინაც კი, თუ ეს არ არის სწორი, რამდენად არ ცდილობენ?
ასე რომ იღებს დონე ძალისხმევა და ოდენობით
რომელიც თქვენ ცოტა off პრობლემა კომპლექტი პრობლემები.
>> Correctness-- ამ ერთი, რამდენად არის თქვენი კოდი
შეესაბამება ჩვენი სპეციფიკაციები და უფასო შეცდომები.
ასე რომ არ მუშაობს სწორად?
თუ ვაძლევთ მას გარკვეული შეყვანის, იგი მოგვცეს გამომავალი რომ უნდა ველოდოთ?
Design-- ახლა ეს არის პირველი განსაკუთრებით ხარისხობრივი პირობა,
ან პირობა, რომ საჭიროებს ადამიანის გადაწყვეტილება.
და მართლაც, სწორედ ამიტომ ჩვენ გვყავს პერსონალი ამდენი სწავლების პრაქტიკის და რა თქმა უნდა,
თანაშემწეები.
რამდენად თქვენი კოდი წერილობითი კარგად?
>> და ისევ, ეს არის ძალიან თვისებრივი შეფასება
რომელიც თქვენთან ერთად bi-directionally კვირის მოდის.
ასე რომ, როდესაც თქვენ არ მხოლოდ რიცხვითი ქულა, არამედ
წერილობითი ქულა, ანუ აკრეფილი კავშირი, ან წერილობითი კავშირი ინგლისური სიტყვა.
ის, რაც ჩვენ ვიყენებთ მართოს მიმართ რეალურად წერა უკეთესი კოდი.
და ლექცია და მე, ჩვენ შევეცდებით უნდა აღვნიშნო, აღმოჩნდა, როგორც ხშირად, როგორც ჩვენ can--
რას აკეთებს პროგრამა არა მარტო სწორი და ფუნქციურად კარგი,
არამედ კარგად შემუშავებული.
ყველაზე ეფექტური შეიძლება იყოს, ან მაშინაც კი, ყველაზე ლამაზი ეს შეიძლება იყოს.
>> რომელსაც მივყავართ სტილი.
სტილი საბოლოოდ არის ესთეტიკური გადაწყვეტილება.
არ აირჩიოთ კარგი სახელები თქვენი ცვლადები?
არ თქვენ indented თქვენი კოდი სწორად?
გამოიყურება კარგი, და, შესაბამისად, არის ადვილი სხვა ადამიანის
წავიკითხე თქვენი შესაბამისი მისი სისწორე.
>> ახლა ზოგადად პოსტი სილაბუსი, ჩვენ ანგარიშით, ეს ყველაფერი ხუთბალიან შკალაზე.
და ნება მომეცით hammer საწყისი წერტილი რომ სამი არის მართლაც კარგი იყო.
ძალიან სწრაფად გააკეთოს ეგ დაიწყოს აკეთებს არითმეტიკული.
როდესაც ისინი სამი ხუთ სისწორე ზოგიერთი pset
და მიაჩნიათ რა, მე ვაპირებ 60% რომელიც არსებითად D ან E.
>> ეს არ არის გზა ჩვენ ვფიქრობ, ამ ნომრებზე.
სამი კარგია, და რა ვარაუდობს დასაწყისში
ტერმინი არის, რომ თუ თქვენ მიღების რამოდენიმე three's-- შესაძლოა რამდენიმე
ბაზრობები, რამდენიმე fours-- ან რამდენიმე twos, რამდენიმე fours--
რომ კარგი ადგილი უნდა დაიწყოს.
ასე რომ, სანამ ჩვენ ვხედავთ აღმასვლაა დროთა განმავლობაში,
თქვენ განსაკუთრებით კარგი ადგილი.
>> ფორმულა ჩვენ ვიყენებთ წონა რამ არის არსებითად
ეს პოსტი სილაბუსი, რაც მხოლოდ იმას ნიშნავს, რომ ჩვენ
უფრო მეტი წონა სისწორე.
იმიტომ რომ ძალიან ხშირად სისწორის რომელიც იღებს საუკეთესო დრო.
მერწმუნეთ, ახლა.
თქვენ find-- მინიმუმ ერთ pset--, რომ თქვენ
დახარჯავს 90% თქვენი დრო მუშაობს 10% პრობლემა.
>> და ყველაფერი სახის სამუშაოები გარდა ერთი ან ორი შეცდომები,
და ეს ის შეცდომები, შენარჩუნება თქვენ გვიან ღამით.
ეს არის პირობა, რომ სახის გაქცევა თქვენ.
მაგრამ შემდეგ საძილე მას, ან დამსწრე ოფისში საათი
ან სვამს კითხვებს შემოსული, როდესაც თქვენ, რომ 100% გოლი,
და სწორედ ამიტომ წონა სისწორის საუკეთესო.
დიზაინი ცოტა ნაკლები, და სტილი ცოტა ნაკლებია.
მაგრამ შენარჩუნება mind-- სტილი ალბათ იოლი
ეს იმისათვის, რომ bite off თითო სტილის სახელმძღვანელო.
>> და ახლა, უფრო სერიოზული შენიშვნა აკადემიური პატიოსნება.
CS50 აქვს სამწუხარო განსხვავება უმსხვილესი პროდიუსერი Ad Board
შემთხვევები თითქმის ყოველ წელს ისტორიულად.
ეს იმიტომ არა, სტუდენტები მოტყუებას CS50 რაიმე უფრო ვიდრე რომელიმე სხვა კლასი,
არამედ იმიტომ, რომ ბუნების მუშაობა, ის ფაქტი, რომ ეს ელექტრონული,
ის ფაქტი, რომ ჩვენ ვეძებთ, და ის ფაქტი, რომ ჩვენ ვართ კომპიუტერი მეცნიერები,
შემიძლია ვთქვა, რომ ჩვენ, სამწუხაროდ, ძალიან კარგად გამოვლენის იგი.
>> ასე რომ, რას ნიშნავს ეს რეალური თვალსაზრისით?
ასე რომ, პოსტი სილაბუსი, რა თქმა უნდა, ფილოსოფია
მართლაც, boil ქვემოთ იყოს გონივრული.
არსებობს ამ ხაზს შორის აკეთებს ერთი ნამუშევარი საკუთარ
და მიღების ცოტა გონივრული დახმარებით მეგობარს,
და აშკარა აკეთებს, რომ მუშაობა თქვენი მეგობარს, ან გაგზავნის მას თქვენი კოდი
ისე, რომ მას შეუძლია უბრალოდ მიიღოს ან სესხის out უფლება.
და რომ კვეთს ხაზი ჩვენ შედგენილი კლასში.
>> ვხედავ, სილაბუსი საბოლოო ჯამში ხაზები
რომ ჩვენ მიაპყროს როგორც გონივრული და უაზრო ქცევა,
მაგრამ ეს ნამდვილად არ boil ქვემოთ არსი
თქვენი სამუშაო სჭირდება იყოს თქვენი ბოლომდე.
ახლა რომ თქვა, არის ევრისტიკული.
იმის გამო, რომ, როგორც თქვენ ალბათ imagine-- ოფისში საათი და ვიზუალური
და ვიდეო ჩვენ ნაჩვენებია ამით far-- CS50
მართლაც ნიშნავდა, რომ იყოს როგორც ერთობლივი და კოოპერატივის და როგორც სოციალური
რაც შეიძლება.
როგორც ერთობლივი, როგორც ეს არის მკაცრი.
>> მაგრამ ეს განაცხადა, ევრისტიკული, როგორც თქვენ იხილეთ სილაბუსი,
ის არის, რომ როდესაც თქვენ მქონე ზოგიერთი პრობლემა.
თქვენ გაქვთ რამდენიმე bug თქვენს კოდი, რომ თქვენ არ შეგვიძლია, მიზანშეწონილია, რომ თქვენ
რათა ნახოთ თქვენი კოდი ვინმეს.
მეგობარი კი კლასში მეგობარს სხდომაზე შემდეგ თქვენ ოფისში საათის,
ან თანამშრომლის.
მაგრამ ისინი არ შეიძლება ნახოთ მათი კოდი, რომ თქვენ.
>> სხვა სიტყვებით, პასუხი თქვენს question--
მე უნდა help-- არ oh, აქ არის ჩემი კოდი.
შევხედოთ ამ და დავასკვნათ მისგან რას.
ახლა, რა თქმა უნდა, არსებობს ისე ნათლად სათამაშო
ეს სისტემა, რომლის დროსაც მე გაჩვენებთ ჩემი კოდი ადრე მქონე კითხვა.
თქვენ მაჩვენოთ ჩემი თქვენი კოდი ადრე მქონე კითხვა.
მაგრამ ვხედავ სილაბუსი ერთხელ finer დეტალები, სადაც ამ ხაზის.
>> მხოლოდ ახლა ხატავს სურათზე და გაზიარება გამჭვირვალედ, რაც შეიძლება
სადაც ჩვენ ვართ, უკანასკნელ წლებში, ეს არის ნომერი Ad Board შემთხვევაში
რომ CS50 ზე მეტი ბოლო შვიდი წლის განმავლობაში.
14 შემთხვევაში ამ უკანასკნელ შემოდგომაზე.
თვალსაზრისით სტუდენტები ჩართული, ეს იყო 20 რაღაც უცნაური სტუდენტები
გასულ შემოდგომაზე.
იყო პიკი 33 სტუდენტები რამდენიმე წლის წინ.
ბევრი მათგანი, სამწუხაროდ, აღარ აქ კამპუსში.
>> სტუდენტები ჩართული როგორც პროცენტული კლასი ისტორიულად მერყეობდა 0%
5.3%, რომელიც მხოლოდ იმის თქმა, ეს არის ყოველწლიურად გამოწვევა.
და მიმართ, რომ საბოლოო ჯამში, რა ჩვენ გვინდა გადმოცემა, ერთი
ჩვენ dd-- მხოლოდ FYI-- შევადარებთ სამართლიანობა იმ სტუდენტებს, რომლებმაც
მიყვება ხაზი შესაბამისად.
ჩვენ ამას ვაკეთებთ, შევადარებთ ყველა მიმდინარე წარდგინება წინააღმდეგ ყველა წარსული მისიები
წარსულში მრავალი წლის განმავლობაში.
>> ჩვენ ვიცით ძალიან, როგორ Google გარშემო და კოდი საცავებში
ონლაინ სადისკუსიო ფორუმები ამჟამად, სამუშაო საიტები ონლაინ.
თუ სტუდენტს შეუძლია იპოვოს ის, ჩვენ შეგვიძლია დაბეჯითებით ამას, როგორც ჩვენ, სამწუხაროდ, ამის გაკეთება.
ასე რომ, რა დაინახავთ სილაბუსი თუმცა ეს სინანული სტატიაზე.
მე, რა თქმა ვაფასებთ, და ჩვენ ყველა აქვს
პერსონალი, რაც გაკეთდა, რა თქმა უნდა, როგორც , ან ეს თავად დროთა განმავლობაში,
რა თქმა უნდა ვიცი, თუ რას ჰგავს, როდესაც ცხოვრებაში იღებს გზა, როდესაც თქვენ გაქვთ
ზოგიერთი გვიან ღამით deadline-- არა მარტო ამ კლასში,
მაგრამ another--, როდესაც თქვენ სრულიად ამოწურულია, ხაზი გაუსვა,
აქვს მათდამი ნომერი სხვა რამ უნდა გააკეთოს.
გააკეთე რაღაც მომენტში ცხოვრება, მართლაც ცუდი, ალბათ, გვიან
ღამის გადაწყვეტილება.
>> ასე რომ პოსტი სილაბუსი, არსებობს ამ სტატიაზე,
ასეთი, რომ თუ 72 საათის განმავლობაში მიღების ზოგიერთი ცუდი გადაწყვეტილება, თქვენ ფლობდეს მდე
და მივაწვდინოთ ჩემთვის და ერთი კურსის ხელმძღვანელები
და გვექნება საუბარი.
ჩვენ გაუმკლავდეს ყველაფერი იძულებით იმედები
ეს ხდება უფრო სწავლების მომენტში ან ცხოვრების გაკვეთილი,
და არა რაღაც განსაკუთრებით მკვეთრი ramifications
როგორც თქვენ ალბათ ნახე ეს სქემები აქ.
>> ასე რომ, ძალიან სერიოზული ტონი.
მოდით შევჩერდეთ მხოლოდ რამდენიმე წამი შესვენება დაძაბულობა.
>> [მუსიკის დაკვრა]
>> დევიდ ჯ Malan: ყველა უფლება, ასე რომ, როგორ იყო, რომ segue?
დღეს პირველადი თემები.
რომელთაგან პირველი არის აბსტრაქცია.
კიდევ ერთი, რაც უნდა იყოს წარმომადგენლობა მონაცემები, რომელიც გულწრფელად
არის ძალიან მშრალი გზა ამბობდა როგორ შეგვიძლია წასვლა პრობლემა და აზროვნების
პრობლემა?
ასე რომ თქვენ ვნახეთ Scratch, და თქვენ ჩანს, ალბათ, უკვე pset1 დავუკავშირდეთ C
რომ თქვენ არა მხოლოდ შეგიძლიათ გამოიყენოთ ფუნქციები, როგორიცაა printf,
რომ სხვა ხალხი წლის წარსული დაწერა თქვენთვის.
ასევე შეგიძლიათ დაწეროთ ფუნქციები.
>> და მიუხედავად იმისა, რომ თქვენ შეიძლება არ აქვს გაკეთდეს ამ C და გულწრფელად in pset1
თქვენ ნამდვილად არ უნდა დაწეროთ თქვენი საკუთარი ფუნქცია, რადგან problem--
ალბათ, daunting at პირველი glance-- დაინახავთ
საბოლოოდ გადაიჭრება არ არის, რომ ბევრი ხაზები კოდი.
მაგრამ რომ თქვა, იმ თვალსაზრისით, წერა თქვენი საკუთარი ფუნქცია,
გააცნობიეროს, რომ C არ მისცეს თქვენ ამ შესაძლებლობებს.
>> მე ვაპირებ წასვლა დღევანდელი კოდის, რომელიც ხელმისაწვდომია უკვე შემოსული,
და მე ვაპირებ წავიდეთ წინ და გახსნა up პროგრამა მოუწოდა ფუნქცია 0.C,
და ფუნქცია zero ჩვენ დავინახავთ, რამდენიმე რამ.
პირველი ხაზები 18 გზით 23 არის ჩემი მთავარი ფუნქცია.
და ახლა, რომ ჩვენ დაწყებული წაკითხული კოდი, რომელიც ჩვენ არ წერს on the fly,
მაგრამ ნაცვლად მე დაწერილი წინასწარ ან, რომ თქვენ პრობლემა კომპლექტი
შესაძლოა, მიიღოს მქონე დაწერილი წინასწარ.
კარგი გზა, რათა დაიწყოს კითხულობს სხვისი კოდი
გამოიყურება ძირითადი ფუნქცია.
გაერკვნენ, სადაც რომ ჩანაწერი საქმე იმაშია, რომ გაშვებული პროგრამა,
და შემდეგ ის ლოგიკურად იქიდან.
>> ასე რომ, ეს პროგრამა აშკარად ბეჭდავს სახელი მოჰყვა მსხვილი ნაწლავის.
ჩვენ მაშინ გამოიყენოს GetString CS50 ბიბლიოთეკა
მიიღოს სიმებიანი, სიტყვა ან ფრაზა მომხმარებელს კლავიატურაზე.
და მერე ეს რაც აქ PrintName.
>> ახლა PrintName არ არის ფუნქცია, რომელიც გააჩნია C.
ეს არ არის სტანდარტული io.h.
ეს არ cs50.h.
ეს საკმაოდ იგივე ფაილი.
ყურადღება მიაქციეთ, თუ მე გადახვევა ქვემოთ bit-- ხაზები 25 to 27--
უბრალოდ საკმაოდ გზა კომენტირებისას თქვენი კოდი გამოყენებით ვარსკვლავი და დახრილ ხაზებს.
ეს არის multi-line კომენტარი, და ეს მხოლოდ
ჩემი აღწერილობა ლურჯი რა ეს ფუნქცია აქვს.
>> იმის გამო, რომ ხაზები 28 გზით 31, მე დაწერილი სუპერ მარტივი ფუნქცია
რომლის სახელიც PrintName.
იგი იღებს, რამდენი არგუმენტები იტყვით?
ასე რომ, ერთი არგუმენტი, რადგან იქ ერთი არგუმენტი ჩამოთვლილი შიგნით ფრჩხილებში.
ტიპის, რომელიც სიმებიანი.
რაც უნდა ითქვას, PrintName ჰგავს ეს შავი ყუთი
ან ფუნქცია, რომელიც იღებს როგორც შეყვანის სიმებიანი.
>> და სახელი, რომ String მოხერხებულად იქნება სახელი.
არ S, არა N, მაგრამ სახელი.
ასე რომ, რას PrintName გავაკეთოთ?
ეს არის ლამაზი მარტივი.
უბრალოდ, როგორც ერთი ხაზი კოდი printf, მაგრამ როგორც ჩანს ეს
ბეჭდავს out "Hello", ასე და ასე.
სადაც ასე და ასე მოდის არგუმენტი.
>> ახლა ეს არ არის დიდი ინოვაცია აქ.
მართლაც, მე მიღებული პროგრამა, რომელიც შეიძლება უკვე დაწერილი ერთი ხაზი კოდი
აყენებს ამ აქ, და შეიცვალა მას რაღაც
რომელიც მოიცავს დაახლოებით ექვსი ან შვიდი ან იმდენად ხაზების კოდი, ყველა გზა ქვემოთ აქ.
>> მაგრამ პრაქტიკოსი პრინციპი ცნობილია, როგორც აბსტრაქცია.
სახის encapsulating შიგნით ახალი ფუნქცია, რომელიც აქვს სახელი, და უკეთესი
ჯერ კიდევ, რომ სახელი სიტყვასიტყვით ამბობს, თუ რას აკეთებს.
ვგულისხმობ printf--, რომ არ განსაკუთრებით აღწერითი.
თუ მინდა, რომ შევქმნათ თავსატეხი ცალი, ან თუ
გვინდა, რომ შევქმნათ ფუნქცია ბეჭდავს რომ ვინმეს სახელი,
სილამაზის ამით არის, რომ მე შეიძლება რეალურად
მისცეს, რომ ფუნქციის სახელი , რომელიც ასახავს, ​​თუ რას აკეთებს.
>> ახლა იგი იღებს შეყვანის რომ მე თვითნებურად მოუწოდა სახელი,
მაგრამ ეს ძალიან შესანიშნავად აღწერითი ნაცვლად იმისა, რომ ცოტა მეტი
generic როგორიცაა S. And ბათილად, ახლა, მხოლოდ იმას ნიშნავს,
რომ ეს ფუნქცია არ ხელით უკან არაფერი.
ეს იმას არ ნიშნავს, რომ GetString ფაქტიურად ხელები ჩემს უკან სიმებიანი
ისე, როგორც ქაღალდი, თქვენი თანაკლასელები გასულ კვირას,
არამედ, ეს უბრალოდ აქვს გვერდითი ეფექტი.
იგი ბეჭდავს რაღაც ეკრანზე.
>> ასე რომ, დღის ბოლომდე, თუ მე არ მიიღოს ფუნქცია 0, ./function-0,
ჩვენ ვხედავთ, რომ იგი სთხოვს ჩემი სახელი.
მე აკრიფოთ დავით, და ეს სახის ჩემი სახელი.
თუ ამის გაკეთება კვლავ რობ ის აპირებს, რომ ვთქვათ "Hello, რობ".
ასე რომ მარტივი იდეა, მაგრამ, ალბათ, განზოგადების ამ გონებრივად
რომ როგორც თქვენი პროგრამების ცოტა უფრო რთული,
და გსურთ დაწეროთ ბლოკი კოდი და შეატყობინეს, რომ code-- Invoke
რომ code-- ზოგიერთი აღწერითი სახელი, როგორიცაა PrintName,
C არ მივცემთ ჩვენს ამ შესაძლებლობებს.
>> აქ არის კიდევ ერთი მარტივი მაგალითი.
მაგალითად, თუ გახსნა ფაილის მოუწოდა return.c,
შეამჩნია რა მე ვაკეთებ აქ.
ყველაზე მეტად ეს მთავარი ფუნქცია printf.
მე პირველად თვითნებურად ინიციალიზაცია ცვლადში x რომ ნომერი 2.
მე მაშინ ამობეჭდოთ "x არის % I "გავლით ღირებულება x.
ასე რომ, მე უბრალოდ ვამბობ, რა არის.
>> ახლა მე უბრალოდ თამამად ამტკიცებენ, printf.
მე cubing რომ ღირებულება x, და მე ამით მოუწოდებენ ფუნქცია
მოუწოდა კუბი მიღება in x არგუმენტი,
და შემდეგ გადარჩენა გამომავალი ცვლადი თავად x.
ასე რომ, მე clobbering ღირებულება x.
მე უმთავრესი ღირებულება x, რასაც
შედეგი მოუწოდებს ამ კუბი ფუნქცია.
და მერე უბრალოდ ამობეჭდოთ გარკვეული fluffy პერსონალის აქ ამბობს იმას, რაც გავაკეთე.
>> მერე რა მაშინ არის cube?
ყურადღება მიაქციეთ, რა ფუნდამენტურად განსხვავებული აქ.
მე მოცემული ფუნქცია სახელი, როგორც ადრე.
მე მითითებული სახელი არგუმენტი.
ამ დროს იგი ე.წ. n ნაცვლად სახელი, მაგრამ მე ვერ ეძახით არაფერი მინდა.
მაგრამ ეს არის სხვადასხვა.
ეს რამ მარცხენა.
ადრე ეს იყო ის, რაც სიტყვით?
ბიჭები.
ახლა აშკარად int.
>> ასე რომ, რა ალბათ წართმევას?
, ხოლო ბათილად ნიშნავს სახის დარჩენილი, რომ ეს იყო საქმე.
PrintName დაბრუნდა არაფერი.
ეს მოხდა რაღაც, მაგრამ ეს არ გადასცემს ჩემს უკან
რაღაც რომ მე ვერ ჩაიცვი მარცხენა მხარეს თანაბარი ნიშანი
ისევე, როგორც მე ვაკეთებ აქ on line 22.
>> ასე რომ, თუ მე ვიტყვი, შევიდა on line 30, რა არის ეს, ალბათ, რაც გულისხმობს,
იმაზე, თუ რა cube აკეთებს ჩემთვის?
ჰო?
ის დააბრუნებს რიცხვი.
ასე რომ ხელები ჩემს უკან, რადგან მაგალითად, ქაღალდზე
, რომელიც მას წერილობითი პასუხი.
2 cubed, ან 3 cubed, ან 4 cubed-- რასაც მე მიიღო,
და რა მე განახორციელოს ეს?
ისევე, N ჯერ N ჯერ N აი როგორ შეიძლება კუბი ღირებულება.
ასე რომ კიდევ ერთხელ, სუპერ მარტივი იდეა, მაგრამ საჩვენებელ
ახლა როგორ შეგვიძლია ჩაწერის ფუნქცია რომ შეეძლოთ უკან დაბრუნება
ღირებულებები, რომლებიც შეიძლება საინტერესო იყოს.
>> მოდით შევხედოთ ერთი ბოლო მაგალითია აქ მოუწოდა ფუნქცია ერთი.
ამ მაგალითში, იგი იწყებს მიიღოს უფრო მყარი.
ასე რომ, ამ ფუნქციას ერთი, ეს პროგრამა ცნობა საბოლოოდ
მოუწოდებს ფუნქცია მოუწოდა GetPositiveInt.
GetPositiveInt არ არის ფუნქცია CS50 ბიბლიოთეკა,
მაგრამ ჩვენ გადავწყვიტეთ, რომ ჩვენ მინდა უნდა არსებობდეს.
>> ასე რომ, თუ ჩვენ გადახვევა ქვემოთ შემდეგ ფაილი, შეამჩნევთ, თუ როგორ მივედი შესახებ ახორციელებს
დადებითი int, და მე ამბობენ, რომ ეს უფრო მყარი
იმიტომ, რომ ეს არის ღირსეული ნომერი ხაზების კოდი.
ეს არ არის მხოლოდ სულელური პატარა სათამაშო პროგრამა.
ის, ფაქტობრივად, მიიღო რაიმე შეცდომა შემოწმებისას და აკეთებს რაღაც უფრო სასარგებლო.
>> ასე რომ, თუ თქვენ არ მინახავს walkthrough ვიდეო, რომ ჩვენ ჩართული pset1,
ვიცით, რომ ამ ტიპის loop in C, იგივე სულისკვეთებით,
რომ სახის რამ Scratch შეუძლია გააკეთოს.
და ნუ ამბობს ამის გაკეთება.
ბეჭდვა ამ.
მაშინ წავიდეთ წინ და მიიღოს N-- კიდევ int და ჩაწეროთ იგი n,
და აკეთეთ ეს კიდევ ერთხელ და ისევ და ერთხელ, იმდენად, რამდენადაც n ნაკლებია, ვიდრე ერთი.
>> ასე რომ, ო იქნება არანაკლებ ერთი მხოლოდ იმ შემთხვევაში, თუ ადამიანის არ თანამშრომლობს.
თუ იგი აკრეფის 0 ან -1 ან -50,
ამ loop აპირებს შენარჩუნება შესრულებაში ისევ და ისევ.
და საბოლოოდ შეამჩნია, I უბრალოდ დაბრუნების ღირებულება.
ასე რომ, ახლა ჩვენ გვაქვს ფუნქცია რომ უკვე ლამაზი
თუ CS50, რომ განახორციელებს CS50.h და CS50.c თქვენ,
მაგრამ აქ ჩვენ ახლა განახორციელოს ამ თავს.
>> მაგრამ ორი კომენტარები რამოდენიმე ძირითადი დეტალები.
One-- რატომ ვაცხადებ int n, როგორ ფიქრობთ, on line 29
ნაცვლად მხოლოდ აკეთებს ეს აქ,
უფრო შეესაბამება რაც ჩვენ გავაკეთეთ გასულ კვირას?
ჰო?
კარგი აზრის.
ასე რომ, თუ ჩვენ დააყენოს ის აქ, ეს თითქოს ჩვენ
შენარჩუნება გამოცხადების ეს ისევ და ისევ.
რომ და თავისთავად არა პრობლემატური, თავისთავად,
იმიტომ, რომ ჩვენ მხოლოდ უნდა ღირებულება, და შემდეგ
ჩვენ ვაპირებთ, რომ მიიღოთ ახალი მაინც.
მაგრამ კარგი აზრის.
ჰო?
>> ახლოს.
ასე რომ, იმიტომ, რომ მე განაცხადა N on ონლაინ 29 გარეთ მარყუჟის,
ეს ხელმისაწვდომია მთელი მთელი ამ ფუნქციას.
არა სხვა ფუნქციები, რადგან n კვლავ შიგნით ამ Curly
braces აქ.
So-- დარწმუნებული ვარ.
>> ზუსტად.
ასე რომ, ეს კიდევ უფრო წერტილი.
თუ ჩვენ ნაცვლად განაცხადა, n სწორედ აქ on line 32,
ეს პრობლემატურია, რადგან ვხვდები სად სხვაგან მე უნდა მიუწვდომელი?
On line 34, მარტივი წესი thumb არის
რომ თქვენ შეგიძლიათ მხოლოდ გამოიყენოს ცვალებად შიგნით უახლესი Curly braces
რომელშიც თქვენ გამოაცხადა.
>> სამწუხაროდ, ხაზი 34 არის ერთი ხაზი ძალიან გვიან,
იმიტომ, რომ მე უკვე დაიხურა Curly გაუწიოს on line 33
რომელიც შეესაბამება Curly გაუწიოს on line 30.
და ეს არის გზა რომ რომ ეს ცვლადი int არის scoped,
ასე ვთქვათ, მხოლოდ შიგნით იმ Curly braces.
ის უბრალოდ არ არსებობს გარეთ მათ.
>> ასე რომ, რა თქმა უნდა, თუ ეს არასწორი, ნება მომეცით გადარჩენა კოდი
როგორც is-- არასწორად დაწერილი.
ნება მომეცით წავიდეთ წინ და მიიღოს ფუნქცია-1, და შეამჩნია შეცდომა.
გამოყენება გამოუცხადებელ იდენტიფიკატორი n on line 35, რომელიც აქ არის.
და თუ ჩვენ გადახვევა up შემდგომი, კიდევ ერთი.
გამოყენება გამოუცხადებელ იდენტიფიკატორი n on line 34.
>> ასე შემდგენელი, Clang, არის დაენახა, რომ ეს მხოლოდ
არ არსებობს, მიუხედავად იმისა, ნათელია, რომ ეს არ არსებობს ვიზუალურად.
ასე მარტივი სარემონტო აცხადებს იგი.
>> ახლა ნება მომეცით გადახვევა ზედა ფაილი.
რა jumps out at თქვენ, როგორც რომ ცოტა სხვადასხვა
საწყისი პერსონალის ჩვენ შევხედეთ გასულ კვირას?
არა მარტო მაქვს სახელი, არა მხოლოდ არ მაქვს მკვეთრი მოიცავს up ზედა,
მე მაქვს რაღაც მე მოუწოდებს პროტოტიპი.
ახლა რომ გამოიყურება საშინლად მსგავსი რა ჩვენ უბრალოდ დაინახა მომენტში წინ ხაზი 27.
>> ასე რომ, მოდით ითქვას, განსხვავებული შეცდომა, რის გამოც მე ვაკეთებ ამ.
ნება მომეცით წავიდეთ წინ და წაშლა ხაზი არსებობს.
ასე რომ, ჩვენ ამის შესახებ არაფერი იციან პროტოტიპი.
რიმეიკი ამ ფაილის.
ფუნქციის ერთი.
და ახლა, რა, ოთხი შეცდომები.
მოდით გადახვევა up to პირველი.
>> დაფარული დეკლარაცია ფუნქცია დადებითი int არასწორია წელს C99.
C99 მხოლოდ იმას ნიშნავს, 1999 მობილური ენის
C, რაც ჩვენ მართლაც გამოყენებით.
ასე რომ, რას ნიშნავს ეს?
ასევე, C და უფრო კონკრეტულად C compilers-- საკმაოდ dumb პროგრამები.
იციან ის, რასაც თქვენ უთხრა მათ, და რომ
რეალურად თემატური გასულ კვირას.
>> პრობლემა ის არის, რომ თუ მე რეფორმების სახელი აქ,
და მოვუწოდებ ფუნქცია მოუწოდა GetPositiveInt აქ ხაზი 20,
რომ ფუნქცია ტექნიკურად არ არსებობს, სანამ შემდგენელი ხედავს ხაზი 27.
სამწუხაროდ, შემდგენელი აკეთებს რამ ზედა, down, მარცხნივ, მარჯვნივ,
ასე იმიტომ, რომ მას არ უნახავს განხორციელების GetPositiveInt,
მაგრამ ის ხედავს თქვენ ცდილობთ გამოიყენოს იგი აქ,
უბრალოდ აპირებს bail-- დაწეროთ თქვენ შეცდომა message-- ალბათ
cryptic, და არა რეალურად კომპილაციის ფაილი.
>> ასე რომ, ე.წ. პროტოტიპი up აქ არის მართლაც ზედმეტი.
ფაქტიურად, მივედი ქვემოთ აქ და მე გადაწერილი და ჩავსვი ეს, და მე ამას აქ.
ბათილად იქნება უფრო სწორი, ასე რომ ჩვენ სიტყვასიტყვით დააკოპირეთ და ჩასვით იგი ამ დროს.
მე სიტყვასიტყვით გადაწერა და გაკრული იგი.
მართლაც, ისევე როგორც, როგორიცაა პური crumb.
>> პატარა ქალაქში შემდგენელი.
მე არ ვიცი რა ეს იმას არ არის, მაგრამ მე პირობა დადო, რომ თქვენ
ის, რომ იარსებებს საბოლოოდ.
და ამიტომ ეს ხაზი in ონლაინ 16-- მთავრდება მძიმით.
რომ გადაჭარბებული დიზაინი.
დიახ?
>> თუ არ უკავშირებენ თქვენი ბიბლიოთეკა to the-- oh, კარგი კითხვა.
Sharp შედის header ფაილი ჩანართებით.
უნდა be-- უნდა თითქმის ყოველთვის იქნება ძალიან ზევით
of ფაილის similar-- for ზუსტად იმავე მიზეზით, დიახ.
იმის გამო, რომ სტანდარტი io.h ფაქტიურად ონლაინ
მსგავსი, მაგრამ სიტყვა printf და მისი არგუმენტები და მისი დაბრუნების პირობა.
და ასე აკეთებს მკვეთრი მოიცავს up აქ, რა თქვენ ფაქტიურად აკეთებს
კოპირება და pasting შინაარსი სხვისი დაწერა up დაბრუნება.
ამით cluing თქვენი კოდი უნდა ის ფაქტი, რომ იმ ფუნქციას, არ არსებობს.
ჰო?
>> აბსოლუტურად.
ასე რომ, ძალიან ჭკვიანი და სწორი გამოსავალი იქნება, იცით, რა?
მე არ ვიცი, რა პროტოტიპი, მაგრამ მე ვიცი,
თუ მე მესმის, რომ C არის მხოლოდ მუნჯები და გადააზრების ზემოდან.
კარგად მოდით მივცეთ მას, რაც მას სურს.
მოდით გაჭრა კოდი, ჩასვით up ზედა, და ახლა დააყენებს მთავარი ქვემოთ.
ეს ძალიან მოაგვარებს.
>> მაგრამ თქვენ შეიძლება ძალიან ადვილად ამუშავება სცენარი, რომელშიც უნდა მოვუწოდებთ B,
და იქნებ B მოუწოდებს თავში ა ეს არის რაღაც მოუწოდა უკან,
და ჩვენ დავბრუნდებით რომ.
და შეიძლება იყოს ან არ იყოს კარგი რამ, მაგრამ თქვენ შეგიძლიათ ნამდვილად
დაარღვიოს ეს გადაწყვეტა.
>> და უფრო მეტიც, მე აცხადებენ, სტილისტურად,
განსაკუთრებით მაშინ, როდესაც თქვენი პროგრამები გახდეს ეს ხანგრძლივი და ამ ხნის განმავლობაში,
უბრალოდ სუპერ მოსახერხებელი იმისათვის, რომ მთავარ ზედა
იმიტომ, რომ ეს არის, რაც ყველაზე პროგრამისტები აპირებს აინტერესებს.
ასე რომ, ეს ცოტა სუფთა, სავარაუდოდ, ამის გზა
მე თავდაპირველად ეს გააკეთა პროტოტიპი კი
თუმცა ეს გამოიყურება პატარა ზედმეტი ერთი შეხედვით.
ჰო?
უკაცრავად, ამბობენ, რომ ის louder?
>> თუ თქვენ გადახვიდეთ ადგილას განხორციელება და პროტოტიპი?
ასე რომ, ეს კარგი კითხვაა.
თუ თქვენ ხელახლა განაცხადოს ამ ქვემოთ აქ, ვნახოთ, რა მოხდება.
ასე რომ, თუ მე ეს ქვემოთ აქ, რას ამბობდა.
ოჰ, უკაცრავად.
Louder?
კიდევ უფრო ხმამაღლა ისმის.
ოჰ, კარგი კითხვაა.
რომ ეს ბათილად ცნობის ფუნქცია?
მოგეხსენებათ, მას შემდეგ, რაც მთელი ამ წლების განმავლობაში, მე არასდროს არ დააყენა პროტოტიპი შემდეგ.
ასე რომ, მოდით, რათა ფუნქცია 1 შემდეგ აკეთებს, რომ.
>> [Muttering]
დევიდ ჯ Malan: ოჰ, დაველოდოთ.
ჩვენ ჯერ კიდევ გვაქვს იმისათვის, რომ ყველაფერი ზევით.
ასე რომ, მოდით ეს აქ, თუ მე ვარ გაგება თქვენს კითხვას სწორად.
მე აყენებს ყველაფერს, მათ შორის პროტოტიპი ზემოთ ძირითადი,
მაგრამ მე აყენებს პროტოტიპი ქვემოთ განხორციელება.
>> ასე რომ, თუ ერთი, მე მისაღებად უკან შეცდომა გამოუყენებელი ცვლადი n.
ოჰ, არსებობს.
დიდი მადლობა.
ვნახოთ, ჩვენ დავაღწიოთ ამ.
რომ სხვადასხვა bug, მოდით იგნორირება, რომ.
მოდით მართლაც სწრაფად რიმეიკი ამ.
>> OK, ასე რომ მონაცემები არგუმენტი არ გამოიყენება სტრიქონში
N-- oh, იმიტომ, რომ მე შეიცვალა ამ აქ.
ყველა უფლება, ჩვენ ვიცით, რა პასუხი აპირებს, რომელთა მიზანია ყველა უფლება, აქ ჩვენ მივდივართ.
Ah, მადლობა დადებითი.
ყველა უფლება, მე დაფიქსირება ეს კოდი after-- იგნორირება ამ კონკრეტულ bug
მას შემდეგ, რაც ამ was-- მუშაობს ის არის პასუხი.
>> ასე რომ, ეს არ გადაწერა რა თქვენ გაკეთდეს.
ეჭვი მაქვს, შემდგენელი დაწერილი ისე,
ის, რომ იგნორირება თქვენი პროტოტიპი იმიტომ, რომ სხეულის, ასე ვთქვათ,
ფუნქცია უკვე განხორციელდა უმაღლესი up.
მე რეალურად კონსულტაციები სახელმძღვანელო შემდგენელი
უნდა გვესმოდეს, თუ არსებობს რაიმე სხვა გავლენა, მაგრამ ერთი შეხედვით
მხოლოდ ცდილობს და ექსპერიმენტებს, როგორც ჩანს, არ იმოქმედებს.
კარგი კითხვაა.
>> ასე რომ, მოდით გაყალბებას ელის ახლა, მოძრავი დაშორებით გვერდითი მოვლენები, რომელიც
ფუნქციები, რომ რაღაც მოსწონს ვიზუალურად ეკრანზე printf,
მაგრამ არ დაბრუნდებიან მნიშვნელობა.
და ფუნქციები, აქვს დაბრუნების ღირებულებებს, როგორიცაა ჩვენ უბრალოდ დაინახა რამდენიმე.
ჩვენ უკვე ვნახეთ, ამ ცნება ფარგლებს, და ჩვენ ვხედავთ, ეს ისევ და ისევ.
მაგრამ ახლა, კიდევ ერთხელ, გამოყენების წესი ცერის
რომ ცვლადი შეიძლება გამოყენებულ იქნეს მხოლოდ შიგნით ყველაზე ცოტა ხნის წინ გაიხსნა
დახურული და curly braces, როგორც ჩვენ დაინახა, რომ კონკრეტული მაგალითი.
>> და როგორც თქვენ აღნიშნა, არსებობს ability--
თქვენ შეიძლება გადაწყვიტოს ზოგიერთი პრობლემა გამოსული ცვლადი გლობალურად
ძალიან ზევით ფაილი.
მაგრამ თითქმის ყველა შემთხვევაში ჩვენ გვინდა frown საფუძველზე, რომ
და მართლაც კი არ დადიან შევიდა, რომ გამოსავალი არის.
ასე რომ, ახლა, takeaway არის, რომ ცვლადები ამ ცნება ფარგლებს.
>> მაგრამ ახლა მოდით შევხედოთ სხვა მშრალი გზა, ფაქტობრივად, ეძებს
რაღაც საკმაოდ საინტერესო განხორციელების დეტალები.
როგორ შეიძლება წარმოადგენდეს ინფორმაცია.
და ჩვენ უკვე შევხედე პირველ კვირას კლასის.
ეძებს binaries და შევახსენებთ საკუთარ თავს, ათობითი.
>> მაგრამ გავიხსენოთ, რომ გასულ კვირას, რომ C აქვს სხვადასხვა ტიპის მონაცემები და bunches მეტი,
მაგრამ ყველაზე სასარგებლო პირობა ახლა შეიძლება იყოს ეს.
Char, და ხასიათი, რაც ხდება, უნდა იყოს ერთი ბაიტი, რვა ბიტი შეადგენს.
და რომ ამბობენ, რომ ზომა of char მხოლოდ ერთი ბაიტი.
Byte არის რვა ბიტი, ეს ნიშნავს, რომ ჩვენ შეგვიძლია რამდენი გმირები.
რამდენი ასო ან სიმბოლოები კლავიატურაზე
თუ ჩვენ გვაქვს ერთი ბაიტი რვა ბიტი.
ფიქრობთ თავში კვირაში ნულოვანი.
თუ თქვენ გაქვთ რვა ბიტი, რამდენი სულ ღირებულებები
შეგიძლიათ წარმოადგენენ ნიმუში zeros და პირობა?
One-- მეტია.
ასე რომ 256 სულ თუ დაიწყება დათვლის ნულიდან.
ასე რომ, თუ თქვენ გაქვთ რვა ბიტი ასე რომ, თუ ჩვენ გვქონდა ჩვენი ორობითი ნათურებით აქ კიდევ ერთხელ,
ჩვენ შეიძლება იქცეს იმ ნათურებით on და off ნებისმიერი 256 უნიკალური ნიმუშები.
>> ახლა ეს არის ცოტა პრობლემატური.
არა იმდენად ინგლისური და რომანული ენები, მაგრამ, რა თქმა უნდა
როდესაც თქვენ გააცნობს, რომელიც მაგალითად, აზიური ენები, რომელიც
გაცილებით სიმბოლოები, ვიდრე მოსწონს 26 ასო ანბანი.
ჩვენ რეალურად ალბათ საჭიროა მეტი byte.
და საბედნიეროდ ბოლო წლებში საზოგადოების
მიღებული სხვა სტანდარტებთან გამოყენება მეტი byte პოსტი პასუხისმგებელი.
>> მაგრამ ახლა C, რა არის მხოლოდ ერთი ბაიტი რვა ბიტი.
მთელი რიცხვი, იმავდროულად, არის ოთხი bytes, სხვაგვარად ცნობილია როგორც 32 ბიტი.
რაც იმას ნიშნავს, რა არის უდიდესი შესაძლო ნომერი ჩვენ შეგვიძლია ერთად int
როგორც ჩანს?
მილიარდი.
ასე რომ, ეს ოთხი მილიარდი მისცეს ან მიიღოს.
2 დან 32 ძალა, თუ ჩვენ ვივარაუდოთ, არ უარყოფითი რიცხვები
და მხოლოდ გამოიყენოთ ყველა დადებითი ნომრები, ოთხი მილიარდი
მისცეს ან მიიღოს შესაძლებლობები.
Float, იმავდროულად, არის სხვადასხვა ტიპის მონაცემთა ტიპი C. ეს არის კიდევ მთელი რიგი,
მაგრამ ეს რეალური რაოდენობა.
რაღაც ათობითი წერტილი.
და აღმოჩნდება, რომ C ასევე იყენებს ოთხი ბაიტი
to წარმოადგენს მცურავი პუნქტიანი ღირებულებებს.
>> სამწუხაროდ, რამდენი მცურავი წერტილი ღირებულებები არ არსებობს მსოფლიოში?
რამდენი რეალური ციფრები არსებობს?
არსებობს უსასრულო ნომერი, და ამ საკითხთან დაკავშირებით
არსებობს უსასრულო რაოდენობა რიცხვებით.
ასე რომ, ჩვენ უკვე სახის თხრა საკუთარ თავს ხვრელი აქ.
რომლის დროსაც, როგორც ჩანს, computers-- at მინიმუმ პროგრამების დაწერილი C on them--
მხოლოდ ითვლიან როგორც მაღალი, როგორც ოთხი მილიარდი მისცეს ან მიიღოს,
და მცურავი პუნქტიანი ღირებულებებს შეიძლება მხოლოდ, როგორც ჩანს,
აქვს გარკვეული სასრულ თანხის სიზუსტით.
მხოლოდ ამდენი ციფრები შემდეგ მათი ათობითი წერტილი.
>> იმის გამო, რომ, რა თქმა უნდა, თუ თქვენ მხოლოდ 32 ბიტი,
მე არ ვიცი, თუ როგორ ვაპირებთ წავიდეთ შესახებ წარმოადგენს რეალური ნომრები ალბათ
სხვადასხვა ტიპის ნიმუშები.
მაგრამ იქ აუცილებლად სასრული რიგი ისეთი ნიმუშები,
აქ, ძალიან, ეს პრობლემატურია.
>> ახლა ჩვენ შეგვიძლია თავიდან ავიცილოთ პრობლემა ოდნავ.
თუ თქვენ არ გამოიყენოს float, თქვენ შეიძლება გამოიყენოთ ორმაგი
C, რომელიც გაძლევთ რვა ბაიტი, რაც უფრო მეტი შესაძლო ნიმუში zeros
და პირობა.
მაგრამ მაინც სასრული, რომელიც აპირებს პრობლემატურია, თუ თქვენ ჩაწერის პროგრამული
გრაფიკა და ლამაზი მათემატიკური ფორმულები.
ასე რომ თქვენ შეიძლება რეალურად მინდა ითვლიან up უფრო დიდი ვიდრე.
ხანგრძლივი ხანგრძლივი stupidly named-- ასევე რვა ბაიტს, ან 64 ბიტი,
და ეს არის ორჯერ გრძელი int, და ეს დიდი ხნის მთელი მნიშვნელობა.
>> გართობა ფაქტობრივად თუ int ოთხი ბაიტი, რამდენი ხანი არის ხანგრძლივი დო წესი?
ასევე ოთხი ბაიტი, მაგრამ ხანგრძლივი ხანგრძლივი რვა ბაიტი,
და ეს არის ისტორიული მიზეზების გამო.
>> მაგრამ takeaway ახლა უბრალოდ, მონაცემების
წარმოდგენილი იყოს კომპიუტერი, რომ ის, ფიზიკური მოწყობილობა ელექტროენერგიის,
ეს ზოგადად მართვის იმ zeros და პირობა
სასრულ რაოდენობით სიზუსტით.
ასე რომ რა პრობლემაა მერე?
>> ასევე არსებობს პრობლემა, მთელი რიცხვი overflow.
არა მხოლოდ C, არამედ კომპიუტერები ზოგადად.
მაგალითად, თუ ამ არის byte ღირს bit--
ასე რომ, თუ ამ რვა bit-- ყველა რომელთაგან ერთი.
რა რაოდენობის არის ეს წარმოადგენს თუ ჩვენ ვივარაუდოთ,
ეს ყველაფერი პოზიტიური ღირებულებების ორობითი?
>> 255, და ეს არ არის 256, რადგან ნულოვანი არის ყველაზე დაბალი ნომერი.
ასე რომ 255 არის უმაღლესი ერთი, მაგრამ პრობლემა
არის ვარაუდი, რომ მინდოდა ნამატი ეს ცვლადი, რომ
გამოყენებით რვა ბიტი სულ თუ მინდა, რომ იყოს იგი.
>> კარგად, როგორც კი დავამატო ერთი, რომ ყველა ეს პირობა,
თქვენ შეიძლება ალბათ წარმოიდგინეთ visually-- მხოლოდ როგორიცაა ტარების ერთი გამოყენებით decimals--
რამე ხდება შემოვა მარცხენა.
და მართლაც, თუ მე დაამატოთ ნომერი ერთი ეს, რა ხდება binary
ის არის, რომ ეს overflows ნული.
>> ასე რომ, თუ თქვენ მხოლოდ გამოიყენოს არ არის int, მაგრამ ერთი ბაიტი ითვლიან რიცხვებით
პროგრამა, რომელსაც default-- როგორც კი თქვენ მიიღებთ 250, 251, 252, 253, 254,
255-- 0 მას შემდეგ, რაც 255, რომელიც, ალბათ, არ არის, რაც
მომხმარებელი ვაპირებთ ველოდოთ.
>> ახლა იმავდროულად მცურავი წერტილი სამყაროში, თქვენ ასევე აქვს მსგავსი პრობლემა.
არა იმდენად უდიდესი number-- მიუხედავად იმისა, რომ ჯერ კიდევ საკითხი.
მაგრამ ოდენობით სიზუსტით რომ თქვენ შეგიძლიათ წარმოადგენენ.
ასე რომ, მოდით შევხედოთ ამ მაგალითს აქ ასევე დღევანდელი წყარო code--
float-0.c.
>> და შენიშნავს, რომ სუპერ მარტივი პროგრამა, რომელიც
უნდა აშკარად ამობეჭდოთ რა ღირებულება?
რას ფსონს ამ აპირებს ბეჭდვა მიუხედავად იმისა, რომ ცოტა ახალი სინტაქსის
აქ?
ასე რომ, იმედია 0.1.
ასე ექვივალენტი ერთი მეათედი იმიტომ, რომ მე ვაკეთებ 1 დაყოფილი 10.
მე შენახვის პასუხი ცვლადში ვ.
რომ ცვლადი ტიპის float, რომელიც არის სიტყვით უბრალოდ შემოთავაზებული არსებობდა.
>> ჩვენ არ მინახავს ეს ადრე, მაგრამ ეს არის ერთგვარი გარღვევა გზა printf
დააკონკრეტა რამდენი ციფრები თქვენ გვინდა, რომ მას შემდეგ, რაც ათობითი წერტილი.
ასე რომ, ეს notation მხოლოდ იმას ნიშნავს, რომ აქ არის placeholder.
ის ამისთვის მცურავი წერტილი ღირებულება, და მე, სხვათა შორის,
გამოჩნდება ეს ათობითი წერტილი ერთი ნომერი შემდეგ ათობითი წერტილი.
ასე რომ, ნომერი მნიშვნელოვანი ციფრები,
ასე ვთქვათ, რომ დაგვჭირდება.
>> ნება მომეცით, წავიდეთ წინ და ამის გაკეთება რათა float-0, ./float-0,
და როგორც ჩანს, 1 დაყოფილი 10 0.0.
ახლა რატომ არის ეს?
>> ასევე კიდევ ერთხელ, კომპიუტერული ხდება მე ფაქტიურად, და მე არ გაუკეთებია 1
და მე დაწერილი 10 და მიხვდები რა არის ვარაუდი, მონაცემები ტიპის ამ ორი
ღირებულებები?
Int, ტექნიკურად რაღაც ცოტა განსხვავებული.
როგორც წესი, დიდი ხნის განმავლობაში, მაგრამ ეს საბოლოოდ განუყოფელი ღირებულება.
არ მცურავი წერტილი ღირებულება.
>> რაც უნდა ითქვას, რომ თუ ამ არის int და ეს არის int,
პრობლემა ის არის, რომ კომპიუტერი არ აქვს უნარი
კი შესანახად ათობითი წერტილი.
ასე რომ, როდესაც თქვენ ამის გაკეთება 1 დაყოფილი 10 გამოყენებით რიცხვებით
ორივე მრიცხველი და მნიშვნელი, პასუხი უნდა იყოს 0.1.
მაგრამ ეგმ რადგან ეს ის რიცხვებით
არ იცის, რა უნდა გააკეთოს, 0.1.
>> ასე რომ, რა არის ეს ნათლად აკეთებს?
უბრალოდ სროლა ის მოშორებით, და რა მე ხედავს საბოლოოდ
არის 0.0 მხოლოდ იმიტომ, რომ ამტკიცებდა, რომ printf მაჩვენო ერთი ათობითი წერტილი.
მაგრამ პრობლემა ის არის, რომ თუ დაყოფის რიცხვი მიერ მთელი რიცხვი,
თქვენ get-- განსაზღვრების საქართველოს, C რიცხვი.
და ის არ აპირებს ამის გაკეთებას რაღაც ლამაზი და მოხერხებული
როგორიცაა მრგვალი მდე უახლოესი ერთი ან ქვემოთ.
ის აპირებს truncate ყველაფერი შემდეგ ათობითი.
>> ასე რომ, უბრალოდ ინტუიციურად, რა ალბათ fix?
რა არის მარტივი გადავწყვიტოთ აქ?
ჰო?
ზუსტად.
რატომ არ გვაქვს უბრალოდ მკურნალობა ეს როგორც მცურავი პუნქტიანი ღირებულებების ეფექტურად
გარდამტეხი მათ მოძრავი ან ორჯერ.
და ახლა თუ არ მიიღოს მოძრავი-0, ან თუ მე კომპილაციის მოძრავი-1,
რომელიც იდენტურია რა იყო მხოლოდ შემოთავაზებული.
და ახლა მე მოძრავი-0, ახლა მე ჩემი 0.1.
>> ახლა ეს არის საოცარი.
მაგრამ ახლა მე ვაპირებ ამის გაკეთებას რაღაც ცოტა განსხვავებული.
მაინტერესებს რა არის ნამდვილად ხდება ქვეშ hood,
და მე ვაპირებ ბეჭდვა ეს იმისათვის, რომ 28 ათობითი ადგილებში.
მინდა ვხედავ 0.1000-- infinite--
[INAUDIBLE] 27 zeros მას შემდეგ, რაც 0.1.
>> ასევე ვნახოთ, თუ ეს ის, რაც მე მართლაც მიიღოს.
მიიღოს მოძრავი-0 იგივე ფაილი.
./floats-0.
მოდით მიუახლოვდით დრამატული პასუხი.
ამ დროს, თქვენ უკვე ფიქრი 1 დაყოფილი 10 10%, ანუ 0.1.
ეს არ არის.
მინიმუმ რამდენადაც კომპიუტერის შეშფოთებულია.
>> ახლა why-- OK, რომ სრული ტყუილი 1 დაყოფილი 10 0.1.
მაგრამ why--, რომელიც არ არის takeaway დღეს.
ასე რატომ კომპიუტერული ვფიქრობ, განსხვავებით ყველა ჩვენგანი ოთახი,
რომ 1 დაყოფილი 10 რეალურად, რომ გიჟები ღირებულება?
რა არის კომპიუტერში აკეთებს როგორც ჩანს?
რა არის ეს?
>> ეს არ არის overflow, თავისთავად.
Overflow როგორც წესი, როდესაც თქვენ გადაიტანოთ გარშემო ღირებულება.
ის ამ საკითხს ორაზროვნება მცურავი წერტილი ღირებულება
სადაც თქვენ მხოლოდ 32 ან თუნდაც 64 ბიტიანი.
მაგრამ თუ არსებობს უსასრულო უძრავი ნომრები
ნომრები ათობითი ქულა და ნომრები thereafter-- აუცილებლად
ვერ წარმოადგენს ყველა მათგანი.
ასე რომ კომპიუტერის მისცა us უახლოესი მატჩი
ღირებულება, შეიძლება წარმოადგენს გამოყენებით, რომელიც ბევრი ბიტი არც მე რეალურად მინდა,
რომელიც არის 0.1.
>> სამწუხაროდ, თუ დაიწყოს აკეთებს მათემატიკის, ან თქვენ
დაიწყოს, მათ შორის ამ სახის მცურავი წერტილი ღირებულებების მნიშვნელოვანია, რომ პროგრამების
ფინანსური უზრუნველყოფა, სამხედრო software-- არაფერს
სადაც აღქმა ალბათ საკმაოდ მნიშვნელოვანია.
და დაიწყება დასძინა ნომრები ასე, და დაწყების
გაშვებული, პროგრამული უზრუნველყოფა მართლაც დიდი საშუალებებით
ან უამრავი საათი და უამრავი დღის ან უამრავი წლის განმავლობაში,
ამ პატარა შეცდომები აუცილებლად შეგიძლიათ დაამატოთ up დროთა განმავლობაში.
>> ახლა, როგორც განზე, თუ თქვენ ოდესმე ჩანს Superman 3 ან საოფისე ფართი
და თქვენ ალბათ გახსოვთ, როგორ, იმ ბიჭებს მოიპარეს
ბევრი ფული მათი კომპიუტერი გამოყენებით მცურავი პუნქტიანი ღირებულებებს
და დასძინა up პატარა დარჩენილი, იმედია, რომ ფილმი
ახლა ხდის უფრო გრძნობა.
ეს არის, რაც იყო, მიანიშნებენ, რომ ფილმის.
ის ფაქტი, რომ ყველაზე კომპანიები არ გამოიყურება
შემდეგ გარკვეული რაოდენობის საქართველოს ათობითი ადგილებში,
მაგრამ იმ ფრაქციების ცენტი.
ასე რომ თქვენ დაიწყოს დასძინა, მათ, თქვენ დაიწყოს, რათა ბევრი ფული
თქვენს საბანკო ანგარიშზე.
ასე რომ, ის საოფისე ფართი განმარტა.
>> ახლა, სამწუხაროდ მიღმა საოფისე ფართი, არსებობს
ზოგიერთი ლეგიტიმურად შემაშფოთებელი და მნიშვნელოვანი ზემოქმედება
ამ სახის ძირითადი დიზაინის გადაწყვეტილებები,
და მართლაც ერთ ერთი მიზეზი ჩვენ ვიყენებთ C რა თქმა უნდა,
ასე, რომ თქვენ ნამდვილად გაქვთ ამ მიწაზე up გაგება, თუ როგორ კომპიუტერები მუშაობენ,
როგორ პროგრამული და არა არაფერი მიანიჭა.
>> და მართლაც, სამწუხაროდ, თუნდაც რომ ფუნდამენტური გაგება,
ჩვენ ადამიანებს უშვებენ შეცდომებს.
და რა ვიფიქრე მე მინდა წილი რვა წუთიანი ვიდეო აქ მიღებული
საწყისი თანამედროვე Marvels ეპიზოდი, რომელიც საგანმანათლებლო შოუ, თუ როგორ მუშაობს
რომ ხატავს ორი სურათით , როდესაც არასათანადო გამოყენება
და გაგება მცურავი პუნქტიანი ღირებულებებს
გამოიწვია ზოგიერთი მნიშვნელოვანი სამწუხარო შედეგებს.
მოდით შევხედოთ.
[ვიდეო აღწარმოების]
დიახ, ახლა დაბრუნდნენ "საინჟინრო სტიქია "თანამედროვე Marvels.
კომპიუტერები.
ჩვენ ყველა მოდის მიიღოს ხშირად frustrating პრობლემა, რომელიც
მიიღო them-- შეცდომები, ვირუსების და პროგრამული glitches-- მცირე ფასები
გადაიხადოს მოხერხებულობისთვის.
მაგრამ მაღალტექნოლოგიური და მაღალი სიჩქარით სამხედრო და სივრცეში პროგრამის განაცხადების,
პატარა პრობლემა შეიძლება განდიდდეს შევიდა უბედურება.
>> 4 ივნისს, 1996, მეცნიერები მზად დაიწყოს უპილოტო Ariane 5 რაკეტა.
იგი ახორციელებს სამეცნიერო თანამგზავრების განკუთვნილია
დამყარება ზუსტად როგორ დედამიწის მაგნიტური ველი ურთიერთქმედებს
მზის ქარები.
სარაკეტო აშენდა ევროპის კოსმოსური სააგენტო,
და გააუქმა off მისი დაწესებულებაში სანაპიროზე ფრანგული გვიანა.
>> -დაახლოებით 37 წამში შევიდა ფრენის, მათ პირველი
შენიშნა რაღაც მიდის არასწორი.
რომ რეაქტიული საქშენები იყო swiveling ისე, რომ ისინი ნამდვილად არ უნდა.
დაახლოებით 40 წამში შევიდა ფრენის, ნათლად ავტომობილის უბედურება,
და ეს მაშინ, როდესაც ისინი გააკეთა გადაწყვეტილება უნდა გაანადგუროს იგი.
სპექტრი უსაფრთხოების ოფიცერი, დიდი guts, დაპრესილი ღილაკს
და ააფეთქეს სარაკეტო სანამ გახდება საშიშროების საზოგადოებრივი უსაფრთხოების.
>> ეს იყო ერთ maiden მოგზაურობა Ariane 5,
და მისი განადგურების მოხდა განათავსეთ გამო ხარვეზი
ჩართული სარაკეტო პროგრამული უზრუნველყოფა.
-პრობლემა Ariane იყო, რომ
იყო მთელი რიგი, რომელიც საჭირო 64 ბიტი გამოთქვას,
და უნდოდათ რომ გადაიყვანო მას 16-bit ნომერი.
ისინი ფიქრობდნენ, რომ ნომერი არასდროს არ უნდა იყოს ძალიან დიდი.
რომ ყველაზე მეტად იმ ციფრისგან 64-bit ნომერი იყო zeros.
ისინი არასწორია.
>> -უუნარობა ერთ პროგრამული უზრუნველყოფის პროგრამა მიიღოს
სახის მიერ გენერირებული სხვა იყო ფესვი უკმარისობა.
პროგრამული უზრუნველყოფის დამუშავება გახდა ძალიან ძვირადღირებული ნაწილი ახალი ტექნოლოგიები.
Ariane 4 სარაკეტო ჰქონდა ძალიან წარმატებული იყო.
იმდენად, რამდენადაც პროგრამული უზრუნველყოფის შექმნა იგი ასევე გამოიყენება Ariane 5.
>> -ძირითადი პრობლემა ის იყო, რომ Ariane 5.
იყო faster-- დააჩქარა სწრაფად და პროგრამული უზრუნველყოფის არ ჰქონდა აღრიცხვა რომ.
>> -განადგურების სარაკეტო იყო დიდი ფინანსური კატასტროფის.
ყველა გამო წუთი პროგრამული შეცდომა.
მაგრამ ეს არ იყო პირველი, მონაცემები კონვერტაციის პრობლემები
ჰქონდა ხშირია თანამედროვე სარაკეტო ტექნიკა.
>> თიბისი 1991 დაწყება პირველი ყურის ომი,
პატრიოტის სარაკეტო გამოცდილი მსგავსი
რიგი კონვერტაციის პრობლემა.
და შედეგად 28 people-- 28 American soldiers-- დაიღუპა,
და ასამდე დაიჭრა.
როდესაც პატრიოტთა, რომელიც სავარაუდოდ რომ დაიცვას წინააღმდეგ შემომავალი Scuds,
ვერ ცეცხლი სარაკეტო.
>> როცა ერაყში შეიჭრა ქუვეითსა და ამერიკაში დაიწყო Desert Storm დასაწყისში 1991,
პატრიოტის სარაკეტო ბატარეები იყო განლაგდნენ დასაცავად საუდის არაბეთი და ისრაელს
ერაყის Scud სარაკეტო თავდასხმებს.
პატრიოტის არის აშშ საშუალო დამიზნების ზედაპირზე-to-air სისტემა
მიერ წარმოებული RAYTHEON კომპანია.
>> ანუ ზომა პატრიოტის interceptor თავად
ეს დაახლოებით დაახლოებით 20 ფუტი სიგრძის, და იგი იწონის დაახლოებით 2,000 ფუნტი.
და იგი ახორციელებს ქობინით დაახლოებით, მე ვფიქრობ, რომ დაახლოებით 150 ფუნტი.
და ქობინით თავისთავად მაღალი ასაფეთქებელი, რომელიც
აქვს ფრაგმენტები გარშემო მას.
ასე რომ, გარსაცმის warhead არის განკუთვნილია იმოქმედოს, როგორც buckshot.
>> ანუ რაკეტები ხორციელდება ოთხი შეადგენს კონტეინერ,
და ტრანსპორტირება ნახევრად trailer.
>> ანუ პატრიოტის რაკეტსაწინააღმდეგო სისტემის მიდის უკან მაინც 20 წელია.
თავდაპირველად დაპროექტებული როგორც საჰაერო თავდაცვის სარაკეტო
ჩამოაგდებენ მტრის თვითმფრინავები.
პირველი ყურის ომი როდესაც რომ ომი მოვიდა,
არმიის სურდა გამოვიყენოთ რომ სროლა ქვემოთ Scuds, არ თვითმფრინავები.
ერაყის საჰაერო ძალები ასე არ არის დიდი პრობლემა,
მაგრამ არმიის აწუხებს Scuds.
ასე რომ, ისინი ცდილობდნენ, განახლება პატრიოტია.
>> -Intercepting მტერი სარაკეტო მოგზაურობა საათზე MACH 5
მიდიოდა იწვევს საკმარისი.
მაგრამ როდესაც პატრიოტთა იყო შევარდა სამსახურის,
არმიის არ იყო საქმის კურსში ერაყის მოდიფიკაცია რომ
გააკეთეს Scuds თითქმის შეუძლებელია ეს.
>> რა მოხდა არის Scuds რომ იყო შემოდიოდნენ იყო არასტაბილური.
ისინი wobbly.
ამის მიზეზი იყო Iraqis-- იმისათვის, რომ მიიღოთ 600 კილომეტრის გარეთ
300-კილომეტრიანი Range missile-- აიღო წონა გარეთ წინა ქობინით,
და გააკეთა ქობინით მსუბუქია.
ახლა პატრიოტთა ცდილობს მოდის at Scud, ყველაზე time--
უმრავლესობა time-- ეს იქნებოდა უბრალოდ ფრენა მიერ Scud.
>> -Once პატრიოტის სისტემის ოპერატორები მიხვდა პატრიოტის გაშვებული მისი სამიზნე,
ისინი აფეთქდა პატრიოტთა warhead რათა თავიდან ავიცილოთ შესაძლო მსხვერპლი, თუ იგი
ეძლეოდა ჩავარდნას, რათა ადგილზე.
>> ანუ იყო ის, რაც ხალხის უმრავლესობას დაინახა როგორც დიდი fireballs ცაში,
და არასწორად როგორც საუბრების of Scud ქობინი.
>> -Although In ღამის ცა, პატრიოტთა აღმოჩნდა წარმატებით გაანადგურეს
Scuds საათზე Dhahran, იქ შეიძლება იყოს არ შეცდომის შესახებ მისი შესრულება.
იქ პატრიოტთა სარადარო სისტემის დაკარგა კვალს შემომავალი Scud
და არასოდეს დაიწყო გამო to პროგრამული უზრუნველყოფის ხარვეზი.
>> ეს იყო ისრაელის, რომელმაც პირველად აღმოაჩინა რომ აღარ სისტემა იყო,
დიდი დრო შეუსაბამობა გახდა.
გამო საათის ჩართული სისტემაში კომპიუტერში.
>> -About ორი კვირით ადრე ტრაგედიას Dhahran,
ისრაელის განუცხადა თავდაცვის დეპარტამენტი
რომ სისტემის დაკარგვის დროს.
შემდეგ დაახლოებით რვა საათის გაშვებული, მათ შენიშნეს,
რომ სისტემის ხდება შესამჩნევად ნაკლები სიზუსტით.
თავდაცვის დეპარტამენტის გამოეხმაურა ვეუბნებოდი ყველა პატრიოტის ბატარეები
რომ არ დატოვებს სისტემები დიდი ხნის განმავლობაში.
ისინი არ ამბობს, რა დიდი დრო იყო.
8 საათი, 10 საათი, ათასი საათი.
არავინ იცოდა.
>> ანუ პეტრიოტებ განლაგებული დროს ყაზარმებში
at Dhahran და მისი ყალბი შიდა საათი იყო დაახლოებით 100 საათი
იმ ღამით, 25 თებერვალს.
>> ხომ tracked დრო და სიზუსტე დაახლოებით მეათედი მეორე.
ახლა მეათე მეორე საინტერესო ნომერი
იმიტომ, რომ ეს არ შეიძლება იყოს გამოხატული ორობითი ზუსტად, რაც
იმას ნიშნავს, რომ არ შეიძლება იყოს გამოხატული ზუსტად ნებისმიერ თანამედროვე ციფრული კომპიუტერი.
ძნელი დასაჯერებელია, მაგრამ გამოიყენოს ეს როგორც მაგალითად.
>> ავიღოთ ნომერ მესამე.
ერთი მესამედი ვერ იქნება გამოიხატოს ათობითი ზუსტად.
ერთი მესამედი არის 0,333 გრძელდება უსასრულობამდე.
არ არსებობს გზა უნდა გააკეთოს, რომ აბსოლუტური სიზუსტით წელს ათობითი.
სწორედ სახის პრობლემა რომ მოხდა პატრიოტია.
აღარ სისტემა გაიქცა, უარესი დრო შეცდომა გახდა.
>> მას შემდეგ რაც 100 სამუშაო საათები, შეცდომა იყო მხოლოდ დაახლოებით ერთი მესამედი
მეორე.
მაგრამ თვალსაზრისით სამიზნედ სარაკეტო მოგზაურობა საათზე MACH 5,
მას შედეგად თვალთვალის შეცდომა მეტი 600 მეტრია.
ეს იქნება ფატალური შეცდომა ამისთვის ჯარისკაცებთან Dhahran.
>> რა მოხდა Scud დაწყებას გამოვლინდა მიერ ადრეული გაფრთხილების თანამგზავრების,
და მათ იცოდნენ Scud მოდიოდა მათი ზოგადად მიმართულებით.
მათ არ იციან, სადაც იგი მოდიოდა.
ეს იყო ახლა მდე სარადარო კომპონენტი პატრიოტის სისტემის
დაცვითი Dhahran იქნებიან და შეინახოს სიმღერა შემომავალი მტრის რაკეტა.
>> ანუ რადარზე ძალიან ჭკვიანი.
ეს რეალურად აკონტროლოთ პოზიცია Scud
და შემდეგ პროგნოზირება, სადაც ეს ალბათ იქნება
მომავალი დრო სარადარო გაგზავნილი პულსი გარეთ.
რომ ერქვა Range კარიბჭე.
>> მაშინდელ ერთხელ პატრიოტის გადაწყვეტს საკმარისი დრო აქვს
გავიდა წასვლა უკან და შეამოწმოთ შემდეგი საიდან ამ გამოვლინდა ობიექტი
იგი მიდის უკან.
ასე რომ, როდესაც იგი დაბრუნდა არასწორი ადგილი, მაშინ ვერ ხედავს ობიექტი.
და ეს გადაწყვეტს, რომ არ იყო წინააღმდეგი.
რომ იყო ყალბი აღმოჩენისა და წვეთების სიმღერა.
>> ანუ შემომავალი Scud გაქრა სარადარო ეკრანზე,
და წამის შემდეგ, ის გააკრიტიკა შევიდა ყაზარმები.
Scud დაიღუპა 28.
ეს იყო ბოლო ერთი გასროლა პირველი ყურის ომი.
ტრაგიკულია, რომ განახლებული პროგრამული უზრუნველყოფის ჩამოვიდა გამთენიისას მომდევნო დღეს.
პროგრამული უზრუნველყოფის ხარვეზი უკვე დაფიქსირდა, იხურება
ერთი თავი პრობლემური ისტორიაში პატრიოტის სარაკეტო.
>> [END ვიდეო აღწარმოების]
>> დევიდ ჯ Malan: ეს არის ის, CS50.
ვნახავთ თქვენ ოთხშაბათს.
>> [მუსიკის დაკვრა]