[Powered by Google Translate] [კვირა 2 გაგრძელდა]
[დევიდ ჯ Malan, ჰარვარდის უნივერსიტეტი]
[ეს არის CS50. - CS50.TV]
ყველა უფლება. ეს არის CS50, და ეს არის ბოლომდე კვირაში 2.
თუ თქვენ მოველით, რომ იყოს მშიერი გარშემო ამ დროს ხვალ,
ვიცი, რომ ჩვენ ვაპირებთ მოიწვიოს როგორც მცირე ჯგუფი ხვალ, ხუთშაბათს, 1:15 საათზე.
არსებობს ამ URL აქ თუ გსურთ Rsvp.
ფართი არის შეზღუდული, ასე რომ გთხოვთ აპატიებს თუ ფორმა შევსებული მიერ ახლა თქვენ შეავსოთ ამ გარეთ.
კიდევ ერთი URL, თუმცა, რომ შეიძლება იყოს ინტერესთა ეს.
რაღაც დაახლოებით თვეში, რა თქმა უნდა, იქნება ხელმისაწვდომი
ყველა უფრო ფართოდ მეშვეობით EDX გავლით რომელიც FOLKS ინტერნეტში შეძლებს დაიცვას გასწვრივ,
ჩაერთონ თქმა საკმაოდ აქტიურად, ფაქტობრივად.
ისინი გექნებათ გამოყენებით CS50 ელექტრო და CS50 იმსჯელებს
და ყველაზე მეტად სხვადასხვა პროგრამული ინსტრუმენტების, რომ ჩვენ უკვე იყენებს ამ სემესტრში.
და ერთ ინიციატივების მინდა იღებს როგორც ექსპერიმენტი ამ წელიწადში
, ვნახოთ, თუ რაოდენ ბევრის კონტენტი შეგვიძლია თარგმნოს
სხვა ლაპარაკობენ და წერილობითი ენებზე.
ასე რომ, თუ თქვენ შეიძლება ჰქონდეს ინტერესი ამ პროექტში მონაწილეობდა
რომლითაც ჩვენ ვუზრუნველყოფთ English ტრანსკრიპცია და სუბტიტრები კურსის ლექციები
და შორტები და სემინარები და სექციები და მოსწონს,
თუ საუბარი თავისუფლად ან ჩაწერის თავისუფლად ზოგიერთი სხვა ენაზე
ჩვენ გვიყვარს აწარმოონ თქვენ ამ პროექტში, რომლის დროსაც თქვენ იღებს ერთი ან მეტი ვიდეო,
თარგმნა მათი ენა, იცნობენ.
>> გადმოგცეთ გრძნობა ინტერფეისი, არსებობს ამ ვებ დაფუძნებული ინტერფეისი
რომ ჩვენ უნდა გამოყენებით რომ შევქმნით არსებითად UI მოსწონს ეს.
ეს იყო ჩემთვის სწავლების ზოგიერთი ჰელოუინი წინ,
და მარჯვენა მხარეს იქ შავ შემდეგი ამ დროს შტამპები,
თქვენ ნახავთ სხვადასხვა რამ, რომ გამოვიდა ჩემი პირით, რომ დღეს,
და შემდეგ ქვემოთ ეს თქვენ გექნებათ გარდაქმნა ზოგიერთი სხვა ენაზე
ზუსტად რა არის რუკების შორის, ამ შემთხვევაში, ინგლისური და, ვთქვათ, ესპანური.
ასე რომ, რეალურად ძალიან მოსახერხებელი ინსტრუმენტი.
შეგიძლიათ გადახვევა და სწრაფი წინსვლის ძალიან ადვილად ერთად კლავიშთა.
ასე რომ, თუ გსურთ, მონაწილეობა მიიღოს ამ ექსპერიმენტი და აქვს თქვენი სიტყვა უნახავს და წაიკითხეთ
მიერ პოტენციურად ათასობით FOLKS out არსებობს, გთხოვთ, ნუ მოგერიდებათ მონაწილეობას.
ერთი სიტყვით kitten ორშაბათიდან.
Lest ჩვენ გაგზავნილი ზედმეტად საშინელი გაგზავნა, არ ესმოდეს, რომ, როგორც ოფისში საათის ვარაუდობენ
და როგორც სექციები ვარაუდობენ, დიზაინი რა თქმა უნდა, ძალიან ბევრი რამ
არ სტუდენტები თანამშრომლობს და საუბარს მუშაობის გზით პრობლემის კომპლექტი
და პრობლემები ერთად, და ნამდვილად ხაზის უბრალოდ მოდის ქვემოთ,
ერთხელ, სამუშაო თქვენ საბოლოოდ წარუდგინოს უნდა იყოს თქვენი საკუთარი.
და ა.შ. საკმაოდ პატიოსნად, ოფისში საათის ეს სრულიად ნორმალურია,
ეს სრულიად უნდა მოსალოდნელია კი, უნდა chatting ზოგიერთ მეგობარს შემდეგი თქვენ.
>> თუ იგი ბრძოლა ზოგიერთი თემის და თქვენ, როგორიცაა,
"ოჰ, კარგად, მინდა გადმოგცეთ glimpse ზოგიერთი ხაზი კოდი, რომ დავწერე," რომ ჯარიმა,
ეს მოხდება, და რომ ძალიან ბევრი რამ ხელს, ვფიქრობ, ერთად პროცესში სწავლისა.
სად ხაზი იღებს გადმოკვეთა არის, როცა ხელმძღვანელი არის ერთგვარი tilted მეტი აქ ძალიან ბევრი წამი
ან წუთი, რომ ნამდვილად არ იყო მხოლოდ ბლოკის მოხსნა შესაძლებლობა თქვენი მეგობარი,
და, რა თქმა უნდა, როდესაც რამ მისაღებად გაცვალეს ელექტრონული ფოსტის მეშვეობით და Dropbox და მოსწონს,
იქაც არის ხაზზე.
ასე რომ ყველა საშუალებით კომფორტისთვის და გრძნობს წახალისება ესაუბროთ მეგობრები
და თანაკლასელები შესახებ psets და უფრო და მხოლოდ გააცნობიეროს, რომ ის, რაც თქვენ საბოლოოდ წარუდგენს
უნდა იყოს ნამდვილად პროდუქტი თქვენი შექმნა და არა ვინმე სხვა.
და ა.შ. ერთი domain სპეციფიკური პრობლემებს pset2,
რომელიც გამოვა გვიან ხვალ, არის ჩაყვინთვის შევიდა სამყაროში კრიპტოგრაფიის,
რომელიც ხელოვნების encrypting ან scrambling ინფორმაციით,
და ეს საბოლოო ჯამში ეხება სამყაროს უსაფრთხოებას.
ახლა, უსაფრთხოების ყველაზე მეტად ჩვენს მოდის სახით საკმაოდ mundane მექანიზმები.
ყველა ჩვენგანს აქვს სახელისა და პაროლის,
და ყველას უნდა გვქონდეს ძალიან ცუდი სახელისა და პაროლის, სავარაუდოდ.
>> თუ თქვენი პაროლი არის იგივე სხვადასხვა საიტებზე, რომ ალბათ არ საუკეთესო იდეა,
როგორც ჩვენ განვიხილავთ მიმართ სემესტრის ბოლოს.
თუ თქვენი პაროლი აწერია შენიშვნათა - არ ხუმრობა - თქვენი მონიტორი,
რომ ძალიან არ არის აუცილებლად საუკეთესო დიზაინის, მაგრამ საკმაოდ ჩვეულებრივი მოვლენაა.
და თუ თქვენ არ იყენებთ კრიპტოგრაფიის დაშიფვრა თქვენი პაროლები,
ისინი განსაკუთრებით მგრძნობიარენი.
ასე რომ, თუ თქვენ ფიქრობთ, თქვენ მიმდინარეობს სუპერ ჭკვიანი მიერ მქონე ფარული Word დოკუმენტის
სადმე თქვენს ხისტ დისკზე, რომელსაც აქვს ყველა თქვენი პაროლები
მაგრამ საქაღალდეში, რომ არავინ აპირებს გამოიყურებოდეს წელს, რომ ძალიან არ არის ძალიან უსაფრთხო მექანიზმი.
და მერე რა pset2 გააცნობს არის ამ ხელოვნებას კრიპტოგრაფიის
და scrambling ინფორმაცია ისე, რომ რამ, როგორიცაა პაროლები ყველა უფრო უსაფრთხო.
კონტექსტში აქ არის, რომ არასაიმედო მონაცემები
მოდის საშუალებას დაშიფვრა ეს და scramble ეს.
და ამიტომ ეს, მაგალითად, არის მაგალითი დაშიფრული გაგზავნა.
ეს რეალურად ამბობს რაღაც ინგლისურ, მაგრამ აშკარად არ მთლიანად აშკარაა.
და ჩვენ მოდის სრული წრე დღეს აჯავრებენ გარდა რა ამ საიდუმლო გაგზავნა აქ არის.
მაგრამ რეალურ ცხოვრებაში კომპიუტერების, რამ არც კი ჰგავს, შესაძლოა, მათ ინგლისურ ფრაზებს.
მაგალითად, ეს არის ის, რაც თქვენ შეიძლება on სტანდარტული Linux ან Mac ან UNIX კომპიუტერი
წელს ფაილი, რომელიც იყო ერთხელ მოუწოდა დაგავიწყდათ ფაილი.
>> დღესდღეობით მისთვის გადავიდა სხვა ადგილებში.
მაგრამ თუ გადავხედავთ სწორი ადგილი სისტემა, თქვენ ნახავთ არამხოლოდ თქვენი სახელი
ან რომ სხვა ადამიანების სისტემა, მაგრამ თქვენ ნახავთ დაშიფრული ვერსია მათი პაროლი.
მართლაც, სიტყვის საძვალე იქ ვარაუდობს, რომ შემდეგი პერსონალი არის დაშიფრული,
და ამ სერიაში ერთი შეხედვით შემთხვევითი წერილები და პერსონაჟები და ნომრები და ა.შ.
შეიძლება გაშიფრავთ მხოლოდ ზოგადად იცის ზოგიერთი საიდუმლო -
საიდუმლო სიტყვა, ფარული ნომერი -
და ა.შ. რა თქმა უნდა, ხელოვნების კრიპტოგრაფიის საბოლოოდ boils ქვემოთ ნდობის გარკვეული
და იცის, რომ რაღაც სხვის არ.
ამიტომ ჩვენ შეისწავლონ ეს ცოტა უფრო დეტალურად დღესაც და pset მოვა.
და ახლა სიტყვა უღელტეხილზე / Fail.
განსაკუთრებით ზოგიერთ თქვენგანს dived შევიდა pset1, ელექტრო მოწყობილობების,
და ძალიან ახალი მსოფლიო თავს, გააცნობიეროს, რომ იმედგაცრუებები და დაბნეულობა
და მხოლოდ ტექნიკური სირთულეების საკმაოდ უნდა მოსალოდნელია,
განსაკუთრებით პირველი pset, სადაც უბრალოდ იმდენად ახალი,
უბრალოდ გაცნობოდა ls და CD და ყველა ამ arcane ბრძანებები
და ახალ გარემოსთან, და ეს ცალკე ფაქტობრივი მასალა და პროგრამირების თავად.
ასე რომ მიხვდებიან, ძალიან, რომ არსებობს ნამდვილად საათებში, რომ არსებობს, როგორც მხარდაჭერა სტრუქტურა.
>> სექცია იწყება ამ მოდის კვირა.
მაგრამ რაც მთავარია, თუ თქვენ შეგრძნება მხოლოდ, რომ ეს არ არის მსოფლიოს თქვენთვის,
გააცნობიეროს, რომ ის მართლაც ამჯამად მხოლოდ დრო სჭირდება.
და იყო არა ეს შესაძლებლობა წლის წინ ჩემთვის აღების კლასის უღელტეხილზე / ვერ,
პატიოსნად, მე არასოდეს იქნებოდა კიდევ დადგენილი ფეხით საკლასო ოთახში.
თქვენ შეგიძლიათ შეცვალოთ ეს წლამდე, ვთქვათ, მეხუთე ორშაბათს კურსის,
ასე რომ, თუ თქვენ ზღვარზე ახლა, გააცნობიეროს, რომ ვიდრე უფროსი შევიდა ზოგიერთი სხვა წყლებში საერთოდ,
რა თქმა უნდა განიხილოს მხოლოდ იცვლება მიღება / ჩავარდება.
ისევ და ისევ, იქ ნამდვილად არ ამ კულტურის აქ ჰარვარდის აღების რამ მიღება / ვერ
რადგან ყველას ნამდვილად სურს მიაღწიოს ან overachieve,
მაგრამ გულწრფელად ვამბობ, რომ ეს არის შესანიშნავი გზა ცდილობს რაღაც გარეთ
რომ არ უნდა იყოს ნაცნობი თქვენ, და თქვენ დასრულდება up აკეთებს, უმეტეს შემთხვევაში, საკმაოდ ჯარიმა,
ალბათ ბევრი თქვენი სიურპრიზი.
და უფრო კონკრეტული ვადები, რას ვფიქრობ გაივლის / ვერ აკეთებს საერთოდ,
განსაკუთრებით, როგორც თქვენ ალბათ გამოცდილი ერთად pset0,
თუ თქვენც არ დაიშურებთ 10 საათი, 15 საათი, 25 საათი შევიდა ზოგიერთი pset
და თქვენ მხოლოდ ამ banging თქვენი უფროსის წინააღმდეგ კედლის და ის მისაღებად სუპერ გვიან ღამით
მაგრამ თქვენ გადაღებული pset 90% გზა და თქვენ უბრალოდ ვერ გაერკვნენ ერთი რამ,
მიღება / ვერ იღებს ნამდვილად პირას გამორთვა კლასის მოსწონს,
სადაც შეგიძლიათ სახის სიხარულით ამბობენ, "Okay, მე ვიცი, რომ ეს არ არის სრულყოფილი,
მაგრამ ვმუშაობდი ჩემი ass off ამ, მე საკმაოდ კმაყოფილი სადაც იგი დასრულდა, "
და რომ შეხვდება მოლოდინი უღელტეხილზე / ჩავარდება.
ასე რომ შევინარჩუნოთ, რომ გონება. ყველა უფლება.
>> ასე რომ იმ, ვინც არ იბრძვის გამოიყენოთ ჰარვარდის უნივერსიტეტი, Wi-Fi,
ვიცი, რომ არსებობს CS50 SSID, Wi-Fi კავშირი, მცურავი გარშემო
რომ თქვენ შეიძლება უკეთესი გისურვებთ ამისთვის.
ეს პატარა ირონიული, რომ პაროლი, თუ გსურთ ცდილობენ დამაკავშირებელი ამ
უკეთესი სიჩქარეზე - და გვაცნობოთ თუ უკეთესი არ - არის 12345, ყველა გზა მდე 8
რადგან 8 არის უფრო უსაფრთხო, ვიდრე 5.
ასე რომ, თუ თქვენ უნდა Wi-Fi დაგავიწყდათ, დაუკავშირდეთ CS50 wirelessly აქ, 12345678,
და პოსტ on CS50 იმსჯელებს თუ გაგიჩნდებათ რაიმე წყვეტილი კავშირი საკითხები,
და ჩვენ ნება ძალებს, უნდა იცოდეს, ამ სივრცეში. ყველა უფლება.
ამიტომ სწრაფი teaser, განსაკუთრებით იმ თქვენ, რომლებიც გულშემატკივართა ბიჭები ან გოგონებს ყველაფერი Apple.
რა გათხრილი მდე რამდენიმე წლის იყო ამ ფაილის აქ, iUnlock.c,
მხოლოდ სახის უფრო კონკრეტული და უფრო რთული
ზოგიერთი უფრო საბაზისო C პროგრამების ჩვენ წერილობით.
ამიტომ გავხსენი ეს ფაილი, iUnlock.c. ეს შესაძლებელი ლექციები გვერდზე დღეს.
On მარცხენა მხარეს ხედავთ გრძელი სიის ფუნქციები.
ასე რომ თანამემამულე ვინ დაწერა ეს დაწერა up ბევრი ფუნქციები, მეტი, ვიდრე უბრალოდ ძირითადი.
მან გამოიყენა მთელი bunch ბიბლიოთეკების აქ, და თუ ჩვენ დავიწყებთ სენსორული მეშვეობით,
რა არის რეალურად არის პირველი, მე მჯერა, crack for ორიგინალური iPhone.
>> როდესაც თქვენ სურდა jailbreak ორიგინალური iPhone, რაც იმას ნიშნავს, untether ის AT & T
და ფაქტობრივად დააყენოთ სპეციალური პროგრამული მასზე და გავაკეთოთ რამ, რომ Apple არ სურს ხალხს უნდა გავაკეთოთ,
ვიღაცამ აიღო დრო უნდა გაერკვნენ, თუ როგორ ზუსტად მათ შეეძლოთ გამოეყენებინათ პროგრამული ხარვეზები,
შეცდომები, შეცდომები, წელს Apple პროგრამული უზრუნველყოფა, და ამით დაიბადა iUnlock.c--
რომ თუ თქვენ შედგენილი იგი თქვენს კომპიუტერში და დამონტაჟებული მას გადატანა iPhone
რომელიც დაკავშირებულია თქვენს კომპიუტერში მეშვეობით, ვთქვათ, USB კაბელი,
ეს გაძლევთ ადმინისტრაციულ ან root პრივილეგიებით თქვენს iPhone
და მოდით თქვენ აკეთებთ საკმაოდ ბევრი რაც გაგიხარდებათ.
და ასე რომ უკვე ამ მომხიბლავი კატა და მაუსი თამაში
შორის Apple და დანარჩენ მსოფლიოსთან კერძოდ, როგორც მათ, როგორც ბევრი კომპანიები,
ცდილობენ ჩაკეტვა მათი პერსონალის ქვემოთ ასე რომ თქვენ შეგიძლიათ მხოლოდ შუაში იყო, რაც მათ განზრახული.
მაგრამ წყალობით ადამიანს მოსწონს ეს და გაგება დაბალი დონის დეტალები -
და ამ შემთხვევაში C პროგრამირების - და ბევრი ნაცნობი აშენებს
რომ დავიწყეთ თამაში, თქვენ შეგიძლიათ რეალურად ბერკეტები აპარატურა
ისე ხედავთ fit და არ ემთხვეოდეს ზოგიერთი კორპორატიული პირი.
ასე მაგალითად, მე არ ვიცი, რა ყველა ამ აკეთებს
მაგრამ GetVersion ხმები საკმაოდ მარტივია,
და როგორც ჩანს, ეს ფუნქცია, რომ ეს ადამიანი წერს.
იგი იღებს გარკვეული რიცხვი, როგორც არგუმენტი, არ დააბრუნებს არაფერი,
მაგრამ, როგორც ჩანს, მარყუჟის რეჟიმში ამისთვის loop აქ და თუ მდგომარეობა, თუ მდგომარეობა შესვენების
და რაღაცნაირად დაკავშირებულია ვერსია ნომრები თუ ჩვენ გადახვევა down,
მიუხედავად იმისა, რომ ბევრი ამ სიტყვებით ვაპირებთ იყოს ახალი.
წინ კიდევ მთელი ბევრი ფუნქციები აქ ჩვენ მინახავს და შეიძლება არ ოდესმე ვხედავ
მეტი კურსი სემესტრი.
>> დასასრულს დღეს, იგი შემდეგნაირად იგივე წესების და ლოგიკა, რომ ჩვენ თამაშს დღემდე.
ასე რომ, ეს არის ზედმეტად მოხუცი ბზარი თქვენი iPhone 3S ან 4S ან მალე 5S ამ დღეებში,
მაგრამ ვიცით, რომ ეს ყველაფერი ძალიან გამომდინარეობს ამ მსოფლიოს, რომ ჩვენ dived შევიდა.
მოდით შევხედოთ ცოტა უფრო მარტივი მაგალითი:
ამ ერთი, უბრალოდ მისაღებად warmed რაიმე სინტაქსი და ასევე ზოგიერთი სხვა ტიპის მონაცემის
რომ ჩვენ ვისაუბრეთ, მაგრამ არ ნამდვილად ჩანს C.
ეს არის ფაილი სახელად positive1.c, და თითო კომენტარები ზედა,
ამ მხოლოდ მოითხოვს, რომ მომხმარებლის უზრუნველყოს დადებითი რიცხვი.
ასე რომ მაგალითი do-ხოლო loop, რომელიც ლამაზი მომხმარებლის ინტერაქტიული პროგრამების
სადაც თქვენ უნდა ვუთხრა მომხმარებელს რაღაც,
და თუ ისინი არ თანამშრომლობენ თქვენ დაწეროთ მათ ან უარყოს მათი შეყვანის.
მაგალითია: მე აპირებს ხაზები 19 გზით 24
ამიტომ სანამ მომხმარებლებს არ მომცა დადებითი რიცხვი.
ეს დეტალი აქ on line 18, რატომ ვაცხადებ N ზემოთ ამ მთელი looping მშენებლობა
როგორც ეწინააღმდეგებოდა უფლება მომდევნო ხაზი 22, სადაც მე რეალურად ზრუნვა მისაღებად N? Yeah.
[სტუდენტი] Scope. >> ჰო, ისე ამ საკითხის ფარგლებს.
და ერისკაცად წარმოგვიდგება მისი თვალსაზრისით, რას ფარგლებს ეხება?
Yeah. >> [Inaudible სტუდენტი საპასუხოდ] >> იქნებ ცოტა louder?
[სტუდენტი] სად შეგიძლიათ, რომ ცვლადი. >> Perfect.
სად შეგიძლიათ კონკრეტული ცვლადი.
და საერთოდ, უზენაესობის ცერის დღემდე არის, რომ ფარგლებს ზოგიერთი ცვლადის
განისაზღვრება უახლესი Curly braces რომ თქვენ ვხედავთ.
>> და ა.შ. ამ შემთხვევაში, თუ დაუშვა შეცდომა, გამოცხადების N on line 22, რომ ხაზი იმუშავებს.
მინდა კიდევ int, და მე მისთვის შეიძლება შევიდა, რომ ცვლადი N სტრიქონში 22,
მაგრამ ხაზი კოდი, რომ ახლა არ ვიცი რა მე ვსაუბრობ? >> [სტუდენტი] 25.
[Malan] 25 და თურმე 24, რადგან ამ შემთხვევაში იგი მოდის გარეთ Curly braces.
ასე რომ მხოლოდ ცოტა უსიამოვნოა, მაგრამ ძალიან ადვილად მოგვარდება უბრალოდ გამოცხადების ცვლადი
გარეთ ფუნქცია თავად.
ჩვენ დავინახავთ, დღესვე შეგიძლიათ ერთი ნაბიჯი შემდგომი
და თქვენ შეიძლება კი ცოტა ზარმაცი.
და ეს არ შეიძლება რეკომენდებული ზოგადად, მაგრამ თქვენ ვერ კი ეზარებათ
და დააყენა ცვლადი გლობალურად, ასე ვთქვათ, არ შიგნით ფუნქცია, არ შიგნით მარყუჟის,
მაგრამ ფაილი თვით, გარეთ ყველა ფუნქციების თქვენ წერილობითი, როგორც მე აქ ხაზი 15.
ეს არის ზოგადად frowned საფუძველზე, არამედ გააცნობიეროს ეს არის გამოსავალი ხან სხვა პრობლემებს,
როგორც ჩვენ საბოლოოდ ვხედავთ.
ასე რომ, ახლა ჩვენ დავტოვებთ მას მოსწონს, მაგრამ მოდით ვნახოთ, შევძლებთ თუ გადაწერას ამ
უბრალოდ უნდა დაიწყოს გამოხატავს საკუთარ თავს პატარა განსხვავებულად.
ეს პროგრამა, უბრალოდ უნდა იყოს მკაფიო, არის positive1.
ნება მომეცით წავიდეთ წინ აქ და ჩემი ტერმინალის ფანჯარაში მიიღოს positive1, შეიყვანეთ.
ადგენს okay. მე ვაპირებ აწარმოებს positive1, დააჭიროთ.
მე მოვითხოვ რომ თქვენ მაძლევს დადებითი მთელი რიცხვი. მე ვთქვა -1. რომ არ მუშაობდა.
0, 99. რომელიც, როგორც ჩანს მუშაობა.
იქნებ არ საუკეთესო მკაცრი გამოცდა, მაგრამ მაინც კარგია, საღი აზრის გამშვები
რომ ჩვენ სწორ გზაზე.
>> ახლა ნება მომეცით წავიდეთ წინ და გახსნა ვერსია 2 ამ,
და რით განსხვავდება უკვე?
იგი ახორციელებს იგივე, მაგრამ რა jumping, როგორც ნათლად სხვადასხვა ამ დროს?
ეს bool მწვანე. ეს არის ასახული მწვანე, ამ სიტყვით ცნობილია როგორც bool, რომელიც მონაცემთა ტიპის.
იგი არ მოდის აგებული ყველა ვერსიები C.
თქვენ უნდა შეიცავდეს კონკრეტულ ბიბლიოთეკაში.
ჩვენს შემთხვევაში, მე მოიცავდა CS50 ბიბლიოთეკაში ისე, რომ ჩვენ გვაქვს წვდომა bool.
მაგრამ ხაზი 18, ჩვენ, როგორც ჩანს, აქვს ლოგიკური მნიშვნელობა მოუწოდა მადლობელი.
მე შეეძლო უწოდა არაფერი, მაგრამ მე მას მადლობას
მხოლოდ სახის გადმოცემა გარკვეული სემანტიკური მნიშვნელობა.
ასე რომ თავდაპირველად on line 18, მე აშკარად არ მადლობელი
რადგან ლოგიკური ღირებულება მადლობელი ინიციალიზდება მცდარია, შეესაბამება 18.
და შემდეგ, როგორც ჩანს, რაც მე ვაკეთებ აქ ხაზები 21 გზით 23
არის მე უბრალოდ სახის გადაწერილი ჩემი ლოგიკა.
ასე რომ არ ფუნქციურად განსხვავებული, მაგრამ ხაზი 22 ახლა შევამოწმოთ თუ int მომხმარებლის უზრუნველყო
მეტია 0, მაშინ მე უბრალოდ შეცვლის ღირებულება მადლობას უხდის ჭეშმარიტი.
და რატომაა ასე? რადგან ხაზი 25, სავარაუდოდ მე ვაპირებ შეამოწმოს მდგომარეობა.
გააკეთეთ მარყუჟი ხოლო მადლობელი სიცრუეა.
ასე რომ მე შევთავაზე ამ როგორც ალტერნატივა ვერსია 1
იმიტომ რომ ცოტათი მაინც უფრო ინტუიტიური შესაძლოა, ეს ცოტა უფრო საფუძვლიანი ინგლისურ ენაზე.
ასე რომ შემდეგი ხოლო თქვენ არ მადლობელი ან ხოლო მადლობელი სიცრუეა.
და ამ დროს ძალიან მე აშკარად არ მაინტერესებს უნდა გვახსოვდეს, რა მომხმარებლის აკრეფილი
რადგან ცნობაში არ ცვლადი N, ისე რეალურად, პატარა თეთრი ტყუილი არსებობს.
>> ფუნქციურად პროგრამის ოდნავ განსხვავებული ერთხელ მივიღებთ ბოლოში ეს
რადგან მე არ დამახსოვრების რა N არის.
მაგრამ მსურდა დემონსტრირება აქაც რომ მიუხედავად იმისა, რომ ჩვენ ვნახეთ GetInt
და GetString გამოიყენება on მარჯვენა მხარეს ტოლობის ნიშანი დღემდე
ისე, რომ ჩვენ გვახსოვს ღირებულება, ტექნიკურად, ეს არ არის მკაცრად აუცილებელია.
თუ სხვადსხვა მიზეზის გამო უბრალოდ არ მაინტერესებს გადარჩენა ღირებულების,
გსურთ შეამოწმოთ ღირებულება შეამჩნევთ, რომ ჩვენ შეგვიძლია უბრალოდ წერენ ეს GetInt,
ღია PAREN, მჭიდრო PAREN.
რომ ფუნქციის დაბრუნებას აპირებს ღირებულება, როგორც ჩვენ ვამბობდით.
იგი აპირებს მოგცემთ უკან int.
და ასე თუ ფსიქიკურად ვფიქრობ ამ ხდება,
როცა აკრიფოთ 99, GetInt ბრუნდება ნომერი 99,
და ასე კონცეპტუალურად, ეს თითქოს ჩემი კოდი იყო რეალურად ამ.
ასე რომ, თუ 99 მართლაც მეტია 0, მაშინ მადლობელი სიმართლე ხდება,
შემდეგ ხაზი 25 აცნობიერებს Ooh, ჩვენ გავაკეთეთ, რადგან მე ახლა მადლობელი,
და სტრიქონში 26, ჩვენ უბრალოდ ამბობენ, "გმადლობთ დადებითი მთელი რიცხვი!"
რასაც ეს იყო.
ახლა მოდით უმნიშვნელო სინტაქსური შაქარი აქ, ასე ვთქვათ.
მოდით ვნახოთ, თუ შევძლებთ გაწმენდა ამ ხაზის 25 ამ მესამე და საბოლოო ვარიანტი წელს positive3.
>> გაითვალისწინეთ მხოლოდ განსხვავება არის არის რა ხაზი კოდი? >> [სტუდენტი] 25. >> [Malan] Yeah, 25.
და ჩვენ ნამდვილად არ მინახავს ეს ხრიკი უბრალოდ არ არის, მაგრამ ჩვენ არ ვხედავთ ძახილის წერტილი ორშაბათს,
რაც ნიშნავს, რა? >> [სტუდენტი] არ. >> არ ან უარყოფა.
ასე რომ მიიღოს ლოგიკური მნიშვნელობა და Flip მისი ღირებულება.
True ხდება ყალბი, ყალბი ხდება.
ასე რომ, ეს, მინდა შესთავაზოს, არის კიდევ უფრო ინტუიციური გზა წერა კოდი
იმიტომ, რომ მე ჯერ კიდევ ინიციალიზაცია მადლობას უხდის ცრუ, მე მაინც გავაკეთებ შემდეგ,
მე მითითებული მადლობას უხდის ჭეშმარიტი, როცა დრო მოდის,
მაგრამ ახლა შეგიძლიათ ნამდვილად უბრალოდ თარგმნოს ეს კოდი სიტყვიერი მარცხნიდან მარჯვნივ,
ხოლო (! მადლობელი); რადგან bang ან ძახილის წერტილი ნიშნავს ცნება არ,
ასე ხოლო არ მადლობელი.
ასე რომ კიდევ ერთხელ, ჩვენ არ გააცნო ნებისმიერი ახალი კონცეფციების თავისთავად.
ჩვენ ვისაუბრეთ Booleans უკან, როდესაც ჩვენ ითამაშა, რომელზეც Scratch,
მაგრამ რეალიზება ახლა შეგვიძლია დავიწყო წერა ჩვენი კოდი ბევრ სხვადასხვა გზა.
ამიტომ განსაკუთრებით pset1 თუ თქვენ სახის ცდილობს გაერკვნენ გზა დაწერა რამდენიმე პროგრამა,
შანსი თქვენ გისურვებთ რადგან შეიძლება იყოს ნებისმიერი რაოდენობის გადაწყვეტილებები
რომ თქვენ შეიძლება მოხდეს საფუძველზე.
მაგალითად, ეს მხოლოდ 3 ამისთვის კი მარტივი პროგრამების. ყველა უფლება.
და ახლა გავიხსენოთ ორშაბათს წამოვედით ამ აღვნიშნავთ დაბრუნების ღირებულებებს.
ასე რომ ძალიან პირველად დაწერა პროგრამა, რომელიც ჯერ არ აქვს მხოლოდ ძირითადი;
მას ასევე გააჩნია საკუთარი საბაჟო ფუნქცია რომ დავწერე აქ.
ასე რომ ხაზის მეშვეობით 31 34 მე განხორციელებული კუბი ფუნქცია.
ეს არ არის კომპლექსი. უბრალოდ * * ამ შემთხვევაში.
მაგრამ რა მნიშვნელოვანია ამის შესახებ არის ის, რომ მე აღების შეყვანის სახით
და მე დაბრუნების გამომავალი სახით * *.
ახლა მაქვს უნარი, ჰგავს მე ერთად prinf მარტო,
მოვუწოდებთ ამ ფუნქციის დარეკვით კუბი ფუნქცია.
>> და კუბი ფუნქცია იღებს გარკვეულ შეყვანის და კუბი ფუნქცია დააბრუნებს ზოგიერთი გამომუშავება.
პირიქით, printf უბრალოდ გააკეთა რაღაც.
ეს არ დაუბრუნებია არაფერი რომ ჩვენ ზრუნავდა, თუმცა როგორც განზე ეს სულაც დაბრუნების ღირებულება;
უბრალოდ ზოგადად იგნორირება მოვახდინოთ.
Printf უბრალოდ გააკეთა რაღაც. მას ჰქონდა გვერდითი ეფექტი დაბეჭდვის რომ ეკრანზე.
ამის საპირისპიროდ, ჩვენ გვყავს კუბი ფუნქცია, რომელიც რეალურად ბრუნდება რაღაც.
ასე რომ იმ იცნობს, ეს არის საკმაოდ მარტივია იდეა.
მაგრამ მათთვის ნაკლებად იცნობს ამ იდეას გადადის საშუალებებით და დავუბრუნდეთ შედეგები,
მოდით ვეცადოთ უბრალოდ რაღაც სუპერ მარტივი.
არის ვინმე კომფორტული ახლოვდება სცენაზე მოკლედ?
თქვენ უნდა იყოს კომფორტულად კამერა თქვენ ასევე. ჰო? Okay.
რა არის შენი სახელი? >> [სტუდენტი] კენ. >> კენ. ყველა უფლება. კენ, მოდის up.
კენ იქნება ფუნქცია ჯიშები აქ.
მოდით წავიდეთ წინ და ამის გაკეთება. მოდით კიდევ პატარა ლამაზი.
კარგია თქვენთან შეხვედრა. კეთილი იყოს ცენტრი ეტაპზე. ყველა უფლება.
მოდით მოხვდა ამ ღილაკს აქ. ყველა უფლება.
ასე რომ აქ თქვენ გაქვთ თანამედროვე chalkboard,
და რაც მე ვარ არის მთავარი ფუნქცია, მაგალითად,
და მე არ მაქვს iPad ჩემი მხრივ.
>> მე ნამდვილად არ ახსოვს, თუ როგორ უნდა - ისე, მე ვერ ვიტყვი, რომ.
მე ნამდვილად არ აქვს კარგი ხელწერა,
და ა.შ. ამიტომ მინდა ბეჭდვა რაღაც ეკრანზე ჩემთვის.
მე ვარ მყოფი ძირითადი პროგრამა, და მე ვაპირებ გაქვთ ამბობენ, რომ ეს
წერილობით ეს ჩემი ქათამი ნაკაწრი და შემდეგ ავლით თქვენ შეყვანის.
ასე რომ სულელური თუმცა ეს exercise არის, ცნება ფუნქციები და მოუწოდებდა ფუნქცია
და დაბრუნების ფუნქცია მართლაც boils ქვემოთ ეს.
მე ვარ მთავარი, მე ახლახან წერილობითი printf, ციტირებით-unquote რაღაც ეკრანზე,
მე ვარ გაშვებული ამ პროგრამის და როგორც კი printf იღებს მოუწოდა,
იგი იღებს ერთ არგუმენტად ან ერთი პარამეტრი ხანდახან შორის ორმაგი შეთავაზებები.
აქ არის ის, რომ არგუმენტი. მე გავლით მას კენ.
იგი არის შავი ყუთი წერილობითი გარკვეული რაოდენობის წლის წინ
რომ როგორც ჩანს მხოლოდ იცის როგორ ბეჭდვა რამ ეკრანზე.
ასე შეასრულოს.
ეს არ არის ცუდი. ძალიან კარგი.
ახლა კენ კეთდება შესრულებაში. ამჯამად მან უნდა ჩააბაროს ჩემთან არაფერი უკან?
არ არის, რომ ჩვენ ვნახეთ დღემდე.
ერთხელ, printf ამჯამად რეალურად დაბრუნებას ნომერი, მაგრამ ჩვენ ვაპირებთ იგნორირება, რომ ახლა
რადგან ჩვენ არ გამოიყენება იგი. ასე რომ ეს კენ.
და ა.შ. ახლა მთავარ იღებს კონტროლის პროგრამა ერთხელ
იმიტომ, რომ ხაზი კოდი, printf, კეთდება შესრულებაში.
და ჩვენ მივდივართ ჩვენი გზით, შესრულებაში რასაც სხვა ხაზების არსებობს.
ახლა მოდით ვცდილობთ ოდნავ განსხვავებული მაგალითი.
ამჯერად აქ მოდით პირველ გარკვევა ეკრანზე, და ამ დროს ჩვენ ყველაფერს გავაკეთებთ cubing ფუნქცია,
მაგრამ ამ დროს, მე მოველი გამონატანის მნიშვნელობა.
>> მოდით წავიდეთ წინ და ამის გაკეთება.
ახლა ხაზი კოდი, რომ ამბობს x იღებს Cube of x.
ხაზი კოდი, გაწვევა, ასე გამოიყურება: x = კუბი (x);
მაშ როგორ არის ამ იმუშავებს? მოდით წავიდეთ წინ და გაძლევთ თეთრი ეკრანზე ერთხელ.
ვაპირებ დაწერეთ ახლა ღირებულების x,
რომელიც ამ ეტაპზე დროში ხდება რომ იყოს, ვთქვათ, 2 შენარჩუნება ეს მარტივი.
მე არ ჩაიწერება წლის ნაჭერი ქაღალდი ღირებულება 2, რომელიც არის ჩემი ღირებულების x.
მე გადასცემს მას კენ. >> მე უბრალოდ წერენ პასუხი? >> ჰო, მოდით უბრალოდ წერენ პასუხი.
Okay. და ახლა მას აქვს დაბრუნებას ჩემთვის რაღაც. Perfect. Nice segue.
ახლა იგი ხელში ჩემთვის უკან ღირებულება 8 ამ შემთხვევაში, და რა შუაში იყო?
სინამდვილეში - ვნახოთ, ამ უფლებას. რა ვარ მე გაკეთებას აპირებს იგი?
ახლა მე ვაპირებ ამ ღირებულების და ფაქტობრივად ჩაწეროთ იგი იმ იგივე ბიტი მეხსიერებაში.
მაგრამ შეამჩნევს ვარ სახის იბრძოდა აქ.
მე პატარა დაბნეული რადგან სად მაქვს რეალურად წერენ ღირებულება x,
რადგან ის, რაც მე უბრალოდ გაკეთდეს ფიზიკურად მხრივ კენ ნაჭერი ქაღალდი, რომ ჰქონდა ღირებულება 2,
რაც x, და მართლაც, რომ ზუსტად რა მოხდა.
გამოდის, რომ როცა რეკავთ ფუნქცია და თქვენ კორიდორი არგუმენტი
მოსწონს hello, მსოფლიოს ან თქვენ კორიდორი არგუმენტი მოსწონს 2,
ზოგადად, თქვენ გადადის ასლი, რომ არგუმენტი.
და ა.შ. როგორც მე დაწერა ქვემოთ რიცხვი 2 აქ და გადასცეს იგი კენ,
რომ უნდა ნიშნავს, რომ მე ჯერ კიდევ აქვს ასლი ღირებულება 2 სადღაც
რადგან მართლაც, ახლა რომ მე მიღებული თავში ღირებულება 8, მე უნდა წავიდეთ უკან RAM
და რეალურად დაწერეთ 8, სადაც მე ერთხელ ჰქონდა ნომერი 2.
ასე რომ ვიზუალურად, გახსოვდეთ ეს ცნება გადადის, სიტყვასიტყვით, ასლი ღირებულება.
>> კენ აკეთებს რამ, ხელები ჩემს უკან რაღაც - ამ შემთხვევაში ღირებულების მოსწონს 8 -
და მერე რაიმე უნდა მოვიმოქმედოთ, რომ ღირს, თუ მინდა შეინახოს იგი გარშემო.
ასე რომ ყველა ამ დავბრუნდებით უნდა იყოს ძალიან ნაცნობი ადრე ხანგრძლივი.
დიდი მადლობა ამ დემო აქ, კენ. [ტაში]
ძალიან კარგად გაკეთდეს.
ვნახოთ, როგორ, რომ საბოლოოდ ეხება ზოგიერთი ფუნქცია მოუწოდებდა, რომ ჩვენ აქ აკეთებენ.
ნება მომეცით წავიდეთ წინ და მიგვიყვანს თავში cubing მაგალითად აქ.
გაითვალისწინეთ, რომ თუ ჩვენ გვინდა რეალურად დაიწყოს აღების ამ შემდგომი,
ჩვენ ვაპირებთ უნდა მავიწყდება იმისა, რომ ხმების x რომ მიმდინარეობს გადავიდა აქ
განსხვავდება რა მართლაც გადავიდა, რათა ფუნქცია.
ასე რომ კიდევ ერთხელ, ამ უღელტეხილზე მიერ ასლი უნდა გახდეს საკმაოდ გერმანე რაღაც მომენტში.
მოდით შევხედოთ რაღაც რომ არ საკმაოდ მუშაობა უფლება არავის გაუკეთებია.
მე ვაპირებ წავიდეთ წინ და გახსნა მესამე buggy მაგალითად, რომელიც გაყალბდა ბუნებით,
და ეს ე.წ. buggy3 და იგი ახორციელებს შევცვალე ფუნქცია.
აქ მთავარი ფუნქცია, რომელიც X და Y თვითნებურად ინიციალიზაცია რომ 1 და 2, შესაბამისად.
ჩვენ შეეძლო GetInt, მაგრამ ჩვენ უბრალოდ უნდა მარტივი სწავლება,
ასე ძნელია კოდირებული როგორც 1 და 2.
სტრიქონები 21 და 22, ჩვენ აშკარად ამობეჭდოთ x და y, 1 თითო ხაზზე.
მაშინ on line 23, მე ამტკიცებენ მე შევცვალე ეს ფასეულობები, dot, dot, dot.
მე აშკარად მოვუწოდებთ ფუნქცია ხაზი 24 წ swap რომ იღებს 2 არგუმენტები.
ეს სრულიად legit ამისთვის ფუნქციები მიიღოს 2 არგუმენტები. ჩვენ ვხედავთ printf გავაკეთებთ უკვე.
>> ასე რომ swap სავარაუდოდ იღებს x და y, და როგორც მისი სახელი ვარაუდობს,
მინდა იმედი ვიქონიო, რომ აპირებს სვოპ ამ 2 ღირებულებებს.
ასე რომ მერე აცხადებენ on line 25 "swapped!" მე და reprint x და y
ქვეშ ვარაუდი, რომ ისინი მართლაც swapped.
მაგრამ თუ მე რეალურად აწარმოებს ამ პროგრამის - ნება მომეცით გახსენით ტერმინალი ფანჯარა,
ნება მომეცით მიიღოს buggy3 - როგორც სახელი ვარაუდობს, ამ არ აპირებს დასრულდება კარგად
რადგან, როდესაც მე დააჭიროთ შეამჩნევთ, რომ X არის 1, Y არის 2,
და ჯერ კიდევ ბოლომდე პროგრამა, ისინი მაინც, ფაქტობრივად, იგივე.
ამიტომ ეფუძნება მიტინგი მხოლოდ ახლა კენ, რა რეალურად საქმე?
მოდით ჩაყვინთვის შევიდა ამ swap ფუნქცია. ეს სუპერ მოკლე. ეს მხოლოდ რამდენიმე ხაზი კოდი ხანგრძლივი.
მაგრამ რა არის ფუნდამენტური პრობლემა ეფუძნება მარტივი ამბავი განუცხადა up აქ კენ?
რატომ swap გაფუჭებული?
[სტუდენტი] თქვენ შენახვა, რათა ასლი, არ ცვლადი.
სწორედ. ჩვენ შენახვის, რათა ასლი, არ ცვლადი თავად.
სხვა სიტყვებით, swap სავარაუდოდ იღებს 2 არგუმენტები, int,
და ეს თვითნებურად მოუწოდა და ბ,
და აქ მე გადავიდა x და y, რომლებიც შესაბამისად 1 და 2
მაგრამ მე არ სიტყვასიტყვით გადადის x, მე არ სიტყვასიტყვით გადადის Y,
მე გავლით ასლი x და ასლი წ.
თითქმის თითქოს თქვენ გადაწერა და pasted შევიდა swap
ფასეულობები, გნებავთ რეალურად მანიპულირება.
ასე რომ თუ ეს შემთხვევაა, როდესაც მე პროგრამის დაწყება შესრულებაში ხაზი 35 მაშინ 36,
როცა მისაღებად ხაზი 37, ამ დროისთვის ამბავი, რა არის ღირებულება?
ამ დროისთვის ამბავი, ხაზი 37, რა არის ღირებულება ამ ეტაპზე? >> [სტუდენტი] 1.
[Malan] უნდა იყოს მხოლოდ 1, უფლება, რადგან x იყო ძალაში შევიდა, როგორც პირველი არგუმენტი,
და ამ ფუნქციის მხოლოდ თვითნებურად მოუწოდებს მისი პირველი არგუმენტი.
ანალოგიურად არის Y მეორე არგუმენტი, და ეს მხოლოდ თვითნებურად მოუწოდებდა მეორე არგუმენტი ბ.
>> ეს dichotomy რეალურად საკმაოდ უბრალოდ განმარტა. დაფიქრდით.
არც ერთი ჩვენგანი არ შეხვდა ადამიანი, რომელიც წერდა printf,
ასე ნამდვილად, იგი არ აქვს როგორია ჩვენი ცვლადები 30 წლის შემდეგ ვაპირებთ ეწოდება.
ასე უნდა იყოს განსხვავება რა რეკავთ ცვლადები წელს ფუნქციების თქვენ წერა
და რა რეკავთ ცვლადები წელს ფუნქციების თქვენ მოუწოდებდა ან გამოყენებით.
ასე რომ, სხვა სიტყვებით, მე არ წერია ჩემი ცვლადები როგორც x და y,
მაგრამ თუ ვინმეს დაწერა swap ფუნქციის, იგი ნამდვილად არ ვიცი
რა ჩემი ცვლადები ვაპირებთ ეწოდოს,
ასე, რომ ეს არის რატომ უნდა ამ Duality ვინაობას.
ტექნიკურად, მე ვერ გავაკეთებ ამას დამთხვევა,
მაგრამ ისინი კვლავ ძალაში შევიდა, როგორც ასლები.
ეს იქნებოდა მხოლოდ სუფთა დამთხვევა ესთეტიურად თუ ეს პირი რომელმაც დაწერა swap
კაცებმა იგივე სახელები.
ამრიგად, ამ ეტაპზე იმ ამბავს, ხაზი 37, 1, ბ, 2, და ახლა გაგრძელება სვოპ მათ.
უპირველეს ყოვლისა, ნება მომეცით რეალურად ამის გაკეთება ბევრად უფრო მარტივად.
მე არ ვიცი რა იმ 3 ხაზი კოდი აკეთებდნენ.
ნება მომეცით უბრალოდ ამ: ბ =; = ბ; გაკეთდეს.
რატომ არის ამ გატეხილი, ლოგიკურად?
ეს სახის ინტუიციური რამ, არა?
ასე ხდება B და B ხდება,
მაგრამ პრობლემა ის არის, რომ როგორც კი ხაზი 37 ახორციელებს, რა ღირებულების და ბ?
იგივე, 1, იმიტომ, რომ თქვენ არ clobbered, ასე ვთქვათ, თქვენ შეიცვალა B ერთნაირი.
ასე რომ კიდევ ერთხელ ხაზი 37 აქვს შესრულებული, რომ დიდი, თქვენ ახლა უკვე 2 ასლები ნომერი 1
შიგნით ამ ფუნქციას, ისე მაშინ, როდესაც თქვენ ამბობთ შეესაბამება 38 = B,
თქვენ სახის ბრალია, რადგან თქვენ მხოლოდ მინიჭება 1 დან 1.
თქვენ სახის დაკარგა ღირებულება თქვენ ზრუნავდა.
ასე რომ, ორიგინალური ვერსია ამ შეამჩნევთ, რა გავაკეთე.
მე ნაცვლად ჰქონდა მესამე ხაზი კოდი, რომ ჩანდა მოსწონს ეს.
ვაცხადებ დროებით ცვლადი.
>> TMP არის ძალიან გავრცელებული სახელი დროებითი ცვლადი, და ეს int
რადგან მას ემთხვევა რა მინდა ასლი.
მე შესანახად ასლი შიგნით tmp, ამიტომ კიდევ ერთხელ ხაზი 37 აქვს შესრულებული,
ღირებულება არის - სწრაფი საღი აზრის გამშვები - 1, ღირებულება B არის 2,
და ღირებულება tmp ასევე 1.
ახლა მე შეასრულოს ხაზის 38.
ერთხელ ხაზი 38 ახორციელებს, იღებს ღირებულების ბ. და ბ იყო 2, ასე რომ არის 2.
ამრიგად, ამ ეტაპზე იმ ამბავს, არის 2, ბ არის 2 და tmp არის 1,
ახლა ლოგიკურად, ჩვენ უბრალოდ plop tmp ღირებულების შევიდა B და ჩვენ გავაკეთეთ.
ამიტომ ჩვენ მოგვარდება, რომ პრობლემა.
სამწუხაროდ, როდესაც მე აწარმოებს ამ პროგრამის ამ ფორმით, ის ფაქტობრივად არ სვოპ ნებისმიერი ღირებულებებს.
მაგრამ უნდა იყოს ნათელი, თუ რატომ?
მე დაფიქსირდა ლოგიკური პრობლემა მხოლოდ მომენტში წინ,
თუმცა ისევ და ისევ, თუ აწარმოებს ამ პროგრამის x და y უცვლელი რჩება
ბოლოსთვის პროგრამის აღსრულება.
[Inaudible სტუდენტი კომენტარი] >> ჩვენ არ დაბრუნდა არაფერი, ისე, რომ მართალია.
მაგრამ თურმე არსებობს ცოტა პრობლემა აქ რადგან ჯერჯერობით
ერთადერთი, რაც ჩვენ ვერ დაბრუნდა არის ერთი რამ, და ეს შეზღუდვა C.
თქვენ შეგიძლიათ მხოლოდ დაბრუნებას ნამდვილად ერთ ღირებულება, რომლის დროსაც მე სახის დავრჩებოდით აქ
რადგან მე ვერ დაბრუნდებიან ახალი ღირებულება x ან მე ვერ დაბრუნდებიან ახალი ღირებულება Y,
მაგრამ მე მინდა ორივე უკან.
ამიტომ დაბრუნების არ არის მარტივი გამოსავალი აქ.
მაგრამ პრობლემა ფუნდამენტურად არის რატომ? რა გვაქვს რეალურად swapped?
[სტუდენტი] და ბ. >> და ბ.
მაგრამ და ბ are ასლები x და y, რაც იმას ნიშნავს, რომ ჩვენ უბრალოდ ყველაფერი ამ ნაწარმოებზე,
ჩვენ მხოლოდ დახარჯული 3 წუთი ლაპარაკი swap ფუნქცია და ყველა 3 ამ ცვლადებს,
და ეს დიდი, მშვენივრად სწორი იზოლაცია,
მაგრამ და B-ს ფარგლებს მხოლოდ არის ამ ხაზების აქ.
>> ასე რომ, ისევე, როგორც for loop, თუ განაცხადოს რიცხვი მე შიგნით ამისთვის მარყუჟის,
ანალოგიურად, თუ თქვენ გამოცხადების და ბ შიგნით ფუნქციის რომ თქვენ წერილობითი,
ისინი ძალაშია მხოლოდ შიგნით რომ ფუნქცია, რაც იმას ნიშნავს, როგორც კი swap კეთდება შესრულებაში
და ჩვენ აქედან ხაზი 24 ხაზი 25, X და Y არ იქნა შეცვლილა.
თქვენ უბრალოდ გადაყრილი მთელი ბევრი დრო შევცვალე ასლები ცვლადები.
გამოდის, რომ გადაწყვეტილება ამ ფაქტობრივად არასამთავრობო აშკარა.
ეს არ არის საკმარისი დაბრუნების ღირებულებები, რადგან ჩვენ მხოლოდ დაბრუნდნენ 1 ღირებულება,
და მე ნამდვილად მინდა, რომ სვოპ ორივე x და y ამავე დროს,
ამიტომ ჩვენ ვაპირებთ უნდა დაუბრუნდეს ამ.
მაგრამ ახლა, გააცნობიეროს, რომ საკითხი ფუნდამენტურად გამომდინარე იმისა, რომ A და B არის ასლები
და ისინი საკუთარ ფარგლებს.
მოდით ცდილობენ მოგვარებას ამ რამდენიმე გზა.
ნება მომეცით რეალურად გადახვევა უკან აქ და გახსენით, ვთქვათ, მეოთხე ვარიანტი ამ, buggy4.
რაც შეეხება ამ საკითხთან დაკავშირებით?
ეს არის მსგავსი, მაგრამ უფრო მარტივი პრობლემა შევხედოთ წინაშე ავიღებთ stab at გადაჭრის იგი.
ეს პროგრამა ეწოდება წუთობრივი, და ეს აშკარად initializes x რიცხვი to 1 სტრიქონში 18.
მე მაშინ აცხადებენ x არის 1, მე მაშინ აცხადებენ "დამატება ..."
მე მაშინ მოვუწოდებთ წუთობრივი, მაგრამ მერე ხაზები 22 და 23, მე აცხადებენ მისთვის incremented,
მე აცხადებენ x არის რაც არ არის - 2, სავარაუდოდ - მაგრამ ამ პროგრამის buggy.
რა არის პრობლემა?
Yeah. >> [Inaudible სტუდენტი საპასუხოდ] >> ზუსტად.
ამიტომ x გამოცხადდა, ცხადია, on line 18.
სწორედ შიგნით ძირითადი ს Curly braces.
ასე რომ მარტივი პასუხი აქ არის ის, რომ მაშინ, როცა x არსებობს აქ,
ის არ არსებობს შეესაბამება 32, ასე რომ ეს პროგრამა რეალურად არც კი შეადგინოს.
შემდგენელი როდესაც ვცდილობ შედგენის ეს კოდი აპირებს დაწეროთ at me
შესახებ რამდენიმე გამოუცხადებელ იდენტიფიკატორი ან რაღაც რომ ეფექტი. ფაქტობრივად, მოდით ვცდილობთ.
ეს არის მიიღოს buggy4. არსებობს ეს.
გამოყენება გამოუცხადებელ იდენტიფიკატორი "x" სტრიქონში 32.
და ფაქტობრივად, მოდით უფრო ზუსტად რომ ვთქვათ, დღეს აქ, ასე, რომ ეს არის სასარგებლო
ოფისში საათი და სახლში.
>> გაითვალისწინეთ, რომ ეს პატარა cryptically წერილობითი.
მაგრამ ის ფაქტი, რომ Clang აქვს yelled ჩვენზე და განაცხადა, რომ buggy4.c: 32:5, ფაქტობრივად სასარგებლო.
ეს ნიშნავს, რომ შეცდომა on line 32 საათზე ხასიათი თანამდებობა 5.
ამგვარად 1, 2, 3, 4, 5. სწორედ, ფაქტობრივად, სადაც პრობლემა არის.
და ასევე, ძალიან, გვახსოვდეს ოფისში საათი და სახლში, მე იღბლიანი აქ.
მაქვს ერთი შეცდომა. ეს იქნება შედარებით იოლი დაფიქსირება.
მაგრამ თუ თქვენ გაქვთ მთელი ეკრანის სავსე უამრავი შეცდომის შეტყობინებები,
ერთხელ გააცნობიეროს, რომ bottommost შეიძლება მხოლოდ იყოს სიმპტომატური of ზედოთ მდებარე ერთ.
ამიტომ ყოველთვის აყვანას ქვემოთ თქვენი შეცდომები ზემოდან ქვემოთ
რადგან შეიძლება მხოლოდ იყოს Daisy ჯაჭვის ეფექტი
რომელიც მიგვითითებს გაქვთ გზა მეტი პრობლემა ვიდრე თქვენ რეალურად გავაკეთოთ.
ასე როგორ უნდა დაფიქსირება ამ შემთხვევაში ჩემი მიზანია ნამატი x? >> [სტუდენტი] ჩადება x გლობალური.
Okay, ასე რომ ჩვენ შეგვიძლია x გლობალური.
ავიღოთ კომბინაცია, რომ მე გააფრთხილა შესახებ ადრე, მაგრამ heck, ჩვენ უბრალოდ უნდა გადავწყვიტოთ,
მოდით უბრალოდ, ვამბობთ int x აქ. ხდის x გლობალური.
ახლა მთავარ ხელი მიუწვდება და ნამატი ხელი მიუწვდება ის,
და ნება მომეცით, წავიდეთ წინ და შეადგინონ ეს ახლა.
ჩადება buggy4, შეიყვანეთ. როგორც ჩანს, კომპილაციის არის.
მოდით აწარმოებს buggy4. და როგორც ჩანს, რეალურად იმუშავებს.
ეს არის ერთი ასეთი რამ რომ გააკეთოს, როგორც მე ვიტყვი, არ როგორც მე,
როგორც მე უბრალოდ გაკეთდეს აქ, რადგან ეს, ზოგადად,
ჩვენი პროგრამების ვაპირებთ კიდევ უფრო მეტი საინტერესო და ბევრად აღემატება ამ,
და თუ თქვენი გამოსავალი ცხოვრების პრობლემები მხოლოდ დააყენა ყველა ცვლადები ზედა თქვენი ფაილი,
ძალიან სწრაფად არ პროგრამების მისაღებად horrifically რთული მართვა.
იგი იღებს უფრო რთული მგონია ახალი ცვლადი სახელები,
იგი იღებს უფრო რთული იმის გაგება, თუ რა ცვლადი აკეთებს რა,
და ა.შ. ზოგადად, ეს არ არის კარგი გამოსავალი.
ასე რომ მოდით ეს უკეთესი.
ჩვენ არ გვინდა, რომ გამოიყენოთ გლობალური ცვლადი აქ.
>> მე მინდა, რომ ნამატი x, ამიტომ მე ვერ აშკარად -
დასასრულს დღეში, ეს არის სახის სულელური ამბავი იმიტომ, რომ ჩვენ უბრალოდ ამ -
მაგრამ თუ არ იცოდა, რომ ოპერატორი ან მე არ მისცეს შეცვლის მთავარ თავად,
როგორ სხვას შეიძლება მე განახორციელოს კენ მეტი აქ ამ დროს არ კუბი არამედ ნამატი?
როგორ შევცვალო ეს საგანი აქ? Yeah.
[სტუდენტი] კორიდორი x და შემდეგ დაბრუნდნენ [inaudible] >> Okay, კარგი.
მაშ რატომ არ მე კორიდორი x და შემდეგ ვიდრე მისი დაბრუნება,
რატომ არ მე უბრალოდ დააბრუნოს x + 1.
რამდენიმე რამ უნდა შეცვალოს აქ. მე სწორ გზაზე.
კიდევ რა უნდა tweak? ვინმე. Yeah.
[Inaudible სტუდენტი საპასუხოდ]
მე უნდა შეიცვალოს დაბრუნების გაცნობის ნამატი, რადგან ეს არ ბათილად.
ძალადაკარგულად არაფერს ნიშნავს მიმდინარეობს დაბრუნდა, მაგრამ მკაფიოდ არის ეს,
ასე რომ ეს უნდა შეიცვალოს, რათა - >> [სტუდენტი] int.
int იყოს შეესაბამება რასაც მე რეალურად დაბრუნების.
არის რაღაც ჯერ კიდევ buggy აქ. Yeah.
[Inaudible სტუდენტი საპასუხოდ] >> [Malan] ასე უნდა იყოს x?
[Inaudible სტუდენტი საპასუხოდ] >> [Malan] Ah, ამიტომ მე უნდა გაიაროს x.
ასე რომ, მე უნდა გავაკეთოთ ეს აქ. >> [Inaudible სტუდენტი კომენტარი]
[Malan] ასე პროტოტიპი, უნდა შეიცვალოს ეს ყველაფერი აქ.
ასე რომ, ეს უნდა გახდეს int, ამ უნდა გახდეს -
hmm, მე რეალურად bug ქვემოთ აქ. მოდით დაფიქსირება ამ ერთი პირველი.
რა უნდა ამ რეალურად იყოს? ეს რაღაც უნდა იყოს int რაღაც.
ეს შეიძლება იყოს X, მაგრამ გულწრფელად, თუ დაიწყება მოუწოდებენ ყველა თქვენი ცვლადები x,
იგი აპირებს მიიღოს უფრო ნაკლებად ნათელია, რომელიც, რომელიც.
>> მოდით უბრალოდ თვითნებურად აირჩიოს სხვადასხვა ნეიმინგი კონვენცია ჩემი დამხმარე ფუნქციები,
ფუნქციების მე წერა. ჩვენ მოვუწოდებთ მას, ან ჩვენ შეგვიძლია ეძახით -
მოდით ეძახით ხმების რომ ვიყოთ კიდევ უფრო ცხადი.
ასეა, მაშინ მე უნდა დაბრუნდეს რაოდენობის მიუხედავად არის პლუს 1,
და ახლა მე უნდა შეიცვალოს 1 სხვა რამ აქ და ერთი სხვა რამ აქ.
რა უნდა შეიცვალოს on line 21 პირველი? >> [Inaudible სტუდენტი საპასუხოდ]
[Malan] მე უნდა მივანიჭოთ მას x. მე არ შეუძლიათ უბრალოდ მოვუწოდებ ნამატი (x).
მე უნდა გვახსოვდეს პასუხი შეცვლით ღირებულება x on მარცხენა მხარეს.
და მიუხედავად იმისა, x არის მარცხენა და მარჯვენა, რომ მთლიანად ჯარიმა
რადგან მარჯვენა მხარეს იღებს შესრულებული პირველი მაშინ იღებს plopped შევიდა მარცხენა რამ -
x ამ შემთხვევაში.
და მერე ბოლოს, ეს არის ადვილი სარემონტო არის.
ეს უნდა უბრალოდ დაემთხვა რა ქვემოთ ქვემოთ int ნომერი.
ასე რომ მთელი bunch of ცვლილებები მართლაც სულელური ფუნქცია
მაგრამ წარმომადგენელი რამ, რომ ჩვენ სულ უფრო გსურთ.
ასე რომ buggy4. მე ბრალია სადღაც.
ოჰ, ღმერთი ჩემი. ხუთი შეცდომები 6-ხაზის პროგრამის.
რა არის არასწორი on line 18, ხასიათი 5?
ასე რომ მე უნდა განაცხადოს ამ, int.
ვნახოთ. არსებობს მთელი bunch სხვა შეცდომები.
ოჰ, ღმერთი ჩემი - 19, 18, 21 - მაგრამ ერთხელ, მოდით უბრალოდ გარკვევა ეკრანზე, კონტროლის L აქ,
და გამეორება Clang.
ასე 5 პრობლემების რეალურად მხოლოდ, რომ 1.
ახლა მოდით აწარმოებს buggy4, შეიყვანეთ. Whew, x უკვე incremented სწორად.
ყველა უფლება. ნებისმიერი კითხვები, თუ როგორ უნდა იყოს ციფრები? Yeah.
[Inaudible სტუდენტი კითხვა] >> კარგი კითხვაა.
როგორ არის ის, რომ მე შემიძლია უბრალოდ შეცვალეთ x ნომერზე და პროგრამა ვიცი მაშინვე?
>> ისევ, ვფიქრობ, რომ ეს ამ აბსტრაქცია.
ასე რომ, თუ მე ვარ ძირითადი და კენ არის წუთობრივი, გულწრფელად, არ მაინტერესებს რა კენ მოუწოდებს მისი iPad.
არ მაინტერესებს, რა იგი მოუწოდებს არაფერი რომ უნდა გააკეთოს მისი განხორციელების ფუნქცია.
ეს არის განხორციელება დეტალურად რომ მე, ძირითად, არ აინტერესებს.
და ასე, უბრალოდ იცვლება ის თანმიმდევრულად შიგნით ფუნქცია - ნომერი აქ და ნომერი აქ -
არის ყველა სჭირდება, თუ მე recompile.
ეს ერთგვარი მინდა თუ ფიქრობთ ამის შესახებ ბევრი ჩვენგანი, იმ თქვენ ერთად მძღოლის ლიცენზიები
ვინც არ ამოძრავებს, ან თუ თქვენ კი ბიძგი მანქანაში,
ყველაზე მეტად ჩვენს წარმოდგენა არ როგორ მანქანა მუშაობს ქვეშ hood.
და სიტყვასიტყვით, თუ თქვენ გახსენით hood, ყველაზე მეტად ჩვენს - თავს შედის -
არ ვაპირებთ ნამდვილად ვიცი, რა ჩვენ შევხედავთ,
სახის მოსწონს იგრძნობთ ერთად პერსონალის მოსწონს ეს ახლავე.
მაგრამ ჩვენ ნამდვილად არ უნდა იზრუნოს, თუ როგორ მუშაობს მანქანა,
ჩვენ არ უნდა იზრუნოს რა ყველა წნელები და pistons და კაბელები შიგნით მანქანა
რეალურად აკეთებს.
ასე რომ მსგავსი რამ, რაც თქვენ მოვუწოდებთ დგუში არ აქვს მნიშვნელობა აქ ამ შემთხვევაში. იმავე იდეას.
Yeah. >> [Inaudible სტუდენტი კითხვა]
თუ უფრო გამოყენების ცვლადი xa მომენტში წინ,
თქვენ, პროგრამისტი, უნდა შეცვალოს ისინი ყველგან.
ან შეგიძლიათ სიტყვასიტყვით გავაკეთოთ ფაილი, მენიუ, და შემდეგ მოძებნა, შეცვალეთ - რაღაც მსგავსი -
მაგრამ თქვენ აპირებთ უნდა მოხდეს ყოველთვიურად ცვლილებების თავს.
თქვენ უნდა იყოს თანმიმდევრული. >> [სტუდენტი] თუ არსებობს მრავალი ცვლადის [inaudible]
კერძოდ იმისათვის, როგორიც აქ, თუ ეს იყო int მეორე ნომერი? >> [სტუდენტი] სწორი.
[Malan] Yeah. დაალაგე მნიშვნელოვანია, როდესაც თქვენ მოუწოდებენ ფუნქცია.
>> ასე რომ, თუ მე მირეკავდა ნამატი აქ რაღაც მძიმით რაღაც,
არსებობს პირდაპირი რუკების.
პირველი ცვლადი, რასაც ის მოუწოდა, კეთდება ასლი პირველი არგუმენტი მეტი აქ.
უკაცრავად. ეს არ უნდა იყოს ფრჩხილებში.
მეორე არგუმენტი ხაზები ერთად მეორე. ამიტომ იმისათვის, დიახ, თემა. ყველა უფლება.
უკაცრავად. მე მივიღე დიდი გზა მისაღებად არსებობს. გაქვთ სხვა კითხვები? ყველა უფლება.
ასე რომ ვნახოთ, შევძლებთ თუ არა ხატავს სურათს, რა რეალურად მიმდინარეობს აქ
ქვევმოთ hood, ასე ვთქვათ.
ეს არის მართკუთხედი, რომ შესაძლოა წარმოადგენდეს თქვენი კომპიუტერის მეხსიერებაში.
მაშინაც კი, თუ თქვენ არ ვიცი როგორ მუშაობს მეხსიერების ან როგორ RAM სამუშაოები,
მინიმუმ ვივარაუდოთ, რომ თქვენ გაქვთ bunches იგი ამ დღეებში.
თქვენ მოხვდით მბ იგი, თქვენ მოხვდით გიგაბაიტი ეს,
და ჩვენ ვიცით კვირაში 0, რომ ერთი ბაიტი არის მხოლოდ რა? >> [სტუდენტი] 8 ბიტი.
8 ბიტი, არა? ასე რომ 8 zeroes და 1.
ასე რომ, თუ თქვენი კომპიუტერი GIG of RAM, 2 gigs of RAM ამ დღეებში,
თქვენ გაქვთ მილიარდი ან 2 მილიარდი ბაიტი მეხსიერების ან უხეშად 8 მილიარდ ან 16 მილიარდი ბიტი
შიგნით თქვენი კომპიუტერი.
განსხვავებით ცოტა Wooly Willy მაგალითად, ეს არ მაგნიტური ნაწილაკების ჩვეულებრივ უქმნით.
სულ უფრო და უფრო - ში ლაპტოპები მინიმუმ - ის მყარი სახელმწიფო დისკები, SSDs,
რომ უბრალოდ არ აქვთ მოძრავი ნაწილები. ეს ყველაფერი ელექტრონულ. ეს ყველაფერი ელექტროენერგიის დაფუძნებული.
ამიტომ ვფიქრობ, ამ ოთკუთხედი როგორც მხოლოდ წარმოადგენენ 1 ან 2 გბ მეხსიერების რომ თქვენ გაქვთ.
>> ასე რომ ბლოკი მეხსიერება.
მსოფლიოში კომპიუტერული მეცნიერების სახის partitioned off
მოცულობით მეხსიერების გავაკეთოთ სხვადასხვა რამ.
მაგალითად, თუ ეს თქვენი კომპიუტერის RAM, როგორც მიერ შემოთავაზებული ოთხკუთხედი იქ,
აღმოჩნდება, რომ კონვენციის, ზედა თქვენი RAM, ასე ვთქვათ,
ზოგადად რასაც ტექსტი სეგმენტი.
ეს ის 0S და 1s, რომ თქვენ არ შედგენილი.
ასე რომ, როდესაც ჩვენ ჩანდა ქვეშ Hood რა a.out არის,
ყველა ამ 0S და 1s, როდესაც თქვენ აწარმოებს პროგრამა,
იმ 0S და 1s არიან დატვირთული თქვენს ხისტ დისკზე შევიდა რაღაც მოუწოდა RAM,
და RAM ისინი დააყენა ზედა.
ამავდროულად, თქვენ გაქვთ სხვა რამ: ინიციალიზაცია მონაცემები, uninitialize მონაცემები.
იმ 2 swaths მეხსიერების ეხება გლობალური ცვლადები, რომელიც თქვენ არ ხშირად იყენებენ
მაგრამ ზოგჯერ თუ ისინი დასრულდება up up there ისევე.
მაშინ არსებობს რამდენიმე სხვა პერსონალი: გარემოს ცვლადები, რომელიც ჩვენ არ დახარჯოს დიდი დრო ჩართულია,
მაგრამ მაშინ 2 მნიშვნელოვანი რამ, რომ დავბრუნდებით მთელი სემესტრის
დასტის და ბევრი.
ასე რომ ყველაზე თქვენი კომპიუტერის მეხსიერების დაცულია როდესაც გაშვებული პროგრამა
რაღაც მოუწოდა დასტის და რაღაც მოუწოდა ბევრი.
ჩვენ არ ვაპირებთ ვისაუბროთ ბევრი დღეს, მაგრამ ჩვენ ვსაუბრობთ Stack.
დასტის ნიშნავს conjure up ვიზუალური of სასადილოს კვება ქაღალდის წელს Mather სახლი
ან ნებისმიერ ადგილას მოხდეს იყოს სადაც სასადილოს პერსონალის გაწმენდა მათ ყოველდღე,
ისინი დააწყობს მათ მდე სართულზე up,
და ანალოგიურად, მეხსიერებაში, არსებობს ამ იდეას აყენებს რაღაც დასტის,
აყენებს რაღაც დასტის, აყენებს რაღაც Stack.
და რას ვგულისხმობთ ამ?
>> მოდით მიუახლოვდით მხოლოდ ქვედა ნახევარში ამ სურათს, თქვენი კომპიუტერის RAM,
შესთავაზოს შემდეგ.
თურმე, როდესაც თქვენ აწარმოებს პროგრამა მოსწონს a.out ან მიესალმები -
მიუხედავად პროგრამის არის ის, რომ თქვენ წერილობითი -
ერთხელ, იმ 0S და 1s ჩატვირთვის თქვენი მყარი დისკის, რომელიც გრძელვადიანი შენახვა,
რჩება იქ მაშინაც კი, როდესაც გაიყვანოს plug, ჩაიტვირთება RAM.
RAM არის სწრაფად, ვიდრე მყარი დისკები - ის ნაკლებია მყარი დისკები -
მაგრამ აქ პროგრამების ცხოვრობს, ხოლო თქვენ გაშვებული მათ.
ასე, რომ თქვენ ორმაგად დაწკაპეთ პროგრამა Mac ან PC, ის დატვირთული მყარ დისკზე შევიდა RAM.
როგორც კი ის ჩაიტვირთება RAM, 0S და 1s გადასვლა ზე გზა ზევით,
ე.წ. ტექსტი სეგმენტი, მაგრამ შემდეგ, როგორც კი თქვენი პროგრამის რეალურად იწყება გაშვებული,
ძირითადი ფუნქცია ეწოდება, და მთავარი, როგორც ჩვენ ვნახეთ, ხშირად აქვს ადგილობრივი ცვლადები,
და მას აქვს ints და სიმებიანი და chars და მოსწონს.
ასე რომ, თუ თქვენი პროგრამა, რომელიც თქვენს მიერ დაწერილი ან პროგრამა, რომელიც თქვენ ორმაგი დააწკაპებთ
გამოყენებული ზოგიერთი ცვლადის შიგნით ძირითადი,
ისინი დასრულდება up ბოლოში თქვენი დასტის მეხსიერების, ასე ვთქვათ.
კერძოდ, რას ნიშნავს რეალურად?
ეს მხოლოდ იმას ნიშნავს, რომ თუ ჩვენ ვაპირებთ ხმების bytes of RAM თქვენს კომპიუტერში,
შეამჩნია, რომ ეს შეიძლება იყოს byte ნომერი 0, ეს შეიძლება იყოს byte ნომერი 1, 2, 3, 4, 5, 6,
ყველა გზა მდე 2 მილიარდი იქნება ყველა გზა იქ ზედა.
ასე რომ, სხვა სიტყვებით, როდესაც ვსაუბრობთ RAM ან მეხსიერების თვალსაზრისით ბაიტი,
უბრალოდ იმას ნიშნავს, რომ ვიღაცამ გადაწყვიტა, რა რაოდენობის თითოეული იმ მოცულობით მეხსიერება.
ასე რომ, როდესაც თქვენ გჭირდებათ 32 ბიტი for int ან გჭირდებათ 8 ბიტი ამისთვის char,
სად ისინი დასრულდება up მეხსიერებაში?
>> კონცეპტუალურად, ისინი უბრალოდ დასრულდება მდე ბოლოში ამ რამ მოუწოდა Stack.
მაგრამ რა საინტერესოა ახლა, როდესაც მთავარ მოუწოდებს ფუნქცია -
ვარაუდობენ ფუნქცია მოუწოდა foo, მხოლოდ თვითნებური სახელი -
რა ხდება არის მთავარია ბოლოში ამ დასტის მეხსიერების;
foo არის ისიც, ყველაზე მთავარი მეხსიერებაში.
ასე რომ ნებისმიერი ლოკალური ცვლადები რომ foo არ დასრულდება მდე სახის კონცეპტუალურად ზემოთ იმ მთავარ.
თუ foo მოუწოდებს სხვა ფუნქცია მოუწოდა ბარი, იმ ცვლადის დასრულდება მდე აქ.
თუ ბარი მოუწოდებს რაღაც, აქ, აქ, აქ.
რა საინტერესოა შესახებ გაშვებული პროგრამის არის ის, რომ, როგორც თქვენ მოვუწოდებთ ფუნქციები
და როგორც ამ ფუნქციების მოვუწოდებთ ფუნქციები და როგორც ამ ფუნქციების მოვუწოდებთ ფუნქციები,
თქვენ დაამყარონ ამ დასტის ფუნქციების მეხსიერებაში.
და მხოლოდ ერთხელ ფუნქცია დააბრუნებს გაქვთ დაიწყოს მიღების, რომ მეხსიერების უკან.
ასე რომ ერთი მარტივი გზა ამოიწურა მეხსიერება კომპიუტერული პროგრამა
არის დაწერა ფუნქციებს, რომ არასდროს დაბრუნდება.
ასე მაგალითად, მოდით დემონსტრირება იმდენი ერთად შეგნებულად buggy პროგრამა.
ნება მომეცით წავიდეთ წინ და ნუ # მოიცავს ,
int ძირითადი (void),
და მე ვაპირებ ამის გაკეთებას, ხოლო (2> 1), რაც ალბათ არ ოდესმე შეცვლის ჩვენზე,
და ნება მომეცით წავიდეთ წინ არის და არ printf.
სინამდვილეში, რომ იქნება ნაკლებ ვიზუალურად საინტერესო. მოდით ეს.
იყიდება int i = 0; i> 0 - გადავდგათ ეს შეცდომა - i + +.
და მოდით არ printf აქ. მოდით პრაქტიკაში რა იყო ქადაგებდა.
მოდით მეთოდი აქ, ბათილად გუნდისა, და ჩვენ ვიტყვით, int i,
და შემდეგ მე ვაპირებ ვთქვა printf - არა, მოდით ამ უფრო საინტერესო.
მოდით რეალურად არ ბეჭდვა არაფერი ყოფილა. მოდით უბრალოდ ეს: გუნდისათვის (I).
ყველა უფლება. ასე რომ, ეს buggy რადგან რატომ?
მე მიღების ეს ყველაფერი, როგორც მე, რადგან პროგრამა ფაქტობრივად არ არაფერი საინტერესო.
>> მაგრამ ეს არ არის მიზანი.
მიზანია დაწერონ პროგრამა, რომლის მთავარი ფუნქცია აკეთებს იმას, სავარაუდოდ?
ზარის თავად. და ფაქტობრივად, ჩვენ არ გვჭირდება loop.
მოდით კიდევ გამარტივება ამ უბრალოდ ისე, რომ არ დაკარგოს დანახვაზე მართლაც ფუნდამენტური შეცდომა.
მთავარი მოუწოდებს გუნდი მაინც მღერიან რამდენიმე გუნდი,
მაშინ მე იმედი და მქონდა გუნდი ზარის გუნდი
იმიტომ, რომ მე აიღო ვინმე აპირებს განახორციელოს ეს ალბათ,
და ახლა ამ არ აპირებს კომპილაციის ამჟამად. მე უნდა რა?
მჭირდება პროტოტიპი, მახსოვს.
ასე რომ უნდა აქ ბათილად გუნდი (int i);
ახლა თუ ქვევით აქ - ფაქტობრივად, მოდით გამოიყენოთ უფრო დიდი ფანჯარა.
მოდით წავიდეთ წინ და მიიღოს გუნდისათვის.
გამოყენება გამოუცხადებელ იდენტიფიკატორი მე.
ოჰ, რომ იყო სულელური. ჩვენ არ გვჭირდება არგუმენტი. მოდით უბრალოდ ეს.
ვუსურვებ ჩვენ დავიწყეთ ამ გზით. ეს იქნებოდა ბევრად უფრო ადვილი პროგრამა დაწერა.
არსებობს. ახლა მოდით წავიდეთ მეტი ჩემს ტერმინალის ფანჯარა, გამეორება Clang, და აქ ჩვენ მივდივართ.
ეს იყო მართლაც სწრაფი.
რაც სინამდვილეში მხოლოდ მოხდა, თუმცა?
ისე, ახლა მე დაამატოთ ბეჭდვის ხაზი ასე ვხედავთ.
ნება მომეცით აღვნიშნო printf ("მე აქ") - არ ცვლადები. ჩვენ დავტოვებთ მას მოსწონს, რომ.
ნება მომეცით გამეორება მიიღოს. ნება მომეცით გამეორება გუნდისათვის.
და ... მოდის. შეინახეთ აპირებს.
როგორც განზე, რატომ მას არ შეეჯახა ჯერ არ გაქვთ?
სეგმენტაცია ბრალია მოხდა სუპერ სწრაფი ადრე.
[Inaudible სტუდენტი საპასუხოდ] >> ზუსტად. ასე რომ დრო სჭირდება ბეჭდვა, არა?
ეს უბრალოდ იღებს მეტი მუშაობა კომპიუტერის ნაწილი.
და იქ ეს: სეგმენტაცია ბრალია.
>> ასე რომ შეამჩნევს, თუ რამდენად სწრაფად პროგრამების გასაშვებად.
თუ თქვენ არ დაბეჭდვის არაფერი, სუპერ სწრაფი.
მაგრამ ჩვენ მაინც მოხდა ეს სეგმენტაცია ბრალია, რადგან, თუ რა ხდებოდა?
თუ ფიქრობთ იმაზე, თუ როგორ თქვენი კომპიუტერის მეხსიერების ასახული,
ეს მოხდება, რომ იყოს მთავარი, მაგრამ აქ მოდით უბრალოდ დაარქვით გუნდისა, და მოდით მოვუწოდებთ ამ გუნდისათვის.
და ახლა, თუ ჩემი ესთეტიკის უფლება, ეს მხოლოდ თქმას გუნდი, გუნდი, გუნდი,
გუნდი, გუნდი, გუნდი, გუნდი, რეკლამა nauseum და საბოლოოდ, რა მოხდება?
თუ დიდი სურათი, სიტყვასიტყვით, ეს, რა რაღაც კონცეპტუალურად?
დასტის overruns ბევრი.
ან, უფრო უარესი, უბრალოდ overrun ყველაფერი, მათ შორის ტექსტი სეგმენტი,
რაც 0S და 1s რომ წარმოაჩენს თქვენს პროგრამას.
მოკლედ, ეს მხოლოდ სუპერ, სუპერ ცუდი.
შენი პროგრამა spiraled კონტროლიდან.
თქვენ იყენებთ გზა მეტი მეხსიერების ვიდრე თქვენ აპირებდით
ყველა გამო სულელური შეცდომა ამ შემთხვევაში,
ან ამ შემთხვევაში სრულიად შეგნებულად კეთდება ფუნქცია მოუწოდებდა თავად.
ახლა, ეს არ არის ყველა ცუდი.
ფუნქციები მოუწოდებდა თავად რეალურად აქვს დიდი ძალა, როდესაც თქვენ გამოიყენოს იგი სწორად.
მე არ გამოიყენება მას სწორად აქ.
ასე რომ, ეს არ არის ყველა ცუდია, მაგრამ ფაქტია, რომ მე არასოდეს რეალურად შეწყვიტოს მოუწოდებენ თავს
არის ფუნდამენტური სისუსტე აქ ამ პროგრამას.
ისე სად მივდივართ ყველა ამ? რა ხდება რეალურად?
როდესაც მოვუწოდებ ნამატი ფუნქცია, როგორიცაა ვაკეთებდით იმ მაგალითები,
მაქვს ღირებულება, როგორიცაა 1 რომ მე გაივლის სისტემაში
მე კორიდორი ასლი ნომერი 1, ასე შემდეგ მოხდება.
მოდით წასვლას ნამატი მაგალითად, ამ ბიჭს უფლება მეტი აქ.
აქ რა ხდება რეალურად.
როდესაც მოვუწოდებ ნამატი და მე კორიდორი x, pictorially, რა ხდება აქ არის ამ.
>> თუ მაქვს ღირებულება 1 ინახება აქ და მე სინამდვილეში წუთობრივი,
რომელიც ახლა მოუწოდა ქორო - iPad არის სროლა ჩემთვის off აქ.
მოდით მოვუწოდებთ ამ წუთობრივი, და ჩვენ არ ვიცით, რა ამ შემდეგი ფუნქცია იქნება.
ასე რომ, რა ხდება რეალურად არის აქ სადღაც მთავარ მაქვს ბლოკი მეხსიერება
რომელიც შენახვის ნომერი 1.
როდესაც მოვუწოდებ წუთობრივი, მე გამოყენებით მეორე ბლოკი მეხსიერება,
მაგრამ ახლა მაქვს ასლი 1.
როდესაც მე ნამატი, რომ ღირებულება, ეს ხდება 2,
მაგრამ შემდეგ რა მოხდება, როგორც კი წუთობრივი ანაზღაურება?
ეს მეხსიერების უბრალოდ იღებს გადასცა თავში ოპერაციული სისტემა,
რაც იმას ნიშნავს, რომ ყველაფერი რაც თქვენ გავაკეთეთ არაფერია სასარგებლო.
1 რომ თავდაპირველად შეიცავს ძირითად კვლავ რეალურად არსებობს.
ისე სად მივდივართ ამ?
თურმე ხსოვნისადმი გაქვთ ამ back-to-back თანმიმდევრობა bytes
შეგიძლიათ განათავსოთ პერსონალის, და აღმოჩნდება, რომ ჩვენ უკვე დავინახეთ რაღაც
რომელიც მოიცავს აყენებს რამ თავში დაბრუნება თავში დაბრუნება.
რა არის სიმებიანი ეფუძნება კვირაში 1 და ახლა კვირაში 2?
უბრალოდ კოლექცია სიმბოლო.
გამოდის, ისევე როგორც თქვენ შეგიძლიათ განათავსოთ ნომრები მეხსიერება,
ანალოგიურად შეგიძლიათ დააყენა გმირები მეხსიერებაში.
და კიდევ ჩვენ ვიწყებთ აყენებს სიმბოლოების მეხსიერების თავში დაბრუნება თავში დაბრუნება,
აღმოჩნდება, რომ გამოყენებით მარტივი რამ, როგორიცაა ამისთვის მარყუჟი ან ხოლო მარყუჟის,
ჩვენ შეგვიძლია iterate მარცხნიდან მარჯვნივ მეტი სიმბოლოების სიმებიანი
და დაიწყოს massaging მათთვის სხვადასხვა სიმბოლოების საერთოდ -
შესაძლოა გახდეს ბ, ბ გახდებოდა გ -
ასე რომ, საბოლოო ჯამში, შეიძლება ავიღოთ English სასჯელს, რომ რეალურად აზრი
და დააკონვერტიროთ თითოეული იმ წერილების ერთ დროს
გავლით ჩვენი კომპიუტერის მეხსიერების მარცხნიდან რეალურად დაშიფვრა.
მოდით ჩვენი ხუთი წუთის შესვენების აქ,
და როცა ჩვენ დავბრუნდებით, დავიწყებთ ამ პროცესს scrambling ინფორმაციას.
>> ყველა უფლება.
სანამ ჩვენ ჩაყვინთვის შევიდა გარკვეული შიფრის და ეს ყველაფერი მოუწოდა მასივები,
ნება მომეცით პაუზის ნებისმიერი კითხვები, რადგან მე თავს ნამდვილად სახის muddled
ზოგიერთი ასეთი თემები. მოდით დაფიქსირება ახლა შევძლებთ თუ არა.
ჩვენ უბრალოდ ისაუბრა დაბრუნების ღირებულებები, ჩვენ ვისაუბრეთ არგუმენტები,
და ჩვენ ვისაუბრეთ ამ ცნება, რომელიც ჩვენ დავბრუნდებით ამ კვირის მოსვლა,
საქართველოს ათვალიერებენ მეხსიერების როგორც მთელი bunch ამ stacked ქაღალდის, ასე ვთქვათ,
საგებიდან on up, ასეთი, რომ ყოველი უჯრა რომ იღებს ჩაიცვი დასტის
წარმოადგენს ფუნქციას, რომელიც ამჟამად მიმდინარეობს მოუწოდა.
ნებისმიერი კითხვები?
ნება მომეცით შეკითხვა დაესვა აქ.
ნება მომეცით გაამარტივებს ამ თავში, რაც იყო ადრე ჩვენი ზოგიერთი ადრე Q & A.
ის ფაქტი, რომ ნამატი აქვს ღია ფრჩხილებში, int ნომერი, დახურული ფრჩხილებში -
რას int ხმების წარმოადგენს?
[სტუდენტი] არგუმენტი. >> არგუმენტი. Okay. მაგრამ რა არის არგუმენტი?
[Inaudible სტუდენტი საპასუხოდ] >> რა არის რომ? >> [სტუდენტი] რაღაც, რომ თქვენ გაივლის სისტემაში
Okay, ასე რომ რაღაც თქვენ გაივლით სისტემაში და ზოგადად, უბრალოდ დასტური.
თუ წერდნენ ფუნქცია და რომ ფუნქცია მიზანი ცხოვრებაში
არის რაღაც პატარა სხვადასხვა ყველა დროის გამოყენება,
მაშინ ერთადერთი გზა, რომ მოხდეს მართლაც რომ ჩანს, უზრუნველყოს იგი შეყვანის
ასე რომ შეგიძლიათ გააკეთოთ რაიმე განსხვავებული, რომ შეყვანის ყოველ ჯერზე.
>> ასე, რომ თქვენ უნდა მიუთითოთ ორი რამ როდესაც ფუნქცია იღებს შეყვანის.
თქვენ უნდა მიუთითოთ სახელი, რომ თქვენ მინდა რომ შეყვანის
წმინდა საკუთარი მოხერხებულობის ასე რომ თქვენ შეგიძლიათ უწოდებს
წელს ფუნქცია, რომ თქვენ თავის წერს, როგორც მე აქ ხაზი 32.
მაგრამ თქვენ უნდა მიუთითოთ მისი ტიპის რადგან C არის პროგრამირების ენა
რომ მხოლოდ მოითხოვს, რომ თუ გინდათ ცვლადი, თქვენ უნდა ვუთხრა კომპიუტერის რა მონაცემები ტიპის ეს,
დიდი ნაწილი ისე, რომ იცის რამდენი ბიტი გამოყოფას რომ ცვლადი
იმიტომ, რომ ეს შეიძლება იყოს 6 - უკაცრავად, ეს არ იქნება 6.
ეს შეიძლება იყოს 16, ეს შეიძლება იყოს 8, ეს შეიძლება იყოს 32, თუნდაც 64,
მაგრამ კომპიუტერში უნდა გაიგოს.
ახლა, int წლის მარცხენა მხარეს წარმოადგენს რა, პირიქით?
[Inaudible სტუდენტი საპასუხოდ] >> რა არის რომ? >> [სტუდენტი] გაცნობის ფუნქცია.
გაცნობის ფუნქცია და, უფრო კონკრეტულად კი, გაცნობის მისი გამომუშავება. მარჯვენა.
ასე რომ, მაშინ როდესაც რამ ფრჩხილებში წარმოადგენს მისი შეყვანის, ასეთის არსებობის შემთხვევაში,
რამ მარცხენა წარმოადგენს მისი გამომუშავება.
და ამ შემთხვევაში, ნამატი სავარაუდოდ ბრუნდება int,
და ასე int არის დაბრუნების ტიპის ამ ფუნქციის.
რას ნიშნავს დაბრუნებას?
სიტყვასიტყვით, თქვენ იყენებთ სიტყვით დაბრუნების და მერე თუ რას დაბრუნების
მარჯვნივ სიტყვით არის მთელი რიცხვი,
მაშინ ეს მართლაც შეესაბამება იმას, რასაც ჩვენ დავპირდით.
თქვენ ვერ რაღაც მსგავსი - hello, world - რადგან ეს სიმებიანი.
>> ცხადია, ეს არ არის მთელი რიცხვი.
ასე მოკლედ, ტვირთი მართლაც ჩვენზე, პროგრამისტი, უნდა იყოს კონკრეტული
რაც ჩვენ დაბრუნების და შემდეგ ფაქტიურად წასვლა დაბრუნებაზე იგი.
კონტექსტში აქ არის ის არის, რომ თქვენი კომპიუტერის მეხსიერების Gigabyte, 2 გბ -
რასაც - იქნებ უფრო მეტიც, შეიძლება უფრო ნაკლებად,
მაგრამ კომპიუტერი ამას განიხილავს არა როგორც განსხვავებული სექციები.
რაღაც მიდის down იქ, რაღაც მიდის up there,
სხვადასხვა პერსონალის მიდის შუა, და დღეს ჩვენ უბრალოდ დაიწყოს ვეუბნებოდი ამბავი,
მაგრამ ჩვენ დავბრუნდებით ამ დროთა განმავლობაში.
ახლა მხოლოდ ნაჭერი მეხსიერების ჩვენ ნამდვილად აინტერესებს არის ტექსტი სეგმენტი
იმიტომ, რომ მხოლოდ წარმოადგენს 0S და 1s რომ Clang აქვს outputted.
ასე რომ, როდესაც თქვენ აწარმოებს ბრძანებას კლავიატურის მოსწონს a.out
ან თქვენ ორმაგად დაწკაპეთ ხატი on Mac OS ან Windows,
თქვენი პროგრამა დატვირთულია საწყისი თქვენს ხისტ დისკზე შევიდა RAM
და ეს plopped ზედა თქვენი კომპიუტერის RAM, ასე ვთქვათ.
იმავდროულად, როგორც თქვენი პროგრამა იწყება გაშვებული და ძირითადი იღებს მოუწოდა
პროგრამაში თქვენ წერდა ან პროგრამა Microsoft ან Apple წერდა,
მისი ნებისმიერი ადგილობრივი ცვლადები დასრულდება მდე დაეცა იქ ბოლოში თქვენი კომპიუტერის მეხსიერებაში.
მაგრამ თუ ძირითადი მოუწოდებს სხვა ფუნქცია, რომელიც თვითონ აქვს ცვლადები ან არგუმენტებზე, ისინი დასრულდება up ზემოთ.
და თუ ეს ფუნქცია მოუწოდებს რაღაც, ისინი დასრულდება up ზემოთ ეს, უპირველეს იგი, ზემოთ ის.
>> და მხოლოდ ერთხელ ფუნქციის კეთდება შესრულებაში ამჯამად Stack of ქაღალდის, ასე ვთქვათ,
დაიწყოს მიიღოს ქვედა და ქვედა.
და ეს არის ის, რაც შემდეგ, მოკლედ, განმარტავს, თუ რატომ როცა რეკავთ კუბი
ან რეკავთ წუთობრივი, თქვენ გადადის ასლი ღირებულება.
და რა ეს იმას ნიშნავს pictorially არის, რომ თქვენ ფაქტიურად წერა ნომერი 1
სხვა ნაწილში მეხსიერება, იცვლება, რომ 1 დან 2 შემთხვევაში, რომლის წუთობრივი
ან 8 წელს შემთხვევაში კუბი და შემდეგ სროლა რომ მეხსიერების მოშორებით
როგორც კი ნამატი ან კუბი ფუნქცია დააბრუნებს. შეკითხვა.
[სტუდენტი] სად არიან გლობალური ცვლადები ინახება?
გლობალური ცვლადები ინახება რა გაკეთებული მოუწოდა ინიციალიზაცია მონაცემები ან uninitialized მონაცემები,
განსხვავებით, თუ თქვენ გაქვთ გლობალური ცვლადი და მივანიჭოთ მას მაშინვე ღირებულება
ერთად ტოლობის ნიშანი, იგი მთავრდება ზედა იქ,
და თუ უბრალოდ, ვამბობთ int x; რომელზეც არ ღირებულება, იგი მთავრდება ოდნავ დაბალია RAM
უბრალოდ კონვენციას.
გაქვთ სხვა კითხვები? ყველა უფლება.
ასე რომ ამ სურათს დავბრუნდებით, როგორც ჩვენ უფრო ძლიერი
რა შეგვიძლია გავაკეთოთ ერთად კომპიუტერში,
მაგრამ ახლა, მოდით აქვს მოკლე intro to კრიპტოგრაფიის,
კონკრეტული ტიპის კრიპტოგრაფიის რომ არ გადაჭრის ყველა მსოფლიოს პრობლემების
მაგრამ ამჯამად გადაჭრის ზოგიერთი მათგანი.
ამ შემთხვევაში აქ, ჩვენ გვაქვს რაღაც მოუწოდა საიდუმლო-გასაღები კრიპტოგრაფიის.
საიდუმლო-გასაღები კრიპტოგრაფიის, როგორც სახელი ვარაუდობს, გამომდინარეობს მისი უსაფრთხოების საწყისი საიდუმლო.
>> მაგალითად, თუ თქვენ უკან Grade სკოლა და თქვენ გადიოდნენ პატარა საიდუმლო სიყვარულის წერილი
to ბიჭი ან გოგონა თქვენ გამანადგურებელი შესახებ, თუ სურდა, რომ გაივლის შენიშვნა მეშვეობით აუდიტორია
თქვენ ალბათ არ წერენ ასეთი შენიშვნა ინგლისურ ან რასაც თქვენს მშობლიურ ენას წარმოადგენს.
უფრო მეტიც, თქვენ შეიძლება გაშიფრავს თუ თქვენ შეიძლება მხოლოდ გააგზავნოთ ტექსტური შეტყობინება ამ დღეებში.
მაგრამ თქვენ შეიძლება რეალურად გაივლის მათ შენიშვნა მთელი კლასის.
და ამის გაკეთება უსაფრთხოდ ისე, რომ თქვენი მეგობრები და მასწავლებელი
არ ვიცი რა თქვენ წერის, თქვენ შეიძლება ამუშავება სამართლიანად მარტივი ალგორითმი,
ახალგაზრდა იმისა, რომ თქვენ შეიძლება იყოს, უბრალოდ scramble სიტყვა.
ასე რომ ნაცვლად წერა შეიძლება დაწეროს ბ,
ნაცვლად B შეიძლება დაწეროს გ,
ნაცვლად გ თქვენ შეიძლება დაწეროს დ და სხვ.
ან თქვენ ვერ ამუშავება უფრო დახვეწილი თარგმანი
წერილების სხვადასხვა წერილებს.
მაგრამ დაჭერა არის ბიჭი ან გოგო, რომელსაც თქვენ გაგზავნის ამ შენიშვნა
უნდა გაიგოს რაღაც, რაც, ბუნებრივია? >> [სტუდენტი] თუ რას აგზავნის.
რა საიდუმლო არის, მსგავსი იმისა, რაც არის, რომ რუკების შორის და B და C-ს და d's.
არის თუ არა მხოლოდ დასძინა 1 თითოეულ წერილებს გადასვლა, რათა ბ, ბ გ?
იქნებ უფრო კომპლექსური, ვიდრე რომ?
>> ასე, რომ თქვენ და თქვენი Crush უნდა ამ საიდუმლო ინფორმაციას,
მაგრამ სახის catch-22 აქ.
თუ ეს ძალიან პირველად თქვენ გაგზავნის ეს სიყვარული წერილი მეშვეობით კლასის,
როგორ არის, რომ ბიჭი ან გოგო აპირებს ვიცით რა საიდუმლო კი არის?
ასე რომ საიდუმლო-გასაღები Crypto არ გადაჭრის ყველა მსოფლიოს პრობლემები,
და არსებობს რეალურად ურთიერთობისათვის აქ რომ ჩვენ დაბრუნდება მიმართ სემესტრის ბოლოს.
ანალოგიურად არა უმეტეს us არ ვიცი ვინმეს რომ მუშაობს, მაგალითად, დილის Amazon.com,
და ჯერ ბევრი ჩვენგანი ალბათ იყიდა პერსონალის at Amazon.com,
და ჩვენ ისწავლება უნდა ვივარაუდოთ, რომ ამ ელექტრონული კომერციის ოპერაციების უსაფრთხო.
URL ალბათ ამბობს https, არსებობს იქნებ სულელური პატარა ბოქლომს ხატი სადღაც,
არსებობს გარკვეული სახის კრიპტოგრაფიის უზრუნველყოფის თქვენი საკრედიტო ბარათის ინფორმაცია
თქვენს შორის და Amazon.com.
და მაინც, თუ კრიპტოგრაფიის მოიცავს იცოდა ზოგიერთი საიდუმლო
და ჯერ არ ვიცი, ვინმეს დროს Amazon და მე ნამდვილად არ მოწყობილი რაიმე სახის საიდუმლო
ვინმესთან დროს Amazon, როგორ არის ჩემი კომპიუტერი ან ჩემი ბრაუზერი ამით?
თურმე არსებობს სხვა სახის კრიპტოგრაფიის საერთოდ რომ ამ პრობლემის გადაწყვეტა.
მაგრამ დღეს, ჩვენ ფოკუსირება მარტივი ერთი
სადაც შეგიძლიათ მოწყობა წინასწარ იცოდეს ზოგიერთი საიდუმლო
მოსწონს +1 ან რუკების შორის და B-ს.
და პროცესი კრიპტოგრაფიის ზოგადად მოიცავს ამ.
თქვენ გაქვთ ზოგიერთი ძირითადი ტექსტი, გამოსახული აქ მარცხენა
თქვენ გაუშვით მეშვეობით გარკვეული ალგორითმის ან პროცედურა encrypting იგი -
იქნებ ეს მხოლოდ ხდება ბ, ბ ხდება C -
და მაშინ დასრულდება up ერთად ciphertext.
იმავდროულად, ერთხელ თქვენი Crush იღებს ამ საიდუმლო შენიშვნა,
მას უნდა შემდეგ გაშიფვრა იგი ზოგადად უკუქცევის რომ ალგორითმი
რათა მიიღოთ უკან ძირითადი ტექსტი.
არსებობს ფიზიკური incarnations ამ.
>> მაგალითად, ეს პატარა საიდუმლო დეკოდერი ბეჭედი,
და ეს არის ბეჭედი იმ გაგებით, რომ არსებობს ორი აკრიფეთ აქ.
On გარეთ პერიფერია ამ რამ, არსებობს წერილების მეშვეობით Z,
თუმცა ისინი შემთხვევითი იმისათვის,
და ქვეყნის შიგნით, იქ რეალურად ზოგიერთი ნომრები
ისეთი, რომ ამ რგოლის შეგიძლიათ სახის ჩართოთ გარეთ მაგრამ არა შიგნით
რათა გამოდიან ნომრები წერილებს.
მდებარეობა ფილმის მოუწოდა საშობაო ამბავი, დაინახავთ, რომ პატარა Ralphie
იმდენად მოწადინებული გაერკვნენ, რა პატარა ობოლი Annie საიდუმლო გაგზავნა იყო მისთვის
რომ იყო communicated, ვფიქრობ, სახით რიცხვითი შეტყობინებების მარცვლეულის ყუთი
და გქონდათ დაგროვების ყველა პატარა ბარათები, რომ მოვიდა მარცვლეულის ყუთი,
თქვენ იძულებული გახდა გვერდის მათ, გქონდათ დასაბრუნებლად საიდუმლო დეკოდერი ბეჭედი
ასე რომ თქვენ შეგიძლიათ საბოლოოდ გაერკვნენ, რა არის რუკების შორის ასოები და რიცხვები
ან ასოები და წერილები.
როგორ წელს კომპიუტერულ შეგვიძლია წავიდეთ შესახებ განხორციელების ან წარმოადგენს რამ ასე?
ჩვენ გვჭირდება გზა გამოხატავს საკუთარ თავს ცოტა მეტი მოქნილად
ვიდრე ჩვენი ცვლადები ჯერჯერობით არ დაუშვეს.
ჩვენ გვქონდა ints, ჩვენ გვქონდა სიმბოლო, ჩვენ გვქონდა მოძრავი და ორადგილიანი და რამდენიმე სხვები,
მაგრამ იმ ინდივიდუალური ცალი მეხსიერების რომ ნამდვილად არ გვაძლევს გამოვხატოთ რამ
მოსწონს სიტყვა და სასჯელი და ფრაზები.
მართლაც, ჩვენ მოუწოდა ასეთი რამ სიმები,
მაგრამ გპირდებით, რომ ეს მართლაც მხოლოდ გამარტივების წელს CS50 ბიბლიოთეკა
რომ ჩვენ აპირებს კანი უკან.
და მოდით ახლა გადავიდეთ გავაკეთოთ, რომ აქ.
ნება მომეცით წავიდეთ წინ და გახსენით ფაილი -
ყველა ამ ფაილებზე ხელმისაწვდომია, როგორც ყოველთვის, ონლაინ - წოდებული array.c
გადაჭრის პრობლემას უკავშირდება სტრიქონები მაგრამ რომ ხატავს სურათს აქ
თუ როგორ შეიძლება გამოვიყენოთ რაღაც მოუწოდა მასივი.
>> Array არის მონაცემები ტიპის.
ეს გაცნობის ცვლადი of ჯიშები რომ მრავლობითი პატარა მონაცემთა ტიპები შიგნით ეს
თავში დაბრუნება თავში დაბრუნება.
ასე მაგალითად, თუ გვინდოდა წერენ პატარა პროგრამა, რომელიც გაძლევთ თქვენს ვიქტორინა საშუალო
ამისთვის, რა თქმა უნდა, როგორიცაა 50, რომელსაც აქვს 2 ვიქტორინებში,
თქვენ შეიძლება ძალიან ადვილად წერენ ამ პროგრამის საფუძველზე კი ზოგიერთ გასულ კვირას მასალა
გამოყენებით GetInt და რამოდენიმე ცვლადის: int quiz1, int quiz2.
და ეს საკმაოდ მარტივია.
ეს ალბათ 10, 20 ხაზების კოდი max განახორციელოს პროგრამა
რომ სთხოვს მომხმარებლის 2 Quiz ქულით და შემდეგ computes მათი საშუალო
დამატებით მათ ერთად, გამყოფი მიერ 2, ხოლო შემდეგ ბეჭდვის შედეგები.
ჩვენ შეგვეძლო ალბათ, რომ საკმაოდ ადვილად არის გარკვეული რაოდენობის წუთი.
მაგრამ პრობლემა ისაა, რომ ვივარაუდოთ, რომ 50 ჰქონდა 3 ტესტებში ან 4.
დავუშვათ, რომ თქვენ სურდა გამოიყენოთ იგივე პროგრამის კლასი, რომელიც ჰქონდა ყოველკვირეული ვიქტორინებში.
იფიქრეთ კლასის, რომელიც ყოველკვირეული ტესტებში.
თუ არსებობს 16 ან იმდენად კვირით სემესტრში, ახლა თქვენ გაქვთ 16 ცვლადები:
int quiz1, int quiz2, int quiz3, int quiz4.
როგორც კი დაიწყება ვხედავთ ამ redundancy, ამ გადაწერა და pasting კოდის,
ეს უნდა დაიწყოს, რათა გსურთ იყო უკეთესი გზა.
და საბედნიეროდ, რადგან მასივები არსებობს. ასე რომ მოდით ეს.
პირველი, მინდა წარმოგიდგინოთ ძალიან მარტივი რამ, რომ ჩვენ არ გამოიყენება ჯერჯერობით
მაგრამ დაინახავთ მას ზოგჯერ კოდის.
>> ეს არის რა ზოგადად მოუწოდა მუდმივი.
ასე რომ მუდმივი იმ გაგებით, რომ ამ მნიშვნელობის არასოდეს ცვლის.
ადამიანის კონვენციის როდესაც შექმნა მუდმივი
ის, რომ მთელი ასოებით მხოლოდ ისე, რომ იგი ნამდვილად გამოირჩევა თქვენს კოდი,
და სპეციალური სიტყვით რომ სარგებლობთ C არის # განსაზღვრავს.
ამიტომ ვამბობთ # განსაზღვრავს, მაშინ სივრცე, მაშინ სიტყვა, რომელიც გსურთ გამოიყენოთ მუდმივი სახელი
და მაშინ ღირებულების მუდმივი.
გაითვალისწინეთ ეს განსხვავდება მინიჭების რაიმე ცვლადი.
იქ არ არის ტოლობის ნიშანი, არ მძიმით.
ეს არის რა საყოველთაოდ ცნობილია, როგორც preprocessor დირექტივა,
მაგრამ უფრო, რომ სხვა დროს.
ახლა ამ ქმნის unchanging ღირებულება მოუწოდა ტესტები
რომლის ფაქტობრივი რიცხვითი მნიშვნელობა არის 2.
ასე რომ სადმე ხედავთ ტესტები, ტესტები, ტესტები მთელ ამ ფაილის,
ეს მხოლოდ ნომერი 2.
თუ გავითვალისწინებთ მთავარ ახლა, ვნახოთ, თუ როგორ ეს სამუშაოები.
პირველი ეს გამოიყურება პატარა cryptic, მაგრამ ყველა პერსონალის საწყისი კვირაში 1.
დასვით მომხმარებლის for კლასის. როგორ გავაკეთოთ ეს?
შეესაბამება 22 - ეს მართლაც წვნიანი ნაწილი - ვაცხადებ float
მაგრამ არა მხოლოდ ერთი float. მე გამოცხადების, არამედ მასივი მცურავი პუნქტიანი ღირებულებებს.
რომ ცვლადი აპირებს ეწოდოს კლასის, როგორც გულისხმობდა აქ,
მაგრამ მხოლოდ ნაჭერი ახალი სინტაქსის მაშინ ეს კვადრატულ ფრჩხილებში.
ის ფაქტი, რომ მე განაცხადა float კლასების და შემდეგ ღია bracket და შემდეგ ნომერი -
შეამჩნია თუ ეს მუდმივი ეს მხოლოდ ისე, როგორც ეს -
ეს იმას ნიშნავს, "Hey კომპიუტერი, მომეცი 2 მოძრავი და მოდით ერთობლივად მოვუწოდებთ მათ კლასის."
>> ეს არის განსხვავებით ბევრად უფრო რუტინული პროცესი ასე: float grade1;
ათწილადი grade2 და სხვ.
ამიტომ მასივი საშუალებას გვაძლევს განვახორციელოთ ეს იდეა, მაგრამ უფრო ნაკლებად messily,
ისე, რომ ჩვენ შეგვიძლია დავწეროთ 1 ხაზი კოდი ნაცვლად, ვთქვათ, 16 16 კვირიანი სემესტრის.
მე არ მინდა, რომ მყარი კოდი 2 რადგან თუ ფიქრობთ ეს ახლა ლოგიკურად,
ვარაუდობენ, მომავალ წელს CS50 ცვლილებების 3 ტესტებში ნაცვლად
და მქონდა ნომერი 2 აქ, მქონდა ნომერი 2 აქ,
მქონდა ნომერი 2 აქ, ნომერი 2 აქ.
ეს ხდება ძალიან რუტინული და ძალიან ადვილი Screw up
და შემთხვევით შეცვალოს 1 ღირებულების 3 და ელოდებიან რაიმე სხვა ღირებულება 2.
ამიტომ მე ვაპირებ ნაცვლად აბსტრაქტული ამ მოშორებით და გამოიყენოს ეს მუდმივი რომ,
როგორც მისი სახელი ვარაუდობს, არასდროს ცვლილებები.
და ახლა არ აქვს მნიშვნელობა თუ არა გვაქვს სხვადასხვა ტესტებში წელს ან მომდევნო,
მე უბრალოდ უნდა შეცვალოს იგი ერთ ადგილას აქ ზედა.
ასე რომ ყველა კონსტანტა.
ამასობაში, ახალი კონცეპტუალური ფუნქცია რომ მასივი.
ასე რომ კვადრატულ ფრჩხილებში მომეცი ამ ბევრი მოძრავი და საშუალებას ჩემთვის ერთობლივად მოვუწოდებთ მათ კლასის აქ.
ახლა ვნახოთ რა მე ვაპირებ ამის გაკეთებას.
აქ ხაზი 24 არის დასაწყისიდან ამისთვის loop.
>> ეს მართლაც არაფერი მიეცით. უბრალოდ გამოყენებით ტესტები ნაცვლად მყარი კოდირებული ნომერი.
მაგრამ არაფერი ინტელექტუალურად სხვადასხვა იქ გასულ კვირას.
ეს არის მხოლოდ printf, ასე printf ("Quiz #% d of% d:")
რადგან მინდა ამობეჭდოთ მომეცი Quiz რაოდენობის 1 2 და შემდეგ 2 2.
ასე რომ, ეს არის წმინდა წყლის ესთეტიკური რამ.
მაგრამ საინტერესო ნაწილი ახლა არის ხაზზე 27.
იმისათვის, რომ შეავსონ ერთი ორი placeholders ერთად მცურავი პუნქტიანი ღირებულება,
თქვენ კვლავ გამოიყენოთ კვადრატულ ფრჩხილებში.
ამ შემთხვევაში, მე გამოყენებით რადგან მე ამ loop დაიწყო მე equaling რა ღირებულება, სავარაუდოდ?
[სტუდენტი] 0. >> [Malan] 0.
ამიტომ პირველ iteration ამ მარყუჟის, ეს თითქოს მე დავწერე ეს კოდი,
მაგრამ მეორე iteration ამ მარყუჟის, ეს თითქოს მე დავწერე ეს ჩემი კოდი.
მაგრამ ის ფაქტი, რომ მე გამოყენებით ცვლადი არის სრულყოფილი, რადგან, როგორც სახელი ვარაუდობს,
ის განსხვავებული მისი ღირებულება ყოველ iteration,
ამიტომ მე შევსების ამ მასივი ერთ ადგილზე დროს.
რას მასივი გამოიყურებოდეს?
მიზეზი მე მიიპყრო სუპერ მარტივი მართკუთხედი ეკრანზე აქ ადრე იყო ამის გამო.
Array მხოლოდ ბლოკი მეხსიერება მოჰყვა კიდევ ერთი ბლოკი მეხსიერება
მოჰყვა კიდევ ერთი ბლოკი მეხსიერება და სხვ.
ასე რომ, თუ ჩემი array არის ზომა 2 ამ შემთხვევაში აქ, ყველა მე აკეთებს
აკრეფით ჩემი Quiz ქულით მინდა აქ - მე მივიღე 100 ამ ერთ და შემდეგ მე მივიღე 99 ამ ერთ -
მაშინ ეს მეხსიერების შეიძლება არც კი იყოს გამოყენებული, რადგან მე მხოლოდ სთხოვა კომპიუტერი
ამისთვის მასივი ზომა 2.
იმ მოედნებზე ჯერ კიდევ არსებობს, არა?
თქვენ ჯერ კიდევ აქვს 2 გიგაბაიტი ოპერატიული მეხსიერება შემთხვევაშიც კი, თუ თქვენ მხოლოდ ითხოვენ 2 მოძრავი.
ასე რომ იდეა უკან კოლექტორები არის, რომ კომპიუტერი მხოლოდ იღებს ბლოკი მეხსიერება
და შემდეგ გამოყოფს პატარა დარტყმები თავში დაბრუნება თავში დაბრუნება.
და ისე, რომ ყველა წყობა.
>> ეს მომიჯნავე ბლოკი მეხსიერების შიგნით, რომელიც შეგიძლიათ დააყენა რამ.
ეს მოხდება, მაშინ ნუ რამოდენიმე მოსაწყენი არითმეტიკული.
თუ მე გადახვევა ქვემოთ აქ, ეს არის სადაც მე მაშინ iterate მეტი მასივი.
მე ამუშავება summation ყველა ღირებულებების მასივი,
და შემდეგ გამოვიყენო მრგვალი ფუნქცია აქ მართლაც თანხა იყოფა ტესტები.
მაგრამ ნება მიბოძეთ ტალღის ჩემი ხელი, რომ როგორც სახის საკმარისი არითმეტიკული ახლა.
მაგრამ ყველა რომ აკეთებს ჩემთვის საბოლოოდ არის Computing საშუალო.
ამიტომ პირველ Quiz პლუს მეორე ვიქტორინა იყოფა 2 და შემდეგ ბეჭდვას ის, როგორც int.
მაგრამ მოდით ახლა გადასვლის სხვადასხვა მაგალითი უწოდა string1,
რომელიც ხატავს მსგავსი სურათს მაგრამ მისი გამოყენება სტრიქონები.
ნება მომეცით წავიდეთ წინ და გაამარტივებს ამ მხოლოდ მომენტში.
აპატიე წანაცვლება ახლა.
ცნობა, ხაზი 19 ამ მაგალითად, მივიღებ string საწყისი მომხმარებელს.
მაგრამ შეამჩნევს თუ რა მე შემდეგი აკეთებდა ხაზები 22 Onward.
მე რეალურად iterating საწყისი მე მდე - და ეს არის ახალი ხრიკი - strlen, string სიგრძე.
ეს არის ფუნქცია, რომელიც გააჩნია C, რომ თუ თქვენ გაიაროს ეს ტექსტი,
ეს გიჩვენებთ რამდენი გმირები არიან, რომ სიმებიანი. ეს იყო.
და ის ფაქტი, რომ strlen ნაცვლად სიმებიანი სიგრძე არის მხოლოდ იმიტომ, რომ ეს უფრო ლაკონური.
ოცდაათი წლის წინ, ხალხი მომეწონა დაწერა რამ როგორც succinctly, რაც შეიძლება,
ამიტომ ჩვენ ინახება, რომ კონვენციის აქ.
მე + + უბრალოდ ნიშნავს ნამატი მე თითოეულ iteration.
და ახლა შეამჩნია ეს, რომელიც მართლაც ძალიან საინტერესო.
სტრიქონში 24, მე ვიტყვი, "კომპიუტერი, მომეცი ხასიათი, 8 ბიტი, და ეძახით გ."
მაგრამ რა არის ეს მარჯვენა მხარეს ამბობდა?
ინგლისურ, რას წარმოადგენს?
[სტუდენტი] პირველი პერსონაჟი მასივი.
სწორედ. მომეცი პირველი პერსონაჟი მასივი.
ან, უფრო ზოგადად, მომეცი შ პერსონაჟი მასივი.
და გააცნობიეროს, მნიშვნელოვანია, რომ როგორც კომპიუტერი მეცნიერები,
ჩვენ რეალურად დათვლის საწყისი 0.
>> თქვენ არ შეხედულებისამებრ ახლა უნდა დაიწყოს ამით.
ახლა თქვენ უნდა მოიქცეს შესაბამისად კომპიუტერის მოლოდინი და დათვალეთ საწყისი 0
რადგან [0] იქნება პირველი პერსონაჟი სიმებიანი,
[1] იქნება მეორე, [2] იქნება მესამე და სხვ.
ასე რომ, ეს პროგრამა, თუ კომპილირება, ეს კიდევ ერთხელ string1, ასე რომ string1,
და ახლა მე აწარმოებს string1 ჩემი ტერმინალის ფანჯარაში.
ეს ელოდება შეყვანის, ისე მე ვაპირებ აკრიფოთ დავით, მიუთითოთ,
და ახლა იგი ბეჭდავს დავით ყველა სხვადასხვა ხაზების რადგან გაფრთხილების რა ვაკეთებ.
მე დაბეჭდვის ერთი ხასიათი დროს.
ჩვენ არ წასვლას დეტალურად დღეს ამ, მაგრამ მე წაიშალოს მომენტში წინ ამ გამშვები აქ.
თურმე, თუ მომხმარებელს misbehaving, შეჯიბრებითობის, ან უბრალოდ დაიბნა,
შეგიძლიათ პრაქტიკულად ვერ მისცემს სიმებიანი ზოგიერთი სიგრძე.
თუ თქვენ მოხვდა არასწორი გასაღები წლის კლავიატურის, თქვენ შეიძლება არ სიმებიანი ყველა,
ან თუ თქვენ მუქარის, თქვენ ალბათ ცდილობენ ჩასვით წელს Gigabyte-ის ღირებულების ესსე
შევსება ეს კონტექსტი და, თუ კომპიუტერში გადის out of მეხსიერება,
გამოდის, რომ ჩვენ ვაპირებთ დავუბრუნდეთ ამ მასივები მოუწოდა null.
ასე რომ, ახლა, უბრალოდ ვიცი, რომ არსებობს ამ მასივები მოუწოდა NULL
რომელიც საშუალებას მოგვცემს, რათა შეამოწმოთ, როდესაც ჩვენ მეხსიერება ღალატობს, სხვა საკითხებს შორის.
მაგრამ თუ მე გახსენით ახლა string2, შეამჩნია ერთი განსხვავება აქ.
გაითვალისწინეთ ერთი განსხვავება აქ string2.
With string2, ეს არის მარყუჟის ცოტა განსხვავებული.
>> ნება მომეცით წაშლა NULLs ასე, რომ ჩვენ შეგვიძლია საუბარი იმ სხვა დროს.
რა არის განსხვავებული შესახებ for loop ამ დროს?
შემიძლია დავუბრუნდეთ წინა მაგალითს.
ასე რომ 2 ვერსია, ეს ვერსია 1. 1, 2.
1, 2.
Strlen ზარის სადაც?
ეს პირველ ნაწილს შეეხება loop.
ნებისმიერი აზრები, თუ რატომ მე ამით? Yeah.
[სტუდენტი] ასე რომ თქვენ არ მოვუწოდებთ ფუნქცია თითოეული დრო.
[Malan] ასე რომ, ჩვენ არ მოვუწოდებთ ფუნქცია თითოეული დრო. სწორედ.
შეგახსენებთ, საწყისი ამისთვის მარყუჟების, რომ ისინი სუპერ მარტივი
ერთხელ თქვენ სახის გვესმოდეს, რომ ეს არის ინიციალიზაციისას, მდგომარეობა და განახლება.
პრობლემა ისაა, რომ მდგომარეობა ხდება ყოველ iteration of loop.
და ა.შ. ამ მაგალითში აქ, რა არის ცუდი ფაქტი, რომ ეს არის ჩემი მდგომარეობა?
[სტუდენტი] თქვენ მოუწოდებდა strlen.
[Malan] თქვენ მოუწოდებდა strlen ისევ და ისევ და ისევ.
მაგრამ ერთხელ მე აკრეფილი დავით, სიგრძით, რომ სტრიქონს 5,
და ეს არ შეიცვლება ყოველ iteration of loop
რადგან სიმებიანი კვლავ D--V-I-დ.
ასე რომ, ეს არის მინიშნება რა აპირებს გახდეს მნიშვნელოვანი იდეა
ცნობილია, როგორც დიზაინის გადაწყვეტილება, სადაც უბრალოდ არ მიიღოს კომპიუტერი ზედმეტი მუშაობა.
>> ისევე, როგორც Sneak ესკიზი pset2, pset2 in სტანდარტული გამოცემა
აპირებს დაუპირისპირდეს თქვენ რეალურად განახორციელოს გარკვეული რაოდენობის ciphers,
ზოგიერთი ხმების შიფრირების ალგორითმები, ასე რომ თქვენ შეგიძლიათ ორივე გაშიფრავს
და გაშიფვრა საიდუმლო შეტყობინებები ჰგავს ერთი Ralphie არსებობს გაშიფრული გამოჩნდება.
In Hacker გამოცემა pset2, ჩვენ ვაპირებთ წასვლა ცოტა შემდგომი.
ჩვენ ვაპირებთ გადასცემს თქვენ ფაილის ფაქტობრივი კომპიუტერულ სისტემაში
რომელიც შეიცავს მთელ bunch of სახელისა და ფაქტობრივი დაშიფრული პაროლები,
და გამოწვევა Hacker გამოცემა იქნება, რათა ბზარი იმ პაროლები
და გაერკვნენ, თუ რა კრიპტოგრაფიის ან რა საიდუმლო იყო გამოყენებული, რათა რეალურად გამოიმუშავებენ იმ პაროლები.
და ჩვენ ვაპირებთ ამ გამოყენებით ახალი ფუნქცია აქ C
რომ მე მივცემ თქვენ უბრალოდ დემო ცნობილია როგორც ბრძანება ხაზი არგუმენტები.
თურმე, როგორც ზოგიერთი თქვენთაგანი შეიძლება მინახავს ნაწილში ან სახელმძღვანელოებში,
მთავარი ყოველთვის არ უნდა იყოს ბათილად ფრჩხილებში.
თურმე მთავარი ასევე შეიძლება წერილობითი მოსწონს, ორი არგუმენტები,
argc და argv, სადაც argc არის ხმების სიტყვა
რომ თქვენ ტიპი შემდეგ პროგრამის სახელი თქვენს command line
და argv არის ფაქტობრივი სიტყვა.
და როგორც კვადრატულ ფრჩხილებში არსებობს ვივარაუდოთ, argv აშკარად მასივი.
ეს იქნება სიმებიანი შემდეგ სიმებიანი შემდეგ სიმებიანი მეხსიერებაში.
>> ასე რომ, რასაც ჩვენ ვაპირებთ გამოუვა დაწყებული pset 2 არის მსგავსი რამ.
თუ მე argv1, რომელიც მაგალითად ჩვენ დაბრუნებას ორშაბათს, და გაუშვით,
შეამჩნია, რომ არ ჩანს არაფერი გაუკეთებია.
უბრალოდ ბეჭდავს out საკუთარი სახელით.
მაგრამ თუ ვიტყვი Goodbye კლასის შეამჩნევთ, რომ ამ პროგრამის სავარაუდოდ iterates
აღემატება თითოეული სიტყვა, რომლებიც აკრეფილი ბრძანებათა ზოლზე.
და საშუალება, რომლითაც ჩვენ შესვლის უფლების მოსაპოვებლად სიტყვა, რომ მომხმარებელს უკვე აკრეფილი ბრძანებათა ზოლში
არის შეცვლით მთავარ დაწყებული ამ კვირის საწყისი int ძირითადი (void) to int ძირითადი (argc, argv)
და ამით იქნება დაბადებული ბრძანება ხაზი არგუმენტები.
და კიდევ თქვენ ნამდვილად დახვეწილი ამ, თქვენ გექნებათ დაწერა მართლაც trippy პროგრამები
როგორიცაა ამ ერთი აქ, რომელიც მაღლა იწევს და მის ფარგლებს გარეთ
ზოგიერთი ფუნქციონალური ჩვენ გავაკეთეთ დღემდე მაგრამ ყველა საკმაოდ ძლიერი.
>> ამიტომ, ჩვენ დავტოვებთ ამ ამ ეკრანზე, და ვნახავთ თქვენ ორშაბათს.
>> [CS50.TV]