>> [მუსიკალური სათამაშო]
>> დავით J Malan: ყველა უფლება, მივესალმებით უკან CS50.
ეს არის დაწყების კვირაში ორი.
სიტყვა, ერთი ჩვენი მეგობრებს campus -
თუ თქვენ დაინტერესებული, შესაძლოა, არც ახლა, ხან მომავალში ვადა
მაშინაც კი, კიდევ უფრო კომფორტული, სწავლების საშუალო სკოლის სტუდენტები პატარა
რამე კომპიუტერულ მეცნიერებათა ამის გაკეთება ხელმძღვანელი რომ URL.
ისინი განსაკუთრებით საჭიროება ახლავე of მასწავლებლები, განსაკუთრებით თუ თქვენ გაქვთ
გარკვეული ექსპოზიციის კომპიუტერულ მეცნიერებაში.
>> ასე რომ გავიხსენოთ, რომ ბოლო დროს, ჩვენ გააცნო რამდენიმე მონაცემთა ტიპები ამ C, და
თქვენ შეიძლება არ დაიწყო თქვენი ხელში ბინძური, ამ დღემდე
ამ პრობლემის მითითებული ერთი.
და ჩვენ გვქონდა char.
ასე რომ, გარკვეულწილად ტექნიკური თვალსაზრისით, რა არის char როგორც იცით დღეს?
>> ასე რომ, ხასიათის, მაგრამ უფრო სწორედ ახლა.
რას ნიშნავს ხასიათი ან ინდივიდუალური char?
არასამთავრობო რიცხვითი ხასიათი -
ასე რომ არ არის აუცილებელი.
გამოდის, რომ მაშინაც კი, ნომრები, მაშინაც კი, პუნქტუაციის და ასო
წარმოდგენილი ამ მონაცემთა აკრიფოთ ცნობილია როგორც char.
ასე რომ, ეს არ არის აუცილებელი ანბანურ.
ჰო?
>> ასე რომ, ეს ASCII ხასიათი.
ასე რომ, თუ თქვენ ფიქრობთ, დაბრუნდა კვირის ნულოვანი, როდესაც ჩვენ გვქონდა ჩვენი byte მოხალისეთა
ამუშავება და არც გამართავს ხელში up თუ არა, მათ წარმოდგენილია ბიტი.
თუმცა ერთობლივად, როგორც ჯგუფის რვა, ისინი წარმოდგენილია byte.
და ჩვენ გააცნო ცნება ASCII იმ ლექცია, რომელიც უბრალოდ არის
რუკების შორის ნომრები და წერილები.
და ASCII მიზნებისათვის, როგორც იმ ადამიანებს ნაგულისხმევი, რვა ბიტი
წარმოადგენს ხასიათი.
>> ასე რომ, შესაბამისად, თუ რვა ბიტი შეიძლება თითოეული მიიღებს ერთი ორი ფასეულობების -
ნულოვანი ან ერთი -
უნდა ნიშნავდეს ეს იყო ორი შესაძლებლობები ეს პირი -
ნულოვანი ან ერთი -
ორი ამ ადამიანს, ორი, ამ პირი, ორი ეს ერთი.
ასე რომ, სულ ორჯერ ორჯერ ორჯერ ორჯერ ორ -
ასე ორი მერვე შეადგენს.
ასე რომ საერთო რაოდენობის გმირები 256 შესაძლებელია, რომ თქვენ
წარმოადგენს რვა ბიტი.
>> ახლა, ვინც საუბრობენ აზიური ენებზე ალბათ იცით, რომ არსებობს უფრო
გმირები მსოფლიოში, ვიდრე უბრალოდ როგორც და Bs და Cs და Ds.
მართლაც, ASCII არ საკმარისია ბევრი ენების მსოფლიოში.
თუმცა ხმა ამაზე სხვა დროს.
ახლა ვიცი, რომ C, თუ გინდათ წარმოადგინოს წერილი, ნაწილი
პუნქტუაციის, ან უბრალოდ რაღაც ხასიათი ბუნებაში, ჩვენ ვიყენებთ char.
და ეს ერთი byte ან რვა ბიტი.
>> როგორ შესახებ int?
ისე, int არის მთელი რიცხვი.
რამდენი ბიტი, თუ გავიხსენებთ, იყო მთელი, როგორც წესი?
ნებისმიერ მსურველს გაწვევას?
ასე რომ, როგორც წესი, 32.
ეს რეალურად დამოკიდებულია კომპიუტერის რომ თქვენ იყენებთ.
მაგრამ მოწყობილობების, და ბევრი კომპიუტერების, ეს 32 ბიტი ან ოთხი
bytes - რვაჯერ ოთხი.
და ints მხოლოდ გამოიყენება შენახვის ნომრები, ან უარყოფითი,
დადებითი, ან საერთოდ ნულოვანი.
>> და თუ თქვენ გაქვთ 32 ბიტი და მხოლოდ ზრუნავს დადებითი ციფრები, შეიძლება
ვინმეს ballpark რამდენი შესაძლებელი რიცხვებით კომპიუტერული შეუძლიათ ეხლა
ნულოვანი მდე?
ასე რომ, ეს იქნება ორი 32, რომელიც დაახლოებით ოთხი მილიარდი.
ასე რომ, ეს უფლებამოსილება ორი იქნება განმეორებითი თემებზე კომპიუტერული მეცნიერება.
როგორც ჩვენ დავინახავთ, ისინი საკმაოდ მოსახერხებელია ვიმუშაოთ შემთხვევაშიც კი, თუ ეს არ არის საკმაოდ
ადვილია მათემატიკის ერთ თავი.
>> ასე რომ, ჩვენ ვთქვა უხეშად ოთხი მილიარდი.
ახლა, ხანგრძლივი ხანგრძლივი -
შეგიძლიათ სახის ვხვდები.
ეს უფრო მეტია, ვიდრე int.
რამდენი ბიტი?
ასე რომ, 64 ბიტი ან რვა ბაიტს.
ეს უბრალოდ ნიშნავს, თქვენ შეგიძლიათ წარმოადგენს კი უფრო დიდი ციფრები, უპირველესად, დადებითი ან
უფრო დიდი უარყოფითი ნომრები.
>> და რა float?
ეს არის ის, მცურავი წერტილი ღირებულება 32 ბიტი.
ეს არის მხოლოდ რეალური რაოდენობა, რაღაც ერთად ათობითი წერტილი.
მაგრამ თუ თქვენ ნაცვლად მეტი ადგილები მას შემდეგ ათობითი წერტილი ან გსურთ
წარმოადგენს უფრო დიდი რაოდენობის რამდენიმე ფრაქცია მას შემდეგ, შეგიძლიათ გამოიყენოთ
ორმაგი, რომელიც 64 ბიტი.
>> მაგრამ არსებობს საინტერესო takeaway აქ.
ასე რომ, თუ ints შეზღუდულია 32 ბიტი და მაშინაც კი, ხანგრძლივი longs შემოიფარგლება მიერ 64
bits, რომ ერთგვარი სთხოვს კითხვაზე, რა მოხდება, თუ თქვენ ნამდვილად გინდათ ითვლიან
მაღალია, ვიდრე 4 მილიარდი int?
ისე, უბრალოდ გამოიყენოთ ხანგრძლივი ხანგრძლივი.
მაგრამ რა, თუ გსურთ ითვლიან უმაღლესი ვიდრე ორი 64, მისცეს ან?
>> ახლა, რომ ის დიდი რაოდენობით.
თუმცა, საბოლოოდ, შეიძლება რეალურად აინტერესებს ასეთი ღირებულებები,
მით უმეტეს, თუ თქვენ იყენებთ მონაცემთა ბაზა და დაწყებული შეგროვება უამრავი და უამრავი
და უამრავი მონაცემები და იმის უნიკალური ციფრები, ყოველი ნაჭერი რომ მონაცემები.
ასე რომ, ჩვენ ასეთი აქვს პრობლემა.
და ანალოგიურად, ერთად მცურავი წერტილი ღირებულებები - მოძრავი ან ორადგილიანი -
თუ თქვენ მხოლოდ მიიღო სასრულ ნომერი ბიტი, რამდენი საერთო ციფრები შეიძლება თქვენც
შესაძლოა წარმოადგენს?
>> ისე, ეს უფრო ბუნდოვანია, როდესაც თქვენ ჩართვა ათობითი წერტილი.
მაგრამ ეს აუცილებლად სასრული.
თუ თქვენ გაქვთ სასრულ რაოდენობის ბიტი, სასრულ რაოდენობის ადამიანები, სასრულ
რიგი ნათურები, აუცილებლად თქვენ მხოლოდ წარმოადგენენ სასრულ ნომერი
მცურავი პუნქტიანი ღირებულებებს.
მაგრამ რამდენი რეალური ნომრები მათი მსოფლიოში?
აქ არის უსასრულო.
ასე რომ, ასეთი პრობლემა, რადგან ჩვენ არ გვაქვს უსასრულო რაოდენობის
მეხსიერების ან RAM შიგნით ჩვენი კომპიუტერი.
ასე რომ ზოგიერთი რთული რამ შეიძლება მოხდეს.
>> მოდით წავიდეთ წინ და ცდილობენ , გამოხატოს ამ აქ.
ნება მომეცით წავიდეთ წინ და ქმნის gedit.
მე ვაპირებ წავიდეთ წინ და გადარჩენა ფაილი სახელწოდებით "floats0.c" უბრალოდ უნდა იყოს
შეესაბამება მაგალითია იმისა, რომ არის ხელმისაწვდომი, თუ გსურთ.
და მე ვაპირებ წავიდეთ წინ და განისაზღვროს შემდეგი რედაქციით -
მე ვაპირებ წავიდეთ წინ და აცხადებენ, int მთავარი ბათილად, როგორც ჩვენ ხშირად.
>> და მაშინ ამ პროგრამის, მე ვაპირებ ვაცხადებ თავს float, ამიტომ 32-bit
ცვლადში ვ, თვითნებურად.
და მაშინ მე ვაპირებ შესანახად მასში მე არ ვიცი, ერთი მეათე, ასე 0.1.
ამიტომ, მე ვაპირებ, რომ გამოხატოს, რომ როგორც ერთი იყოფა 10, რაც სავსებით
ლეგიტიმური in C.
>> და მერე მეორე ხაზი, უბრალოდ გვინდა ბეჭდვა, რომ მნიშვნელობა.
ასე რომ გავიხსენოთ, რომ ჩვენ შეგვიძლია გამოვიყენოთ ნაცნობი printf.
ჩვენ არ გვინდა გამოვიყენოთ% i for int.
ჩვენ გვინდა გამოვიყენოთ% ვ for float.
და მაშინ მე ვაპირებ გაკეთებას წარმატებული ნ ახლო გაცემა, მძიმე, F, მძიმით.
>> ასე რომ, აქ არის ჩემი პროგრამა.
აქ უკვე ერთი შეცდომა.
არა ვინმე, ვისაც ეს დაწკაპავთ უკვე მინდა აღვნიშნო, სულ მცირე,
ერთი bug მე გააკეთა?
ჰო?
ჰო.
დამავიწყდა "# მოიცავს" at დასაწყისში, მათ სიმპტომია რომელიც, თუ ვცდილობ
შეადგინოს ეს იქნება, რომ შემდგენელი აპირებს დაწეროთ at me,
ამბობდა გაურკვეველ სიმბოლო ან რაღაც რომ ეფექტი.
ეს არ მესმის, რაღაც მინდა printf.
>> ამიტომ, მე ვაპირებ ამის გაკეთება "# მოიცავს "შენახვა ფაილი.
და ახლა უკეთეს ფორმაში.
მაგრამ მე ასევე ვაპირებ ერთი ახალი დეტალი დღეს.
გარდა ამისა, მიუთითებს ადგილი მფლობელები, როგორიც% ვ% i% s, შეგიძლიათ
ზოგჯერ გავლენას ახდენს ქცევის იმ placeholder.
მაგალითად, იმ შემთხვევაში, მცურავი წერტილი ღირებულება, თუ სურს
არიან ერთი ათობითი შემდეგ პერიოდში, შემიძლია რეალურად გააკეთებს 0.1f.
ასე რომ, სხვა სიტყვებით, მე გამოყოფა ვ და პროცენტი ნიშანი ერთად 0.1, უბრალოდ
ვეუბნებოდი printf, ალბათ მთელი რამოდენიმე ნომრები შემდეგ ათობითი
აღვნიშნო ჩემთვის.
მაგრამ მე მხოლოდ გვინდა, რომ ერთი მათგანი.
>> ამიტომ, მე ვაპირებ წავიდეთ წინ ახლა და გადარჩენა ამ პროგრამის წასვლას ჩემს ტერმინალში
ფანჯარა, და მე ვაპირებ წავიდეთ წინ და ტიპის მიიღოს float 0, შევა.
მე ვხედავ, რომ გარკვეულწილად cryptic ხაზი, რომელიც დაიწყება, რათა უფრო გრძნობა, როგორც ჩვენ
tease ის გარდა ამ კვირაში და შემდეგ.
ახლა მე ვაპირებ წავიდეთ წინ და აწარმოებს float ნულოვანი.
ხოლო, რა.
>> ასე რომ, კიდევ ერთი bug აქ რაიმე მიზეზით.
მე პირადად დარწმუნებული ვარ, რომ ერთ მეათე, ან ერთი იყოფა 10, არ არის 0.0.
იქნებ მე მხოლოდ არ ეძებს ერთი საკმარისი ციფრები.
რატომ არ ვამბობ, რომ ორი .2 სანახავად ორი თანრიგს ნაცვლად მხოლოდ ერთი.
ნება მომეცით დაბრუნდეს ჩემი ტერმინალში ფანჯარა აქ და მოხვდა up რამოდენიმე ჯერ
ვხედავ ჩემი ისტორია.
ნუ მიიღოს float ნულოვანი ერთხელ, და შემდეგ კვლავ.
ახლა კი შევა.
>> ახლა კი დარწმუნებული ვარ ეს არასწორია.
და მე ვერ გააკეთებს სამი და ოთხი და მე ალბათ აპირებს შეინარჩუნოს ხედავს zeros.
ასე რომ, სად არის bug?
ერთი იყოფა 10 უნდა იყოს 0.1.
საყვარელი სურთ stab რა ფუნდამენტური საკითხი არის?
ჰო?
ისინი ორივე რიცხვებით.
მერე რა?
ასე რომ, ერთი იყოფა 10 ეს არის ის, რა გავაკეთო არითმეტიკული.
და მე 0.1.
>> ჰო.
ასე რომ, ეს მართლაც რომ ამ საკითხთან დაკავშირებით.
როდესაც შენ მთელი ამ კომპიუტერს და თქვენ ყოფს მას კიდევ ერთი რიცხვი,
კომპიუტერული ჩვეულებრივ აპირებს ვივარაუდოთ, რომ გსურთ რიცხვი.
პრობლემა იმისა, რა თქმა უნდა, რომ 0.1 არ არის მთელი რიცხვი.
ეს რეალური რაოდენობა.
ასე რომ, ის, რაც კომპიუტერში აკეთებს მიერ საწყისად უბრალოდ აგდებს მოშორებით
ყველაფერი მას შემდეგ ათობითი წერტილი.
ეს არ მრგვალ ქვემოთ ან თავისთავად.
უბრალოდ აგდებს მოშორებით ყველაფერი მას შემდეგ ათობითი წერტილი.
ახლა კი, რომ აზრი.
იმის გამო, რომ ახლა ჩვენ ნათლად დარჩა ნულოვანი.
>> მაგრამ დაველოდოთ წუთში.
მე არ ხედავს int ნულოვანი.
მე რეალურად ხედავს 0.00.
ასე რომ, როგორ შემიძლია შერიგება ეს ახლა მოხდეს?
თუ ერთი იყოფა 10 ნულის ტოლია, მაგრამ მე ხედავს, 0.00, სადაც ის მისაღებად
მოაქცია უკან რეალური რაოდენობა?
ჰო.
ზუსტად.
>> ასე რომ, აქ შეესაბამება ხუთი, როდესაც მე რეალურად შესანახად, რომ 0.1, რომელიც შემდგომ
truncated ნულის, შიგნით float, ეს არის ის ეფექტურად ექვივალენტურია
შენახვის არა როგორც int, მაგრამ, მართლაც, როგორც float.
უფრო მეტიც, მე მაშინ გამოყენებით printf to მკაფიოდ ბეჭდვა, რომ ნომერი ორი
თანრიგს მიუხედავად იმისა, შესაძლოა, რეალურად არ იყოს.
>> ასე რომ, ამ სახის sucks, არა?
როგორც ჩანს თქვენ არ შეუძლია მათემატიკის, მინიმუმ ამ დონის
სიზუსტით, შემდეგ კომპიუტერში.
მაგრამ ნამდვილად არსებობს გამოსავალი.
რა არის მარტივი გადავწყვიტოთ შეგვეძლო იქნებ ამის გაკეთება, თუნდაც მხოლოდ ინტუიციურად აქ
მოსაგვარებლად?
ჰო?
ჩართეთ რიცხვებით შევიდა -
ჰო.
მაშინაც კი, თუ მე არ ვარ სრულიად დარწმუნებულია რა სინამდვილეში აქ, თუ იგი
ძირეულად უნდა გააკეთოს, ამ ორივე როგორც ints, ასევე, რატომ არ
გააკეთოს, რომ 10.0, რაც ამ 1.0, resave ფაილი.
ნება მომეცით დაბრუნდეს ქვემოთ ბოლოში და recompile.
ნება მიბოძეთ ახლა გამეორება.
და აი -
ახლა, მე მივიღე ჩემი მეათედი წარმოდგენილია როგორც 0.10.
>> ყველა უფლება.
ასე რომ, ეს არ არის ცუდი.
და ნება მომეცით აღვნიშნო, კიდევ ერთი გზა ჩვენ შეგვეძლო გადაწყდება ეს.
ნება მომეცით, ფაქტობრივად, გააფართოვოს უკან დრო როდის გვქონდა, როგორც ერთი
მეათე მომენტში წინ.
და ნება მომეცით წავიდეთ წინ და resave ეს ფაილი როგორც სხვადასხვა ფაილის სახელი, მხოლოდ
ცოტა საგუშაგოს.
ასე რომ, ეს იყო მობილური ერთი.
ახლა კი ნება მომეცით წავიდეთ წინ და გავაკეთოთ კიდევ ერთი ვერსია.
ჩვენ ამას დავარქმევთ მობილური ორი ნულოვანი ინდექსირებული.
>> და მე ვაპირებ, რომ ამის სანაცვლოდ გააკეთებს ამ - იცით რა?
დამატება dot ნულოვანი მუშაობს ამ შემთხვევაში.
თუმცა ვარაუდობენ, ერთი იყო განსხვავებულია.
სავარაუდოდ 10 იყო განსხვავებულია.
სხვა სიტყვებით, ვივარაუდოთ, რომ მე ვერ მხოლოდ მყარი კოდი .0 დასასრულს
ამ არითმეტიკული გამოსახულება.
ისე, მე შეიძლება რეალურად რომ რამე ფრჩხილებში მოუწოდა აძლევენ.
შემიძლია მიცემული, რომ მთელი 10 float, და შემიძლია მიცემული, რომ მთელი ერთი
float, ასევე.
მაშინ მათემატიკის რომ აპირებს გასაკეთებელი ეფექტურად 1.0 იყოფა 10.0,
შედეგია, რომელიც მიდის ფა, როგორც ადრე.
ასე რომ, თუ მე recompile ეს გააკეთოს მოძრავი 2 და ახლა floats 2, მე იგივე
პასუხის გაცემა, ასევე.
>> ასე რომ, ეს საკმაოდ contrived მაგალითად, ამ პრობლემის მოგვარებას
შემოღება გააპროტესტეს.
მაგრამ ზოგადად, ჩამოსხმის იქნება ძლიერი რამ, განსაკუთრებით
პრობლემა მითითებული ორი კვირის შემდეგ, როდესაც თქვენ აკონვერტირებთ ერთი მონაცემების ტიპის
კიდევ ერთი, რომ დღის ბოლოს წარმოდგენილნი არიან ანალოგიურად.
შეხვედრის დასასრულს დღეს, თითოეული რამ ჩვენ ვისაუბრეთ დღემდე არის
უბრალოდ ints ქვეშ hood.
ან თუ რა დაბალი დონე თქვენ, ისინი უბრალოდ ნომრები
ქვეშ Hood.
მაშინაც კი, პერსონაჟი, კიდევ ერთხელ იხსენებენ ეხლა კვირას ნულოვანი, არის ციფრები
ქვეშ Hood.
>> რომელი ვთქვა, ჩვენ შეგვიძლია გარდაქმნას შორის სხვადასხვა ტიპის ნომრები, თუ
ისინი უბრალოდ ბიტი.
ჩვენ შეგვიძლია გარდაქმნას შორის ნომრები და წერილები, თუ ისინი უბრალოდ
bits, და პირიქით.
და აძლევენ ამ გზით მექანიზმი პროგრამირებაში რომ გაძლევთ იძულებით
შეიცვლება ერთი ტიპის მონაცემის სხვა.
სამწუხაროდ, ეს არ არის, როგორც პირდაპირი, როგორც მე შეიძლება არ მომეწონა.
>> მე ვაპირებ წასვლა ისევ მოძრავი 1, რომელიც უფრო მარტივი, უფრო
პირდაპირი ერთი .0 დამატებები ყოველი.
და როგორც სწრაფი refresher, ნება მომეცით წავიდეთ წინ და recompile
ამ გააკეთოს მოძრავი 2 -
ვწუხვარ, რომ ეს არის მიიღოს მოძრავი 1.
ახლა კი მოდით აწარმოებს მოძრავი 1.
ხოლო ბოლოში, შეამჩნია რომ მე ნამდვილად მისაღებად 0.1.
ასე რომ, პრობლემა მოგვარდება.
>> მაგრამ ჯერ არ არის.
მე ახლა ვაპირებ ცოტა უცნაურ, და მე ვაპირებ დაბრუნდეს ჩემს
printf განცხადება და აცხადებენ, იცით რა?
მინდა დავადასტურო, რომ ამ მართლაც მეათედი.
და მე ვაპირებ გვინდა, რომ ამ to, ვთქვათ, ხუთი ათობითი ადგილებში.
ეს არ არის პრობლემა.
შევცვალო ორიდან ხუთ, მე recompile ერთად მიიღოს.
I გამეორება იქნება, როგორც floats 1.
ვეძებთ საკმაოდ კარგი.
ჩემი საღი აზრის ამოწმებს შეიძლება დასრულდეს, მაგრამ მე მისაღებად უფრო თამამი.
მე ვაპირებ, რომ შეიცვალოს 0.5-დან 0.10.
მსურს, რომ 10 ნიშნა შემდეგ ათობითი ადგილი.
>> და მე ვაპირებ წავიდეთ წინ და recompile ამ და გამეორება floats 1.
I ტიპის სინანული რომელმაც ტესტირება ამ შემდგომი იმიტომ, რომ ჩემი მათემატიკის ასე არ არის
გამოსწორებას აღარ ჩანს.
მაგრამ დაველოდოთ ერთი წუთით, იქნებ ეს მხოლოდ fluke.
შესაძლოა კომპიუტერში მოქმედებს ცოტა უცნაურია.
ნება მომეცით წავიდეთ წინ და გააკეთოს 20 ათობითი რაოდენობა და დარწმუნება თავს, რომ მე ვიცი
როგორ უნდა გავაკეთოთ მათემატიკის.
მე ვიცი, როგორ უნდა პროგრამა.
სასტარტედ მოძრავი 1, recompile და რა იგი.
სწორედ რეალურად, მართლაც მისაღებად შორს ნიშნის.
>> ასე რომ, რა ხდება აქ?
ინტუიციურად, ჩვენი ვარაუდები ადრე ზომის მონაცემთა ტიპები,
რა უნდა ხდება აქ ქვეშ hood?
ჰო?
ზუსტად.
თუ გსურთ ამ დიდი სიზუსტით, და ეს არის ის, heck უამრავ სიზუსტით -
20 ნომრები შემდეგ ათობითი წერტილი.
თქვენ არ შეიძლება წარმოადგენს თვითნებური ნომერი თუ თქვენ გაქვთ
თვითნებური რაოდენობის ბიტი.
მაგრამ ჩვენ არ.
იყიდება float, ჩვენ მხოლოდ 32 ბიტი.
>> ასე რომ, თუ 32 ბიტი შესაძლებელია მხოლოდ permuted in გზა - ისევე, როგორც ჩვენი ადამიანები, ხოლო სცენაზე
ხელში ან ქვემოთ - ამ სასრულ ნომერი გზა, იქ მხოლოდ სასრული რაოდენობის
უძრავი ნომრები შეგიძლიათ წარმოადგენს იმ ბიტი.
ასე რომ, კომპიუტერში საბოლოოდ აპირებს უნდა
დაიწყოს ჭრის კუთხეში.
კომპიუტერული შეუძლია დამალვა იმ დეტალებზე ეხლა ჩვენთვის ცოტა დრო.
მაგრამ თუ ჩვენ დავიწყებთ გააღიზიანოს ნომრები და ეძებს შემდგომი და შემდგომი ზე
არასასურველი ნომრების მთელი რიცხვი, მაშინ ჩვენ დავიწყებთ, რომ ეს
რეალურად approximating იდეა მეათედი.
>> ასე რომ, გამოდის, ტრაგიკულია, რომ არსებობს უსასრულო რაოდენობის ნომრები
ჩვენ არ შეგვიძლია წარმოადგენს ზუსტად კომპიუტერი, მაინც სასრულ
რაოდენობის ბიტი, სასრულ თანხის ოპერატიული.
ახლა სამწუხაროდ, ეს ზოგჯერ აქვს რეალური შედეგები.
თუ ადამიანს არ საკმაოდ ვაფასებთ ამ ან სახის თავისთავად ფაქტი
რომ მათი კომპიუტერი უბრალოდ რა უთხრეს მას ამის გაკეთება და არ
კარგად ესმის ეს ფუძემდებლური წარმომადგენლობის დეტალები -
რაც, გულწრფელად, ზოგიერთ ენაზე ლაპარაკობს დაფარული მომხმარებელი, განსხვავებით C -
რამდენიმე ცუდი რამ შეიძლება მოხდეს.
>> და რა მეგონა, ჩვენ მინდა გაკეთება არის მიიღოს უკან გადადგმული ნაბიჯია.
და ეს არის დაახლოებით რვა წუთიანი ვიდეო.
იგი ეთერში რამდენიმე წლის წინ, და ეს იძლევა insights შევიდა რეალურად როგორ შეიძლება
არასწორია, როდესაც თქვენ წლამდე ვაფასებთ ამ სახის ვრცლად ძალიან ყველა ძალიან
რეალურ ცხოვრებაში.
თუ შეგვეძლო dim განათება რამდენიმე წუთის განმავლობაში.
>> დინამიკები 1: ჩვენ ახლა დაბრუნდნენ საინჟინრო
კატასტროფების თანამედროვე Marvels.
>> კომპიუტერები -
ჩვენ ყველა მოდის მიიღოს ხშირად სამწუხარო პრობლემები
რომ წავიდეთ მათთან.
Bugs, ვირუსებს, და პროგრამული უზრუნველყოფის glitches ეს არის პატარა ფასები გადაიხადონ
მოხერხებულობისთვის.
მაგრამ მაღალტექნოლოგიური და მაღალი სიჩქარით სამხედრო და სივრცეში პროგრამა
განცხადებები, პატარა პრობლემა შეიძლება magnified შევიდა უბედურება.
>> 4 ივნისს, 1996, მეცნიერები მზად დაიწყოს უპილოტო Ariane 5 რაკეტა.
ეს იყო დატვირთული სამეცნიერო თანამგზავრების შექმნილია ჩამოყალიბება, ზუსტად როგორ
დედამიწის მაგნიტური ველი ურთიერთქმედებს ერთად მზის ქარი.
სარაკეტო აშენდა ევროპის კოსმოსური სააგენტო და გააუქმა off მისი
დაწესებულებაში სანაპიროზე ფრანგული გვიანა.
>> JACK GANSSLE: დაახლოებით 37 წამი შევიდა ფრენის, ისინი პირველად შენიშნა
რაღაც ხდებოდა არასწორია.
საქშენები იყო swiveling in ასე ნამდვილად არ უნდა.
დაახლოებით 40 წამი შევიდა ფრენის, ნათლად მანქანა არ იყო.
და ეს მაშინ, როდესაც ისინი გააკეთა გადაწყვეტილება გაანადგუროს იგი.
სპექტრი უსაფრთხოების ოფიცერი, რომელიც უზარმაზარი guts, დაპრესილი ღილაკს
ააფეთქეს სარაკეტო, სანამ შესაძლებელი იქნებოდა გახდება საშიშროების საჯარო უსაფრთხოებას.
>> დინამიკები 1: ეს იყო maiden voyage საქართველოს Ariane 5, და მისი განადგურება
მოხდა იმიტომ, რომ ნაკლი ჩართული ამ სარაკეტო ის პროგრამული.
>> JACK GANSSLE: პრობლემა Ariane იყო, რომ იქ ნომერი
რომ საჭირო 64 bits, გამოხატონ.
ხოლო მათ სურდათ გარდაქმნას to 16-bit ნომერი.
ისინი ფიქრობდნენ, რომ ნომერი, არასდროს ყოფილა იქნება ძალიან დიდი, რომ ყველაზე
იმ ციფრები in 64-bit ნომერი იყო zeros.
ისინი არასწორია.
>> დინამიკები 1: უუნარობა ერთ პროგრამული პროგრამა, მიიღოს სახის
ნომერი მიერ კიდევ ერთი ქართველი ერთი ძირი უკმარისობა.
პროგრამული უზრუნველყოფის დამუშავების გახდა ძალიან ძვირადღირებული ნაწილი ახალი ტექნოლოგიები.
Ariane 4 სარაკეტო იყო ძალიან წარმატებული, იმდენად, რამდენადაც პროგრამული
შექმნილი ეს იყო გამოიყენება Ariane 5.
>> PHILIP COYLE: ძირითადი პრობლემა იყო ის, რომ Ariane 5 იყო სწრაფად,
დააჩქარა სწრაფად.
და პროგრამული უზრუნველყოფის არ ჰქონდა აღრიცხული, რომ.
>> დინამიკები 1: განადგურების სარაკეტო იყო დიდი ფინანსური კატასტროფის
ყველა გამო წუთი პროგრამული შეცდომა.
მაგრამ ეს არ არის პირველი შემთხვევა მონაცემები კონვერტაციის პრობლემები ჰქონდა ხშირია თანამედროვე
სარაკეტო ტექნოლოგია.
>> JACK GANSSLE: 1991, ერთად დაწყებას პირველი ყურის ომი, პატრიოტი
სარაკეტო გამოცდილი მსგავსი რიგი კონვერტაციის პრობლემა.
შედეგად, 28 ამერიკელი ჯარისკაცი დაიღუპა და დაახლოებით 100 დაიჭრა
როდესაც პატრიოტთა, რომელიც უნდა დაიცვას შემოსულ Scuds,
ვერ მოხერხდა ხანძრის რაკეტა.
>> დინამიკები 1: როცა ერაყში შეიჭრა ქუვეითი და ამერიკის დაიწყო უდაბნოს ქარიშხალი
ადრეულ 1991 წელს პატრიოტთა სარაკეტო ბატარეები განალაგეს დასაცავად საუდის არაბეთში
და ისრაელს ერაყის Scud სარაკეტო თავდასხმები.
პატრიოტის არის აშშ საშუალო დიაპაზონი ზედაპირულად ჰაერის სისტემის მიერ წარმოებული
RAYTHEON კომპანია.
>> THEODORE postol: ზომის პატრიოტის interceptor თავისთავად უხეშად
20-ფეხები ხანგრძლივი.
და ეს იწონის დაახლოებით 2000 ფუნტი.
და იგი ახორციელებს საბრძოლო ქობინი შესახებ -
მე ვფიქრობ, დაახლოებით 150 ფუნტი.
და ქობინით თავისთავად მაღალი ასაფეთქებელი, რომელსაც აქვს
ფრაგმენტები გარშემო.
გარსაცმის of ქობინით განკუთვნილია to ვმოქმედებთ buckshot.
>> დინამიკები 1: რაკეტები ხორციელდება ოთხი თითო კონტეინერი და ტრანსპორტირება
by ნახევრად მისაბმელიანი.
>> PHILIP COYLE: პატრიოტის რაკეტსაწინააღმდეგო სისტემის მიდის უკან
მინიმუმ 20 წელია.
თავდაპირველად შექმნილია როგორც საჰაერო თავდაცვის სარაკეტო to
ჩამოაგდებენ მტრის თვითმფრინავები.
პირველ ყურის ომი, როდესაც ომი მოვიდა ერთად, არმიის სურდა მის გამოყენებას
ჩამოაგდებენ Scuds, არ თვითმფრინავები.
ერაყის საჰაერო ძალების არ იყო იმდენად, რამდენადაც პრობლემაა.
მაგრამ არმია აწუხებს Scuds.
ასე რომ მათ სცადეს განახლება პატრიოტთა.
>> დინამიკები 1: Intercepting მტრის სარაკეტო მოგზაურობა at Mach ხუთ იყო
უნდა გამოწვევას საკმარისი.
მაგრამ როდესაც პატრიოტთა იყო შევარდა მომსახურება, არმია არ იცის
ერაყის მოდიფიკაცია რომ გააკეთეს Scuds თითქმის შეუძლებელია მოხვდა.
>> THEODORE postol რაც მოხდა არის Scuds, რომლებიც
მოსვლის იყო არასტაბილურია.
ისინი wobbling.
მიზეზი ის იყო, ერაყელები, ამ იმისათვის, რომ 600 კილომეტრის გარეთ
300 კილომეტრიანი რადიუსის რაკეტა, აიღო წონა გარეთ წინ ქობინით.
ისინი საარჩევნო ქობინით მსუბუქია.
ასე რომ, ახლა პატრიოტთა ცდილობს მოვა at Scud.
და ყველაზე მეტად დროს, აბსოლუტური უმრავლესობა დროს, ის უბრალოდ
ფრენა მიერ Scud.
>> დინამიკები 1: ერთხელ პატრიოტის სისტემის ოპერატორები მიხვდა პატრიოტის ხელიდან გაუშვა
მისი სამიზნე, მათ აფეთქდა პატრიოტთა ქობინით რათა თავიდან ავიცილოთ შესაძლო
მსხვერპლი, თუ იგი ეძლეოდა დაეცემა, რათა ადგილზე.
>> THEODORE postol: ეს იყო, რაც ყველაზე ადამიანი დაინახა, როგორც დიდი fireballs ცაში
და არასწორად როგორც საუბრების საქართველოს Scud ქობინი.
>> დინამიკები 1: მიუხედავად იმისა, რომ ღამის ცის პატრიოტთა აღმოჩნდა წარმატებით
განადგურება Scuds საათზე Dhahran არსებობს შეიძლება იყოს შეცდომა მის
შესრულება.
იქ, პატრიოტთა სარადარო სისტემის დაკარგა სიმღერა შემომავალი Scud და არასდროს
დაიწყო გამო პროგრამული ხარვეზი.
>> ეს იყო ისრაელის, რომლებიც პირველად აღმოაჩინეს რომ აღარ სისტემა
იყო, დიდი დრო განსხვავება გახდა გამო საათის
ჩართული სისტემა კომპიუტერში.
>> JACK GANSSLE: დაახლოებით ორი კვირით ადრე ტრაგედიის Dhahran, ისრაელის
იტყობინება თავდაცვის დეპარტამენტის რომ სისტემა დაკარგვის დროს.
მას შემდეგ, რაც დაახლოებით რვა საათის გაშვებული, მათ შენიშნეს, რომ სისტემა
ხდება შესამჩნევად ნაკლებად ზუსტი.
თავდაცვის დეპარტამენტის გამოეხმაურა ვეუბნებოდი ყველა პატრიოტის ბატარეები
to არ დატოვებს სისტემები მე დიდი ხანია.
ისინი არ ამბობს, რა დიდი დრო იყო.
რვა საათი?
10 საათის განმავლობაში?
1000 საათი?
არავინ იცის.
>> დინამიკები 1: პატრიოტის ბატარეის დისლოცირებული ზე ყაზარმებში at Dhahran
და მისი ყალბი შიდა საათის ყოფილა ზე მეტი 100 საათი ღამეს
25 თებერვალს.
>> JACK GANSSLE: ეს დააფიქსირა, დრო, სისწორის შესახებ მეათე მეორე.
ახლა მეათე მეორე საინტერესო ნომერი, რადგან იგი არ შეიძლება იყოს
გამოხატული ბინარული ზუსტად, რაც იმას ნიშნავს, მას არ შეუძლია იყოს გამოხატული ზუსტად
ნებისმიერი თანამედროვე ციფრული კომპიუტერი.
ეს დაუჯერებელია, მაგრამ გამოიყენოს ეს როგორც მაგალითი.
ავიღოთ ნომერ მესამე.
ერთი მესამედი არ შეიძლება გამოთქვა in ათობითი ზუსტად.
ერთი მესამე 0,333 აპირებს მიმდინარეობდა უსასრულობა.
არ არსებობს გზა უნდა გააკეთოს, რომ აბსოლუტური სიზუსტით in ათობითი.
სწორედ მსგავსი პრობლემა მომხდარ პატრიოტთა.
აღარ სისტემა გაიქცა, ყველაზე ცუდი დრო შეცდომა გახდა.
>> დინამიკები 1: მას შემდეგ, რაც 100 სამუშაო საათები, შეცდომა იყო მხოლოდ
დაახლოებით ერთი მესამედი მეორე.
მაგრამ თვალსაზრისით გათვლილი სარაკეტო მოგზაურობა at Mach ხუთი, ეს შედეგად
თვალთვალის ცდომილება მეტი 600 მეტრია.
ეს იქნება ფატალური შეცდომა for ჯარისკაცებთან Dhahran.
>> THEODORE postol რაც მოხდა არის Scud დაწყებას გამოვლინდა ადრეული
გაფრთხილების თანამგზავრების.
და მათ იცოდნენ, რომ Scud მოდიოდა მათი საერთო მიმართულებით.
არ იცოდნენ, სადაც იგი მოდიოდა.
>> დინამიკები 1: ახლა მდე სარადარო კომპონენტი პატრიოტის სისტემის
იცავდა Dhahran to იქნებიან და შეინახოს სიმღერა შემომავალი მტრის რაკეტა.
>> JACK GANSSLE: სარადარო იყო ძალიან ჭკვიანი.
კარგი იქნებოდა, ფაქტობრივად, თვალყური თანამდებობაზე Scud და შემდეგ პროგნოზირება, სადაც იგი
ალბათ იქნება მომავალი დრო რადარის გაგზავნილი პულსი გარეთ.
ამის მოუწოდა დიაპაზონი კარიბჭე.
>> THEODORE postol: მაშინ ერთხელ პატრიოტის გადაწყვეტს საკმარისი დრო გავიდა წასვლა
უკან და შემოწმება მომდევნო ადგილმდებარეობა ამ აღმოჩენილი ობიექტი, იგი ბრუნდება.
ასე რომ, როდესაც იგი დაბრუნდა არასწორი ადგილი, მაშინ ვერ ხედავს ობიექტი.
და იგი გადაწყვეტს, რომ არ არსებობს ობიექტი, ეს იყო ყალბი გამოვლენის და
მცირდება გზაზე.
>> დინამიკები 1: შემომავალი Scud გაქრა ეხლა რადარის ეკრანზე, და
წამში მოგვიანებით გააკრიტიკა შევიდა ყაზარმებში.
Scud დაიღუპა 28 და ბოლო იყო გასროლა პირველი ყურის ომი.
ტრაგიკულია, განახლებული პროგრამული ჩავიდა at Dhahran მომდევნო დღეს.
პროგრამული ხარვეზი იყო დაფიქსირებული, დახურვის ერთი თავი პრობლემური
ისტორიის პატრიოტის რაკეტა.
>> პატრიოტის ფაქტიურად აკრონიმი ამისთვის ეტაპობრივი Array თვალთვალის
ჩაჭრა სამიზნე.
>> დავით J Malan ყველა უფლება, sobering მაგალითად, დარწმუნებული უნდა იყოს.
და საბედნიეროდ, ეს უფრო დაბალი დონის შეცდომები არ არის ის, რაც ჩვენ გამოგიგზავნით
როგორც წესი, უნდა ვაფასებ, რა თქმა უნდა არა ზოგიერთი ჩვენი
ადრეული პროგრამები.
პირიქით, ყველაზე შეცდომებს თქვენ ნაცნობობა იქნება ლოგიკური ბუნება,
სინტაქსური ხასიათის რომლის კოდი უბრალოდ არ მუშაობს უფლება.
და იცით ეს საკმაოდ სწრაფად.
>> მაგრამ განსაკუთრებით მაშინ, როცა ჩვენ მისაღებად სემესტრის ბოლოს, იგი აპირებს
სულ უფრო და უფრო შესაძლებლობა ნამდვილად ვფიქრობ, მძიმე შესახებ დიზაინი
თქვენი პროგრამებისა და ძირითადი წარმომადგენლობა
იქ, ძალიან, საქართველოს მონაცემები.
მაგალითად, ჩვენ გააცნობს MySQL, რაც პოპულარულია მონაცემთა ბაზის ძრავა
რომ თქვენ შეგიძლიათ გამოიყენოთ ერთად საიტები შესანახად მონაცემების უკან ბოლომდე.
და თქვენ უნდა დაიწყოს, გადაწყვიტონ ზე სემესტრის ბოლოს არა მარტო რა
სახის მონაცემების გასწვრივ ამ ხაზების გამოყენება მაგრამ ზუსტად რამდენი ბიტი გამოიყენოს,
თუ არა გსურთ შესანახად თარიღების როგორც თარიღები და ჯერ ჯერ, და ასევე
რამ, როგორიცაა რამდენად დიდი გინდათ უნიკალური პირადობის მოწმობა იყოს, ვთქვათ, მომხმარებლებს
თქვენს მონაცემთა ბაზაში.
>> რეალურად, თუ ზოგიერთ თქვენგანს არ ჰქონდა Facebook ითვლის საკმაოდ გარკვეული დრო,
და თქვენ იცით, თუ როგორ უნდა მიიღონ დაშვება თქვენი მომხმარებლის ID -
რაც ზოგჯერ გვიჩვენებს up თქვენს ნახვა ნახვა URL თუ თქვენ მიერ არჩეული
მეტსახელად for URL, ან თუ თქვენ გამოყენებული Facebook-ის Graph API,
საჯაროდ ხელმისაწვდომი API მიერ, რომელიც თქვენ შეგვიძლია მოვითხოვოთ Facebook ნედლეულის მონაცემები -
თქვენ ხედავთ, რა თქვენი რიცხვითი ID არის.
და რამდენიმე წლის წინ, Facebook არსებითად ჰქონდა უნდა შეიცვალოს გამოყენებით
ეკვივალენტს ints გამოყენებას ხანგრძლივი ხანგრძლივი რადგან დროთა განმავლობაში, როგორც წევრებს მოვა
და წავიდეთ და შევქმნათ უამრავი ანგარიშები და ყალბი ანგარიშები, თუნდაც ისინი ძალიან ადვილად
შეძლეს იწურება რაღაც 4 მილიარდი შესაძლო მნიშვნელობა, როგორიცაა int.
>> ასე რომ, უფრო იმ სახის საკითხები ქვემოთ გზა, ასევე.
ყველა უფლება, რომელიც აძლევენ.
ეს იყო ორაზროვნება.
რამდენიმე სწრაფ განცხადებები.
ასე სექციები ოფიციალურად დაიწყოს ამ მოდის კვირა, ორშაბათს, სამშაბათს.
თქვენ მოისმენს ფოსტით მოგვიანებით ამ კვირაში როგორც თქვენი მონაკვეთზე საბუთი.
და თქვენ აქვე იმ ეტაპზე რამდენად შეცვლას მონაკვეთზე, თუ თქვენი
გრაფიკი უკვე შეცვალა ან თქვენი კომფორტის დონე უკვე შეიცვალა.
ამასობაში P-ნაკრები ერთი და ჰაკერების ერთ ვართ გამო ამ ხუთშაბათი with არჩევანი
ვრცელდება, რომ ვადა პოსტი სპეციფიკაციები პარასკევის
in ტიპიური გზა.
>> გააცნობიერონ, რომ მათ შორის პრობლემა კომპლექტი სპეციფიკაციები ინსტრუქციებით
როგორ უნდა გამოიყენონ CS50 მოწყობილობების, რათა, ასევე CS50 კონკრეტული საშუალებები
ისევე, როგორც სტილის 50, რომელიც გთავაზობთ გამოხმაურებებით დინამიურად წლის
ხარისხი თქვენი კოდი სტილი და ასევე შეამოწმოს 50, რომელიც გთავაზობთ
დინამიური კავშირი, როგორც თქვენი კოდექსის სისწორე.
აპატიებს, რომ ჩვენ ჯერ კიდევ დაუთოება რამდენიმე ქინქსის ერთად გამშვები 50.
რამდენიმე თქვენი თანაკლასელები, რომელიც ვერ დაიწყებს დაახლოებით ოთხი საათზე პარასკევს ღამით, როდესაც
სპეც ავიდა არ შენიშნა მას შემდეგ რამდენიმე შეცდომები, რომ ვმუშაობთ
მეშვეობით და ბოდიშს ყველას, ვინც გამოცდილი გაუმართლებელი იმედგაცრუებები.
ბრალი ჩემია.
მაგრამ ჩვენ თვალყური on CS50 განვიხილოთ, როცა წყდება.
>> ასე რომ, სიტყვა ქულით თავს.
ასე რომ, ეს იქნება ორი კვირის, სანამ დავიწყოთ მიიღონ კომენტარები პრობლემების კომპლექტი
იმიტომ, რომ თქვენ ჯერ კიდევ არ აქვს სწავლების თანამემამულე.
და მაშინაც, დავიწყებთ შევაფასოთ C პრობლემა ადგენს სანამ ჩვენ
დაბრუნდეს და შეაფასოს ნულიდან იმდენად რომ თქვენ უფრო შესაბამისი
კავშირი უფრო სწრაფად.
მაგრამ ზოგადად პოსტი სილაბუსი, CS50 პრობლემა კომპლექტი ფასდება გასწვრივ
შემდეგ ოთხი ღერძი -
ფარგლებში, სისწორეში, დიზაინი, და სტილი.
>> სფერო იქნება ნომერი, როგორც წესი, შორის ნულოვანი და ხუთი, რომ
იღებს, თუ რამდენად ცალი, რომ თქვენ ცოტა off.
როგორც წესი, გნებავთ ეს იყოს ხუთი.
თქვენ სულ მცირე შევეცადე ყველაფერი.
და შეამჩნია ეს multiplicative ფაქტორი ასე, რომ ამით მხოლოდ ნაწილი
პრობლემა ნაკრები არ არის საუკეთესო სტრატეგიას.
>> ამავდროულად, უფრო თვალსაჩინოს არის მნიშვნელობა სისწორე -
უბრალოდ თქვენი პროგრამის სწორი ერთად მიმართ დაზუსტება?
ეს შეწონილი განზრახ მეტი მძიმედ, ვიდრე დანარჩენი ორი ღერძი მიერ
ფაქტორი სამი იმიტომ, რომ ჩვენ ვაღიარებთ რომ, როგორც წესი, თქვენ აპირებს დახარჯოს
გაცილებით მეტი დრო გატანა ქვემოთ გარკვეული შეცდომები, მიღების თქვენი კოდი მუშაობა, მაშინ
მათ indenting მას და ვირჩევთ შესაბამისი ცვლადის სახელები და
მინდა, რომელიც ჩაეგდო სპექტრის სტილის.
>> ეს არ არის იმის თქმა, სტილი არ არის მნიშვნელოვანია და ჩვენ იქადაგა, რომ მეტი
დრო, როგორც ლექციებს და სექციები.
სტილი ეხება ესთეტიკის თქვენი კოდი.
თქვენ მიერ არჩეული კარგად დაასახელა ცვლადები , რომლებიც მოკლე, მაგრამ გარკვეულწილად
აღწერილობითი?
თქვენი კოდი indented როგორც ვნახე წელს ლექცია და ისე თანმიმდევრული
სტილი 50?
>> და ბოლოს არის დიზაინის უფლება იქ ცენტრიდან.
დიზაინი არის უფრო რთული ერთი დააყენოს თითი იმიტომ, რომ ის ბევრად უფრო
სუბიექტური.
მაგრამ ეს, ალბათ, ყველაზე მნიშვნელოვანი სამი ღერძი თვალსაზრისით პედაგოგიური
ღირებულება დროთა განმავლობაში და რომ ეს იქნება სწავლების მონაწილის შესაძლებლობა
მოგაწვდით ხარისხიანი კავშირი.
მართლაც, CS50 მიუხედავად იმისა, რომ გვაქვს ეს ფორმულები და ქულები, ბოლოს
დღეს ეს არის სრულიად შეგნებულად ძალიან მცირე თაიგულების - პუნქტიანი ღირებულებები
შორის ნულოვანი და სამი და ნულოვანი და ხუთ.
ჩვენ არ ცდილობენ მიაპყროს ძალიან უხეში ხაზები შორის პრობლემა კომპლექტი შორის ან
სტუდენტები არამედ ფოკუსირება, როგორც ჩვენ შეგვიძლია ხარისხობრივი, longhand
კავშირი, ან ნაბეჭდ ან ზეპირი დან თქვენი კერძოდ სწავლების თანამემამულე,
თქვენ მიიღებთ იცნობენ.
>> მაგრამ ზოგადად, ეს არის წონით რომ სხვადასხვა ღერძი ექნება.
იმავდროულად, ძალიან, ღირს შენახვა ძალაუნებურად, რომ თქვენ არ უნდა ვივარაუდოთ, რომ
სამი ხუთიდან არის 60% ამიტომ უხეშად ვერ.
სამი განზრახ ნიშნავს, რომ სახის შუა გზაზე კარგი.
თუ თქვენ მისაღებად threes ზე დასაწყისში სემესტრში, სწორედ
მართლაც ნიშნავს, რომ კარგი მიიტანეთ უნდა დაიწყოს.
თუ თქვენ მისაღებად twos, ბაზრობების, არ არსებობს აუცილებლად სადღაც სამუშაო გადაიხადოს პატარა
მეტი ყურადღება, ისარგებლოს საქართველოს სექციები და საათებში.
>> თუ თქვენ მისაღებად fours და fives, დიდი.
მაგრამ ნამდვილად, ჩვენ ვიმედოვნებთ, რომ ნახოთ ტრაექტორიების დაზუსტებისთვის სტუდენტებს შორის - ძალიან
ინდივიდუალური თითო სტუდენტი, მაგრამ დაწყებული სემესტრის აქ ერთგვარი
ორი სამი სპექტრი, მაგრამ დამთავრებული აქ ამ ოთხი ხუთი დიაპაზონი.
ეს არის ის, რასაც ჩვენ ნამდვილად ეძებს.
და ჩვენ გვახსოვდეს დელტა, რომ თქვენ გამოფენებში შორის კვირაში ნულოვანი და კვირაში
12 როდესაც მე ვაკეთებ შეფასება.
არ აქვს მნიშვნელობა, ჩვენთვის აბსოლუტურად თუ როგორ თქვენ სამართლიანად დასაწყისში, თუ თქვენი
ტრაექტორია მართლაც აღმავალი და ძლიერი.
>> აკადემიური პატიოსნება - ასე რომ ნება მიბოძეთ, ჩემი უფრო სერიოზული ხმა მხოლოდ ერთი წუთით.
ასე რომ, ეს კურსი აქვს განსხვავება გაგზავნის მეტი სტუდენტები, ვიდრე რომელიმე სხვა
ისტორიაში დაფა, მე მჯერა.
ჩვენ გვყავს სახის დაკარგა რაოდენობა ამ წერტილი რამდენად ხშირად ეს ხდება.
და ეს არა იმიტომ, რომ სტუდენტების 50 რაიმე უფრო არაკეთილსინდისიერი, ვიდრე მათი
თანაკლასელები მის ფარგლებს გარეთ.
მაგრამ გააცნობიეროს, ძალიან, რომ ჩვენ ძალიან კარგი ზე გამოვლენის ასეთი რამ.
>> და ეს არის უპირატესობა, რომ კომპიუტერული მეცნიერების კლასი აქვს, რომ ჩვენ
შეუძლია და ჩვენ შევადარებთ ყველა სტუდენტი პრობლემა ადგენს წყვილი-ბრძენი წინააღმდეგ ყველა
სხვა, არა მარტო ამ წლის მაგრამ ყველა წინასწარი წელი.
ჩვენ შეგვიძლია ასეთი, ისევე როგორც სტუდენტების კლასი, რომ Google და იპოვონ კოდი
საიტები, როგორიცაა github და ფორუმი.
არსებობს აბსოლუტურად გადაწყვეტილებების CS50-ს P-აწესებს მცურავი გარშემო არსებობს.
მაგრამ თუ ნახავთ მათ, ჩვენ შეგვიძლია მოვძებნოთ მათ.
და ეს ყველაფერი არის ძალიან ავტომატიზებულია და ადვილად და სამწუხარო ჩვენთვის, რათა იპოვოს.
>> თუმცა ხაზგასმით მინდა აღვნიშნო, ძალიან, რომ რა თქმა უნდა, აკადემიური პატიოსნება პოლიტიკა
ძალიან ნიშნავს, რომ ძალიან საპირისპირო, რომ სული.
მართლაც, ამ წელს ჩვენ rephrased რამ ამ სილაბუსში უნდა იყოს ეს, dot
dot dot, უფრო დეტალურად ამ სილაბუსში.
მაგრამ მთავარი თემა, რა თქმა უნდა ნამდვილად უნდა იყოს გონივრული.
ჩვენ ვაღიარებთ, რომ არსებობს მნიშვნელოვანი თანხის პედაგოგიური
ღირებულების კოლაბორაციული, გარკვეულწილად, ერთად თანაკლასელები, რომლის დროსაც თქვენ
ორი ან თქვენ სამი ან მეტი არიან იდგა თეთრ დაფაზე
whiteboarding, ასე ვთქვათ, თქვენი იდეები -
წერა out pseudocode in სურათები, დიაგრამების შედგენა რა უნდა Mario, თუ
თქვენ დაწერა პირველი ამ pseudocode.
რა უნდა ხარბ ალგორითმი -
როგორ უნდა მოიქცეს პოსტი პრობლემა ადგენს ერთი?
>> ასე რომ მიხვდებიან, რომ ქცევის რომ ჩვენ გარწმუნებთ, ძალიან
ბევრი ერთად იმ ხაზები.
ხოლო სილაბუსში, დაინახავთ, მთელი bunch of ტყვიები ქვეშ
გონივრული კატეგორია და არ მომწონს კატეგორია, რომლებიც გვეხმარება დაეხმარება
თქვენ გადატანა თქვენი გონება გარშემო, რომელშიც ჩვენ მიაპყროს, რომ ხაზი.
და საერთოდ, წესიერი წესი thumb არის, რომ თუ იბრძვიან მოსაგვარებლად
ზოგიერთი ხარვეზის და თქვენი მეგობარი ან კლასელი ზის შემდეგ თქვენ, იგი
გონივრული თქვენთვის ნახოთ მას თქვენი კოდი და აცხადებენ, hey, შეგიძლიათ დამეხმაროთ
მე გაერკვნენ, თუ რა ხდება არასწორი აქ?
>> ჩვენ არ, როგორც წესი, მოიცავს მოპირდაპირე მხარეს.
ეს არ არის სწორი პასუხი თქვენს მეგობარი ან კლასელი აქ სათქმელია, რა,
შევჩერდეთ აფეთქდა და მოღვაწის ის, რომ.
სწორედ ერთგვარი უსაფუძვლოა.
თუმცა შემდეგ ვინმეს, კიდევ ერთი ტვინის, კიდევ ერთი წყვილი თვალით შევხედოთ
თქვენს ეკრანზე ან შევხედოთ თქვენი კოდი და აცხადებენ, დარწმუნებული ხართ, რომ გსურთ
ჰქონდეს მარყუჟის აქ?
ან არიან ნამდვილად გსურთ რომ მძიმით აქ?
ან oh, რომ შეცდომა ნიშნავს ეს.
ესენი ძალიან გონივრული და წახალისება ქცევას.
>> შემთხვევაში, რომელიც მე alluding to ადრე იმატებს ქვემოთ, როდესაც სტუდენტებს
გვიან ღამით მიღების ცუდი განაჩენი გადაწყვეტილებები და emailing მათი კოდს
ვინმე ან უბრალოდ ამბობდა, აქ, ეს არის ამ Dropbox ან
Googling გვიან ღამით.
ასე რომ ხელს შეუწყობს და ბეგ თქვენგანს, თუ აქვს იმ გარდაუვალია
მომენტები სტრესი, თქვენ bumping up წინააღმდეგ ვადა, თქვენ არ გვიან
დღეს, რადგან ეს უკვე პარასკევს, რომ წერტილი, ელ კურსის ხელმძღვანელები ან
თავს პირდაპირ.
ამბობენ, მოსმენა, მე ვარ, ჩემი არღვევს წერტილი აქ.
მოდით საუბარი და გაერკვნენ ის.
მიმართავენ ვებგვერდი ან სხვა არა გონივრული საქციელი არასდროს
გადაწყვეტა და ძალიან ბევრი თქვენი თანაკლასელები აღარ აქ
campus გამო, რომ ღარიბი გადაწყვეტილება.
მაგრამ ეს ძალიან ადვილია კაბაში რომ ხაზი.
>> აქ არის პატარა სურათი, გულშემატკივრობენ თქვენ მდე მაღრაძე ასე რომ ახლა
ყველაფერი კარგად იქნება.
>> ასე სწრაფად recap, მაშინ, სადაც ჩვენ შეჩერდით.
ასე რომ, გასულ კვირას, გავიხსენოთ, რომ ჩვენ დანერგვა პირობები, არ Scratch
მაგრამ C ამ დროს.
და იყო რამდენიმე ახალი სინტაქსი მაგრამ ნამდვილად არ ახალი იდეები თავისთავად.
ჩვენ გვქონდა ლოგიკური გამონათქვამების, რომ ჩვენ შეგვიძლია ან ერთად ორი ვერტიკალური
ბარები ან და ერთად ampersands განაცხადა, რომ ორივე მარცხენა
და უფლება უნდა იყოს ჭეშმარიტი ამ შეასრულოს.
მაშინ ჩვენ გვქონდა კონცენტრატორები, რომელიც ჩვენ ჩანდა ზე მოკლედ, მაგრამ მე ვთავაზობ მართლაც
უბრალოდ სხვადასხვა syntax მისაღწევად მსგავსი მიზანი, თუ თქვენ იცით,
წინასწარ რა თქვენი შემთხვევებში იქნება.
>> ჩვენ შევხედე მარყუჟების.
For loop არის იქნებ ყველაზე გავრცელებული, ან, როგორც მინიმუმ ერთი რომ ხალხი
როგორც წესი მიღწევა ინსტინქტურად.
მიუხედავად იმისა, რომ იგი გამოიყურება ცოტა cryptic, დაინახავთ, ბევრი, ბევრი მაგალითი
ადრე ხანგრძლივი, როგორც თქვენ გაქვთ უკვე გვიან გასულ კვირას.
მიუხედავად იმისა, მარყუჟების შეიძლება ასეთივე მისაღწევად იგივე.
მაგრამ თუ თქვენ გსურთ რაიმე incrementation ან განახლება
ცვლადი ღირებულებებს, თქვენ უნდა ამის გაკეთება უფრო ხელით, ვიდრე
for loop ადრე საშუალებას.
და მაშინ იქ do-ხოლო მარყუჟის რაც საშუალებას გვაძლევს, რომ რამე ზე
ერთხელ მაინც, ხოლო რაღაც დანარჩენი არის ჭეშმარიტი.
და ეს განსაკუთრებით კარგია პროგრამების ან თამაშების სადაც გსურთ
უბიძგონ შესახებ რაღაც ერთხელ მაინც.
და მაშინ, თუ იგი არ ითანამშრომლებს, დაგვჭირდება ამის გაკეთება
ისევ და ისევ.
>> ერთად ცვლადები, ამასობაში, ჩვენ გვქონდა ხაზები კოდის მსგავსად, რომელიც
ორი ხაზი.
თქვენ შეიძლება განაცხადოს, int მოუწოდა მრიცხველი, მძიმით.
ან შეგიძლიათ უბრალოდ განაცხადოს და განსაზღვრავს ის, ასე ვთქვათ.
მისთვის მნიშვნელობა ამავე დროს.
>> და მაშინ ბოლოს, ჩვენ ვისაუბრეთ დაახლოებით ფუნქციები.
ეს იყო ლამაზი მაგალითია იმ გაგებით, რომ იგი ასახავს
ორი სახის ფუნქციებს.
ერთი არის GetString (), რომელიც, კიდევ ერთხელ, იღებს ნახატზე შესახებ.
მაგრამ GetString () ერთგვარი საინტერესო, იმდენად, რამდენადაც ჩვენ გამოვიყენეთ ის,
იმიტომ, რომ ჩვენ ყოველთვის ერთად რაღაც მარცხენა მხარეს
თანაბარი ნიშანი.
ანუ, რომ GetString () დააბრუნებს მნიშვნელობას.
ის დააბრუნებს, რა თქმა უნდა, მხოლოდ.
შემდეგ კი მარცხენა მხარეს, ჩვენ უბრალოდ გადასარჩენად, რომ სიმებიანი შიგნით
ცვლადში სახელი.
>> ეს არის განსხვავებული, ამ თვალსაზრისით, საწყისი ფასი printf რადგან printf მაინც, ჩვენი
გამოყენება აქ, არ დაბრუნდება არაფერი.
როგორც განზე, ის დაბრუნების რაღაც.
ჩვენ უბრალოდ არ მაინტერესებს რა არის.
თუმცა, ეს იმას თუ რა არის მოუწოდა მხარე ეფექტი.
და რა არის ის, რომ მხარე ეფექტი ყველა შემთხვევაში ჩვენ ვნახეთ დღემდე?
რას printf გაკეთება?
იგი ბეჭდავს რაღაც ეკრანზე, მონიტორები ტექსტის ან ნომრები ან რაღაც
ეკრანზე.
და ეს მხოლოდ განიხილება მხარე ეფექტი რადგანაც ეს ნამდვილად არ გადაცემის
უკან ჩემთვის.
ეს არ არის პასუხი შიგნით შავი ყუთი რომ მე მაშინ
მიაღწევს შევიდა და დაიბრუნოს.
უბრალოდ აკეთებს ამას საკუთარი, გაცილებით ისევე როგორც კოლტონი იყო plugged შევიდა ამ
შავი ყუთი გასულ კვირას, და ის როგორღაც magically იყო ხატვის ფორუმში
უჩემოდ რეალურად ჩართული.
ეს იქნება მხარის ეფექტი.
მაგრამ, თუ შეეძლოთ მიღწევა უკან აქ და აცხადებენ, oh, აქ სიმებიანი
ეხლა შესახებ, რაც იყოს დაბრუნებული მნიშვნელობა.
>> და დღემდე ჩვენ მხოლოდ ფუნქციები რომ სხვა ადამიანების მიერ დაწერილი.
მაგრამ ჩვენ შეგვიძლია რეალურად გავაკეთოთ ეს სახის რამ საკუთარ თავს.
ამიტომ, მე ვაპირებ წასვლას CS50 მოწყობილობების ერთხელ.
ნება მომეცით ჩემი გამოსვლა tab, რომ ჩვენ ჰქონდათ ღია მომენტში წინ.
და ნება მომეცით წავიდეთ წინ და შექმნა ახალი ფაილი.
და მე ვაპირებ წავიდეთ წინ და დაარქვით მას positive.c.
მინდა, რომ რამე ერთად დადებითი ციფრები აქ.
ამიტომ, მე ვაპირებ წავიდეთ წინ და ამის გაკეთება int -
ბოდიში -
# მოიცავს.
ნუ გააკეთოს, რომ იგივე შეცდომა, როგორც ადრე.
Int მთავარი (ბათილად), ღია curly მუდმივი წინააღმდეგობა გაუწიოს, დახურული curly მუდმივი წინააღმდეგობა გაუწიოს.
>> ახლა კი მინდა შემდეგ.
მინდა დაწერა პროგრამა, რომელიც ამტკიცებს, რომ მომხმარებელს აძლევს
ჩემთვის დადებითი მთელი რიცხვი.
ასე რომ, არ არსებობს GetPositiveInt ფუნქცია ამ CS50 ბიბლიოთეკა.
არის მხოლოდ GetInt ().
მაგრამ ეს OK რადგან აშენებს, რომლითაც შემიძლია დააწესოს
ცოტა მეტი შეზღუდვა, რომ მნიშვნელობა.
მე ვერ რომ რამე მოსწონს ეს.
>> ასე int n -
და თუ თქვენ აკრეფით გასწვრივ, უბრალოდ გააცნობიეროს მე ვაპირებ უკან და
შეცვალოს ზოგიერთი რამ მომენტში -
ასე int n შეადგენს GetInt ().
და ეს გეგმავს int შიგნით ო.
და ნება მომეცით უფრო აღწერითი.
ნება მომეცით აღვნიშნო, რომ მსგავსი რამ მოვითხოვ თქვენ მაძლევს დადებითი მთელი რიცხვი.
>> ყველა უფლება.
ასე რომ მხოლოდ ცოტა ინსტრუქციები.
ახლა კი რა გავაკეთო?
მე უკვე ვიცი, რომ ჩემი უბრალო პირობების ან ფილიალი, ისევე, როგორც მე
ჰქონდა Scratch, მე ვიტყოდი, რაღაც მინდა, თუ n ნაკლებია ან ტოლი
ნულოვანი, მაშინ მე მინდა, რომ რამე მინდა, რომ არ არის დადებითი.
და მე ვერ გააკეთებდა -
კარგია, მაგრამ მე ნამდვილად გვინდა, რომ int.
ასე რომ, მე წასვლა აქ და მე ვერ ტიპის ასლის ამ და აბზაცის ამ.
და მაშინ, OK.
ასე რომ, თუ n ნაკლებია ან ნულის ტოლია გაკეთება.
>> ახლა, რა შემთხვევაში შესახებ არ თანამშრომლობს?
კარგად, მაშინ მე ვაპირებ კარიერებისა ამ აქ.
და მერე წავიდეს აქ და აქ და აქ.
ასე რომ, ეს ნამდვილად არ გადაწყვეტა, არა?
იმის გამო, რომ არ არსებობს ბოლომდე ჩანდა.
თუკი მინდა მოითხოვენ, რომ მომხმარებელს აძლევს ჩემთვის დადებითი მთელი რიცხვი, შემიძლია
რეალურად მიიღონ int.
შემიძლია შემდეგ შემოწმება, რომ int.
მაგრამ მინდა გადამოწმება კიდევ ერთხელ და შეამოწმეთ იგი კვლავ და შემოწმება შეიძლება.
ასე რომ, ცხადია, რა უკეთესი მშენებლობა უნდა გამოყენებით აქ?
ყველა უფლება, გარკვეული ციკლი.
>> ამიტომ, მე ვაპირებ, თავი დაეღწია თითქმის ყველა ამ.
მინდა მიიღოს ამ int ერთხელ მაინც.
ამიტომ, მე ვაპირებ ვთქვა გააკეთოს -
და მე დაბრუნდება ხოლო სულ რაღაც მომენტში -
ახლა, რა?
მე ვაპირებ გაკეთებას int n იღებს GetInt ().
OK.
ასე რომ, საკმაოდ კარგი.
ახლა კი რამდენად ხშირად მინდა ამის გაკეთება?
>> ნება მიბოძეთ printf შიგნით მარყუჟის ასე რომ მოითხოვოს ისევ და ისევ,
თუ საჭირო იქნება.
და რას მინდა ხოლო პირობით უნდა გავაკეთოთ?
მინდა აკეთეთ ამ ხოლო თუ რა არის საქმე?
ჰო.
N ნაკლებია ან ნულის ტოლია.
ასე რომ, უკვე, ჩვენ მნიშვნელოვნად გაიწმინდა ეს კოდი up.
ჩვენ ითხოვა ძალიან მარტივია მშენებლობა - do-ხოლო ციკლი.
მე მოპარული მხოლოდ მნიშვნელოვანი ხაზები კოდექსი, დავიწყე გადაწერა და
pasting, რაც არ იყო ბრძენი.
ასე რომ, ახლა მე ვაპირებ, ფაქტობრივად, ჩასვით იგი აქ და მხოლოდ ამის გაკეთება კიდევ ერთხელ.
>> ახლა კი რა მინდა გააკეთოს ბოლომდე ამ პროგრამის?
მე მხოლოდ ამბობენ, რომ რაღაც მარტივი მინდა, მადლობა - და
გავაკეთებ% i for int -
წარმატებული ო, მძიმე, და შემდეგ plug in ნ მძიმით.
>> ყველა უფლება.
მოდით ვნახოთ, რა მოხდება ახლა როდესაც მე აწარმოებს ამ პროგრამაში.
მე ვაპირებ წავიდეთ წინ და ნუ პოზიტიური.
Damn.
რამდენიმე შეცდომები.
ნება მომეცით, გადახვევა უკან პირველი.
არ მუშაობს მათ უკან.
მუშაობა მათ ზემოდან ქვემოთ Lest ისინი კასკადი და მხოლოდ
ერთი რამ იყოს არასწორი.
იმპლიციტური დეკლარაციას ფუნქციის GetInt ().
ჰო.
ასე რომ, ეს არ არის საკმარისი.
I ტიპის გააკეთა იგივე შეცდომა, მაგრამ ცოტა განსხვავებული ამ დროს.
მე უნდა არა მხოლოდ მოიცავს stdio.h მაგრამ ასევე cs50.h, რომელიც მოიცავს
ე.წ. განცხადებები მისაღებად int, რომელიც ასწავლიან მოწყობილობების, ან ასწავლის
C რა GetInt () არის.
>> ნება მომეცით resave.
მე ვაპირებ იგნორირება სხვა შეცდომები იმიტომ, რომ მე ვაპირებ იმედი მაქვს, რომ ისინი
როგორღაც დაკავშირებული შეცდომა მე უკვე დაფიქსირდა.
ნება მომეცით, წავიდეთ წინ და recompile ერთად პოზიტიური, შეიტანეთ.
Damn.
სამი შეცდომები, მაინც.
ნება მომეცით გადახვევა მდე პირველი.
გამოუყენებელი ცვლადი ო.
ჩვენ არ უნახავს ეს ადრე.
ეს კი, ძალიან, არის პატარა cryptic.
ეს არის გამომავალი შემდგენელი.
და რა, რომ ხაზი გაუსვა ხაზი იქ - positive.c :9:13 -
ამბობს, რომ ეს დაყრდნობით ხაზი ცხრა positive.c, იმ მე -13 ხასიათი,
მე -13 სვეტი, გააკეთეთ ეს შეცდომა.
>> განსაკუთრებით ეს ეუბნება მე გამოუყენებელი ცვლადი ო.
ასე რომ, ვნახოთ -
ხაზი ცხრა.
მე გამოყენებით n იმ თვალსაზრისით, რომ მე რაც მას მნიშვნელობას.
მაგრამ რა კომპილატორი არ მოსწონს არის რომ მე არ შეხედვით გამოყენება.
მაგრამ დაველოდოთ ერთი წუთით, მე გამოყენება.
შესაბამისად 11, მე გამოყენებით მას აქ.
მაგრამ თუ გადაფურცლეთ ქვემოთ შემდგომი ზე positive.c :11 -
ისე ხაზი 11, ხასიათი 12, შემდგენელი ის მეუბნებოდა, გამოყენების
გამოუცხადებელ იდენტიფიკატორი ო.
>> ასე რომ გამოუცხადებელი საშუალება მაქვს არ არის მითითებული იქნება, როგორც
ცვლადი ერთად მონაცემთა ტიპის.
მაგრამ დაველოდოთ წუთში.
მე ზუსტად რომ შეესაბამება ცხრა.
ასე რომ ვინმე მართლაც დაბნეული აქ.
ეს არც მე ან კომპილატორი, რადგან შეესაბამება ცხრა, ისევ, მე გამოცხადების
int n, და მე მინიჭების იგი დაბრუნების ღირებულება GetInt ().
მაშინ მე გამოყენებით, რომელიც ცვლადი ო შეესაბამება 11 და შემოწმების თუ მისი ღირებულება ნაკლებია
მეტი ან ტოლია ნულის ტოლია.
მაგრამ ეს, როგორც ჩანს, არის ცუდი და გატეხილი რატომ?
ამბობენ, რომ ეს აღარ განმეორდეს?
>> Ah, უნდა განაცხადოს ო ადრე შესვლის ციკლი.
მაგრამ რატომ?
ვგულისხმობ, ჩვენ უბრალოდ წინადადებით ცოტა წინ, რომ ეს ჯარიმა განაცხადოს ცვლადები
ყველა ერთ ხაზს და მერე მივანიჭოთ მათ გარკვეული მნიშვნელობა.
გლობალური ცვლადი - მოდით დავბრუნდებით იმ აზრს, რაღაც მომენტში.
რატომ გსურთ ჩემთვის დააყენოს იგი გარეთ მარყუჟის?
ეს არის.
ზუსტად.
>> ასე რომ, თუმცა, გარკვეულწილად counterintuitive, ნება მომეცით შეაჯამებს.
როდესაც თქვენ გამოაცხადოს ო შიგნით საქართველოს do ბლოკი იქ -
კონკრეტულად შიგნით იმ curly აფრთხილებს -
რომ ცვლადი n აქვს რა მოუწოდა ფარგლებს -
არ უკავშირდება ჩვენს გაიტანა სისტემის რა თქმა უნდა - მაგრამ ფარგლებს, რომ
შემოიფარგლება იმ curly აფრთხილებს.
სხვა სიტყვებით, როგორც წესი, თუ თქვენ გამოაცხადოს ცვლადი შიგნით კომპლექტი
curly აფრთხილებს, რომ ცვლადის მხოლოდ არსებობს შიგნით იმ curly აფრთხილებს.
ასე რომ, იმ ლოგიკით მარტო, მიუხედავად იმისა, მე განაცხადა n შეესაბამება ცხრა, ეს
არსებითად ქრება ფარგლებში, ქრება მეხსიერება, ასე ვთქვათ,
იმ დროისთვის მე მოხვდა ხაზი 11.
იმის გამო, რომ ხაზი 11, სამწუხაროდ, არის გარეთ იმ curly აფრთხილებს.
>> ასე, რომ, სამწუხაროდ, ვერ დაფიქსირება ამ მიერ ბრუნდება რა გავაკეთე, რომ ადრე.
თქვენ ალბათ პირველ რიგში ამის გაკეთება.
მაგრამ რა ხარ ახლა არ აკეთებს ციკლურად?
თქვენ აშკარად ვერ ვიღებთ int ციკლურად.
ასე რომ, ჩვენ შეიძლება დატოვოს GetInt (), და ჩვენ უნდა დატოვონ GetInt () შიგნით
მარყუჟის იმიტომ, რომ ის, რაც ჩვენ გვინდა pester შესახებ, ისევ და ისევ.
მაგრამ ეს იმას გვაძლევს, წავიდეთ მდე ხაზი, ვთქვათ, ექვსი.
Int N, მძიმით.
არ მისცეს მას ღირებულება ჯერჯერობით რადგან თქვენ არ გჭირდებათ მხოლოდ ამჟამად.
>> მაგრამ ახლა ყველაფერი აქ, გაფრთხილების - ეს იქნება ძალიან ადვილია შეცდომა.
მე არ მინდა, რომ დაჩრდილოს ჩემი წინა დეკლარაციას ო.
მინდა ო, რომ ნამდვილად არსებობს.
ასე რომ, ახლა ხაზზე 10, მე დაავალოს n ღირებულება.
მაგრამ ხაზი ექვსი, ვაცხადებ ო.
ასე რომ, შემიძლია, ან ვერ გამოყენება ხაზი 12 ახლა?
მე არ შემიძლია, რადგან შორის, რომელიც curly აფრთხილებს არის n განაცხადა ახლა?
ერთი გოლი აქ ხაზი ხუთ.
ერთი აქ ხაზი 14.
ასე რომ, თუ მე ახლა დააშორებს, გარდა ფაილის წასვლა ისევ და აწარმოებს პოზიტიური, ეს
შედგენილი ამ დროს.
ასე რომ, უკვე მიმდინარეობს.
სლეში. . / დადებითი, შეიტანეთ.
>> მოვითხოვ, რომ თქვენ მაძლევს დადებითი მთელი რიცხვი.
უარყოფითი 1.
უარყოფითი 2.
უარყოფითი 3.
ნულოვანი.
ერთი.
და მადლობა ერთი რა ახლა დაბეჭდილი.
>> ნება მომეცით ცდილობენ, რაღაც, გარეთ ცნობისმოყვარეობა.
მე ეუბნებიან შეყვანის რიცხვი.
მაგრამ მე ვფიქრობ ნაცვლად აკრიფოთ ცხვრის?
ასე რომ, ახლა ვხედავთ სხვადასხვა სწრაფი -
სცადეთ კიდევ ერთხელ.
მაგრამ არსად ჩემს კოდი საერთოდ ვწერ სცადეთ კიდევ ერთხელ.
ასე რომ, სადაც, სავარაუდოდ, ამ კვალვ შეგახსენებთ მოდიოდა, იტყვით?
ჰო, ეხლა GetInt () თავად.
ასე რომ, ერთი რამ CS50 პერსონალი აკეთებს თქვენ, როგორც მინიმუმ, ამ პირველი რამდენიმე
კვირის განმავლობაში, რომელიც ჩვენ წერილობითი გარკვეული თანხა შეცდომის შემოწმების იმის უზრუნველყოფა, რომ იმ შემთხვევაში, თუ
რეკავთ GetInt (), მაშინ თქვენ სულ მცირე დავუბრუნდეთ int ეხლა შესახებ.
ვერ მიიღებთ მხოლოდ.
ვერ მიიღებთ char.
თქვენ არ მიიღოს რაღაც დანარჩენი საერთოდ.
თქვენ მიიღებთ int.
>> ახლა, ეს არ უნდა იყოს დადებითი.
ეს არ უნდა იყოს უარყოფითი.
ჩვენ არ გარანტიები გარშემო, რომ.
მაგრამ ჩვენ pester შესახებ კვლავ სცადოთ, კვალვ, კვალვ, სანამ იგი რეალურად
თანამშრომლობს.
ანალოგიურად, თუ 1.23, ეს არ არის int.
მაგრამ, თუ აკრიფოთ, ვთქვათ, 50, რომ მაძლევს ღირებულება, რომელიც მინდოდა.
>> ყველა უფლება.
ასე რომ ცუდი არ არის.
ნებისმიერი შეკითხვა, რაც ჩვენ უბრალოდ გაკეთდეს?
გასაღები takeaway მყოფი, უნდა იყოს ნათელი, არ იმდენად მარყუჟის, რომელიც ჩვენ ვნახეთ
ადრე მიუხედავად იმისა, რომ ჩვენ არ გვაქვს ნამდვილად გამოიყენება, მაგრამ საკითხი ფარგლებს, სადაც
ცვლადები შესაძლებელია მხოლოდ გამოიყენება მხოლოდ შემადგენლობა რამდენიმე მითითებულ ფარგლებში.
>> ყველა უფლება, ნება მიბოძეთ წინადადება თქვენ გააკეთა ადრე, რომ
გლობალური განსხვავებულია.
როგორც განზე აღმოჩნდება, რომ კიდევ ერთი აღნიშნული პრობლემის მოსაგვარებლად, მაგრამ
როგორც წესი, არასწორი გადაწყვეტილება ან ცუდად შექმნილია გადაწყვეტა, არის ის, რომ
ვაცხადებთ თქვენი ცვლადი როგორც რა მოუწოდა გლობალური განსხვავებულია.
ახლა მე სახის დარღვევის ჩემი განმარტება საქართველოს ფარგლებს, რადგან არსებობს
არ curly აფრთხილებს ზუსტად იმ დაბრუნება და ძალიან ბოლოში ფაილი.
მაგრამ გულისხმობს, რომ არის, რომ ახლა შეესაბამება ოთხი,
n არის გლობალური განსხვავებულია.
და როგორც სახელი გულისხმობს, ეს მხოლოდ ხელმისაწვდომი ყველგან.
>> Scratch რეალურად აქვს.
თუ თქვენ გამოიყენება ცვლადი, თქვენ ალბათ გახსოვთ თქვენ უნდა აირჩიოს, თუ ეს შეეხება
ამ Sprite ან ყველა sprites.
ისე, ყველა sprites მხოლოდ ნათელი გზა ამბობდა გლობალური.
ჰო?
Ah, კარგი კითხვა.
>> ასე რომ გავიხსენოთ, რომ პირველი მობილური , ჩემი კოდი, როდესაც მე არასწორად
განაცხადა და განისაზღვრება n შეესაბამება ცხრა -
I გამოაცხადა, როგორც ცვლადი და მე მას ღირებულების მქონე
დავალება ოპერატორი -
ამ მომცა ორი შეცდომები.
ერთი, ის ფაქტი, რომ n არ იყო გამოყენებული, და ორი, რომ ხაზი 11
უბრალოდ არ იყო გამოცხადებული.
ასე რომ, პირველი მე არ მისამართი დროს.
ეს არ არის მკაცრად შეცდომა გამოაცხადოს ცვლადი მაგრამ ვერ გამოიყენებს.
მაგრამ ერთი რამ ჩვენ გავაკეთეთ in CS50 მოწყობილობების, განზრახ,
pedagogically, რომელიც ჩვენ cranked up მოლოდინი შემდგენელი, რათა
დარწმუნებული ვარ, რომ თქვენ აკეთებთ რამ არ არის მხოლოდ სწორად მაგრამ ნამდვილად სწორად.
>> იმიტომ, რომ თუ თქვენ გამოცხადების ცვლადი ისევე როგორც ო და არასოდეს იყენებს, ან გამოყენება
სწორად, მაშინ რა იგი აკეთებს იქ?
ეს მართლაც ემსახურებიან.
და ეს ძალიან ადვილია, დროთა განმავლობაში, თუ არ დააკონფიგურიროთ თქვენი საკუთარი კომპიუტერი
ამ გზით, უბრალოდ აქვს კოდი, რომელიც აქვს ცოტა ნარჩენებისგან აქ, ნარჩენებისგან არსებობს.
შემდეგ კი თვის შემდეგ გადავხედავთ და უკან თქვენ, როგორიცაა, თუ რატომ არის ამ ხაზის
კოდი იქ?
და თუ იქ არ არის კარგი მიზეზი, მას არ ისარგებლოს თქვენი კოლეგები
ქვემოთ გზა უნდა stumble მას შემდეგ.
>> როგორც განზე, სად არის რომ მოდის?
ასევე, გავიხსენოთ, რომ ყოველ ჯერზე ჩვენ შედგენა პროგრამა, ყველა ამ პერსონალის არის
იბეჭდება.
ასე რომ, ჩვენ დავბრუნდებით ამ.
თუმცა ისევ და ისევ, მიიღოს არის უტილიტა, რომელიც automates პროცესის შედგენის მიერ
გაშვებული ფაქტობრივი შემდგენელი მოუწოდა clang.
ეს რამ, ჩვენ საბოლოოდ ვხედავთ, აქვს გავაკეთოთ ერთად გამართვის სპეციალური
პროგრამა debugger.
ეს არ უკავშირდება ოპტიმიზაციის კოდი - უფრო, რომ მომავალში.
Std = c99 -
ამას მხოლოდ იმას ნიშნავს, გამოიყენოთ 1999 მობილური C. C უკვე გარშემო კი უმეტეს
ეს, მაგრამ მათ გააკეთეს კარგი ცვლილებები 10 პლუს წლის წინ.
>> აი შესაბამისი პირობა.
ჩვენ ვამბობთ, გააკეთოს ყველაფერი, რაც ადრე იქნებოდა გაფრთხილება
შეცდომა თავიდან აცილების სტუდენტი ეხლა შედგენას.
და კედლის საშუალებით გააკეთებს, რომ მთელი bunch რამ არ
უბრალოდ დაკავშირებულია ცვლადი.
და მაშინ ნება მომეცით გადახვევის ბოლოს ხაზი.
ეს კი, ძალიან, ჩვენ საბოლოოდ დაბრუნდება.
ეს არის აშკარად სახელი ფაილი მე შედგენას.
ეს იხსენებს სახელით ფაილი მე outputting როგორც სახელი
, ჩემი runnable პროგრამა.
ეს-lcs50 მხოლოდ იმას ნიშნავს, გამოიყენოთ CS50 ბიბლიოთეკა და ნებისმიერი zeros და პირობა, რომ
თანამშრომელთა წერდა და შედგენილი ადრე ამ წლის ინტეგრირება
მათ ჩემი პროგრამა.
>> და ყველას, ვიცი, რა-lm არის?
ეს მათემატიკის ბიბლიოთეკა, რომელიც უბრალოდ იქ კი, თუ თქვენ
არ ვაკეთებთ ნებისმიერი მათემატიკის.
უბრალოდ ავტომატურად გათვალისწინებული ჩვენთვის მიხედვით.
>> ისე, მინდა გავაკეთოთ ერთი სხვა მაგალითი აქ გახსნით ახალ ფაილს.
და ნება მომეცით გადარჩენა ამ ერთი, როგორც string.c.
გამოდის, რომ, როგორც ჩვენ ვსაუბრობთ მონაცემები სახის დღეს, იქ კიდევ უფრო
მიმდინარეობს ქვეშ hood ვიდრე ჩვენ ვნახეთ დღემდე.
ნება მომეცით სწრაფად გააკეთოს სწრაფი პროგრამა.
ჩართეთ stdio.h.
და მე გადარჩენა რომ.
და იცით, ნება მომეცით არ გააკეთებს იგივე შეცდომა ისევ და ისევ.
ჩართეთ cs50.h.
და ნება მომეცით წავიდეთ წინ ახლა და ამის გაკეთება int მთავარი (ბათილად).
>> ახლა კი, უბრალოდ, მინდა პროგრამა რომ აკეთებს ამას - ამბობენ სიმებიანი
მოუწოდა და მიიღოს სიმებიანი ეხლა შესახებ.
და ნება მომეცით პატარა ინსტრუქციები აქ -
გთხოვთ, მომეცი სიმებიანი - ასე შესახებ იცის რა უნდა გააკეთოს.
შემდეგ კი ქვემოთ აქ ქვემოთ ამისა, მინდა ასეთია -
for int i იღებს ნულოვანი.
ისევ, კომპიუტერული მეცნიერები, როგორც წესი, დაიწყოს დამთვლელი ზე ნულოვანი, მაგრამ ვერ
გააკეთოს, რომ ერთი თუ ჩვენ ნამდვილად სურდა.
ახლა მე ვაპირებ შევიდე ნაკლებია ვიდრე სიმებიანი ხანგრძლივობა s.
ასე რომ strlen -
S-T-R-L-E-N -
კიდევ ერთხელ, ეს მოკლე, რადგან უფრო ადვილია შეიტანოთ, მიუხედავად იმისა, რომ ეს
ცოტა cryptic.
>> სწორედ ფუნქცია ჩვენ არ გამოიყენება ადრე მაგრამ ფაქტიურად აკეთებს, რომ -
დაბრუნებას მე ნომერი, რომელიც წარმოადგენს ხანგრძლივობა სიმებიანი
რომ მომხმარებელს აკრეფილი.
თუ ისინი აკრეფილი hello, ეს დაბრუნდნენ ხუთ რადგან იქ ხუთ
წერილები hello.
ამის შემდეგ, ყოველ iteration of ამ მარყუჟის i პლუს პლუს.
ასე რომ, კიდევ ერთხელ, სტანდარტული მშენებლობა კი, თუ თქვენ არ საკმაოდ ძალიან კომფორტული ან
იცნობს ამჟამად.
>> მაგრამ ახლა ყოველ iteration ამ მარყუჟის შეამჩნია რა მე ვაპირებ ამის გაკეთებას.
მინდა წავიდეთ წინ და ბეჭდვა out ერთი გმირი -
ასე% c წარმატებული n ახალ ხაზზე.
შემდეგ კი, იცით, რა მინდა?
როგორიც არ უნდა იყოს სიტყვა, რომ მომხმარებელს ტიპის in, ისევე როგორც hello, მინდა ბეჭდვა
H-E-L-L-O, ერთი ხასიათი თითო ხაზზე.
სხვა სიტყვებით, მინდა მიიღოთ ინდივიდუალური სიმბოლოების ტექსტი,
რომლის დღემდე სიმებიანი ახლახანს ყოფილა რიგითობა სიმბოლოს.
>> და აღმოჩნდება, შემიძლია s, bracket, i, ახლო bracket, დახუროს
ფრჩხილებში, მძიმით.
მე უნდა გავაკეთოთ კიდევ ერთი რამ.
ეს არის ამ ფაილი სახელად string.h რომ strlen განისაზღვრება.
ასე რომ, თუ მინდა, რომ ფუნქცია, მე უნდა გითხრათ შემდგენელი,
ველით, რომ გამოიყენოს იგი.
ახლა ნება მომეცით წავიდეთ წინ და მიიღოს პროგრამა სიმებიანი.
Dot, ხაზი, სიმებიანი.
>> გთხოვთ მაძლევს სიმებიანი.
მე წავიდეთ წინ და ტიპის იგი.
Hello, ყველა caps, შეიტანეთ.
ახლა კი შეამჩნია მე ნაბეჭდი ამ ერთი ხასიათი შემდეგ სხვა.
ასე რომ, ახალი დეტალი ისაა, რომ ტექსტი, ერთი დღის ბოლოს, შეიძლება იყოს
ხელმისაწვდომი გზით მისი ცალკეული სიმბოლოების შემოღების კვადრატულ
bracket notation.
და ეს იმიტომ, რომ სიმებიანი ქვეშ hood მართლაც რიგითობა
სიმბოლო.
მაგრამ რა არის გარღვევა მათ შესახებ არის თქვენს კომპიუტერის RAM -
Mac, PC, რაც არ არის - ისინი ფაქტიურად უკან დაბრუნება უკან -
H-E-L-L-O -
ერთი ინდივიდუალური, მიმდებარე bytes მეხსიერებაში.
>> ასე რომ, თუ გსურთ მიიღოთ მერვე ასეთი ნაწილად, რომელიც ამ მარყუჟის იქნება
bracket ნულოვანი, bracket ერთი, bracket ორი, bracket სამი, bracket ოთხი -
ეს ნულოვანი ინდექსირებული წლამდე ხუთ -
რომელიც ამობეჭდოთ H-E-L-L-O საკუთარი ხაზი.
>> ახლა, როგორც teaser, ნება მომეცით გაჩვენოთ სახის ნივთები, თქვენ საბოლოოდ
შეუძლია გაიგოს, სულ ცოტა ზოგიერთი ახლო ეძებს.
ერთი, რასაც ჩვენ შედის დღევანდელი მაგალითები, თუ გსურთ, ფაქტიურად
ერთი პირველი jailbreaks for iPhone.
Jailbreaking ნიშნავს cracking ტელეფონი ასე რომ თქვენ შეგიძლიათ რეალურად გამოვიყენოთ იგი
სხვადასხვა გადამზიდავი ან install თქვენი პროგრამული უზრუნველყოფა.
თქვენ შეამჩნევთ ამ გამოიყურება სრულიად cryptic, სავარაუდოდ.
მაგრამ შეხედეთ ამ.
IPhone სავარაუდოდ დაბზარული ერთად ამისთვის მარყუჟის თუ მდგომარეობაში, დანარჩენი
მდგომარეობაში, რამოდენიმე ფუნქციები ჩვენ არ უნახავს.
>> ისევ და ისევ, თქვენ არა ერთი შეხედვით ალბათ
გაუგებარია, როგორ ეს მუშაობს.
მაგრამ ყველაფერი, რასაც ჩვენ ერთგვარი მიიღოს თავისთავად ჩვენს თანამედროვე ცხოვრებაში
რეალურად ტენდენცია შეამციროს კი რამდენიმე ამ საფუძვლები ჩვენ
ეძებს.
ნება მომეცით წავიდეთ წინ და გახსნა ერთი სხვა პროგრამა, holloway.c.
ასე რომ, ეს, ძალიან, არის რაღაც უნდა არ ვიცი.
მაშინაც კი, არც ერთი პერსონალის ან მე ვერ ალბათ გაერკვნენ ამ out ეძებს
რადგან ეს იყო ვიღაცის კოდი რომელიც წარედგინება რა
ისტორიულად ცნობილია, როგორც obfuscated C კონკურსი, სადაც წერთ პროგრამა
რომ ადგენს და ეშვება მაგრამ იმდენად რა cryptic არ ადამიანის უკეთ გავიგოთ, რა
ის აპირებს მანამ, სანამ სინამდვილეში აწარმოებს.
>> ასე რომ, მართლაც, თუ გადავხედავთ ამ კოდი, ვხედავ შეცვლა.
მე ვხედავ მთავარი.
მე ვხედავ ამ კვადრატულ ფრჩხილებში რაც გულისხმობს გარკვეული მასივი.
ვინმეს გვინდა რას ამ პროგრამის რეალურად
აკეთებს თუ მე აწარმოებს Holloway?
დიახ.
OK.
კარგად გაკეთდეს.
ასე რომ მხოლოდ თანამშრომლები და მე ვერ ახერხებს რა ეს ყველაფერი გავაკეთოთ.
>> ახლა კი ბოლოს, ნება მომეცით წავიდეთ წინ და ქმნის ერთი პროგრამა.
ეს ერთ -
ერთხელ, მივიღებთ წყაროს კოდი ინტერნეტში - ეს ერთი უბრალოდ
სახის საკმაოდ შევხედოთ.
ყველა გააკეთეს არის მოხვდა სივრცეში ბარი საკმაოდ მწირი.
მაგრამ ეს ნამდვილი კოდი.
ასე რომ, თუ თქვენ ფიქრობთ, რომ საკმაოდ, თუ ჩვენ რეალურად აწარმოებს ამ დროს სწრაფი,
საბოლოოდ დაინახავთ, თუ როგორ შეიძლება გავაკეთოთ რამ მოსწონს ეს.
>> ასე რომ, ჩვენ დავტოვებთ თქვენ რომ ნოტა და თქვენ ოთხშაბათს.
>> [მუსიკალური სათამაშო]
>> დინამიკები 2: მომდევნო CS50, TFS დადგმა ამბოხებას.
>> დინამიკები 3: არსებობს ის არის.
მიიღეთ მას!
>> [მუსიკალური სათამაშო]