>> [მუსიკალური სათამაშო]
>> Davin: ყველა უფლება, ბიჭები.
ასე რომ ეს არის მიმოხილვა პირველი ვიქტორინა.
ყველას მზად ვიქტორინა ოთხშაბათს?
ALLISON: Woo!
სტუდენტი: Woo!
Davin: ჰო.
ALLISON: Yeah!
Davin: ეს ბიჭი მზად.
რომ ბიჭი, ორიდან, ლამაზი.
ასე ინტელექტუალური მიმოხილვა დღეს, ის აპირებს უნდა იყოს დაახლოებით საათი და ნახევარი.
ჩვენ ვაპირებთ, რომ წავიდეთ ყველა ძირითადი ცნებები თქვენ უნდა იცოდეს, რომ ვიქტორინა.
ჩვენ ვაპირებთ წავიდეთ მეტი რამდენიმე კოდირება მიერ ხელის მაგალითები, რომლებიც ყოველ ვიქტორინა.
და თუ თქვენ გაქვთ შეკითხვები, მოგერიდებათ გაზარდოთ თქვენი მხრივ, და ყველაფერი
როგორიცაა, რომ.
ასევე, ლოჯისტიკა შესახებ ვიქტორინა ხაზზე.
ამიტომ, ჩვენ ვაპირებთ, რომ გაყოფილი ხალხი up სხვადასხვა ოთახებში.
ის ეფუძნება მათი სახელი.
ასე რომ, თუ თქვენ გაქვთ რაიმე შეკითხვები, სადაც წასვლა ან იმაზე, თუ რა მასალა, როგორიცაა,
ოფიციალური სიტყვა რა ხდება უნდა იყოს ინტელექტუალური, შეამოწმეთ ონლაინ რეჟიმში.
და ეს ყველაფერი დღემდე.
ასე რომ, თუ არ არსებობს შეკითხვები დასაწყისისთვის, ჩვენ ვაპირებთ დავიწყოთ.
და აქ Allison.
>> [Claps]
>> ALLISON: OK, მადლობა, Rob.
ვაფასებ მას.
Davin უნდა flipped ამ.
ეს არის არასამთავრობო ამომწურავ ჩამონათვალს, თემა, როგორც ყოველთვის, როგორც Davin უბრალოდ განაცხადა.
გაეცანით დოკუმენტაციას ონლაინ შესახებ ვიქტორინა ნულოვანი.
მაგრამ ეს არის საკმაოდ ბევრი ეს არის ის სილაბუსი
არის ყველაფერი ჩვენ წავიდა დღემდე.
ყველაფერი აქ არის სამართლიანი თამაში, ისევე როგორც არაფერი
რომელიც შეიძლება უკვე აღნიშნული ლექცია.
>> ჩემს განყოფილებაში, აქ, უბრალოდ ბევრი მიმოხილვა.
არსებობს რამდენიმე წვრთნები რომ თქვენ ბიჭები შეიძლება მუშაობა.
მაგრამ უმეტესწილად, ჩვენ ნამდვილად გვინდა Davin იმ კოდი
ხელით წვრთნები.
>> ამიტომ, მე ვაპირებ, რომ ფრენა მეშვეობით.
თუ თქვენ გაქვთ რაიმე შეკითხვები, შეწყვიტოს ჩემთვის.
გაზარდოთ თქვენი მხრივ.
მე გპირდებით, რომ მე, ალბათ, რომ თქვენ.
თუ არ გამოვიდა, ტალღა ირგვლივ.
მე ვაპირებ უნდა ვსაუბრობთ სწრაფად.
იმედი მაქვს, ყველას კარგად რომ.
>> OK, სპეციალური სიტყვა, Davin აშკარად დაავიწყდა Flip მეშვეობით ეს სლაიდები.
[იცინის] თქვენ პრობლემები, კაცი.
ასე რჩევები ვიქტორინა ნულოვანი, პრაქტიკაში კოდირების ქაღალდზე.
თქვენ ბიჭები ვაპირებთ, რომ რაღაც პრაქტიკაში, რომ ახლა Davin,
ასე რომ თქვენ არ იქნება მთლიანად თავს.
მე ვფიქრობ, რომ ჩვენ რეალურად აპირებს ამ ორი ფუნქციები.
ასე რომ თქვენ უნდა კარგად მომზადებული იყო.
>> იყოს იცნობს თქვენი პრობლემა კომპლექტი.
არ ყოფილა შეკითხვები წინა ტესტები
რომ მოგთხოვთ, მაგალითად, კოდექსში რაღაც ძალიან გავს Mario.
ასე რომ, ძალიან კარგად იცნობს თქვენი პრობლემა ადგენს, ასევე
როგორც ჩვენს მიერ დასმულ კითხვებს თქვენ დასაწყისში on ფორმა
რომ თქვენ შეავსოთ, ნება ემსახურება თქვენ ძალიან კარგად.
>> ნუ წინა ვიქტორინა ქვეშ დრო შეზღუდვების.
ეს ტესტები ხანგრძლივი.
დრო გადის მართლაც სწრაფი.
და ხშირად, თქვენ არ ესმოდეს, თუ როგორ სწრაფად მიდის, სანამ თქვენ ნამდვილად
დააყენა თავს ქვეშ იმ შეზღუდვების.
ასე რომ, თუ თქვენ შეგიძლიათ უბრალოდ გაიყო, თქვენ იცით, 75-ე წუთზე, ან დღეს ან ხვალ
მიიღოს ერთი ამ ტესტებში ქვეშ ის, რომ თქვენ უნდა იყოს ბევრად უკეთესი ფორმა.
>> და ასევე, ქმნის თქვენი მინიშნება ფურცელი.
გახსოვდეთ, თქვენ გაქვთ ერთი გვერდი წინა და უკანა
როგორც მინიშნება თქვენი Quiz ოთხშაბათს.
შექმნა, რომელიც დიდი გზა შესწავლა.
ყველაფერი, რაც თქვენ მქონე უბედურება თქვენ გსურთ მოიცავს იქ.
რამე რომ თქვენი TFs არ ყოფილა, ისევე, როგორც ეს მართლაც მნიშვნელოვანია.
თქვენ უნდა იცოდეს, არის იქნებ გაქვს იქ
თუ თქვენ არ აქვს მათ მეხსიერებაში.
მაშინაც კი, თუ თქვენ იცით მათ ნამდვილად ასევე, ზოგჯერ, რომელსაც იგი იქ
მხოლოდ სახის კომფორტი თქვენთვის, რაც მე ვიცი, ტესტები სტრესული.
ასე რომ, ნებისმიერ კომფორტს თქვენ შეუძლია დაეხმაროს.
ყველა უფლება, ასევე, ძილის და ჭამა და მინდა ჩვეულებრივი რამ
ჩვენ გეტყვით, ტესტები.
>> ასე იწყება off ადვილი, მონაცემთა ტიპის და ზომის.
როგორც ვთქვი, ეს მხოლოდ აპირებს უნდა მე სროლა ბევრი პერსონალი
აქ რომ თქვენ უნდა იცოდეს.
ასე რომ, ჩვენ გვაქვს ჩვენი chars რომ არის ერთი ბაიტი, ints
რომ ოთხი ბაიტი, ხანგრძლივი ხანგრძლივი, რომლებიც რვა ბაიტს.
ძირითადად, ეს მხოლოდ თქვენ მინდა გამართავს დიდი რიცხვებით.
მოძრავი, რომელიც ოთხი, ორადგილიანი, რომელიც რვა.
ერთხელ, გაძლევთ მეტი სივრცეს მოძრავი.
და შემდეგ ჩაწერეთ ვარსკვლავი, ასე რომ ნებისმიერი კურსორი on 32-bit მანქანა,
რომელიც ყველა თქვენ ბიჭები უნდა იცოდეს, რომ ოთხი ბაიტი.
>> ასე რომ ყველაფერი თქვენ უნდა ვიცი, ალბათ ყველაფერი
გსურთ აქვს თქვენი მინიშნება ფურცელი.
OK, ორობითი კონვერტაციის ორობითი, კონვერტაციის
თექვსმეტობითი, უკან და მეოთხე, ყველაფერი უნდა იცოდეს.
ასე ორობითი ათობითზე.
თქვენ ბიჭები უნდა მიიღოს სწრაფი წუთი და ცდილობენ და გაერკვნენ, თითოეული ამ
და მაშინ მითხარით რა არის?
>> მე ასევე candy ჩემი ჩანთა, ასე რომ ყველას რომელიც პასუხობს იღებს candy, სხვათა შორის.
და მაქვს უამრავი იგი.
ნება მიბოძეთ აითვისებდა ეს.
მე ვაპირებ, რათა ეს Gabe.
ასე რომ თქვენ შეგიძლიათ გადასცემს კანფეტი ვინც არის ლამაზი და კოოპერატივი.
>> OK, ვნახე მხრივ იქ უკან.
>> სტუდენტი: ჰო, პირველი 42 წლისაა.
>> ALLISON: დიახ, პირველი არის 42 სწორი.
სტუდენტი: [INAUDIBLE].
[სიცილის]
ALLISON: მეორე, არსებობს უკან ყვითელი?
სტუდენტი: 110010.
ALLISON: სწორი, და ეს ბოლო ერთი, ქვევით აქ ბოლოში?
ასევე, yeah, თქვენ იცით, თუ გინდათ?
უბრალოდ toss out candy.
როგორ შესახებ candy ყველასთვის?
>> სტუდენტი: [INAUDIBLE] როდესაც ჩვენ გავაკეთეთ.
>> ALLISON: Shh.
და შემდეგ ბოლო ერთი.
ვისაც სურს, რომ პასუხი?
უფლება არსებობს.
>> სტუდენტი: 11100.
>> ALLISON: 11100, შევხედოთ, რომ.
გილოცავთ, დიდი სამუშაო, ყველას.
OK, ყველა სახის მესმის, პროცესი ამით?
თქვენ, მიმდინარეობს ორობითი ათობითზე სხვათა შორის, მე, როგორც წესი, ამის გაკეთება, წერს out
უფლებამოსილების 2.
ამიტომ ვამბობ, OK, 0-ჯერ 2: 0, ასე ეს არის 0, 1 ჯერ 2, პირველ რიგში,
2 აპირებს მოყოლებული, რომ გზა.
ვინმეს სურს მე პირდაპირ გავლა მაგალითი ორობითი?
OK, ზემოთ.
>> ათობითი რომ ორობითი ძალიან ჰგავს.
მე, როგორც წესი წერენ, უფლებამოსილება 2.
იწყება ერთი, რომ ყველაზე დიდი, მაგრამ არ წავიდეთ წარსულში ათობითი
რომ თქვენ ეძებს.
და შემდეგ სახის მუშაობა თქვენი გზა უკან დასძინა რამ, როგორც საჭიროა.
>> და შემდეგ ამისა, ის ისევე, როგორც ნორმალური გარდა.
თუ ოდესმე იმ შემთხვევაში, თუ თქვენ დამატებით ორი 1s, აშკარად ხდება 2.
2 ორობითი არის 1 0 ასე რომ თქვენ უნდა განახორციელოს თქვენი 1 მომდევნო სვეტი.
ზემოთ.
>> თექვსმეტობითი, ეს შეიძლება იყოს რაღაც რომ ოდნავ ნაკლებად იცნობს.
ისე, რობ უბრალოდ მეუბნებოდა წინასწარ მისი ხრიკი ამ
უბრალოდ გაყოფილი up ოთხი ბაიტი მოცულობით, OK?
Bits, უკაცრავად.
ვხედავ?
მადლობა რობ.
სწორედ ამიტომ, თქვენ აქ. [ხმაური] OK, ასე რომ ჩვენ უბრალოდ შესვენება ეს
ოთხი ბიტი მოცულობით.
ასე binaries თექვსმეტობითი, ჩვენ შევხედოთ პირველი 4,
რომელიც, თუ ჩვენ გვაქვს ოთხი 1s in a row, თუ რა რაოდენობის ჯერ, რომ სიმბოლოს?
>> სტუდენტი: F.
>> ALLISON: ასე რომ, ამ შემთხვევაში, რა არის 11111111 or-- yes?
სტუდენტი: FF.
ALLISON: Perfect, FF.
იმდენად დიდი, candy თქვენთვის.
ახლა, როგორ თექვსმეტობითი ორობითი, ჩვენ უბრალოდ დაფიქრდით სახის საპირისპირო.
თითოეული ნომერი ან წერილი, რომელიც ჩვენ გვაქვს ჩვენი თექვსმეტობითი,
მხოლოდ გარდაქმნას იგი მისი ოთხი bit [იცინის] მისი ოთხი ცოტა კონვერტაციის.
ასე რომ, 5, ამ შემთხვევაში, რა არის 5 თუ ჩვენ წარმოადგენს, ოთხი ბიტი?
>> სტუდენტი: 010?
მმ-hm.
და შემდეგ, რაც რეალურად, 10 იქნება?
1010.
ასე რომ, ჩვენ, რომ აქ.
ასე კონვერტაცია შორის თექვსმეტობითი ორობითი რეალურად არ არის, რომ ცუდი.
თუ თქვენ შეხედეთ მას ოთხი bit მოცულობით, იქნება ოქროს.
Everyone-- yes?
>> ROB: ეს არის სულელური, მაგრამ მე ყოველთვის გვახსოვს,
მას შემდეგ, რაც ის უნდა იყოს 10.
ორობითი უბრალოდ 10 10, so--
>> ALLISON: Ah, იქ ჩვენ წავიდეთ.
>> ROB: Hey.
>> ALLISON: Hey, კანფეტი Rob.
არსებობს არასამთავრობო შოკოლადის პერსონალი იქ.
ასე, რომ თქვენ შეიძლება ჰქონდეს.
ასე ASCII მათემატიკის.
მოიქცეს.
ასე ASCII მათემატიკის, როგორც თქვენ ბიჭები ალბათ კარგად გახსოვთ,
p მითითებული 2 Visioneer და Caesar, თქვენ ბევრი რამ ამ.
მახსოვს, სიმბოლოები ფუნდამენტურად მხოლოდ ციფრები.
ამიტომ ჩვენ შეგვიძლია გავაკეთოთ math მათ, ისევე, როგორც ჩვენ ვაკეთებთ მათემატიკის ints.
>> ასე რომ, ჩვენ უბრალოდ პატარა მარტივი რამ აქ.
ჩვენ გვაქვს ზოგიერთი, რომ ეს ინიციალიზაცია 65.
და B ტოლია ASCII ღირებულება პლუს 1, char C ტოლი D მინუს 1,
და char D ტოლი 68.
ასე რომ მაშინ ჩვენ ვაპირებთ ბეჭდვა ყველა მათგანი, როგორც ვხედავთ აქ.
და შეიძლება ვინმეს მითხრათ ის, რაც ამ ამობეჭდოთ?
სტუდენტი: [INAUDIBLE].
ALLISON: სწორედ ასე ერთი რამ შეამჩნია,
რომ ჩვენ ბეჭდვა პერსონაჟების ყოველ დროს, აქ.
ჩვენ აღმნიშვნელი მიუხედავად იმისა, რომ A და B არის ints როდესაც ჩვენ განაცხადა, მათ ზემოთ.
ჩვენ ვბეჭდავთ მათ, როგორც გმირები პროცენტი C და ჩვენი printf განცხადება,
ასე რომ, ისინი ყველა ბეჭდვა სიმბოლო.
და რა თქმა უნდა, ASCII ღირებულების 65 ბეჭდვა ა ASCII ღირებულება პლუს 1
იქნება 66, რომლების ვამაყობ, რომ B. ასე რომ, ფაქტობრივად, ჩვენ
მიიღეთ A B C დ ყველას კარგი არსებობს?
ნებისმიერი კითხვები?
გასაოცარია.
>> OK, ფარგლებს.
ასე ფარგლებს აშკარად ძალიან მთავარია გვესმოდეს, აქ.
ბევრი თქვენგანი, თუ აქვს შედგენის შეცდომები,
და ამბობს, თქვენ არ გაქვთ ხელმისაწვდომობა რამდენიმე ცვლადი,
ეს, ალბათ, იმიტომ, რომ თქვენ განსაზღვრა განმავლობაში ციკლი
და შემდეგ შევეცადეთ ვებგვერდზე გარეთ, ან პირიქით.
>> ასე ფარგლებს მისი ძირითადი, ის მხოლოდ განსაზღვრავს, სადაც
ჩვენ ვამბობთ, ცვლადი არსებობს, სადაც ჩვენ შეუძლია შეცვალოს ის, სადაც ჩვენ შეუძლია ეს.
ეს მხოლოდ სახის განაცხადა, რომ ეს არის მხოლოდ ის ადგილები, სადაც თქვენ გაქვთ
ამ ცვლადში.
>> ასე რომ, ორი ფარგლები, რომ ჩვენ ვსაუბრობთ დროს კლასი გლობალური და ადგილობრივი.
ასე გლობალური ცვლადები ვსაუბრობთ როდესაც თქვენ განსაზღვრის მათ ზემოთ ძირითადი.
ეს ნიშნავს, რომ თქვენი პროგრამას აქვს დაშვება,
და ის არსებობს, სანამ როგორც პროგრამა ეშვება, OK?
ადგილობრივი ნიშნავს, რომ ის უფრო შემოიფარგლება რეგიონში.
ასე რომ, როდესაც თქვენ გაქვთ კონკრეტული ფუნქციები როგორიცაა სვოპი, ჩვენ ყოველთვის ვსაუბრობთ.
ჩვენ ყოველთვის საუბრობენ გამოცვლას და B. A და B არსებობა, რომ ფუნქცია.
არ არსებობს არსად.
>> ასევე, როდესაც თქვენ გაქვთ თუ განცხადებები და მარყუჟების.
როცა კი გვაქვს, მაგალითად, ამისთვის მარყუჟის, ჩვენ გვაქვს int i უდრის 0.
ჩვენ გვაქვს გარკვეული მდგომარეობა და განახლება.
მე მხოლოდ არსებობს ფარგლებში braces რომ loop.
თუ თქვენ ცდილობენ, რათა შეამოწმონ იგი სხვაგან, თქვენი შემდგენელი რომ დაწეროთ თქვენ.
ეს მინდა იყოს, რას ცდილობთ?
ეს არ არსებობს.
ასე რომ, ეს ორი სხვადასხვა სახის ფარგლებს.
ამჯამად რომ აზრი ყველას?
>> ასე მაგალითად, აქ, ამ არის რამოდენიმე მარტივი პროგრამა.
რა ბიჭები ვფიქრობ, რომ მოხდება თითოეული წერტილი
რომ ჩვენ ვცდილობთ ბეჭდვა?
ასე რომ, ეს ერთი აქ, რა მოხდება?
სტუდენტი: ეს იქნება ბეჭდვა სამ.
ALLISON: Right.
ეს კიდე ბეჭდვა სამ.
რაც შეეხება აქ?
სტუდენტი: ეს არ იმუშავებს.
ALLISON: ეს არ იმუშავებს.
თქვენ ფარგლებს, არა?
ადგილობრივი ცვლადი არ არსებობს გარეთ ამ braces, ყველა უფლება?
და მერე რა აქ?
>> სტუდენტი: [INAUDIBLE].
>> ALLISON რა?
ძარცვა, წავიდეთ.
>> ROB: მე უბრალოდ განაცხადა.
გლობალური ცვლადები უნდა იყოს გლობალური ხაზს ცვლადი.
>> ALLISON: Ah, დიახ, უკაცრავად.
მადლობა, Rob.
რობ, როგორიცაა ჩვენი რეზიდენტი შემდგენელი.
ის უბრალოდ დაწეროთ, როდესაც ჩვენ სჭირდება. [იცინის] დიახ,
უნდა იყოს გლობალური ხაზს ცვლადი.
ასე ვთქვათ, რომ გლობალურ ხაზგასმა
ცვლადი, რა მოხდება აქ?
სტუდენტი: ეს იმუშავებს.
ALLISON: ეს ვიმუშავებთ.
ასე რომ თქვენ ბეჭდვა, ისე უბრალოდ ძალიან მარტივი მაგალითი.
OK, პროტოტიპები.
ამიტომ ცხადია, რომ ჩვენ მართლაც ხაზს ვუსვამთ, თქვენ ბიჭები
რათა ფუნქციები, თუ იგი აზრი თქვენს პროგრამებში.
რა თქმა უნდა, როდესაც თქვენ რათა საკუთარი ფუნქციები,
როგორც წესი, თქვენ განსაზღვროს მათ შემდეგ რჩება.
და თქვენ ცდილობენ მოვუწოდებთ მათ მთავარ.
და თუ თქვენ არ იყენებთ პროტოტიპი, თქვენი კომპილატორი დაწეროთ თქვენ.
>> Prototype ძირითადად უბრალოდ ვეუბნებოდი თქვენი შემდგენელი
რომ მაქვს ეს ფუნქცია ქვემოთ ძირითადი.
მე ვაპირებ მოვუწოდო, რომ სანამ მე განსაზღვრავს მას.
მხოლოდ გაიმართება.
მე გპირდებით, რომ ეს არ არის განსაზღვრული, და თქვენ გექნებათ ყველაფერი, რაც გჭირდებათ.
>> ასე ვაკეთებთ, რომ ეს მხოლოდ თქვენი დაბრუნება ტიპის, თქვენი ფუნქციის სახელი, თქვენი წვლილი
სიაში.
ეს, ძირითადად, პირველი ხაზი თქვენი ფუნქცია დეკლარაცია.
ეს მართლაც ყველა ეს.
მაგრამ ეს მხოლოდ ზოგადი სახის ფორმატში.
>> ასე, რომ ჩვენს მაგალითში, რომელიც თქვენ ბიჭები უნდა
არ მინახავს ნაწილში რაღაც მომენტში, ჩვენ გვაქვს
ზოგიერთი int cube, რომ სჭირდება გარკვეული int შეყვანის.
და ჩვენ გვაქვს ჩვენი მთავარი ფუნქცია, რომელიც მოუწოდებს კუბი.
და კუბი განისაზღვრება შემდეგ ფაქტი.
>> ასე რომ, თუ ჩვენ არ გვაქვს int cube input ზედა, როდესაც ჩვენ მოუწოდა კუბი
ფარგლებში ძირითადი, ჩვენი შემდგენელი დაიჭერს შეშლილი us.
ეს მინდა იყოს, რა ვსაუბრობთ?
Cube არ არსებობს.
მე არ ვიცი, რა თქვენ ითხოვს.
და მე უბრალოდ აპირებს გაჩერება.
>> არამედ იმიტომ, რომ ჩვენ გავაკეთეთ ჩვენი პროტოტიპი ზედა, ჩვენ ვთქვით,
თქვენ იცით, როდესაც თქვენ ხედავთ, cube, არ აღელვებს ეს.
მე გპირდებით, რომ განსაზღვრული მოგვიანებით.
და ეს თქვენ მოგცემთ, რაც თქვენ გჭირდებათ.
ასე რომ, თუ თქვენ ოდესმე ფუნქცია რომ განაცხადა, მას შემდეგ, რაც თქვენ ეძახით
პირველად, თქვენ უნდა აქვს მას prototyped ზედა.
>> დიახ?
>> ROB: ეს კვადრატი, არ cubing.
>> ALLISON: Oh ღმერთი ჩემი.
მე არ ჰქონდეს Gabe, ვფიქრობდი, თქვენ იყავით ჩვენი proofreader.
OK ბიჭები, ეკისრება ჩემთან, აქ.
იმედი მაქვს, ყველას მიღების იდეა.
OK, ასე რომ, ეს უნდა ჰქონდეს უკვე კვადრატში, არა cubed.
მაგრამ იდეა იგივე რჩება.
ნებისმიერი ფუნქცია, რომ ჩვენ მოუწოდებდა შემდეგ ის ფაქტი, უნდა ჰქონდეს პროტოტიპი.
ყველას კარგი რომ?
ნებისმიერი სხვა typos?
OK.
ნებისმიერი typos აქ სანამ ჩვენ ვიწყებთ, რობ?
[იცინის] OK, ასე რომ structs.
ძირითადად, structs საშუალებას გაძლევთ შექმნათ თქვენი საკუთარი მონაცემები ტიპის.
იმდენად მოსწონს int ან char ან float, ეს არის კიდევ ერთი ტიპის.
მე მიყვარს ვფიქრობ, რომ ეს, ისევე, შექმნათ თქვენი საკუთარი მონაცემები ტიპის.
ასე რომ, ეს საშუალებას გაძლევთ ამის გაკეთება.
და მას აქვს სხვადასხვა ტიპის მონაცემები.
>> ასე რომ, თუ გახსოვთ, მასივი, ჩვენ შეიძლება მხოლოდ გამართავს რამ მსგავსი ტიპის.
Structs საშუალებას გვაძლევს გამართავს მრავალჯერადი რამ სხვადასხვა სახის.
ასე რომ, ამ შემთხვევაში აქ, ჩვენ აქვს struct მოუწოდა სტუდენტი
სახელად აქ ბოლოში.
და ჩვენ გვაქვს int id და ზოგიერთი სიმებიანი სახელი.
ასე რომ, ეს არის კიდევ ერთი მონაცემები ტიპის.
ახლა ჩვენ გვაქვს მონაცემები ტიპის მოუწოდა სტუდენტი.
>> ასე რომ, რადგან ჩვენ შეგვიძლია ვიფიქროთ, როგორც მხოლოდ სხვა მონაცემები ტიპის,
ჩვენ შეგვიძლია განაცხადოს ცვლადები როგორც ჩვენ გვინდა სხვა.
ასე რომ ნაცვლად მხოლოდ მქონე, ისევე, int აბიტურიენტი, ჩვენ უბრალოდ სტუდენტი,
სტუდენტი 1.
Oh, შეხედეთ.
ეს Rob.
ასე რომ, აქ ჩვენ ვაცხადებთ struct, და ცვლადი
ე.წ. სტუდენტი 1 ტიპის სტუდენტი.
ასე რომ, ეს აპირებს id და სახელი ასოცირდება იგი.
>> და გზა ჩვენ შედიხართ ამ ელემენტების ფარგლებში ჩვენი struct
ერთად dot ოპერატორი, აქ.
ასე რომ, ამ შემთხვევაში, ჩვენ განაცხადა ზოგიერთი სტუდენტი 1.
ჩვენ დაავალა ID, 1.
და ჩვენ დაავალა სახელი უნდა იყოს Rob.
OK, ყველას კარგი რომ?
გამოიყენეთ მხოლოდ მოსწონს yes?
>> სტუდენტი: Yeah, typedef-- როდესაც ჩვენ უნდა გამოვიყენოთ typedef?
>> ALLISON: So typedef მხოლოდ ამბობს that-- რობ, თქვენ
შეუძლია შეასწოროს ჩემთვის, თუ მე wrong-- მაგრამ typedef, უბრალოდ რეალურად გამოცხადების
მას, როგორც ტიპის, რომ თქვენ შეგიძლიათ გამოიყენოთ, არა?
>> ROB: ჰო, ის, ძირითადად, ასე რომ, ეს უბრალოდ ქმნის
იგივე, და მეტსახელი ტიპის.
ასე, რომ თქვენ შეგიძლიათ მიუთითოთ, რომ [INAUDIBLE].
ასე რომ, [INAUDIBLE] არსებობს, და ახლა ჩვენ უბრალოდ უნდა
[INAUDIBLE] საშუალება ზუსტად იგივე.
ასე რომ, აქ, ჩვენ აკრეფილი, ვფიქრობ, ზოგიერთი struct ტიპის 2 [INAUDIBLE].
ისე უბრალოდ მეტსახელი მოცემული ტიპის.
>> სტუდენტი: String [INAUDIBLE] ბიბლიოთეკა იყო აკრეფილი, როგორიცაა char ვარსკვლავი.
>> ALLISON: ჩვენი მიზნებისთვის აქ თუ თქვენ გამოცხადების struct,
მხოლოდ ამის typedef struct.
OK, ასე რომ, წინასწარ, რომ ეს არის უბრალოდ ნორმალური ცვლადი აქ.
ჩვენ ვებგვერდზე dot.
თუ ჩვენ გვაქვს მომცეთ struct, ჩვენ შეგვიძლია რეალურად
გამოყენება arrow, რომელიც არის საკმაოდ გრილი.
>> ასე რომ, ამ შემთხვევაში, ჩვენ უნდა მომცეთ სტუდენტი 1, რომელიც ტიპის სტუდენტი.
გახსოვდეთ, თქვენი მაჩვენებელი მშენებლობა,
გსურთ რასაც აკრიფოთ თქვენი მაჩვენებელი მიუთითებს, რომ იყოს დასაწყისში.
ასე რომ, ჩვენ გვაქვს რამდენიმე სტუდენტი 1, აქ.
და რადგან ეს სტუდენტი 1 არის აღნიშნა,
ჩვენ შეგვიძლია რეალურად წასვლა სტუდენტი 1 arrow სახელი ნაცვლად dot, იმიტომ, რომ ეს მაჩვენებელი,
და მივანიჭოთ Rob.
და ახლა, თუ გვინდა, შეცვლა რობ Davin,
ეს უბრალოდ გვიჩვენებს, თუ სხვაგვარად ამის გაკეთება.
>> ასე რომ, ნაცვლად გამოყენებით arrow, შეიძლება also-- I დასრულდება და შემდეგ
მიიღოს, რომ კითხვა, რომ თქვენ შეიძლება ასევე გავაკეთოთ მითითებით სტუდენტი 1.
რომ ვამბობ, როგორიცაა წასვლა რაც არ არის სტუდენტი 1,
იქნება ჩვენი სტუდენტი struct.
ვებგვერდზე dot და ელემენტი გსურთ, და შემდეგ reassign ის.
იყო შეკითხვა.
სტუდენტი: დიახ, ასე როგორ, შენ უნდა გამოიყენოთ [INAUDIBLE] როდესაც თქვენ
სტუდენტი ვარსკვლავი გარეშე [INAUDIBLE] სტუდენტი?
ALLISON: იმიტომ, რომ ეს ქმნის მაჩვენებელი.
ROB: ჩვენ ვაპირებთ საუბარს.
ALLISON: ჩვენ ვაპირებთ, რომ გაიგო რომ მოგვიანებით მიმოხილვა.
ასე რომ, უბრალოდ გამართავს გადატანა, რომ ეგონა.
თუ ეს მაინც აწუხებს ზე ბოლოს, მოვა გაიგო ჩვენგანი.
>> ასე რომ, ეს გააკეთოს ზუსტად იგივე რამ.
ჩვენ უბრალოდ გვიჩვენებს, თუ ორი სხვადასხვა გზა ამის გაკეთება.
სტუდენტი 1 არის მაჩვენებელი, ამიტომ თქვენ შეგიძლიათ თქვათ სახელი ელემენტს
ფარგლებში struct ისარი.
ან შეგიძლიათ dereference თქვენი მაჩვენებელი და შემდეგ შედიხართ, როგორც თქვენ ჩვეულებრივ აკეთებთ.
ამჯამად რომ აზრი ყველა ერთი?
თუ მთელი მაჩვენებელი რამ ცოტა გაუგებარია, Gabe ისაუბრებენ, რომ,
და მაშინ იქნებ ეს გახდის უფრო გრძნობა.
დიახ?
>> სტუდენტი: დიახ, ასე როგორ არის ეს განსხვავდება?
ALLISON: წინა?
ასე რომ, სტუდენტი 1 ამ საქმე არ არის მაჩვენებელი.
ეს მხოლოდ თქვენი ფაქტობრივი struct.
>> სტუდენტი: OK.
>> ALLISON: ვინაიდან ეს ერთი მომცეთ struct.
>> სტუდენტი: OK, მაგრამ ეს ერთგვარი დასრულდება მუშაობა იმავე [INAUDIBLE].
>> ALLISON: ეს ეფექტურად მუშაობს იგივე.
თქვენი სინტაქსი არის უბრალოდ სხვადასხვა.
სტუდენტი: OK.
>> ALLISON: Yeah, ისინი ეფექტურად იგივე.
უბრალოდ დამოკიდებულია კონტექსტში, შეგიძლიათ ერთი მეტი სხვა.
დიახ?
>> სტუდენტი: როცა მითითება 1--
ALLISON: Mm-hm?
სტუდენტი: რატომ ფრჩხილებში?
ALLISON: იმის გამო, სტუდენტი 1 არის მაჩვენებელი.
ასე, რომ თქვენ უნდა დავრწმუნდეთ, რომ თქვენ მხოლოდ dereferencing მაჩვენებელი.
>> სტუდენტი: OK.
>> ALLISON: ასე რომ, ამ შემთხვევაში აქ, ფრჩხილებში გარშემო
იმას ნიშნავს, თქვენ dereferencing სტუდენტი 1.
ასე რომ, თქვენ აპირებს, სადაც სტუდენტი 1 რაოდენობა, რომელიც არის თქვენი struct.
ახლა თქვენ შეგიძლიათ ვფიქრობ, მას, როგორც, რომ struct,
ამიტომ ჩვენ შეგვიძლია გამოვიყენოთ ჩვენი ნორმალური dot ოპერაცია.
ნებისმიერი სხვა კითხვები?
მაგარი, გასაოცარია.
>> ასე რომ, ბოლო რამ, ვფიქრობ, ეს არის ჩემი ბოლო slide, woo!
OK, ასე რომ მცურავი პუნქტიანი ორაზროვნება.
ჩვენ მოკლედ ვისაუბრეთ ამ დროს ლექციას.
ძირითადად, ჩვენ გვაქვს უსასრულოდ ბევრი რეალური ციფრები.
და თუ თქვენ ბიჭები მიყვარს მათემატიკის, არსებობს
ყველა სახის cool პერსონალის ჩვენთან ერთად.
>> მაგრამ არსებობს უსასრულოდ მრავალი რეალური ნომრები.
მაგრამ ისინი მხოლოდ სასრულ ბევრი ბიტი, რომ ჩვენ გვაქვს.
ასე რომ თქვენ ყოველთვის აპირებს აქვს ორაზროვნება, არის ყველა.
და ეს რომ მხოლოდ სახის რაღაც თქვენ უნდა იცოდეს.
რომ ისევე, როგორც ჩვენ შეიძლება გთხოვოთ, რატომ მცურავი პუნქტიანი ორაზროვნება არსებობს?
ასე რომ მხოლოდ ის, რომ თქვენ უნდა იცოდეს.
და რომ, მე გარდამტეხი მას მეტი პოინტერები.
>> Binky: Hello, ბიჭები.
ჩემი სახელის Binky.
მე ვაპირებ ვისაუბროთ პოინტერები.
ჰო, ისე, მითითებას, ფაქტობრივად, ჩემი საყვარელი ნაწილი ამ კურსს.
ასე რომ მხოლოდ ნათელი, თუ რა Allison იყო საუბარი აქ, ასე რომ მიზეზი
why-- ერთადერთი განსხვავება აქ, დიდი განსხვავება იყო გზა
ჩვენ ვაცხადებთ რამ.
ასე სტუდენტი ვარსკვლავი ნიშნავს ეს მომცეთ სტუდენტი.
იმის გამო, რომ slide ადრე, სტუდენტი ფაქტობრივი struct, ფაქტობრივი სტუდენტი,
შეიცავს იმ რამ.
>> და მიზეზი, რის გამოც მინდა, რომელთა მიზანია: დიახ, Davin?
>> Davin: რას arrow ნიშნავს?
>> Binky: ისრიანი საშუალებით ზუსტად ისევე, როგორც ეს.
ასე, რომ თქვენ ნამდვილად არ უნდა ისარი.
როგორიცაა, თუ თქვენ მხოლოდ პროგრამა C, თქვენ შეგიძლიათ გამოიყენოთ ეს.
უკაცრავად, მე არ რა, რომ არის.
თქვენ შეგიძლიათ გამოიყენოთ ეს სინტაქსი.
>> მაგრამ ზოგიერთი ადამიანი, როდესაც ისინი შექმნასა C,
მათ figured, რომ ადამიანი გამოიყენება, რომ სინტაქსი იმდენად,
რომ მიყვარს მხოლოდ ამუშავება ერთად სინტაქსის სტრუქტურა იგი.
და ეს მოხდა სახით ამ arrow.
და ეს მართლაც კარგია, რადგან ის განასახიერებს რაიმე
როგორც ჩვენ რეალურად შემდეგ ეს ისარი, ეს მაჩვენებელი,
მიმართ გარკვეული სივრცეში მეხსიერებაში.
და როდესაც ჩვენ იქ, ჩვენ გვინდა გამოიყურება სახელი, რომ სტუდენტი,
თუ ეს აზრი.
OK?
>> ასე რომ, ეს არის ზუსტად იგივე.
ეს არის ზუსტად იგივე, როგორც ეს.
ისინი შედგენილი ზუსტად იგივე, OK?
და მიზეზი აქ რატომ ჩვენ malloc რაღაც, იმიტომ რომ ამ შემთხვევაში,
ჩვენი ცვლადი რეალურად მხოლოდ კურსორი ცვლადი.
ასე რომ, ჩვენ მხოლოდ გარკვეული სივრცე მეხსიერება, რომელიც მართავს მაჩვენებელი.
ჩვენ ნამდვილად არ აქვს რაიმე სივრცე რომელიც ფლობს რეალურ struct.
>> ასე რომ, ეს უნდა გაკეთდეს ორ ეტაპად.
ჩვენ უნდა შევქმნათ მეხსიერების დააყენოს struct in.
და ჩვენ უნდა შევქმნათ მეხსიერების დააყენოს კურსორი.
ასე რომ, ისინი ძირითადად ორი სხვადასხვა ცვლადები, აქ.
ერთ-ერთი მათგანი ტიპის სტუდენტი, გარდა ამისა, ეს ნამდვილად არ აქვს სახელი.
და მეორე არის ტიპის სტუდენტი ვარსკვლავი.
და მაშინ სტუდენტი 1 რაოდენობა არსებობს, თუ ეს აზრი.
OK?
>> ასე რომ, მიზეზი, რის გამოც ჩვენ ვიყენებთ მითითებები არის, რადგან ყველაფერი
კომპიუტერი, ყველა ცვლადის კომპიუტერი აქვს ორი რამ.
მას აქვს თავისი ღირებულება.
და მას აქვს მისამართზე.
და კარგი გზა კონცეფცია, რომ ეს არ არსებობს
ბევრი პრობლემა, როდესაც თქვენ ცდილობენ გამოიყენონ ფუნქციები.
და ჩვენ ვაპირებთ ცდილობენ შეისწავლის იმ.
კერძოდ, ის აპირებს ვფიქრობ, მეხსიერებაში, ყუთები.
>> თქვენ ყოველთვის ვფიქრობდი, რომ ცვლადები როცა ამბობენ, რომ na შეადგენს 5.
თქვენ ვფიქრობ აყენებს 5 შევიდა ყუთი.
მერე რა, რომ გსურთ გაივლის რომ int შევიდა ფუნქცია?
უბრალოდ გაივლის მე არ იცით x შევიდა ფუნქცია.
მაგრამ რა ხდება, ჩვეულებრივ, როგორც ადამიანები, თქვენ
ვფიქრობ, რომ მსგავსი რამ მე ვარ გავლის ყუთი პირი.
და ეს ნამდვილად არ მოხდეს კომპიუტერები.
რა ხდება არის ის ასლი ღირებულება ყუთი პირის ყუთში.
>> ასე რომ, რა ვცდილობ ვთქვა, რომ თუ თქვენ გაქვთ ფუნქცია ბოდიში აქ
თუ ჩვენ გვაქვს ფუნქცია, როგორიცაა ხუთ up არსებობს, თუ თქვენ ცდილობენ გაივლის ცვლადი,
ეს მხოლოდ აპირებს.
თუ ინიციალიზაცია nx უდრის 3-ის აპირებს კოპირება ამ ღირებულების მდე ცვლადი
იქ.
OK, და ეს არის ერთგვარი მიზეზი ამიტომ, ჩვენ გვინდა გამოვიყენოთ პოინტერები.
ნაცვლად იმისა, რომ რაც მხოლოდ ღირებულება,
ნაცვლად მხოლოდ გავლით მხოლოდ ღირებულება ფუნქცია,
ჩვენ გვინდა, რომ გაივლის მიერ მინიშნება.
რაც ჩვენ მოვუწოდებთ გაივლით მიერ მინიშნება არის სახის გაცემის ყუთი ფუნქცია,
ასე რომ ფუნქცია შეიძლება ასევე შეცვლა ღირებულებების ყუთში.
>> OK, ასე რომ მხოლოდ რამდენიმე ძირითადი მაჩვენებელი პერსონალის შექმნა მითითებას,
უბრალოდ განაცხადოს ის ტიპი და თქვენ დააყენა ვარსკვლავს უფლება მას შემდეგ.
და ტიპის მხოლოდ რა თქვენ მიუთითებს.
ასე რომ, თუ ეს int ვარსკვლავი, თქვენ მიუთითებს int.
თუ ეს char ვარსკვლავი, თქვენ მიუთითებს სქემა.
და თუ ეს სტუდენტი ვარსკვლავი, თქვენ მიუთითებს სტუდენტი.
OK?
>> და ისინი ყველა 4 ბაიტი ხანგრძლივი.
იმიტომ, რომ ეს ცვლადი ის ფაქტობრივად არ
უნდა გამართოს char, int, ან სტუდენტი.
ეს მხოლოდ სჭირდება გამართავს მისამართზე.
სწორედ ამიტომ, ისინი ყველა 4 ბაიტი ხანგრძლივი ნორმალური 32-bit მანქანა.
OK?
ასე რომ, აქ, x არის ცვლადი, რომელიც მიუთითებს int. y რაოდენობა char. z რაოდენობა
float.
რაიმე შეკითხვები აქ?
ზემოთ.
არსებობს ორი სხვადასხვა სიმბოლოები აქვთ
უნდა გვახსოვდეს, როდესაც მოდის მაჩვენებელი.
ასე მითითება და dereferencing არის დიდი მიიჩნიეს.
ამიტომ ampersand საქართველოს ცვლადის სახელი გაძლევთ?
სტუდენტი: მისამართი.
Binky მისამართი.
ასე რომ, თუ თქვენ განაცხადოს int უდრის 5, მაშინ ampersand
ერთი აპირებს მოგცემთ მისამართზე.
და თქვენ შეგიძლიათ რეალურად ცდილობენ ბეჭდვა და ვნახოთ
რა მისამართზე მეხსიერება თქვენი ცვლადის აქვს.
და შემდეგ dereferencing-- ისე, რომ მითითება,
მიღების address-- dereferencing ზუსტი საპირისპირო.
OK, ისევე, როგორც ჯერ არის საპირისპირო განყოფილება,
ვარსკვლავი საპირისპირო ampersand.
ამიტომ dereferencing ნიშნავს წავალთ.
ასე რომ, თუ თქვენ მისცეს star-- I არ ვიცი 50, რომ
ვაპირებ ცდილობენ წასვლა მისამართი ნომერი 50 შიგნით თქვენი კომპიუტერი.
OK, და რატომ ვხედავთ რომ ისინი განსხვავდებიან?
იმის გამო, რა მოხდება, თუ თქვენ აკეთებთ რაღაც მსგავსი ვარსკვლავი ampersand?
ასევე, ampersand გაძლევთ მისამართი ცვლადი, მისამართი.
მაგრამ ვარსკვლავი ნიშნავს იქ.
>> რა მოხდება, თუ თქვენ წასვლა მისამართი?
თქვენ უბრალოდ უნდა, არა?
ასე აპირებს მისამართი არის იგივე როგორც.
სწორედ ამიტომ, ისინი, როგორც წესი, მოხსენიებული იგივე ეს
და ეს არის მოხსენიებული, საპირისპირო ოპერატორები.
OK?
ისე მაგარი.
>> ქვეშ Hood, მაგალითად, თუ ჩვენ ვაცხადებთ int x უდრის 5,
ჩვენ გვაქვს ცვლადი.
და მახსოვს, რომ მე ვთქვი ყველა ცვლადი და ეს კარგია
შენარჩუნება mind-- მას აქვს ორი სხვადასხვა რამ უკავშირდება.
მას აქვს მიმართა და მნიშვნელობა.
OK?
>> ასე რომ, არც ამ შემთხვევაში არის 5.
და მისამართი is-- ვთქვათ, მე ვარ მიღების რაღაც up-- ეს 0x04.
და ერთადერთი მიზეზი, რის გამოც ჩვენ, როგორც წესი, წარმოადგენს მისამართები თექვსმეტობითი
არის ერთი, რადგან ეს როგორც კარგი.
ეს კარგად ორობითი.
ეს ადვილი დააკონვერტიროთ და ორობითი.
და ეს არ მიიღოთ ძალიან დიდი თუ თქვენ გაქვთ ძალიან დიდი რაოდენობით.
ასე რომ, ჩვენ გვსურს გამოვიყენოთ თექვსმეტობითი ბეჭდვის მისამართები.
მაგრამ მე ვერ წარმოადგენს როგორც მთელი რიცხვი.
ეს ჯარიმა.
>> და ასე აქვს მისამართი 4 და ღირებულება 5.
და მე ვთქვი მაშინ int ვარსკვლავი მაჩვენებელი.
ასე რომ, ეს არის სხვადასხვა ტიპის, ცნობა.
Int ვარსკვლავი მაჩვენებელი შეადგენს მისამართი x.
ასე რომ, რა იქნება ღირებულება ptr?
ეს იქნება მისამართი x, ქვემოთ აქ.
OK, ასე რომ, არც აპირებს იყოს იგივე, რაც მისამართზე.
ეს არის ის დავალება მოქმედებს ვაკეთებ.
და შემდეგ ptr აპირებს საკუთარი მისამართი, რომელიც თურმე,
ამ შემთხვევაში, მე -8, OK?
>> და მერე შექმნა ახალი რიცხვი ასლი.
და ვამბობ, რომ int ასლი ტოლია წასასვლელად.
ასე რომ, რა ptr მიუთითებს.
ისე, რა ამ ptr აქვს?
Ptr აქვს 0x04.
რა მოხდება, თუ მე ვცდილობ იქ?
მე ნახავთ ბიჭი, რომელსაც აქვს მისამართი x და ვინ მისამართზე 4.
და ვინ ოთხ არის x.
ამჯამად რომ აზრი?
დიახ?
>> სტუდენტი: In ამ შემთხვევაში, მაჩვენებელი დასტის?
>> Binky: ამ შემთხვევაში, it's-- კარგი კითხვა.
მე არ მგონია, რომ ამ როდესაც შედგენა ამ მისამართებზე.
მაგრამ თუ ეს, ისევე, როგორც, ყველა ეს არის ადგილობრივი ცვლადები,
მაშინ x აპირებს ცხოვრობენ in-- ყველაფერი აპირებს ცხოვრობენ Stack.
ასე რომ ყველაფერი ხდება მიუთითებს დააწყობს.
თქვენ მხოლოდ უნდა ბევრი, როდესაც თქვენ დაიწყება გამოიყენოს malloc, არა?
>> ასე რომ, თუ გახსოვთ, დასტის არის ყველა დროის რეკავთ ფუნქცია თქვენს პროგრამაში,
ისევე, როგორც, მთავარ მაგალითად, ან ნებისმიერი სხვა ფუნქცია, როგორიცაა printf.
ყველა ადგილობრივი ცვლადები აპირებს დააყენოს დასტის ჩარჩო.
და ისინი აპირებენ მიიღონ როგორიცაა დაგროვილი Stack.
ეს არის ის, რასაც Stack.
და ყველა იმ ადგილობრივი ცვლადები ვაპირებთ, რომ არსებობს.
და heap-- და ჩვენ ვაპირებთ გაიგო მეტი ამ later--
ბევრი არის, სადაც ყველა დინამიურად გამოყოფილი მეხსიერება ცხოვრებაში.
მაგარი?
>> ჩვენ მივდივართ ამ slide.
დიახ?
>> სტუდენტი: რატომ არ არის int გადაწერეთ დაბრუნების 0x04?
>> Binky: რატომ არ არის int გადაწერეთ დაბრუნების 0x04?
>> სტუდენტი: რატომ არ არის, რომ [INAUDIBLE]?
>> Binky: იმის გამო, თუ რა არის ღირებულება ptr?
>> სტუდენტი: 0x04.
>> Binky: 0x04.
რა მოხდება, თუ თქვენ გადასვლა 0x04?
რას იღებთ?
>> სტუდენტი: Oh, OK.
Binky ხედავთ?
სტუდენტი: დიახ.
Binky: ასე რომ თქვენ 5.
ასე ასლი აპირებს 5, თუ ეს აზრი.
დიახ?
>> სტუდენტი: იქნებ ჩვენ მიღებული 5 ღირებულება ყუთი [INAUDIBLE]
თუ ჩვენ int ასლი [INAUDIBLE].
>> Binky: გაკეთება int ჩვენ გვინდა, yeah.
რომ არ კეთდება საკმაოდ ბევრი იგივე.
მაგრამ ეს გზა, ჩვენ შეგვიძლია გაივლის მიმართოს ფუნქციები.
და ეს მაგარი რამ ჩვენ ვაპირებთ, რომ ახლა.
>> ასე რომ, ეს სახის სწავლება ყოველთვის მოდის მდე on-- ძალიან ჩვეულებრივ ჩნდება შესახებ ვიქტორინებში.
ასე რომ ეს ნამდვილად კარგი ცდილობენ გავაკეთოთ, რომ მსგავსი რამ თავს.
ამიტომ ცდილობენ შენარჩუნება სიმღერა, თუ რა მისამართი და მინდა, რომ ღირებულებებს ცვლადები
ყოველ ეტაპზე.
ასე რომ, ეს არის ზუსტად ის, ის, რასაც ჩვენ ვაპირებთ, რომ გავაკეთოთ.
აქ, ჩვენ გვაქვს ნაბიჯები, ერთი, ორი, სამი, ოთხი, ხუთი.
ერთი, ორი, სამი, ოთხი, ხუთი.
და ჩვენ ვაპირებთ, რომ შევინარჩუნოთ სიმღერა ღირებულებები x და.
>> ასე, თუ რას აკეთებს, თუ ეს buggy კოდი, ჩვენ ვცდილობთ გავაკეთოთ ხუთ.
ამიტომ, ჩვენ ვცდილობთ მიიღონ ცვლადი და შეცვალოს მისი ღირებულება 5.
და მახსოვს ჩემი ანალოგია, რომელსაც ყუთი და გადაცემის ყუთი ვინმე?
ასე რომ მთავარ აქვს ამ ყუთში მოუწოდა x.
და შეიცავს ღირებულება 3.
და ვცდილობ გადასცემს ეს ყუთი ხუთ.
>> და მინდა ხუთი შეცვალოს ღირებულება ამ ყუთში 5.
და მაშინ მე უბრალოდ ბეჭდვა ღირებულება x.
ეს არის ის, რაც ჩემი ფუნქცია ეს არის ის, რაც მე ცდილობს.
მე უბრალოდ ცდილობს განაახლოს ღირებულება x 5.
ეს არის ნათელი, თუ რა ფუნქცია აქვს?
>> OK, ასე რომ, რას აპირებს იყოს ღირებულებებს x და სწორედ აქ,
პირველ ზოლში, უფლება ადრე პირველი ხაზი მინდა ვთქვა პროგრამა?
>> STUDENT ალბათ ნაგავი.
>> Binky: Just ნაგვის პერსონალი.
ამიტომ მე მხოლოდ დააყენა N / A. ასე ჩვენ ნამდვილად არ ვიცი.
მინდა, კი არ არსებობს, იმიტომ, რომ ჩვენ არ მოუწოდა ხუთ.
Int არ გამოცხადდა.
და x აპირებს არსებობს აქ, მაგრამ ჩვენ ნამდვილად არ
დანიშნული რაიმე ღირებულება, ასე რომ OK?
>> და მაშინ, რა იქნება ღირებულებებს x და ნომერი ორი?
>> სტუდენტი: [INAUDIBLE].
>> Binky: So x იქნება 3.
რომ ადვილი, რადგან ჩვენ მინიჭების 3 მას.
და კიდევ არ არსებობს იმიტომ, რომ უბრალოდ ცხოვრობს ხუთ.
ამიტომ, მე ვაპირებ, რომ 3 და არაფერი.
ან, როგორც ნაგვის, რასაც, ნამდვილად არ არის განსაზღვრული.
და ახლა, ეს არის მნიშვნელოვანი ხაზი.
აქ, ჩვენ ვაპირებთ სინამდვილეში ხუთ.
და მახსოვს რა ვთქვი.
ჩვენ არასდროს გაივლის ყუთში.
ჩვენ უბრალოდ ასლი ღირებულება ყუთი ერთ ყუთში.
რომ ყველა კომპიუტერი, ასლი ნივთები ერთი ადგილიდან მეორეზე.
>> ასე რომ, ხუთი, რასაც ის რეალურად აკეთებს ეს არის ასლი ღირებულება x, რათა.
ასე რომ, რა ხდება აქ?
ღირებულებები x და.
3 და 3, ჩვენ უბრალოდ ასლი ეს მეტი x to a.
ზემოთ.
>> ახლა ჩვენ აქ.
და ახლა ჩვენ ვაპირებთ განახლება შეადგენს 5.
რა მოხდება ხაზის ოთხი?
>> სტუდენტი: [INAUDIBLE].
>> Binky: იღებს განახლება, მაგრამ x ვერ განახლდა.
იმის გამო, რომ x ცხოვრობს მთავარი, ის სრულიად განსხვავებული ბლოკი მეხსიერება.
ეს სხვადასხვა ცვლადი.
არის კიდევ ერთი ცვლადი.
ისინი არ უნდა ჰქონდეს იგივე ღირებულება იმიტომ, რომ მე
გადაწერა დასრულდა ღირებულება x, რათა.
მაგრამ ახლა, როცა მე უდრის 5, ნამდვილად არ მოქმედებს x არანაირად.
ეს არის უფრო რთული ნაწილი.
ის აზრი, რომ ყველას?
დიახ?
სტუდენტი: კიდევ ერთი შეკითხვა, თქვენ გაქვთ 3.
რატომ არის already-- ო, არა, ეს 3.
უკაცრავად, არასდროს არ იბადება.
წავიკითხე 5.
>> Binky: Yeah, 3, 3.
>> სტუდენტი: [INAUDIBLE], yeah.
Binky: და მერე მივუთითოთ 5 , მაგრამ ნამდვილად არ შეცვლის x.
კარგი?
სტუდენტი: დიახ.
Binky: Yes?
ახსნით ერთხელ, თუ როგორ იღებს გადაწერა [INAUDIBLE]?
>> Binky: OK, ასე რომ, როდესაც თქვენ მოვუწოდებთ ხუთ x, ამიტომ ეს ხაზი კოდი აქ.
ხუთ x, რა არის x?
x არის 3, ამ ეტაპზე, არა?
ასე, რომ თქვენ შეიძლება უბრალოდ ვფიქრობ აყენებს 3 აქ და ივიწყებს x.
უბრალოდ დააყენა 3 აქ.
როგორიცაა, ჩვენ ვაპირებთ, რომ გადაწერეთ ღირებულება x, რომ int რომ იქ.
OK?
>> ასე რომ, ღირებულება x 3.
ჩვენ ვაპირებთ, რომ ასლი 3 გადასცა.
და ყველა ეს სხვა ბლოკი მეხსიერება, ეს სხვა ცვლადი
მოუწოდა მოგიწევთ 3, ასევე.
ამჯამად რომ აზრი?
დიახ?
>> სტუდენტი: თუ თქვენ მისცეს ხუთ როგორიცაა აქვს ის, რაც მთელი x ნაცვლად,
მინდა, რომ დაფიქსირება ყველაფერი?
>> Binky: თუ ეს integer-- არა, რომ არ დაფიქსირება ყველაფერი.
ასე რომ, ეს ძალიან კარგი კითხვაა.
ეს ნამდვილად არ აქვს მნიშვნელობა, რა რეკავთ ცვლადები.
კიდევ ერთხელ, ეს იქნება საკითხი ფარგლებს, იმიტომ, რომ ისინი არ არის იგივე x.
ისინი სრულიად სხვადასხვა ფართების მეხსიერებაში.
სტუდენტი: [INAUDIBLE].
Binky ასე რომ, ეს ნამდვილად არ აქვს მნიშვნელობა, რას მოვუწოდებთ მათ.
რომ არ დაფიქსირება რამ, OK?
კიდევ შეკითხვები?
დიახ?
>> სტუდენტი: როგორ არის ის უკან ხუთი ნომერი [INAUDIBLE]?
Binky: OK, ჩვენ არ კეთდება, რომ ამჟამად.
მოდით, ხუთი ნომერი, მაშინ.
>> სტუდენტი: [INAUDIBLE]?
>> Binky რა?
>> სტუდენტი: თქვენ გაქვთ დაბრუნების ყველა?
Binky: ჩვენ არ გვაქვს სანაცვლოდ, არა ძირითადი.
მაგრამ მთავარ ანაზღაურება 0 ავტომატურად თუ არ დაბრუნდება არაფერი.
დიახ?
>> სტუდენტი: იქნებ მიიღოს main-- ან შეიძლება თუ არა მიიღოს ხუთ სანაცვლოდ?
>> Binky: ჩვენ შეგვეძლო ხუთ დაბრუნდება, დიახ.
მაგრამ მაშინ ჩვენ უნდა მივანიჭოთ x უდრის დაბრუნების ღირებულება ხუთ,
რომელიც იქნება ოდნავ სხვადასხვა პროგრამა.
ეს იმუშავებს.
მაგრამ რაც ჩვენ გვინდა, რომ გავაკეთოთ, რა არის მოუწოდა ცვლილება რაღაც ადგილზე.
ასე რომ, ჩვენ გვინდა, რომ რეალურად შეიცვალოს, რომ ყუთი და არ აღელვებს
იმის გამო, დაბრუნდნენ ღირებულებები ან არაფერი.
OK?
>> ეს ისევე, როგორც swap ფუნქცია დავით აჩვენა ლექცია, გარდა მე ვარ
მხოლოდ საქმე ერთი ცვლადი.
და მან გამოიყენა ორი, ასე int და ბ და მაშინ დროებითი ცვლადი და whatnot.
OK?
რა არის ბოლო ხაზი?
მას შემდეგ, რაც ხუთ ბრუნდება, ის უბრალოდ აპირებს წავიდეს.
ჩვენ არ გვაქვს აღარ, და მხოლოდ x მაინც ცხოვრობს.
>> და გამოიცანით რა? x არ შეცვლილა მისი ღირებულება,
მას შემდეგ, რაც ყველა, რადგან ჩვენ მხოლოდ შეცვლის ღირებულება.
სწორედ ამიტომ, x 3 იყო მთელი.
OK?
კარგი.
ასე რომ ეს პროგრამა არ მივაღწევთ იმას, რაც გვინდოდა.
ახლა მოდით გაასწორონ ის.
>> და გადავწყვიტოთ პროგრამა გამოყენებით პოინტერები.
რას ვაკეთებთ ჩვენ გვაქვს სამი ხაზები, რომლებიც სხვადასხვა.
პირველი, ვინც ეს ჩვენ არ გადადის x.
ჩვენ გავლის მისამართი x.
ასე რომ, ნაცვლად გადაწერა მეტი ღირებულება ყუთი,
მე მაინც აპირებს მეტი რაღაც.
მაგრამ მე გადაწერა მეტი მისამართი ყუთში.
>> ასე რომ, თუ მე გაივლის მისამართი ყუთი, რათა ხუთი, მაშინ ხუთ
შეძლებს იპოვოს, რომ მეხსიერება და შეცვალოს მისი ღირებულება.
>> ისე და მერე იქ, მე მაქვს რომ ეს არ არის int უქმნით.
არის int ვარსკვლავი.
ეს მაჩვენებელი რიცხვი.
შემდეგ კი, რადგან მე ჩაბარების მივმართო აქ, და შემდეგ რა გავაკეთო
არ არის შეადგენს 5, რადგან მართავს მისამართზე.
ასე რომ, რა გსურთ არის იქ და განახლება შინაარსი ამ მისამართზე
5.
>> OK, ასე რომ, მოდით გავლა ყველა ხაზები ერთი.
ასე რომ, როდესაც მე აქ იწყება I ჯერ კიდევ გვაქვს N / A, N / A, N / A
რადგან ყველაფერი პირველი ხაზი, იმიტომ, რომ მე ნამდვილად არ
განაცხადა პერსონალი ამჟამად.
და შემდეგ ხაზი ორი, მე მაქვს x უდრის 3.
Int ვარსკვლავი არ არსებობს, იგივე როგორც ადრე.
>> ახლა იგი იღებს საინტერესო.
ამიტომ, მე ვაპირებ გაკეთებას.
და მოდით დავუშვათ, რომ მისამართი x არის 12 თექვსმეტობითი.
მოდით უბრალოდ ვივარაუდოთ, რომ ეს.
მე მივიღე ეს.
რა ვარ მე გავლით აქ არის ხუთ.
მე გავლით 12.
>> ასე რომ მნიშვნელობა არ აქვს?
>> სტუდენტი: [INAUDIBLE].
>> Binky: უკაცრავად?
>> სტუდენტი: [INAUDIBLE].
Binky: ჰო, როგორც, რომ, მოდით ვივარაუდოთ, რომ ჩვენ ვართ აქ, ახლა.
მე გეკითხებით.
>> სტუდენტი: [INAUDIBLE].
>> Binky: უკვე დაიწყო.
>> სტუდენტი: [INAUDIBLE].
Binky: იმის გამო, რომ ჩვენ გავიდა რაღაც ფუნქცია.
დიახ?
>> სტუდენტი: მისამართი x.
Binky: იგი აპირებს აქვს მისამართი x.
და მისამართი x 12, კარგი.
ასე რომ, x იქნება 3, რადგან ჩვენ ნამდვილად არ შეიცვალა x ამჟამად.
და მაშინ იქნება 0x12, ასე მისამართი x, იმიტომ, რომ
ის, რაც ჩვენ გავიდა ხუთ.
>> და მერე რა მოხდება თუ ჩვენ ვცდილობთ იქ?
რასაც ჩვენ ვაპირებთ, რათა იპოვოს?
ასე რომ, თუ თქვენ ცდილობენ ბეჭდვა ვარსკვლავი, ჩვენ ვაპირებთ ამ მისამართზე
და მიიღეთ ღირებულება შიგნით.
და არც მხოლოდ იგივე ღირებულება, რომელიც x
აქვს, რადგან ეს არის მისამართი x, რომელიც იქნება 3.
ჩვენ კარგი?
>> OK, მაშინ ახლა, ჩვენ ნამდვილად წასასვლელად.
და ჩვენ განახლება, რასაც ამ მისამართზე 12.
ჩვენ ეს 5.
ასე რომ, ახლა, როგორც x და ვარსკვლავი არის 5.
>> რატომ არის, რომ?
იმის გამო, რომ მისამართი x 12.
და ასევე 12 მისი ღირებულება.
ასე რომ, თუ ჩვენ დაიცვას 12 ჩვენ უბრალოდ აპირებს იპოვოს x.
ასე რომ, რასაც ჩვენ ვაკეთებთ ვარსკვლავი მოხდება
x, რადგან შეიცავს მისამართი x.
OK?
>> და ეს არის, როგორც არსი, სარემონტო.
ასე რომ, ახლა ჩვენ შეუძლია, საწყისი ხუთ, რეალურად
მეხსიერება, რომელიც ცხოვრობდა მთავარი.
ასე რომ, ეს მეხსიერება არ ცხოვრობს, რომ ხუთი, ისევე, როგორც ადრე, ამ მისამართზე 12.
ჩვენ შევძელით, რომ იქ და შეცვალოს მისი ღირებულება 5.
>> და მაშინ, როცა ჩვენ დავბრუნდებით, ჩვენ დაივიწყოს.
ჩვენ დაივიწყოს ვარსკვლავი.
და x კვლავ ხუთ.
ასე რომ, თუ გსურთ განახორციელოს swap ფუნქცია,
თქვენ უბრალოდ გააკეთოს ზუსტად იგივე, გარდა თქვენ უნდა int ვარსკვლავი აქ,
და ასე შემდეგ და ასე შემდეგ.
OK?
ჩვენ კარგი?
ზემოთ.
>> ამიტომ კურსორი არითმეტიკული.
ეს არის ოდნავ სახიფათო თემაზე.
გამოდის, რომ მითითებები მხოლოდ რიცხვებით.
თქვენ შეგიძლიათ ვფიქრობ, რომ მათ რიცხვები.
იმის გამო, რომ მეხსიერება, თქვენ გაქვთ, როგორიცაა მეხსიერების მისამართი ნულოვანი, ერთი, ორი, სამი,
ოთხი, ხუთი.
ასე შეგვიძლია შევაჯამოთ მეხსიერების მისამართები.
>> და ეს, როგორც წესი, თუ რას აკეთებთ თქვენ და მასივი, მაგალითად.
მასივი, ისევე, როგორც მომიჯნავე ბლოკი მეხსიერება, უამრავი სიმბოლო,
მაგალითად, უამრავი ints.
ასე რომ, თუ გსურთ წასვლა მეორე int ან იმ მესამე int,
შეგიძლიათ უბრალოდ მთლიანობაში რაღაც პირველი მისამართი, და თქვენ ვაპირებთ იქ.
ასე რომ, ეს ნამდვილად სასარგებლოა, რომ.
>> და ის, რომ შევინარჩუნოთ გათვალისწინებით, თუმცა,
რომ ეს არ არის მხოლოდ, ნორმალური არითმეტიკული გრძნობა
იმ შემთხვევაში, თუ თქვენ საქმე, ვთქვათ, int ვარსკვლავი, და თქვენ დაამატოთ 1 მას,
მაშინ, თქვენ არ აპირებს დაამატოთ 1, მისამართი,
თქვენ ვაპირებთ დაამატოთ -4 მისამართზე.
იმიტომ, რომ int არის 4 ბაიტი.
>> ასე რომ, ეს არის, ისევე, ფეხით მასივი.
თუ ჩვენ გვაქვს მასივი უამრავი ints და მაშინ ჩვენ ვცდილობთ, გადადით მეორე,
არსებითად ის შემაჯამებელი მისამართი პირველი plus 1.
მაგრამ, რომ არ be-- უბრალოდ ვთქვათ, რომ მისამართს პირველი, 4.
აქ, ამ შემთხვევაში.
და თუ ჩვენ მთლიანობაში, ასე რომ ეს არის ის, რაც ხდება.
ჩვენ გვაქვს int.
Int x უდრის 5.
X აქვს მნიშვნელობა 5.
და ჩვენ ინიციალიზაცია ეს მაჩვენებელი, int y int ვარსკვლავი y ტოლია მისამართი x.
>> მოდით ვივარაუდოთ, მისამართი x 4.
რა მოხდება ახლა, თუ თანხა დაამატოთ 1 y?
ის აპირებს რეალურად თანხა 4 ნაცვლად მხოლოდ 1.
ასე რომ, მე დაამატოთ 1, მაგრამ რეალურად დამატებული 4, რადგან კომპიუტერის ჭკვიანი.
ასე რომ, ის აპირებს რეალურად დაამატოთ i-ჯერ ზომა ტიპის მაჩვენებელი.
OK?
>> ასე რომ, თუ ეს იყო char, მაგალითად, თუ ეს იყო char ვარსკვლავი y,
და თუ ჩვენ კიდევ 1 მაშინ ეს 5, რადგან char არის 1 ბაიტი ხანგრძლივი.
კარგი?
>> და ბოლოს, ჩვენ მივიღეთ პოინტერები და მასივები.
გამოდის, რომ ყველა დროის თქვენ საქმე მასივი,
თქვენ რეალურად საქმე მაჩვენებელი.
ძალიან ლამაზი კონცეპტუალური მიზეზი ეს არის ის, რომ კოლექტორები ძალიან დიდი.
ასე მახსოვს, რომ მე ვთქვი, რომ ყოველ დროს, თქვენ გაივლის პერსონალის გარშემო,
ასლი ყველაფერი.
ასე რომ, თუ თქვენ გაქვთ მასივი ეს მართლაც, მართლაც დიდი,
თქვენ ნამდვილად არ მინდა, რომ ასლი ყველაფერი ყველა დროის
თქვენ უნდა გაიაროს ეს გარშემო სხვა ფუნქცია, რადგან ეს მხოლოდ
მასიური რაოდენობით მუშაობა.
ასე რომ, რა უნდა გავაკეთოთ არის მხოლოდ წარსული მისამართი პირველი byte.
და შემდეგ ფუნქცია ექნება დაშვება ყველა ელემენტები, რომ მასივი.
ასე გავიდა მასივი, მისი მისამართი, ასე რომ, მისამართი პირველი byte.
>> ასე რომ, თუ ჩვენ ვაცხადებთ int მასივი 3, აქ, ჩვენ ვიცით,
როგორ შედიხართ პირველ ელემენტს გამოყენებით ფრჩხილი ნოტაცია.
თუ გახსოვთ bracket notation, array bracket 0 უდრის 1.
ასევე, ეს იქნება ზუსტად ისევე, როგორც უბრალოდ იქ და ბოლო 1.
OK, არის ზუსტად იგივე.
ასე ფრჩხილი ნოტაცია აქ იგივე იქნება, როგორც ეს ონლაინ.
>> და გამოიცანით რა ფრჩხილი ნოტაცია მასივი bracket 1 იქნება?
ეს იქნება მხოლოდ იგივე, როგორც ეს.
ასე რომ დაამატოთ ერთი მასივი.
გადაადგილება ერთი ერთად მეხსიერებაში.
იქ, და 2.
OK?
და ეს ხაზი არის იგივე.
ჩვენ გვინდა წასვლა, მესამე ყუთი, რათა მასივი plus 2.
იქ, და 3.
ასე რომ მეხსიერება, რა მოხდება არის ჩვენ
გვექნება 1, 2 და 3, სამი ელემენტები ამ მასივი.
>> შეგვეძლო გავაკეთეთ ამ გამოყენებით ჩვენი ნაცნობი ფრჩხილი ნოტაცია.
მე მხოლოდ მინდა, შენ რომ ვიცით, რომ ისინი იგივე.
OK, კითხვები შესახებ?
ლამაზი.
ახლა, მე ვაპირებ, რომ გადასცემს მას მეტი Hannah,
>> HANNAH: Yay, Yee-Haw.
>> Binky: საუბარი მეხსიერება და მე პერსონალი.
[ტაში]
>> HANNAH: Hi, cool, ამიტომ ჩვენ მიმდინარეობს გაიგო ცოტა მეტი
მეხსიერება, რომელიც ჩვენ მხოლოდ მიმართა გამოყენებით პოინტერები.
ასე რომ, არსებობს ორი ძირითადი ნაწილისგან მეხსიერება, რომ ჩვენ შეშფოთებული.
ჩვენ გვაქვს დასტის, რომელიც იზრდება მდე ქვედა, და ბევრი, რომელიც
მიდის ქვემოთ ზემოდან.
და დასტის აპირებს გამართავს ყველა ეგზემპლარის ცვლადებს.
ასე რომ, თითოეული მოუწოდებს ფუნქცია იღებს საკუთარი პატარა ჩარჩო დასტის.
ისე, Gabe ზემოთ აღინიშნა, თუ ჩვენ მოვუწოდებთ ფუნქცია ისევ და ისევ,
ჩვენ ვაპირებთ, რომ დააწყობს რამ Stack.
>> და ანალოგიურად, ბევრი, რომელიც იწყება ზედა
აწყობს ყველა მეხსიერება ჩვენ დინამიურად გამოყოფს.
ასე რომ, როგორც ჩვენ დინამიურად გამოყოს მეხსიერება,
ეს მოვა ქვემოთ ბოლოში.
რამდენიმე რამ უნდა იცოდეს, როდესაც ჩვენ გამოყენებით დასტის და ბევრი,
დასტის, თუ ჩვენ გვაქვს ძალიან many-- ვთქვათ რეკურსიული მოუწოდებს,
და ჩვენ მოუწოდებდა ფუნქციის ერთხელ, და ისევ და ისევ და ისევ,
და ეს დაწყობა up, დაწყობა up, დაწყობა up.
და ის აპირებს ავარიული შევიდა ბევრი.
ჩვენ ვაპირებთ, რომ ამოიწურა მეხსიერება.
რომ აპირებს იწვევს პრობლემა კომპიუტერი.
და ეს მოუწოდა დასტის overflow.
ასე რომ, ეს ნამდვილად რაღაც უნდა იცოდეს და ცდილობენ, რათა თავიდან ავიცილოთ.
და ბევრი, უნდა გვახსოვდეს, არ შემთხვევით გაჟონვა მეხსიერება.
ნებისმიერ დროს გამოყენება malloc, არ დაგავიწყდებათ გასათავისუფლებლად, რომ მეხსიერებაში.
წინააღმდეგ შემთხვევაში, ეს უბრალოდ იქნება ბევრი შეეწირა,
და კომპიუტერი არ იცის, რომ ეს არის უფასო გამოიყენოს, რომ მეხსიერებაში.
ასე რომ, ეს არის რამდენიმე რამ უნდა იყოს ძალიან ფრთხილად, როდესაც
თქვენ საქმე დასტის და ბევრი.
რაიმე შეკითხვები ამ საკითხთან დაკავშირებით?
გასაოცარია.
>> OK, ზემოთ.
აი, ეს აქვს იგივე იდეა, როგორც დასტის overflow, სადაც
ჩვენ ვაპირებთ მიღმა ფარგლებში, რაც მეხსიერება
არის ჩვენ უნდა შეეძლოს გამოიყენოს.
ასე რომ მიიღოს, მაგალითად, ბუფერული, ან შეიძლება მხოლოდ ვფიქრობ, რომ ეს მასივი.
და ვთქვით, OK, ჩვენ ვაპირებთ შექმნა ამ ლამაზი პატარა მასივი.
ეს იქნება სიმებიანი.
ან ის აპირებს შესანახად სიმბოლო.
და ეს მხოლოდ აპირებს მიესალმები.
და ეს გაურკვეველი.
ეს არის ის.
>> მაგრამ თუ მე ვინმე ბოროტი და უნდოდა რაღაც ცუდი ამ მასივი, რა
შეიძლება გავაკეთოთ ცდილობენ წერენ წარსულში ბოლოს სიმებიანი.
და როგორც დაინახავთ, თუ ვწერ შორს,
მე შემიძლია რეალურად იმოქმედებს დაბრუნების მისამართზე.
და თუ დავიწყებ, რომ მოახდენს დაბრუნების მისამართი,
მე გავლენა იქონიოს პროგრამის რეალურად მართავს.
და დაბრუნების ნაცვლად, თქვენ იცით, ბედნიერი სიმებიანი მოსწონს hello, I
შეიძლება რაღაც ცუდი, ისევე წასვლა სხვაგან თქვენს კომპიუტერში, ჯერ კიდევ
მეხსიერება, შეცვლის, რაც მე მინდა ამის გაკეთება.
ასე რომ, რაც გამოიყურება ასე თუ მე მხოლოდ სახის ამოავსო
შემთხვევითი ნაგვის ღირებულება, ამ შემთხვევაში, უბრალოდ.
და მაშინ, როდესაც მე რეალურად მიიღო მეხსიერების მისამართი,
დავიწყე შევსება, რაღაც რომ გააკეთა ის, რაც მინდოდა, რომ ეს გააკეთოს.
ნებისმიერი კითხვები ბუფერული overflow?
გასაოცარია, საფრენი მარჯვენა ამ პერსონალის.
>> OK, ასე რომ ჩვენ ვისაუბრეთ ბევრი შესახებ კურსორი ერთად Gabe.
როგორ ჩვენ რეალურად მომცეთ?
როგორ მივიღოთ მისამართი მეხსიერებაში?
ასევე, ჩვენ შეგვიძლია გამოვიყენოთ ეს ლამაზი ფუნქცია ზარი malloc, რომელიც
აპირებს პატარა ნაჭერი მეხსიერება,
კერძოდ, ბევრი, როგორც ჩვენ განვიხილეთ,
და ის აპირებს მოგცემთ უკან კურსორის მისამართი მეხსიერებაში.
და არგუმენტი, რომ ჩვენ უნდა მისცეს malloc
ის, თუ რამდენად სივრცეში მეხსიერებაში გვინდა.
>> ასე რომ თქვენ ხედავთ ზომა byte.
ვთქვათ, მაგალითად, ან რეალურად, ამ მაგალითად,
ჩვენ გამოყოფს საკმარისი ფართი 10 რიცხვებით.
ასე რომ, ალბათ, რასაც ჩვენ ვაპირებთ, რომ გსურთ იმისათვის, რომ აქ არის მასივი 10 რიცხვებით.
ასე ვაძლევთ მას ზომა ints, რომელიც შევიტყვეთ, ის იყო, თუ რამდენი ბაიტი?
სტუდენტი: 4.
HANNAH: 4, ლამაზი და ჩვენ მინდა 10 იმ ზედიზედ,
ასე რომ ჩვენ გვაქვს საკმარისი სივრცე შესანახად ყველა 10 რიცხვებით, ამ შემთხვევაში.
რაღაც სუპერ მნიშვნელოვანია, ნებისმიერ დროს რეკავთ malloc,
თქვენ უნდა შეამოწმოთ for null.
თუ არ შევამოწმოთ null, ასევე, malloc თუ იგი გადის out სივრცეში
და აღარ გაძლევთ ნებისმიერი მეტი მეხსიერება, მაშინ ის დააბრუნებს null.
ასე რომ, თუ თქვენ არ შეამოწმოთ, malloc დაბრუნება null.
და თუ ჩვენ ვცდილობთ dereference null მაჩვენებელი,
ჩვენ ვაპირებთ, რომ მიიღოთ სეგმენტაცია ბრალია, რომელიც ჩვენ ვსაუბრობთ ახლა.
გასაოცარია.
>> OK, კითხვები malloc?
დიახ?
>> სტუდენტი: თუ არა შემოწმების null [INAUDIBLE] არ გავაკეთებთ ვიქტორინა?
>> HANNAH: რა თქმა უნდა, კითხვა იყო ჯერ ეს matter-- ინტელექტუალური,
თქვენ მიიღებთ რაოდენობა იქნება, თუ თქვენ არ შევამოწმოთ null?
დიახ, თქვენ მიიღებთ რაოდენობა off თუ არ შევამოწმოთ null.
ნებისმიერ დროს რეკავთ malloc, როგორც ინტელექტუალური და თქვენი psets და რეალურ ცხოვრებაში,
თქვენ უნდა შეამოწმოთ for null.
კარგი კითხვაა.
>> GABE: რა მოხდება, თუ არ არის თავისუფალი?
HANNAH: Gabe უნდა იცოდეს, რა, თუ არ არის თავისუფალი.
მაშინ გვექნება მეხსიერების გაჟონვის ჩვენი ბევრი.
ნებისმიერი სხვა კითხვები?
დიახ?
>> სტუდენტი: შეიძლება you-- წავიდეთ მეტი ბუფერული overflow რეალური სწრაფი ისევ?
>> HANNAH: რა თქმა უნდა.
შეკითხვა ჩვენ წავიდეთ მეტი ბუფერული overflow მართლაც სწრაფი.
მოდით დავუბრუნდეთ იმ სლაიდები.
ასე ბუფერული, შეგიძლიათ მხოლოდ ვფიქრობ, რომ ეს მასივი, არა?
თქვენ გაქვთ გარკვეული სივრცეში მეხსიერებაში.
და როდესაც ჩვენ პირველად შექმნა ჩვენი მასივი, ჩვენ ვიცით, კოლექტორები აქვს ფიქსირებული ზომა,
ან ჩვენი ბუფერული აქვს ფიქსირებული ზომა.
>> ასე ვთქვათ, ამ შემთხვევაში, ჩვენ გვაქვს მხოლოდ საკმარისი სივრცე დაწერა სიმებიანი hello.
თუ ჩვენ წასვლა წარსულში რომ შეკრული, თუ ჩვენ წასვლა წარსულში რა არის ჩვენი array ჩვენ ვთქვით, რომ ეს შეიძლება გამართავს,
ჩვენ შეგვიძლია რეალურად დაიწყოს წერის მეხსიერება
რომ კომპიუტერი არ მინდა, რომ დაწეროს.
კერძოდ, თუ ჩვენ მოხვდა რაღაც დაბრუნების
მისამართი ფუნქცია, რომელიც, როგორც ნებისმიერი სხვა ნაჭერი მეხსიერება,
არის მხოლოდ სადღაც თქვენი კომპიუტერი, თქვენ შეგიძლიათ რეალურად
შეიცვალოს, რომ და დაიწყოს ბოროტი.
პასუხი თქვენს კითხვაზე?
გასაოცარია, არაფერი?
დიახ?
>> სტუდენტი: ასე დასტის [INAUDIBLE], თქვენ განაცხადა გადასვლა ბოლოში იზრდებოდა.
ფარგლებში დასტის სპექტრი, აკეთებს მეხსიერების გადასვლა, ისევე,
ზემოდან ქვემოთ დაკავშირებული თითოეული შესვენების?
>> HANNAH: როგორ you-- თვლიან, Rob ეს ერთი.
>> ROB: ეს გაიზრდება იმავე მიმართულებით დასტის იზრდება.
HANNAH: OK.
ROB: ასე რომ, მე დაბნეული.
ეს იქნება აბსტრაქცია.
HANNAH: OK.
ROB: ეს არის სწორი.
ასე რომ, თუ დასტის იზრდება მდე, შემდეგ ზოგადად ეს
არ უნდა იყოს. მაგრამ შეგიძლიათ განაცხადოს int x.
მერე განაცხადოს int y.
მაშინ int x, ზოგადად, ქვედა დასტის, ვიდრე int y.
მაგრამ ეს მხოლოდ ფაქტია.
რომ არ მომწონს მნიშვნელოვანი სათესლე რამ.
>> ROB: ასე რომ, კიდევ ერთხელ იყო მხოლოდ რა ხდება, ყოველი ფარგლებში აშენებს.
ასე რომ, თითოეული ფუნქციის იღებს პატარა ნაჭერი Stack.
და როგორც თქვენ გადასვლა up, შიგნით რომ პატარა ნაჭერი, შიგნით რომ ჩარჩო,
ჩვენ ვიტყვით, რომ ცვლადები ფარგლებში, რომ ჩარჩო ასევე გადავიდა.
კითხვა?
>> ROB: Just იყოს mic.
HANNAH: Oh, yeah.
ROB: მე საუბარი უყვარხარ.
HANNAH: Oh, yeah, OK.
ROB: გამონაკლისია ამისთვის კოლექტორები და structs,
სად კოლექტორები, ქვედა ინდექსი მასივი,
და structs უმაღლესი სფეროში structs
გარანტირებული უნდა იყოს დაბალ მისამართები ვიდრე შემდეგ არც მასივი.
ასე რომ, ეს გარანტირებულია.
მაგრამ რაიმე განსაკუთრებული ცვლადები შიგნით, როგორიცაა int x და int y ფარგლებში ფუნქცია,
არ არსებობს საჭირო ურთიერთობისათვის შორის მათი მისამართები.
HANNAH: სხვა კითხვა აქ?
სტუდენტი: ასე რომ ბუფერულ ნაკადი, მხოლოდ ბუფერული overflow
მხოლოდ მაშინ მოხდა, როდესაც თქვენ აქვს, ისევე, დანიშნული
თანხის მასივი რომ არის მაშინ უფრო?
როგორიცაა, შეგიძლიათ?
ასე რომ, თუ თქვენ ითხოვს რაღაც user--
>> HANNAH: Mm-hm.
სტუდენტი: Can ისინი იძულებით მოგაწვდით რაღაც უკან
რომ აღემატება, რასაც თქვენ მათთვის გამოყოფილი?
HANNAH: რა თქმა უნდა, ასე რომ კითხვა იყო, ძირითადად,
შეიძლება პროფაილი მოგცემთ მეტი, ვიდრე თქვენ ვთხოვო?
სტუდენტი: Yeah.
HANNAH ისე, თქვენ ვერ შეუშლის ხელს მომხმარებელს აკეთებს, რომ.
თქვენ შეიძლება კონკრეტულად არ მომეცი ზე მეტი x ნომერი bytes
მე მხოლოდ თქვენ გეძლევათ ოთახი x ნომერი ბაიტი, X რაოდენობის სიმბოლოებს.
ისე, რომ რაღაც გსურთ თავიდან ასაცილებლად.
დიახ?
რა განსხვავებაა დასტის overflow და ბუფერული overflow?
>> HANNAH: OK, ასე დასტის overflow-- მე, რა
არის განსხვავება დასტის overflow და ბუფერული overflow?
ასე რომ ჩვენ გვინდა, ვფიქრობ დასტის overflow მაშინ, როცა ჩვენ, ფაქტობრივად,
დაწყობა up ამ ფუნქციის მოუწოდებს.
ვთქვათ თქვენ გაქვთ რეკურსიული ფუნქცია, რადგან ჩვენ ვიცით, რომ ყველა დროის
მოვუწოდებთ ფუნქცია, ეს იღებს საკუთარი ჩარჩო დასტის.
>> ასე რომ, ჩვენ დააწყობს up ძალიან მაღალია, და მაშინ ჩვენ დავიწყებთ overflow.
და ვიყენებთ ძალიან ბევრი მეხსიერება, და ჩვენ არ გვაქვს არსად დარჩა.
მივიღებთ, რომ შეცდომა.
>> ბუფერული overflow ფარგლებში პროგრამა.
ჩვენ გვინდა, შეიძლება სულაც არ აქვს ამოიწურა მეხსიერება იგივე გზა
რომ ჩვენ შეიძლება, თუ ჩვენ დაწყობა ამდენ ფუნქცია მოუწოდებს,
მაგრამ ჩვენ წერენ წარსულის მეხსიერება რომ ჩვენ ვიცით, ჩვენ შეგვიძლია გამოვიყენოთ.
და რომ საშუალებას გვაძლევს გავაკეთოთ ბოროტი.
ჰო?
>> ROB: დიახ, დაგვჭირდება უბრალოდ ვიმეორებ, ეს,
მაგრამ ასევე შეგიძლიათ ვფიქრობ, დასტის overflow
როგორც მინდა, კონკრეტული ტიპის ბუფერული overflow.
ან უბრალოდ ვფიქრობ, თქვენი დასტის როგორც ძალიან დიდი ბუფერული.
მაშინ, როდესაც თქვენ overflow დააწყობს, ეს არის სახის მოსწონს ბუფერული overflow.
მაგრამ დასტის overflow არის მხოლოდ კონკრეტული ტერმინი გამოიყენება, როდესაც დასტის
თავად overflows.
>> HANNAH: მარჯვენა, ასე ვიმეორებ, ვიდეო,
ეს შეგიძლიათ წარმოიდგინოთ, რომ დასტის overflow რადგან კონკრეტული ტიპის ბუფერული overflow.
მაგარი?
ნებისმიერი უფრო მეტი შეკითხვა, სანამ ჩვენ?
გასაოცარია.
>> OK, მაგარი, ასე რომ მოდით ვისაუბროთ ზოგიერთი საერთო შეცდომა შეტყობინებები.
ეს არის ის, რაც აქვს ნაჩვენები სხვადასხვა ვიქტორინებში,
ასე რომ რაღაც ღირს აღების მეორე შევხედოთ.
დარწმუნებული ვარ, რომ თქვენ შეექმნა მაინც ეს
როგორც თქვენ აკეთებთ თქვენი პრობლემა კომპლექტი.
ასე რომ დარწმუნდით, რომ თქვენ შეგიძლიათ გაიგო მათ ვიქტორინა.
>> ასე რომ, პირველი არის სეგმენტაცია ბრალია.
და ეს ნებისმიერ დროს ჩვენ ცდილობენ, რათა შეამოწმონ მეხსიერება
რომ ჩვენ არ ეძლევათ.
ასე რომ თქვენ migh არ მინახავს, მაგალითად, წარმოუდგენელი.
თუ აღმოაჩინოს კოლიზია დაბრუნების null, და მაშინ
შევეცადე, რომ რამე რომ null მნიშვნელობას,
კომპიუტერული მისცემს თქვენ სეგმენტაცია ბრალია.
ასე რომ, ერთი მნიშვნელოვანი რამ გავაკეთოთ იმისათვის, რათა თავიდან იქნას აცილებული ამ
ყოველთვის შემოწმება null.
>> თქვენ შეიძლება არ ჩანს დაფარული დეკლარაცია ფუნქცია.
ასე რომ, ეს არის ის, რაც ხდება, როდესაც Allison აჩვენა, თუ
როგორ ჩვენ პროტოტიპი, არა?
ასე ვთქვათ, ჩვენ გვაქვს ფუნქცია, რომ ჩვენ განსაზღვრავს.
მოდით ვთქვათ, კუბი.
და რომ მიდის ბოლოში ჩვენი ფუნქცია, რომლის მთავარი.
>> თუ ჩვენ დაგავიწყდებათ ვუთხრა კომპიუტერის შესახებ cube, როდესაც მთავარ ცდილობს მოვუწოდებთ cube,
კომპიუტერი იქნება, ისევე, როგორც, რა ჩემი gosh.
მე არ ვიცი, ეს რას ნიშნავს.
მე არ ვიცი, რა უნდა გავაკეთოთ, აქ.
ასე პროტოტიპი ამბობს არ ინერვიულოთ.
მე ვაპირებ გითხრათ.
>> ის მოვა.
არ დაწეროთ at me.
არ მაძლევს დაფარული დეკლარაციას ფუნქცია.
ასე რომ, თუ ეს შეცდომა, ერთი რაც თქვენ ვაპირებთ, რომ გსურთ
დარწმუნდით, რომ თქვენ გაქვთ თქვენი პროტოტიპი.
OK?
>> და ბოლო, მაგრამ არანაკლებ, გამოუცხადებელ იდენტიფიკატორი
არსებითად, როდესაც თქვენ ეცდება გამოიყენოს ცვლადი, რომ თქვენ არ გამოცხადდა.
ასე უეცრად თქვენ დაიწყოს გამოთქმა n plus plus.
კომპიუტერი და ამბობს, რა არის N?
თქვენ არ მითხრა n იყო რამ.
>> ასე რომ ერთი რამ, რომ თქვენ უნდა დავრწმუნდეთ, რომ თქვენ საერთოდ არ არის ვუთხრა კომპიუტერი რა N არის.
ასე მაგალითად, n შეიძლება იყოს მთელი რიცხვი.
და მაშინ თქვენ არ შეცდომა.
ნებისმიერი კითხვები გავრცელებული შეცდომები?
დიახ?
>> სტუდენტი: For დაფარული დეკლარაცია ფუნქციის,
შეიძლება ეს იყოს, რომ თქვენ გამოტოვებული ერთი ბიბლიოთეკების თქვენ უნდა
მოიცავს, ვიდრე პროტოტიპი?
>> HANNAH: მარჯვენა, კითხვა იყო, იქნებ
ასევე ეს შეცდომა, თუ თქვენ დაავიწყდა მოიცავს ბიბლიოთეკა.
>> სტუდენტი: დიახ.
>> HANNAH: რა თქმა უნდა, იმიტომ, რომ იგივე გზა
რომ ჩვენ გვინდა, რომ ჩვენი პროტოტიპები ადრე მთავარი ფუნქცია,
თუ ჩვენ გვაქვს ბიბლიოთეკა, იმ ვაპირებთ არსებითად მოიცავს პროტოტიპები,
მოიცავს განმარტებები ფუნქციები.
დიდი კითხვა.
>> სტუდენტი: For სეგმენტაცია ბრალია, რომ, რომელიც ასევე
მოხდება, თუ ჩვენ, ისევე, ცდილობდა წვდომის ცვლადი,
როგორიცაა, სხვადასხვა [INAUDIBLE] ვიდრე ეს გამოცხადდა?
HANNAH: რა თქმა უნდა, ისე, რომ ჩვენ მიიღოთ სეგმენტაცია ბრალია
თუ ჩვენ შევეცადეთ, რათა შეამოწმონ ცვლადი ფარგლებს?
ის იყო, რომ ამ საკითხთან დაკავშირებით?
სტუდენტი: დიახ.
HANNAH ლამაზი.
ასე რომ, ალბათ, თქვენ აპირებს მიიღოს გამოუცხადებელ იდენტიფიკატორი შეცდომა ნაცვლად.
ასე რომ, ეს მხოლოდ თქმას მე არ ვიცი, რა არის.
ზემოთ, არაფერი?
ჰო, კარგი, ლამაზი.
>> ყველა righty, ამიტომ უკან.
ამიტომ ვთქვი, რამდენიმე ჯერ რომ ჩვენ შეიძლება დასტის overflow
იმიტომ, რომ ჩვენ მოვუწოდებთ ჩვენს რეკურსიული ფუნქცია ასე ბევრჯერ.
ჩვენ ვიღებთ ყველა ამ დასტის ფარგლებში, blah, blah, blah.
რაც კი არის რეკურსიული ფუნქცია?
ასევე, რეკურსიული ფუნქცია ნებისმიერი ფუნქცია, რომელიც მოუწოდებს თავად.
>> ზოგი რამ უნდა იცოდეს, როდესაც თქვენ ახორციელებს რეკურსიული ფუნქცია,
არ უნდა დაგვავიწყდეს, რომ მოიცავს ბაზის შემთხვევაში.
ბაზის საქმე პუნქტი, რომელიც დასრულდება.
ასე, მაგალითად, თუ ჩვენ კოდირების, , ვთქვათ, Fibonacci რეკურსიული,
ჩვენ გვინდა დავრწმუნდეთ, რომ როდესაც მივიღებთ 0-ან პირველ Fibonacci ნომერი,
იმ ორი ნომერი, რომ ამ შემთხვევაში, იმიტომ, რომ ეს არ არის დამოკიდებული
რამ, რაც ადრე მოვიდა.
მათ აქვთ საკუთარი ღირებულებები.
>> რაღაც დადებითი, რათა უკან, რომელიც კითხვა, რომელიც ჩვენ ვნახეთ წარსულში ტესტებში.
ისინი შეიძლება გამოიწვიოს მოკლე, ელეგანტური კოდი.
და ბევრი ფუნქციები, ბევრი სხვადასხვა ალგორითმები,
რეალურად lend საკუთარ თავს უკან.
მათი განმარტება შეიძლება იყოს რეკურსიული და თავისთავად.
ასე Fibonacci არის.
ფაქტორიალი არის.
შერწყმა დალაგების არის one-- ყველა რამ, რომ თქვენ შეიძლება შევხედოთ.
OK, შეკითხვები?
დიახ?
>> სტუდენტი: არის კუთხეში შემთხვევაში მსგავსი ბაზის შემთხვევაში?
ან არის, რომ ზოგიერთი სხვა სახის [INAUDIBLE]?
>> HANNAH: რა თქმა უნდა, ასე რომ კუთხეში შემთხვევაში არის any-- ასე
არის კუთხეში შემთხვევაში იგივე როგორც ბაზის შემთხვევაში?
კუთხეში შემთხვევაში რამე რომ თქვენი კოდი შეიძლება მოიქცეს ცოტა განსხვავებულად.
ბაზის შემთხვევაში არის ერთგვარი დაკავშირებული, in რომ ისინი, როგორც განსაკუთრებული შემთხვევა
რომ თქვენ გვინდა შევხედოთ.
მაგრამ იდეა ბაზის შემთხვევაში არის ის, რომ გსურთ თქვენი რეკურსიული ფუნქცია
შეჩერება რაღაც მომენტში.
მას არ შეუძლია შეინარჩუნოს მოუწოდებდა თავად სამუდამოდ.
ეს უნდა შეწყდეს რაღაც მომენტში.
>> ROB: დიახ, ხშირად, თქვენი ბაზის შემთხვევებში შესაძლოა მაგალითები კუთხეში ბაზები.
>> HANNAH: მარჯვენა, cool, არაფერი?
>> სტუდენტი: იქნებ ახსნას ბაზების ცოტა მეტი?
მე არ მესმის [INAUDIBLE] ბაზის შემთხვევაში.
>> HANNAH: ბაზის შემთხვევაში?
>> სტუდენტი: Base შემთხვევაში, yeah.
>> HANNAH: Oh yeah, დარწმუნებული ვარ.
ვნახოთ.
ჩვენ არ ცარცით აქ?
დიახ, ჩვენ ვაკეთებთ.
OK, ასე რომ ძალიან სწრაფად, მე ცდილობენ წერენ დიდი საკმარისი
ასე რომ თქვენ ხედავთ ეკრანზე.
მოდით ვისაუბროთ, ნამდვილად სწრაფად, Fibonacci.
ასე რომ, მე გაძლევთ Fibonacci თანმიმდევრობა.
თქვენ შეგიძლიათ ეძებოთ განმარტება.
>> არსებითად, თითოეული ნომერი თანმიმდევრობა ეს არის თანხა, ორი წინა ნომრები.
OK, ასე რომ, ისე, რომ მე უბრალოდ აღწერილი Fibonacci,
თქვენ შეიძლება მოვისმინოთ უკან, არა?
როდესაც ვთქვი, თითოეული ნომერი არის თანხა წინა ორი ნომრები,
ჩვენ შეგვიძლია ვთქვათ, OK.
ასევე, nth Fibonacci number-- მოდით
ამბობენ, რომ ჩვენ ამ ფუნქციის მოუწოდა fib-- FIB ო
იქნება ტოლი FIB ო მინუს 1 plus-- უკაცრავად,
ჩვენ ვაპირებთ, რათა მომდევნო ხაზი მეტი აქ FIB of n მინუს 2.
>> OK, ასე რომ, ეს მუშაობს დიდი თუ თქვენ შევხედავთ, მაგალითად, ნულოვანი, ერთი,
ორი, სამი, ოთხი, მეხუთე Fibonacci ნომერი,
სადაც შეიძლება ითქვას, რომ 5 უდრის 2 + 3.
მაგრამ რა, თუ თქვენ დასაწყისში?
რა მოხდება, თუ თქვენ უბრალოდ hitting პირველი ორი ღირებულებები?
>> იმისათვის რომ ეს 1 თქვენ არ შეგიძლიათ ამბობენ რჩეულებში წინა ორი,
იმიტომ, რომ ნულოვანი and-- არ ვიცი.
ასე რომ რაღაც მომენტში, ჩვენ უნდა შეწყვიტოს.
რაღაც მომენტში, უნდა ითქვას, რომ ეს ორი უბრალოდ აქვს საკუთარი განმარტებები.
0 Fibonacci ნომერი 0.
და პირველი Fibonacci ნომერი 1.
>> ასე რომ გზა, მე შეიძლება კოდექსს, I ვიტყოდი, თუ n ნაკლებია, ვიდრე ორი,
შემდეგ დააბრუნებს n.
და ეს იქნება ჩემი ბაზის შემთხვევაში.
აი, როგორ მე ვიცი, რომ შეწყვიტოს რეკურსიული ფუნქცია.
ის არის, რომ ნათელი?
გასაოცარია.
არაფერი უკან?
ლამაზი.
>> მოდით სწრაფად საუბრობენ ძებნის და დალაგება აწარმოებს ჯერ.
და მერე მისცემს Davin ზოგიერთი დრო ვილაპარაკოთ კოდირების მაგალითები.
ასე რომ, აქ არის მთავარი ძიება და სახის, რომ თქვენ უნდა იცოდეს ამის შესახებ.
Guarantee-- მე ვერ უზრუნველყოფს, იმიტომ, რომ მე არ მინახავს quiz--
მაგრამ ეს მოდის ვიქტორინა მას შემდეგ, რაც ვიქტორინა შემდეგ დატოვა.
ასე რომ, ნამდვილად გამოიყენოს ეს სქემა.
როგორიცაა, მიიღოს ეს სქემა.
დააყენოს ის თქვენს cheat ფურცელი.
თქვენ უნდა იყოს ბედნიერი.
>> ეს გვეუბნება, პერსპექტივაში ჯერ თითოეული ამ დალაგება და ძებნის ალგორითმები.
ასე ხაზოვანი ძებნა, ხედავთ პერსპექტივაში დრო, და იგივე ორობითი ძებნა.
წავიდეთ მეტი რა ეს ალგორითმები ამის გაკეთება, იდეა.
შევხედოთ ზოგიერთი pseudocode, თუ არ თავად კოდი.
>> თქვენ ნახავთ, რომ bubble sort აქვს ზედა შეკრული, უარეს შემთხვევაში n კვადრატში.
ასე რომ, თუ ჩვენი მასივი იყო სრულიად უკან ადრე გვინდოდა დასალაგებლად ის,
ჩვენ ვთქვათ, რომ ეს არის ის, აპირებს n კვადრატში ნაბიჯები.
მაგრამ საუკეთესო შემთხვევაში, ასე ქვედა შეკრული, საუკეთესო შემთხვევაში
იქნება, თუ ის უკვე კარგად გადანაწილებული.
მაშინ ყველა ჩვენ უნდა გავაკეთოთ არის შეამოწმეთ, რომ ეს დახარისხებული.
იქ არის საკითხი აქ?
>> სტუდენტი: როდესაც გვინდა გსურთ გამოიყენოთ დალაგება?
დალაგება.
მე უბრალოდ ცნობისმოყვარე.
>> HANNAH: როდესაც რომ თქვენ გსურთ გამოიყენოთ შერჩევის დალაგება?
ეს ერთი?
ერთი, რომ n კვადრატში ორივე შემთხვევაში?
>> სტუდენტი: [INAUDIBLE].
>> HANNAH ასე რომ, ეს არის ძალიან განსხვავებული.
თუ თქვენ გაქვთ კონკრეტული მოთხოვნები თქვენს პროგრამაში,
მსგავსი რამ თუ ჩვენ უბრალოდ განაცხადა, განახორციელოს search-- ბოდიში
განახორციელოს ერთგვარი, თქვენ ალბათ მინდა წასვლა
ერთ-ერთი პირობა, რომ აქვს საუკეთესო შემთხვევაში n,
ან ქვედა ზღვარი, საუკეთესო შემთხვევაში, ო.
მაგრამ შეიძლება იყოს გარკვეული რამ, როგორიცაა, ვთქვათ,
გაცვლებს ხართ ნამდვილად ძვირადღირებული რატომღაც.
მაშინ მინდა ამის გაკეთება bubble sort, იმიტომ, რომ თქვენ
უნდა გავაკეთოთ ისე ბევრი გაცვლებს, რამ, როგორიცაა, რომ.
ნებისმიერი other-- yes?
>> სტუდენტი: თუ ეს იქნება [INAUDIBLE] ვთქვა, რომ [INAUDIBLE]?
HANNAH: ეს არის ერთ ერთი რამ რომ გითხრათ,
თუ თქვენ ეძებს განხორციელებას.
გზა მე რეალურად იმაზე, თუ რატომ ეს ო
კვადრატი არის, რომ ჩვენ უნდა აწარმოებს ჩვენი სიგრძის მასივი n,
ყოველი მიღების ყველაზე, n გაცვლებს.
და ჩვენ გვაქვს, რომ ეს პროცესი n დროს.
>> ასე რომ, როდესაც თქვენ უნდა მიიღოს ყველაზე, n გაცვლებს და n გადის მასივი,
იქ უნდა იყოს N კვადრატში.
მაგრამ დიახ, ეს იქნება გამოვლინდა ამ ორმაგი მარყუჟი,
კითხვაზე asked-- ან წყობილი ამისთვის მარყუჟის, მე უნდა ვთქვა.
OK?
>> შემდეგ შერწყმა ჯიშია, არის სწრაფი დალაგების ჩვენ ახლა
ან რომ ჩვენ დაფარული in CS50, ვიცით, რომ მთავარი ალგორითმი
ამ იდეას არღვევს დახარისხებული ცალი და შემდეგ
შერწყმის ერთად ამ დახარისხებული ბიტი.
და მიიღებს us შესვლა N შესვლა n.
რაიმე შეკითხვები ძიება და სახის სანამ მე გაიაროს ეს?
ვნახოთ.
>> Oh, დაკავშირებული სიები.
უკაცრავად, მაქვს კიდევ ერთი თემა.
OK, გასაოცარია, დაკავშირებული სიები.
პრობლემა მასივები, მათ აქვთ ფიქსირებული ზომა.
ასე რომ, თუ თქვენ არ იცით, თუ როგორ დიდი თქვენი შეყვანის იქნება,
თქვენ არ მინდა, რომ შევქმნათ მასივი.
იმიტომ, რომ თუ ჩვენ შევქმნით მასივი, რომელიც არის ძალიან პატარა,
ჩვენ შეიძლება აწარმოებს შევიდა ბუფერული overflow.
>> ამიტომ ჩვენ შეიძლება რაღაც უკავშირდება სიები, რომელიც
საშუალებას გვაძლევს დინამიურად ზომის მონაცემები სტრუქტურა
რომელიც საშუალებას მოგვცემს შესანახად უფრო მოქნილი რაოდენობით მონაცემები.
ასე რომ თითოეული კვანძის ჩვენს უკავშირდება სია, ჩვენ გვაქვს ორი ცალი.
გვაქვს ფაქტობრივი არც ის, რომ ინახავს.
ასე რომ მხოლოდ ის, რაც თქვენ, იხილეთ მასივი, მაგალითად.
და მაშინ ჩვენ ასევე ტრეკზე მომცეთ შემდეგი რამ მეხსიერებაში.
>> განსხვავებით მასივები, რომელიც ჩვენ ვიცით, ყველა აპირებს
to be-- მასივი ელემენტები არიან ერთი მიყოლებით მეხსიერება უკავშირდება
სიები შეიძლება იყოს სადმე მეხსიერება.
ისინი თვითნებური.
ასე რომ, თუ ჩვენ უნდა რეალურად წასვლა, ჩვენ
უნდა შევინარჩუნოთ სიმღერა შემდეგი რამ ჩვენს სიაში.
>> და მაშინ, იმისათვის, რომ ვიცი სადაც, რომ სიაში, როგორც მთელი,
ჩვენ უნდა შევინარჩუნოთ სიმღერა არის ძალიან პირველად ელემენტს უკავშირდება სიაში.
და რომ ყველაფერს საშუალებას გვაძლევს შეასრულა.
>> ასე რომ, ეს არის, თუ როგორ შეიძლება განისაზღვროს რეჟიმში.
ეს არის დიდი შესაძლებლობა ისარგებლოს structs.
იმის გამო, რომ თქვენ გაქვთ ეს იდეა, ისევე, მოცემული კვანძის, მაქვს ორი ცალი.
მაქვს ფაქტობრივი ღირებულება თავისთავად.
და მაშინ მე უნდა მომცეთ მომდევნო ელემენტს უკავშირდება სიაში.
ასე რომ, ხედავთ, ჩვენ გვაქვს მთელი რიცხვი n, რომელიც იქნება რეალური ღირებულება,
და მერე მომცეთ კვანძის მოუწოდა შემდეგი.
ასე რომ, ეს იქნება შემდეგი ელემენტს უკავშირდება სიაში.
სტუდენტი: დიახ?
ნუ თქვენ უნდა მიუთითოთ, რომ ვარსკვლავი, როგორც struct?
>> HANNAH: დიახ, ასე, რადგან ეს თითქმის ისევე, როგორც სახის,
როგორც ჩანს, რეკურსიული განმარტება, რომ ჩვენ
უნდა იცოდეს, რა კვანძის შიგნით მოძიებაში კვანძში.
მას შემდეგ, რაც ფაქტობრივად არ იცით, რა კვანძის სრულიად
სანამ არ მივიღებთ ბოლომდე ამას და ამის შემდეგ ჩვენ შეგვიძლია მხოლოდ მას
კვანძში შიგნით განმარტება, ჩვენ უნდა ეძახით struct კვანძში.
დიდი კითხვა.
არაფერი?
დიახ?
>> სტუდენტი: რატომ უნდა ვთქვა კვანძის ორჯერ?
იმიტომ, რომ როდესაც ჩვენ [INAUDIBLE] ჩვენ უბრალოდ უნდა გავაკეთოთ ეს მძიმით,
მაგრამ ახლა ჩვენ უნდა მოვძებნოთ რომ struct კვანძის? [INAUDIBLE].
HANNAH: მე მჯერა, ბოლო მაგალითად,
ჩვენ უბრალოდ შექმნაში ნებისმიერ დროს გამოყენება სურდა სტუდენტი შემდეგ, თქვენ
უნდა გამოვიყენოთ struct კვანძში მე ბოდიში struct სტუდენტი.
ეს მოგვცა, მას შემდეგ, ფაქტობრივად, მხოლოდ გამოყენების კვანძის დაამატოთ ახალი ტიპის, არსებითად.
აზრი?
ასე რომ ჩვენ გვინდა უნდა დაბრუნდეს და შევხედოთ კოდი ადრე.
მაგრამ ვხვდები, რომ ჩვენ არ გამოიყენოს typedef.
და ჩვენს კითხვაზე, რატომ უნდა გამოვიყენოთ typedef?
Typedef საშუალებას გვაძლევს თავიდან ავიცილოთ სიტყვა struct დასაწყისში.
დიახ?
სტუდენტი: რა სახის კითხვები ამუშავება
თვალსაზრისით თვალსაზრისით კვანძების და უკავშირდება სიები?
>> HANNAH: ასე რომ ერთი რამ შეიძლება ითქვას, თუ როგორ შეიძლება თქვენ ძებნის საშუალებით უკავშირდება სიაში?
OK, იმიტომ, რომ ეს ცოტა უფრო რთული
მეტი თუ ჩვენ ეძებს მეშვეობით მასივი.
ჩვენ შეგვიძლია შევჩერდეთ ელემენტს ნულოვანი, ელემენტით ერთი ელემენტი, ორი, blah, blah,
blah.
თუ ჩვენ გვინდა, ძიება მეშვეობით უკავშირდება სიაში,
ჩვენ გვინდა რეალურად უნდა დაიცვას ამ პატარა maze მითითებას.
მოდით რეალურად წასვლა ამ მართლაც სწრაფად.
რისი გაკეთება შეგვიძლია ამ შეკვეთა რომელთა მიზანია ვთქვათ
მინდა უბრალოდ iterate მეშვეობით ჩვენი მთლიანად უკავშირდება სიაში.
ჩვენ დაიწყება ხელმძღვანელი.
და მაშინ, იმისათვის, გადატანა მომდევნო ელემენტს,
ნაცვლად მხოლოდ დამატება ერთი როგორც ჩვენ, შესაძლოა გადის მასივი,
ჩვენ რეალურად აპირებს დაიცვას შემდეგი მაჩვენებელი,
ასე რომ შეგიძლიათ სადაც მეხსიერება შემდეგი ელემენტი.
ასე რომ, მე ვიცი, რომ ეს არ არის საკმარისი მიიღოს ეს ყველაფერი ახლა,
მაგრამ თქვენ უნდა ეს სლაიდები.
ასე რომ თქვენ შეგიძლიათ გადის ეს ცოტა უფრო ნელა.
მაგრამ არსებითად, რაც ჩვენ გვინდა რომ გააკეთოთ, არის დაიცვას ამ მითითებას
მეშვეობით მთლიანად უკავშირდება სიაში.
ასე რომ, ეს არის საკითხი, თქვენ შეიძლება სთხოვა.
>> რაღაც შეამჩნია ერთად ჩასმა, ვთქვათ,
გვინდოდა ახალი ელემენტი წინ ჩვენი უკავშირდება სიაში.
ჩვენ უნდა ვიყოთ ძალიან ფრთხილად, შესახებ ბრძანება, რომელშიც ჩვენ
გადაიყვანა მითითებას.
იმის გამო, რომ ვთქვათ, მე მხოლოდ ის განაცხადა, OK.
რათა უფროსმა წერტილი ამ ახალ ელემენტს.
მხოლოდ ის აღვნიშნო, რომ 1 შემდეგ, ჩვენ არსებითად დაკარგა დანარჩენი ჩვენი სია,
იმიტომ, რომ მე არ მახსოვს, სადაც 2 სიცოცხლე.
>> ამიტომ, ჩვენ უნდა გავაკეთოთ ძალიან კონკრეტული მიზნით.
პირველი, ჩვენ ახალი ელემენტის წერტილი ხელმძღვანელი.
და მაშინ ჩვენ ხელმძღვანელი აღვნიშნო, რომ ახალ ელემენტს.
ასე რომ, ვნახოთ რა, რომ ჰგავს ერთად arrows-- ისევე, რომ.
ასე რომ თქვენ პირველი უნდა ახალი ელემენტის წერტილი ძველი ხელმძღვანელი.
და ახლა, ჩვენ გვაქვს ხელმძღვანელი აღვნიშნო, რომ პირველ ელემენტს.
რაიმე შეკითხვები ამ საკითხთან დაკავშირებით?
>> OK აქ არის რამდენიმე კოდი ერთხელ, რაღაც შევხედოთ ცოტა მოგვიანებით.
და ახლა აქციოს ეს მეტი Davin for GDB და ცოტა პრაქტიკა
კოდირების ქაღალდზე.
ლამაზი.
>> ROB: Rob.
>> HANNAH: Oh, Davin და Rob.
მე ბოდიში.
>> სტუდენტი: Woo!
>> ROB: მადლობა.
>> Davin: არ მინდა ვთქვა, ყველაფერი რეალური სწრაფი?
ROB: Yeah, yeah.
Davin: მას შემდეგ, რაც მე up.
OK, ხოლო Rob აყენებს მიკროფონი, ასე რომ GDB?
ყველას უნდა სცოდნოდა, GDB in კლასი და ასევე საათებში.
და თქვენ უნდა იყოს მისი გამოყენება.
რა არის GDB?
ვინმეს?
>> სტუდენტი: ეს debugger.
>> Davin: ეს debugger.
და რას ნიშნავს ეს საშუალებას გაძლევთ ამის გაკეთება?
როგორიცაა, რატომ მოსწონს GDB?
სტუდენტი: შეანელებს პროგრამა.
Davin: მარჯვენა, შეგიძლიათ ფეხით მეშვეობით, როგორიცაა ადამიანის ტემპებით.
ასე რომ, რა არის გარკვეული ბრძანებები შეგიძლიათ გააკეთოთ?
ასევე, შესვენების ალბათ თქვენი საყვარელი ბრძანება.
იმის გამო, რომ, რომელიც საშუალებას გაძლევთ შესვენება პროგრამა და რეალურად გავლა
ხაზს.
>> Run გაძლევთ საშუალებას აწარმოებს.
შემდეგი, როგორიცაა სტეპინგზე მეშვეობით.
რა არის შორის მომავალი და ნაბიჯი?
დაველოდოთ, ამბობენ, რომ ხმამაღლა.
ეს იყო სწორი.
>> სტუდენტი: [INAUDIBLE].
>> Davin: დიახ, რა.
ამიტომ მინდა, მომავალი და ნაბიჯი, თუ you're-- ვთქვათ თქვენ გაქვთ ფუნქცია, თქვენ
განსაზღვრავს.
მოდით ამბობენ თქვენს მთავარ ფუნქციას, და თქვენ მხოლოდ დარტყმის შემდეგ, მომდევნო,
შემდეგი.
თქვენ რეალურად აპირებს შეასრულოს ეს ფუნქცია,
მაგრამ თქვენ ნახტომი მეტი იგი.
თუ თქვენ მოხვდა ნაბიჯი, ან ან რასაც, თქვენ
აპირებს რეალურად გადასვლა რომ ფუნქცია,
და მაშინ მოხვდა შემდეგი რომ სხვადასხვა ზარები
შიგნით რომ ფუნქცია.
ჰო?
>> სტუდენტი: არის გზა ხტომა, როგორიცაა, უკან out?
Davin: Finish, yeah, დასრულდება აირჩიე თქვენ out.
ასე რომ, ეს უნდა დაასრულოს ამ ფუნქცია, და შემდეგ თქვენ
იქნება უკან მთავარ მაგალითად.
Print ამობეჭდოთ ერთ დროს.
რაღაც მე ყოველთვის ვიყენებ, არის ჩვენება.
ჩვენება ამობეჭდოთ მუდმივად მთელი მთლიანად
თქვენი პროგრამა.
>> მაგალითად, თუ თქვენ ამისთვის მარყუჟის, და თქვენ
გვინდა, რომ რაღაც იცვლება, და თქვენ არ მინდა, მინდა, მუდმივად
უნდა აკეთებს როგორც ბეჭდვითი, ბეჭდვა, ბეჭდვა, ჩვენება
ცარიელია, რომ ცვლადი მუდმივად, ყოველ დროს, თქვენ მოხვდა შემდეგი.
და გაგრძელდება.
ასე GBD, რომ GDB.
>> სტუდენტი: რა არის ერთი სადაც თქვენ [INAUDIBLE]?
Davin: რა არის ეს?
>> სტუდენტი: რა არის the-- ადგილობრივი ცვლადები.
ROB: არსებობს რაღაც რეალურად როგორც ადგილობრივები ან რამე.
სისტემაში მე can not
>> Davin: ეს შეიძლება იყოს რაღაც რომ, yeah.
>> HANNAH: In ადგილობრივები?
>> Davin: ეს არის ის.
ეს ერთი.
ROB: Beautiful.
>> Davin: ჰო.
>> სტუდენტი: რას გაგრძელდება ამის გაკეთება?
>> Davin: ეს continues-- ისე უბრალოდ აპირებს გააგრძელოს თქვენი პროგრამებს.
ასე რომ, თუ თქვენ შესვენება და მოხვდა გაგრძელდება, ის აპირებს
მხოლოდ აწარმოებს, რომ პროგრამის სანამ გაიტანა რომ შესვენების ერთხელ.
ასე მაგალითად, თუ თქვენ მა ფუნქცია,
და თქვენ ვაპირებთ გავაკეთოთ, როგორიც მარყუჟი ან რამე მაგდაგვარს,
და თქვენ მოხვდა გაგრძელდება, ის აპირებს გაგრძელდება და დაბრუნდეს, რომ შესვენება.
ან არ არსებობს შესვენება, ის აპირებს გაგრძელდება და დასრულდება პროგრამა.
>> ROB: ასე რომ, ისევე აწარმოებს გაჩერება პირველივე breakpoint
თქვენ მოხვდა, თუ მაშინ მოხვდა გაგრძელდება, ეს გავაგრძელებთ
აპირებს, სანამ ის შემდეგი breakpoint.
და შემდეგ გააგრძელოს წავა შემდეგი breakpoint.
Davin: სხვა კითხვები GDB?
ამიტომ, მე ვფიქრობ, რომ წარსულში, ჩვენ ვთხოვეთ, თუ რა
GDB და მისცეს მაგალითად ზოგიერთი რამ,
შეუძლია გააკეთოს GDB, ასე რეალური მარტივი, მაგრამ yeah.
იქ წასვლა.
და კვანძების?
>> ROB: დიახ, ასე, რა მიმართულებით იყო ეს?
სტუდენტი: ეს იყო იგი.
Davin: დაველოდოთ.
ROB: ეს ბიჭი?
Davin: ეს ერთი.
ROB: ეს ბიჭი, რა, მე არ ესმოდეს.
ასე რომ, ჩვენ არ იყო ნათელი, თუ რა the-- მე არ
ვიცი, ვინც ეს იყო, მაგრამ კითხვა.
ჩვენ არ ვიცით, ზუსტად რა ითხოვდნენ, რომ ამის შესახებ, ისე უბრალოდ
განვმარტო, რაღაც.
ასე რომ, პირველი, როგორც უკვე ვთქვი, typedef თქვენ ყოველთვის გამოყენებით მხოლოდ
შექმნა მეტსახელი ტიპის.
ასე რომ სწორედ აქ, მეტსახელად ჩვენ შექმნა არის ამ ტიპის struct კვანძში.
>> ასე რომ, პირველი, იგნორირება ამ კვანძის typedef, ასე რომ, ეს struct კვანძის curly
გაუწიოს ქვემოთ შემდეგი curly გაუწიოს არის struct კვანძის ტიპის.
და ჩვენ გვჭირდება, რომ კვანძის იქ, იმიტომ, რომ ჩვენ
უნდა მითითებას კვანძის აქ.
ასე რომ, ამ სახის რეკურსიული struct, თქვენ უნდა მისცეს ამ struct სახელი,
ანდა თქვენ ვერ ამბობენ struct კვანძის აქ.
მანამდე სტუდენტი როდესაც ჩვენ აკრეფილი, ვფიქრობ,
ჩვენ არ უნდა ვთქვათ, სტუდენტი იქ, იმიტომ, რომ ჩვენ
არ უნდა ვთქვა struct სტუდენტი შიგნით struct თავად.
ასე რომ, ეს რეკურსიული, რომ გვაიძულებს ვთქვა კვანძის არსებობს.
>> ამ კვანძის არის მხოლოდ სახელი, ჩვენ ვაძლევთ კვანძის typedef.
ისე, რომ კვანძი არ არის იგივე, რაც კვანძი.
მაგრამ ეს struct კვანძის არის იგივე, რაც struct კვანძში.
Davin: ასე რომ, როდესაც თქვენ მოვუწოდებთ, როგორიცაა, node თქვენს მთავარ ფუნქციას,
თქვენ არ აპირებს უნდა ვთქვა struct კვანძში.
შეგიძლიათ უბრალოდ, ვამბობთ კვანძის, რადგან კვანძში არის different-- ძირითადად
თქვენ ამბობდა, OK.
ნაცვლად, რომელმაც უნდა ზარები struct კვანძის ჩემი კოდი,
მე უბრალოდ მინდა გადარქმევა მას როგორც კვანძის გაუადვილებს.
>> ROB: თუ თქვენ ყოველთვის გამოყენება typedef, მაშინ ეს
ეს არის ერთადერთი ადგილი, თქვენ აპირებს აქვს განაცხადოს ცვლადი ერთად struct კვანძის
ვარსკვლავი, yeah.
>> Davin: OK, ასე რომ ბოლო ნაწილი ძნელია ასწავლიან იმიტომ,
ROB: რა?
>> Davin: იმიტომ, რომ ის კოდირების ქაღალდზე.
ასე რომ, ყოველ წელს ჩვენ გვაქვს კოდი ქაღალდზე შეკითხვებს.
ასე რომ, ვფიქრობ, გასულ წელს, 12 80 ქულა იყო კოდი ქაღალდზე.
წლით ადრე, რომ 10 out of 80, წლით ადრე, რომ 20 100,
ასე რომ საკმაოდ რამდენიმე მათგანზე.
ასე რომ თქვენ უნდა შეძლებს კოდი up ამ ფუნქციების ხელით.
>> მე figured ჩვენ შეიძლება გავლა რამდენიმე მათგანი და ვნახოთ, როგორ ხალხი,
სახის გავლა მათ ნელ-ნელა ხალხს.
ასე რომ, ზოგადად, strlen და atoi უკვე ძალიან პოპულარული.
გასულ წელს, ვფიქრობ, GetPositiveInt და RandomInt.
მაგრამ pow, ისე ხელისუფლებაში, ასევე პოზიტიური იყო.
მოდით უბრალოდ გავლა, შესაძლოა, ერთი ან ორი ერთად.
რა სურს ხალხს, რომ?
>> სტუდენტი: atoi.
სტუდენტი: Yeah.
Davin: atoi?
სტუდენტი: [INAUDIBLE].
Davin: OK, მე ვაპირებ ამის გაკეთება ფორუმში.
გაქვთ უპირატესობა თუ მე აქ ან იქ?
იქ, Gabe ამბობს, რომ არსებობს.
>> ROB: ეს არის ზოგადი აზრები ამ კოდირების შეკითხვებს.
ცდილობენ რაღაც დავწერო.
არ დატოვოთ ცარიელი.
>> Davin: დიახ.
ROB: თუ შეგიძლიათ მიიღოთ დაბრუნების ტიპის არის სწორი,
ან იქნებ ჩვენ, შესაძლოა, მას თქვენ, მაგრამ თუ შეგიძლია, ისევე,
წერენ ზოგადად ფუნქციის ხელმოწერა, თუ შეგიძლიათ მიიღოთ ბაზის შემთხვევაში სწორია,
ან კუთხეში შემთხვევაში, ან დამახსოვრების შემოწმება null,
რადგან თქვენ გაქვთ გარკვეული რამ, მაშინ, შესაძლოა,
მოგცემთ რამდენიმე მიუთითებს, რომ პრობლემა.
არ დატოვოს ცარიელი.
>> Davin: დიახ, და თუ უბრალოდ სრულიად
დაბნეულები, თუ როგორ უნდა რეალურად იქცეს კოდი.
თუ წერთ pseudocode, ეს საკმაოდ კარგი ძალიან.
ასე რომ მოსწონს, ეს ექვსპუნქტიანი კითხვა, და წერთ სწორი pseudocode,
თქვენ მიიღებთ მინიმუმ ორი ქულა.
ასე რომ არ დატოვოს მათ ცარიელი.
ვცდილობთ, რომ რაღაც.
>> ROB: ეს უნდა იყოს სწორი pseudocode, თუმცა.
>> Davin: დიახ.
ROB: ასე რომ, ჩვენ, როგორც წესი, ნაკლებად გამო შეცდომები pseudocode.
Davin: OK, ასე რომ თქვენ ბიჭები სურდა, რომ atoi.
OK, ასე რომ მხოლოდ ნამდვილად ასე რომ თქვენ გსურთ ამის გაკეთება
თქვენ აპირებს იყოს მოცემული რაღაც ნომერი.
თუმცა, ეს რაოდენობა არ არის იქნება int, არა?
რა არის ეს იქნება?
>> სტუდენტი: [INAUDIBLE].
>> Davin: ეს იქნება სიმებიანი, არა?
ასე რომ, თუ თქვენ გადაეცათ სიმებიანი ვთქვათ
>> ROB: უნდა გაიყვანოს up რედაქტორი?
შემიძლია დახევის up--
>> Davin: Oh, თქვენ გსურთ ამის გაკეთება on--
>> ROB: გირჩევნიათ ფორუმში?
>> Davin რას უნდა გავაკეთოთ?
ვგულისხმობ, ხომ არ გსურთ ამის გაკეთება ხელით?
თუ თქვენ გსურთ ამის გაკეთება კომპიუტერის?
>> ROB: ამას ხელით.
>> Davin: [იცინის]
ROB: ამას ხელით.
>> Davin: OK, ასე რომ, ეს იქნება atoi.
რა არის it-- ვგულისხმობ, ჩვენ ალბათ მისცემს ეს თქვენ.
მაგრამ რა არის ის აპირებს დაბრუნებას?
>> სტუდენტი: Int.
>> Davin: ეს დაბრუნებას აპირებს int, არა?
So-- მე არ მინდა ამის გაკეთება არის.
მე ამას აქ.
>> ROB: თქვენ შეგიძლიათ მისი დანგრევა და შემდეგ დააყენებს მასზე.
>> Davin: yeah.
[იცინის] თამაშის ცვლილება.
OK, ასე რომ, ეს იქნება int atoi, და რა არის ის აპირებს?
Char ვარსკვლავი, ასე რომ მხოლოდ string, ვარსკვლავი s, როგორიცაა, რომ.
>> ROB: Nice ვარსკვლავი, ლამაზი.
Davin: ეს არ უნდა იყოს იქ, OK.
ROB: ჰო.
Davin: OK, ასე რომ პირველი რამ გსურთ გააკეთოს I
არ ვიცი, თუ ვინმეს ეძებდნენ პრაქტიკას solutions--
მაგრამ, თუ რას აპირებს გსურთ, რომ თქვენ
აპირებს სურთ მარყუჟის, იმიტომ, რომ თქვენ
აპირებს გვინდა, რომ რეალურად ნაბიჯი მეშვეობით ამ სიმებიანი.
ასე helpful-- ასე ვთქვათ, ჩვენ ვაპირებთ ამისთვის მარყუჟის,
და ჩვენ ვაპირებთ, რომ ნაბიჯ მეშვეობით ყველა ელემენტის მისაღებად.
რამდენ ხანს არის ეს?
რამდენჯერ მივდივართ უნდა iterate, რომ მარყუჟი?
სტუდენტი: Sterln?
Davin: Sterln, yeah.
ასე ვთქვათ int სიგრძე შეადგენს sterln s.
და უბრალოდ აინტერესებს, რატომ არის ის ყოველთვის სახის უკეთესი უნდა გააკეთოს ამ გარეთ მარყუჟების?
როგორიცაა, რატომ არის უკეთესი მოვუწოდებთ ამ ფუნქციის გარეთ loop?
უბრალოდ სწრაფი საღი აზრის შეამოწმოს?
ჰო?
სტუდენტი: ასე რომ თქვენ არ უნდა შევინარჩუნოთ შემოწმების.
თქვენ შეგიძლიათ უბრალოდ [INAUDIBLE].
>> Davin: სწორედ ასე yeah, ზუსტად რა განაცხადა მან.
ამიტომ, ჩვენ არ უნდა შევინარჩუნოთ შემოწმების.
ასე მაგალითად, თუ მე მოუწოდებენ ამ ფუნქციის შიგნით მარყუჟის,
მაშინ მე ვაპირებ შენარჩუნება მოუწოდებს ამ ფუნქციის რამდენჯერმე.
და რომ აპირებს შეამციროს ეფექტურობის თქვენი პროგრამა.
ასე რომ ყოველთვის სასარგებლო განაცხადოს გარეთ.
>> ROB: ეს თქმით, ნებისმიერი ეს პრობლემა,
საკმაოდ ბევრი, რადგან თქვენ სამუშაო ხსნარი, თქვენ მიიღებთ სრულ საკრედიტო.
ასე რომ არ ინერვიულოთ, თუ თქვენი დიზაინის აბსოლუტურად საშინელი.
შესაძლოა, ჩვენთვის დაარღვიოს კითხულობს თქვენს კოდი.
მაგრამ რადგან იგი მუშაობს, თქვენ მიიღებთ რაოდენობა.
>> Davin: დიახ.
OK, ასე შემდეგ მე ვაპირებ ვაცხადებ ცვლადი.
უბრალოდ ვაპირებ მოვუწოდო int თანხა.
და მე ვაპირებ მითითებული ეს ნულის ტოლია, როგორიცაა, რომ.
და ეს მხოლოდ აპირებს იყოს placeholder.
ასე რომ, ეს იქნება რა მე ვაპირებ დაბრუნებას.
ამიტომ, მე ვაპირებ, რათა საბოლოოდ დაბრუნებას თანხა ამ პროგრამაში.
ასე რომ, მე ამ ორ ცვლადს.
მაქვს სიგრძეზე.
მაქვს თანხა.
და ახლა მოდით ხტომა შევიდა ჩვენი სიმებიანი.
>> ასე რომ, მოდით გვაქვს ჩვენი ამისთვის loop.
ისე ოთხი int მე შეადგენს 0 w, ხოლო მე ნაკლებია, ვიდრე სიგრძეზე I plus plus.
და ახლა
ROB: Nice.
Davin: OK, და ახლა აქ მოდის ხორცი ჩვენი კოდი.
ასე რომ თქვენ შეგიძლიათ რეალურად გავაკეთოთ ეს, ძირითადად, ერთ ხაზზე.
ასე რომ ვინმეს აქვს იდეა ის, რასაც ჩვენ ვაპირებთ, რომ გავაკეთოთ შემდეგი?
OK, ასე რომ, OK.
ასე ვაკეთებთ ვთქვა თანხა შეადგენს მიადევნე თვალი დადის ამ over-- თანხა
უდრის თანხა 10-ჯერ plus-- ჩვენ აპირებს s I მინუს ერთი
რეიტინგი 0 ერთი ციტატა კეთდება, როგორიცაა, რომ.
ROB: ძალიან ინტუიტიური.
>> Davin: გაანადგურა იგი.
OK, ასე რომ someone-- მე მივიღე ეს, მე მივიღე ეს.
OK, ასე რომ, ეს აშკარად იზრდებოდა.
რას ნიშნავს ეს?
ასე რომ ვინმეს იცით ეს რას ნიშნავს?
შეიძლება ყველას, რომ ეს?
არა, არავინ ხედავთ, OK.
მე ვაპირებ, რომელთა მიზანია:
>> ROB: მე ვაპირებ დაწერა ფორმულა მხოლოდ უფლება აქ.
Davin: OK, რობ აპირებს ამის გაკეთებას კომპიუტერი, რომელიც არის fun.
ROB: Oh ღმერთი ჩემი.
ან მე არ.
Davin: ლოდინის.
სტუდენტი: მე მაქვს შეკითხვა.
Davin: ჰო, რა თქმა უნდა.
სტუდენტი: [INAUDIBLE]?
Davin: OK, ასე რომ, რეალურად, , უბრალოდ, ზოგადად,
თუ თქვენ უნდა დააყენოს, ისევე, ამ დეკლარაციის int
I უდრის 0 მძიმით სიგრძე უდრის sterln, that--
>> სტუდენტი: [INAUDIBLE].
>> Davin: ეს ჯარიმა, რადგან that--
სტუდენტი: თქვენ რატომ კი უნდა გამოვიყენოთ სიგრძე?
რატომ არ ჩვენ უბრალოდ [INAUDIBLE] sterln s, ისევე როგორც მთელი დრო [INAUDIBLE]?
>> Davin: თქვენ ნიშნავს აქ?
>> სტუდენტი: დიახ.
Davin, რადგან ყველა დროის ამ for loop გადის,
ის აპირებს შეაფასოს მდგომარეობა.
სტუდენტი: Right.
Davin: თუ თქვენ გაქვთ sterln არსებობს, მაშინ ეს
აპირებთ უნდა სინამდვილეში რომ ფუნქცია თითოეული დრო.
ასე რომ ნაცვლად მხოლოდ შედარებით ეს int,
თქვენ აპირებს იყოს მოუწოდებდა ფუნქცია და შემდეგ შედარებით
დაბრუნების ღირებულება.
ჰო, ისე, უბრალოდ, yeah.
>> ლამაზი, OK, ასე რომ, ახლა ყველას შეუძლია დანახვა.
რა აკეთებს ეს მოსწონს, ეს არის ის.
ეს არის ჯემი, უფლება აქ.
რას ნიშნავს ეს?
რა ვარ მე აკეთებს?
ჰო, იდეა?
ჰო?
>> სტუდენტი: ისე, ასე რომ, როდესაც თქვენ შემოსვლა მასივი,
თქვენ იქნება აპირებს მარცხნიდან მარჯვნივ,
ასე რომ თქვენ იქნება მიმდინარეობს ათწილადები ქვემოთ [INAUDIBLE].
Davin: ზუსტად.
სტუდენტი: ასე რომ თითოეული თქვენ უნდა გავამრავლოთ
რას დაინახა, როგორც ღირებულება int მიერ ახლა თქვენ გადატანა, რომ ერთ-ერთ.
>> Davin: Perfect, სრულყოფილი, ასე მაგალითად, მოდით
ამბობენ მივეცი you-- ვარ აპირებს დაწეროს აქ.
არა, მე არ ვარ.
მე ვაპირებ წერენ აქ.
ვთქვათ, მე მისცა თქვენ 76, არა?
ვთქვათ, მე მოგცემთ 76.
რომ სიმებიანი დაიწყოს, OK?
>> ამიტომ სიგრძით რა არის?
2, არა?
თანხა 0.
მაშინ ჩვენ ხტომა ჩვენი ამისთვის loop.
OK, პირველ iteration ეს, რა იქნება კი ეს?
ეს იქნება თანხა 0.
ასე მთლიანობაში 10-ჯერ 0.
რომ არის უაზრო.
მერე რას აკეთებთ?
სტუდენტი: [INAUDIBLE].
>> Davin: იგი აპირებს გახდეს, რომ ხასიათი მთელი რიცხვი, არა?
ეს არის სახის, როგორიცაა თქვენი პრობლემა კომპლექტი ამ light--
ეს არის სახის მოსწონს ერთად პრობლემა კომპლექტი Visioneer.
თქვენ საქმე ASCII ღირებულებებს.
ასე რომ, თუ მე გაძლევთ, როგორიცაა, შვიდი, მაგრამ ეს ხასიათი,
და თქვენ გაინტერესებთ, დიახ, რა ციფრი არის ეს?
ჰო, შეიძლება, yeah.
ასე რომ, რა ციფრი არის ეს?
თქვენ შეიძლება სხვაობა 0-დან, მაგრამ თქვენ უნდა გამოვაკლოთ 0, ხასიათი.
>> და სადაც ზოგიერთი ადამიანი მისაღებად იმყოფებოდა up, ისინი
როგორიცაა, OK, კარგად, მე არ ვიცი ASCII ღირებულებებს ამ ვიქტორინაში?
არა, თქვენ ნამდვილად არ უნდა იცოდეთ ASCII
ღირებულებები, ისევე, როგორც ამას a, ზედა, ნულოვანი.
>> ROB: არ არსებობს მიზეზი, რომ ოდესმე დააყენოს ამ cheat ფურცელი.
>> Davin: ნამდვილად არ დაკარგავთ სივრცეში ამ.
შეგიძლიათ ფაქტიურად მხოლოდ ნაცვლად ამბობდა, 48, როგორიცაა უფლება
არსებობს, რომელიც უდრის ამბობდა ერთი, ერთი აპოსტროფი,
როგორც, რომ, ზუსტად იგივე.
>> ROB: თქვენ შეიძლება თითქმის ვფიქრობ, მას, როგორც if-- ღმერთს, მე მჭირდება,
oops-- შეგიძლიათ თითქმის ვფიქრობ, რომ ეს თითქოს ჩვენ გვაქვს რაღაც, რომ hash
განისაზღვროს 0, 48.
რომ არ იმუშავებს.
მაგრამ ვფიქრობ, რომ ეს ერთი გაცემა 0 ერთი გაცემა და ყველა სიმბოლოს.
ვფიქრობ, რომ ეს მუდმივი, რომ წარმოადგენს, რომ ASCII ღირებულება.
>> Davin: დიახ.
OK, ასე რომ, პირველი მეშვეობით, ისე ერთად 76-- ისე პირველი მეშვეობით,
ეს არის მხოლოდ გმირი 7 მინუს ხასიათი 0
და იმ შვიდი რიცხვებით ასევე, იმ
შვიდი ფართები დაშორებით თითოეულ სხვა on ASCII ჩარტში ან რასაც.
ასე რომ დაბრუნებას აპირებს int 7.
ახლა, თანხა შეადგენს 7.
>> OK, ასევე, მოდით ხტომა ამ for loop ერთხელ.
OK, ახლა ეს თანხა 10-ჯერ.
ასე რომ თქვენ ეფექტურად მოძრავი 7 მარცხენა.
ამჯამად რომ აზრი?
თქვენ ეფექტურად მოძრავი მას მარცხენა.
>> და მაშინ add-- ეს იქნება 6 მინუს 0.
ეს არის ის, 6.
ასე რომ, ეს იქნება 70 + 6.
76, რომ თქვენი ნომერი.
ასე რომ, მიუხედავად იმისა, თუ რა რაოდენობის მივეცი თქვენ, ნელა უბრალოდ
აპირებს გადაეტანა დიდი ფასეულობები მარცხენა, 1 ფაქტორი 10
ყოველ ჯერზე ამისთვის მარყუჟის, და შემდეგ დაამატოთ, როგორც საჭიროა.
>> In უკან?
სტუდენტი: ჩვენ არ უნდა გავაკეთოთ ნებისმიერი შემოწმების პროგრამაში?
>> ROB: ასე რომ როგორც შემოწმების მიდის პროგრამა,
ჩვენ გვინდა გითხრათ, საკმაოდ ბევრი ის, რაც თქვენ უნდა შეამოწმოთ.
თუ ჩვენ არ გეტყვით არაფერი, მაშინ, როგორც წესი,
ვივარაუდოთ, თქვენ უნდა შეამოწმოთ საუკეთესო რამ.
როგორც თქვენ შესაძლოა, უბრალოდ უნდა იყოს უსაფრთხო, ალბათ შეამოწმეთ hey, არის s null?
მაშინ მე არ ვიცი, რა უნდა დაბრუნდეს.
მაგრამ ჩვენ რომ გითხრათ, ამ სახის რამ.
0, მე არ ვიცი.
>> Davin: და რატომ გსურთ გადაამოწმოს თუ ტოლია null?
სტუდენტი: [INAUDIBLE].
Davin: იმის გამო, რომ char ვარსკვლავი.
ეს მაჩვენებელი.
ასე რომ, სავსებით მისაღებია დეკლარაცია, მე ვერ ვიტყვი, OK,
s შეადგენს null, იმიტომ, რომ ეს შეიძლება იყოს მომცეთ null.
ასე რომ, როდესაც თქვენ უნდა პოინტერები თქვენი გზა, როგორც ეს,
თქვენ უნდა ალბათ შემოწმება.
იმიტომ, რომ თუ არ შეამოწმოს, რომ, და მაშინ, შემდეგ კი თქვენი მარყუჟის,
და თქვენ აკეთებს დადის ქვემოთ.
დადის ქვემოთ.
>> ROB: უკაცრავად, რომ არის ის.
>> Davin ასე რომ, როგორიცაა, თუ ეს არის null, და მაშინ
ამის გაკეთება, რა შეცდომა თქვენ აპირებს მიიღოს?
სტუდენტი: თქვენ აპირებს მიიღოს კომპლექტი ბრალია.
Davin: თქვენ შექმნას აპირებს ბრალია, უფლება, რადგან თქვენ
ცდილობს ინდექსი null.
ასე რომ, თქვენ აპირებს ცდილობენ ინდექსი მეხსიერებაში, რომ არ ფლობენ.
ასე რომ, ეს, თუ ეს null, და თქვენ ამის გაკეთება, თქვენ ციკლი.
>> ROB: მე ასევე ვფიქრობ, რომ გამოცდა, რომელიც ჩვენ ამ კითხვაზე, ჩვენ გითხრათ
რომ თქვენ შეგიძლიათ მხოლოდ ვივარაუდოთ, ეს დადებითი რიცხვი.
იმის გამო, რომ atoi ასევე მოსალოდნელია გაუმკლავდეს უარყოფითი რიცხვები,
ასე, რომ თქვენ უნდა განსაკუთრებული შემთხვევაა.
Hey, ეს არის პირველი სიმბოლო ტირე, ამ შემთხვევაში, OK,
ახლა ეს უარყოფითი რიცხვი.
ჩვენ გეტყვით, თუ ამ სახის რამ.
ჩვენ გეტყვით, თუ რა უნდა გაუმკლავდეს.
Davin: დიახ.
ასე რომ დარწმუნებული ვარ, ზოგიერთი ადამიანი შეიძლება ჰქონდეს თუ დავიწყეთ ძველი გამოცდები,
ვნახე sterln.
რომ პოპულარული იყო.
და მე ვფიქრობ, sterln, თქვენ უნდა ამისათვის გამშვები null, დაბრუნების
0 ან რამე მაგდაგვარს.
როგორიცაა, თქვენ უნდა შევამოწმოთ null.
და თუ არა, რომ იყო აღვნიშნო off ვიქტორინა.
ასე მაინც, ჯერ ყველას გრძნობს კარგად atoi?
ვინმეს გვინდა გადასვლა ნაწილების ერთხელ?
ROB: Oh yeah, მე ვფიქრობ, ჩვენ ასევე გითხრათ
შეიძლება ვივარაუდოთ, რომ ყველაფერი is-- რომ ისინი რეალურად შესვლის ნომერი,
რომ თქვენ არ უნდა ფიქრი, როგორიცაა, წერილები მყოფი ტექსტი, ასე.
Davin: ჰო.
დიახ?
სტუდენტი: შეგიძლიათ წასვლა კიდევ ერთ დროს, როდესაც
თქვენ ორმაგ გაცემა და ერთი გაცემა?
>> Davin: რა თქმა უნდა, ასე რომ ორმაგი შეთავაზებები, ძალიან უბრალოდ, არის ორმაგი შეთავაზებები სიმები.
ასე რომ, თუ თქვენ ორმაგად გაცემა არაფერი, რომ სიმებიანი.
მაშ, ასე, რომ, თუ მე ამ 0 აქ, და მე ეს, რომ სიმებიანი.
რომ აღარ ხასიათი.
ასე რომ, მე ვერ პოულობენ ამ ღირებულების ჩემი ASCII სქემა, იმიტომ, რომ ეს ტექსტი, yeah.
>> OK, ნებისმიერი სხვა კითხვები?
დიახ?
>> სტუდენტი: ასე რომ თქვენ უკვე გავეცი პასუხი ამ,
მაგრამ, როგორც, როდესაც ჩვენ რეალურად წერა ამ ინტელექტუალური,
გინდა წერა დახრილ ხაზებს zeroes [INAUDIBLE]?
Davin: No.
კითხვა იყო უნდა თქვენ ბოლო ხაზი მეშვეობით zeros
მიუთითოს, თუ ისინი zeros?
არა, ჩვენ გაერკვნენ ის.
ჰო, მადლობა, ისინი კარგი.
OK, არაფერი?
ვინმეს სურს, რომელთა მიზანია ამიტომ ვფიქრობ, ჩვენ აწარმოებს ცოტა მეტი დრო.
გინდათ, რომ კიდევ ერთი, ერთი, ან?
სტუდენტი: RandomInt.
>> Davin: RandomInt, OK, ზუსტად.
ასე რომ, მოდით RandomInt.
მე ამას აქ.
ასე RandomInt რეალურად ბევრად უფრო მარტივია.
მე ვფიქრობ, atoi ალბათ უმძიმესი ერთი რომ ჩვენ ვთხოვეთ წინა წლებში.
სტუდენტი: [INAUDIBLE].
>> Davin რა?
ROB: მე ხედავს, თუ მისი სახის საქართველოს ფაქტიური მეტი აქ.
Davin: არის ეს?
ROB: არა მგონია, რომ ეს going-- ვფიქრობ, ის აპირებს off მარჯვნივ.
Davin: OK, ასე რომ მე ამის გაკეთება ერთი.
და მაშინ მხოლოდ დააყენა ის ეკრანზე.
>> ROB: ყველა უფლება.
>> Davin გსურთ იყოს ჩემი მწიგნობარი?
>> ROB: ჰო.
>> Davin: Nice.
OK, შემიძლია წაშლას?
>> სტუდენტი: Yeah.
>> Davin სწორედ ასე.
(სიმღერისა) თქვენ აკეთებთ თუ რას აკეთებს.
და რას არა.
ყველა უფლება.
>> OK, თუ სწორად მახსოვს, on ვიქტორინა RandomInt იყო,
OK, მე ვაპირებ, რომ გადმოგცეთ ორი ციფრები, ისევე როგორც და ბ.
და მინდა მომეცი RandomInt შორის იმ ნომრები.
ასე RandomInt აპირებს მიიღოს ორი ნომრები
ასე RandomInt-- და ეს დაბრუნებას აპირებს int.
>> რა არის დაბრუნების მნიშვნელობა?
მე უბრალოდ გითხარით.
Int, არა?
როგორც ეს, და შემდეგ ეს აპირებს ორი ints.
ასე რომ, ის აპირებს int და int b, როგორიცაა, რომ.
ასე რომ, რა RandomInt არის ვაპირებთ გავაკეთოთ არის ის აპირებს
დაბრუნებას შემთხვევითი არც ამ ორ ღირებულებებს.
ასე რომ, ეს იქნება დიდი მეტი, ნაკლები ბ.
ამიტომ ვფიქრობ, თქვენ, ალბათ, ვივარაუდოთ, რომ არის პატარა ორი ღირებულებებს.
ასე რომ, თუ ჩვენ საქმე შემთხვევითობა, რა ფუნქცია
ჩვენ ვხედავთ, რომ გვაძლევს შემთხვევითი რამ?
სტუდენტი: Drand.
Davin: Drand, ზუსტად.
ასე რომ თქვენ ალბათ გსურთ გამოიყენოთ თქვენი drand.
ასე შეიძლება ითქვას, int შემთხვევითი, და ჩვენ უბრალოდ, ვამბობთ ეს უდრის 0 ახლავე.
და ისინი ჩვენ ვაპირებთ ამბობენ, OK, შემთხვევითი შეადგენს drand 48.
და რას დაბრუნებას?
რას ნიშნავს ეს ფუნქცია მოგცემთ?
>> სტუდენტი: 0 და 1.
>> Davin: Yeah, 0 და 1.
ასე რომ, ის აპირებს be--
>> ROB: ეს is-- ვფიქრობ, ჩვენ გვინდა გითხრათ, ამ.
როგორიცაა, შეგიძლიათ გამოიყენოთ drand 48.
თქვენ შეგიძლიათ ამის შემოწმება თუ წარსულში გამოცდა.
მაგრამ ჩვენ ალბათ ამბობენ, რომ თქვენ შეგიძლიათ გამოიყენოთ drand 48, რომელიც
ბრუნდება float შორის 0 და 1.
>> Davin: დიახ, დიახ, მე ვარ საკმაოდ დარწმუნებული ვარ, რომ გამოცდა
ის ამბობს, ალბათ, გსურთ გამოიყენოთ drand, yeah.
ასე რომ, ის დაბრუნებას აპირებს გარკვეული მნიშვნელობა 0 და 1.
და მერე რა ხარ აპირებთ უნდა გავაკეთოთ?
კარგად, თქვენ გვინდა გავამრავლოთ by-- დაველოდოთ, მე ვფიქრობ, რომ ეს, როგორც ეს, sorry.
მე მხოლოდ ამის გაკეთება.
მე არ ვიცი.
>> ასე რომ ბ მინუს.
ასე რომ, რატომ b მინუს?
ასე ვთქვათ drand გაძლევთ უკან საუბარია int OK, მე უბრალოდ დანარჩენი,
პლუს.
ასე რომ, რა იმას y ბ მინუს.
ასე ვთქვათ, რომ drand გაძლევთ უკან მაქსიმალური მნიშვნელობა, რომ, შესაძლოა,
მოგაწვდით.
რა, რომ იქნება?
სტუდენტი: 1.
>> Davin: 1, არა?
ასე რომ, თუ ეს არის 1, და თქვენ გამრავლებული b მინუს,
ისე, რომ ეს მხოლოდ სხვაობა მინუს ა
და თუ შემდეგ დავამატებთ, რომ უკან გადატანა, რომ არის რა?
ის ძირითადად ბ.
ამჯამად რომ აზრი?
>> სტუდენტი: დიახ.
>> Davin: ასე რომ, თუ ეს არის მაქსიმალური ვაფასებთ ეს შეიძლება იყოს,
ეს იქნება 1.
და შემდეგ ეს მხოლოდ განსხვავება ორ.
სანიშნეს წლის, ასე რომ, ეს დაბრუნებას აპირებს შემთხვევითი.
და კუთხეში შემთხვევაში, drand გაძლევთ უკან 1,
შემთხვევითი იქნება მხოლოდ ეფექტურად ბ.
მაგრამ ეს მაქსიმუმ შეიძლება იყოს.
ასე რომ, თუ ეს იქნება ნაკლები, ვიდრე რომ, ასე ვთქვათ, რომ მისი, როგორც 0.9,
ასე რომ, მაშინ 0.9-ჯერ b- იქნება ნაკლები
მეტი განსხვავება b მინუს.
>> და მაშინ თუ დავამატებთ, რომ რათა, მაშინ, რომ არც
იქნება უფრო მეტი, ვიდრე, რადგან თქვენ დასძინა რაღაც გადატანა,
მაგრამ ეს იქნება ნაკლები ბ.
ასე რომ თქვენ აპირებთ მისაღებად შემთხვევითი ნომერი, იმიტომ, რომ თქვენ მოუწოდებდა drand.
და რომ rand, რომ შემთხვევითი რიცხვი იქნება სადღაც შორის
და ბ.
ამჯამად რომ აზრი?
>> ROB: Just დააყენოს ის კონკრეტული ციფრები,
ვთქვათ, ჩვენ გვინდა, რომ აირჩიოთ შემთხვევითი რიცხვი 7 და 10.
ასე რომ ბ მინუს ჩვენი სპექტრი.
ასე არ არის, სამი ციფრები, ჩვენ გვინდა, რომ არჩევანი.
და შემდეგ გამრავლების რომ 0 და 1: 1,
თუ ეს მაშინ გვაძლევს some-- ვთქვათ, რომ გვაძლევს 1.5.
>> 1,5, ჩვენ გვინდა წასვლა 7-დან 10.
ასე 1.5 + 7 მოაქვს ისევ ჩვენი 7-დან 10 დიაპაზონი.
და მაშინ ჩვენ შენახვა ეს შიგნით მთელი რიცხვი, ასე რომ შეიკვეცება ქვემოთ 8.
და მაშინ ჩვენ უბრალოდ დაბრუნებას, რომ.
ასე რომ ბ მინუს ჩვენი სპექტრი.
ინაცვლებს ის შევიდა ნომრები რომ ჩვენ გვინდა ფარგლებში სპექტრს.
ასე შორის 7 და 10, და მაშინ ჩვენ შეიძლება შეიცვალოს, რასაც ჩვენ დასრულდება up ერთად.
>> Davin: ჰო, კარგი.
>> ROB: დიდი მადლობა.
>> Davin: Yeah, რა ხდება?
>> სტუდენტი: ნუ ჩვენ აწარმოებს ნებისმიერი სახის ASCII შეცდომები we're-- თუ drand არის
დაბრუნების float [INAUDIBLE].
>> ROB: ასე რომ, ისევე რობ განაცხადა, იმიტომ, რომ შემთხვევითი არ არის int,
ასე drand იქნება float.
ისე და მერე ეს multiplies out.
და შესაძლოა, სახის float ნომრები.
და შემდეგ ის აპირებს შეკვეცავს.
>> სტუდენტი: OK.
Davin: ჰო.
ROB: და თუ შემდგენელი იყო გავაფრთხილო თქვენ, როგორიც დაკარგვა სიზუსტით,
მხოლოდ დააგდეს int in იქ, და მაშინ კარგია.
Davin: Yes?
>> სტუდენტი: თუ ეს აქვს იგივე ალბათობა,
როგორც, B ან A [INAUDIBLE]?
>> ROB: So is-- მე რეალურად wondering-- არის RandomInt ვარაუდობენ,
უნდა იყოს ნომრის ნაკლები b?
ისევე, როგორც, რომ, თუ ის 7-დან 10 რა შესაძლებლობები?
7, 8, 9, ან 7, 8, 9, 10
Davin: I დაგავიწყდებათ.
საქართველოს პრობლემა კომპლექტი
>> ROB: მე ვფიქრობ, რომ 7, ​​8, 9.
>> Davin: ეს კონკრეტულად ამბობს ერთი ინკლუზიური და ერთი განსაკუთრებული.
>> ROB: ჰო.
>> Davin: მაგრამ მე do not მე not--
>> ROB: ასე რომ, მე ვფიქრობ, რომ ეს არის არ შედის, ამ შემთხვევაში,
არსებობს თანაბარი ალბათობა 7, 8 და 9.
არ არსებობს ალბათობა 10.
Davin: Yes?
სტუდენტი: მე მაქვს შეკითხვა.
ჩვენ გვინდა, რომ განსაზღვრავს ფუნქცია ბრუნდება არა ერთი მნიშვნელობა, მაგრამ მასივი.
შემდეგ რა იქნება სინტაქსი დაბრუნების შემდეგ?
>> Davin: OK, ასე რომ, მაშინ would-- დაბრუნების შემდეგ?
ასე ვთქვათ, თქვენ განაცხადა, მასივი სადღაც იქ.
მაშინ დააბრუნებს სახელი მასივი.
>> სტუდენტი: OK, მადლობა.
მაშინ მხოლოდ დაბრუნდება a--
Davin: Oh დაველოდოთ, ასე რომ ბოდიში.
კითხვაზე იყო თუ როგორ თქვენ დაბრუნდეს მასივში.
>> ROB: მიუხედავად იმისა, რომ მას არ შეეძლო შეიძლება მასივი გამოცხადდა
დასტის ან რამე მსგავსი.
ეს უნდა იყოს რაღაც malloced, რადგან malloc
ეს თქვენ გარშემო მეხსიერების ავტომატური განაწილება.
>> Davin: დიახ.
ROB: როგორ მიიღოთ დაახლოებით, ადგილობრივი მასშტაბის.
>> Davin: მაგრამ თქვენ ამას უბრალოდ დააბრუნოს მისი სახელი
>> სტუდენტი: [INAUDIBLE] ეს არ არის ერთი ღირებულება, მაგალითად, ორი ნომრები, ასე
[INAUDIBLE].
>> Davin თქვენ ვერ დაბრუნდება მრავალჯერადი ნომერი.
თქვენ არ შეგიძლიათ, როგორიცაა, დაბრუნდება
>> სტუდენტი: მე ისაუბრა დაბრუნების მასივი ან რამე მაგდაგვარს.
>> Davin: ჰო, ასე რომ, კითხვა შემიძლია დაბრუნდება მრავალჯერადი ფასეულობათა.
თქვენ ვერ ბრუნდება მრავალჯერადი ღირებულებებს.
თქვენ არ შეგიძლიათ, ისევე, დაბრუნების შემდეგ დაბრუნდეს b ან რამე მაგდაგვარს.
რადგან მას შემდეგ, დაბრუნდება, თუ თქვენ ვბრუნდებით გარეთ ფუნქცია.
და შემდეგ ფუნქცია კეთდება, და როგორც რობ განაცხადა, რომ Stack.
>> ასე რომ ყველა, რომ მეხსიერება მხოლოდ იღებს დაბრუნდა კომპიუტერი.
ყველაფერი იღებს დავიწყებული, ძირითადად.
ასე რომ, თუ გვინდა, რომ დაბრუნდება მრავალჯერადი ღირებულებები, თქვენ უნდა დაბრუნდეს მასივში,
და ისე გავაკეთოთ, რომ mallocing.
და მაშინ დაბრუნდება x როგორიცაა, რომ.
ძირითადად, უბრალოდ დაბრუნების სახელი.
და როცა დაბრუნდება მსგავსი რამ, რომ თქვენ
რეალურად არ დაბრუნების ღირებულება.
>> ასე ვთქვათ ინახება ღირებულებების მასივი.
თქვენ არ რეალურად დაბრუნების იმ ღირებულებებს.
მსგავსად, თუ დავბრუნდი int, მე ნამდვილად დაბრუნების ასლები ღირებულებებს.
მაგრამ თუ მე უნდა დაბრუნდეს მსგავსი რამ,
მე დაბრუნების მინიშნება იმ ღირებულებებს.
ასე რომ, მე დაბრუნების, ძირითადად, მეხსიერების მისამართი ღირებულებებს.
ამჯამად რომ აზრი?
სტუდენტი: დიახ.
Davin: Nice.
დიახ?
>> სტუდენტი: როდესაც თქვენ გამოყენებით drand აქ,
თქვენ უნდა დააყენოს srand მანამდე?
>> Davin: არა, არა, მე ასე არ ვფიქრობ.
>> ROB: ჰო, ასე რომ თქვენ უნდა რომ არაფერი ვთქვათ srand?
ნაგულისხმები თქვენ არასდროს უთქვამს, srand ყველა არის უბრალოდ srand null.
ასე drand საკუთარი იმუშავებს.
და ეს ავტომატურად სათესლე მიმდინარე დრო არის ის, რაც იგი იყენებს.
Davin: Yes?
სტუდენტი: თქვენ თუ [INAUDIBLE] ნომრები?
Davin: დიახ, შეგიძლიათ.
სტუდენტი: ასე რომ თქვენ შეიძლება ამბობენ, ისევე, 4-ჯერ 2.
საქმე ის არის, რომ თქვენ არ შეიძლება ვივარაუდოთ, მაშინ int არის ოთხი ბაიტი.
Only--
>> Davin: მე ვგულისხმობ, ვიქტორინა თქვენ შეგიძლიათ.
[იცინის]
>> ROB: Mm, no.
Davin: დიახ, დიახ, თქვენ შეგიძლიათ.
თუ ისინი გთხოვოთ, თუ რამდენად დიდ int, თქვენ არ შეიძლება იყოს, როგორიცაა, ოთხი ან რვა.
ROB: Oh, ასე რომ, თუ კითხვაზე, თუ კონკრეტულად,
მსგავსად, თუ იგი არის კოდირების პრობლემა, უნდა ვთქვა, ზომა int.
თუ ეს მაგიდა, ან ის ამბობს, რამდენი ბაიტი,
თქვენ არ უნდა შეავსოთ ზომა ints.
>> STUDENTS: [იცინის]
>> Davin: მარჯვენა, რატომ არის ზომა int აქ მნიშვნელოვანია?
ამიტომ მინდა, თუ ჩვენ ვაპირებთ, რომ 32-bit პროცესორი ან რამე მაგდაგვარს,
მაშინ ეს იქნება ოთხი ბაიტი.
მაგრამ ზოგიერთი უფრო ახალი პერსონალი, ეს შეიძლება იყოს რა?
ეს შეიძლება იყოს რვა, არა?
ასე გაკეთება, თუ თქვენ მხოლოდ მძიმე კოდი ოთხი, შემდეგ რამდენიმე მანქანა, ის იმუშავებს.
რამდენიმე მანქანა, ეს არ იმუშავებს.
მაგრამ თუ ვიქტორინა ჩვენ როგორიცაა, თუ როგორ დიდი არის int?
ბოლო ოთხი.
ROB: Right.
Davin: ჰო?
სტუდენტი: ასე რომ, რადგან ჩვენ ვაცხადებთ [INAUDIBLE] შიგნით ფუნქცია,
უნდა გვქონდეს 3 შიგნით რომ ფუნქცია?
ან შეგვიძლია გამოვიყენოთ ის გარეთ?
Davin: თქვენ შეგიძლიათ გამოიყენოთ ეს გარეთ რომ ფუნქცია.
ამიტომ იგი ითხოვს free.
>> სტუდენტი: კარგავენ სიმღერა სადაც [INAUDIBLE].
>> ROB: Oh, უფასო არ მოხდეს ეს ნაწილი ჯადოსნური malloc
არის, რომ თქვენ არ შეზღუდული ადგილობრივი მასშტაბის.
თქვენ გაქვთ სრული კონტროლი როდემდე თქვენი ცვლადები ცხოვრობს.
ამიტომ, ჩვენ მოვუწოდებთ malloc აქ, ეს შეიძლება სრულიად დამოუკიდებელი ფუნქცია.
ეს შეიძლება იყოს 10 საათის შემდეგ რომ ჩვენ საბოლოოდ მოვუწოდებთ free.
>> Davin: ასე მაგალითად, როგორიცაა, რამდენიმე კვირის ახლა, როდესაც თქვენ საბოლოოდ
ნუ თქვენი ლექსიკონი speller psets, თქვენ აპირებს
აქვს რამოდენიმე ფუნქცია რომ ქმნის ტონა კვანძების.
ასე რომ თქვენ mallocing ტონა კვანძების ამ ფუნქციას.
და შემდეგ წელს ცალკე ფუნქცია, თქვენ
აპირებს გვინდა გასათავისუფლებლად ყველა იმ კვანძების.
ასე რომ თქვენ შეგიძლიათ სიტყვასიტყვით უბრალოდ გაივლის გასათავისუფლებლად მაჩვენებელი, ამიტომ მეხსიერების მისამართი
ის, რაც თქვენ malloced.
და რომ კარგად იქნება.
თქვენ არ გაქვთ თავისუფალი, როგორიცაა, იგივე ფუნქცია.
დიახ?
>> სტუდენტი: ასე malloc ცვლადი [INAUDIBLE] გარეთ?
ის არის, რომ თუ რას ამბობდა?
Davin: დაველოდოთ, ამბობენ, რომ?
უკაცრავად.
>> სტუდენტი: თუ malloc ცვლადი შეიძლება იყოს თავისუფალი სადმე კოდი,
ამის შემდეგ შეიძლება ხელმისაწვდომი იყოს სადმე კოდი?
შეგიძლიათ შენარჩუნება მათ ადგილობრივი?
>> Davin: Oh, მან სთხოვა, როგორიცაა, ცვლადი, ისევე როგორც
>> ROB: ასე რომ, თქვენ კვლავ უნდა აქვს გარკვეული მინიშნება
რომ malloc ბლოკი მეხსიერება.
ასე რომ, ჩვენ დაბრუნების x.
სტუდენტი: Oh.
ROB: თუ ჩვენ არ დაბრუნდება x აქ, და ეს იყო მხოლოდ ის, ბათილად,
მაშინ ჩვენ არ გვაქვს წვდომა მაჩვენებელი, რომელიც იყო malloced,
და ეს გაჟონა მეხსიერება.
>> სტუდენტი: OK.
>> Davin: ასე რომ, ვთქვათ, ამ, როგორიცაა, უფლება აქ.
ROB: არა
Davin: ჩემი მთავარი ფუნქცია, მე არ შემიძლია დარეკეთ მხოლოდ ამ x და, როგორც, OK,
ამ ფუნქციას, მე ეს.
>> ROB: Right.
>> Davin: ასე რომ მე ვაპირებ მოვუწოდო x in, როგორიცაა, მთავარი ან რამე მაგდაგვარს.
თქვენ შეგიძლიათ ამის გაკეთება.
თქვენ აპირებს დაბრუნებას რაღაც.
მაგრამ რას აპირებს დაბრუნებას?
თქვენ ვაპირებთ დაბრუნებას მეხსიერების მისამართზე.
და რადგან თქვენ დაბრუნდება მეხსიერება მისამართი, რომელიც შეიძლება ხელმისაწვდომი მის ფარგლებს გარეთ.
ნებისმიერი უფრო მეტი შეკითხვა?
დიახ?
>> სტუდენტი: არის ფუნქცია ზემოთ მიმდინარეობს გამშვები [INAUDIBLE]?
>> Davin: რატომ არ უნდა გავაკეთოთ ეს?
სტუდენტი: [INAUDIBLE].
Davin: იმიტომ, რომ თქვენ არ mallocing არაფერი.
ასე რომ, ეს not-- ჰო, არ მინდა string s.
ეს მაჩვენებელი სადღაც.
ეს არის მხოლოდ ღირებულებებს.
სტუდენტი: OK.
Davin: ჰო.
არაფერი?
ROB: Yep?
სტუდენტი: მაგრამ როდესაც თქვენ [INAUDIBLE]?
>> ROB: ასე რომ, რათა გასათავისუფლებლად მეხსიერება, ჩვენ ვთქვათ აქ.
ასე რომ X არის ჩვენი მომცეთ ბლოკი მეხსიერება.
ჩვენ გასათავისუფლებლად რომ მომცეთ.
და ჩვენ არ არის აუცილებელი ამის გაკეთება აქ.
ჩვენ შეგვიძლია ამის გაკეთება ყველგან.
მაგრამ თქვენ მხოლოდ დარეკეთ უფასოდ რაღაც რომ malloc ბრუნდება.
Malloc, აქ დაბრუნდა რა ხდება ინახება x.
ასე რომ ჩვენ შეგვიძლია მოვუწოდებთ უფასოდ x.
ნებისმიერი ბოლო კითხვები?
>> Davin: ნებისმიერი ბოლო კითხვები?
ჰო?
>> სტუდენტი: უკაცრავად, შეგიძლიათ ხელახლა ახსნას ამიტომ თქვენ გასათავისუფლებლად იქ?
რატომ [INAUDIBLE]?
>> Davin: იყიდება აქ?
>> სტუდენტი: Yeah, როგორიცაა შემდეგ.
Davin ალბათ არ მინდა უფასოდ აქ.
ROB: ალბათ არა.
Davin: ჰო, ეს იქნებოდა არაფერი.
ეს იქნებოდა, როგორც, შექმნა მეხსიერება, პერსონალის ის,
და შემდეგ დაუყოვნებლივ დაივიწყოს ის, yeah.
>> ROB: მაგრამ ჩვენ, შესაძლოა, ისევე, აქ რატომღაც.
შეიძლება ითქვას, int ვარსკვლავი y უდრის დაბრუნების მასივი.
რაღაცები და y, იქნებ ამობეჭდოთ შინაარსი.
და მაშინ, საბოლოოდ, ჩვენ გავაკეთეთ.
ჩვენ შეგვიძლია გასათავისუფლებლად y.
სტუდენტი: [INAUDIBLE].
Davin: თუ მე გადახვევა ქვემოთ?
მადლობა.
ROB: Nice.
>> Davin: OK, რომ არის ის.
ROB: ყველა უფლება, კარგი.
წარმატებებს გისურვებთ.
>> Davin: თუ თქვენ გაქვთ შეკითხვები, მოგვწეროთ.
წარმატებებს გისურვებთ.