>> JASON HIRSCHHORN: Welcome to A5, ყველას.
ჩვენ საინტერესო კვირით ადრე ჩვენთვის, ძირითადად იმიტომ, რომ არსებობს ამდენი new
დგას ამ ოთახში.
ეს მშვენიერი.
ბევრი თქვენ აქ შემთხვევით, რაც უფრო უკეთესი.
ასე რომ იმედია თქვენ შენარჩუნება მობრძანებისათვის.
>> ამ კვირაში ჩვენ ვაპირებთ გაატაროთ ნაყარი განყოფილებაში
ემზადება ვიქტორინა.
ასე რომ, ერთ ჩვენს დღის წესრიგში, ჩვენ ვაპირებთ გაიგო ცოტა რესურსი კლასის,
არამედ ინტელექტუალური და შემდეგ, კიდევ ერთხელ, დახარჯოს ნაყარი კლასის საუბარი
შესახებ შეკითხვებს.
მას შემდეგ, რაც ჩვენ გავაკეთეთ პასუხობდა თქვენი შეკითხვები, თუ თქვენს შეკითხვებს
ბუნებრივად მიგვიყვანს რამდენიმე კოდირება, I აქვს ნიმუში პრობლემები შუალედური
წარსულში, რომ ჩვენ კოდექსის ცოცხალი განყოფილებაში ერთად, რომელიც ასევე ზრდიან ზოგიერთი სხვა
კარგი თემა დასაფარავად.
>> ასე რომ, პირველი, როგორც ჩვენ გავიარეთ, რომ ბოლო რამდენიმე კვირის განმავლობაში შეგახსენოთ
ბიჭები, არსებობს ტონა რესურსების ხელმისაწვდომია ამ კურსს.
ბევრი მათგანი იქნება წარმოუდგენლად სასარგებლო თქვენ, როგორც თქვენ გააგრძელებს
შესწავლა ინტელექტუალური 0, იმიტომ, ის სამშაბათი დღის მეორე ნახევარში.
ასე რომ ყველა თქვენ უკვე შესწავლის ცოტა.
>> არსებობს ლექცია შენიშვნები და წყარო კოდი, რომ თქვენ უნდა
აუცილებლად შეამოწმეთ.
უყუროთ შორტები.
შეამოწმეთ study.cs50.net.
და შემდეგ, ქვემოთ ჩამოთვლილი, მთელი რიგი სხვა რესურსები.
>> ერთხელ, ინტელექტუალური 0 არის ხვალ 1 საათზე.
თუ არ გავაკეთეთ უკვე, გადაამოწმოთ out შესახებ Quiz 0 დოკუმენტი
რა თქმა უნდა ვებგვერდი გაერკვნენ სადაც თქვენ აღების ვიქტორინა.
ვიქტორინა იწყება 1:10 და დამთავრდა 70 წუთის შემდეგ.
ასე რომ, თუ გამოჩნდება შემდეგ 1:10, თქვენ აპირებს მიიღოს, რომ ბევრი ნაკლები ე
70 მატჩში ვიქტორინა.
ამიტომ დარწმუნდით, თქვენ იქ დრო.
თუ თქვენ გაგრძელების სტუდენტი ან ჰქონდეს ზოგიერთი სხვა ტესტირების გათვალისწინებით, რომ
არ უნდა იყოს 1 საათზე ხვალ.
მაგრამ ერთხელ, შესამოწმებლად მომხმარებლის Quiz 0 დოკუმენტურად უნდა დავრწმუნდეთ, თქვენ იცით, როდესაც
თქვენ აღების ვიქტორინა.
მე დავწერე 75 წუთზე აქ.
მე ვფიქრობ, რომ უფლება, არა 70.
>> იგი მოიცავს ყველა მასალა კვირაში 0 გასულ კვირას ლექცია ოთხშაბათს.
ისევ და ისევ, ეს ვიქტორინა, პოსტი, რომ დოკუმენტი, თქვენ ერთი ორმხრივი და 8
1/2 11 ფურცელზე, რომ თქვენ გამოიყენოთ როგორც აღნიშნავს დროს ვიქტორინა.
ბევრი ადამიანი, თუ არა საუკეთესო ხალხი, აქვს აღმოჩნდა, რომ ერთი ყველაზე გამოსადეგი გზა
სასწავლებლად ვიქტორინა არის მიიღოს სასწავლო ფურცელი,
ერთი sider, საკუთარი.
ასე რომ შევხედოთ წარსულში პირობა, თუ ვნახე გასული მიიჩნიეს.
მივაწვდინოთ მეგობარი დაინახოს, თუ რა ისინი აყენებს მათი.
>> მაგრამ ხელები ქვემოთ, საუკეთესო გზა, თქვენ შეგიძლიათ სასწავლო გავლა ყველაფერი და
whittle ის ქვემოთ რა უნდა ან უნდა არ ეკუთვნის, რომ ფურცელზე
ქაღალდი, იმიტომ, რომ უბრალოდ მართლა გამოსადეგი გზა თქვენ დარწმუნდით
თქვენ გადის ყველაფერი და გარკვეული მნიშვნელოვანია ეს.
ყველაზე ხალხი, ჩვენ, მიუხედავად იმისა, არ ფურცელზე სხდომაზე უფლება
შემდეგ მათ ვიქტორინა, არ ჩართოთ , რადგან, კიდევ ერთხელ, რომ ძალიან
პროცესს გადის ინფორმაცია დაეხმარა მათ ვისწავლოთ იგი.
>> ვინმეს გაქვთ რაიმე შეკითხვები შესახებ ინტელექტუალური 0?
აქვს ყველას -
მე არ ვაპირებ ამის გაკეთება შოუ ხელში.
არასოდეს გათვალისწინებით.
მე ვაპირებ ვკითხო, რომლებიც დაიწყო სწავლა.
მაგრამ მე არ მინდა, რომ თქვენ ყველა არ დააყენოს თქვენი ხელები.
ასე რომ, როგორც ვთქვი - დიახ, Avi, წავიდეთ წინ.
>> AVI: რა იქნება სასარგებლო რამ დააყენოს ერთი ძალაშია?
>> სტუდენტი: ეს თქვენზეა.
>> JASON HIRSCHHORN: თქვენ გამოიყენოთ თქვენი გადაწყვეტილება.
სასარგებლო რამ მოათავსოთ ერთ გვერდიანი მასალა, თუ თქვენ დაბნეული შესახებ დიდი O
runtime სხვადასხვა სახის ძებნა და სახის, დააყენა, რომ იქ
მოსახერხებელი Dandy ჩარტში.
ამგვარად, თუ თქვენ სთხოვა, რომ ვიქტორინა, თქვენ არ უნდა ვეცადოთ და ფიგურა
ის ან მიზეზი მეშვეობით Runtime.
თქვენ შეგიძლიათ მხოლოდ კოპირება ქვემოთ.
თუ გადავხედავთ ტესტები წარსულში, ბევრი ჯერ, იქ გაშვებული დრო შეკითხვებს.
ასე რომ იყოს მაგალითი კარგი რამ დააყენა თქვენი ერთი ძალაშია.
>> სხვა კარგი რამ დააყენა, თუ თქვენ დაბნეული შესახებ, თუ როგორ უნდა განაცხადოს
ფუნქცია ან რა სხვადასხვა ფუნქცია დეკლარაციაში, წერენ
რომ არის, generic ვერსია და მაშინ იქნებ მაგალითი.
თუ თქვენ დაბნეული შესახებ მითითებას, სქემა, თუ როგორ პოინტერები მუშაობა
ალბათ ნამდვილად გამოსადეგი.
თუ თქვენ დაბნეული შესახებ უკან, ნიმუში რეკურსიული ფუნქცია იქ
შეიძლება ასევე ადასტურებს, რომ იყოს მართლაც გამოსადეგი.
ნიშნავს ეს მოგცემთ ზოგიერთი იდეები?
>> AVI თქვენ უნდა გვესმოდეს მთელი შედგენა პროცესი, ისევე როგორც
როგორ, რომ სამუშაოები?
>> JASON HIRSCHHORN: Everything რომ უკვე დაფარული იქნებოდა
გამოჩნდება ვიქტორინა.
კითხვები -
მაგრამ ერთხელ, ზოგი რამ იქნება შეწონილი მძიმედ, ვიდრე სხვები.
ზოგიერთი რამ არ ამუშავება ერთხელ და ისევ კლასის,
ლექცია და განყოფილება.
სხვა რამ არ აქვს ამუშავება, რომ ხშირად.
>> ჩვენ ვისაუბრეთ ბევრი რამ # მოიცავს და -L რაღაც და რა ნიშნავს
compilation პროცესში.
ჩვენ ვისაუბრეთ ბევრი რამ GDB, cling, იმ სხვადასხვა flags რომ ჩვენ ვიყენებთ, როდესაც
ჩვენ კომპილაციის რაღაც, და რა make15, მაგალითად, ნამდვილად
ნიშნავს და მართლაც.
ჩვენ არ გაიგო იმდენი შესახებ ყოველი ნაბიჯი
compilation პროცესში.
ჩვენ კვლავ ისაუბრა.
ასე რომ, ეს არის კიდევ რაღაც, რომ თქვენ უნდა იცნობს.
მაგრამ ერთხელ, ჩვენ არ ვაპირებთ, რომ იყოს -
რამ ამუშავება უფრო ხშირად კლასში უფრო სავარაუდოა, რომ ამუშავება მეტი
ხშირად და უფრო მძიმედ შეწონილი on ვიქტორინა.
>> ზემოთ.
ნებისმიერი სხვა კითხვებს ვიქტორინა 0?
>> OK, ამიტომ დააყენა სიაში თემები ფორუმში.
მე გაიარა სილაბუსში.
მე გაიარა განხილვის მონაკვეთზე ღამით და იმ სლაიდები ამუშავება
ერთად არასამთავრობო ამომწურავ ჩამონათვალს თემები რომ ჩვენ დაფარული ამ დრომდე CS50
და რაც შეიძლება გამოჩნდება ვიქტორინა.
ასე რომ, მე არ ვაპირებ გავლა თითოეული მათგანი.
რომ დასჭირდება ბევრად უფრო დრო, ვიდრე გვაქვს.
მაგრამ მე დააყენა ამ მდე აქ იმედია Jog თქვენი მეხსიერება, რათა რაც შეიძლება
ან შეიძლება არ იყოს ნაცნობი თქვენ.
>> და მე მიყვარს დახარჯვა ნაყარი განყოფილების თქვენს კითხვებს პასუხობს შესახებ
ამ თემებზე, თემები, არ დაფარული აქ.
ჩვენ შეგვიძლია დავწეროთ ფსევდო კოდი.
ჩვენ შეგვიძლია დავწეროთ რეალური კოდი უზრუნველყოს, რომ თქვენ -
შემიძლია უპასუხოს შეკითხვას და დავეხმაროთ ყველას ფუნდამენტურად ესმის
ბევრი ეს თემა ასე რომ თქვენ გრძნობენ მომზადებული და კომფორტული შესვლის
ვიქტორინა ხვალ.
ასე რომ წაიკითხოთ მეტი სიაში.
თქვენ იმედია არ მოვა განყოფილებაში ზოგიერთ კითხვებზე, ასევე.
როდესაც თქვენ მზად, გაზარდოთ თქვენი მხრივ, და ჩვენ უნდა დავიწყოთ.
>> გაითვალისწინეთ, კითხვები გაქვთ, არ არსებობს სულელური შეკითხვა.
ჩვენ მოვისმინეთ, რომ ბევრი.
და კითხვები გაქვთ, მზად ვარ დადებს, რომ ბევრი სხვა ხალხი, როგორც
იჯდა აქ და თვალს ონლაინ აქვს ასევე.
ასე რომ თქვენ შეგიძლიათ მხოლოდ დაეხმარება ხალხს მიერ სვამს კითხვებს.
Marcus.
>> MARCUS: შორის დასტის და ბევრი, არსებობს წინასწარ გამოყოფილი
პროცენტული მეხსიერება, რომელიც განისაზღვრება, როგორც ეს არის დასტის, ან ბევრი?
ან როგორ აკეთებს, რომ მუშაობა, ზუსტად?
>> JASON HIRSCHHORN: Great კითხვა.
მე ვაპირებ უკან კვალი ცოტა.
არა ყველას -
გთხოვთ, იყოს პატიოსანი აქ.
მე ვიცი, მე გეკითხებით თქვენ დააყენოს თქვენი მხრივ თვალწინ თქვენს თანატოლებს.
მაგრამ არსებობს ადამიანები, რომლებიც გრძნობენ არასასიამოვნო დასტის და ბევრი
და მინდა წასვლა, რომ და რა არის ეს ნიშნავს?
გაზარდოთ თქვენი მხრივ, თუ -
OK.
დიდი მადლობა.
ამიტომ, ჩვენ ვაპირებთ წასვლა მეტი დასტის და ბევრი მართლაც სწრაფად და შემდეგ
გადაინაცვლოს პასუხობდა თქვენს კითხვაზე.
>> ასე რომ, თუ ჩვენ მიაპყროს out ყუთი წარმოადგენს მეხსიერების თქვენს კომპიუტერში, რა
რამ, რომ წასვლა ამ ყუთში?
მთავარი.
ძირითადი ფუნქცია.
სად მთავარი წავიდეთ?
>> სტუდენტი: [INAUDIBLE].
>> JASON HIRSCHHORN: ასე ჩვენ მა მთავარ ქვემოთ აქ.
რა მიდის ამ ყუთში?
>> სტუდენტი: ფუნქციები რომ თქვენ მოვუწოდებთ.
>> JASON HIRSCHHORN: ფუნქციები რომ ჩვენ მოვუწოდებთ.
და სად მიდიან?
>> სტუდენტი: In Stack.
>> JASON HIRSCHHORN: ისინი წავიდეს Stack.
ამიტომ, ჩვენ ვაპირებთ, რომ მოვუწოდო ამ რამ ქვემოთ აქ Stack.
და ზევით, ჩვენ გვაქვს ბევრი.
ასე რომ მეხსიერება არ არის ყუთი, ისევე, როგორც ეს.
მაგრამ ეს არის რეალურად საკმაოდ ჰგავს.
ეს იქნება ბევრი ყუთები მეტი და მეტი, დამოკიდებულია თუ რამდენად დიდი თქვენი
კომპიუტერი და რამდენად დიდი თქვენი მეხსიერება არის.
>> ამავე ციტირებით-unquote "bottom" არის Stack.
და არსებობს მრავალი რამ რომ წავიდეთ Stack.
და ის დამოკიდებული ფუნქციები თქვენ გაქვთ თქვენი კოდი.
თქვენ ყოველთვის აქვს ერთი ფუნქცია თქვენი კოდი ეწოდება მთავარი, ასე რომ ყოველთვის
განყოფილების ქვემოთ აქ დააწყობს მიეძღვნა მთავარი.
>> ამ მონაკვეთების დასტის მოუწოდა დასტის ფარგლებში.
როცა რეკავთ სხვა ფუნქცია, ვთქვათ მთავარი მოუწოდებს ბინარული ძებნის ფუნქცია,
ჩვენ კიდევ ჩარჩო Stack.
უფრო კონკრეტულად, ჩვენ ვაპირებთ დავეხმაროთ ბლოკი მეხსიერება ჩვენს
კომპიუტერული შესანახად ორობითი ძებნა ლოკალური ცვლადები და აწარმოებს ორობითი
ძიების კოდი.
>> ამიტომ ჩვენ მოვუწოდებთ ორობითი ძებნა.
ამ ბლოკი მეხსიერება, ჩვენ ვაპირებთ შესანახად მისი ადგილობრივი ცვლადები.
ჩვენ ვაპირებთ შესანახად მისი printf ზარები.
რაც არ უნდა მოხდეს, რომ ფუნქცია იქნება შენახული უფლება არსებობს.
ორობითი ძებნა აპირებს შეასრულოს.
იგი აპირებს დაასრულოს აღსრულება.
რა არის სიტყვა C, რომელიც ნიშნავს რომ ფუნქცია უნდა
დაასრულებს შესრულების?
>> სტუდენტი: დაბრუნება.
>> JASON HIRSCHHORN: დაბრუნება.
ასე რომ როდესაც ხედავთ დაბრუნების განაცხადი, ფუნქცია მთავრდება
როდესაც ის იგებს, რომ.
ასე რომ ორობითი ძებნა მოხვდა მისი დაბრუნება.
ამ ნაწილში ხსოვნას არსებითად გათავისუფლდებიან up.
და ძირითადი კვლავ აღსრულება.
ასე რომ, მთავარი იქნება პაუზის იქ, სადაც იყო, დარეკეთ ორობითი ძებნა, მიიღოთ გარკვეული დაბრუნების ღირებულება,
და გააგრძელებს აღსრულება.
ამ დასტის ჩარჩო მიდიან.
>> იმ შემთხვევაში, თუ ჩვენ მოვუწოდებთ რეკურსიული ფუნქცია, რომელიც არის ფუნქცია, რომელიც მოუწოდებს თავად მეტი
და მეტი, შესაძლებელია, - ამბობენ, რომ ჩვენ გააკეთა ბინარული ძებნის რეკურსიული.
ჩვენ შესაძლოა ბინარული ძებნის მობილური ერთი, ორობითი ძებნა ორი, ორობითი ძებნა
სამი, ბინარული ძებნის ოთხი, ორობითი ძებნა ხუთ.
და მაშინ ეს საბოლოო ორობითი ძებნა ხუთ მოხვდა ბაზის შემთხვევაში, და დასტის
ფარგლებში წავა უკან და შეინახოს დახურვა სანამ ჩვენ დავუბრუნდეთ მთავარ.
ჩვენ შეგვიძლია წავიდეთ უკან ცოტა.
მაგრამ ეს ყველაფერი არის იმის თქმა, თუ თქვენ მოუწოდებდა მრავალი ფუნქციები დროს,
იქ ვიქნები მრავალი დასტის ფარგლებში Stack.
>> ბევრი, მეორეს მხრივ, აქ, არ არის ფუნქციები,
არა ადგილობრივი ცვლადები.
ეს შეეხება დინამიურად გამოყოფილი ცვლადები.
ასე რომ ეს არის ცვლადი, რომელიც შეიძლება იყოს ინიციალიზაცია ორივე მთავარ ან
ფუნქცია, რომელიც მთავარ მოუწოდებს.
სადმე თქვენს კოდი, ისინი შეიძლება ინიციალიზაცია.
და ინიციალიზაცია დინამიურად გამოყოფილი ცვლადი.
რა ფუნქცია C ვიყენებთ?
>> სტუდენტი: Malloc.
>> JASON HIRSCHHORN: Malloc.
რეკავთ malloc.
თქვენ სივრცეში მეხსიერებაში.
და რომ სივრცე მეხსიერება არის ბევრი.
და რომ სივრცე მეხსიერების რჩება იქ, სანამ რეკავთ უფასოდ.
>> ასე დინამიურად გამოყოფილი ცვლადები ბევრი იქნება, რადგან თქვენ
გვინდა, რომ არსებობს, და ისინი არ მიდიან, სანამ მკაფიოდ
ვუთხრა, უნდა წავიდეს.
თქვენ შეგიძლიათ შექმნათ მათ ერთი ფუნქცია.
ეს ფუნქცია დასტის ჩარჩო მიდიან.
მაგრამ ეს ცვლადი კვლავ არსებობს წელს ბევრი სანამ იგი გათავისუფლდა,
პოტენციურად ფუნქცია მოუწოდა ორობითი ძებნა ან რასაც.
>> ასე რომ იმ ბევრი ცვლადები იქ რადგან გსურთ
მათ იქ დარჩენა.
და ისინი დააყენა აქ.
ხოლო შემდეგ მომდევნო ერთი იღებს დასვა იქ.
ისინი არც შევსებული, და ისინი დარჩება იქ, სანამ რეკავთ უფასოდ.
>> და არსებითად, ბევრი და დასტის, მიღების Marcus კითხვაზე,
იზრდება ერთმანეთის მიმართ.
და თუ ისინი გადაეყარონ ერთმანეთს, თქვენ გამოიყენება ყველა მეხსიერების თქვენს
კომპიუტერი, და თქვენი პროგრამის დატოვა იმიტომ, რომ თქვენ არ გაქვთ მეტი მეხსიერების
მარცხენა გამოიყენოს.
წელს მათ შორის, არსებობს პოტენციურად სხვა რამ.
მაგრამ წინამდებარე რა თქმა უნდა, არ უნდა ფიქრი, რომ.
>> ასე რომ, იყო პასუხი თქვენს კითხვაზე.
არ ინერვიულოთ შესახებ.
მაგრამ ეს იყო გრძელი პასუხი.
ყველა თქვენ უნდა იცოდეთ არის ბევრი და დასტის იქნება -
იწყება ბოლოში.
დასტის აკეთებს.
ბევრი არის იქ.
ისინი გაიზრდებიან უფრო ახლოს ერთმანეთს.
>> და თუ ისინი შეეხოთ, რომ პრობლემა.
თქვენ გაიქცა out of მეხსიერება.
არამედ, გარდა ამისა, იცოდა, სადაც ისინი, რა ინახება ორივე
დასტის და ბევრი.
Curtis.
>> CURTIS: როდესაც collide, ის არის, რომ დასტის overflow?
>> JASON HIRSCHHORN: როდესაც collide, ეს არ არის დასტის overflow.
დასტის overflow არის სხვადასხვა ტერიტორიაზე რომ ჩვენ შეგვიძლია წავიდეთ, თუ გნებავთ.
OK, ჩვენ დავბრუნდებით, რომ ცოტა.
>> სტუდენტი: რა არის სიტყვა მოუწოდა როდესაც ისინი ერთმანეთს,
დასტის და ბევრი?
>> JASON HIRSCHHORN: ახლა, არ ინერვიულოთ.
უბრალოდ ვიცი, -
მე ამ კითხვაზე პასუხის გაცემა მას შემდეგ, რაც კლასის.
თუ ისინი გადაეყარონ ერთმანეთს, თქვენ გაიქცა აქედან მეხსიერება, იმიტომ, რომ იქ აღარ
ფართი არსებობს.
>> სტუდენტი: უკაცრავად, რა არის seg ბრალია?
>> JASON HIRSCHHORN: A სეგმენტი ბრალი შეიძლება მოუწოდა -
ეს დამოკიდებულია იმაზე, თუ რატომ seg ბრალია მოუწოდა.
ზოგჯერ, თქვენი დასტის overflow, ეს თქვენ ამბობენ seg ბრალია, როგორც შეცდომა.
>> სტუდენტი: რა dereferencing null ცვლადი?
ის არის, რომ seg ბრალია?
>> JASON HIRSCHHORN: dereferencing null მაჩვენებელი -
OK, ასე რომ, თუ თქვენ გაქვთ მომცეთ, რომ თქვენ მითითებული ტოლი null, მითითებები, გაწვევას,
მაღაზია მეხსიერების მისამართები როგორც მათი ღირებულებები.
და null მაჩვენებელი არსებითად შენახვის 0, 0-th
სიტყვით რომ ცვლადი.
ასე 0x, 0, 0, 0, 0, et cetera.
რომ 0-th მისამართზე მეხსიერებაში, რომ არ არის ჩვენს სურათს, რომ იქ
სადღაც, რომ დაცულია კომპიუტერი.
ჩვენ არ დაუშვეს შეეხოთ მას.
>> ასე რომ, როდესაც თქვენი პროგრამის შესრულებაში, თუ რაღაც ცდილობს წასვლა მეხსიერება
მისამართი 0, იგი დარწმუნებულია, რომ რომ არის ცარიელი ღირებულება.
იგი დარწმუნებულია, არაფერი უნდა იყოს იქ.
ასე რომ, თუ თქვენ ცდილობენ და გამოიყენოთ რაღაც არსებობს და მკურნალობა, რაღაც არსებობს, ან
ცდილობს წავიდეს იმ, თქვენ აპირებს მიიღოს seg ბრალია ან შეცდომა.
ამჯამად რომ უპასუხოს შეკითხვას?
>> და ახლა ჩვენ დავბრუნდებით დასტის overflow.
რამ დასტის, როგორც თქვენ ბიჭებს აქვთ მინახავს ადრე, - მოდით დავხატოთ ახლოს
up დასტის ჩარჩო.
შეიძლება ყველას ვხედავ, რომ?
ასე რომ, ჩვენ გვაქვს ჩვენი დასტის ჩარჩო.
ჩვენ გადარჩენის მასივი, როგორც ადგილობრივი ცვლადი ამ ფუნქციას.
ასე რომ ვთქვათ, ჩვენი მასივი ხუთ წერტილში.
ხუთივე იმ იქნება შენახული ამ დასტის ჩარჩო.
>> თუ ჩვენ დავიწყებთ წერა მიღმა ფარგლებში ამ მასივი -
ასე რომ, თუ ჩვენ დავიწყებთ წერის, მოდით ვთქვათ, რომ 0.
იმ ხუთ ინდექსები ჩვენი მასივი.
თუ ჩვენ დავიწყებთ წერის ინდექსი 5, რომელიც ჩვენ არ გვაქვს, როდესაც ჩვენ გვაქვს
მასივი ზომა 5, ჩვენ ვიწყებთ წერის ინდექსი 6, 7, 8, 9, ჩვენ შეგვიძლია მივიღოთ Stack
Overflow შეცდომა.
>> ზოგადად, ეს არ არის -
თქვენ ალბათ მოხვდნენ უბედურება თუ მთავრდება ერთი.
მაგრამ ზოგადად, თქვენ შეღწევას ყველაზე უბედურება თუ მთავრდება ბევრი
და თქვენ გადასვლა ჯერჯერობით მეტი რომ წერთ მეტი დაბრუნების მისამართი, რომ
ფუნქცია, რომელიც მდებარეობს ბოლოში დასტის ჩარჩო.
>> რადგან, არა?
თქვენ - რომ - უკაცრავად.
"არა იმიტომ, რომ უფლება."
>> დასტის ჩარჩო, თქვენ უნდა თქვენი ადგილობრივი ცვლადები.
ძალიან ბოლოში დასტის ჩარჩო დაბრუნების მისამართზე.
სწორედ იქ, სადაც ფუნქცია მიდის, როდესაც ეს დასრულდა.
და თუ გადავაწერო, რომ დაბრუნების მისამართი, მაშინ, როდესაც ამ დასტის ჩარჩო,
როდესაც თქვენ გადის დასტის ვიზრუნოთ და შესრულებაში თითოეული ხაზი, თქვენ
აპირებს მისვლას თქვენი დაბრუნების მისამართი რომ წერია ნაცვლად
ფაქტობრივი ერთი.
და ასე ჩვენ ვნახეთ ზოგიერთი უსაფრთხოების არღვევს
შეიძლება მოხდეს კომპიუტერი.
>> ასე დასტის overflow, მოკლედ, როდესაც თქვენ გადავაწერო მონაწილეობა დასტის
თქვენ უნდა გამოიყენოთ, ადგილობრივი ცვლადი თქვენ უნდა გამოიყენოთ, და
კერძოდ, როდესაც თქვენ დავიწყოთ overwriting მნიშვნელოვანი რამ, როგორიცაა
დაბრუნებას მისამართზე.
და რომ სადაც თქვენ მიიღებთ შეცდომა.
ან შესაძლოა თქვენ შეიძლება დაიწყოს თუნდაც წერილობით შევიდა -
ამბობენ, რომ ორობითი ძებნა იყო უფლება ზემოთ მთავარი.
თუ თქვენ overwrote ბევრი, თქვენ შეეძლო დაეწერა თარგმნეს მთავარი.
მაგრამ ზოგადად, თქვენ გაქვთ შეცდომა ადრე შემდეგ, იმის გამო, რომ კომპიუტერი იცის
თქვენ აკეთებთ რაღაც არ უნდა აკეთებს.
ჰო.
>> სტუდენტი: რა არის განსხვავება შორის დასტის overflow
და ბუფერული overflow?
>> JASON HIRSCHHORN: ბუფერული overflow უფრო generic ტიპის
რა მე უბრალოდ აღწერილი.
>> სტუდენტი: ასე დასტის overflow არის მაგალითი ბუფერული overflow.
>> JASON HIRSCHHORN: ზუსტად.
ეს არის მასივი ჩვენ შეგვიძლია ვიფიქროთ, როგორც ბუფერული, ფართი რამ წასვლა შემოსული
ეს არის დასტის ბუფერული overflow.
ჩვენ შეგვეძლო ბევრი ბუფერული overflow.
თუ იყო ბუფერული, რომელიც იქ ხშირად არის მასივი ბევრი, და ჩვენ
overwrote იმ ფარგლებში, მაშინ ჩვენ აქვს ბევრი ბუფერული overflow.
>> და სცილდება ეს კურსი, ისინი აღმოჩენილი ცოტა განსხვავებულად.
შემდგენელი აქვს სპეციალური გზების გამოვლენის თითოეული.
მაგრამ ბუფერული overflow უფრო generic ტიპის რაც მე აღწერილი,
რომელიც დასტის ბუფერული overflow.
იცოდით, რომ პასუხი გასცეს შეკითხვას?
ტკბილი.
>> იქ ნებისმიერი სხვა საკითხებს დასტის და ბევრი?
ჰო.
>> სტუდენტი: მე ვიცი, თქვენ გაქვთ თავისუფალი strings იმიტომ, რომ ისინი ბევრი
და არ გსურთ გაჟონვა მეხსიერება.
მაგრამ გაქვთ თავისუფალი გლობალური ცვლადები და პერსონალის იგრძნობა?
ან ისინი ავტომატურად გათავისუფლდებიან?
>> JASON HIRSCHHORN: კარგი კითხვაა.
ასე რომ cs50.h, ჩვენ შევქმნით ამ რამ თქვენ მოუწოდა სიმებიანი.
String მართლაც რა?
>> სტუდენტი: Char ვარსკვლავი.
>> JASON HIRSCHHORN: A char ვარსკვლავი, მომცეთ to ხასიათი, მომცეთ
მასივი სიმბოლო.
სწორედ string არის.
ამიტომ, ჩვენ უნდა გავათავისუფლოთ, რადგან GetString, რაც ჩვენ ბევრი -
string სახელი შეადგენს GetString -
რომ mallocs ჩვენთვის გარკვეული მეხსიერების ბევრი და შემდეგ დააბრუნებს მომცეთ
პირველი ხასიათი, რომ სიმებიანი, char ვარსკვლავი.
>> ასე რომ, თითქოს, თუ თქვენ არ წერა უფასოდ თქვენს strings
რომ თქვენ მოუწოდა ჯერჯერობით, თქვენ უნდა უკვე ჩამოდის ზოგიერთი მეხსიერებაში.
რა თქმა უნდა, ჩვენ არ ისაუბრა , ასე რომ არავინ მიღებული
პრობლემები ვაკეთებთ.
მაგრამ წინსვლის, დიახ.
როცა რეკავთ GetString, თქვენ mallocing გარკვეული სივრცე ბევრი.
და თუ თქვენ არ მოვუწოდებთ უფასო მოგვიანებით, რომ სიმებიანი, თქვენ გაქვთ მეხსიერების გაჟონვის.
რომ პასუხი თქვენს კითხვაზე?
>> ჰო
>> სტუდენტი: ასე უნდა გავაკეთოთ, რომ ვიყენებთ free უფლება ადრე დაბრუნების?
მსგავსად, ფარგლებში, ვფიქრობ, თუ ჩვენ ვამბობთ, როგორიცაა, int, მთავარ ფარგლებში
ფარგლებს კოდი რომ ფარგლებში იმ curly აფრთხილებს, უფლება -
თქვენ იცით, სადაც ნეტავ ჩვეულებრივ დააყენა დაბრუნების.
იცით თუ დააყენა უფასო მანამდე?
>> JASON HIRSCHHORN: ასე რომ თქვენ შეგიძლიათ განათავსოთ უფასო იქ, სადაც გსურთ განათავსოთ უფასო.
იმიტომ, რომ ეს დინამიურად გამოყოფილი ცვლადები, რადგან მათ შეუძლიათ
ცხოვრება სცილდება კონკრეტული ფუნქცია, თუ რეკავთ malloc წელს
ცალკე ფუნქცია, მაგალითად, GetString, შეგიძლიათ დარეკოთ უფასოდ მთავარი.
თქვენ არ გჭირდებათ ეძახით კონკრეტული ფუნქცია
სადაც malloc ეწოდება.
მაგრამ თქვენ უნდა ეძახით სანამ მთავარ ბრუნდება.
>> და ეს ნამდვილად არის დამოკიდებული.
ეს დამოკიდებულია იმაზე, თუ რატომ malloced რომ ფართი პირველ რიგში.
ზოგიერთი ადამიანი მოვუწოდებთ თავისუფალი საკმაოდ სწრაფად.
ზოგიერთი ადამიანი არ მოვუწოდებთ თავისუფალი, სანამ ბოლომდე მათი პროგრამა.
და ისინი ყველაფერს გაიაროს თავისუფალი და ყველაფერი.
ეს დამოკიდებულია იმაზე, თუ რატომ მოუწოდა malloc.
>> სტუდენტი: რა იტყვით თუ თქვენ მოუწოდა გამოყენების GetString?
თქვენ მინდა ვთქვა, უფასო რა?
>> JASON HIRSCHHORN: So სინტაქსი უფასო უბრალოდ თავისუფალი, ღია paren ახლოს,
paren, და სახელი მაჩვენებელი.
ასე რომ, თუ წერთ string სახელი თანასწორთა GetString, თქვენ დააყენა სახელი აქ.
ეს არის ის სახელით მაჩვენებელი.
და იგი დარწმუნებულია, თავისუფალი, რომ მეხსიერებაში.
>> სტუდენტი: ასე რომ, როდესაც ათავისუფლებს, რომ მეხსიერება, მაჩვენებელი კვლავ მიუთითებს, რომ ადგილი
მეხსიერებაში?
ან მაჩვენებელი ასევე დაცლილი მისამართი, რომ ეს მიუთითებს.
>> JASON HIRSCHHORN: ჩვენ უნდა ვეცადოთ, რომ.
ჩვენ უნდა კოდი, რომელიც.
მოდით დავბრუნდებით როდესაც მივიღებთ კოდირების, და მოდით კოდი, რომელიც.
და თუ გვინდა, რომ გაერკვნენ პასუხი რომ, ასევე, შეგიძლიათ კოდი, რომელიც
ამასობაში.
მაგრამ ეს დიდი კითხვა.
>> სტუდენტი: შესაძლებელია free რაღაც ძალიან მალე?
ასე, რომ თქვენ მაინც სჭირდება თქვენი პროგრამა, და თქვენ გაათავისუფლა, რომ მეხსიერების სივრცე?
>> JASON HIRSCHHORN: დიახ.
ეს შესაძლებელია, თუ თავისუფალი რაღაც და მაშინ გამოიყენოს იგი კვლავ, თქვენ
გადაეყარონ შეცდომა.
მაგრამ ეს თქვენ, რადგან თქვენ გაათავისუფლა რაღაც და შემდეგ მას შემდეგ.
ისე, რომ პროგრამისტი შეცდომა.
მაგრამ დიახ.
თქვენ შეეძლო დაეწერა, რომ.
>> ნებისმიერი უფრო მეტი შეკითხვა -
დიახ.
>> სტუდენტი: ასე რომ, თუ თქვენ უნდა მხოლოდ გასათავისუფლებლად ეს ზოგადად ადრე
პროგრამა დამთავრდა, ნიშნავს თუ პროგრამა დამთავრდა და თქვენ არ გაათავისუფლოს იგი,
რომ მეხსიერების მაინც გამოყოფილი?
>> JASON HIRSCHHORN: თუ თქვენი პროგრამა დამთავრდა და თქვენ დაგავიწყდებათ გასათავისუფლებლად რაღაც, მაშინ
რომ მეხსიერების გამოყოფილი მთელი სიცოცხლის თქვენი პროგრამა.
როდესაც თქვენი პროგრამის ხურავს მთლიანად, რომ მეხსიერება არ აპირებს
იქ სამუდამოდ.
კომპიუტერი არის ჭკვიანი საკმარისი ვიცი რომ როდესაც პროგრამა იხურება, მას
უნდა მოისპოს ყველა მეხსიერება, ასოცირდება, რომ პროგრამა.
>> თუმცა, არსებობს იარაღები შეგიძლიათ აწარმოებს on პროგრამა აღმოაჩინოს, თუ, როდესაც
პროგრამის დასრულების შემდეგ, თქვენ დაავიწყდა გასათავისუფლებლად ზოგიერთი მეხსიერებაში.
და თქვენი მომავალი პრობლემა კომპლექტი, სადაც თქვენ უნდა გამოყენებით malloc და გამოყენებით
პოინტერები, თქვენ გაშვებული ამ პროგრამა თქვენს პროგრამაში თუ,
როდესაც მთავარ ანაზღაურება, თქვენ გარკვეული რამ, რაც დარჩა unfreed.
>> ასე რომ, ისინი არ აპირებენ დარჩენას malloced forever თქვენს კომპიუტერში.
ეს იქნება wasteful, რადგან ძალიან სწრაფად, კომპიუტერი
რომ ამოიწურა მეხსიერება.
მაგრამ თუ გაუშვით ბოლომდე თქვენი პროგრამა და ისინი არ გათავისუფლდებიან და თქვენი
პროგრამა ითიშება, რომ კვლავ პრობლემად რომ ეს ინსტრუმენტი დაგეხმარებათ მიმართოს.
>> სტუდენტი: ის არის, რომ Valgrind?
>> JASON HIRSCHHORN: ეს მოუწოდა Valgrind.
და თქვენ -
>> სტუდენტი: მაგრამ ჩვენ არ უნდა იცოდეს, რომ ინტელექტუალური, თუმცა?
ვგულისხმობ, ის ისაუბრა ცოტა ლექცია.
>> JASON HIRSCHHORN: So Valgrind არის სახელი, რომ ინსტრუმენტი.
იცის, თუ რას აკეთებს არის საკმარისი ვიქტორინა.
მაგრამ თქვენ არ გამოიყენება ამაზე თქვენი პრობლემა კომპლექტი იმიტომ, რომ ჩვენ არ ჰქონდა
პრობლემა კომპლექტი, რომელიც ღიად რიგდება ერთად malloc ან თქვენ იყენებთ malloc.
ასე რომ თქვენ არ გამოიყენება Valgrind არავის გაუკეთებია.
მაგრამ თქვენ გამოიყენოს იგი ადრე ვიდრე მოგვიანებით.
>> სტუდენტური შეგიძლიათ ვიმეორებ რა Valgrind არის?
>> JASON HIRSCHHORN: უკაცრავად?
>> სტუდენტური შეგიძლიათ გავიმეორო მიზნით Valgring არის?
>> JASON HIRSCHHORN: Valgrind არის სახელი -
მოსწონს GDB გეხმარებათ გამართვის თქვენი პროგრამა, Valgrind გეხმარებათ გაერკვნენ, თუ
რამ არ იქნა გათავისუფლებული როდესაც თქვენი პროგრამის იხურება.
ასე რომ თქვენ აწარმოებს თქვენი პროგრამა.
და თქვენი პროგრამის გასასვლელების, და ეს ვიტყვი თქვენი პროგრამის მოუწოდა malloc ამ ბევრი
ჯერ ამდენი ბაიტი, და თქვენ მხოლოდ მოუწოდა free ეს ბევრჯერ.
და ასე რომ თქვენ დაუტოვებიათ ამ ბევრი bytes გარეშე გაათავისუფლეს.
ან იგი ყველაფერს ამბობენ თქვენ გათავისუფლდა ყველაფერი.
კარგად იმუშავა.
>> სტუდენტი: OK.
და ეს ე.წ. Valgring?
>> JASON HIRSCHHORN: V-A-L-G-R-I-N-D.
>> სტუდენტი: შეკითხვა პოინტერები.
ასე რომ ვთქვათ, თქვენ არ n ვარსკვლავი x უდრის რაღაც.
რომ შეადგენს, რაც თქვენ აყენებს არსებობს, არის ის, რომ რა ხდება დააყენა შიგნით
რა x მიუთითებს, ან კურსორი of x?
>> JASON HIRSCHHORN: შეგიძლიათ ვიმეორებ კითხვას?
შეგვიძლია, ხოლო თქვენ ამბობთ ამას?
>> სტუდენტი: In ვიქტორინა, ფაქტობრივად, ერთი თქვენ გამოგვიგზავნეს, თითქოს, char
star სიმართლე შეადგენს CS50 კლდეები, არა?
ასე რომ, ნიშნავს, რომ CS50 კლდეები არის ის, რაც სიმართლე მიუთითებს?
>> JASON HIRSCHHORN: ასე რომ თქვენ საუბარი დაახლოებით char ვარსკვლავი სიმებიანი, თუ როგორ
რომელიც მუშაობს?
ჰო.
OK.
მოდით დავხატოთ ეს მეტი აქ.
>> [SIDE მიმოწერა]
>> JASON HIRSCHHORN: ასე რომ, ამ ცვლადის იქნება ტიპის char ვარსკვლავი.
როგორ დიდი არის ცვლადი ტიპი char ვარსკვლავი?
რამდენი ბაიტი?
>> სტუდენტური ოთხი.
>> JASON HIRSCHHORN: ეს არის ოთხი bytes.
რამდენი უფლებების ცვლადი ტიპის int ვარსკვლავი?
>> სტუდენტური ოთხი.
>> JASON HIRSCHHORN: ოთხი bytes.
იმ შემთხვევაში, თუ ეს მაჩვენებელი, მაშინ ის ყოველთვის ოთხი ბაიტი, რადგან მითითებას, მათი
ღირებულება მეხსიერების მისამართზე.
და მეხსიერების მისამართები CS50 ელექტრო ოთხი ბაიტი ხანგრძლივი.
ასე რომ, როდესაც ჩვენ მოვუწოდებთ GetString, ან როდესაც ჩვენ ვთქვათ, stringname შეადგენს, ხოლო შემდეგ
ორმაგი შეთავაზებები დააყენა სიმებიანი, ჩვენ აყენებს -
კარგად, რომ ცოტა განსხვავებული.
ჩვენ ყველაფერს გავაკეთებთ, GetString, როგორც მაგალითად.
ან char ვარსკვლავი რაღაც შეადგენს სიმებიანი.
უკაცრავად, მომეცი მაგალითად რომ წაიკითხოთ?
>> სტუდენტი: char ვარსკვლავი სიმართლე შეადგენს "CS50 კლდეები" ორმაგ ბრჭყალებში.
>> JASON HIRSCHHORN: ასე რომ, ეს ვარსკვლავი, ამ ჩვენ მოვუწოდებთ ამ ცვლადი x ჩვენი
generic მიზნებისათვის.
ჩვენ შევქმენით ცვლადში x.
ეს ტიპი char ვარსკვლავი.
ეს არის მაჩვენებელი სერია სიმბოლო.
ასე რომ, აქ ქვემოთ -
>> ასე რომ ეს არის, თუ როგორ ეს იქნება მუშაობა მეხსიერებაში.
ამ შემთხვევაში შესანახად მეხსიერებაში მისამართზე.
ეს იქნებოდა შესანახად მეხსიერებაში მისამართი პირველი პერსონაჟი მასივი.
და მაშინ, როდესაც თქვენ მოჰყვა კურსორი, თქვენ უნდა
მისაღებად პირველი ხასიათი.
>> და თუ თქვენ კითხულობთ ამ რამ, როგორიცაა სიმებიანი, თქვენს კომპიუტერში არ არის ჭკვიანი
საკმარისი ვიცი, წავიკითხე ამ მთელი რამ სანამ იგი იღებს, რათა საწინააღმდეგოდ 0.
მაგრამ თუ თქვენ კითხულობს ეს ხასიათი at დრო, ასე რომ თქვენ iterating მეშვეობით
ამ სტრიქონს, მაშინ თქვენ უბრალოდ წაიკითხა ხასიათი დროს სანამ თქვენ მიიღებთ
backslash 0.
რომელიც შესაძლოა არ უპასუხოს თქვენს კითხვა, თუმცა.
>> სტუდენტი: ჰო, მაგრამ თქვენ არა გაქვთ malloced რომ სივრცე
ჯერ რომ მომცეთ.
>> JASON HIRSCHHORN: ასე რომ, მე არ ვარ საკმაოდ დარწმუნებული ვარ, ზუსტად რა თქვენ ეძებს,
იმიტომ, რომ მე არ მიიღოს, რომ ვიქტორინა.
ეს უნდა იყოს სასარგებლო რესურსი სხვა TF.
თუ თქვენ შექმნით სიმებიანი შესახებ დააწყობს ან როგორც ადგილობრივი ცვლადი, იგი ყველაფერს
მხოლოდ მასივი ბრალდებით, ვიდრე ზოგადად char ვარსკვლავი მიუთითებს
სხვა სიმებიანი.
მაგრამ მე არ ვიცი.
ეს შეიძლება იყოს მომცეთ სხვა string დასტის ისევე.
ჰო.
>> სტუდენტი: მე ვიცი, რომ თქვენ უნდა გამოყოს მეხსიერება თუ კურსორი არის
მიღების განაცხადა შიგნით სხვა ფუნქცია.
თქვენ უნდა გავაკეთოთ იგივე, თუ ის ცხადდება შიგნით ძირითადი,
თქვენ იყენებთ შიგნით ძირითადი?
>> JASON HIRSCHHORN: ასე რომ, დიახ.
თქვენ შეგიძლიათ გამოაცხადოთ მომცეთ რაიმე მეხსიერების მისამართი მეხსიერებაში.
ეს შეიძლება იყოს მეხსიერების მისამართი ადგილობრივი ცვლადი, თუმცა ხშირად,
ხალხი არ განაცხადოს მეხსიერების მისამართები ადგილობრივი ცვლადები, რადგან ისინი დადიან
მოშორებით ერთხელ რომ ფუნქცია დააბრუნებს, რომელიც ამიტომ ზოგადად malloc რამ.
მაგრამ დიახ, თქვენ შეიძლება განაცხადოს მაჩვენებელი სხვა ადგილობრივი ცვლადი.
უბრალოდ საერთოდ არ კეთდება.
მაგრამ შემიძლია შევხედოთ, რომ კონკრეტული რამ შემდეგ კლასი.
ჰო.
>> სტუდენტი: მე ვფიქრობ, რომ ეს არის ერთგვარი რა სთხოვა.
ეს არ ჩანს უცნაური უნდა ინიციალიზებისას მაჩვენებელი არ არის, როგორც
მისამართი, მაგრამ რაც როგორც ჩანს, ღირებულება.
როგორც ჩანს, CS50 არის რა შიგნით რაც მიმდინარეობს აღნიშნა და
არ ფაქტობრივი მისამართი, უფლება?
>> JASON HIRSCHHORN: ასე რომ, არ არის, თუმცა.
ეს არ არის, რა ხდება.
როდესაც თქვენ გამოაცხადოს char ვარსკვლავი, ეს მეხსიერების მისამართზე.
პოინტერები ყველა მეხსიერების მისამართები მიუთითებს რაღაც.
რომ რაღაც შეიძლება იყოს დასტის, მაგრამ თითქმის ყოველთვის არის
ბევრი გზა ვნახავთ გამოიყენება.
მაგრამ stringname ტოლია ორმაგი გაცემა "GetString," ჩვენ ვხედავთ, რომ ჩვენ
შეგიძლიათ გაეცნონ, რომ და კოდი, რომელიც.
GetString string არ არის შენახული რომ ცვლადი, ან რასაც სიმებიანი
სახელი არ არის შენახული, რომ ცვლადი, იმიტომ, რომ ის, თუ როგორ
პოინტერები მუშაობა.
ამჯამად რომ აზრი?
>> სტუდენტი: Yeah.
>> JASON HIRSCHHORN: OK.
იმედია, რომ არ იყო გაუგებარია ვინმეს.
მაგრამ თუ ეს იყო, ჩვენ შეგვიძლია შევხედოთ მას ერთხელ ცოტა, იმიტომ, რომ ჩვენ რეალურად აპირებს
კოდექსში, რომ რაღაც იქნება იმედია მუშაობა სტრიქონები და დაგეხმარებათ გრძნობენ
უფრო კომფორტულად მათ.
>> ნებისმიერი სხვა სახის კითხვებით დაკავშირებული ამ თემები და სხვა საკითხები, რომლებიც
მე დააყენა back up?
და -
ახლა.
დიახ, Alden.
>> ALDEN: ასე რომ ეს სრულიად unrelated, მაგრამ შეგვიძლია უბრალოდ მეტი
მართლაც სწრაფად ის, რაც ჩვენ უნდა ვიცოდეთ სხვაობა 32 და
64-bit მანქანა?
>> JASON HIRSCHHORN: დიახ.
ასე რომ, 32 ბიტი არის რამდენი ბაიტი?
>> ALDEN: ეს არის ოთხი bytes.
>> JASON HIRSCHHORN: ეს არის ოთხი bytes.
და 64 ბიტი რამდენი ბაიტი?
>> სტუდენტი: რვა.
>> JASON HIRSCHHORN: რვა bytes.
ასე რომ კიდევ ერთხელ, რვა ბიტი არის ერთი ბაიტი.
თქვენი CS50 ელექტრო მოწყობილობების არის 32-bit მანქანა.
ასე რომ მეხსიერების მისამართები ოთხი ბაიტი ხანგრძლივი.
არსებობს 2 დან 32 მეხსიერების მისამართები.
0 2 32 მინუს 1.
და მე არ ვარ დადებითი, მაგრამ ეს ალბათ ფარგლებს რაც თქვენ გჭირდებათ რომ
ვიცი, 32-bit მანქანა, რომ მეხსიერების მისამართები, კიდევ ერთხელ, ოთხი ბაიტი ხანგრძლივი,
და რომ მაქსიმალური თანხა მეხსიერების მისამართები.
>> გარდა ამისა, მონაცემთა ტიპები -
ეს შეიძლება იყოს რაღაც კარგად რომ აღსანიშნავია.
ზომა მონაცემები ტიპის დამოკიდებულია მანქანა თქვენ მუშაობს.
ასე რომ char, ერთი ხასიათი, თუ რამდენად ბევრი bytes ჩვენი CS50 ელექტრო?
ერთი byte.
და ეს არის რეალურად ერთი byte როგორც კარგად 64-bit მანქანა.
>> და ყველაზე მონაცემთა ტიპები არიან იგივე ნომერი ბაიტი ორივე მანქანები.
მაგრამ ზოგიერთი მონაცემთა ტიპები იქნება სხვადასხვა ორივე მანქანა.
ისე, რომ იქნება პოტენციურად ერთადერთი, რაც თქვენ უნდა იცოდეთ.
>> მაგრამ, რომ, ვფიქრობ, არის მიღმა -
მე თითქმის დადებითი, თუ ვიხსენებთ ძველი ტესტები, ის ამბობს, დავუშვათ
კოდირების პრობლემები თქვენ იყენებთ 32-bit მანქანა.
მაგრამ არსებობს, წავიდეთ ერთად, რომ თუ თქვენ დაინტერესებული, არსებობს
მონაცემთა ტიპები, რომლებიც იმავე ზომა ყველა მანქანები.
>> თუ ვნახე რაღაც uint32_t, თქვენ შეიძლება იყოს ან
არ მინახავს, ​​რომ.
ეს მონაცემები ტიპის.
რომ ამბობს, იყოს 32 ბიტი არ აქვს მნიშვნელობა, რა მანქანა ეს არის.
ასე რომ, როდესაც ადამიანი წერილობით პორტატული კოდი, ალბათ არ იქნება გამოყენებული ints.
ისინი ნაცვლად გამოიყენოთ ეს სხვა მონაცემები სახის, რომ მათ იციან იქნება იგივე
ზომა თითოეული მანქანა.
Madhu.
>> Madhu: მე მქონდა შეკითხვა compilation პროცესში.
ასე რომ, თუ თქვენ წერა პროგრამა, რომელიც იყენებს ბიბლიოთეკა მოსწონს CS50 ან რამე
მოსწონს, რომ მე ვიცი, რომ ბიბლიოთეკა აქვს, რაღაც მომენტში, უნდა
შედგენილი და უკავშირდება შემოსული
მაგრამ რამდენად, რომ ხდება შედგენა თქვენი პროგრამა?
რა ნაწილი რომ ბიბლიოთეკა პროცესი ხდება, როდესაც თქვენ
შედგენა თქვენი პროგრამა?
>> JASON HIRSCHHORN: მოდით წავიდეთ მეტი ზოგადად ნაბიჯები ამ პროცესში.
თქვენ დაწერეთ თქვენი. C ფაილი.
თქვენს. გ ფაილი, თქვენ # მოიცავს თქვენი header ბიბლიოთეკების, მაგალითად, cs50.h.
რას მკვეთრი არის ონლაინ გააკეთოთ, რომ თქვენი პროგრამა?
Akchar.
>> AKCHAR: იგი დასძენს პროტოტიპები ფუნქციების header
ფაილი ბიბლიოთეკები.
>> JASON HIRSCHHORN: ზუსტად.
იგი დასძენს იმ ფუნქციის პროტოტიპები თქვენს კოდი.
ასე რომ, როდესაც თქვენი კოდი იქმნება ადრეულ სტადიაზე, შემდგენელი იცის
რომ ამ ფუნქციების რეალურად არსებობს, და რომ სადღაც მათ უკვე განსაზღვრულია.
. H ფაილი არ შეიცავს განსაზღვრებები ამ ფუნქციების ან როგორ
ისინი რეალურად მუშაობს.
Cs50.h მხოლოდ მოიცავს რასაც ამბობს GetString არის რეალური რამ,
შეიძლება მოხდეს.
და standardio.h ამბობს printf არის რეალური, რაც შეიძლება მოხდეს.
>> ასე რომ თქვენი c ენის ამ. Header ფაილის იღებს გადაიქცა რაღაც
მანქანით წაკითხვადი კოდი, რომელიც საბოლოოდ იღებს გადაიქცა ორობითი
კოდი, 0 და 1 ს.
და ეს კოდი, რომელიც საბოლოოდ იღებს დასაჯეს.
-L cs50 ონლაინ - მაგალითად, როდესაც თქვენ წერილობით Clang -
და მაშინ მოიცავს-l CS50, თქვენ ჩაწერეთ რომ სისტემაში
და ხედავთ, რომ.
როდესაც წერთ, რათა, თქვენ ვხედავთ, რომ გამოდიან აქ.
და ვნახავთ, რომ მეორე, როდესაც ჩვენ კოდექსით ან მოგვიანებით, როდესაც ჩვენ კოდი.
>> მაგრამ, რომ-l cs50 ხაზი აკეთებს ცოტა განსხვავებულია, ვიდრე
# მოიცავს cs50.h.
რას-l cs50 ონლაინ გავაკეთოთ?
Avi?
>> AVI: მე მინდა ვთქვა, რომ ეს ბმულები ბიბლიოთეკის ფუნქცია
მოვუწოდებთ, როგორიცაა. o ფაილი.
>> JASON HIRSCHHORN: ასე რომ ძალიან ახლოს, თუ არ მიხვდებიან, რაშია-on.
-L cs50 იღებს ორობითი ფაილი და უერთდება ეს თქვენი ორობითი ფაილი.
ასე რომ cs50.h, არ არსებობს წერტილი გარდამტეხი cs50.h ეხლა C ენის ორობითი ყველა
ერთ დროს ის გამოიყენება.
ეს იქნება სულელური, იმიტომ, რომ რომ დაგვრჩა ბევრი დრო.
ასე რომ, უკვე შედგენილია და გადაიქცა შესრულებადი.
და ახლა იგი აპირებს შეუერთდა თქვენი ფაილი დასასრულს.
ასე რომ იმ 1 და 0 ს ვაპირებთ შერწყმა თქვენი პირობა
და 0 ს დასასრულს.
ახლა თქვენ რეალურად აქვს ფაქტობრივი 1 და 0 ის, რომ განისაზღვროს, თუ როგორ GetString,
მაგალითად, სამუშაოების, ან როგორ printf, მაგალითად, მუშაობს.
>> და მეტი ინფორმაციით, არსებობს მოკლე compilers რომ Nate იძლევა, რომ
თქვენ უნდა შეამოწმეთ რომ მიდის მეშვეობით ამ ნაბიჯებს.
მაგრამ -
დიახ.
>> სტუდენტი: ისინი ყოველთვის. O ფაილი როდესაც ისინი ბიბლიოთეკაში ფორმა,
მზად უნდა გაერთიანდა, უკავშირდება - როგორც ისინი ორობითი კოდი?
>> JASON HIRSCHHORN: OK.
რა -
>> სტუდენტი: ის არის, რომ ყოველთვის საქმე ბიბლიოთეკების, როდესაც თქვენ უკავშირებენ მათ?
>> JASON HIRSCHHORN: დიახ.
ასე რომ არსებობს. S ფაილი, რომელიც იქნება მანქანა კოდი, რომელიც ასევე იქნება
cryptic თქვენ.
თქვენ არ გჭირდებათ ფიქრი იმ.
მაგრამ ზოგადად, yeah, ისინი ყველაფერს იყოს. o ფაილი მზად ვართ წავიდეთ.
>> სტუდენტი: ასე რომ, როდესაც თქვენ გემი ბიბლიოთეკა, თქვენ მხოლოდ მოვახდენთ
. h და. o?
თქვენ არ დაძრულიყო. გ ან. S.
>> JASON HIRSCHHORN: ასე -
და ეს არის ამ მოკლე, ასევე, თუ ამ ინფორმაციას, როგორც ჩანს, მოდის
ცოტა სწრაფად.
მაგრამ მოკლე compilers საუბარი ასევე.
როცა ხომალდი ბიბლიოთეკა, თუ მოვახდენთ . სთ, header ფაილი, იმ
ფუნქცია პროტოტიპები, და 1 და 0 ს, რომ ყველა თქვენ უნდა მისცეს.
თქვენ არ უნდა მივცეთ, როგორ ფუნქცია მუშაობს,. c ფაილი.
იმის გამო, რომ წერტილი აბსტრაქცია, ან აღვნიშნო APIs, საქმე ამ SPL,
სტენფორდის პორტატული ბიბლიოთეკა, ის თქვენ არ ინერვიულოთ შესახებ, თუ როგორ new
GRect მუშაობს, თუ როგორ გადავიდეს სამუშაოები, ან როგორ დაამატოთ სამუშაოები.
ყველა თქვენ უნდა იცოდეთ არის ის, რომ add არის ფუნქცია, რომელიც შეგიძლიათ
გამოყენება, და იგი აკეთებს ამას.
ასე, რომ თქვენ ნამდვილად არ უნდა იცოდეს, როგორ ის დაწერილი C. თქვენ უბრალოდ უნდა
ვიცი, აქ ფუნქციები, რაც მათ გავაკეთოთ, და აქ არის 1 და 0 ს
როდესაც თქვენ ნამდვილად გსურთ მათი გამოყენება.
>> ზემოთ.
ნებისმიერი უფრო მეტი შეკითხვა compilers ან სხვა თემა ფორუმში?
>> სტუდენტი: მე მაქვს კითხვა ახორციელებს რეკურსიული ფუნქციები.
კითხვაზე, თუ უკან.
მე მქონდა განცდა, რომ მოვიდოდა up.
მოდით სწრაფად გავლა უკან კონკრეტული
მაგალითად, factorial ფუნქცია.
იმიტომ, რომ ეს არის მაგალითი, რომ ხშირად მოდის ან გამოიყენება
საილუსტრაციოდ უკან.
>> ასე რომ, "4" წაკითხვის 4 factorial.
და რას 4 factorial ნიშნავს?
რას აკეთებთ?
როგორ უნდა გამოვთვალოთ 4 factorial?
4 ჯერ 3 ჯერ 2 ჯერ 1.
>> ასე რომ სხვა გზა დაწერა 4 factorial დაწერა ეს.
4 ჯერ 3 factorial.
იმის გამო, რომ 3 factorial არის 3 ჯერ 2 ჯერ 1.
ასე რომ 4 ჯერ 3 factorial 4 ჯერ 3 ჯერ 2 ჯერ 1.
სწორედ ამიტომ factorial არის დიდი კანდიდატი უკან, რადგან ეს
ნათელია, რომ არსებობს რაღაც, რაც ხდება მეტი და მეტი
მცირე რაოდენობის რამ, სანამ თქვენ მიაღწიონ ბოლომდე.
როდესაც თქვენ მივაღწიოთ 1, 1 factorial არის 1.
თქვენ არ შეგიძლიათ გადასვლა ბევრად უფრო.
0 factorial ასევე განისაზღვრება, როგორც 1.
ასე რომ, როდესაც თქვენ მიიღებთ 1 ან 0, თქვენ დასასრულს, და შეგიძლიათ
დაიწყოს ბრუნდება up.
ასე რომ, თუ გვინდოდა დაწერა რეკურსიული ფუნქციის გამოთვლა factorial,
ჩვენ ვაპირებთ დავწეროთ ზოგიერთი pseudocode, რომ ახლა.
სანამ ჩვენ წერენ, რომ pseudocode -
მე მივცემ თქვენ ბიჭები რამდენიმე წუთი წერენ ფსევდო კოდი ან უბრალოდ ვფიქრობ
ამის შესახებ - არსებობს ორი რამ ყველა რეკურსიული ფუნქცია სჭირდება.
რა არის ეს ორი რამ?
>> JACK: მას მოვუწოდებთ თავად.
>> JASON HIRSCHHORN: Noah?
Oh, ჯეკ.
წავიდეთ წინ.
>> JACK: მას მოვუწოდებთ თავად.
>> JASON HIRSCHHORN: So რეკურსიული ფუნქცია სჭირდება რეკურსიული ზარი,
მოვუწოდებთ თავად.
ეს ერთი.
და რა სხვა რამ?
>> JACK: A ბაზის შემთხვევაში.
>> JASON HIRSCHHORN: A ბაზის შემთხვევაში.
ბაზის შემთხვევაში ის არის, რომ აქ, როცა ჩვენ შეწყვიტოს.
ასე რომ თქვენი ფუნქცია იღებს მოუწოდა.
ბაზის შემთხვევაში მოდის პირველი.
გსურთ ვიცით, თუ თქვენ დასასრულს.
და თუ თქვენ არ დასასრულს, თქვენ რათა თქვენი რეკურსიული ზარი.
და თქვენ გავლა ამ ფუნქციას ისევ, სანახავად ბაზის შემთხვევაში ერთხელ.
თუ თქვენ არ ბოლოს, თქვენ სხვა რეკურსიული ზარი,
et cetera, et cetera.
>> სწორედ ამიტომ რეკურსიული ფუნქციების ყოველთვის გვჭირდება იმ ბაზის შემთხვევებში და იმ
რეკურსიული მოუწოდებს.
თუ თქვენ არ გაქვთ რეკურსიული ზარი, იგი არ უნდა იყოს რეკურსიული ფუნქცია.
თუ თქვენ არ გაქვთ ბაზა შემთხვევაში, თქვენ წავიდოდა სამუდამოდ და
არ იქნება დასასრული.
და ბაზის შემთხვევაში ყოველთვის მოდის პირველი, იმიტომ, რომ თქვენ ყოველთვის გვინდა შევამოწმოთ
თუ თქვენ დასასრულს პირველი.
ასე რომ სანამ ჩვენ გავაკეთოთ ზოგიერთი pseudocode, რატომ არ მიიღოს წუთი ფიქრი
როგორ რეკურსიული factorial ფუნქცია იქნება დაწერილი?
>> ასევე, როგორც ბევრი როგორც თქვენ აკეთებთ, წერის მას გარეთ ფურცელი არის
თუ რას აპირებს გავაკეთოთ ვიქტორინა ხვალ.
ასე რომ, ალბათ კარგი პრაქტიკა, რათა დარწმუნებული კოდი თქვენ წერა
ქვემოთ ფურცელზე -
ან თქვენ შეგიძლიათ ამის გაკეთება.
თქვენ იცით, სადაც semicolons არიან.
გახსოვთ სინტაქსი.
იმიტომ, რომ თქვენ ვერ შეძლებთ აქვს შემდგენელი გითხრათ გააკეთა შეცდომა.
>> ასევე, ერთად იმ ხაზები, ხვალ, როცა თქვენ არ კოდირების პრობლემები, თუ თქვენ
რომლებიც შევარდა დრო, ან თუ თქვენ ძალიან დაბნეული, თუ როგორ თქვენ უნდა
დაწერა კონკრეტული რამ c, ეს რომ behoove გაძლევთ დაწეროთ ფსევდო კოდი
ან ჩაწერის კომენტარები ისევე.
იმიტომ, რომ იქ არასრული, კრედიტი ბევრი კითხვებს ვიქტორინა.
ასე, რომ თქვენ შეიძლება შევარდა, ან თქვენ შეიძლება მხოლოდ იყოს დაბნეული.
წერა კომენტარი ან ფსევდო კოდი ხშირად გზები, რომ თქვენ
შეგიძლიათ მიიღოთ ნაწილობრივი საკრედიტო.
>> ასე რომ არ დატოვოს რაღაც blank on ვიქტორინა.
არ არსებობს ჯარიმები აყენებს რამ შემოსული
ფაქტობრივად, აყენებს ფსევდო კოდი ან კომენტარები აპირებს დაეხმაროს კლასელი
გაერკვნენ, თუ თქვენ ნამდვილად იცით, რა თქვენ ვსაუბრობთ, და იქნებ ჯილდო
თქვენ გარკვეული ნაწილობრივი საკრედიტო რომ.
>> ასევე გასწვრივ იმ ხაზები, დაწერეთ გარკვევით.
იმ შემთხვევაში, თუ ჩვენ არ შეგვიძლია ნამდვილად თუ რას წერს, ჩვენ არ ვაპირებთ თქვენთან დარეკვა
შუაღამისას ხვალ ფიგურა თუ რა დაწერა.
ჩვენ უბრალოდ აპირებს მიიღოს off რაოდენობა.
დაწერეთ აშკარად ასე რომ ჩვენ შეგვიძლია მოვისმინოთ, უფრო სწორად, ჩვენ შეგვიძლია წავიკითხოთ რას წერს.
>> და თუ ის ამბობს, ორი წინადადება, არ წერენ პუნქტში.
მიჰყევით ინსტრუქციას.
დაწერეთ გარკვევით.
და წერენ იმ კომენტარი ან pseudocode კითხვა, რომელიც შეიძლება
ჯილდო ნაწილობრივი საკრედიტო.
>> OK, მოდით წასვლა factorial.
ამიტომ ჩვენ გვაქვს ფუნქცია factorial.
მე რომ რეალურად წერენ ამ C, რა უნდა დააყენოს სანამ სახელი
ფუნქცია?
დაბრუნების ტიპის, რომელიც ამ შემთხვევაში, ჩვენ მივცემ მას int.
და შემდეგ შიგნით curly აფრთხილებს, ის არის, რა მიდის შიგნით curly აფრთხილებს for
ფუნქცია?
>> სტუდენტები: დავა ტიპის.
>> JASON HIRSCHHORN: მისი არგუმენტები.
ასე რომ factorial ალბათ მიიღოს არგუმენტი.
ეს ალბათ მხოლოდ ერთი არგუმენტი.
და ჩვენ აცხადებენ, რომ ეს წავა რიცხვი მოუწოდა x.
და კიდევ ერთხელ, როდესაც წერილობით პროტოტიპი ფუნქცია ან წერილობით ფუნქცია
თქვენს კოდი ადრე განსაზღვრავს ის, რაც თქვენ დაწერა მონაცემთა ტიპი და დასახელება
რომ ცვლადი, რომ ფუნქცია მხოლოდ.
ასე, რომ თქვენ ვერ გაივლის გარკვეული რაოდენობის ამ ფუნქცია, ეს იქნება მოხსენიებული, როგორც x
იძულებით.
>> ჩვენ გვაქვს ჩვენი factorial ფუნქცია.
ჩვენ გვჭირდება ორი რამ, ბაზის შემთხვევაში და რეკურსიული ზარი.
რა არის ბაზა საქმე factorial?
ვინც წერდა ის და, რომელსაც არ სალაპარაკო არ არის, რა არის ბაზა
საქმე factorial?
>> სტუდენტი: თუ n ნაკლებია, ვიდრე 2, დაბრუნება 1.
>> JASON HIRSCHHORN თუ N არის ნაკლებია, ვიდრე 2, დაბრუნება 1.
მინდა, რომ, იმიტომ, რომ ზრუნავს 0 და 1.
ასე რომ, ჩვენ ყველაფერს გავაკეთებთ x <2, დაბრუნება 1.
იმ შემთხვევაში, თუ ჩვენ მივიღებთ გავიდა 0, თუ არ მივიღებთ გავიდა 1, ეს ფუნქცია
დაუყოვნებლივ დაბრუნებას 1.
იმ შემთხვევაში, თუ ჩვენ მივიღებთ გავიდა გარკვეული რაოდენობის მეტი მეტი ან ტოლია 2, ჩვენ ვაპირებთ
ჩვენი რეკურსიული ზარი.
>> და ა.შ. როგორ არის, რომ იმუშავებს?
შეგიძლიათ ვინმეს, ვინც მუშაობდა ამ ვინც არ ლაპარაკობენ ჯერჯერობით მომეცი
რეკურსიული მოწოდება ამ ფუნქციის in pseudocode?
იმ შემთხვევაში, თუ ჩვენ მივიღებთ გავიდა რიგ x და ეს უფრო მეტია, ვიდრე 2, რა
გვინდა გავაკეთოთ?
ჩვენ ასევე მაგალითი დაწერილი მხარე, რომელიც შეიძლება გიპასუხოთ.
>> სტუდენტური ზარის x ჯერ factorial of x მინუს 1?
>> JASON HIRSCHHORN: ზუსტად უფლება.
ჩვენ ვაპირებთ დაბრუნებას x times factorial of x მინუს 1.
და რომ, მიუხედავად იმისა, რომ მე დავწერე up, ძირითადად, რაც თქვენ განაცხადა, English,
ამ factorial ფუნქცია მიიღებს ე.წ. ერთხელ.
ეს თქვენ შეასრულოს on x მინუს 1.
ეს კიდე დაბრუნდება ზოგიერთი რიცხვი, და მაშინ ეს თქვენ გავამრავლოთ ეს ორი
ერთად, და რომ ღირებულება იქნება დაბრუნდა რასაც უწოდა
factorial ფუნქცია, რომელიც შეიძლება კიდევ ერთი შემთხვევა
ამ factorial ფუნქცია.
>> ასე რომ, არის მაგალითი რეკურსიული ფუნქცია, ძალიან
მარტივი რეკურსიული ფუნქცია.
მაგრამ მათი უმრავლესობა იქნება მოსწონს ეს.
თუ გსურთ კარგი რეკურსიული გამოწვევა ვიქტორინა, ცდილობენ კოდირების
ორობითი ძებნა რეკურსიული.
იმიტომ, რომ თუ თქვენ არ ორობითი ძებნა პრობლემა კომპლექტი სამი, ალბათ ეს გააკეთა
iteratively ხოლო loop.
>> მაგრამ მას ასევე შეუძლია ჩაიწეროს რეკურსიულად.
თქვენ აპირებთ უნდა დაწეროთ ცალკე ფუნქცია, რომელიც იღებს გარკვეული
სხვადასხვა ბრძანების ხაზი არგუმენტები - ან არა ბრძანების ხაზი არგუმენტები, ზოგიერთი
სხვადასხვა მხოლოდ რეგულარული არგუმენტები.
მაგრამ თქვენ ვერ წერენ ორობითი ძებნა რეკურსიული ასევე.
>> სტუდენტური ასე რომ თქვენ შეიძლება ასევე წერია, ნაცვლად x მინუს 1, თქვენ
შეიძლება ასევე წერილობითი x minus მინუს, ან თქვენ შეიძლება
წერილობითი მინუს მინუს x.
შეგიძლიათ უბრალოდ ავუხსნათ მართლაც სწრაფად რატომ იმ იქნებოდა სხვადასხვა ნივთები,
მოსწონს რა განსხვავება არის შორის x მინუს მინუს და მინუს მინუს x?
>> JASON HIRSCHHORN: არა, მე არ ვარ ვაპირებ წასვლას, რომ.
მაგრამ მე გელაპარაკოთ მას შემდეგ, კლასი. x მინუს მინუს, მინუს მინუს x
decrement x 1.
მაგრამ მათ ამის გაკეთება ცოტა განსხვავებულად.
მაგრამ მე არ მინდა, რომ.
სხვა კითხვებს უკან ან ეს ფუნქცია?
ეს არ არის ნამდვილად კი pseudocode.
რომ ძირითადად კოდი in C თქვენ ამას წერენ ამ.
>> OK, ნებისმიერი სხვა სახის კითხვებით თემებზე აქ?
ჰო.
>> სტუდენტი: მე მაქვს სწრაფი rundown of მცურავი წერტილი და ზუსტი.
>> JASON HIRSCHHORN: Floating წერტილი და ზუსტი.
შეგიძლიათ ვინმეს მართლაც სწრაფად მომეცი rundown of
მცურავი წერტილი და ზუსტი?
თქვენ ყველა უნდა გაეკეთებინათ ეს თქვენი პრობლემა კომპლექტი, ასე რომ თქვენ ყველა
იცნობს მას.
ან იქნებ არა ყველა თქვენ.
ვინმეს?
მომეცი დაიწყო ადგილზე.
მცურავი წერტილი და ზუსტი.
რა არის პრობლემა?
დიახ.
Victoria?
>> VANESSA: Vanessa.
>> JASON HIRSCHHORN: Vanessa.
უკაცრავად.
>> VANESSA: არსებობს მხოლოდ სასრულ ნომერი ციფრები, რომ შეიძლება წარმოდგენილი
იმიტომ, რომ თქვენ, ჩვენს შემთხვევაში, 32-bit სისტემა.
ასე, რომ თქვენ სახის უნდა შეადგინოს ზოგიერთი ნომრები.
>> JASON HIRSCHHORN: ასე რომ, სწორედ.
არსებობს მხოლოდ გარკვეული რაოდენობის ციფრები, რომ შეიძლება წარმოდგენილი.
თუ თქვენ გავამრავლოთ ორი ძალიან დიდი რაოდენობით, ეს შეიძლება overflow ოდენობით
ფართები თქვენ უნდა წარმოადგენს მთელი რიცხვი.
ამიტომ, ზოგჯერ ჩვენ ვიყენებთ ხანგრძლივი ხანგრძლივი ნაცვლად int.
რომ უფრო მეტი სივრცეებს.
რომ შეიძლება გამართავს დიდი რაოდენობის.
>> მცურავი პუნქტიანი სიზუსტით უნდა გააკეთოს , მაგრამ ასევე აქვს შუაშია
ის ფაქტი, რომ ათობითი ნომრები ყოველთვის არ არის წარმოდგენილი.
უკაცრავად.
ნება მიბოძეთ ამ თავში up.
ათობითი რიცხვი 1.0 ყოველთვის არ არის წარმოდგენილია, როგორც თქვენ მოელოდა,
1,000000000.
იგი ხანდახან წარმოდგენილია როგორც 1,000000001 ან 0,999999999.
ეს შეიძლება იყოს თუნდაც 89 დააგდეს იქ სადღაც.
ასე რომ იმ ათობითი ციფრები არ არის წარმოდგენილია ზუსტად ისევე, როგორც თქვენ ამას
ველით, რომ ისინი იყოს წარმოდგენილი.
>> ასე რომ, პრობლემა კომპლექტი -
იყო ეს ორი? -
პრობლემა კომპლექტი, ორი, სადაც ჩვენ შესძლეს მცურავი პუნქტიანი ნომრები, როცა გვინდოდა
მათ წარმოადგენს სწორედ ის, რაც ჩვენ გვინდოდა მათ წარმოადგენს, ნომერი
საქართველოს pennies, ან რაოდენობის ცენტი, გავამრავლებთ მათ მიერ 100.
ჩვენ მრგვალდება მათ.
და მაშინ ჩვენ შეწყვიტა ყველაფერი უკან ათობითი წერტილი.
ეს იყო იმის უზრუნველყოფა, რომ ისინი რეალურად ტოლია ზუსტად ის, რაც გვინდოდა
მათ გაუტოლდება.
>> იმის გამო, რომ, როდესაც თქვენ მიიღოს რაღაც რომ ათწილადი და ჩართოთ იგი int, თქვენ
შეწყვიტა ყველაფერი მარჯვენა ათობითი წერტილი.
იმის გამო, რომ არსებობს გარკვეული მცურავი წერტილი ორაზროვნება, 100.000 შეიძლება
წარმოდგენილია როგორც 99,999999999.
და თუ უბრალოდ შეწყვიტა ყველაფერი მარჯვენა დაუყოვნებლივ, თქვენ აპირებს
არასწორი ნომერი.
ჰო.
>> სტუდენტი: მე მქონდა კითხვა დაახლოებით აძლევენ.
რა მიზნით იგი მოხდეს?
თუ გსურთ გააკეთოთ float, ფრჩხილებში, 1 გაყოფილი 10, იგი ჩვენგან 1 იყოფა 10,
შემდეგ კიდევ 0.1, მაშინ იქცევა იგი float?
>> JASON HIRSCHHORN: თუ თქვენ ათწილადი 1 იყოფა 10 -
>> სტუდენტი: ჰო, და შემდეგ შეადგენს -
ასევე, ეს ჩვეულებრივ აქვს მას თანასწორი -
ჰო.
გსურთ, რათა ის float, არა?
>> JASON HIRSCHHORN: OK, ასე რომ, ჩვენ ვაპირებთ გამოიყენოთ, რომ segue შევიდა მჭიდროდაა
ამ კითხვებზე პასუხის გაცემა მეშვეობით კოდირების.
იმის გამო, რომ თქვენ ალბათ ბევრი ამ წუთში კითხვებს, და კარგი გზა
მათ მოგვარებას მეშვეობით კოდირების.
ამიტომ, ჩვენ ვაპირებთ, რომ კოდექსის ამ წუთას, და მაშინ ჩვენ ვაპირებთ წავიდეთ უკან და
კოდექსის კითხვა გქონდათ.
>> ასე რომ, პირველი ხაზი -
მე არ უნდა წერილობითი იგი - რა არის პირველი, რაც ჩვენ გვინდა, რომ, როდესაც ჩვენ
ქმნის ახალ ფაილს gedit?
>> სტუდენტური ჩართეთ.
>> JASON HIRSCHHORN: ჩართეთ რა?
>> სტუდენტი: CS50 ბიბლიოთეკაში.
>> JASON HIRSCHHORN: OK.
რა უნდა შეიცავდეს?
ჩვენ უბრალოდ აპირებს შეამოწმოს, რა ხდება როდესაც თქვენ მიცემული რაღაც float.
მაგრამ რას უნდა შეიცავდეს თუ ჩვენ აპირებს დაწეროს C პროგრამაში?
>> სტუდენტი: სტანდარტული I / O.
>> JASON HIRSCHHORN: stdio.h.
ჩვენ, ფაქტობრივად, არ უნდა, ამ პროგრამა, cs50.h, მიუხედავად იმისა, რომ
ყოველთვის სასარგებლოა მოიცავს იგი.
მაგრამ ჩვენ ყოველთვის უნდა stdio.h.
>> სტუდენტი: როდესაც კოდირების C?
>> JASON HIRSCHHORN: როდესაც კოდირების C.
>> ასე რომ, მე გადარჩენა, როგორც ეს. C ფაილი.
მე კიდევ ზოგიერთი ლამაზი სინტაქსის შეფერადება.
მე დავწერე ბათილად შიგნით ძირითადი.
რას ბათილად ნიშნავს?
>> სტუდენტი: არა მიიღოს ნებისმიერი ბრძანების ხაზი არგუმენტები.
>> JASON HIRSCHHORN: Void საშუალებით, ამ შემთხვევაში, მთავარი არ მიიღოს ნებისმიერი
ბრძანების ხაზი არგუმენტები.
სხვა შემთხვევაში ეს ნიშნავს ფუნქცია არ მიიღოს ბრძანება ხაზი არგუმენტები.
ან ფუნქცია, თუ მე დაწერა void ძირითადი (void), რომელიც იტყვის, მთავარ მიერ
არ დაბრუნების არაფერი.
ასე რომ, ბათილად უბრალოდ არაფერს ნიშნავს.
რას ვწერ, თუ მე რომ მიიღოს ბრძანება ხაზი არგუმენტები?
>> სტუდენტი: int arc c string arc წინააღმდეგ
>> JASON HIRSCHHORN: int argc სიმებიანი argv.
არის ის, რომ არა?
>> სტუდენტი: ეს char ვარსკვლავი argv ფრჩხილებში.
>> JASON HIRSCHHORN: ასე რომ, შეგიძლიათ დაწეროთ სიმებიანი argv ფრჩხილებში ან char ვარსკვლავი argv
ფრჩხილებში, მაგრამ თქვენ უნდა ფრჩხილებში.
იმის გამო, რომ argv არის მასივი სიმები, მახსოვს.
ეს არ არის მხოლოდ ერთი სტრიქონი.
ასე რომ სიმებიანი argv არის, აქ არის ერთი string მოუწოდა argv.
სიმებიანი argv ფრჩხილებში არის, აქ არის მასივი სტრიქონები.
ასე int argc სიმებიანი argv ფრჩხილები იქნება რაღაც, რომ მე
ალბათ დაწერა.
>> ასე, რომ თქვენ სურდა შეინახე რიცხვი?
>> სტუდენტი: Yeah, რიცხვი.
ან float.
>> JASON HIRSCHHORN: In float?
მსგავსად, float x უდრის 1 გაყოფილი 10.
>> JASON HIRSCHHORN: OK.
როგორ შემიძლია ამობეჭდოთ float in printf?
რა?
>> სტუდენტი:% ვ.
>> JASON HIRSCHHORN% ვ.
რა რიცხვი?
დ ან i.
რა სიმებიანი?
>> სტუდენტი: s.
>> JASON HIRSCHHORN: s.
როგორ მივიღო ახალი ხაზი?
>> სტუდენტი: backslash n.
>> JASON HIRSCHHORN: რა დაბრუნდნენ იმ შემთხვევაში, თუ მთავარი ეშვება სწორად?
>> სტუდენტი: 0.
მჭირდება დაწერა, რომ ხაზი, თუმცა?
>> სტუდენტი: არა,
OK, ჩვენ არ წერენ, მაშინ.
შეგიძლიათ ყველამ წაიკითხოს ეს?
იგი გამოიყურება ცოტა პატარა.
შეგიძლიათ ყველამ დაინახოს, ან უნდა მე ეს დიდი?
მე ვფიქრობ, რომ ამისთვის კამერა, ჩვენ გავაკეთებ ეს ცოტა დიდია, თუმცა.
>> JASON HIRSCHHORN: თუ მინდა, რომ ეს . გ ფაილის შევიდა გაშვება, რა
შემიძლია დავწერო?
>> სტუდენტი: სასტარტედ ტესტი.
>> JASON HIRSCHHORN: უკაცრავად?
>> სტუდენტი: სასტარტედ ტესტი.
>> JASON HIRSCHHORN: მარკა ტესტი.
ჩვენ ვსაუბრობთ ამ ხაზის ადრე.
Clang.
რა clang?
სახელი შემდგენელი.
რა არის ეს ხაზი?
>> სტუდენტი: Sets it up გამოყენების GDB.
>> JASON HIRSCHHORN: Sets it up გამოყენების GDB.
ეს ხაზი, რა არის ეს?
>> სტუდენტი: Source კოდი.
>> JASON HIRSCHHORN: ეს არის წყარო ფაილი,. c ფაილი.
რა ეს ორი ხაზი გავაკეთოთ?
ან ეს ორი არ ხაზები.
>> სტუდენტი: ეს სახელები ის შესამოწმებლად.
>> JASON HIRSCHHORN: ასე რომ dash o ამბობს, დაარქვით რაღაც განსხვავებულად.
აქ თქვენ უწოდა ტესტი.
იმ შემთხვევაში, თუ არ მქონდა, რომ, რას უნდა დაასახელოს ამ?
>> სტუდენტი: a.out.
>> JASON HIRSCHHORN: a.out.
რას აკეთებთ?
>> სტუდენტი: ბმულების მათემატიკის ბიბლიოთეკაში.
>> JASON HIRSCHHORN: ეს ბმულები in მათემატიკის ბიბლიოთეკაში.
ჩვენ არ მოიცავს მათემატიკის ბიბლიოთეკაში, მაგრამ მას შემდეგ, რაც, რომ ასე გავრცელებული, ისინი
დაწერილი, რათა ყოველთვის მოიცავს მათემატიკის ბიბლიოთეკაში.
ანალოგიურად, ეს მოიცავს CS50 ბიბლიოთეკაში.
>> OK, ასე რომ, თუ ჩვენ სიაში, ჩვენ ახლა აქვს შესრულებადი მოუწოდა ტესტი.
შეასრულოს ის, ვწერ ტესტი.
მე ვხედავ, რომ ჩემი მცურავი წერტილი, როგორც მოსალოდნელი იყო, უდრის 0.
აკეთებს, რომ -
ასე -
>> სტუდენტი: თუ თქვენ დააყენა ათწილადი ახლა, როგორც თქვენ მიიღო ის როგორც float -
>> JASON HIRSCHHORN: როლებში 1 float?
>> სტუდენტი: არა, მიცემული სრული რამ -
yeah.
თუ თქვენ უბრალოდ გააკეთა, რომ ამას რომ ეს 0.1?
>> JASON HIRSCHHORN: OK, ასე რომ ნამდვილად სწრაფად, 1 იყოფა 10, იმ
რიცხვებით იყოფა.
ასე რომ, როდესაც თქვენ დაყოფის რიცხვებით, ისინი 0, და თქვენ გადარჩენის, რომ 0
ათწილადი, რადგან slash არის უბრალოდ მთელი განყოფილება.
ასე რომ, ახლა ჩვენ გთხოვოთ რაღაც შევიდა float.
>> ვნახოთ, რა მოხდება.
ჩვენ დავდებთ ტესტი.
ახლა ჩვენ ვხედავთ, რომ ხაზი არ იყო მთელი განყოფილება, იგი მცურავი
წერტილი გაყოფა.
იმის გამო, რომ მისი არგუმენტები უკვე მიცემული to float.
ახლა ის ამბობდა, მკურნალობა ამ განყოფილება როგორც ჩვენ საქმე გვაქვს
მცურავი ქულა, არა რიცხვებით.
ასე რომ, ჩვენ მიიღოს პასუხი ჩვენ მოველით.
>> ვნახოთ, რა ხდება -
oops.
თუ მინდოდა ბეჭდვა უფრო ათობითი ლაქები, როგორ შეიძლება მე ამის გაკეთება?
>> სტუდენტი: Point dot f, ან როგორც ბევრი ათობითი ადგილებში როგორც თქვენ გსურთ.
>> JASON HIRSCHHORN: So I ბეჭდვა 10 ათობითი წერტილებით.
და ჩვენ ახლა ვხედავთ ჩვენ ვიღებთ რაღაც უცნაური პერსონალი.
და რომ მიდის უკან თქვენი კითხვა შესახებ მცურავი პუნქტიანი ორაზროვნება.
არსებობს უცნაური პერსონალის ინახება აქ.
>> OK, ამჯამად რომ უპასუხოს შეკითხვას?
რა არ გსურთ კოდექსში სწრაფად?
>> სტუდენტი: მე უბრალოდ სურდა თუ არა, თუ გაათავისუფლა ზოგიერთი მაჩვენებელი,
თუ არა, რომ მაჩვენებელი ჯერ კიდევ ინახება ის მისამართი, თუ რა იყო
მიუთითებს ადრე.
>> JASON HIRSCHHORN: OK, მოდით გავაკეთოთ ეს.
Char star Ptr, ეს ქმნის ცვლადი ე.წ. Ptr ტიპის char ვარსკვლავი.
როგორ შემიძლია დაწერა malloc?
Alden?
>> ALDEN: Just malloc.
მაგრამ მაშინ ეს უნდა იყოს ზომა, და ამ შემთხვევაში, ვფიქრობ, ნეტავ
იქნება მიუთითებს char.
ასე რომ, მინდა იყოს char.
>> JASON HIRSCHHORN: OK, ასე უფრო generically, Inside -
მოდით შეცვალონ.
Inside malloc, გსურთ ნომერი ბაიტების ბევრი.
საერთოდ, რაც ჩვენ ვნახეთ, რომ ჩვენ აკეთებს არის ჩვენ ვაპირებთ malloc
სიმები, მაგალითად, ან კოლექტორები რიცხვებით.
ასე რომ, თუ ჩვენ გვინდა, რომ 10 რიცხვებით, ან 10 სიმბოლო, 10 მოგვცემს 10.
და მერე ზომა chars მისცემს ჩვენთვის, რომ ზომა სიმბოლო, რომელიც
ამ შემთხვევაში არის 1 byte.
მივიღებთ 10 bytes.
თუ ჩვენ უნდა დაწეროს ზომა int, რომ მოგვცეს 40 bytes.
>> ასე უფრო generically, შიგნით malloc არის ბაიტების რაოდენობას გსურთ.
ამ შემთხვევაში, ჩვენ ვიღებთ 1 byte.
რომელიც თითქოს უცნაური გამოყენება of malloc, არამედ ჩვენი
მიზნებისათვის აზრი.
ასე რომ იქ რომ.
>> ჩვენ ვაპირებთ მოვუწოდებთ უფასოდ.
ჩვენ მოისპოს იგი და ვიყენებთ Ptr ერთხელ.
და რა გსურთ შემოწმება?
>> სტუდენტი: მე უბრალოდ მინდოდა თუ არა ან არ იყო არაფერი
შიგნით მას.
>> JASON HIRSCHHORN: ასე რომ თუ არა ის აღნიშნა, რომ არაფერი?
>> სტუდენტი: ჰო, ზუსტად, თუ ეს ჯერ კიდევ მეხსიერებაში მისამართზე.
>> JASON HIRSCHHORN: ასე რომ გსურთ შევამოწმოთ ღირებულება Ptr?
>> სტუდენტი: ჰო, ზუსტად.
>> JASON HIRSCHHORN: რას ვწერ აქ თუ მინდა შევამოწმო ღირებულება
წერტილი - რა არის, Jordan განაცხადა, ღირებულება?
ან რა ინახება შიგნით Ptr?
>> სტუდენტი: მეხსიერების მისამართზე.
>> JASON HIRSCHHORN: A მეხსიერების მისამართზე.
ასე რომ, თუ ვწერ მხოლოდ ამ, იგი ყველაფერს მომეცი ღირებულება Ptr.
და როგორ შემიძლია ამობეჭდოთ მეხსიერების მისამართი?
რა არის სტრიქონში განთავსების მეხსიერების მისამართი?
>> სტუდენტი:% p.
>> JASON HIRSCHHORN% p.
% S სიმებიანი.
% P განთავსების მაჩვენებელი.
არის ის, რომ არა?
ეს არის სწორი.
ასე Ptr შეადგენს -
მას ჯერ კიდევ აქვს რაღაც იგი.
ეს არის, ალბათ უფრო საინტერესო კითხვა.
რას ონლაინ გავაკეთოთ?
>> სტუდენტი: seg ხარვეზებით.
>> JASON HIRSCHHORN: What?
>> სტუდენტი: მე ვფიქრობ, რომ seg ხარვეზებით.
>> JASON HIRSCHHORN: Hm?
>> სტუდენტი: მე ვფიქრობ, რომ seg ბრალია.
>> JASON HIRSCHHORN: ასე რომ, ეს ხაზი კოდი, ვარსკვლავი Ptr, რა
ჯერ ვარსკვლავი ნიშნავს?
>> სტუდენტი: შინაარსი.
>> JASON HIRSCHHORN: ჰო.
წავიდეთ მისაღებად შინაარსი.
ასე რომ, ეს აპირებს ხსოვნას მიმართოს და მომეცი, რომ.
მე% c უფლება აქ იმიტომ, რომ იქ არიან გმირები იქ ინახება.
ამიტომ, ჩვენ ვაპირებთ წასვლა რომ მისამართი ჩვენ უბრალოდ ვნახე - ან ეს ალბათ
ცოტა განსხვავებული ამ დროს ჩვენ გაუშვით პროგრამა.
მაგრამ ჩვენ წასვლა რომ მისამართი რომელიც ჩვენ ვიცით, ჯერ კიდევ არსებობს
და ვნახოთ რა იქ.
>> ასე რომ არ seg ბრალია.
ეს უბრალოდ არ მოგვცეს არაფერი.
ეს შეიძლება მართლაც მოგვცა რაღაც, ჩვენ უბრალოდ ვერ ვხედავ მას.
და რომ მიდის უკან ეს იდეა -
და ჩვენ არ ვაპირებთ, რომ ძალიან ბევრი შევიდა ეს, იმიტომ, რომ გარეთ
წინამდებარე კურსი.
მაგრამ ჩვენ ვისაუბრეთ აქ, თუ ჩვენ გასცდა ფარგლებში მასივი მიერ
1, ჩვენ შეიძლება არ მიიღოთ უბედურება.
>> ზოგჯერ, როდესაც თქვენ უბრალოდ მიდის 1, თქვენ აკეთებთ რაღაც, და თქვენ
ვერ უბედურება.
მაგრამ თქვენ არ ყოველთვის უბედურება.
ეს დამოკიდებულია იმაზე, თუ რამდენად ცუდი, რაც თქვენ ნუ, თქვენ აპირებთ მიიღოთ უბედურება.
რომელიც არ არის იმის თქმა, იქნება sloppy თქვენი კოდი.
მაგრამ ეს არ არის იმის თქმა, რომ პროგრამა არ ყოველთვის დატოვა, მაშინაც კი, თუ სადმე
თქვენ არ უნდა წავიდეს.
>> კარგი მაგალითია, რომ არის, ბევრი ხალხს პრობლემა კომპლექტი 3, რომელიც
იყო 15, არ შეამოწმოთ ფარგლებში ფორუმში.
ასე, რომ თქვენ ჩანდა მარცხენა, ჩანდა, რომ მარჯვენა, ჩანდა, რომ ყველაზე, ჩანდა
ბოლოში.
მაგრამ თქვენ არ შეამოწმეთ თუ ზევით რეალურად იქნება ფორუმში.
და ბევრი ადამიანი, ვინც ეს გააკეთა, რომ და აღმოჩნდა, რომ, მათი პროგრამა მუშაობდა
კარგად, იმიტომ, რომ სადაც ეს board იყო ინახება მეხსიერებაში, თუ წავიდა ერთი
ზემოთ ან შემოწმდება, რომ მეხსიერების მისამართი, იქ არ იყო არაფერი
განსაკუთრებით საშინელი, რომ, ასე რომ თქვენი პროგრამა არ იყო
აპირებს დაწეროთ თქვენ.
>> მაგრამ ჩვენ მაინც მიიღოს off ქულა, თუ თქვენ არ შეამოწმოს, რომ, რადგან თქვენ
აკეთებს რაღაც არ იყო უნდა გავაკეთოთ, და თქვენ შეიძლება
მიღებული უბედურება.
შანსები, თუმცა, ალბათ, არა.
ასე რომ, ეს აჩვენებს, რომ, დიახ, ჩვენ მაინც წასვლა მას.
და ჩვენ არ მიღების პრობლემები ამ შემთხვევაში.
თუ ჩვენ შევეცადეთ წაიკითხა მომდევნო 100 სიმბოლო, ჩვენ მინდა
ალბათ კიდევ უბედურება.
და თქვენ შეგიძლიათ კოდექსის კითხულობს მომდევნო 100 პერსონაჟი, თუ გსურთ აკეთებს ზოგიერთი
სახის for loop.
ჰო.
>> სტუდენტი: მას შემდეგ, რაც ჩვენ დაავალა, რომ ფართი ფაქტობრივი ღირებულება, ჩვენ არ
რეალურად ნახოს არაფერი.
უნდა ვეცადოთ ეს მიიღწევა, რომ ტოლი მინდა c ან რაღაც?
>> JASON HIRSCHHORN: Great კითხვა.
როგორ შემიძლია მითითებული, რომ ღირებულება -
რა ხაზი კოდი არ ვწერ on line შვიდი უნდა გავაკეთოთ ის, რაც თქვენ განაცხადა?
>> სტუდენტი: Star Ptr შეადგენს ერთ გაცემა c დასრულდება ერთი გაცემა.
>> JASON HIRSCHHORN: ასე რომ აყენებს ხასიათი, c, იმ ადგილას,
იმიტომ, რომ კიდევ ერთხელ, რომ ვარსკვლავი ნიშნავს წასვლა იქ.
და როდესაც გამოიყენება მარცხენა მხარეს, დავალება ოპერატორი, რომელიც უდრის
დარეგისტრირდით, ჩვენ არ ვაპირებთ, რომ მიიღოთ, რომ ღირებულება იმდენად, როგორც მითითებული, რომ ღირებულება.
ახლა ვნახოთ, რა მოხდება.
>> ჩვენ დააყენა რაღაც არსებობს და ეს იყო.
გამოვიძახეთ free.
რაღაცები ალბათ მოხდა ბევრი.
ასე რომ, ეს არ უქმნით.
თუმცა ისევ და ისევ, ჩვენ ვერ ვიღებთ პრობლემები მიმდინარეობს.
>> მე ამით გარეთ კოდი საილუსტრაციოდ რომ ბევრი ამ
კითხვა, რომელიც თქვენ უნდა, ისინი მართლაც ძალიან საინტერესო
პასუხობს ბევრი დრო.
და ისინი ნამდვილად კარგი კითხვები.
და თქვენ შეგიძლიათ გაერკვნენ მათ გარეთ საკუთარი, თუ, მაგალითად,
ჩვენ არ მონაკვეთზე.
ჰო.
>> სტუდენტი: იმის გამო, რომ თქვენ არ გაგზავნის კურსორი სადმე, გჭირდებათ
გამოიყენოთ malloc?
>> JASON HIRSCHHORN: ასე რომ, ეს მიდის უკან თქვენს საწყის კითხვაზე.
[? ?]
უბრალოდ ადგილობრივი ცვლადი?
Malloc აქ არ არის, რომ მყარი.
გამოყენების malloc აქ არ არის რომ დამაჯერებელი, რადგან ეს
მხოლოდ ადგილობრივი ცვლადი.
>> სტუდენტური ასე რომ შეგიძლიათ გააკეთოთ char star Ptr შეადგენს მიესალმები?
>> JASON HIRSCHHORN: Oh.
ამიტომ, ჩვენ ვაპირებთ, რომ ახლა დავუბრუნდეთ თქვენს საწყის კითხვაზე.
მე ვფიქრობ, თქვენ არ დაკმაყოფილდა ჩემი პასუხი.
OK?
ასე?
>> სტუდენტი: Yeah.
დაველოდოთ.
>> JASON HIRSCHHORN: სად გსურთ ამობეჭდოთ?
ამიტომ ჩვენ ამობეჭდოთ string ასე?
>> სტუდენტური საინტერესო.
>> JASON HIRSCHHORN: ასე რომ, ეს ამბობს, რომ ეს არგუმენტი აქვს ტიპის ხასიათი.
ასე რომ, ეს უნდა იყოს ხასიათი.
>> სტუდენტი: Just იღებს პირველი.
>> JASON HIRSCHHORN: ასე რომ, ეს არის ის, რაც ვთქვი.
როგორც ვთქვი, ეს არ არის შენახვის string შიგნით ცვლადის მაჩვენებელი.
ის შენახვა -
>> სტუდენტი: პირველი ღირებულება სიმებიანი.
>> JASON HIRSCHHORN: მისამართი პირველი ღირებულება სიმებიანი.
თუ ჩვენ უნდა ამობეჭდოთ ეს, ჩვენ მიღების ღირებულება შიგნით მაჩვენებელი.
და ვნახავთ, რომ ეს არის, მართლაც, მეხსიერების მისამართზე.
>> ამჯამად რომ აზრი?
უკაცრავად.
დაველოდოთ, ამჯამად რომ უპასუხოს თქვენს კითხვაზე, თუმცა?
>> სტუდენტი: Yeah.
>> JASON HIRSCHHORN: ეს ხაზი კოდი არის შექმნა სიმებიანი და შემდეგ სხვა
ცვლადი მაჩვენებელი, რომელიც მიუთითებს რომ სიმებიანი, რომ მასივი.
ჰო.
>> სტუდენტი: ასე რომ, თუ ჩვენ წავიდა ერთი მეხსიერება მიმართოს უფრო, რომ მივიღებთ h?
ამ დრომდე ვერ მოხერხდა ინახება როგორც სიმებიანი?
>> JASON HIRSCHHORN: Like, ჩვენ -
ასე რომ ეს არის ღირებული გააკეთოს.
ეს არის წერტილი არითმეტიკა, რომელიც თქვენ ბიჭები მინახავს ადრე და უნდა იყოს
შედარებით კომფორტულად.
ეს არის akin რომ წერა -
თუ ჩვენ წერენ ეს ხაზი კოდი, ჩვენ ვნახეთ მასივი notation ადრე.
ეს უნდა მოგვცეს მეორე ღირებულება ამ მასივი, თ.
>> იმ შემთხვევაში, თუ ეს გავაკეთეთ, ეს უნდა მისცეს us მეორე მნიშვნელობა, რომ მასივი.
იმის გამო, რომ იგი აპირებს არ ხსოვნას მისამართი პირველი რამ, მაგრამ
მეხსიერების მისამართი რამ დასრულდა.
და შემდეგ ვარსკვლავი ოპერატორი dereferences რომ მომცეთ.
და ისევ, ვნახოთ.
მივიღებთ h ერთხელ.
>> სტუდენტი: რა აკეთებს dereference ნიშნავს?
>> JASON HIRSCHHORN: dereference არის ლამაზი სიტყვა წასვლა.
წასვლა რომ და კიდევ რა იქ არის dereference მაჩვენებელი.
უბრალოდ ლამაზი სიტყვა, რომ.
>> სტუდენტი: თუ გვინდოდა ბეჭდვა მთელი სიმებიანი, შეგვეძლო
გავაკეთოთ ampersand მაჩვენებელი?
>> JASON HIRSCHHORN: OK, ჩვენ ვართ აპირებს პაუზის აქ.
ჩვენ ვაპირებთ დასრულდება აქ.
Ampersand გაძლევთ მისამართი ადგილმდებარეობა, ასე რომ, როდესაც თქვენ ampersand of
ცვლადი, ეს გაძლევთ მისამართი სადაც, რომ ცვლადი ინახება.
Ampersand მაჩვენებელი მოგცემთ მისამართი Ptr სადაც Ptr არის მეხსიერებაში.
>> ჩვენ არ ვაპირებთ წასვლა ამ მაგალითად.
შეგიძლიათ გაერკვნენ ამ რამ საკუთარ.
თუმცა ისევ და ისევ, ეს შეიძლება იყოს verging ცოტა მიღმა, რაც თქვენ უნდა იცოდეს
ფარგლებში ამ შუალედური -
ან ამ ინტელექტუალური, საკმაოდ.
უკაცრავად.
>> ჩვენ ვაპირებთ, რომ გადაადგილება, რადგან მე მინდა ერთი კოდირების პრობლემა
სანამ დრო არის up.
და ჩვენ ვაპირებთ კოდი რა ვფიქრობ არის ყველაზე დამაჯერებელი ამ
მაგალითები, atoi.
ასე რომ ეს იყო კითხვა ვიქტორინა ორი წლის წინ.
და მე ეს ფორუმში აქ.
>> ხალხი სთხოვა ვიქტორინა -
მათ მიეცათ ცოტა მეტი tesxt in კითხვაზე, მაგრამ მე აღმოფხვრილი
ტექსტის რადგან ეს იყო ზედმეტი ჩვენი მიზნებისთვის ახლა.
ეს იყო მხოლოდ ზოგიერთი ფონზე რა atoi გააკეთა.
მაგრამ თქვენ იცით, და ძალიან იცნობს atoi.
>> მე გთავაზობთ კოდექსს on ფურცელზე.
მე ასევე გთავაზობთ გამოიყენოთ სტრატეგია რომ ჩვენ წავიდა მეტი
ბევრი ჩვენს განყოფილებაში.
პირველ რიგში, დარწმუნდით გესმით რა atoi აკეთებს.
ფრე სურათის ან ამუშავება ზოგიერთი ფსიქიკური იმიჯი იგი თქვენს ხელმძღვანელი.
შემდეგი, წერენ გარეთ pseudocode ამ.
On ვიქტორინა, თუ ყველა თქვენ არის pseudocode, მინიმუმ თქვენ
დააყენა რაღაც down.
და შემდეგ განვსაზღვრავთ, რომ pseudocode გადატანა C. თუ თქვენ გაქვთ გამშვები თქვენი
pseudocode, როგორიცაა შეამოწმეთ თუ რამე არის 1, რომელიც რუკები გადატანა, თუ
მდგომარეობა და სხვ.
და ბოლოს, კოდექსის პროგრამა C.
>> ასე რომ დავუბრუნდეთ atoi და მიიღოს ხუთი წუთის კოდექსში ამ ფურცელზე
ქაღალდი, რომელიც ალბათ შესახებ დროის თქვენ უნდა მიიღოს
ვიქტორინა კოდი atoi.
ხუთიდან 15 წუთის შემდეგ, ხუთიდან 12, ხუთ 10 წუთის განმავლობაში, დაახლოებით ოდენობით
დრო ნეტავ დაიხარჯოს ეს კითხვა ვიქტორინა.
ასე რომ ხუთ წუთში ახლა, გთხოვთ.
და თუ თქვენ გაქვთ რაიმე შეკითხვები, ამაღლება თქვენი მხრივ, და მე მოდის გარშემო.
>> [SIDE საუბრები]
>> JASON HIRSCHHORN: OK, ასე რომ, რომ იყო ხუთი წუთის განმავლობაში.
ეს იყო ალბათ ოდენობის შესახებ დრო ნეტავ გაატაროთ, რომ ვიქტორინა,
იქნებ დაბალი ბოლოს იმ დროს.
ჩვენ recap ცოტა.
დავიწყოთ კოდირების ეს.
და თუ ჩვენ არ მიიღოთ ყველა გზა, პასუხები ამ და ამ
ინტელექტუალური კითხვა არსებობს, კიდევ ერთხელ, 2011 წლის შემოდგომაზე, როდესაც ამ კითხვაზე
გამოჩნდა ვიქტორინა.
>> და ეს იყო ღირს რვა ქულა on ვიქტორინა შემდეგ.
რვა რაოდენობა არის მაღალი ბოლოს თანხის რაოდენობა, რაღაც ღირს.
საუკეთესო კითხვები სპექტრი ერთი ექვსი ქულით.
ასე რომ, ეს უფრო რთული კითხვაზე, დარწმუნებული ვარ.
შეიძლება ვინმეს ჩემთვის დაიწყო?
>> საერთოდ, რას აპირებს გსურთ ამ
ფუნქციონირებს atoi, ლოგიკურად?
რა გვინდა გავაკეთოთ?
ამიტომ, ჩვენ ვაპირებთ დავწეროთ ზოგიერთი pseudocode.
>> სტუდენტი: Convert გმირები თარგმნეს რიცხვებით.
>> JASON HIRSCHHORN: Convert გმირები თარგმნეს რიცხვებით.
OK.
ასე რომ, რამდენი გმირები ვართ ჩვენ აპირებთ უნდა გაიაროს?
>> სტუდენტური ყველა მათგანი.
>> სტუდენტი: ყველა პერსონაჟი სიმებიანი.
>> JASON HIRSCHHORN: ყველა სიმბოლოების string.
ასე რომ, თუ გვინდოდა გავლა ყველა პერსონაჟი სიმებიანი, რა არის რამ
in C ჩვენ ვნახეთ, რომ საშუალება მისცა us გაიაროს ყველა
პერსონაჟი სიმებიანი?
>> სტუდენტური: A for loop.
>> JASON HIRSCHHORN: A for loop.
ამიტომ, ჩვენ ვაპირებთ, რომ loop მეშვეობით ყველა პერსონაჟი s.
>> მერე რა ჩვენ ვაპირებთ გსურთ როდესაც მივიღებთ კონკრეტული ხასიათი?
ამბობენ, რომ ჩვენ ვიღებთ მიიღო 90.
მივიღებთ 9.
ეს ხასიათი.
რა გვინდა გავაკეთოთ ერთად რომ ხასიათი 9?
>> სტუდენტი: გამოკლება მას ხასიათი 0?
>> სტუდენტური სანიშნეს 0?
>> JASON HIRSCHHORN: გამოკლება ეს ხასიათი 0?
>> სტუდენტი: Yeah.
>> JASON HIRSCHHORN: რატომ გსურთ ამის გაკეთება?
>> სტუდენტი: [INAUDIBLE]
ღირებულება.
მისი int ღირებულება.
>> JASON HIRSCHHORN: OK, ასე რომ ავიღებთ ხასიათი 9, გამოვაკლოთ ეს
ხასიათი: 0 მისაღებად რეალური რიცხვი 9.
ტკბილი.
და იცით, რომ ხასიათი 9 მინუს 0 გმირი არის 9?
რა გრაფიკი არ შეხედავთ?
>> სტუდენტი: არსებობს ლოგიკურად ცხრა ადგილები შორის 9 და 0.
ან თქვენ შეიძლება შევხედოთ ASCII მაგიდასთან.
>> JASON HIRSCHHORN: ASCII მაგიდასთან.
მაგრამ დიახ, თქვენ სწორი ისევე.
ასე რომ, ჩვენ სხვაობა 0.
ახლა ჩვენ გვაქვს მთელი რიცხვი 9.
და რა გვინდა რომ?
თუ ჩვენ 90, ეს პირველი რიცხვი ჩვენ, რა გვინდა?
>> სტუდენტი: მე მინდა დააყენოს დროებითი რიცხვი array, მაშინ მათემატიკის მას
შემდეგ მიიღოს იგი დასრულდა.
>> JASON HIRSCHHORN: OK.
>> სტუდენტი: თქვენ შეგიძლიათ დაიწყოთ დასასრულს array და შემდეგ წინსვლა ასე
რომ ყოველ ჯერზე თქვენ წინსვლა, თქვენ გავამრავლოთ იგი 10.
>> JASON HIRSCHHORN: OK.
რომ ჟღერს საკმაოდ მყარი იდეა.
ჩვენ შეგვიძლია დავიწყოთ ბოლოს ჩვენი მასივი, და ჩვენ შეგვიძლია გამოვიყენოთ strleng.
ჩვენ შეგვიძლია გამოვიყენოთ strleng აქ.
ჩვენ კიდევ სიგრძეზე ჩვენი სიმებიანი.
ჩვენ ვიწყებთ დასასრულს.
და + პირველი, ჩვენ უბრალოდ მიიღოს, რომ მთელი რიცხვი, და შესაძლოა ჩვენ ვქმნით მოსწონს
ახალი რიცხვი ცვლადი up დაბრუნება, სადაც ჩვენ შენახვის ყველაფერი.
ასე რომ, ჩვენ loop მეშვეობით ყველა char in s from უკან წინ, ჩვენ სხვაობა 0, და
მაშინ ჩვენ მას, და დამოკიდებულია სადაც ეს არის, ჩვენ გავამრავლოთ ის
რომელსაც ძალა 10.
იმის გამო, რომ პირველი, რაც ჩვენ გავამრავლოთ rightmost ხასიათი?
>> სტუდენტი: 10 დან 0.
>> JASON HIRSCHHORN: 10 დან 0.
რა გავამრავლებთ მეორე rightmost ხასიათი?
>> სტუდენტი: [INAUDIBLE].
>> JASON HIRSCHHORN: What?
>> სტუდენტი: 10 1.
>> JASON HIRSCHHORN: 10 1.
მესამე rightmost ხასიათი?
>> სტუდენტი: 10 2.
>> JASON HIRSCHHORN: 10 2.
>> სტუდენტი: უკაცრავად, მე არ მესმის რას ვაკეთებთ აქ.
>> JASON HIRSCHHORN: OK, მოდით დავუბრუნდეთ, მაშინ.
ამიტომ, ჩვენ ვაპირებთ, რომ მიიღოთ გავიდა სიმებიანი.
იმის გამო, რომ ჩვენ წერილობით atoi.
ასე რომ, ჩვენ მივიღებთ გავიდა სიმებიანი.
ამბობენ, რომ ჩვენ ვიღებთ გავიდა სიმებიანი 90.
>> პირველი, რაც ჩვენ ვაპირებთ გავაკეთოთ არის ახალი რიცხვი ცვლადი, რომ ჩვენ
უბრალოდ აპირებს შექმნას ჩვენი ახალი რიცხვი.
ეს არის ის, რასაც ჩვენ ვაპირებთ დაბრუნების დასასრულს.
ჩვენ უნდა გაიაროს ყველა პერსონაჟი სიმებიანი, რადგან ჩვენ გადაწყვეტილი
რომ ჩვენ უნდა შეეხოთ თითოეული და შემდეგ დაამატოთ ეს ჩვენი ახალი რიცხვი.
>> მაგრამ ჩვენ არ შეგვიძლია უბრალოდ დაამატე, როგორც ნომერი.
ჩვენ არ შეგვიძლია უბრალოდ მიიღოს 9 რჩეულებში 9 ჩვენი რიცხვი.
ეს დამოკიდებულია იმაზე, თუ რა ადგილი ეს არის სიმებიანი.
ჩვენ ვაპირებთ, რომ უნდა გავამრავლოთ ეს ძალა 10.
იმიტომ, რომ ის, თუ როგორ ბაზაზე 10 სამუშაოებს.
>> ამიტომ, ჩვენ ვაპირებთ, რომ მიიღოს ფაქტობრივი ხასიათი, ან ფაქტობრივი რიცხვი
ნომერი მიერ გამოკლება ხასიათი 0 ეხლა ხასიათი 9 როგორიცაა გავაკეთეთ
გამოკლება ხასიათი კაპიტალის დან რასაც ხასიათი გვქონდა ერთი
იმ პრობლემებზე.
ასე რომ, ჩვენ რეალურად მიიღოთ ნომერი 0 დან 9 შენახული როგორც რეალური ნომერი, და ჩვენ
გავამრავლებ მას ძალა 10 დამოკიდებულია სადაც ჩვენ ვართ სიმებიანი.
და მაშინ ჩვენ ვაპირებთ, რომ დაამატოთ ეს უკან ჩვენს new რიცხვი ცვლადი.
>> რა ეს გამოიყურება ასე იქნება იყოს - ჩვენ მიაპყროს აქ.
იმ შემთხვევაში, თუ ჩვენ მივიღებთ გავიდა სიმებიანი 90 -
>> სტუდენტი: [INAUDIBLE].
>> JASON HIRSCHHORN მაგრამ atoi იღებს სიმებიანი.
ამიტომ, ჩვენ ვაპირებთ გავლა ჰოლდინგი.
ჩვენ კიდევ გავიდა 90.
ჩვენ წავიდეთ უკან ფრონტზე.
ავიღებთ 0.
>> სტუდენტი: მე უკაცრავად.
იქნებ ეს არის სულელური.
იმ შემთხვევაში, თუ ჩვენ ვიღებთ გავიდა სიმებიანი, რატომ არის 90 რა ვართ
მიღების გავიდა?
იმის გამო, რომ 90 არის მთელი რიცხვი.
>> JASON HIRSCHHORN: იმის გამო, atoi იღებს სიმებიანი და აქცევს მას მთელი რიცხვი
წარმომადგენლობის რომ სიმებიანი.
მაგრამ string 90 არ არის მთელი რიცხვი 90 ან რაოდენობის 90.
სიმებიანი 90 არის მასივი ორი, ან სამი გმირები, უფრო სწორად, 9
ხასიათი, 0 ხასიათი, და backslash 0 ხასიათი.
>> და ჩვენ წერილობით atoi რადგან, მაგალითად, როდესაც თქვენ მიიღოს ბრძანება
ხაზი არგუმენტი, და ეს შენახული argv, ის შენახული როგორც სიმებიანი.
მაგრამ თუ გვინდა, რომ მკურნალობა, როგორც ნომერი, ან, თქვენ უნდა გარდაქმნას იგი
ფაქტობრივი რიცხვი.
რომელიც ჩვენ გავაკეთეთ ჩვენი პრობლემა კომპლექტი.
რომელიც ჩვენ გავაკეთეთ მთელი რიგი ჩვენი პრობლემა კომპლექტი.
ყველას, რომელსაც მთელი როგორც ბრძანების არგუმენტი.
ასე რომ, ამიტომ ჩვენი atoi ფუნქცია იღებს სიმებიანი.
>> ასე რომ კიდევ ერთხელ, ჩვენი მაგალითად აქ, ჩვენ აპირებს ბოლო.
ჩვენ ვაპირებთ გამოვაკლოთ ხასიათი 0 მისგან, რადგან პერსონაჟი 0
ჩამოჭრილია მთლიანი თანხიდან by ხასიათი 0 გაძლევთ ფაქტობრივი რაოდენობის 0, შესაბამისად,
ASCII მათემატიკის რასაც ჩვენ ვაკეთებთ.
>> იმის გამო, რომ გმირები წარმოდგენილია როგორც განსხვავებული, ვიდრე მათი -
ხასიათი, მაგალითად, ამას 97.
ეს არ არის - oops!
ეს არ არის, რასაც თქვენ მოელოდა ეს უნდა იყოს, 0, მაგალითად.
ასე რომ თქვენ უნდა სხვაობა ხასიათი მიიღოს 0.
>> ამიტომ, ჩვენ ვაპირებთ, რომ გავაკეთოთ, რომ აქ მიიღოს ფაქტობრივი ნომერი.
და მაშინ ჩვენ ვაპირებთ გავამრავლოთ ის მიერ ძალა 10 დამოკიდებულია, სადაც ეს
არის ტექსტი, და შემდეგ მიიღოს, რომ და დაამატოთ ეს ჩვენი ადგილის მფლობელი
ცვლადი ასე რომ, ჩვენ შეიძლება ამუშავება ჩვენი საბოლოო new რიცხვი.
ამჯამად რომ აზრი, რომ ყველასთვის?
>> ასე რომ, ჩვენ არ ვაპირებთ კოდექსს ახლა, რადგან ჩვენ
მიღების მოკლე დროში.
მე ბოდიშს დრო, რომ.
მაგრამ ეს არის ის, რაც, იმედია, თქვენ ამას გამოუვა on ვიქტორინა - ზე
სულ ცოტა, ამ pseudocode წერილობითი out.
>> და შემდეგ, თუ ჩვენ უნდა დაწეროთ pseudocode, ფაქტობრივად, ჩვენ შეგვიძლია ამის გაკეთება
საკმაოდ სწრაფად.
თითოეული ხაზი კომენტარი ჩვენ დავწერეთ აქ ითარგმნება შესახებ
ერთი ხაზი C კოდი.
გამოცხადების ახალი ცვლადი, წერილობით loop, ზოგიერთი გამოკლება, ზოგიერთი
გამრავლება, და ზოგიერთი დავალება.
ჩვენ გვინდა ალბათ ასევე მინდა დაწერა დაბრუნების ონლაინ.
ჩვენ შეიძლება ასევე სურს დააყენოს ზოგიერთი ამოწმებს აქ.
ჰო.
>> სტუდენტი: ასე შეგვიძლია მკურნალობა s როგორც ფაქტობრივი სიმებიანი?
იმიტომ, რომ მე ვიცი, რომ ეს უბრალოდ მისამართზე.
მსგავსად, როგორ თქვენ მიიღებთ ხანგრძლივობა სიმებიანი მიმდინარეობს გაიარა?
>> JASON HIRSCHHORN: ასე როგორ გააკეთა სიგრძეზე სიმებიანი?
Strlen.
>> სტუდენტი: strlen, yeah.
მაგრამ შეგიძლიათ განათავსოთ s როგორც არგუმენტი, რომ?
>> JASON HIRSCHHORN: ასე strlen იღებს char ვარსკვლავი.
და იგი შემდეგნაირად, რომ char ვარსკვლავი, და ეს ინახავს დათვლის სანამ იგი იღებს, რათა
backslash 0. strlen იყო, ფაქტობრივად, ერთი სხვა პროგრამების ჩვენ
მიდიოდნენ კოდი.
ეს არის კიდევ ერთი კარგი ერთი კოდი.
რომ ერთი ცოტა უფრო ადვილია, რადგან თუ თქვენ აპირებს ვიფიქროთ, რომ
კონცეპტუალურად -
მე უბრალოდ განაცხადა, რომ ხმამაღლა - strlen შემდეგნაირად მაჩვენებელი და გრძელდება და
დათვლა და შენახვა ტრეკზე სანამ მიაღწევს backslash 0.
>> სტუდენტი: დიახ, მივიღე ეს.
>> JASON HIRSCHHORN: ასე რომ, საუკეთესო გისურვებთ ვიქტორინა 0 ხვალ.
თუ თქვენ გაქვთ რაიმე შეკითხვები, მე გარეთ შემდეგ.
მოგერიდებათ მომაწოდეთ.
მივაწვდინოთ თქვენი საკუთარი TF თუ თქვენ არ არის ჩემი განყოფილებიანი, ან კიდევ ჩემი
მქონ თუ გნებავთ.
>> თუ გსურთ freak out და უბრალოდ გამოგვიგზავნეთ me ელ freakout ელ, მე
გამოგიგზავნით უკან, ისევე, smiley face, ან, ისევე, ხუმრობა ან რამე.
ასე რომ შეგიძლიათ გააკეთოთ, რომ ისევე.
წარმატებებს გისურვებთ ისევ და ისევ, და მე რომ თქვენ ყველა მომავალ კვირას.