[Powered by Google Translate] [ნაწილი 4] [Less კომფორტული]
[Nate Hardison] [ჰარვარდის უნივერსიტეტის]
[ეს არის CS50.] [CS50.TV]
>> ყველა უფლება, მივესალმებით თავში მონაკვეთზე.
ამ კვირის მონაკვეთზე ჩვენ ვაპირებთ რამდენიმე რამ.
ჩვენ ვაპირებთ პირველი recap პრობლემა Set 2,
რაც Caesar და Vigenère პრობლემა კომპლექტი.
და შემდეგ ჩვენ ვაპირებთ ჩაყვინთვის შევიდა Quiz 0 მიმოხილვა
და ხარჯავენ ცოტა დრო recapping რა ჩვენ ვისაუბრეთ
თითოეულ ლექციების ჯერჯერობით, და ჩვენ ასევე გავაკეთებთ რამდენიმე პრობლემები
საწყისი წინა წლის ვიქტორინებში.
ამ გზით თქვენ ბიჭები გვყავს კარგი გზა მოსამზადებლად, რომ.
>> უნდა დაიწყოს, მე გაიჭედოთ up რამდენიმე კარგი გადაწყვეტილებები
ამისთვის წინა პრობლემა კომპლექტი, პრობლემა უცნობია 2, ამ სივრცეში.
თუ ბიჭები ყველა მოხვდა ამ ბმულს
და თუ დაწკაპავთ ჩემი სახელი და დააკლიკეთ ჩემი პირველი გადასინჯვის
დაინახავთ caesar.c, სწორედ იმას, რასაც მე ეძებს.
მოდით ვისაუბროთ ამ მართლაც სწრაფად.
ეს არის მხოლოდ ნიმუში გადაწყვეტა.
ეს არ არის აუცილებლად სრულყოფილი გადაწყვეტა.
არსებობს ბევრი სხვადასხვა გზა წერენ ამ,
მაგრამ არსებობს რამდენიმე რამ, რომ მინდოდა გააშუქებს
რომ დავინახე, როგორც მე შეფასების, საერთო შეცდომები, ვფიქრობ
ამ გადაწყვეტა არ ძალიან კარგი სამუშაო გატარება.
>> პირველი არის გარკვეული სახის header კომენტარი ზედა.
On ხაზების 1 მეშვეობით 7 ხედავთ ინფორმაცია
რა ზუსტად ეს პროგრამა აკეთებს.
კარგი სტანდარტული პრაქტიკა, როდესაც თქვენ წერილობით C კოდი
მიუხედავად, თუ თქვენი პროგრამა შეიცავს ერთი ფაილი ან
თუ არა ეს განხეთქილება, რამოდენიმე ფაილი, გვქონდეს გარკვეული
orienting კომენტარი ზედა.
ეს არის ასევე მათთვის, ვისაც გარეთ და დაწეროთ კოდი რეალურ ცხოვრებაში.
ეს არის სადაც ისინი ყველაფერს დააყენა ინფორმაცია საავტორო უფლებების შესახებ.
ქვემოთ მოცემულია # მოიცავს.
On line 16 არსებობს ამ # განსაზღვრავს, რომელიც ჩვენ დაბრუნებას მხოლოდ ცოტა.
და შემდეგ კიდევ ფუნქცია იწყება, ერთხელ მთავარ იწყება,
რადგან ეს პროგრამა უკვე ყველა შეიცავს ერთი ფუნქცია
ძალიან პირველი რაც ხდება და ეს ძალიან idiomatic და ტიპიური C პროგრამის
რომ იღებს in command line არგუმენტები-ის არის, რომ იგი მაშინვე ამოწმებს
>> ამისთვის არგუმენტი რაოდენობა, argc.
მარჯვენა აქ ჩვენ ვხედავთ, რომ ეს პროგრამა ელოდება 2 არგუმენტები ზუსტად.
გახსოვდეთ არსებობს, რომ პირველი არგუმენტი რომ სპეციალური ერთი
რომ ყოველთვის პროგრამის დასახელება, რომელიც მიმდინარეობს აწარმოებს,
სახელწოდება შესრულებად ფაილს.
და მერე რა ეს იმას არის ეს ხელს უშლის მომხმარებლისთვის გაშვებული პროგრამა
მეტი ან უფრო ნაკლები არგუმენტები.
მიზეზი გვინდა შევამოწმოთ ეს დაუყოვნებლივ არის, რადგან
ჩვენ არ შეგვიძლია რეალურად გავქთ ამ argv მასივი უფლება აქ საიმედოდ
სანამ ჩვენ შეამოწმეს, თუ რამდენად დიდი ეს არის.
>> ერთი საერთო შეცდომები დავინახე იყო ხალხი დაუყოვნებლივ წავიდეს
და Grab argv [1].
მათ მინდა დაიბრუნოს გასაღები არგუმენტი გარეთ მასივი და არ უნდა მე შეამოწმოს მასზე,
შემდეგ კი მინდა გავაკეთოთ გამოცდა argc ასევე შემდეგი ტესტი,
თუ არა პირველი არგუმენტი იყო მართლაც მთელი რიცხვი, ამავე დროს,
და რომ არ მუშაობს, რადგან იმ შემთხვევაში, რომ არ არსებობს არგუმენტი
თქვენ უნდა grabbing არგუმენტი, რომ იქ არ არის ან ცდილობს დაიბრუნოს ერთი რომ იქ არ არის.
>> სხვა დიდი რამ, რომ თქვენ უნდა შეამჩნია ის არის, რომ
თქვენ ყოველთვის გვინდა ამობეჭდოთ გარკვეული სასარგებლო შეცდომა
რათა მომხმარებელს ორიენტი მათ.
დარწმუნებული ვარ, თქვენ ყველა პროგრამების გასაშვებად, სადაც უეცრად იგი დამსხვრევაზე,
და თქვენ ამ სასაცილოა პატარა დიალოგში, რომ pops up და აცხადებს,
რაღაც horribly cryptic და იქნებ გაძლევთ შეცდომის კოდი ან რამე მაგდაგვარს
რომ აზრი არა აქვს.
ეს არის სადაც ნამდვილად გსურთ მოგვაწოდოთ რაიმე გამოსადეგი
და მიზნად ისახავს მომხმარებლის ასე რომ, როდესაც ისინი გაუშვით დადიან "ოჰ," სახე პალმის.
"მე ვიცი, ზუსტად რა უნდა გააკეთოს. ვიცი როგორ დაფიქსირება ამ."
>> თუ არ ბეჭდვა გაგზავნა, მაშინ დასრულდება მდე რეალურად
წასვლის მომხმარებლის წასვლა შეამოწმოს თქვენი კოდის
გაერკვნენ, თუ რა მოხდა ისე.
არსებობს გარკვეული ჯერ რომ თქვენ გამოიყენოთ სხვადასხვა შეცდომა კოდები.
აქ ჩვენ მხოლოდ გამოიყენება ერთი ვთქვა იყო შეცდომა,
იყო შეცდომა, იყო შეცდომა.
Bigger პროგრამები, ხშირად პროგრამები, რომლებიც მოუწოდა სხვა პროგრამები,
დაბრუნდება გარკვეული სპეციალური შეცდომა კოდები სხვადასხვა სცენარების
to პროგრამულად დაუკავშირდეს, რაც თქვენ წინააღმდეგ შემთხვევაში
უბრალოდ გამოიყენოთ ლამაზი English გზავნილი.
ზემოთ.
როგორც ვმუშაობთ down, ხედავთ ჩვენ გაიყვანოს გასაღები გარეთ.
ჩვენ ვამოწმებთ თუ გასაღები ჯდება.
მივიღებთ გზავნილი მომხმარებლის.
მიზეზი ჩვენ გავაკეთებთ ამ გააკეთოს ხოლო loop-და ეს არის ის, რომ ჩვენ დაფარავს
წელს ცოტა, მაგრამ აღმოჩნდება, რომ, თუ თქვენ აკრიფოთ კონტროლის D
როდესაც თქვენ, რომ GetString სწრაფი on ტერმინალი
რა, რომ რეალურად არ არის ის აგზავნის სპეციალური ხასიათის
პროგრამის.
ეს მოუწოდა ELF ან ფაილის დასასრულს ხასიათი.
და ამ შემთხვევაში, ჩვენი გაგზავნა სიმებიანი იქნება null,
ასე რომ, ეს არ იყო რაღაც ჩვენ შემოწმდება პრობლემის მითითებული თავად.
>> მაგრამ როგორც კი, ახლა რომ დავიწყეთ ლაპარაკი პოინტერები
და დინამიური მეხსიერების გამოყოფის შესახებ ბევრი,
შემოწმების for null როდესაც თქვენ გაქვთ ფუნქცია, რომელიც შესაძლოა
დაბრუნების null როგორც ფასეულობა არის ის, რაც თქვენ გსურთ მიიღონ ჩვევა აკეთებს.
ეს არის, პირველ რიგში, აქ საილუსტრაციოდ.
მაგრამ როცა ვხედავ GetString მომავალში,
ასე საწყისი პრობლემა უცნობია 4 წლის, თქვენ გვინდა, რომ ეს გონებაში.
ისევ და ისევ, ეს არ არის საკითხი პრობლემის უცნობია 3 ან წლიდან ჩვენ არ დაფარული იგი ამჟამად.
საბოლოოდ, მივიღებთ ამ ნაწილზე, სადაც ჩვენ კიდევ მთავარ დაშიფვრის მარყუჟის,
და არსებობს რამდენიმე რამ ხდება აქ.
პირველი, ჩვენ iterate მთელ გაგზავნა სიმებიანი თავად.
აქ ჩვენ ინახება strlen ზარის პირობებში,
რომელიც ხმების თქვენ არ აღნიშნა, არ არის დიდი გზაა გასავლელი.
თურმე ამ შემთხვევაში ეს ასევე არ დიდი,
ნაწილობრივ იმიტომ, რომ ჩვენ შეცვლის შინაარსი გაგზავნა თავისთავად
შიგნით ამისთვის loop ასე რომ, თუ ჩვენ გვაქვს გაგზავნა რომ 10 სიმბოლომდე
პირველად ჩვენ ვიწყებთ რომ მარყუჟი strlen დაბრუნდება რა?
10.
>> მაგრამ თუ ჩვენ მაშინ ცვლილებები გაგზავნა, ვთქვათ ჩვენ ცვლილებები თავის მე -5 ხასიათი,
და ჩვენ ჩააგდოს წელს \ 0 ხასიათი მე -5 პოზიცია,
on მომდევნო iteration strlen (გაგზავნა) არ დაუბრუნდება რა თქმა
პირველად ჩვენ iterated,
მაგრამ ნაცვლად დაბრუნების 5 რადგან ჩვენ დაუშინეს ამ null Terminator,
და სიმებიანი მისი სიგრძე განისაზღვრება
მიერ პოზიცია, რომ \ 0.
ამ შემთხვევაში, ეს არის დიდი გზაა გასავლელი, რადგან ჩვენ შეცვლის მას ადგილი.
მაგრამ თქვენ შეამჩნევთ, რომ ეს რეალურად გასაკვირი მარტივი დაშიფვრა
თუ შეგიძლიათ მიიღოთ მათემატიკის სწორი.
ყველა რომ საჭირო არის, რათა შეამოწმოს თუ არა წერილი, რომ თქვენ ეძებს
არის ზედა ან ამას.
>> მიზეზი ჩვენ მხოლოდ უნდა შევამოწმოთ, რომ და არ გვაქვს შევამოწმოთ
არის ალფა საქმე, რადგან
თუ ხასიათი არის ზედა ან თუ ამას
მაშინ ის აუცილებლად ანბანურ ასოს,
იმიტომ, რომ ჩვენ არ გვაქვს ზედა და ამას ციფრები.
სხვა რამ გავაკეთოთ და ეს პატარა სახიფათო-
არის ჩვენ შეცვლილია სტანდარტული კეისრის კოდი ფორმულა
რომ მივეცით პრობლემის კომპლექტი სპეციფიკაცია.
რა არის განსხვავებული აქ არის ის, რომ ჩვენ ჩამოჭრილია მთლიანი თანხიდან
წელს ზედა შემთხვევაში დედაქალაქში, შემდეგ კი ჩვენ დამატებული კაპიტალი
უკან დასასრულს.
>> მე ვიცი რამდენიმე თქვენგანს გაკეთდეს ამ თქვენს კოდი.
ხომ ნებისმიერ ხაზვის თქვენს წარდგინება?
თქვენ ეს. შეგიძლიათ განმარტონ, თუ რა ეს იმას, Sahb?
By subtracting ის, იმიტომ, რომ თქვენ გააკეთა mod უფლება მას შემდეგ,
თქვენ უნდა მიიღოს იგი გარეთ, რათა გზა თქვენ [ხველების] პოზიცია.
ხოლო შემდეგ დასძინა უკან მოგვიანებით თქვენ გადაინაცვლა მეტი ერთი, რომ თქვენ სურდა.
ჰო, ზუსტად.
რა Sahb განაცხადა იყო ის, რომ როდესაც ჩვენ გვინდა დაამატოთ
ჩვენი გაგზავნა და ჩვენი გასაღები ერთად
და შემდეგ mod რომ, თავდაცვის სამინისტროს, რომ NUM_LETTERS,
თუ ჩვენ არ მასშტაბირება ჩვენი გაგზავნა შევიდა შესაბამისი 0 დან 25 Range პირველი,
მაშინ ჩვენ შეიძლება დასრულდება მდე მიღების მართლაც უცნაური ხმების
რადგან ღირებულებებს რომ ჩვენ შევხედავთ შევხედოთ გაგზავნა [i],
შევხედოთ შ ხასიათი ჩვენი ბარის ტექსტში გაგზავნა,
არის ღირებულების სადღაც ამ 65 დან 122 დიაპაზონი
ეფუძნება ASCII ღირებულებების ზედა მეშვეობით ამას z.
და ამრიგად, როდესაც თავდაცვის სამინისტროს მიერ 26 ან NUM_LETTERS,
მას შემდეგ იყო ჩვენი # განსაზღვრავს ზედა მარჯვენა აქ,
რომ აპირებს მოგვცეს ღირებულება, რომელიც არის ამ 0 დან 25 დიაპაზონი,
და ჩვენ გვჭირდება გზა მაშინ მასშტაბი რომ უკან მდე
და მიიღეთ იგი შესაბამის ASCII სპექტრი.
უმარტივეს გზას გავაკეთებთ არის მხოლოდ მასშტაბის ყველაფერი ქვევით
შევიდა 0 დან 25 ქედიდან იწყება,
და მერე გადაიტანოს ყველაფერი უკან მდე დასასრულს.
>> კიდევ ერთი საერთო შეცდომა რომ დავინახე ხალხს გადაეყარონ ის არის, რომ
თუ არ მართლაც ამ სკალირების დაუყოვნებლივ
და თქვენ დაამატოთ გაგზავნა და გასაღები ერთად და თქვენ დაამატოთ ისინი, ვთქვათ,
შევიდა char ცვლადი, პრობლემა, რომ
არის წლიდან გაგზავნა [i] ეს არის შედარებით დიდი რაოდენობის დასაწყისისთვის-
გვახსოვს ის მინიმუმ 65 თუ ზედა ხასიათი-
თუ თქვენ გაქვთ დიდი გასაღები, ვთქვათ, რაღაც 100,
და თქვენ დაამატოთ იმ 2 ერთად შევიდა ხელმოწერილი char თქვენ აპირებს მიიღოს overflow.
თქვენ აპირებს მიიღოს ღირებულება რომ აღემატება 127,
რაც ყველაზე დიდი ღირებულება, რომ char ცვლადი შეიძლება გამართავს.
ერთხელ, ამიტომ მინდა გსურთ, რომ სახის რამ იწყება.
ზოგიერთი ხალხი გარშემო, რომ საქმე, რომელსაც აკეთებს, თუ სხვაგან და ტესტირების
რომ ნახოთ, თუ ამას overflow ადრე აკეთებდა რომ,
მაგრამ ამ გზით იღებს გარშემო რომ.
და შემდეგ ამ გადაწყვეტა ჩვენ ამობეჭდილი მთელი სიმებიანი დროს ბოლომდე.
სხვა ადამიანები, ამობეჭდილი ხასიათი დროს. ორივე გასაოცარია.
ამ ეტაპზე, რა ბიჭებს რაიმე კითხვა, ნებისმიერი კომენტარი ამის შესახებ?
რამ გსურთ, რამ არ მოგწონთ?
>> მე მქონდა შეკითხვა.
იქნებ მე გამომრჩა ის დროს თქვენი განმარტება, მაგრამ რამდენად შეესაბამება ეს პროგრამა
გაფართოებული ფართების დამაკავშირებელი გასაღები სიგრძეზე ტექსტი?
ეს არის უბრალოდ კეისრის კოდი. >> ოჰ, უკაცრავად, yeah.
ჰო, ჩვენ დავინახავთ, რომ.
In კეისრის კოდი მივიღეთ გარშემო, რომ რადგან
ჩვენ მხოლოდ flipped სიმბოლო.
ჩვენ მხოლოდ გარდამავალია მათ თუ ისინი ზედა ან ამას.
თქვენ ბიჭები შეგრძნება საკმაოდ კარგი ამის შესახებ?
Feel free to copy ამ სახლს, მას,
შეადაროთ იგი რასაც თქვენ ბიჭები დაწერა.
აუცილებლად მოგერიდებათ გამოგვიგზავნოთ კითხვები ამის შესახებ ძალიან.
ისევ და ისევ, გააცნობიეროს, რომ მიზანი აქ თქვენი პრობლემა ადგენს
არ არის მისაღებად თქვენ ბიჭები დაწერა სრულყოფილი კოდი თქვენი პრობლემა კომპლექტი.
ეს სწავლის გამოცდილება. Yeah.
>> თავში do ხოლო მარყუჟის, თუ იგი შეადგენს null,
ასე null უბრალოდ არაფერს ნიშნავს, უბრალოდ დააჭიროთ?
Null არის სპეციალური მაჩვენებელი ღირებულების,
და ჩვენ ვიყენებთ null როდესაც ჩვენ მინდა ვთქვა
ჩვენ გვაქვს მაჩვენებელი ცვლადს, რომელიც მიუთითებს არაფერი.
და ა.შ. როგორც წესი, ეს ნიშნავს, რომ ამ ცვლადი, ამ გაგზავნა ცვლადი
არის ცარიელი, და აქ, რადგან ჩვენ გამოყენებით CS50 სპეციალური string ტიპის,
რა არის CS50 string ტიპის?
გინახავთ რა არის, როდესაც დავით გამოყვანილია hood ლექციების?
ეს ხმაურიანი-ის მაჩვენებელი, არა?
Okay, yeah. >> ეს char *.
და ასე ნამდვილად შეგვეძლო შეცვლის ამ
უფლება აქ char * გაგზავნა,
და ასე GetString ფუნქცია, თუ იგი არ წარმატებით მიიღოს სიმებიანი საწყისი მომხმარებელი,
მას არ შეუძლია გარჩევის სიმებიანი და ერთ შემთხვევაში, რომელშიც იგი ვერ გარჩევის სიმებიანი
არის თუ მომხმარებელი სახის ფაილის დასასრულს ხასიათი, კონტროლის D,
რომელიც არ არის რაღაც თქვენ ჩვეულებრივ აკეთებთ, მაგრამ თუ ეს მოხდება
მაშინ ფუნქცია დააბრუნებს ამ null ღირებულება, როგორც გზას ვამბობ,
"Hey, I ვერ string."
რა მოხდება, თუ არ დააყენა გაგზავნა = null,
რაც არის ის, რასაც ჩვენ არ აკეთებდა ჯერ არ გაქვთ?
რატომ უნდა იყოს, რომ პრობლემა აქ?
რადგან ვიცი, რომ ჩვენ ვისაუბრეთ ცოტა ლექციების შესახებ მეხსიერების გაჟონვის.
ჰო, მოდით, ჯერ ვნახოთ, რა მოხდება.
>> ბასილ კითხვაზე იყო, თუ რა მოხდება, თუ არ რეალურად
ამ გაგზავნა = null ტესტი?
მოდით გადახვევა მდე დაბრუნება.
თქვენ ბიჭები შეიძლება კომენტარის ამ გარეთ.
სინამდვილეში, მე შეინახეთ ის გადასინჯვის.
ეს იქნება ცვლილებათა 3.
რა თქვენ უნდა გააკეთოთ, რომ აწარმოებს ამ პროგრამის თქვენ უნდა დააჭიროთ ამ Gear ხატი აქ,
და თქვენ უნდა დაამატოთ არგუმენტი მას.
თქვენ უნდა მისცეს მას გასაღები არგუმენტი, რადგან ჩვენ გვინდა კორიდორი ბრძანების არგუმენტი.
აქ მე ვაპირებ მისთვის ხმების 3. მომწონს 3.
ახლა zooming უკან გარეთ, გაშვებული პროგრამა.
ეს გაშვებული, შედგენა, შენობა.
Here We Go. ეს ლოდინი უნდა აიძულა.
თუ მე აკრიფოთ რაღაც მიესალმები-სად, რომ წავიდეთ?
ოჰ, ჩემი პროგრამა აიღო ძალიან გრძელია გასაშვებად. მე jawing დიდი ხანია.
აქ გადის.
ახლა აკრიფოთ hello.
ჩვენ ვხედავთ, რომ ეს encrypts სათანადოდ.
ახლა რა ხდება, თუ სწრაფი GetString დაბრუნების null?
გახსოვდეთ, მე ვთქვი, რომ ჩვენ, რომ დაჭერით კონტროლის D ამავე დროს.
მე გადახვევა აქ. ჩვენ გაუშვით ერთხელ.
შენობა. არსებობს მიდის.
ახლა, როდესაც მე მოხვდა კონტროლის D
მე მივიღე ეს ხაზი, რომელიც ამბობს opt/sandbox50/bin/run.sh, სეგმენტირება ბრალია.
თქვენ ბიჭები ჩანს, რომ ადრე?
>> [სტუდენტური] რატომ არის იქ არ >> უკაცრავად?
[სტუდენტური] რატომ არის იქ არ core ნაგავსაყრელი ამ შემთხვევაში?
ძირითადი ნაგავსაყრელი არის-საკითხია, თუ რატომ არის იქ არ core ნაგავსაყრელი აქ?
კითხვაზე არის ის, რომ იქ არ უნდა იყოს, მაგრამ ეს ძირითადი ნაგავსაყრელი არის ფაილი
რომ იღებს ინახება მყარ დისკზე.
ამ შემთხვევაში ჩვენ გამორთულია ძირითადი dumps
წლის პერსპექტივაში სერვერი ისე, რომ ჩვენ არ გვაქვს ადამიანებს seg faulting
და მშენებლობაზე ტონა ძირითადი dumps.
თუმცა შესაძლოა კიდევ ერთი.
Core dumps არიან სახის რამ, რომ შეგიძლიათ ხშირად გამორთოთ,
და ზოგჯერ, რასაც აკეთებთ.
სეგმენტაცია ბრალია, რომ პასუხი გასცეს შეკითხვას, ბასილ,
ამბობს, რომ ჩვენ შევეცადეთ წვდომისათვის მაჩვენებელი
რომ არ იყო მითითებული, რომ აღვნიშნო, რომ არაფერს.
დამახსოვრება Binky in ვიდეო, როდესაც Binky ცდილობს
წასვლა შედიხართ მაჩვენებელი, არ მიუთითებს რაიმე?
ამ შემთხვევაში ვფიქრობ ტექნიკურად მაჩვენებელი არის მიუთითებს რაღაც.
ეს მიუთითებს null, რომელიც ტექნიკურად 0,
მაგრამ, რომ არ არის დადგენილი იყოს სეგმენტი, რომ არ არის ხელმისაწვდომი
თქვენი პროგრამა, ასე რომ თქვენ მიიღოთ სეგმენტაცია ბრალია
იმიტომ, რომ თქვენ არ წვდომის მეხსიერების რომ წელს ძალაში სეგმენტი
მოსწონს ბევრი სეგმენტი ან დასტის სეგმენტი ან მონაცემები სეგმენტი.
ზემოთ.
აღარ კითხვებს Caesar?
>> მოდით გადაადგილება. მოდით შევხედოთ ცვლილებათა 2 მართლაც სწრაფად.
სწორედ Vigenère.
აქ Vigenère
ჩვენ გავლა ამ ერთი საკმაოდ სწრაფად, რადგან, კიდევ ერთხელ,
Vigenère და ცეზარ საკმაოდ მსგავსი.
ჰედერის კომენტარი მანამდე,
# განსაზღვრავს მანამდე თავიდან ასაცილებლად გამოყენებით ამ ჯადოსნური ნომრები.
ლამაზი რამ არის ამბობენ გვინდოდა გადავა
სხვადასხვა ანბანი ან რამე მაგდაგვარს.
ვიდრე მქონე წასვლა ხელით შეცვალოთ ყველა 26 წელს კოდი
ჩვენ შეგვიძლია შევცვალოთ ეს 27 ან ვარდნა მისი დანგრევა
თუ ჩვენ გამოყენებით სხვადასხვა დამწერლობას, სხვადასხვა ენებზე.
ისევ და ისევ, ჩვენ მივიღეთ ამ შემოწმების არგუმენტი რაოდენობა,
და მართლაც შეგიძლიათ თითქმის მიიღოს ეს თარგი.
საკმაოდ ბევრი ყველა პროგრამა წერთ უნდა ჰქონდეს-
თუ ის ბრძანება ხაზი არგუმენტები-ზოგიერთ თანმიმდევრობა ხაზები
რომ წერია ასე დასაწყისშივე.
სწორედ ერთერთი პირველი საღი აზრის ტესტები გსურთ.
>> აქ რაც ჩვენ გააკეთა, ჩვენ მივიღეთ დარწმუნებულია, რომ
სიტყვით იყო ძალაში, და რომ იყო მეორე გამშვები რომ გავაკეთეთ.
გაითვალისწინეთ ერთხელ, რომ ჩვენ გამოყოფილი ამ საწყისი argc და 2.
გაითვალისწინეთ, რომ ამ შემთხვევაში ერთი რამ, რომ ჩვენ უნდა გაეკეთებინათ იყო ნაცვლად
გამოყენების to მე გვინდოდა, რათა შეამოწმოს მთელი ტექსტი,
და იმისათვის, რომ გავაკეთოთ, რომ თქვენ ნამდვილად უნდა წახვიდე ხასიათი ხასიათი
მეტი სიმებიანი.
იქ არ არის კარგი გზა მოვუწოდებთ რაღაც მასზე
რადგან კი, მაგალითად, რომ მე დავბრუნდები 0
თუ მას არ შეუძლია გარჩევის რიცხვი, ისე, რომ არც კი მუშაობენ.
ისევ, ლამაზი გაგზავნა ვეუბნებოდი მომხმარებლის ზუსტად რა მოხდა.
მაშინ აქ, კიდევ ერთხელ, ჩვენ ასევე ამუშავებს შემთხვევაში
მომხმარებლის ტიპების კონტროლი D შემთხვევითი ხასიათი.
>> და შემდეგ Charlotte კითხვა ჰქონდა, ადრე, თუ როგორ ჩვენ შევძლებთ გამოტოვება ფართები
ჩვენს სიმებიანი აქ.
ეს იყო ერთგვარი მსგავსია იმისა, რაც ჩვენ ერთად Myspace პროგრამა
რომ ჩვენ ნაწილში, და გზა ამ მუშაობდა
ის არის, რომ ჩვენ მუხლუხიანი რაოდენობის ასოები, რომლებიც ჩვენ გვინდა უნახავს.
როგორც ჩვენ ფეხით მეტი გაგზავნა სიმებიანი, როგორც ჩვენ ფეხით მეტი ხასიათი ხასიათი,
ჩვენ მუხლუხიანი ინდექსი როგორც ნაწილი ჩვენი ამისთვის მარყუჟი, და შემდეგ ჩვენ ასევე მუხლუხიანი
პუნქტების წერილები, ისე არასამთავრობო სპეციალური სიმბოლოების, არასამთავრობო ციფრები, არასამთავრობო თეთრი სივრცე
რომ ჩვენ გვინდა ჩანს ცალკე ცვლადი.
და მაშინ ეს გადაწყვეტა modifies გასაღები
მიიღოს ფაქტობრივი გასაღები მთელი რიცხვი, და ეს იმას, რომ on the fly,
უფლება სანამ შემდეგ გრძელდება დაშიფვრა ფაქტობრივი გაგზავნა ხასიათი.
არსებობს რამდენიმე გადაწყვეტილებები, რომლებიც შესანიშნავად დიდი ძალიან
რომ ცვლილებები გასაღები up როდესაც ტესტირება გასაღები მოქმედების.
გარდა ამისა მიღების დარწმუნებული ვარ, რომ ხასიათი და სიტყვით
იყო ანბანურ ასოს იგი ასევე აღმოჩნდა, რომ შევიდა მთელი რიცხვი
in 0 დან 25 Range შემდეგ გამოტოვოთ მქონე გავაკეთოთ, რომ მოგვიანებით ამ for loop.
ერთხელ, ხედავთ აქ ეს ნამდვილად ზუსტად იგივე კოდი
რომ ჩვენ გამოყენებული Caesar ამ ეტაპზე.
თქვენ აკეთებთ ზუსტი იგივე, ასე რომ რეალური შეასრულა არის მჭიდროდაა გარეთ
როგორ ვაქციოთ სიტყვით შევიდა რიცხვი.
>> ერთი რამ, რომ ჩვენ აქ, რომ არის პატარა მკვრივი
არის ჩვენ გაიმეორა ეს ფრაზა, მე ვფიქრობ, რომ თქვენ შეიძლება ეძახით,
3 ცალკე ჯერ ხაზები 58, 59, და 61.
შეგიძლიათ ვინმეს ახსნას რა ზუსტად ეს ფრაზა არ?
ეს წვდომის ხასიათი, როგორც თქვენ განაცხადა.
ჰო [inaudible] პერსონაჟი სიტყვით,
და ამიტომ რაოდენობის ასოები ჩანს, რადგან თქვენ მხოლოდ მოძრავი გასწვრივ
სიტყვით კიდევ ვნახე წერილი,
ასე რომ აპირებს ეფექტურად გამოტოვოთ ფართები და პერსონალის იგრძნობა.
ჰო, ზუსტად.
და შემდეგ კიდევ ვნახე სიტყვით ცარიელი უბრალოდ mod ასე რომ თქვენ გადაადგილდება გარშემო.
სწორედ. სწორედ სრულყოფილი განმარტება.
რა კევინ განაცხადა, რომ ჩვენ გვინდა ინდექსი შევიდა სიტყვით.
ჩვენ გვინდა num_letters_seen ხასიათი, თუ გნებავთ,
მაგრამ თუ num_letters_seen აღემატება სიგრძეზე სიტყვით,
გზა მივიღებთ ისევ შესაბამისი დიაპაზონი არის ვიყენებთ mod ოპერატორი
ეფექტურად საერთო გარშემო.
მაგალითად, როგორც მოკლე, ჩვენი სიტყვით არის ბეკონი,
და ეს 5 წერილებს ხანგრძლივი.
მაგრამ ჩვენ ვნახეთ 6 შრიფტით ჩვენი ძირითადი ტექსტი ამ ეტაპზე
და დაშიფრული 6.
ჩვენ დასრულდება მდე წვდომის num_letters_seen,
რომელიც 6, mod სიგრძეზე სიტყვით, 5,
და ა.შ. ჩვენ კიდევ 1 და ა.შ. რაც ჩვენ გავაკეთებთ არის ჩვენ გამოგიგზავნით
შედიხართ პირველ სიმბოლოს შიგნით ჩვენი სიტყვით იმ ეტაპზე.
>> ყველა უფლება, ნებისმიერი შეკითხვა Vigenère
სანამ ჩვენ გადასვლა?
თქვენ ბიჭები შეგრძნება საკმაოდ კარგი ამის შესახებ?
ზემოთ, დიდი.
მე გვინდა დავრწმუნდეთ, რომ თქვენ ბიჭები იღებენ შანსს ვხედავ კოდი
რომ ჩვენ ვფიქრობთ გამოიყურება კარგი და აქვს შანსი ვისწავლოთ მისგან.
ეს იქნება ბოლო ჩვენ უნდა გამოყენებით ფართების დროისათვის,
და ჩვენ ვაპირებთ გარდამავალი ახლა, და მე ვაპირებ წასვლა cs50.net/lectures
ამიტომ ჩვენ შეგვიძლია გავაკეთოთ ცოტა Quiz მიმოხილვა.
საუკეთესო საშუალებაა ვფიქრობ უნდა დაიწყოს აკეთებს Quiz მიმოხილვა
არის მისვლა ამ ლექციები გვერდზე, cs50.net/lectures,
და ქვეშ თითოეული კვირაში სასაქონლო, ისე, თუ გავითვალისწინებთ აქ კვირა 0,
მე ვხედავ, რომ ჩვენ გვაქვს ჩამონათვალი თემები, რომ ჩვენ დაფარული კვირა 0.
>> თუ რომელიმე ამ თემებზე ჩანს უცნობ თქვენ
თქვენ აუცილებლად მინდა დაბრუნდეს და scour ლექცია შენიშვნები და შესაძლოა
კი skim მეშვეობით ლექციების, უყუროთ მათ კვლავ თუ გინდათ
მისაღებად შეგრძნებას რა ხდება თითოეულ ამ თემებზე.
მინდა ვთქვა, დამატებით ამ წლის ერთ cool რესურსების გვაქვს
არის ამ შორტები, რომ ჩვენ შევქმენით და, თუ გადავხედავთ კვირა 0,
ჩვენ არ გვაქვს ყველა თემები დაფარული, მაგრამ ჩვენ მივიღეთ საკმაოდ რამდენიმესი,
ზოგიერთი trickier პირობა, ასე თვალს ამ შორტები ერთხელ
კარგ მისაღებად თქვენ მდე სიჩქარე.
კერძოდ, მე ვაპირებ მა დანამატი ამისთვის 3 წლის ბოლოში, რადგან მე იმ.
მაგრამ თუ თქვენ ბრძოლა ორობითი, ბიტი, hex, რომ მსგავსი საქმიანობები,
ორობითი არის დიდი ადგილი დაიწყოს.
ASCII არის კიდევ ერთი რომ კარგია სანახავად ძალიან.
თქვენ შეგიძლიათ კიდევ უყუროთ ჩემთვის 1.5x სიჩქარე თუ მე ვაპირებ ძალიან ნელა თქვენთვის.
რადგან მიმოხილვა, მოგერიდებათ გაგვაჩნია.
>> უბრალოდ უნდა დაიწყოს ნამდვილად სწრაფად, ჩვენ ვაპირებთ გავლა რამდენიმე ამ ვიქტორინაში პრობლემები
უბრალოდ სწრაფად churn მეშვეობით ამ.
მაგალითად, მოდით შევხედოთ პრობლემას 16 რომ მაქვს უფლება აქ ფორუმში.
გვაქვს ამ შემდეგ გაანგარიშება წელს ორობითი,
და გვინდა ვაჩვენოთ ნებისმიერი სამუშაო.
Okay, მე ვაპირებ, რათა გასროლა.
თქვენ ბიჭები უნდა ერთად ქაღალდი,
და ჩვენ ყველაფერს გავაკეთებთ ამ მართლაც სწრაფად.
ჩვენ გვინდა, რომ შეასრულოს შემდეგი გაანგარიშება წელს ორობითი.
მაქვს 00110010.
და მე ვაპირებ დამატებას 00110010.
იყიდება მათემატიკის გენიოსების შემდეგ გასწვრივ სახლში,
ეს ეფექტურად გამრავლებით მიერ 2.
დავიწყოთ.
ჩვენ ვაპირებთ იმავე ამისა ალგორითმი, რასაც ჩვენ ვაკეთებთ
როდესაც ჩვენ დაამატოთ ათობითი ნომრები ერთად.
მართლაც ერთადერთი განსხვავება აქ არის ის, რომ ჩვენ loop უკან გარშემო
ერთხელ ჩვენ გვყავს 1 + 1 ნაცვლად ერთხელ მივიღებთ დან 10.
>> თუ ჩვენ დავიწყებთ, მარჯვენა მართლაც სწრაფად, რა პირველი ციფრი?
[სტუდენტური] 0. >> [Nate ჰ] 0.
დიდი, მეორე ციფრი?
[სტუდენტური] 1.
[Nate ჰ] ეს 1? 1 + 1 არის?
[სტუდენტური] 10.
[Nate ჰ] ზუსტად, მერე რა არის ციფრი, რომ ვწერ უფლება ქვეშ 2 პირობა დასძინა ერთად?
[სტუდენტური] 1, 0, ან 0 და შემდეგ განახორციელოს 1.
[Nate ჰ] 0 ახდენენ 1, ზუსტად.
შემდეგი ერთი გოლი, ბასილ, თქვენ up.
რა არის მესამე? >> [ბასილ] 1.
[Nate ჰ] 1, სრულყოფილი. Kevin?
[Kevin] 0. >> [Nate ჰ] 0, Charlotte?
[Charlotte] 0. >> [Nate ჰ] ჰო, და რა გავაკეთო?
[სტუდენტური] 1.
[Nate ჰ] და რა ვქნათ? და მერე განახორციელოს 1.
სრულყოფილი, Sahb? >> [Sahb] ახლა თქვენ გაქვთ 1.
[Nate ჰ] და ნუ მე არაფერი აქ?
[Sahb] მაშინ მომდევნო ერთი თქვენ გაქვთ 1 იმიტომ, რომ თქვენ განხორციელებული მეტი 1.
[Nate ჰ] დიდი, ასე რომ აქ ჩვენ შეგვიძლია დავამთავროთ ეს up.
ზემოთ.
[სტუდენტური] არა 0 + 0 = 0?
0 + 0 = 0.
1 + 1, ისევე როგორც თქვენ თქვით, არის 10, ან 1, 0, საკმაოდ.
10 არის misnomer რადგან ჩემთვის 10 ნიშნავს ნომერი 10,
და ეს quirk, თუ როგორ ჩვენ წარმოადგენს, როცა ჩვენ წერილობით იგი.
ჩვენ წარმოვადგენთ ნომერი 2 მიერ 1, 0, და ხმების 10 არის ოდნავ განსხვავებული.
>> რა სახის ლამაზი შესახებ ორობითი არის ის, რომ იქ ნამდვილად არ არის, რომ ბევრი
შემთხვევაში უნდა ვისწავლოთ.
არსებობს 0 + 0 = 0, 0 + 1 = 1,
1 + 1 არის 0, ხოლო შემდეგ განახორციელოს 1,
და მაშინ დაინახავ, აქ მესამე სვეტის მარჯვენა
ჩვენ გვქონდა ამ 1, 1, 1.
და 1 + 1 + 1 არის 1,
და თქვენ განახორციელოს სხვა 1.
როდესაც თქვენ აკეთებთ ორობითი ამისა, საკმაოდ მარტივია.
მინდა გავაკეთოთ წყვილი მეტი ასეთი რომ საღი აზრის შეამოწმოს საკუთარი თავი
სანამ წავიდეს, რადგან ეს
ალბათ ის, რასაც ჩვენ დავინახავთ on ვიქტორინა.
ახლა მოდით ეს ერთი ისევე.
მოდით პრობლემა 17.
ჩვენ ვაპირებთ კონვერტირება შემდეგ ორობითი რიცხვის ათობითი.
მაქვს 10100111001.
მახსოვს ორობითი ვიდეო რომ მე
მე ფეხით ისეირნა რამდენიმე მაგალითები, და მე გვიჩვენა, თუ როგორ
ყველაფერი მუშაობს, როდესაც თქვენ აკეთებთ ამას ათობითი.
როდესაც თქვენ მომუშავე ათობითში ვფიქრობ ჩვენ
ამ ეტაპზე ჩვენი ცხოვრება ისე ფლობს, რომ
ეს საკმაოდ ადვილი სიპრიალის მეტი მექანიკის როგორ რეალურად მუშაობს.
>> მაგრამ ამისათვის სწრაფი recap, თუ მაქვს ნომერი 137
ეს ნამდვილად ნიშნავს და ისევ, ეს ათობითში-
ნომერი 137 წელს ათობითი იმას ნიშნავს, რომ მაქვს 1 x 100 + 3 x 10 + 7 x 1.
ეს არის ყველა დარჩენის ეკრანზე.
და შემდეგ თუ თქვენ შეხედეთ ამ ნომრებზე უფლება აქ,
100, 10 და 1, ხედავთ, რომ ისინი პრაქტიკულად ყველა უფლებამოსილება 10.
მაქვს 10 ², 10 ¹ და 10 to ნულოვანი.
ჩვენ გვყავს ანალოგიური სახის რამ ორობითი,
გარდა იმისა, რომ ჩვენი ბაზა, როგორც ჩვენ მას, არის 2 ნაცვლად 10.
ეს 10s რომ დავწერე ქვემოთ აქ ბოლოში,
ამ 10 ², 10 ¹, 10 დან ნულოვანი, 10 არის ჩვენი ბაზა,
და მაჩვენებლებით, 0, 1, ან 2,
იგულისხმება მიერ თანამდებობაზე ციფრი რიცხვი, რომ ჩვენ წერენ.
1, თუ დავაკვირდებით, ეს 1 არის მე -2 პოზიცია.
3 არის 1 პოზიცია და 7 არის 0th პოზიცია.
ასე მივიღებთ სხვადასხვა ექსპონატები ქვემოთ ჩვენი ბაზების.
>> შემდეგ ყველა ამ we'll-ფაქტობრივად, იცით, რა?
ჩვენ ყველაფერს გავაკეთებთ, სადაც არც ჩემი გაუქმება ღილაკს წავიდეთ?
არსებობს მიდის.
მიყვარს ეს გაუქმება რამ.
შემდეგ ამ ვფიქრობ ყოველ შემთხვევაში ჩემთვის
დაწყების უმარტივეს გზას კონვერტაცია ორობითი რიცხვის
ან თექვსმეტობითი ხმების სადაც ბაზა 16
და არა 10 ან 2 არის წავიდეთ წინ და დაწეროთ გარეთ
ბაზებისა და ექსპონატები ყველა ნომრები ჩემი ორობითი რიცხვის ზედა.
თუ ჩვენ დავიწყებთ მარცხნიდან მარჯვნივ ისევ,
რაც სახის counterintuitive,
მე შეიცვალოს თავში შავი აქ, ჩვენ გვაქვს 2 დან 0th პოზიცია,
და მაშინ ჩვენ გვყავს 2 ¹, 2 ²,
და შემდეგ 2 დან 3, 2 დან 4, 2 დან 5, 6,
7, 8, 9, და 10.
ეს ციფრები მე წერილობითი out ყველა ექსპონატი.
მე მხოლოდ წერდა ბაზების აქ პირველი 3 მხოლოდ სივრცეში.
>> ამ ეტაპზე მე ვაპირებ წავიდეთ წინ და მე რეალურად აპირებს წაშალოს
პერსონალის, რომ ჩვენ გააკეთა ათობითი, თუ ეს okay.
თქვენ წასვლამდე რომ.
იმ თქვენ თვალს ონლაინ დარწმუნებული ვარ შეძლებს გადახვევა ჩემთვის თუ მინდა.
გადართვის თავში კალამი.
ახლა, რა შეგვიძლია გავაკეთოთ-თუ ბიჭები არიან სრულიად მდე დაჩქარდეს თქვენს უფლებამოსილება 2,
რომ სრულიად გრილი.
ეს ხდება. მე მესმის.
მე კიდევ ჰქონდა გასაუბრება, სადაც მითხრეს, რომ მე უნდა იცოდეს ყველა ძალაუფლება 2
up მეშვეობით 2 დან 30.
ეს არ იყო სამუშაო მე მივიღე.
ყოველ შემთხვევაში, თქვენ ბიჭები შეიძლება წავიდეთ წინ და ნუ მათემატიკის აქ,
მაგრამ ბინარული ეს ნამდვილად არ აქვს აზრი,
და არც ის აზრი ერთად ათობითი ან თექვსმეტობითი ან,
გავაკეთოთ მათემატიკის, თუ სად გაქვთ zeros.
თქვენ ხედავთ, მაქვს 0 აქ, 0 აქ, 0 აქ, 0 აქ, 0 აქ, 0 აქ.
რატომ შეიძლება ეს არ აქვს აზრი უნდა გააკეთოს რეალურ მათემატიკის
გამოვთვალოთ შესაბამისი ძალა 2 რომ პოზიცია?
სწორედ, ისევე როგორც Charlotte განაცხადა, ეს იქნება 0.
შესაძლოა ასევე გადარჩენა თავის დროს, თუ გაანგარიშების უფლებამოსილება 2 არ არის თქვენი ძლიერი სარჩელი.
ამ შემთხვევაში ჩვენ მხოლოდ უნდა გამოვთვალოთ ეს 2 რომ 0 არის-?
[სტუდენტური] 1.
[Nate ჰ] 1, 2 დან 3 რომელიც-?
[სტუდენტური] 8. >> [Nate ჰ] 8.
2 დან 4?
[სტუდენტური] 2. მე უკაცრავად, 1.
[Nate ჰ] 2 დან 4 არის 16, ზუსტად.
2 დან 5, კევინ? >> 32.
[Nate ჰ] 32, 2 რათა 8?
[სტუდენტური] 32 x 8, 256.
[Nate ჰ] Perfect.
, 2 10?
[სტუდენტური] 1024.
[Nate ჰ] Yeah, 1024.
>> ერთხელ ჩვენ მივიღეთ ამ ნომრებზე შეგვიძლია შევაჯამოთ მათ ყველა up.
და ეს არის, სადაც ეს მართლაც მნიშვნელოვანია გავაკეთოთ რამოდენიმე რამ.
ერთი წასვლა ნელი და შეამოწმოთ თქვენი მუშაობა.
თქვენ შეგიძლიათ თქვათ, რომ არც 1 დასასრულს ეს რიცხვი,
ამიტომ, უნდა მიიღოს კენტი ნომერი, როგორც ჩემი შედეგი,
რადგან ყველა სხვა პირობა ვაპირებთ, რომ ვიყოთ კიდევ ნომრები
იმის გათვალისწინებით, რომ ეს ორობითი რიცხვი.
სხვა რამ უნდა გააკეთოთ, თუ თქვენ მიიღებთ ამ ეტაპზე on ტესტი
და თქვენ წერილობითი იგი out ამ შორს
და თქვენ გაშვებული out of time
შეხედეთ პუნქტების რაოდენობა რომ ეს პრობლემა ღირს.
ეს პრობლემა, როგორც ხედავთ თუ მე Flip თავში ჩემი ლეპტოპი მართლაც სწრაფად-
ამ პრობლემის ღირს 2 ქულა, ასე რომ ეს არ არის ერთგვარი გარდა
თქვენ უნდა გადის თუ თქვენ ნამდვილად დაპრესილი დრო.
მაგრამ ჩვენ გადართოთ თავში iPad, და ჩვენ გავლა მართლაც სწრაფად.
>> მომწონს აკეთებს მცირე რაოდენობით პირველ
რადგან მე, რომ ადვილია.
მომწონს 32 და 8 რადგან ისინი ერთად წავიდეთ საკმაოდ მარტივად, და მივიღებთ 50.
16 და 1 იღებს 17.
არსებობს მივიღებთ 57,
და შემდეგ შეგვიძლია გავაკეთოთ დანარჩენი ამ, ასე რომ ჩვენ შეგვიძლია გავაკეთოთ 57, 156.
Come on.
მამაკაცს, ისევე, ვნახოთ.
ჩვენ გვქონდა 57, 256, და 1024.
ამ ეტაპზე, მე მირჩევნია უბრალოდ გავლა.
მე არ ნახავ. მე ნათლად უნდა წაიკითხონ up ამ.
7, 6, და 4, თქვენ მიიღებთ 17.
1, 5, 5, 2, 13.
მაშინ მივიღებთ 3 და შემდეგ მივიღებთ 1.
1337.
აღდგომის კვერცხი, ვინმე?
ვინმე აღიარებს ამ ნომერი?
კრის აღიარებს ნომერი. რას ნიშნავს, კრის?
[კრის] Leet.
Leet ასე რომ, თუ გადავხედავთ, ეს ჰგავს leet.
Hacker პერსონალი. ფრთხილად, რომ მსგავსი საქმიანობები წლის შუალედური ან ინტელექტუალური, საკმაოდ.
თუ ხედავ, რომ მსგავსი საქმიანობები და თქვენ გაინტერესებთ, "Huh"
რომ შეიძლება რეალურად ნიშნავს რაღაცას.
მე არ ვიცი. დავით მოსწონს ეს აყენებს სისტემაში
ეს კარგი საშუალებაა საღი აზრის შეამოწმეთ იგი.
Like okay, მე ვხედავ, რა ხდება.
>> სწორედ კვირა 0/Week 1 პერსონალის.
თუ ჩვენ გადართოთ უკან ჩვენი ლეპტოპი არის,
zoom out, და რამოდენიმე სხვა რამ.
არსებობს ASCII, რომელიც ჩვენ აკეთებდა ბევრი პრობლემას კომპლექტი.
ეს ცნება კაპიტალური ა რა არის, რომ ნამდვილად?
Knowing ეს ათობითი რიცხვი.
65 არის რასაც ის mapped to in ASCII მაგიდა,
და ეს ამიტომ, თუ როგორ კომპიუტერი წერს იგი,
და ასე ჩვენ ვიღებთ გადაურჩა რეალურად წერა
ხასიათი დედაქალაქში და ხასიათი მხედრულ
ზოგიერთ ამ გადაწყვეტილებებს და პრობლემა კომპლექტი რომ თქვენ უკვე აკეთებს.
რამდენიმე სხვა რამ.
გვაქვს განცხადებებს, ლოგიკური გამოთქმები, პირობები, მარყუჟების, ცვლადები და თემა.
>> იმ ყველა როგორც ჩანს აზრი ამისთვის დიდი ნაწილი?
ზოგიერთი ამ ტერმინოლოგიის არის პატარა ხმაურიანი at ჯერ.
მე მიყვარს ვფიქრობ განაცხადი როგორც საუკეთესო ნაწილი, რომ რაღაც მთავრდება მძიმით.
განცხადებები როგორიცაა x = 7, რომელიც ითვალისწინებს ცვლადი,
სავარაუდოდ მოუწოდა x = 7.
სავარაუდოდ x ასევე ტიპის რომ შენახვა შეუძლია ნომერი 7,
ამიტომ int ან შესაძლოა ათწილადი ან მოკლე ან char,
მსგავსი რამ, რომ.
ლოგიკური გამოხატვის იყენებს ამ ორმაგი შეადგენს
და bang ტოლია ან არ უდრის, ნაკლები, მეტი,
ნაკლებია ან ტოლია, ყველა რომ მსგავსი საქმიანობები.
პირობები მაშინ არის თუ სხვაგან განცხადებებს.
მინდა გვახსოვდეს, რომ შეგიძლიათ არ აქვს სხვაგან გარეშე შესაბამისი თუ.
ანალოგიურად, შეგიძლიათ არ აქვს სხვას თუ გარეშე შესაბამისი თუ.
მარყუჟების, გავიხსენოთ 3 სახის მარყუჟების ჩვენ hammering უყვარხარ
უკანასკნელი რამდენიმე სექციები და პრობლემა კომპლექტი.
გამოყენება არ ხოლო როდესაც თქვენ მიღების მომხმარებლის input,
გამოყენებით, ხოლო მარყუჟების სანამ კონკრეტული მდგომარეობა მართალია,
და შემდეგ გამოყენებით ისინი მარყუჟების თუ საჭიროა
იცით რომელი iteration of loop თქვენ ამჟამად არის, თუ როგორ ვფიქრობ ამის შესახებ.
ან თუ თქვენ აკეთებთ თითოეული პერსონაჟი სიმებიანი მინდა რაღაც,
თითოეული ელემენტი მასივი მინდა რაღაც რომ ელემენტს.
>> Threads და მოვლენები.
ეს ჩვენ არ დაფარული ასე მკაფიოდ დო,
მაგრამ გვახსოვდეს, ამ ნულიდან.
ეს არის ცნება განსხვავებული სკრიპტები.
ეს არის ასევე ამ ცნება მაუწყებლობს ღონისძიება.
ზოგიერთი ადამიანი არ გამოიყენა მაუწყებლობა საკუთარ პროექტებს თავდაპირველად,
რომელიც მთლიანად cool,
მაგრამ ეს არის 2 სხვადასხვა გზები გატარება ამ უფრო დიდი საკითხი მოუწოდა concurrency,
რომელიც როგორ იღებთ პროგრამების განხორციელება
ან შეხედვით შეასრულოს ამავე დროს?
სხვადასხვა ამოცანები გაშვებული ხოლო სხვა ამოცანებს ასევე გაშვებული.
ეს არის, თუ როგორ თქვენი ოპერაციული სისტემა, როგორც ჩანს მუშაობა.
ამიტომ, მიუხედავად იმისა, მაგალითად,
მაქვს ჩემი ბრაუზერის გაშვებული, შემიძლია ასევე ჩართოთ Spotify და ითამაშოს სიმღერა.
სწორედ მეტი კონცეპტუალური უნდა გავითვალისწინოთ.
მინდა შევხედოთ თემა მოკლე
თუ გსურთ შეიტყოთ უფრო მეტი რომ.
>> ვნახოთ, მე მჯერა, შეიძლება ყოფილიყო
პრობლემა ამ ერთ ამ.
ისევ და ისევ, მე ვფიქრობ, თემა და თარიღები არ არის ის, რასაც ჩვენ დაფარავს in C
მხოლოდ იმიტომ, რომ ის მნიშვნელოვნად უფრო რთული, ვიდრე Scratch.
თქვენ არ უნდა ფიქრი მას იქ, მაგრამ ნამდვილად მესმის ცნებები,
მესმის რა ხდება.
სანამ ჩვენ გადასვლა, რაიმე შეკითხვა კვირა 0 მატერიალური?
ყველას შეგრძნება საკმაოდ კარგი?
მემორანდუმი ცვლადები და რა ცვლადი არის?
>> მოძრავი. კვირა 1.
რამდენიმე რამ აქ რომ არ იყო განსაკუთრებით დაფარული
in ინტელექტუალური მიმოხილვა აუცილებლად და ასევე უფრო კონცეპტუალური რამ ფიქრი.
პირველი არის ამ ცნება რა კოდებს, Compilers და ობიექტის კოდი.
ვინმეს? ბასილი.
არის ობიექტის კოდი-ვგულისხმობ კოდის არის ის, რაც თქვენ შევიდა clang,
და ობიექტის კოდი არის რა clang აყენებს გარეთ ისე, რომ თქვენი კომპიუტერი არ აქვს უფლება წაიკითხოს პროგრამა.
სწორედ.
კოდის არის C კოდი, რომ თქვენ რეალურად აკრიფოთ up.
ობიექტის კოდი არის ის, რაც თქვენ გავიდნენ clang.
ეს 0S და 1s ამ ორობითი ფორმატის.
მაშინ რა ხდება, როდესაც თქვენ გაქვთ bunch of ობიექტი ფაილი
ამბობენ თქვენ შედგენა პროექტის ან პროგრამა რომელიც იყენებს მრავალი კოდის ფაილი
რომელიც კონვენციის მოცემულია. გ ფაილის გაფართოება.
ამიტომ ჩვენ გვაქვს caesar.c, vigenère.c.
თუ თქვენ წერა Java პროგრამების თქვენ მივცეთ გაფართოება. Java.
პითონის პროგრამების აქვს გაფართოება. Py ხშირად.
>> მას შემდეგ რაც მრავალი. C ფაილი თქვენ კომპილაციის მათ.
Clang SpitS ყველა ამ ორობითი უსარგებლო.
მაშინ, რადგან თქვენ მხოლოდ მინდა 1 პროგრამის
თქვენ გაქვთ linker ლინკები ყველა ამ ობიექტს ფაილი ერთად
შევიდა 1 შესრულებად ფაილს.
ეს არის ასევე რა ხდება მაშინ, როდესაც თქვენ იყენებთ CS50 ბიბლიოთეკა, მაგალითად.
CS50 ბიბლიოთეკა ორივე რომ. თ header ფაილი
რომ წაიკითხავთ, რომ # includecs50.h.
და მერე ასევე სპეციალური ორობითი ბიბლიოთეკა ფაილი
რომ უკვე შედგენილი, რომ არის 0S და 1s,
და რომ-L დროშა ასე რომ, თუ ჩვენ დავუბრუნდებით ჩვენი სივრცეები და გადავხედავთ ნამდვილად სწრაფად
რა ხდება აქ შევხედოთ ჩვენი clang ბრძანება,
რა გვაქვს ეს არის ჩვენი კოდის ფაილი უფლება აქ.
ეს არის bunch of შემდგენელი დროშები.
ხოლო შემდეგ ბოლომდე, ამ-L დროშები ბმულზე
ფაქტობრივი ორობითი ფაილი ამ 2 ბიბლიოთეკა, CS50 ბიბლიოთეკა და შემდეგ მათემატიკის ბიბლიოთეკაში.
>> გააზრება თითოეული სახის ფაილები 'მიზნით
ასევე შეადგინა პროცესში არის რაღაც თქვენ გსურთ შეძლებს
მივცეთ მინიმუმ მაღალ დონეზე მიმოხილვა.
კოდის მოდის შემოსული ობიექტის კოდი გამოდის.
ობიექტის კოდი ფაილები დაუკავშირონ ერთად, და თქვენ ლამაზი, შესრულებადი ფაილი.
ზემოთ.
ეს არის ასევე სადაც შეგიძლიათ მიიღოთ შეცდომები დროს მრავალჯერადი რაოდენობა
ასევე შეადგინა პროცესში.
ეს არის სადაც, მაგალითად, თუ თქვენ აიღეთ ამ დამაკავშირებელ დროშა,
CS50 დროშა და გამომრჩეს ეს სივრცეები ან როდესაც თქვენ გაშვებული თქვენი კოდი,
ეს არის, სადაც თქვენ მიიღებთ შეცდომა აკავშირებს ფაზაში,
და linker იტყვის, "Hey, თქვენ მოუწოდა ფუნქცია GetString
რომ წელს CS50 ბიბლიოთეკა. "
"თქვენ მითხრა იყო CS50 ბიბლიოთეკაში და ვერ ვპოულობ კოდი იგი."
სწორედ სადაც თქვენ უნდა დაუკავშირონ ის, და ეს ცალკე
საწყისი შემდგენელი შეცდომა რადგან შემდგენელი ეძებს სინტაქსი და რომ მსგავსი საქმიანობები.
კარგია, თუ რა ხდება, როდესაც.
>> სხვა რამ იცოდეთ.
მე ვიტყოდი, თქვენ აუცილებლად გვინდა შევხედოთ მოკლე on typecasting კეთდება იორდანიის
გვესმოდეს რა ints ქვეშ hood,
რა სიმბოლო ქვეშ hood.
როდესაც ვსაუბრობთ ASCII და ჩვენ რეალურად შევხედოთ ASCII მაგიდა,
რა რომ აკეთებს გვაძლევს ქვეშ hood ნახვა
როგორ კომპიუტერი რეალურად წარმოადგენს კაპიტალის და ციფრი 7
და მძიმით და კითხვის ნიშნის.
კომპიუტერი ასევე აქვს სპეციალური გზები წარმოადგენს
ნომერი 7 როგორც მთელი რიცხვი.
მას აქვს სპეციალური გზა წარმოადგენს რაოდენობა 7 როგორც მცურავი პუნქტიანი ნომერი,
და იმ ძალიან განსხვავებული.
Typecasting ასე გითხრათ კომპიუტერი "Hey, მინდა გადაიყვანოთ
ერთი წარმომადგენლობის კიდევ ერთი წარმომადგენლობა. "
რატომ არ გვაქვს შევხედოთ, რომ.
>> მინდა ასევე შევხედოთ მოკლე on ბიბლიოთეკების და მოკლე on compilers.
იმ საუბარი პროცესში შედგენაში,
რა ბიბლიოთეკა, და წავიდეთ მეტი ზოგიერთ ამ შეკითხვაზე, რომ თქვენ შეიძლება სთხოვა.
კითხვები on კვირა 1 მატერიალური?
არსებობს რაიმე თემა აქ რომ ჩანს daunting გსურთ დაფარავს?
ვცდილობ აფეთქება მეშვეობით ყველაზე ამ ადრე თემები ისე, რომ ჩვენ შეგვიძლია მისაღებად
პოინტერები და ნუ ცოტა უკან.
ფიქრები?
არაფერი დაფარავს?
ახლა ზოგიერთი შოკოლადის იქნებ?
თქვენ ბიჭები მუშაობენ მეშვეობით.
მე ვაპირებ შენარჩუნება sipping ჩემს ყავა.
კვირა 2.
კარგი ზარი, კარგი ზარი.
In კვირა 2 ჩვენ ვისაუბრეთ ცოტა მეტი ფუნქციები.
>> პირველ რამდენიმე პრობლემა კომპლექტი ჩვენ არ ნამდვილად წერენ ნებისმიერი ფუნქციების ყველა
გარდა რომელიც ფუნქციას?
[სტუდენტური] მთავარი. >> მთავარი, ზუსტად.
ასე რომ, ჩვენ ვხედავთ სხვადასხვა კოსტიუმები, რომ ძირითადი ატარებს.
არსებობს ერთი, რომელიც მას სჭირდება არანაირი არგუმენტი,
და ჩვენ უბრალოდ, ვამბობთ ბათილად შორის ფრჩხილებში,
და შემდეგ იქ სხვა, სადაც ჩვენ გვინდა, რომ მიიღოს ბრძანება ხაზი არგუმენტები,
და როგორც ჩვენ ვნახეთ, რომ სადაც თქვენ int argc და სიმებიანი argv მასივი
ან არის, რომ ჩვენ ფაქტობრივად დაუცველი string to be char *, რომ ეს არის
ჩვენ ვაპირებთ დავიწყოთ წერა, როგორც char * argv და შემდეგ ფრჩხილებში.
პრობლემების Set 3, თქვენ ბიჭები დაინახა bunch of ფუნქციები,
და თქვენ განხორციელებული bunch of ფუნქციები, გავამახვილო, ეძებოთ, scramble.
პროტოტიპები იყო ყველა წერილობითი არსებობს თქვენთვის.
>> რა მინდოდა ლაპარაკი აქ ფუნქციებს მართლაც სწრაფად
ის არის, რომ არსებობს 3 ნაწილები მათ როდესაც ვწერთ ფუნქციას.
თქვენ უნდა მიუთითოთ დაბრუნების ტიპის ფუნქცია.
თქვენ უნდა მიუთითოთ სახელი ფუნქცია, და შემდეგ თქვენ უნდა მიუთითოთ
არგუმენტი სიაში ან პარამეტრის სია.
მაგალითად, მე რომ დაწერა ფუნქცია შეაჯამებს bunch of რიცხვებით
და შემდეგ დაბრუნდება ჩემთან თანხა რა იქნება ჩემი დაბრუნების ტიპის
თუ მინდოდა მთლიანობაში რიცხვებით და შემდეგ დაბრუნდნენ თანხა?
მაშინ სახელით ფუნქციონირებს.
თუ მე წავიდეთ წინ და ჩაიწეროს, მწვანე, ეს ნაწილი დაბრუნების ტიპის.
ეს ნაწილი სახელი.
ხოლო შემდეგ შორის ფრჩხილებში
სადაც მე ვაძლევ არგუმენტები,
ხშირად განუხრელად როგორც args, ხშირად წოდებული params for პარამეტრებს.
და თუ თქვენ გაქვთ ერთი, თქვენ უბრალოდ მიუთითოთ ერთი.
თუ თქვენ გაქვთ მრავალჯერადი თქვენ გამოყოფთ ყოველი ერთი მძიმით.
და თითოეული არგუმენტი თქვენ მისცეს მას 2, რასაც ახლა-Kevin?
[Kevin] თქვენ უნდა მისცეს პირობა და შემდეგ სახელი.
და მერე სახელი და გვარი არის სახელი, რომ თქვენ აპირებთ მის გამოყენებას
მიმართოს, რომ არგუმენტი ფარგლებში თანხა ფუნქცია,
ფარგლებში ფუნქცია, რომ თქვენ გაკეთებული წერილობით.
>> თქვენ არ უნდა, მაგალითად, თუ მე ვაპირებ შეაჯამებს,
ამბობენ, მასივი რიცხვებით-we'll do int array,
და მე მივცემ თავს ზოგიერთი Curly braces იქ-
მაშინ როდესაც მე გაივლის მასივი თანხის ფუნქცია
მე მსგავ პირველ პოზიციაზე არგუმენტი სიაში.
მაგრამ array რომ მე კორიდორი არ უნდა ჰქონდეს სახელი arr.
Arr იქნება როგორ ეხება ეს არგუმენტი ფარგლებში ორგანოს ფუნქცია.
სხვა საქმეა, რომ ჩვენ გვჭირდება გაითვალისწინოს,
და ეს არის ოდნავ განსხვავებული ფუნქციები, მაგრამ მე ვფიქრობ, რომ მნიშვნელოვანი,
ის არის, რომ C როდესაც მე წერილობით ფუნქცია მოსწონს
როგორ გავიგო რამდენი ელემენტია ამ მასივი?
ეს არის გარკვეულწილად of შეასრულა კითხვაზე.
ჩვენ ვისაუბრეთ ამ ცოტა გასულ კვირას მონაკვეთზე.
როგორ გავიგო რაოდენობის ელემენტების შიგნით მასივი დო?
არის გზა?
>> თურმე არ გზა ვიცი.
თქვენ უნდა გაიაროს ეს ცალკე.
არსებობს შეასრულა, რომ შეგიძლიათ გააკეთოთ
თუ თქვენ ამავე ფუნქციას, რომელშიც მასივი გამოცხადდა,
და თქვენ მუშაობის დასტის მასივი.
მაგრამ რომ მუშაობს მხოლოდ იმ შემთხვევაში, თუ თქვენ იგივე ფუნქცია.
ერთხელ თქვენ გაივლის მასივი სხვა ფუნქცია ან თუ თქვენ განაცხადა მასივი
და თქვენ დააყენა, რომ მასივი შესახებ ბევრი, თქვენ გამოყენებული malloc
და რომ მსგავსი საქმიანობები, მაშინ ყველა ფსონი off.
მაშინ თქვენ ნამდვილად უნდა გაიარონ გარშემო
სპეციალური არგუმენტი ან სხვა პარამეტრების
გეუბნებოდით რამდენად დიდი მასივი არის.
ამ შემთხვევაში, მე მინდა გინდათ გამოიყენოთ მძიმით-I'm sorry, ის აპირებს off ეკრანზე აქ-
და მინდა გაივლის სხვა არგუმენტი
და ეძახით int len ​​ამისთვის სიგრძე.
>> ერთი რამ, რომ შეიძლება ამუშავება on ვიქტორინა
ითხოვს ჩემზე ან შესრულების კონკრეტული ფუნქცია მოუწოდა რაღაც.
თუ ჩვენ არ მოგცემთ პროტოტიპი, ამიტომ ამ მთელი რამ აქ,
ეს მთელი სასადილო ეწოდება ფუნქციის დეკლარაციის ან ფუნქციის პროტოტიპი,
ეს არის ერთ ერთი პირველი რამ, რომ თქვენ გსურთ ფრჩხილის ქვემოთ თუ ეს არ აძლევენ
თქვენ დაუყოვნებლივ on ვიქტორინა.
სხვა ხრიკი მე გავიგე ის არის, რომ
ამბობენ ვაკეთებთ მოგცემთ პროტოტიპი for ფუნქცია და ვამბობთ, "ეი, თქვენ მოხვდით დაწერა."
Inside Curly braces რომ თქვენ შესახებ Quiz
თუ თქვენ შეამჩნევთ, რომ არსებობს დაბრუნების ტიპი და თქვენ შეამჩნევთ, რომ დაბრუნების ტიპის
არის რაღაც გარდა ბათილად, რაც იმას ნიშნავს, რომ ფუნქცია არ დააბრუნებს არაფერი,
მაშინ ერთი რამ თქვენ აუცილებლად ჩვენ უნდა დაწეროს
გარკვეული დაბრუნების განცხადება ძალიან ბოლომდე ფუნქცია.
დაბრუნება, და ამ შემთხვევაში, ჩვენ დააყენა ცარიელი რადგან ჩვენ გვინდა შეავსოთ ცარიელი.
მაგრამ ეს იღებს თქვენ მხედველობაში სწორი გზა, თუ როგორ ვარ მე აპირებს მივუდგეთ ამ პრობლემას?
და ეს შეახსენებს თქვენ აპირებთ უნდა დაბრუნდეს ღირებულება
to Caller ფუნქციის.
>> Yeah. >> [სტუდენტური] არა სტილის ვრცელდება როდესაც ჩვენ წერილობით კოდი ვიქტორინა?
როგორიცაა წანაცვლება და რომ მსგავსი საქმიანობები? >> [სტუდენტური] Yeah.
არა, არა როგორც ბევრი.
ვფიქრობ ბევრი-ეს არის რაღაც ჩვენ გაერკვია on ვიქტორინა on დღეს,
მაგრამ, როგორც წესი, შემაშფოთებელია შესახებ # მოიცავს და რომ მსგავსი საქმიანობები, ეს სახის გარეთ.
[სტუდენტური] არის საჭირო კომენტარი თქვენი ხელნაწერი კოდი?
გჭირდებათ, რათა კომენტარი თქვენი ხელნაწერი კოდი?
კომენტირებისას ყოველთვის კარგია, თუ თქვენ აწუხებს ნაწილობრივი საკრედიტო
ან გსურთ დაუკავშირდეს თქვენი განზრახვა კლასის მოსწავლე.
მაგრამ მე, კიდევ ერთხელ, იქნება განვმარტო on ვიქტორინა თავად და ინტელექტუალური დღეს,
მაგრამ მე არ მჯერა, რომ თქვენ უნდა კომენტარის დაწერა, არ.
როგორც წესი არა, მაგრამ ეს აუცილებლად სახის რამ, სადაც
შეგიძლიათ თქვენი განზრახვა, როგორიცაა "Hey, ეს არის სადაც მე ვაპირებ მასთან."
და ზოგჯერ, რაც დაგეხმარებათ ნაწილობრივი საკრედიტო.
ზემოთ.
>> ბასილი.
[ბასილ] რა სხვაობაა გამოცხადების, ვთქვათ, int lang
წელს არგუმენტები ან პარამეტრების წინააღმდეგ გამოცხადების ცვლადი ფარგლებში ფუნქცია?
Wow, ყავა ჩამოიწია windpipe.
[ბასილ] მსგავსად, რომელიც რამ გვინდა დასვა არგუმენტები.
ჰო, დიდი კითხვა.
როგორ აირჩიოს რა რამ გსურთ დასვა არგუმენტები
წინააღმდეგ რა რამ, რაც უნდა გავაკეთოთ შიგნით ფუნქცია?
ამ შემთხვევაში ჩვენ შედის ორივე როგორც არგუმენტები
რადგან ისინი რაღაც რომ ვინც აპირებს გამოიყენოს თანხა ფუნქცია
სჭირდება დაზუსტება იმ რამ.
>> თანხა ფუნქცია, როგორც ჩვენ ვისაუბრეთ, აქვს არანაირად არ იცის
რამდენად დიდი მასივი არის იგი იღებს მისი Caller ან ვინც იყენებს თანხა ფუნქცია.
მას არანაირად არ იცის რამდენად დიდი რომ მასივი არის.
მიზეზი ჩვენ გაივლის ამ სიგრძე უფლება აქ როგორც არგუმენტი
ეს იმიტომ, რომ რაღაც რომ ჩვენ ძირითადად ვეუბნებოდი Caller ფუნქციის,
ვინც აპირებს გამოიყენოს თანხა ფუნქცია, "Hey, არა მხოლოდ გაქვთ მოგვცეს მასივი
საქართველოს ints, თქვენ ასევე უნდა გვითხრან რამდენად დიდი მასივი, რომ თქვენ მოცემულია ჩვენთვის. "
[ბასილ] ის იქნება ორივე იყოს command line არგუმენტები?
არა, ეს არის ფაქტობრივი არგუმენტები, რომ თქვენ გაივლის, რათა ფუნქცია.
>> ნება მომეცით გავაკეთოთ ახალი გვერდი აქ.
[ბასილ] მსგავსად სახელი იქნებოდა გაივლის-
[Nate ჰ] თუ მაქვს int ძირითადი (void),
და მე ვაპირებ დააყენა ჩემი დაბრუნების 0 ქვევით აქ ბოლოში,
და ვთქვათ მინდა მოვუწოდო თანხა ფუნქცია.
მინდა ვთქვა, int x = თანხა ();
იმისათვის, რომ გამოიყენოთ თანხა ფუნქცია უნდა გაიაროს ორივე მასივი რომ მინდა შეაჯამებს
და სიგრძით მასივი, ასე რომ ეს არის სადაც
თუ, რა თქმა მქონდა მასივი ints,
ვთქვა ჰქონდა int numbaz [] = 1, 2, 3,
სახის გამოყენების რომ კალენდარი up სინტაქსის უფლება არსებობს,
მაშინ რა იქნებოდა ეს თანხა მე სურს კორიდორი
ორივე numbaz და ნომერი 3
ვუთხრა თანხა ფუნქცია "Okay, აქ მასივი მინდა თანხა."
"აქ თავისი ზომა."
ამჯამად რომ აზრი? ამჯამად რომ უპასუხოს თქვენს კითხვაზე?
>> ბევრი თვალსაზრისით ეს იმას პარალელურად იმას თუ რას ვაკეთებთ ძირითადი
როდესაც გვაქვს ბრძანება ხაზი არგუმენტები.
პროგრამა მოსწონს კეისრის კოდი, მაგალითად, რომ საჭიროა
ბრძანება ხაზი არგუმენტები არ იქნება ვერაფერს ვერ გააკეთებს.
ეს არ ვიცი როგორ გაშიფრავს თუ არ ვუთხრა ის, თუ რა გასაღები გამოიყენოს
ან თუ არ ვუთხრა ის, თუ რა string თქვენ სურდა დაშიფვრა.
რითაც ამისთვის შეყვანის, ეს არის სადაც ჩვენ მივიღეთ 2 სხვადასხვა მექანიზმების
აღების შეყვანის in საწყისი მომხმარებელი, აღების ინფორმაციის საწყისი მომხმარებელს.
პრობლემის უცნობია 1 დავინახეთ ამ GetInt, GetString, GetFloat გზა
საქართველოს რითაც ამისთვის შეყვანის და რომ ე.წ. გამოყენებით სტანდარტული input stream.
ეს ოდნავ განსხვავებული.
ეს რაღაც, რაც შეგიძლიათ გააკეთოთ, ერთ დროს ნაცვლად
როდესაც თქვენ იძახებთ პროგრამა, როდის გავუშვით პროგრამა გაშვებული.
ბრძანების ხაზი არგუმენტები ყველა არის მითითებული როდის გავუშვით პროგრამა გაშვებული.
ჩვენ ბევრი შერევით ორი იმ.
როდესაც ჩვენ ვიყენებთ არგუმენტები ფუნქცია, ეს ჰგავს ბრძანების ხაზი არგუმენტები ძირითადი.
ეს მაშინ, როდესაც თქვენ იძახებთ ფუნქციას გჭირდებათ ვუთხრა მას
რას მას სჭირდება, რათა შეასრულოს თავისი ამოცანები.
კიდევ ერთი კარგი რამ შევხედოთ და მე მოგცემთ შეხედოთ იგი თქვენს თავისუფალ დროს,
და ეს იყო დაფარული ინტელექტუალური იყო ამ ცნება ფარგლებს
და ადგილობრივი ცვლადები წინააღმდეგ გლობალური ცვლადები.
Do ყურადღება მიაქციონ, რომ.
>> ახლა, როდესაც ჩვენ ვიღებთ შესახებ, რომ ამ სხვა პერსონალი,
წელს კვირა 3 დავიწყეთ ლაპარაკი ძებნას და დახარისხება.
Searching და დახარისხება მაინც, CS50,
არის ძალიან შესავალი ზოგიერთი უფრო თეორიული ნაწილები კომპიუტერული მეცნიერებების.
პრობლემა ძებნა პრობლემა დახარისხება
დიდი, კანონიკური პრობლემები.
როგორ მოვძებნოთ კერძოდ ნომერი მასივი მილიარდობით რიცხვებით?
როგორ მოვძებნოთ კერძოდ სახელი შიგნით სატელეფონო წიგნაკი
რომ ინახება თქვენს ლეპტოპი?
ასე რომ, ჩვენ ამ თანამედროვე ცნება asymptotic პერსპექტივაში ჯერ
ნამდვილად quantify რამდენ ხანს, რა მძიმე ეს პრობლემა არის,
რამდენ ხანს ისინი მოსაგვარებლად.
In, მე მჯერა, 2011 ს ვიქტორინა არსებობს პრობლემა, რომ ვფიქრობ დამსახურებისთვის
დაფარვის ძალიან სწრაფად, რაც ამ ერთი, პრობლემა 12.
O არა, ეს ომეგა.
>> აქ ჩვენ ვსაუბრობთ უსწრაფესად პერსპექტივაში დრო
კონკრეტული ალგორითმი და შემდეგ ნელი შესაძლებელია პერსპექტივაში დრო.
ეს ომეგა და O მართლაც მხოლოდ კომბინაციები.
ისინი notational კომბინაციები ამისთვის ამბობდა
როგორ სწრაფად საუკეთესო შესაძლებელი საქმეს ჩვენი ალგორითმი პერსპექტივაში,
და როგორ ნელა ყველაზე ცუდ შესაძლო საქმეს ჩვენი ალგორითმი აწარმოებს?
მოდით რამდენიმე ამ, და ეს ასევე დაფარული
მოკლე on asymptotic ნოტაცია, რომელიც უაღრესად რეკომენდაციას.
ჯექსონის გააკეთა ნამდვილად კარგ საქმეს.
ერთად ორობითი ძებნა, ვსაუბრობთ ორობითი ძებნა როგორც ალგორითმი,
და ჩვენ, როგორც წესი, ამაზე თვალსაზრისით დიდი ო
რა არის დიდი O?
რა არის ყველაზე ნელი შესაძლებელია პერსპექტივაში დრო ორობითი ძებნა?
[სტუდენტური] N ²?
დახურვა, ვფიქრობ მსგავსი.
ეს ბევრი უფრო სწრაფად, ვიდრე, რომ.
[სტუდენტური] ორობითი? >> Yeah, ორობითი ძებნა.
[სტუდენტური] ეს log N.
შესვლა N, რას შეხვიდეთ n ნიშნავს?
ეს halves იგი ყოველ iteration.
სწორედ ასე ნელი შესაძლო შემთხვევაში,
ამბობენ, თუ თქვენ გაქვთ დახარისხებული მასივი
საქართველოს მილიონ რიცხვებით და ნომერი ვეძებთ
არის ან ძალიან პირველი ელემენტია მასივი ან ძალიან ბოლო ელემენტია მასივი.
გახსოვდეთ, ორობითი ძებნა ალგორითმი მუშაობს ეძებს ახლო ელემენტს,
ხედავს თუ ეს მატჩი, რომ თქვენ ეძებს.
თუ ეს, მაშინ დიდი, თქვენ ი იგი.
>> საუკეთესო შესაძლო შემთხვევაში, თუ რამდენად სწრაფად აკეთებს ორობითი ძებნა პერსპექტივაში?
[სტუდენტთა] 1.
1, ეს მუდმივი დროს, დიდი O 1. Yeah.
[სტუდენტური] მე მაქვს შეკითხვა. როცა ამბობენ, შეხვიდეთ of N, გულისხმობთ მიმართ ბაზის 2, არა?
დიახ, ასე რომ სხვა რამ.
ჩვენ ვამბობთ შესვლა N და, ალბათ, როდესაც მე ვიყავი საშუალო სკოლა
მე ყოველთვის ვივარაუდოთ, რომ ჩანაწერი იყო ბაზა 10.
ჰო, ასე რომ დიახ, შეხვიდეთ ბაზის 2 ტიპიურად არის ის, რაც ჩვენ ვიყენებთ.
ერთხელ, ბრუნდება ორობითი ძებნა, თუ თქვენ ეძებს ან
ელემენტს დროს ბოლომდე ან ელემენტს დასაწყისშივე,
იმიტომ, რომ თქვენ დაიწყოს შუა და მერე გაუქმება
რომელი ნახევარი არ აკმაყოფილებს კრიტერიუმებს, რომ თქვენ ეძებს,
და თქვენ გადასვლა შემდეგ ნახევარი და შემდეგი ნახევარი და შემდეგი ნახევარი.
თუ მე ეძებს უმსხვილესი ელემენტია მილიონი რიცხვი მასივი
მე ვაპირებ HALVE იგი საუკეთესო შესვლა 1 მლნ ჯერ
სანამ საბოლოოდ გამოცდა და ვხედავ, რომ ელემენტს ვეძებ
არის ყველაზე დიდი ან უმაღლესი მაჩვენებელი მასივი,
და რომ მიიღებს შესვლა of n, log 1 მლნ ჯერ.
>> Bubble ჯიშია.
მიგაჩნიათ თუ არა ბიჭები გახსოვთ ბუშტი დახარისხების ალგორითმი?
კევინ, შეგიძლიათ მომეცი სწრაფი recap, თუ რა მოხდა ბუშტი დახარისხების ალგორითმი?
[Kevin] ძირითადად იგი გადის ყველაფერი სიაში.
იგი უყურებს პირველი ორი.
თუ პირველი ერთი მეტია ვიდრე მეორე ეს სვოპების მათ.
მერე ადარებს მეორე და მესამე, იგივე, სვოპების,
მესამე და მეოთხე, ყველა გზა down.
Bigger ნომრები მოჰყვება ბოლომდე.
ხოლო მას შემდეგ, თუმცა ბევრი მარყუჟების თქვენ გაკეთდეს.
სწორედ, ასე რომ კევინ განაცხადა არის ის, რომ ჩვენ უყუროთ უფრო დიდი ციფრები
ბუშტი მდე ბოლოს მასივი.
მაგალითად, თუ თქვენ იბადება ფეხით ჩვენს მეშვეობით მაგალითი თუ ეს ჩვენი მასივი?
[Kevin] თქვენ მიიღოს 2 და 3.
3 მეტია, ვიდრე 2, ასე რომ თქვენ სვოპ მათ.
[Nate ჰ] მარჯვენა, ამიტომ ჩვენ ამ სვოპ, ამიტომ ჩვენ კიდევ 2, 3, 6, 4, და 9.
[Kevin] მაშინ შედარების 3 და 6.
3 მცირეა 6, ასე რომ თქვენ დატოვეთ,
და 6 და 4, ნეტავ სვოპ მათ რადგან 4 მცირეა 6.
[Nate ჰ] მარჯვენა, ასე რომ კიდევ 2, 3, 4, 6, 9.
[Kevin] და 9 მეტია, ვიდრე 6, ასე რომ თქვენ დატოვეთ.
და ნეტავ დაბრუნდეს მეშვეობით კიდევ ერთხელ.
>> [Nate ჰ] მე გაკეთდეს ამ ეტაპზე? >> [Kevin] ჯგუფი
და რატომ ვარ მე არ კეთდება ამ ეტაპზე?
იმის გამო, რომ გამოიყურება ჩემი მასივი დალაგებულია. მე ეძებს მას.
[Kevin] გავლა კიდევ ერთხელ და დარწმუნდით რომ არ არსებობს უფრო სვოპების
სანამ შეგიძლიათ სრულად შეწყვიტოს.
სწორედ, ასე რომ თქვენ უნდა შევინარჩუნოთ გადის და დარწმუნდით, რომ არ არსებობს სვოპების
რომ შეგიძლიათ ამ ეტაპზე.
ეს იყო ნამდვილად უბრალოდ გაუმართლა, ისევე როგორც თქვენ თქვით, რომ ჩვენ დასრულდა
მხოლოდ მქონე რათა 1 გადის და ჩვენ დახარისხებული.
მაგრამ ამის გაკეთება ზოგად შემთხვევაში ჩვენ რეალურად უნდა გავაკეთოთ ეს უსასრულოდ.
და ფაქტობრივად, ეს იყო მაგალითი მაქსიმალურად შემთხვევაში,
მოსწონს ვნახეთ პრობლემა.
ჩვენ ვნახეთ, რომ მაქსიმალურად საქმე n.
ჩვენ გამოვიარეთ მასივი 1 დრო.
რა არის ყველაზე უარესი შემთხვევაში ამ ალგორითმი?
[Kevin] N ².
და რას ჰგავს? რა მასივი გამოიყურება ასე, რომ მიიღებს n ² დრო?
[Kevin] [inaudible] დახარისხებული.
სწორედ ასე რომ, თუ მქონდა მასივი 9, 7, 6, 5, 2,
პირველი 9 დაუჭერთ ბუშტი ყველა გზა მდე.
შემდეგ 1 iteration ჩვენ ავღნიშნო აქვს 7, 6, 5, 2, 9.
მაშინ 7 დაუჭერთ ბუშტი up, 6, 5, 2, 7, 9, და ა.შ. და ა.შ..
>> მე მინდა უნდა გაიაროს მთელი მასივი N ჯერ,
და თქვენ შეგიძლიათ რეალურად მიიღოთ ოდნავ უფრო ზუსტი, ვიდრე ეს
იმიტომ, რომ ერთხელ ჩვენ გადავიდა 9 ყველა გზა მდე თავის ბოლო შესაძლო პოზიცია
ჩვენ ვიცით, რომ ჩვენ არასოდეს არ შეადაროთ წინააღმდეგ რომ ელემენტს ერთხელ.
ერთხელ ჩვენ ვიწყებთ bubbling 7 up
ჩვენ ვიცით, რომ ჩვენ შეგვიძლია შეწყვიტოს ერთხელ 7 არის სწორი, სანამ 9
მას შემდეგ, რაც ჩვენ უკვე შედარებით 9 მას.
თუ თქვენ ამ წელს გონივრული გზა ეს არ ნამდვილად, ვფიქრობ, რომ დიდი დრო.
თქვენ არ ვაპირებთ შედარების ყველა შესაძლო [inaudible] კომბინაციები
თითოეული დროს თქვენ გავლა თითოეულ iteration.
მაგრამ მაინც, როდესაც ვსაუბრობთ ამ ზედა შეკრული ჩვენ ვამბობთ, რომ
რომლებსაც თქვენ ახლა ეცნობით n ² შედარებები ყველა გზას.
>> მოდით დავუბრუნდეთ, და რადგან ჩვენ დაწყებული მისაღებად პატარა მოკლე დროში
მე ვიტყოდი, თქვენ უნდა აუცილებლად გავლა დანარჩენი ამ მაგიდასთან,
შეავსოთ ეს ყველაფერი გარეთ.
იფიქრეთ მაგალითები. იფიქრეთ კონკრეტული მაგალითები.
რომ მართლაც მოსახერხებელი და სასარგებლო უნდა გააკეთოს.
დახაზეთ იგი out.
ეს არის ერთგვარი მაგიდასთან რომ, როგორც თქვენ გავლით კომპიუტერულ მეცნიერებაში
თქვენ უნდა ნამდვილად დაიწყება იცოდეს ამ ზეპირად.
ეს არის სახის კითხვებით თქვენ მიიღონ გასაუბრება.
ეს არის სახის რამ, რომ კარგი იცოდეს,
და ვიფიქროთ იმ ზღვარზე შემთხვევაში, ნამდვილად მჭიდროდაა თუ როგორ ვიფიქროთ
იცოდა, რომ ბუშტი დასალაგებლად ყველაზე უარესი მასივი
დასალაგებლად, რომ არის ერთი რომ წელს საპირისპირო მიზნით.
>> პოინტერები. ვისაუბროთ ცოტა შესახებ მითითებას.
ბოლო რამდენიმე წუთის გვაქვს აქ
მე ვიცი, ეს არის ის ერთად ფაილის I / O, რომ საკმაოდ ახალი.
როდესაც ვსაუბრობთ პოინტერები მიზეზი გვინდა ვისაუბროთ პოინტერები
ეს იმიტომ, ერთი, როდესაც ჩვენ ვმუშაობთ in C
ჩვენ ნამდვილად დროს საკმაოდ დაბალი დონე შედარებით ყველაზე თანამედროვე პროგრამირების ენები.
ჩვენ რეალურად შეუძლია მანიპულირება ცვლადები მეხსიერებაში,
გაერკვნენ, სადაც ისინი რეალურად ფარგლებში მდებარე ჩვენი RAM.
ერთხელ თქვენ ხმარდება მიიღოს ოპერაციული სისტემა კლასების დაინახავთ
რომ ეს არის ის, კიდევ ერთხელ, სახის აბსტრაქცია.
ეს არ არის რეალურად საქმე.
გვაქვს ვირტუალური მეხსიერება, რომელიც იმალებოდა იმ დეტალებს ჩვენთან.
>> მაგრამ ახლა თქვენ შეიძლება ვივარაუდოთ, რომ როდესაც თქვენ პროგრამას,
მაგალითად, როდესაც თქვენ დავიწყოთ გაშვებული თქვენი კეისრის კოდი პროგრამა
მე გადართოთ თავში ჩემი iPad მართლაც სწრაფად-
რომ თავიდანვე თქვენი პროგრამა, თუ გაქვთ, ვთქვათ,
4 გბ მეხსიერება თქვენი ლეპტოპი,
თქვენ მიიღებთ გათვალისწინებულია ამ ბლოკი, და ჩვენ მოვუწოდებთ ამ RAM.
და ეს იწყება ადგილი ჩვენ ვაპირებთ მოვუწოდებთ 0,
და ეს დამთავრდა ადგილზე რომ ჩვენ მოვუწოდებთ 4 გბ.
მე ნამდვილად ვერ წერენ. მამაკაცს, რომ კალენდარი.
როდესაც თქვენი პროგრამა ახორციელებს
ოპერაციული სისტემა carves up RAM,
და ეს მიუთითებს სხვადასხვა სეგმენტების სხვადასხვა ნაწილების თქვენი პროგრამის ცხოვრება შემოსული
Down აქ ამ სფეროში არის სახის არავინ სახმელეთო.
როდესაც თქვენ ახვიდეთ ოდნავ მოშორებით აქ
თქვენ მოხვდით რეალურად ადგილი, სადაც
კოდი თქვენი პროგრამის ცხოვრებაში.
რომ ფაქტობრივი ორობითი კოდი, რომ შესრულებადი ფაილი რეალურად იღებს დატვირთული მეხსიერებაში
როდესაც თქვენ აწარმოებს პროგრამა, და ეს ცხოვრობს კოდი სეგმენტი.
და როგორც შენი პროგრამა ახორციელებს პროცესორი უყურებს ამ კოდექსით სეგმენტი
გაერკვნენ, თუ რა არის შემდეგი ინსტრუქციის?
რა არის შემდეგი ხაზი კოდი უნდა შეასრულოს?
>> არსებობს ასევე მონაცემები სეგმენტის, და ეს არის სადაც სიმებიანი მუდმივები
მისაღებად ინახება, რომ თქვენ უკვე გამოყენებით.
და მაშინ შორს არ არის ეს ადგილი მოუწოდა ბევრი.
ჩვენ შედიხართ მეხსიერების იქ გამოყენებით malloc,
და მაშინ მიმართ ძალიან ზევით თქვენი პროგრამა
არსებობს დასტის,
და რომ სადაც ჩვენ ვთამაშობდი უმრავლესობა დასაწყისია.
ეს არ არის მასშტაბის ან არაფერი.
ბევრი ეს ძალიან მანქანა დამოკიდებული,
ოპერაციული სისტემის დამოკიდებული, მაგრამ ეს შედარებით, თუ როგორ მიიღოთ chunked up.
როდესაც თქვენ აწარმოებს პროგრამა და თქვენ განაცხადოს ცვლადში X-
მე ვაპირებ დახაზეთ მეორე ყუთი ქვემოთ ქვემოთ და ეს იქნება RAM ისევე.
და მე ვაპირებ გამოიყურება.
ჩვენ მიაპყროს Jagged ხაზების მიუთითოს ეს მხოლოდ მცირე მონაკვეთის RAM
და არა ყველა, როგორც ჩვენ მიაპყროს ზედა.
>> თუ ვაცხადებ მთელი ცვლადში x,
მაშინ რა რეალურად კიდევ არის რუკების
რომ ინახება სიმბოლო მაგიდასთან ჩემი პროგრამა
რომ აკავშირებს სახელი x ამ რეგიონში მეხსიერება, რომ მე შედგენილი
სწორედ აქ შორის ვერტიკალური ბარები.
თუ მაქვს ხაზი კოდი ჩემი პროგრამა, რომელიც ამბობს x = 7
პროცესორი იცის "ოჰ, okay, მე ვიცი, რომ x ცხოვრობს ამ ადგილას მეხსიერებაში."
"მე ვაპირებ წავიდეთ წინ და დაწეროთ 7 არსებობს."
როგორ ვიცით რა საიდან ეს მეხსიერებაში?
ისე, რომ ყველა კეთდება კომპილირების დროს.
შემდგენელი ზრუნავს გამოყოფის სადაც თითოეულ ცვლადების აპირებს
და შექმნა სპეციალური რუკების ან საკმაოდ დამაკავშირებელი წერტილების
შორის სიმბოლო და სადაც ეს ხდება, ცვლადი სახელი
და სად ხდება ცხოვრება მეხსიერება.
მაგრამ აღმოჩნდება, რომ ჩვენ შეგვიძლია რეალურად ვებგვერდზე ჩვენს პროგრამებს ისევე.
ეს იღებს მნიშვნელოვანია, როდესაც ჩვენ ვიწყებთ საუბარს ზოგიერთი მონაცემები სტრუქტურების,
რომელიც კონცეფციას, რომ ჩვენ ვაპირებთ დანერგვა შემდგომში.
>> მაგრამ ახლა, თუ რა შეგიძლიათ ვიცი ის არის, რომ მე შეგიძლიათ შექმნათ კურსორი ამ ადგილას, x.
მაგალითად, მე შეიძლება შექმნათ კურსორი ცვლადი.
როდესაც ჩვენ შევქმნით მაჩვენებელი ცვლადი ვიყენებთ ვარსკვლავი ნოტაცია.
ამ შემთხვევაში, ეს ამბობს მე ვაპირებ შექმნას მომცეთ int.
ეს ტიპი, ისევე, როგორც ნებისმიერი სხვა.
ჩვენ ეს ცვლადი, როგორიცაა Y,
და მაშინ ჩვენ ვაყენებთ მას ტოლი მისამართი, რათა მისამართზე.
ამ შემთხვევაში, ჩვენ შეგვიძლია მითითებული Y აღვნიშნო, X
აღებით მისამართი x, რომელსაც ჩვენ გავაკეთებთ ამ ampersand,
და მაშინ ჩვენ დავსახეთ Y აღვნიშნო მას.
რა ამ არსებითად ამჯამად არის თუ შევხედავთ ჩვენი RAM
ამ ქმნის ცალკე ცვლადი.
იგი აპირებს ეძახით Y,
და როდესაც ამ ხაზი კოდი ახორციელებს
სინამდვილეში აპირებს შექმნას პატარა მაჩვენებელი, რომელიც ჩვენ, როგორც წესი, მიაპყროს როგორც arrow,
და ის ისეთ Y აღვნიშნო, რომ x.
დიახ.
[სტუდენტური] თუ x არის უკვე მაჩვენებელი, რომ თქვენ უბრალოდ
int * y = x ნაცვლად, რომელმაც ampersand?
დიახ.
თუ x არის უკვე კურსორი, მაშინ როდესაც თქვენ დააჭერთ 2 პოინტერები თანაბარი ერთმანეთს,
ამ შემთხვევაში Y არ აღვნიშნო, რომ X,
მაგრამ ეს არ აღვნიშნო, რომ რაც არ უნდა X-ის მიუთითებს.
სამწუხაროდ, ჩვენ გარეთ დრო.
>> მე ვიტყოდი, ამ ეტაპზე, ჩვენ შეგვიძლია ვისაუბროთ ამ ფორუმზე,
მაგრამ მე ვიტყოდი, დაიწყოს მუშაობა ამ პრობლემის, # 14.
ხედავთ უკვე ცოტა შევსებული თქვენთვის აქ.
თქვენ ხედავთ, რომ როდესაც ვაცხადებთ, 2 პოინტერები, int * x და * Y,
და გაითვალისწინოთ, რომ მიანიშნა * შემდეგ ცვლადი იყო რაღაც, რომ გაკეთდა შარშან.
თურმე ეს მსგავსი იმას თუ რას ვაკეთებთ წელს.
არ აქვს მნიშვნელობა, სადაც თქვენ დაწერეთ * როცა თქვენ გამოცხადების მაჩვენებელი.
მაგრამ ჩვენ კარგად გვაქვს წერილობითი * შემდეგი ტიპის
იმიტომ, რომ ხდის ძალიან მკაფიო, რომ თქვენ გამოცხადების მაჩვენებელი ცვლადი.
თქვენ ხედავთ, რომ გამოცხადების 2 პოინტერები გვაძლევს 2 ყუთები.
აქ, როცა ჩვენ დავსახეთ x ტოლია malloc
რა ამ ამბობს განსაზღვრავს განზე მეხსიერება ბევრი.
ეს პატარა ყუთი უფლება აქ, ამ წრის, მდებარეობს ბევრი.
X-ის მიუთითებს მას.
გაითვალისწინეთ, რომ Y კვლავ არ მიუთითებს არაფერი.
იმისათვის რომ მეხსიერების შესანახად ხმების 42 შევიდა x
ჩვენ ვიყენებთ რა ნოტაცია?
[სტუდენტური] * x = 42.
სწორედ * x = 42.
ეს იმას ნიშნავს, დაიცვას arrow და გადაყარეთ 42 იქ.
აქ, სადაც ჩვენ მითითებული Y-სა და x ჩვენ Y მიუთითებს x.
ისევ და ისევ, ეს მხოლოდ მსგავსი იმისა, კევინ განაცხადა, სადაც ჩვენ მითითებული Y ტოლია x.
Y არ არის მიუთითებს x.
უფრო მეტიც, ის მიუთითებს, რა X-ის მიუთითებს ასევე.
>> და მაშინ საბოლოოდ ამ ბოლო ყუთში არსებობს 2 შესაძლო რამ, რომ ჩვენ შეგვიძლია გავაკეთოთ.
ერთი შეიძლება ითქვას * x = 13.
სხვა რამ არის შეიძლება ითქვას-Alex, იცით, რაც ჩვენ შეიძლება არ აქ?
თქვენ შეიძლება ითქვას * x = 13 ან-
[სტუდენტური] თქვენ შეიძლება ითქვას, int რასაც.
[Nate ჰ] თუ ეს იყო მოხსენიებული, როგორც int ცვლადი, ჩვენ შეგვიძლია გავაკეთოთ, რომ.
ჩვენ შეგვიძლია აგრეთვე ამბობენ * Y = 13 რადგან ისინი ორივე მიუთითებს იმ ადგილას,
ამიტომ ვერ გამოიყენოთ ცვლადი მისაღებად არსებობს.
Yeah. >> [სტუდენტური] რას უნდა გამოიყურებოდეს თუ ჩვენ უბრალოდ, ვამბობთ int x არის 13?
იქნებოდა გამოცხადების ახალი ცვლადში x, რომელიც არ მუშაობს.
გვსურს აქვს შეჯახება, რადგან ჩვენ განაცხადა x იყოს მაჩვენებელი აქ.
[სტუდენტური] თუ ჩვენ უბრალოდ ჰქონდა, რომ განცხადება თავად რას უნდა გამოიყურებოდეს თვალსაზრისით წრე?
თუ ჩვენ გვქონდა x = 13 მაშინ ჩვენ ავღნიშნო აქვს ყუთი, და ვიდრე მქონე arrow
გამოდის ყუთი მინდა შევაჩერო ის როგორც მხოლოდ 13.
[სტუდენტური] ყუთში. Okay.
>> გმადლობთ თვალს, და გისურვებთ წარმატებას Quiz 0.
[CS50.TV]