[Powered by Google Translate] [კვირა 4 გაგრძელდა]
[დევიდ ჯ Malan - ჰარვარდის უნივერსიტეტი]
[ეს არის CS50. - CS50.TV]
>> ეს არის CS50, და ეს არის ბოლომდე კვირაში 4.
ასე რომ ზოგიერთი კარგი ამბავია და ზოგიერთი ცუდი ამბავი.
არარის ლექცია ორშაბათს, პრობლემა არ მითითებული მომავალ კვირას. [სტუდენტი cheering]
თქვენ არ აპირებენ მინდა სადაც ეს ხდება.
მაგრამ ჩვენ გვყავს ამ ნაცვლად შემდეგი ოთხშაბათი,
და არსებობს ასევე თითო სილაბუსი 1 პარასკევი ლექცია შემდეგი პარასკევი, ისე, რომ ჩვენ შეგვიძლია დარჩენა გზაზე.
მაგრამ ყველაფერი იქნება გადაღებული, როგორც ყოველთვის, ასე რომ არ ინერვიულოთ.
>> და მიმართებაში Quiz 0 რასაც ჩვენ გავაკეთებთ მიმართ კვირის ბოლომდე
არის საგუშაგო კურსი ვებგვერდი cs50.net განმარტება
თუ რა სახის მოლოდინი უნდა ჰქონდეს, როდესაც საქმე პირველი ვიქტორინა.
ზოგადად, ეს იქნება მრავალჯერადი არჩევანი, True-ცრუ, მოკლე პასუხი, მოკლე კოდირების პრობლემები.
თქვენ არ აპირებენ უნდა განახორციელოს ექვივალენტი
საქართველოს პრობლემა, რომ თქვენ ნახე pset, რისთვისაც თქვენ გაქვთ კომპიუტერი
და debugger და მოსწონს, მაგრამ იქნება პატარა კოდირების პრობლემები.
>> მართლაც, საუკეთესო სახელმძღვანელო მისაღებად გრძნობა რა CS50 ტესტები მოსწონს
არის წასვლა cs50.net, წასვლა ტესტები ლინკები,
და ხედავთ ბოლო რამდენიმე წლის განმავლობაში ღირებულების ვიქტორინებში.
უბრალოდ გააცნობიეროს, რომ სასწავლო გეგმა არ ყოველთვის იგივე წლების განმავლობაში.
ზოგჯერ ჩვენ დაამატოთ, ზოგჯერ სხვაობა,
ასე რომ, თუ ხედავთ ზოგიერთ თემას ერთ იმ ძველ ტესტებში
რომ თქვენ არ ვიცი რა ეს ლაპარაკი, ეს არც იყო ის, რომ დაფაროს იგი
ან რომ ჩვენ არ დაფარავს მას.
მაგრამ სახით მიმოხილვები, ამ კვირას, ორშაბათს, სამშაბათს და
ასევე, რა თქმა უნდა, ფართო განხილვის სხდომაზე კვირა ღამე -
დრო და ადგილი, რათა გამოცხადდება კურსი ვებგვერდი -
თქვენ ყველას გვაქვს საშუალება განიხილოს ერთად საგნის სწავლების პრაქტიკის
მასალა წელს, ორივე ნაწილში და როგორც სრული კლასის,
და იმ იქნება გადაღებული, როგორც ყოველთვის ისევე.
>> ყველა უფლება. ასე გარეშე ado, ერთი კომენტარი უღელტეხილზე / მარცხდება და დაამატოთ / Drop.
თქვენ შეიძლება არ უნახავს ჩემი აღნიშნავს წუხელ, და ამ მართლაც რამოდენიმე დამატებითი reassurance
რომ თუ თქვენ შორის არიან, განსაკუთრებით ნაკლებად კომფორტული ან სადღაც შორის
და თქვენ შეგრძნება მხოლოდ ცოტა ზე მეტ თქვენი უფროსი,
გააცნობიეროს, რომ მართლაც საკმაოდ ნორმალური, და იქ საკმარისი მხარდაჭერა სტრუქტურა ადგილი,
რომელთაგან ერთი სამუშაო საათებში იყო განზრახვების გაუმჯობესების ყველა მეტი პოსტი ჩემი ელ წუხელ,
და გააცნობიეროს, რომ ძალიან მოსწონს ვარიანტი უღელტეხილზე / ვერ ამისთვის კლასის მოსწონს
ნამდვილად იგულისხმება როგორც მექანიზმი მიიღოს პირას გამორთვა კურსი მოსწონს,
ისე, რომ ერთხელ თუ თქვენ ხარჯავს იმ 10, 15, 20 საათი
უბრალოდ ცდილობს ზოგიერთი pset მუშაობა და თქვენ იცით, თქვენ 90-95% of გზა არსებობს
მაგრამ ვერ პოულობთ ზოგიერთი Damn bug, in pass / fail მოდელი რომ სახის okay.
>> იდეა არის, რომ ამ მექანიზმის შეგიძლიათ მერე ფოკუსირება თქვენი სხვა psets
ან ძილის ან რასაც ის არის, რომ გსურთ ფოკუსირება.
ასე რომ მიხვდებიან, რომ თქვენ გაქვთ სანამ ამ მოდის სამშაბათი - ტექნიკურად მე -5 კვირა,
მაგრამ დღესასწაული, ასე რომ ამ მოდის სამშაბათი - გადართვა საწყისი უღელტეხილზე / ვერ ფასდება ან პირიქით.
და თუ თქვენ ნამდვილად on precipice და ფიქრობენ ჩაშვების საერთოდ,
გთხოვთ catch me შემდეგ ლექცია ან ვარდნა ჩემთვის შენიშვნა.
მე მინდა მიყვარს მინიმუმ სტატისტიკა სანამ თქვან adieu.
ყველა უფლება. ამიტომ, ჩვენ დავიწყე სასწავლო თვლები off ბოლო დროს.
კერძოდ, ჩვენ ფოკუსირებული სიმებიანი.
სიმებიანი არის ის, რასაც ის დეკლარირებული CS50 ბიბლიოთეკა,
კერძოდ, რომ ფაილი სახელად cs50.h რომელიც დავიწყებთ შევხედოთ ამ კვირაში და მომავალი.
მაგრამ string მართლაც მხოლოდ გამარტივებას რაღაც
რომ ცოტა მეტი arcanely უწოდა char *.
Char ჩვენ იცნობს. ეს მხოლოდ ერთი ხასიათი.
მაგრამ * როგორც ორშაბათს აღნიშნა რა? >> [სტუდენტი] მაჩვენებელი.
კურსორი. და რაც მაჩვენებელი? >> [სტუდენტი] მისამართზე.
>> ეს მოსწონს მისამართი, საიდან მეხსიერებაში.
რა მისამართი ან საიდან ან მეხსიერების?
ერთხელ, ყველას უნდა გვქონდეს ლაპტოპები ერთად GIG ან 2 გბ ოპერატიული მეხსიერება, სავარაუდოდ, ამ დღეებში,
და ეს ნიშნავს, რომ თქვენ გაქვთ მილიარდი ან 2 მილიარდი bytes ღირებულების მეხსიერება.
და ეს ნამდვილად არ აქვს მნიშვნელობა, თუ რას ფიზიკურად ჰგავს,
მაგრამ იღებს რწმენა, რომ თქვენ შეგიძლიათ ხმების ყველა ინდივიდუალური ბაიტი, რომ თქვენი საკუთარი ლეპტოპი აქვს -
ეს არის byte 0, ეს არის byte 1, ეს არის byte 2 მლრდ -
და ეს ზუსტად ის, რაც კომპიუტერში აკეთებს.
როცა გამოყოფს ფართი ერთჯერადი ხასიათი, მაგალითად,
ეს აშკარად აქვს ცხოვრება სადღაც თქვენი კომპიუტერის მეხსიერების,
და შეიძლება უფრო დროს byte ნომერი 12345,
და ეს სადღაც აქ თქვენს კომპიუტერის მეხსიერებაში.
და მისამართი რა, რომ სიმბოლო არის 12345.
>> ახლა კი, კვირაში 0 მეშვეობით არის ჯერჯერობით, ჩვენ ნამდვილად არ ზრუნავდა
სადაც მეხსიერების რამ ინახება, რადგან ჩვენ, როგორც წესი, გამოიყენოთ სიმბოლოების,
ცვლადები, და კოლექტორები რეალურად მიიღოთ ჩვენს მონაცემები.
მაგრამ როგორც ორშაბათს და მით უფრო დღეს, თქვენ ახლა აპირებს
ყველა უფრო ექსპრესიული შესაძლებლობების მქონე წერილობით პროგრამები
ნამდვილად მანიპულირება კომპიუტერის მეხსიერების თუმცა ხედავთ ჯდება,
ორივე კარგი მიზნებისთვის და ცუდი,
bugs მყოფი ძალიან საერთო შედეგი ამ ეტაპზე სწავლის ამ პერსონალის.
მაგრამ რას ნიშნავს იყოს char *?
მოდით წავიდეთ წინ დაბრუნდა - და ჩვენ დაბრუნდება Binky დაპირებისამებრ დღეს.
მოდით წასვლა უბრალო მაგალითი აქ.
ნება მომეცით გადარჩენა ამ ფაილის როგორც compare.c, და ნება მომეცით უბრალოდ ზოგიერთი თარგი კოდი აქ
ასე შეიცავს stdio.h, ნება მიბოძეთ, მისცეს თავს მოიცავს cs50.h. მე მიუახლოვდით up there.
დავიწყებ წერილობით მთავარ int, მთავარი (void) და ახლა მინდა რაღაც ასე:
printf ("მომეცი string:") და მერე გამოიყენებს string s იღებს GetString
მიიღოს სიმებიანი საწყისი მომხმარებელი, მაშინ მე ვაპირებ ვკითხო მომხმარებლის კიდევ ერთი.
("მომეცი სხვა სიმებიანი:") და მე ვაპირებ ვთხოვთ მეშვეობით GetString მისაღებად რომ.
მე ეძახით t რადგან t უძღოდა წინ და წინ არის ლამაზი სახელი სიმებიანი თუ იგი საკმაოდ generic.
ამიტომ GetString, და ახლა მინდა გააკეთოს საღი აზრის გამშვები და მე ვაპირებ ვთქვა
თუ (ებ == t), მაშინ მე უბრალოდ აპირებს ვუთხრა მომხმარებლის printf ("თქვენ აკრეფილი იგივე \ n");
სხვას მე ვაპირებ ამობეჭდოთ რაღაც ("თქვენ აკრეფილი რაღაც განსხვავებული, \ n")
ან რასაც სასჯელი იქნება. ასე რომ რამე მაგდაგვარს.
მაშინ, როგორც ყოველთვის, მე დაბრუნებას 0 რომელიც მხოლოდ გამორჩეულია, რომ არაფერი ცუდი მოხდა,
და მე ვაპირებ წავიდეთ წინ და შეადგინონ და აწარმოებს ამ პროგრამის.
>> მაგრამ ორშაბათს ჩვენ გაიქცა ამ პროგრამის
და ფაქტობრივად უთხრეს, რომ HELLO არ არის HELLO და Goodbye არ არის Goodbye.
ქცევის დავინახეთ იყო ცოტა უფრო მოსწონს ეს.
ნება მომეცით წასვლას ჩემი წყაროს დირექტორია, მიუახლოვდით აქ და მოდით გავხადოთ შევადარებთ.
შედგენილი okay. ნება მომეცით აწარმოებს შედარების. მომეცი string: Hello.
მომეცი სხვა სიმებიანი: Hello.
თქვენ აკრეფილი რაიმე განსხვავებული?
ისე, ნება მომეცით ძიებასა მარტივი მოსწონს 50, 50. თქვენ აკრეფილი რაიმე განსხვავებული?
hi, hi. ასე ნათლად, რაღაც ხდება აქ.
მაგრამ რა იყო ახსნა, თუ რატომ?
როგორც ჩანს, ხაზი 12 სრულიად დისფუნქციური.
რა არის ფუნდამენტური პრობლემა აქ? Yeah. >> [სტუდენტი] ეს შედარება მისამართები.
ჰო, ზუსტად. სინამდვილეში შედარებით მისამართები
რომელშიც HELLO და HELLO ინახება.
ეს არ შედარება წერილებს HELLO ისევ და ისევ,
რადგან რა მოხდა სინამდვილეში, ყველა ამ დროს ჩვენ უკვე გამოყენებით GetString -
ეს დაფა კვლავ ჩვენი კომპიუტერის მეხსიერებაში,
და ვთქვათ მე მოვუწოდებ GetString გამოცხადების შემდეგ ცვლადი s.
რას ჩემი მეხსიერების გამოიყურებოდეს?
მოდით თვითნებურად ამბობენ, რომ ასე გამოიყურება. ეს მოედანი.
და საკმაოდ ბევრი ნებისმიერ დროს მე შედგენილი ნაჭერი მეხსიერების ეკრანზე
თუ 32 ბიტი მე ხატვის მოედნებზე მოსწონს რადგან ნამდვილად ელექტრო მოწყობილობების,
მაჩვენებელი, მისამართი, არის 32 ბიტი. ეს იგივეა, რაც int.
რომელიც შეიძლება განსხვავდებოდეს ეფუძნება კომპიუტერული სისტემა.
იმ თქვენ, რომლებიც ბუნდოვნად იცნობს იმისა, რომ თქვენი Mac ან PC არის 64 ბიტი,
რომ რეალურად ნიშნავს, რომ თქვენი კომპიუტერი იყენებს 64-bit პოინტერები,
64-bit მისამართები, და შორის upsides რომ თქვენი კომპიუტერები
შეიძლება გაცილებით მეტი RAM, ვიდრე yesteryear.
დიდხანს ამბავი მოკლედ, უკან დღეს, როდესაც კომპიუტერები გამოიყენება მხოლოდ 32 ბიტი
წარმოადგინოს მისამართები, ყველაზე დიდი რაოდენობის ბაიტი თქვენ შეიძლება წარმოადგენდეს
ამ შემთხვევაში იყო რა, თუ თქვენ გაქვთ 32 ბიტიანი?
ასე რომ 4 მილიარდი, უფლება, რადგან 2 დან 32 არის 4 მილიარდი.
ეს რიცხვი უკვე განმეორებადი მსვლელობისას.
>> ასე რომ, თუ თქვენ მხოლოდ 32 ბიტი, ყველაზე მეტი შეგიძლიათ ითვლიან რომ დაახლოებით 4 მილიარდი.
მაგრამ ეს იყო ფუნდამენტური შეზღუდვის კომპიუტერები სანამ რამდენიმე წლის წინ
რადგან თუ თქვენ მხოლოდ ითვლიან როგორც მაღალი, როგორც 4 მილიარდი,
არა აქვს მნიშვნელობა თუ ყიდვა 8 გბ ოპერატიული ან თუნდაც 5 გბ ოპერატიული მეხსიერება;
ვერ ითვლიან, რომ მაღალი, ასე რომ აზრი არ აქვს.
თქვენ შეიძლება მხოლოდ წვდომას პირველი 3 ან 4 გბ თქვენი კომპიუტერის მეხსიერებაში.
სწორედ ნაკლები საკითხი ახლა, და თქვენ შეგიძლიათ შეიძინოთ MacBook დადებითი და Dells
, 8 გბ ოპერატიული მეხსიერება ან კიდევ უფრო ამ დღეებში.
მაგრამ თუ მე გამოყოფს საკმაოდ უბრალოდ ამ პროგრამის მაჩვენებელი, კურსორი მოუწოდა s,
ეს შესაძლოა ასე გამოიყურება ეკრანზე, რადგან მართლაც გვჭირდება კანი უკან ამ ფენას.
მე შენარჩუნება ამბობდა სიმებიანი, მაგრამ როგორც ორშაბათს, string მართლაც char *,
მისამართი ზოგიერთი ხასიათი.
ასე რომ ავიღოთ, რომ სასწავლო საჭე off მიუხედავად იმისა, გავაგრძელებთ გამოყენებით GetString ახლა.
ამიტომ მე განაცხადა s, და ეს არის ბლოკი მეხსიერება, 32 ბიტი.
რა არის აქ მეხსიერებაში იყოს? >> [Inaudible სტუდენტი საპასუხოდ]
რა არის ეს? >> [სტუდენტი] Garbage. >> Garbage. სწორედ.
თუ პროგრამისტი არ დააყენა ღირებულების ცვლადი, ვინც იცის რა არის?
ზოგჯერ თქვენ მიიღებთ გაუმართლა და ეს 0, რომელიც სახის ლამაზი, სუფთა, ნაგულისხმებია,
მაგრამ როგორც დავინახეთ, ორშაბათს, ზოგჯერ ეს არაგონივრულია,
ზოგიერთი მართლაც დიდი დადებითი ან უარყოფითი ხმების რომ მოვიდა აქ?
Yeah. >> [სტუდენტი] ფუნქცია ადრე. >> Yeah.
>> ხშირად ფუნქცია გაბმულ წინაშე წარსდგება, რადგან გახსოვთ,
როგორც რეკავთ ფუნქციების მეხსიერება, მათ დასჭირდეს უფრო და უფრო სივრცეში bottom up,
და როგორც კი ფუნქცია დააბრუნებს, რომ მეხსიერების იღებს reused
მომდევნო ბიჭი რომ იღებს მოუწოდა, ვინც იყენებს თქვენს იგივე ნაჭერი მეხსიერება.
და თუ თქვენ მარცხენა ნაგვის იქ, წინა ღირებულებები,
ჩვენ შესაძლოა შეცდომა s როგორც გარკვეული ღირებულება, როდესაც ნამდვილად არ გვაქვს დააყენა არაფერი არსებობს.
ასე რომ ჩვენი RAM ამ ეტაპზე ასე გამოიყურება.
ახლა მარჯვენა მხარეს ხაზი 7 ჩვენ მოუწოდებდა GetString,
რაც ჩვენ ვაკეთებთ არის კვირების განმავლობაში, მაგრამ რაც GetString მართლაც აკეთებს?
GetString მიერ დაწერილი CS50 პერსონალი პატარა ინტელექტუალური
in, რომ როგორც კი იწყება მომხმარებლის აკრეფით გასაღებები და hits Enter,
GetString მოღვაწეები გარეთ რამდენი keystrokes გააკეთეს მომხმარებლის ჰიტი
რამდენი გმირები მჭირდება გამოყოფს RAM for.
და სად, რომ RAM მოდის, ვინ იცის?
ეს სადღაც თქვენი კომპიუტერის 2 გბ ან whatnot მეხსიერება.
მაგრამ დავუშვათ, რომ კომპიუტერი ნაპოვნია ფართი სიტყვა HELLO უფლება აქ.
სიტყვა მე აკრეფილი იყო H-E-L-L-O.
და თუ ჩვენ გავამახვილო ეს თანმიმდევრობა გმირები, ჩვენ შეიძლება შევაჩერო ეს მოსწონს ეს.
მაგრამ მე უნდა გავაკეთოთ 1 ზედმეტი რამ. რა ეკუთვნის დასასრულს ნებისმიერი string დო?
Null ხასიათი, რომელიც ჩვენ წერენ როგორც \ 0.
ეს ტექნიკურად ნომერი 0, მაგრამ backslash იღებს ყველა ნათელი
რომ ეს არის სიტყვასიტყვით ნომერი 0, მთელი 0;
ეს არ მაგალითად, ციტირებით-unquote 0 რომ თქვენ შეიძლება აკრიფეთ კლავიატურაზე.
ასე რომ, ეს არის Hello.
>> და რა მივიღეთ ამბობენ ორშაბათს, რომ ფუნქცია, როგორიცაა GetString
რეალურად დაბრუნების ყველა ამ კვირის?
ეს არ დაბრუნების სიმებიანი თავისთავად იმიტომ, რომ ნამდვილად არ არ რაც იმას ნიშნავს,
რადგან სტრიქონები არ არსებობს. ისინი სახის ფაბრიკაცია წელს CS50 ბიბლიოთეკაში.
რა არის მართლაც სიმებიანი, უფრო ტექნიკურად? >> [სტუდენტი] ის პირველი ხასიათი.
სწორედ. ეს საკმაოდ უბრალოდ მისამართი პირველ სიმბოლოს, რომ მომხმარებლის აკრეფილი შემოსული
ასე რომ, თუ ჩემი სიტყვა HELLO დამთავრდა ეს up at byte ნომერი 123, ხოლო შემდეგ byte ნომერი 124,
125, 126 და ა.შ. თუ უბრალოდ ხმების ჩემი bytes საწყისი 0 on up,
რა GetString ბრუნდება არის სიტყვასიტყვით ნომერი 123.
მერე რა ხდება დასვა s არის ნომერი 123, არ Letter H, არ სიტყვას Hello,
უბრალოდ მისამართი სადაც შემიძლია მის შესახებ პირველი წერილი Hello.
მაგრამ ეს არ ჩანს, როგორიც არის საკმარისი. ვკითხე თქვენ ტექსტი, არ ხასიათი.
ასე როგორ უნდა ან კომპიუტერი იციან, რომ ELLO სახის მოდის ერთად H?
რა სახის ხელშეკრულება გვაქვს? Yeah.
[სტუდენტი] ეს ინახავს ვეუბნებოდი თავს გამოძებნოს მეტი სიმბოლო. >> ზუსტად.
>> არსებობს ამ ადამიანის კომპიუტერი კონვენცია, რომლის დროსაც, როცა საქმე გვაქვს სიმები,
სხვაგვარად ცნობილია როგორც char ვარსკვლავი, თქვენ უბრალოდ უნდა გაერკვნენ
სადაც ყოველი სტრიქონი ცხოვრების მიერ ნამდვილად უბრალოდ iterating მეტი იგი ამისთვის მარყუჟის,
ხოლო მარყუჟის, რაც, ასე რომ, როდესაც თქვენ იპოვით ბოლოს სიმებიანი
ახლა თქვენ შეგიძლიათ infer ამისა, OH, მთლიანი სიტყვის იყო Hello.
იმ თქვენ წინასწარი პროგრამირების გამოცდილება შეიძლება ვიცი ჯავაში
შეგიძლიათ უბრალოდ ვუწოდებთ. სიგრძე და სხვა ენებზე შეგიძლიათ დარეკოთ სიგრძე ან მსგავსი.
ეს იმიტომ, რომ წელს ბევრი ენების, განსაკუთრებით რამ მოუწოდა ობიექტის ორიენტირებული ენებზე,
სიგრძეზე რაღაც სახის encapsulated შიგნით ნაჭერი მონაცემები თავისთავად,
ჰგავს ჩვენ encapsulated პირადობის მოწმობა და სახელები და სახლები შიგნით სტუდენტი ორშაბათს.
მაგრამ C გაცილებით დაბალია დონეზე. არ არსებობს ობიექტების ან კლასი, თუ მოვისმინე იმ თვალსაზრისით ადრე.
ყველაფერი რაც თქვენ ნამდვილად არის მეხსიერების მისამართები.
ასე რომ, ეს არის ერთგვარი მოძველებული გზა წარმოადგენს საინტერესო მონაცემები სტრუქტურებში.
თქვენ გაქვთ დაწყება ღირებულება, როგორიცაა მისამართი პირველ სიმბოლოს
და შემდეგ რამოდენიმე თვითნებური კონვენციის რომ ყველას თანახმაა დაიცვას.
მაშ როგორ არის სიმებიანი სიგრძე განხორციელდა, საერთოდ გთავაზობთ?
Strlen, strlen, რომელიც ზოგიერთ თქვენგანს არის გამოყენებული რამდენჯერმე. ეს საკმაოდ მარტივია, არა?
ეს მოსწონს 2 ხაზი კოდი.
ეს საკმაოდ ბევრი ამისთვის loop რაიმე სახის, იქნებ ერთად დამატებით ადგილობრივი ცვლადი.
მაგრამ strlen უბრალოდ უნდა მიიღოს მაჩვენებელი და შემდეგ დაიწყოს ეძებს \ 0.
>> და როგორც კი ეს უჭირს, მას შეუძლია დაბრუნდეს საერთო რაოდენობის ნაბიჯები, რომ ის მიღებული, რომ სიმებიანი.
ასე რომ ჩვენ შეგვიძლია infer ამ რა მიდის შემდეგი.
დავუშვათ, მაშინ ვაცხადებ t როგორც მე ვაკეთებ სტრიქონში 10.
ეს არის ზოგიერთი ნაგვის ღირებულება. ვინ იცის პირველ რიგში?
მაგრამ მარჯვენა მხარეს ხაზი 10 მე მოუწოდებდა GetString ერთხელ.
ვინ იცის, სადაც ეს მთავრდება?
მოდით თვითნებურად ამბობენ, რომ ოპერაციული სისტემის ნაპოვნი ოთახი მას გზა მეტი აქ.
მე მოხდეს ერთსა აკრიფოთ H-E-L-L-O ერთხელ,
და ასე შეგვიძლია დავხატოთ იგივე სურათს.
მაგრამ ის ფაქტი, რომ მე redrawn ამ სურათის მიზანმიმართული
რადგან ეს სხვადასხვა HELLO, ვიდრე ეს ერთი.
ასე რომ აქ ეს შეიძლება იყოს საიდან 456, ეს 457 და სხვ.
მერე რა ხდება დააყენოს სადაც კითხვის ნიშნის ერთხელ იყო?
ამ შემთხვევაში 456.
ჩვენ კრეფა ამ ნომრებზე თვითნებურად, რადგან მართლაც შემდეგ დღეს
ჩვენ არ ვაპირებთ ზრუნვა იმდენად იმაზე, თუ რა მისამართი არაფერი არის.
ყველა ჩვენ აღელვებს ის არის, რომ ჩვენ შეგვიძლია გაერკვნენ მისამართი ზოგიერთი ნიმუში მონაცემები, როგორიცაა Hello.
>> ასე ნამდვილად რა საუკეთესო ხალხი კომპიუტერულ მეცნიერებაში, როდესაც საუბარია მეხსიერების მისამართები
და ვსაუბრობთ პოინტერები კონკრეტულად,
ვიდრე გადაიტვირთოთ მჭიდროდაა გარეთ 123 - ვის რაში სადაც ეს პერსონალის ფაქტობრივად,
ჩვენ უბრალოდ ვიცით, რომ ეს არის რაღაც რიცხვითი მისამართი -
ჩვენ გამარტივება მსოფლიოში და უბრალოდ, ვამბობთ, რომ არის მიუთითებს, რომ ხასიათი
და t არის მიუთითებს, რომ ხასიათი.
და ის ფაქტი, რომ arrow საკმაოდ განზრახ
რადგან სიტყვასიტყვით არის s არის მიუთითებს H და t არის მიუთითებს სხვა H
იმიტომ, დღის ბოლოს, არა აქვს მნიშვნელობა, თუ რა მისამართი,
მაგრამ ჯერ ამ საკითხზე, რომ გვაქვს შესაძლებლობა გამოთქვას, რომ მისამართი ზოგიერთი ნაჭერი კოდი.
ჩვენ ნამდვილად არ მანიპულირება ამ მისამართებისათვის მხოლოდ ჯერჯერობით
ამიტომ ჩვენ დავინახავთ, სადაც შეგვიძლია interject და სახის გავაკეთოთ რამ ერთად პოინტერები,
მაგრამ ახლა სტრიქონში 12 სიტყვასიტყვით რა ღირებულებები ჩვენ შედარება
შესაბამისად ეს ამბავი ხაზი 12?
ჩვენ ვამბობთ, არის 123 თანაბარი ტოლია 456? და ეს ნამდვილად არ არის.
და მაშინაც კი, კონცეპტუალურად, ეს მაჩვენებელი ნამდვილად არ არის იგივე როგორც ამ
იმიტომ, რომ თქვენ მოუწოდა GetString ორჯერ, და GetString არ ცდილობს იყოს სუპერ ჭკვიანი,
იგი არ ცდილობს გააცნობიეროს, OH, თქვენ აკრეფილი HELLO 5 წუთის წინ;
ნება მიბოძეთ მოგცემთ იგივე მაჩვენებელი როგორც მივეცი თქვენ წინაშე,
უბრალოდ გამოყოფს ახალი ბლოკი მეხსიერება ყოველ დროს, თქვენ ეძახით.
>> ასე როგორ უნდა დაფიქსირება ამ პრობლემას?
თუ მაღალ დონეზე მინდა შედარების სიმები HELLO და HELLO -
მე არ აინტერესებს პოინტერები - როგორ წავიდეთ შესახებ შეკითხვაზე,
საერთოდ მომხმარებლის აკრიფოთ იგივე? რა არის საჭირო აქ? Yeah.
[სტუდენტი] გამოიყენეთ ფუნქცია. >> შემიძლია ფუნქციის გარეთ ყუთში.
შემიძლია ფუნქცია მოუწოდა strcmp, s-t-R-C-M-P,
უბრალოდ შემოკლებულ ვერსია ამბობდა სიმებიანი შევადარებთ.
და თუ ჩვენ წასვლას, მაგალითად, შევადაროთ 2, რომელიც არის შორის დღევანდელ ირჩენენ,
ვაკეთებ ზუსტად რომ.
მე ინახება ყველაფერი იგივე დარგობრივ 1 წლის ქვემოთ 26 ან იმდენად,
და ახლა შეამჩნია ამ ნაწილში შეიცვალა მხოლოდ ცოტა.
მოდით იგნორირება ხაზი 28 ერთი წუთით და ფოკუსირება მხოლოდ ამ ერთ.
რა ვამბობთ, რომ ორშაბათს ქ შეადარეთ აკეთებს?
ეს სახელურები პროცესში აღების 2 პოინტერები, S და T ამ შემთხვევაში,
სახის პრაქტიკულად აყენებს მისი თითის იმ 2 ასოს,
და რა უნდა გავაკეთოთ არის რაღაც ხოლო მარყუჟი ან ამისთვის მარყუჟის,
და ეს ამბობს ეს იგივე? თუ ასეა, ეს მოძრაობს თითების ან პოინტერები ნაბიჯია.
ეს იგივე, ეს იგივე, ეს იგივე,
ამ იგივე, ეს იგივე? და Ooh, მე დასასრულს სიმებიანი ორივე და ტ.
მე არ ი რაიმე წინააღმდეგობები. დიახ, ეს სტრიქონები არის იგივე.
და რას ქ შედარების დაბრუნების თუ 2 სიმები არის იგივე, როგორც ჩანს? ნულოვანი.
ასე რომ 0 არის კარგი ამ შემთხვევაში, რადგან თუ ის დააბრუნებს -1 ან +1,
რაც იმას ნიშნავს, რომ რაღაც მოვა ადრე t ალფავიტის ან შემდეგ ტ.
და რატომ უნდა, რომ იყოს სასარგებლო ჰქონდეს ფუნქცია რომ გიჩვენებთ რომელიც სიმებიანი მოდის ადრე
ან შემდეგ წელს ლექსიკონი?
[სტუდენტი] Searching. >> ძიება და დახარისხება.
>> ასე რომ შეგიძლიათ გააკეთოთ რამ, როგორიცაა ბინარული ძებნის ან bubble sort ან შერწყმის დალაგება
სადაც თქვენ უნდა შეადაროთ რამ.
ჯერჯერობით ჩვენ სახის მოჭრილი ზოგიერთი კუთხეების და მხოლოდ ისაუბრა დახარისხება
კონტექსტში ციფრები იმიტომ რომ ლამაზი და ადვილი ლაპარაკი,
მაგრამ შეგიძლიათ შეადაროთ, რა თქმა უნდა სიმები, ვაშლის და ბანანის,
რადგან თუ ვაშლის ცნობილია მოსვლა ადრე ბანანის, ანალოგიურად,
შეგიძლიათ გადაადგილება სიმები გარშემო მეხსიერების ისევე რობ შემოიერთა შერწყმა დალაგების წელს ვიდეო
და ჩვენ აქ სცენაზე სელექციაში დახარისხების, Insertion დალაგების, და ბუშტი ჯიშია.
ისე სად სხვაგან შეგვიძლია ამ? მოდით ცდილობენ ამ.
მოდით სახის დაგვავიწყდეს, რომ გაკვეთილი მომენტში და ცდილობენ ეხლა და დააკოპირეთ 1.c გავაკეთოთ შემდეგი.
შეესაბამება 21 მე ვამბობ, ბეჭდვითი რაღაც,
მაშინ მე მიღების string საწყისი მომხმარებელი,
მაშინ მე შემოწმების ამ.
ჩვენ ნამდვილად არ მიღებული ამ ჩვევა არ არის, მაგრამ მოდით, ახლა ამის გაკეთება.
მოდით რეალურად კანი უკან ამ ფენას. ეს მართლაც char *. ეს ბიჭი მართლაც char *.
ასე რომ რას ნიშნავს უნდა შემოწმების თუ == NULL?
თურმე როცა რეკავთ ფუნქცია, როგორიცაა GetString
ან საერთოდ ჰკითხეთ კომპიუტერი გადმოგცეთ გარკვეული მეხსიერება,
რაღაც ვერ არის წესრიგში.
თქვენ შეიძლება გიჟები და ვთხოვ კომპიუტერში terabyte მეხსიერების
მიერ ითხოვენ trillions ბაიტების მეხსიერების რომ უბრალოდ არ არსებობს კომპიუტერი,
მაგრამ GetString და სხვა ფუნქციების დაგვჭირდება გარკვეული გზა yelling at თქვენ
თუ თქვენ სთხოვა ძალიან ბევრი.
და გზა GetString აკეთებს ეს თუ არ ითხოვა მეტი მეხსიერების
ვიდრე შესაძლებელია კომპიუტერის, თუნდაც რომ სუპერ, სუპერ დაბალი ალბათობა
ვინაიდან არცერთ us ვაპირებთ აკრიფოთ ტრილიონი გმირები და შემდეგ დააჭიროთ,
მაგრამ დაბალი ალბათობით, თუმცა არ უნდა იყოს, მე მაინც გვინდა შევამოწმოთ იგი მხოლოდ იმ შემთხვევაში,
და სპეციალური მნიშვნელობა, რომელიც GetString, პასუხი, და სხვა ფუნქციების ბრუნდება
თუ რამე წავიდა არასწორი არის NULL ყველა Caps.
>> და რა არის NULL? NULL მხოლოდ ასე ხდება წარმოადგინოს მაჩვენებელი. ეს მეხსიერების მისამართი 0.
მსოფლიოს გადაწყდა, რომ თვითნებურად, თუ ეს ჩემი კომპიუტერის მეხსიერებაში - იცით რა? -
ჩვენ ვაპირებთ მოიპაროს მხოლოდ 1 byte ყოველი კომპიუტერის მეხსიერებაში, და ეს საიდან 0.
ჩვენ ვაპირებთ მისცეს მას მეტსახელად NULL, და ჩვენ ვაპირებთ გპირდებით
რომ ჩვენ არასოდეს რეალურად დააყენა რეალური მონაცემები არ არსებობს
იმიტომ, რომ ჩვენ უბრალოდ თვითნებურად სჭირდებათ განსაკუთრებული ღირებულება, 0, aka NULL,
ასე, რომ ჩვენ შეგვიძლია დაწეროთ საათზე მომხმარებლებს თუ რაღაც მიდის არასწორი.
წინააღმდეგ შემთხვევაში თქვენ შეიძლება არ ვიცი ამჯამად 0 ნიშნავს დააყენა რაღაც აქ
ან ნიშნავს რაღაც წავიდა არასწორი?
ჩვენ უნდა ყველა თვლის, რომ NULL არაფერს ნიშნავს იყო დაბრუნებული,
არ ფაქტობრივი მისამართი დააბრუნეს.
ახლა, აქ მე უბრალოდ მიღების ჩემს ადამიანურ კონვენციის მე დაბრუნდნენ 1 მთავარი
თუ რამე მიდის არასწორი.
ეს იმიტომ, რომ ძირითად დაბრუნებას კონვენცია წარმოადგენს დაბრუნებას 0 თუ კარგი,
1 ან სხვა ღირებულება, თუ ცუდია.
მაგრამ GetString და ნებისმიერი ფუნქცია, რომ გარიგებებს მეხსიერების ანაზღაურება NULL თუ რაღაც მიდის ცუდი.
>> Okay. ასე რომ, სამწუხაროდ, ხაზი 27, სუპერ მარტივი თუმცა, მთლიანად ვერ გადაიწერა სიმებიანი.
რატომ? ჩვენ ვხედავთ ამ შემდეგნაირად.
მე აცხადებდნენ შეესაბამება 27 უნდა მიღების ასლი და უწოდა ტ.
ასე რომ მე არ გეკითხებით მომხმარებლის 2 სტრიქონები ამ დროს მე უბრალოდ ვამბობ, ღირებულების s
უნდა დადგეს t ისევე.
ახლა მხოლოდ იმის დემონსტრირება, თუ როგორ გატეხილი ეს არის, რომ ამჟამად 29 Onward რა ვარ მე აკეთებს?
პირველი მე შემოწმების თუ სიგრძეზე t მეტია 0.
არსებობს რამდენიმე სტრიქონი იქ. მომხმარებლის აკრეფილი რაღაც სისტემაში
რა არის ხაზზე 32 აკეთებს, როგორც ჩანს?
[Inaudible სტუდენტი საპასუხოდ] >> მარჯვენა. შეგიძლიათ სახის infer ის, რაც ვთქვი ის აკეთებს.
მაგრამ ტექნიკურად, რა არის ეს აკეთებს? t [0] წარმოადგენს რა?
[სტუდენტი] zeroth ხასიათი. >> [Malan] zeroth ხასიათი.
ან, უფრო ადამიანის მსგავსი, პირველი პერსონაჟი t, რასაც არ არის, H იქნებ ამ შემთხვევაში.
და toupper აკეთებს იმას ნათქვამია მოხსენებაში. ეს capitalizes zeroth ხასიათი t და ეს ცვლის მას.
ასე რომ, ეს იმას ნიშნავს, მიიღოს zeroth ხასიათი t, რათა ის ზედა,
და მისი უკან რომ იმავე ადგილას.
ასე რომ, თუ მე აკრიფოთ მიესალმები ამას, ეს უნდა შეიცვალოს ამას თ რომ დედაქალაქში H.
მაგრამ პრობლემა ის არის, რომ ხაზები 35 და 36 რა ვარ შესახებ გააკეთოთ ამობეჭდოთ ჩვენთვის და ტ.
და რაც თქვენი hunch?
რა ვარ მე რეალურად აპირებს თუ არა მე აკრეფილი მიესალმები ყველა ამას?
რა ხდება მისაღებად დაბეჭდილი? >> [Inaudible სტუდენტი საპასუხოდ] >> რა არის რომ?
[სტუდენტი] დიდი H და დანარჩენი მცირე. >> დიდი H და დანარჩენი მცირე რისთვისაც, s ან t?
[სტუდენტი] ორივე. >> ორივე. სწორედ. ასე რომ ვნახოთ რა ხდება აქ.
>> ნება მომეცით წავიდეთ წინ და შეადგინონ ამ. ეს არის copy1, ასე რომ copy1. ყველა უფლება.
Zoom შემოსული ნება მომეცით წავიდეთ წინ და აწარმოებს copy1, შეიტანეთ, ვთქვათ რაღაც: Hello ამას.
ეს კაპიტალიზირდება ასლი, მაგრამ ეს აშკარად კაპიტალიზირდება ორიგინალური ისევე,
რადგან ის, რაც ახლა ხდება ეს ამბავი?
შეესაბამება 27 მე არ რეალურად ჩანს, კოპირება ტექსტი,
მაგრამ მიუხედავად იმისა, რომ თქვენ შეიძლება არ ინტუიციურად იმედი გამოთქვა, რომ იყოს საქმე,
თუ ფიქრობთ ამის შესახებ ამ სურათს, თუ რა არ მინდა გაკეთდეს?
ნახევარი სურათზე არის იგივე.
მოდით გააფართოვოს უკან დროში, ასე რომ t ჯერ არ არსებობს ამბავი.
S შეიძლება არსებობდეს ამბავი, მაგრამ მოდით ამას მიესალმები ამ დროს.
ნება მომეცით, დაფიქსირება, რაც მე რეალურად აკრეფილი შემოსული
ამ შემთხვევაში აქ გვაქვს H-E-L-მ-o.
ჩვენ მიაპყროს, როგორც თანმიმდევრობა გმირები, რომ ჩემი გამყოფი ხაზები აქ და ჩემი \ 0.
ასე რომ, ეს სადაც ჩვენ ვართ, როგორც კი ხაზი 1 მეშვეობით 24-ish, მისცეს ან მიიღოს, არ შესრულდება.
ეს არის სურათის ჩემი გონებიდან.
როდესაც მე მისაღებად ხაზი 27, რა ხდება?
ისევე ადრე, მომცეთ, რომელიც მე მიაპყროს როგორც ამ მოედანზე.
ეს მოუწოდა ტ. და რაც მისი ღირებულება იყოს? ვინ იცის? ზოგიერთი ნაგვის ღირებულება.
>> ამიტომ მე აბსტრაქტული რომ მოშორებით როგორც კითხვის ნიშნის.
და როგორც კი მარჯვენა მხარეს ხაზი 27 ახორციელებს, რა ვარ მე აყენებს შიგნით t?
იგივე რომ წელს s.
ასე რომ, თუ ჩვენ ერთი წუთით ამოიღონ ამ აბსტრაქცია of arrow და ვამბობთ,
OH, ეს არის მეხსიერების დატვირთვის მისამართი 123, როცა ამბობთ t იღებს s, მძიმით,
თქვენ სიტყვასიტყვით აყენებს 123 აქ.
ახლა თუ ჩვენ სახის გაამარტივებს ჩვენი სამყაროს კვლავ სურათები,
რა თქვენ მართლაც გაკეთდეს მხოლოდ დაემატა კიდევ ერთი arrow თქვენს სამყაროსთან
რომ მიუთითებს საწყისი t იმავე ზუსტი სიმებიანი.
ასე რომ, როდესაც შეესაბამება 31 და 32 მე რეალურად წასვლა შეცვლის შესახებ t [0],
რა არის t [0] აშკარად სინონიმი არის? s [0]
ასე რომ ყველა რომ ხდება.
და მიუხედავად იმისა, ასეთი გრძნობს პატარა დაბალი დონე და arcane
და ამ სახის იგრძნობა ალბათ ინტუიციურად უნდა ახლახანს მუშაობდა -
მე გააკეთა ასლები რამ ადრე და ეს მხოლოდ მუშაობდა -
თუ თქვენ ნამდვილად ვფიქრობ იმაზე, თუ რა სიმებიანი ნამდვილად არის, ეს char *.
ისე, რა არის ეს? ეს მისამართი ზოგიერთი ხასიათი.
მაშინ ალბათ ეს ქმნის მეტი გაგებით, რომ როდესაც თქვენ ცდილობენ რაღაც
სუპერ შეხედვით მარტივი მოსწონს, ყველა თქვენ აკეთებთ არის კოპირება მეხსიერების მისამართზე.
თქვენ არ რეალურად აკეთებს არაფერი სიმებიანი თავად.
ისე კი, თუ თქვენ არ ვიცი, როგორ გადაჭრას ეს პრობლემა კოდი,
მაღალი დონის, კონცეპტუალურად, რას უნდა გავაკეთოთ, რათა ta ჭეშმარიტი ასლი s, სავარაუდოდ?
Yeah. >> [სტუდენტი] Give it new საიდან? >> ზუსტად.
>> ჩვენ უნდა მივცეთ t ბრენდის ახალი ადგილმდებარეობა.
ჩვენ გვჭირდება, რათა როგორმე შექმნას სამყარო სადაც მივიღებთ ახალ ბლოკი მეხსიერება,
რომელიც მხოლოდ სიცხადე გულისთვის მე მიაპყროს უფლება ქვემოთ ამ ერთი, მაგრამ ეს არ უნდა იყოს იქ.
მაგრამ ეს უნდა იყოს იგივე ზომის, ამიტომ მე მიაპყროს ამ ვერტიკალური ხაზები იგივე ადგილზე.
ეს ჯარიმა, თუ ეს ყველაფერი ნაგავი თავდაპირველად. ვინ იცის, რა იყო იქ?
მაგრამ ნაბიჯი 1 აპირებს უნდა მომეცი იმდენი მეხსიერებაში, მე უნდა
რათა შეწყობოდა ასლი hello, მაშინ გაერკვნენ, თუ როგორ კოპირება თ აქ, ვებ აქ,
ლ აქ და სხვ.
მაგრამ ეს უკვე უნდა გრძნობდეს პატარა აშკარა მაშინაც კი, თუ ზოგიერთი დეტალი ჯერ კიდევ რეზიუმე.
გადააკოპირეთ ეს სიმებიანი შევიდა ამ, უბრალოდ ამისთვის მარყუჟი ან ხოლო loop
ან რაღაც, რომელთანაც თქვენ გახდეს უფრო იცნობს.
მოდით ცდილობენ ამ. ნება მომეცით წასვლას copy2.c.
In copy2.c გვაქვს თითქმის იგივე პროგრამის გარდა ხაზი 27.
როგორც ჩანს ცოტა რთული, მაგრამ თუ ჩვენ შესვენება მისი დანგრევა ნაჭერი მიერ ცალი,
მარცხენა მხარეს არის იგივე.
ჩარ * t ქმნის ამ რამ მეხსიერებაში, მაგრამ კითხვის ნიშნის
რადგან არ ვიცით რა იქ იყოს.
წლის მარჯვენა მხარეს ჩვენ ახლა შემოღების ახალი ფუნქცია, malloc,
მეხსიერების გამოყოფას, მომეცი მეხსიერება,
და ეს აშკარად იღებს რამდენი არგუმენტები, რამდენი რამ შიგნით ფრჩხილებში?
გავიგე murmurings 1 და 2 გზა, მაგრამ ეს მხოლოდ 1.
იქ არ არის მძიმე, რაც იმას ნიშნავს, არსებობს მხოლოდ 1 რამ შიგნით ფრჩხილებში.
მიუხედავად იმისა, რომ არსებობს სხვა ფრჩხილებში, ნება მომეცით ხაზი გავუსვა
რა შიგნით outermost ფრჩხილებში და ეს ამ გამოსახულებანი:
(Strlen (ებ) + 1) * sizeof (char).
ასე რომ, თუ ჩვენ რეალურად ვფიქრობ ამ გზით, ამ ამბობს მომეცი სიგრძით s.
რატომ ვარ მე, თუმცა დასძინა, 1 გადატანა სიგრძე? >> [Inaudible სტუდენტი საპასუხოდ]
სწორედ. ჩვენ გვჭირდება ფართი ამ ბიჭს საათზე კუდი, მეექვსე ხასიათი, რომ არ აქვს მნიშვნელობა ინგლისური
მაგრამ აქვს სპეციალური პროგრამული მნიშვნელობა აქვს.
>> ამიტომ ჩვენ გვჭირდება + 1 რომ რადგან strlen ბრუნდება ადამიანის მოლოდინს სიგრძე,
მიესალმები ან 5, იგი არ მოგცემთ დამატებით null ხასიათი.
ასე რომ ხელით დაამატოთ ეს ერთად + 1.
და მაშინ ეს, * ზომა (char), ჩვენ არ გვინახავს ამ ადრე.
ეს არ არის ტექნიკურად ფუნქცია.
აი ეს არის განსაკუთრებული სიტყვით რომ ეუბნება, თუ რა ზომის არის ზოგიერთი მონაცემები ტიპის კომპიუტერი
რადგან რეალურად, ზოგიერთი ჩვენგანი 32-bit კომპიუტერებს.
მაქვს საკმაოდ ძველი კომპიუტერი სახლში, და ეს მხოლოდ იყენებს 32 ბიტს წარმოადგინოს პოინტერები.
და ასე თუ წავიდოდი ზომის მონაცემები ტიპის, ეს შესაძლოა 32 ბიტი.
მაგრამ თუ მე გამოყენებით ჩემი ახალი ლამაზი კომპიუტერი, ალბათ დაიბრუნებს ღირებულება 64 ბიტი
ამისთვის რაღაც მისამართზე.
ასე რომ, ამ შემთხვევაში, უბრალოდ უნდა იყოს სუპერ უსაფრთხო, ჩვენ არ ვაპირებთ მძიმე კოდი რაღაც -
ასევე, რა არის ზომა char მიხედვით, რაც ჩვენ უკვე აღვნიშნე, რომ აქამდე?
ჩვენ საკმაოდ ბევრი ამბობს სიტყვიერად, რომ 1 ნაწილად, და ეს საკმაოდ ბევრი ჭეშმარიტი მთელს ფორუმში.
თუმცა ისევ და ისევ, დაშვებების ტენდენცია იყოს ცუდი.
ისინი გამოიწვიოს buggy პროგრამული თუ ადამიანი სარგებლობს თქვენი პროგრამული უზრუნველყოფის გზები თქვენ არ აპირებდა.
მოდით რეზიუმე ამ მოშორებით და უბრალოდ მეტი generically ამბობენ
მჭირდება ამ ბევრი მოცულობით მეხსიერება
და თითოეული ბლოკი მეხსიერება უნდა იყოს ექვივალენტური ზომა ხასიათი,
რაც ფაქტობრივად ტოლია 1 ამ შემთხვევაში, მაგრამ მეტი გზა generic წერის იგი.
ასე რომ, თუ სიტყვა არის hello, რამდენი ბაიტი ამჯამად malloc სავარაუდოდ გამოყოს ამისთვის მიესალმები?
[სტუდენტი] ექვსი. >> ექვსი. ზუსტად ისე, როგორც ბევრი როგორც ჩვენ გვაქვს კითხვის ნიშნები ეკრანზე.
და მერე მიხვდები ახლა ეფუძნება თქვენი გაგება GetString
რას malloc ალბათ დაბრუნებას? >> [სტუდენტი] მისამართზე.
მისამართი რა? პირველი ბლოკი მეხსიერება.
>> ჩვენ არ გვაქვს იდეა რა იქ, რადგან რამდენიმე სხვა ფუნქცია
შესაძლებელი იყო გამოყენებისას მეხსიერების ადრე.
მაგრამ malloc, როგორიცაა GetString ბრუნდება მისამართი პირველი ბაიტი მეხსიერების
რომ მან გათვალისწინებულია თქვენ.
თუმცა, რა იგი ამას არ გააკეთებს არის შეავსოთ ამ ცარიელი ერთად backslash null ხასიათი
რადგან აღმოჩნდება, შეგიძლიათ გამოიყენოთ malloc გამოყოფას არაფერი: ints, სიმები, მასივები,
მოძრავი, სტუდენტი სტრუქტურებში.
თქვენ შეგიძლიათ გამოიყენოთ malloc მთლიანად generically.
მას ფეხზეც ან უნდა ვიცოდეთ თუ რას გამოყოფის მეხსიერების.
ასე რომ, ეს იქნებოდა presumptuous ამისთვის malloc დააყენოს \ 0
დასასრულს ყველა ბლოკი მეხსიერების ის გაწვდით
რადგან ეს \ 0 რამ არის მხოლოდ კონვენციის სიმებისათვის.
ეს არ გამოიყენება ints, ეს არ გამოიყენება მოძრავი, ეს არ გამოიყენება სტუდენტებს.
და ასე GOTCHA ერთად malloc არის, რომ ტვირთი მთლიანად თქვენ პროგრამისტი
უნდა გვახსოვდეს, თუ რამდენი ბაიტი თქვენ გამოყოფილი და არა ოდესმე გამოიყენოს ამისთვის loop
ან მაშინ, როცა მარყუჟის და წავიდეთ წარსულში საზღვრის ბლოკი მეხსიერება თქვენ უკვე ეძლევა.
განათავსეთ სხვა გზა, როგორც კი თქვენ გამოყოს მეხსიერება,
ვერ ვთხოვთ ოპერაციული სისტემა, OH, სხვათა შორის, თუ როგორ დიდი ბლოკი მეხსიერება იყო ეს?
ეს მთლიანად თქვენზეა უნდა გვახსოვდეს, თუ თქვენ გჭირდებათ რომ ღირებულება.
>> ასე რომ ვნახოთ რა გაგრძელება გამოიყენოს ეს მეხსიერებაში.
შეესაბამება 28 და 29 რატომ აკეთებს ამას?
უბრალოდ სულ საღი აზრის ქვითარი.
Just შემთხვევაში რაღაც არ მოხდა ისე, ვთხოვ რაღაც Crazy ოდენობით მეხსიერება
ან მე ამდენი რამ გაშვებული კომპიუტერი რომ იქ უბრალოდ არ არის საკმარისი მეხსიერება,
მსგავსი რამ, რომ მე მინიმუმ გვინდა შევამოწმოთ null.
სინამდვილეში, ყველაზე მეტად კომპიუტერები მოგცემთ იმის ილუზია, რომ ყველა პროგრამა
შეგიძლიათ გამოიყენოთ მთლიანად თქვენი RAM,
მაგრამ ასე, თუ მომხმარებლის ტიპის ზოგიერთ Crazy ხანგრძლივი string რადგან ისინი ცუდი ბიჭი
და ისინი რეალურად ცდილობს Crash თქვენი პროგრამის ან hack მივანიჭო,
გსურთ მინიმუმ შეამოწმოთ დაბრუნების ღირებულება malloc და თუ არა შეადგენს null.
და თუ ეს ასეა, მოდით ახლახან შევწყვიტე ახლავე რადგან არ ვიცი რა უნდა გააკეთოს ამ შემთხვევაში.
როგორ შემიძლია კოპირება სიმებიანი? არსებობს რამდენიმე გზა ამის გაკეთება.
არსებობს ქ კოპირება ფუნქციების C, მაგრამ სუპერ მარტივი ჩვენთვის ამის გაკეთება მოძველებული გზა.
>> პირველი ნება მომეცით გაერკვნენ, რა სიგრძით s არის.
მე შეეძლო ეს loop არამედ უბრალოდ განათავსოთ out აქ სიცხადე.
ასე n ახლა ინახავს სიგრძეზე ორიგინალური ტექსტი, რომელიც სავარაუდოდ 5.
მაშინ ჩემი ამისთვის loop მე iterating საწყისი 0 on მდე N,
და თითოეულ iteration მე აყენებს s [i] შიგნით t [i].
ასე რომ, რაც მე გულისხმობდა, რომ ჩემს 2 თითების მიუთითებს სიმები ადრე.
როგორც ეს loop iterates მოსწონს, მე ვაპირებ იყოს გადაწერა თ შევიდა აქ,
ვებ შევიდა აქ, ლ შევიდა აქ რადგან ეს s, ეს არის ტ.
და მერე ბოლოს, შეესაბამება 35 რატომ აკეთებს ამას?
მე უნდა დავრწმუნდეთ, რომ მე დამთავრებული სიმებიანი ტ.
და მე ეს გზა იყოს სუპერ სიცოცხლისუნარიანობა.
მაგრამ შესთავაზოს, ვინმეს თუ შეგიძლიათ, განსხვავებულ გზას აკეთებენ.
მე ნამდვილად არ გვჭირდება ხაზის 35. არსებობს სხვა გზა ამის გაკეთება.
Yeah. >> [Inaudible სტუდენტი საპასუხოდ] >> Say ეს louder.
[სტუდენტი] ნაკლებია ან ტოლი. >> ზუსტად.
ჩვენ შეგვეძლო უბრალოდ, ვამბობთ ნაკლები ან ტოლია N, რომელიც ზოგადად უკვე ცუდი
რადგან თითქმის ყოველთვის, როცა ჩვენ ახვიდეთ ტოლია რამ ჩვენ დათვლის
ჩვენ 1 ნაბიჯით შორს.
მაგრამ გახსოვდეთ, თუ რამდენი ბაიტი არც ჩვენ გამოყოს?
ჩვენ გამოყოფილი strlen of s, ასე 5 + 1 სულ 6.
ასე რომ ამ შემთხვევაში ჩვენ შეგვიძლია გავაკეთოთ რაღაც მსგავსი
ასე, რომ ჩვენ კოპირება არა მხოლოდ მიესალმები არამედ \ 0 ბოლომდე.
გარდა ამისა, ჩვენ შეგვიძლია გამოვიყენოთ ფუნქცია მოუწოდა ქ ასლი, strcpy,
მაგრამ, რომ არ იქნება თითქმის იმდენი fun.
მაგრამ ეს ყველაფერი მას არ ქვევმოთ hood.
მაშინ ბოლოს, ჩვენ იგივე რამ, როგორც ეს ადრე იყო.
მე კაპიტალიზაცია t და მერე აცხადებენ, რომ ორიგინალური ასე გამოიყურება და ასლი ჰგავს, რომ.
მოდით ვეცადოთ ეს ახლა. ნება მომეცით წავიდეს აქ. ჩადება copy2. ჩვენ მიუახლოვდით და აწარმოებს copy2.
მე ვაპირებ აკრიფოთ მიესალმები ამას, და მართლაც მივიღებ ამას მიესალმები როგორც ორიგინალური
მაგრამ დედაქალაქში გამარჯობა ამისთვის ასლი.
მაგრამ მე არ კეთდება მხოლოდ ამჟამად. მე უნდა გავაკეთოთ 1 ბოლო რამ აქ.
46 და 47 აშკარად გამონთავისუფლების მეხსიერება, მაგრამ რა, რომ რეალურად ნიშნავს?
რა ვარ მე აკეთებს, როგორ ფიქრობთ, დარეკვით ხაზის 46 და ხაზი 47?
რა ეფექტი ამჯამად რომ აქვს? Yeah.
[Inaudible სტუდენტი საპასუხოდ] >> ზუსტად.
>> თქვენ უბრალოდ ვეუბნებოდი ოპერაციული სისტემა, Hey, მადლობა ამ მეხსიერებაში.
ახლა თქვენთვის ვიყენებთ მას ვინმე.
და აქ მაგალითი ნაგვის ღირებულებებს.
მე ახლახან გამოიყენება ამ მეხსიერების დაწერეთ სიტყვა მიესალმები წელს 2 ადგილებში,
აქ, აქ, აქ, და აქ.
ასე რომ, ეს არის H-E-L-L-O-\ 0.
მაგრამ შემდეგ მოვუწოდებ ხაზის 46 და ხაზი 47, და თქვენ იცით, რა ხდება იქ თვალსაზრისით სურათზე?
სინამდვილეში, დაველოდოთ, ამ სურათის ძველი.
ერთხელ ჩვენ ასლი, ამ ბიჭს ფაქტიურად მიუთითებს აქ,
მოდით ამოიღონ ნომრები და მხოლოდ აბსტრაქტული მოშორებით როგორც ჩვენი ისრები კვლავ.
რა ხდება ამ სურათს როცა მოვუწოდებ თავისუფალი?
[Inaudible სტუდენტი საპასუხოდ] >> კი არ.
თუ მოვუწოდებ უფასოდ და T - სახის ხრიკი კითხვა - ამ სურათს არ ცვლის ყველა
რადგან მოუწოდებდა და მოუწოდებდა t მხოლოდ ეუბნება ოპერაციული სისტემა,
Hey, შეგიძლიათ გამოიყენოთ ეს მეხსიერების ერთხელ, მაგრამ ეს არ ცვლის ეს null
ან რაღაც განსაკუთრებული ხასიათი, იგი არ ცვლის ამ,
ეს არ ცვლის თ ან ე ან ლ ან ლ ან o ორივე ადგილიდან არაფერი.
თვალსაზრისით სურათზე, როგორც კი მოვუწოდებთ თავისუფალი, არაფერი შეიცვლება.
და მასში მდგომარეობს წარმოშობის ნაგვის ღირებულებები რადგან თუ შემდეგ ამ პროგრამაში
ვთხოვთ ოპერაციული სისტემის უფრო მეხსიერების ერთად GetString ან malloc ან რამე მაგდაგვარს
და ოპერაციული სისტემის ამბობს, დარწმუნებული ვარ, მყავს 12 ბაიტი მეხსიერება უბრალოდ გაათავისუფლა up,
გამოიყენოს ეს, რას აპირებს გადაეცემა?
თქვენ ვაპირებთ გადაეცემა ბლოკი მეხსიერება, რომ ჩვენ, როგორც წესი, მიაპყროს
ერთად კითხვის ნიშნები, მაგრამ რა არის ის კითხვის ნიშნები?
ისინი მოხდეს იყოს H-E-L-L-O, H-E-L-მ-o.
ეს არის ჩვენი ახალი ნაგვის ღირებულებებს, როგორც კი თქვენ უფასოა, რომ მეხსიერებაში.
>> არსებობს რეალური სამყაროს გავლენა აქაც.
ეს ხდება არ უკავშირდება RAM, მაგრამ თქვენი კომპიუტერები
ფაქტობრივად იგივე რამ რომელსაც დისკზე.
ჩვენ ვსაუბრობთ ამ კერძოდ მომავალში პრობლემა კომპლექტი, რომ აქცენტს აკეთებს სასამართლო ექსპერტიზის.
მაგრამ რა მოხდება თუ თქვენ გაქვთ გარკვეული მგრძნობიარე ფინანსური ფაილი თქვენს კომპიუტერში
ან sketchy JPEG და თქვენ გადაიტანეთ იგი თქვენს ნაგავი,
რა ხდება, როდესაც თქვენ გადაიტანეთ იგი შევიდა ნაგვის ან recycle bin?
თქვენ იცოდა რა იყო საუბარი. [სიცილის]
რა ხდება, როდესაც თქვენ ისხდნენ, რომ მტკიცებულება თქვენი recycle bin ან ნაგვის შეიძლება?
[Inaudible სტუდენტი საპასუხოდ]
ისე, ასე რომ ფრთხილად. რა ხდება, როდესაც თქვენ ეს?
მოკლე პასუხი არის არაფერი, არა?
Sketchy ან მგრძნობიარე ფაილი დღემდე მხოლოდ სხდომაზე სადღაც თქვენს ხისტ დისკზე.
ყველაზე მეტად ჩვენს არანაკლებ ვისწავლეთ რთულ გზაზე, რაც გჭირდებათ დაცლას თქვენი ურნის
ან თქვენი recycle bin რეალურად წაშალოთ ფაილები.
მართლაც, როდესაც თქვენ დააჭიროთ მაუსის მარჯვენა ღილაკს ან კონტროლის დაჭერით თქვენი ნაგვის can
ან აირჩიეთ ფაილი, ცარიელი სანაგვე ან რასაც
და თქვენ ნამდვილად დაცლას trash შეუძლია recycle bin, რაც სინამდვილეში ხდება მაშინ ამ სურათს?
სხვა არაფერი. ასე რომ არაფერი რეალურად ხდება დისკზე.
>> და თუ ჩვენ მხოლოდ დროებით digress და დაწეროთ - I'll ისარგებლეთ უკან ამ.
ახლა სიუჟეტი იცვლება RAM, სადაც პროგრამების არსებობს
ხოლო თქვენ გაშვებული მათ, დისკზე, სადაც ინახება გრძელვადიანი
მაშინაც კი, როდესაც ხელისუფლებაში გადის, ახლა - და ჩვენ დავბრუნდებით ამ მომავალში -
მოდით უბრალოდ ვიტყვი, რომ ეს წარმოადგენს მყარი დისკის შიგნით თქვენი კომპიუტერის
რადგან უკან დღეში ადრე წრიული დისკები, ჰგავს ფლოპი დისკები.
ასე რომ თუ გარკვეული მგრძნობიარე Excel ფაილი, ის შესაძლოა ამ ბლოკი მეხსიერება
თქვენი კომპიუტერის დისკზე, და მე უბრალოდ ხატვის იგივე თვითნებური 1s და 0S.
როდესაც თქვენ გადაიტანეთ ფაილი მოსწონს, რომ თქვენი ნაგვის შეიძლება ან recycle bin,
სიტყვასიტყვით, აღარაფერი ხდება, რადგან Apple და Microsoft ახლახანს გადაწყვიტეს
ნაგვის შეგვიძლია და recycle bin მართლაც მხოლოდ დროებითი placeholder.
იქნებ საბოლოოდ OS იქნება დაცლას იგი თქვენთვის, მაგრამ, როგორც წესი, ის არაფერს აკეთებს,
მინიმუმ, სანამ თქვენ ნამდვილად დაბალი კოსმიურ.
>> თუმცა, როდესაც მიდიხარ ცარიელი სანაგვე ან ცარიელი recycle bin,
ანალოგიურად, აღარაფერი ხდება ამ სურათს.
ყველა რომ ხდება სხვაგან თქვენს კომპიუტერში, არსებობს გარკვეული სახის მაგიდასთან.
ეს ერთგვარი მოსწონს პატარა cheat ფურცელი, რომელიც ამბობს, რომ, ვთქვათ, resume.doc,
ასე რომ თქვენი რეზიუმე Microsoft Word ფაილის გამოიყენება ცხოვრობენ საიდან 123 თქვენს მყარ დისკზე,
არ მეხსიერებაში და არა RAM მაგრამ თქვენს მყარ დისკზე,
და თქვენი sketchy JPEG ცხოვრობს 456, და თქვენი Excel ფაილი ცხოვრობს 789 ან სადაც არ უნდა.
როდესაც თქვენ წაშალოთ ფაილები პრაქტიკულად ვასუფთავებ სანაგვე ყუთს ან recycle bin,
ამ სურათს არ ცვლის. 0S და 1s თქვენს ხისტ დისკზე არ მიდიან სადმე.
მაგრამ ამ მაგიდასთან, ამ პატარა მონაცემთა ბაზის ჯიშები, აკეთებს ცვლილებას.
როდესაც თქვენ წაშალოთ თქვენი რეზიუმე, ეს თითქოს ფაილი ამოღებულია ზოგიერთი გრძნობა,
მაგრამ ყველა კომპიუტერის ამჯამად არის დაივიწყოს სადაც ეს ნივთი ცხოვრობს თქვენს ხისტ დისკზე.
0S და 1s რომ დაკომპლექტებას თქვენი რეზიუმე ან რომელიმე ამ სხვა ფაილი დღესაც ხელუხლებლად.
>> ასე რომ, თუ თქვენ ეს შემთხვევით, იქ მაინც არასამთავრობო ნულოვანი ალბათობის
რომ თქვენ შეიძლება ფეხზე თქვენი მონაცემები გამოყენებით Norton Utilities ან კომერციული პროგრამული
რომლის მიზანია ცხოვრების მოძიების 0S და 1s რომ არ სახის იქნა ობოლი,
დავიწყებული აქ დაუტოვებიათ აქ, ასე რომ თქვენ შეგიძლიათ მიიღოთ თქვენი მონაცემები უკან.
ან სასამართლო გამომძიებლები ერთად პოლიციის ან FBI რომ პრაქტიკულად ხისტ დისკზე
და რეალურად ვეძებთ ნიმუში 0S და 1s რომ გამოიყურებოდეს JPEGs, გამოიყურებოდეს Excel ფაილი
და ფეხზე რომ გზა მაშინაც კი, თუ კომპიუტერში არ დავიწყებია მათ იქ.
ასე რომ ერთადერთი გზა ნამდვილად წაშლა მონაცემები, როგორც ჩვენ განვიხილავთ მომავალში,
არის scrub ან wipe ფაილი ან ხისტი მიერ -
თქვენ არ შეგიძლიათ ნამდვილად დავაღწიოთ 0S და 1s
რადგან სხვაგვარად ნეტავ იწყება Gigabyte ხისტ დისკზე
და ნეტავ დასრულდება up ერთად megabyte ხისტ დისკზე თუ მუდმივად იყო წაშლის,
სიტყვასიტყვით, 0S და 1s.
ასე რომ რას თუ თქვენ ნამდვილად სურდა საფარის თქვენი ტრეკების
და ფუნდამენტური პრობლემა ის არის, რომ იქ მაინც 0S და 1s on დისკზე?
მე ვხედავ ვინმეს gesticulating, რომ თქვენ ფიზიკურად შესვენება მოწყობილობა. იმუშავებს.
[სიცილის] მაგრამ თუ ეს სახის ძვირადღირებული გადაწყვეტა, რა იქნება უფრო გონივრულად?
Yeah. >> [სტუდენტი] გადავაწერო მათ. >> გადავაწერო მათ რა? >> [სტუდენტი] სხვა მონაცემები.
სხვა მონაცემები. შეგიძლიათ უბრალოდ ჩაანაცვლებს დისკზე ერთად 0S ან 1s ან ყველა 0S, ყველა 1s.
>> და ეს მართლაც რა ზოგიერთი პროგრამა აკეთებს.
თქვენ შეგიძლიათ შეიძინოთ პროგრამული ან თუნდაც უფასოდ პროგრამული უზრუნველყოფა,
და კიდევ აგებული, რომ Mac OS ამ დღეებში ნაკლებად ისე Windows,
არის უნარი უსაფრთხოდ წაშალოს.
რეალურად, თუ თქვენ გინდათ რომ ყველა პერსპექტივაში მთავარი დღეს თუ თქვენ გაქვთ Mac და ამის გაკეთება,
თუ თქვენ მოხვდით რაღაცები თქვენს trash შეუძლია, რომ თქვენ უსაფრთხო Empty Trash,
რომელიც ზუსტად რომ.
იმის ნაცვლად, რომ უბრალოდ წაშლას ფაილი აქ, ეს არ წაშალოს 0S და 1s აქ,
პირიქით, ის მხოლოდ ცვლის მათ ყველა, მაგალითად, რომ 0S და dot, dot, dot.
ასე რომ ერთი თქვენი მომავალი psets რეალურად იყოს შეგნებულად ფეხზე მონაცემები -
ფოტოები, რომ ჩვენ აღებულ ადამიანი, ადგილები, და რამ შესახებ კამპუსში
რისთვისაც ჩვენ გავაკეთებ სასამართლო იმიჯი ციფრული კამერა მისი მეხსიერების ბარათი,
რომელიც ზუსტად იგივე იდეა - და თქვენ უნდა იყოს დაუპირისპირდა რეალურად იპოვოს
თარგების რომ წარმოადგენენ JPEGs თქვენს ხისტ დისკზე,
ჰგავს, რომ ყოფილი სტუდენტი, რომელთა ელ წავიკითხე რამდენიმე კვირის წინ გააკეთა
ფეხზე მისი დის ფოტოები.
რატომ არ ვიღებთ 5 წუთიანი შესვენება აქ, და ჩვენ გადაჯგუფების ერთად უფრო მეხსიერებაში.
ასე რომ აქ, სადაც რამ კიდევ ცოტა გონება-bending, მაგრამ ეს არის ძალიან ძლიერი ნაბიჯი
მიმართ გაგება ამ ყველა სხვა.
აქ არის პროგრამა მოუწოდა pointers.c.
ეს არის შორის დღევანდელ ნიმუში კოდი.
გაითვალისწინეთ, რომ პირველი რამდენიმე ხაზი, 19 გზით 22, ყველა ვაკეთებთ არის რაღაც GetString
და დაბრუნების მისამართი, შენახვა მას s.
ამიერიდან ამისთვის pset კი 3 თუ გინდათ მაგრამ pset 4 და
სადაც შეგიძლიათ დაიწყოს მიიღოს ამ სასწავლო თვლები off თავს,
არ არსებობს მიზეზი, რომ ვიტყვი, რომ სიმები არსებობს უქმნით.
ეს, რა თქმა უნდა okay to დავიწყო ამბობდა char *.
>> როგორც განზე, ონლაინ ცნობებსა და წიგნებში შეგიძლიათ ხშირად ვხედავ ვარსკვლავი შემდეგ ცვლადი.
ალბათ კი ფართების გარშემო ორივე მხარეს იგი.
ყველა იმ are ფუნქციურად სწორი.
ახლა, თუმცა, ჩვენ standardize ამ მიდგომას, რათა სუპერ წმინდა
რომ char * ჰგავს ამბობდა ხასიათი მაჩვენებელი.
სწორედ მონაცემები ტიპის.
და მერე სახელით ცვლადი s ამ შემთხვევაში.
ასე რომ ჩვენ მიღებული სიმებიანი და ჩვენ მას s.
და შემდეგ ქვევით აქ შეამჩნია, რომ მე ვაკეთებ რეალურად ცოტა მოსატყუებლად.
ამას უწოდებენ მაჩვენებელი არითმეტიკა, რომელიც ერთგვარი სუპერ მარტივი.
ეს უბრალოდ ნიშნავს, დაამატოთ და სხვაობა ნომრის მითითებას.
მაგრამ ეს რეალურად მუშაობს.
ეს პროგრამა აშკარად ბეჭდავს string s 1 სიმბოლოს თითო ხაზზე ისეთი, რომ საბოლოო ჯამში -
ასე შეგვიძლია გააფუჭებს სადაც ეს ხდება, გააკეთოს პოინტერები, აწარმოებს პოინტერები, ნება მომეცით zoom სისტემაში
ახლა ნება მომეცით ტიპის რაღაც HELLO და გაცნობის შეიყვანეთ
და ეს ბეჭდავს 1 სიმბოლოს თითო ხაზზე.
მანამდე მეორე წინ, ჩვენ გავაკეთეთ ამ მოედანზე bracket ნოტაცია.
გვსურს აქვს ამისთვის მარყუჟის და ჩვენ გვინდა გავაკეთოთ printf of s [i] და ჩვენ გვინდა გავაკეთოთ, რომ ისევ და ისევ და ისევ
ერთად backslash N დასასრულს თითოეული ხაზი.
მაგრამ ამ პროგრამის სხვადასხვა. ეს პროგრამა იყენებს, სიტყვასიტყვით, არითმეტიკული.
ასე რომ, რა ხდება აქ?
უპირველეს ყოვლისა, სანამ ამ loop კი ახორციელებს, რა, უბრალოდ უნდა იყოს მკაფიო, არის s რეალურად?
S არის? >> [სტუდენტი] მისამართზე. >> მისამართზე.
>> და ეს მისამართი, იმ შემთხვევაში, Hello, პირველი პერსონაჟი, რომ სიტყვა, რომელიც თ.
რათა არის, ამ კონკრეტულ მაგალითს, მისამართი თ.
ასე რომ რას ნიშნავს გავაკეთოთ s + მე?
ისე, მე იწყება 0 ამ for loop. ჩვენ გავაკეთეთ, რომ ბევრჯერ.
მე აპირებს ახვიდეთ სიგრძეზე სიმებიანი, როგორც ჩანს.
ამიტომ პირველ iteration ამ მარყუჟის, მე აშკარად 0.
ასე რომ, ეს გამოხატვის ამბობს s + i - საკმაოდ, S +0--რომ აშკარად უბრალოდ s.
რა არის * s აქ?
ახლა ჩვენ გამოყენებით ვარსკვლავს ოდნავ სხვაგვარად.
ნება მომეცით წავიდეთ წინ და დავაღწიოთ t რადგან ჩვენ გავაკეთეთ ვსაუბრობთ t და ასლები s.
ახლა ჩვენ უბრალოდ მინდა ვუთხრა ამბავი ჩართვის s.
და ა.შ. ამ ეტაპზე, მას შემდეგ, რაც ტიპის ტექსტი, ჩვენი სამყაროს გამოიყურება საკმაოდ მოსწონს ეს მოხდა ადრე
მხოლოდ s შენახვის მისამართი თ და ზოგადად მიუთითებს სიმებიანი hello.
თუ მე ახლა ხაზი მოსწონს * (s + I), მოდით ცდილობენ ამ გარეთ.
ასე * (s + I). ნება მომეცით გაამარტივებს ამ რადგან ეს არის 0, ასე რომ ეს არის * (ებ +0).
ისე, დაველოდოთ წუთში. გაამარტივონ შემდგომი. ეს არის * (s).
კარგად, ახლა ფრჩხილებში არიან სახის სულელური, ახლა მოდით უბრალოდ * s.
ამიტომ პირველ iteration ამ მარყუჟი, რომ ხაზი რომ გაუსვა ხაზი, 26,
არის საკმაოდ ბევრი ექვივალენტი ბეჭდვა ამ.
რა არის მონაცემები გაცნობის * s?
ამ კონტექსტში, რადგან ვარსკვლავი ხდება, რომ იყოს შემდეგი s თავად,
მაგრამ უფრო კონკრეტულად, რადგან ჩვენ აღარ გამოცხადების s,
ჩვენ არ შექმნის ცვლადი უქმნით არ ნახსენები char * სტრიქონში 26,
არ ნახსენები სიტყვით ტექსტი, ჩვენ უბრალოდ გამოყენებით ცვლადში s,
თურმე ახლა ვარსკვლავი ოდნავ განსხვავებული და, admittedly, დამაბნეველი მნიშვნელობა.
* S აქ ნიშნავს წასვლა მისამართი და ბეჭდვითი რაც არსებობს.
რათა აქ არის, * s არის - სახის მოსწონს Chutes და კიბეები, დაიცვას arrow - აქ.
ასე რომ, ეს არის * s.
>> მერე რა ხდება დაბეჭდილი პირველი iteration რომ მარყუჟი შეესაბამება 26?
მე ამობეჭდოთ% C, რომელიც placeholder for ხასიათი,
მაშინ \ n ახალი ხაზი. * (S + I), სადაც მე არის 0 მხოლოდ ამ.
მერე რა char შემიძლია ადგილი ამისთვის% გ? H.
მომდევნო iteration of loop - თქვენ ალბათ შეუძლია დაინახოს, სადაც ეს ხდება -
შემდეგი iteration მე აშკარად 1, ასე რომ, ეს იმას ნიშნავს s +1,
და მაშინ ახლა მე გვჭირდება ფრჩხილებში რადგან ახლა ვარსკვლავი სჭირდება ვთქვა
გადადით მეხსიერების მისამართი s +1.
რა არის s? მოდით გააფართოვოს უკან დრო და ამბობენ, რომ ეს arrow ახლა რეალურად არ აკეთებს us ნებისმიერი მომხრეა.
მოდით უფრო კონკრეტულად ვთქვა, რომ ეს შენახვის ნომერი 123
რადგან დაწყება ამ სიმებიანი Hello, ეს არის მისამართი 123, ეს 124 და სხვ.
ასე რომ მეორე iteration როდესაც მე ვამბობ, s +1 ასეთი ამბობდა 123 +1,
სხვაგვარად ცნობილია როგორც 124, ასე რომ char იღებს დაბეჭდილი მეორე iteration?
E საათზე მეხსიერების მისამართი 124.
მაშინ + ერთხელ, 125, 126, 127, და ამ loop საბედნიეროდ შეწყვეტს, სანამ არ მივიღებთ აქ
რადგან მე გამოყენებით strlen დავრწმუნდეთ, რომ მე არ ითვლიან ძალიან მაღალია.
ასე რომ ძალიან არის იგი.
ისევ და ისევ, ეს მხოლოდ თითქოს ჩვენ გავაკეთეთ კვირის წინ.
ნება მომეცით წერენ ეს ხაზი ქვემოთ მიუხედავად იმისა, რომ ჩვენ არ გვსურს რომ ორივე.
ეს არის იდენტური ახლა ამ.
>> ასე რომ მიუხედავად იმისა, რომ ჯერ არ არის ტექსტი, როგორც ჩვენ უწოდა კვირების განმავლობაში, და მართლაც char *.
ასე რომ, თუ ჩვენ გვინდა ვიყოთ super anal, ეს მართლაც სწორი დაწერა კონკრეტული ხასიათი
ზე შ საიდან გამოყენებით ამ რიცხვითი მისამართები და ამ ვარსკვლავი ოპერატორი,
მაგრამ გულწრფელად ვამბობ, ეს მხოლოდ იმდენად სუფთა. ასე რომ, ეს არ არის ცუდი.
არანაირი მიზეზი, რომ შეწყვიტოს აკეთებს ხაზი 27 აქ, მაგრამ 26 არის ფუნქციურად იგივე,
და ეს ფუნქციურად იგივე ზუსტად მიზეზებს, რომ ჩვენ განხილვას ჯერჯერობით.
და ბოლოს, 29 მხოლოდ კარგი პრაქტიკის.
Calling უფასო s ნიშნავს, რომ ახლა თქვენ იძლევიან მეხსიერების რომ GetString მისცა თქვენ
რადგან ერთხელ, როგორც აღვნიშნე ორშაბათი, GetString კვირების განმავლობაში
უკვე შემოღების bug თქვენს კოდი.
შენი კოდი კვირის განმავლობაში საკმაოდ მეხსიერების გაჟონვის
რომლითაც თქვენ უკვე სვამს GetString მეხსიერების მაგრამ თქვენ არასოდეს ვაძლევთ მას უკან.
და ეს შეგნებულად, ჩვენს მიერ არჩეული pedagogically
რადგან უბრალოდ ძალიან ბევრი ფიქრი დილით.
მაგრამ ახლა ჩვენ გვჭირდება მეტი სიმეტრია.
თუ ვთხოვ კომპიუტერში მეხსიერების, როგორც არის საქმე GetString,
როგორც არის საქმე როგორც ჩანს ამისთვის malloc,
თქვენ უნდა ამისთვის pset 4 Onward ასევე უფასოდ ნებისმიერი ასეთი მეხსიერება.
გაითვალისწინეთ ეს განსხვავდება ამბობდა int n.
თქვენ არ გჭირდებათ გასათავისუფლებლად, რადგან თქვენ არ გამოიძახა GetString
და თქვენ არ მოვუწოდებთ malloc.
>> და მაშინაც კი თუ თქვენ მოუწოდა GetInt როგორც ჩვენ საბოლოოდ ვხედავთ,
GetInt არ გამოყოს მეხსიერება თქვენთვის იმიტომ, რომ თქვენ შეიძლება რეალურად გაივლის გარშემო მთელი რიცხვები
და მოძრავი და სიმბოლო უბრალოდ გზა ჩვენ ვაკეთებთ კვირების განმავლობაში.
სიმები, თუმცა, განსაკუთრებული, რადგან რეალურად ისინი გაერთიანების მრავალჯერადი სიმბოლო.
ასე რომ, ისინი უბრალოდ განსხვავებული chars და მოძრავი და ints და ასე შემდეგ.
მაგრამ ამას დაბრუნებას, რომ ხანგრძლივი.
ნებისმიერი კითხვები მაშინ ამ დასაწყისში პოინტერები? Yeah.
[Inaudible სტუდენტი კითხვა]
Ah, ძალიან კარგი კითხვაა.
ერთი იმ რამდენიმე რამ C რეალურად აკეთებს თქვენთვის, რომელიც მოსახერხებელია,
იგი გათვლით out for, თუ რა ზომის არის მონაცემები ტიპის
და შემდეგ აკეთებს, რომ სახის გამრავლება თქვენთვის.
ეს არის შეუსაბამო იმ შემთხვევაში სიმბოლო, რადგან თითქმის ყოველთვის char არის 1 byte,
ასე რომ, ეს უბრალოდ მუშაობს.
მაგრამ გულისთვის დისკუსია, თუ თქვენ რეალურად დაბეჭდვის რიცხვებით
და თქვენ ცდილობდნენ ამობეჭდოთ გარკვეული მნიშვნელობა s, რომელიც მიუთითებს მთელი რიცხვი,
თქვენ ერთნაირად არ უნდა გავაკეთოთ + 4 * მე მხოლოდ იმიტომ, რომ int არის 4 ბაიტი.
Pointer არითმეტიკული ნიშნავს, რომ C და შემდგენელი ყველაფერი რომ მათემატიკის თქვენთვის.
ყველაფერი რაც თქვენ უნდა აღელვებს არის დათვლა წელს სახის ადამიანის გრძნობათა. Yeah.
[სტუდენტი] თუ განაცხადოს სიმებიანი შიგნით ამისთვის მარყუჟის, გაქვთ გასათავისუფლებლად მოგვიანებით?
კარგი კითხვაა.
>> თუ დეკლარირებული სიმებიანი შიგნით ამისთვის მარყუჟის, გჭირდებათ გასათავისუფლებლად მოგვიანებით?
თქვენ მხოლოდ უნდა თავისუფალი მეხსიერება, რომ თქვენ გამოყოფს ერთად GetString ან malloc.
ასე რომ, თუ თქვენ უბრალოდ ამბობენ რაღაც - ნება მიბოძეთ Curly braces არის, ასე რომ ყველა კოდი არის დაკავშირებული.
თუ თქვენ გააკეთეთ რამე, თუმცა buggily, ასე, char * t = s,
თქვენ არ გჭირდებათ თავისუფალი t რადგან t არ ჩავრთოთ ნებისმიერი ნახსენები malloc ან GetString.
თუ პირიქით გააკეთეთ თქვენ ამ, GetString, მაშინ დიახ, თქვენ უნდა უფასო ტ.
და რეალურად, თქვენი ერთადერთი შანსი გავაკეთოთ, რომ არის შიგნით ამ მარყუჟის, იმავე საკითხის ფარგლებს
რომ ჩვენ განიხილეს წარსულში.
წინააღმდეგ შემთხვევაში თქვენ მინდა იყოს გამოყოფის მეხსიერება, გამოყოფის მეხსიერება, გამოყოფის მეხსიერება,
და დასასრულს პროგრამა იმიტომ, რომ თქვენ გარეთ რომ მარყუჟი,
t არ არსებობს, მაგრამ თქვენ არ უთხრა ოპერაციული სისტემა
რომ თქვენ არ გვჭირდება, რომ მეხსიერების უქმნით.
მანამდე ხანგრძლივი, ამისთვის pset 4 ან 5 ჩვენ აღჭურვა თქვენ პროგრამას სახელწოდებით Valgrind,
რაც მსგავსი სულისკვეთებით უნდა GDB რომ ის მიიღო გარკვეულწილად of arcane ინტერფეისი,
მაგრამ მისი მიზანი ცხოვრებაში არის დაგეხმაროთ.
და Valgrind არის პროგრამა, რომელიც მომავალში ძებნის თქვენს პროგრამები
ეძებს მეხსიერების ტბები, თუ არა საწყისი GetString ან malloc,
რაც დავიწყებთ გამოყენებით უფრო როგორც ჩვენ შეწყვიტოს გამოყენებით CS50 ბიბლიოთეკა იმდენი.
ჩვენ საბოლოოდ ახლა სახის ლექსიკა და ერთგვარი ფსიქიკური მოდელის თეორია
რომელთანაც მოსაგვარებლად ამ გატეხილი პროგრამა.
>> ასე რომ ამ პროგრამის გატეხილი, swap მუშაობს შიგნით swap,
მაგრამ მას არასოდეს რეალურად მუშაობდა მთავარ რადგან ძირითად გადავიდა x და y, გაწვევას,
და იმ გადაეცა მიერ ღირებულებების, ასე ვთქვათ.
ასლები მათ გადაეცათ სვოპ.
ბოლოსთვის swap, და ბ იყო მართლაც გაცვალეს,
თუმცა, რა თქმა x და y, როგორც ჩვენ განვიხილეთ ორშაბათს, არ ყოფილა.
ამიტომ მე ვთავაზობ, მწვანე აქ რომ ეს რეალურად გადაწყვეტა აქ.
და ფაქტობრივად, ნება მომეცით გადაადგილება ჩემი ვარსკვლავს მხოლოდ იყოს თანმიმდევრული
მიუხედავად იმისა, კიდევ ერთხელ, ფუნქციურად ეს მნიშვნელობა არ აქვს.
მომავალში კვირის ჩვენ ავუხსნათ, თუ როდის და რატომ არ აქვს მნიშვნელობა.
ასე რომ, მწვანე ახლა არის გადაწყვეტა.
გულწრფელად ვამბობ, ეს გამოიყურება მთელი ლოტი messier რადგან ყველა ეს ვარსკვლავი.
ნება მომეცით აღვნიშნო, ერთი რამ.
ზედა ხაზი აქ, სადაც იგი აცხადებს, int * და int * ბ
ძირეულად აკეთებს იმავეს, როგორც ეს ყოველთვის აქვს.
იგი გამოცხადების 2 არგუმენტები ან პარამეტრების სვოპ,
პირველი რომლის int მაჩვენებელი მოუწოდა,
მეორე რომლის int მაჩვენებელი მოუწოდა ბ.
ერთადერთი, რაც არის ახალი ამ ეტაპზე არის ის, რომ იქ ვარსკვლავი არსებობს.
>> რას ნიშნავს ეს? არ არის int, ბ არ არის int.
არის მისამართი int და ბ არის მისამართი სხვადასხვა int.
Down აქ, ეს არის სადაც მე ვაღიარებ C იღებს დამაბნეველი.
ახლა ჩვენ გამოყენებით ვარსკვლავი, მაგრამ მას აქვს სხვადასხვა მნიშვნელობა მოცემულ კონტექსტში.
იმის გამო, რომ ჩვენ არ გამოცხადების პოინტერები როგორც ჩვენ აქ,
აქ ჩვენ dereferencing რამ.
ასე რომ ტექნიკურად, ვარსკვლავი ამ კონტექსტში პირველი, მეორე და მესამე ხაზის შიგნით swap
არის dereference ოპერატორი, რომელიც მხოლოდ იმას ნიშნავს, იქ.
ასე რომ ისევე როგორც ჩემი თითი მოჰყვა ისარი h,
* საშუალების წასვლა რომ მისამართი და იპოვოს ჩემთვის int რომ იქ.
* ბ საშუალებით წასვლა მისამართი და გაივლის რა არის იქ.
მოდით მეთოდით გადასინჯვის სურათზე ორშაბათიდან ახლა გამოყენებით დასტის ჩარჩოების,
ქვედა რომელთაგან ერთი იქნება ძირითადი,
ზედა რომელთაგან ერთი იქნება swap,
ასე რომ ჩვენი სამყაროს გამოიყურება, ისევე, ორშაბათს, მოსწონს ეს.
აქ არის ბლოკი მეხსიერება, რომ ძირითადი აპირებს გამოიყენოს.
>> შეგახსენებთ, ორშაბათიდან, რომ პროგრამა მხოლოდ ჰქონდა 2 ცვლადები,
ერთი მოუწოდა x და ერთი მოუწოდა Y, და მე დააყენა ციფრები 1 და 2 არსებობს.
ახლა, როდესაც მე მოვუწოდებ სვოპ მოსწონს მე ორშაბათს,
ადრე, როდესაც მე წითელი ვერსია ამ პროგრამის, რომელიც ასე გამოიყურება,
მე მივიღე 2 პარამეტრების, და B, და რა მივიღეთ წერენ აქ და აქ?
მხოლოდ 1 და 2, სიტყვასიტყვით ასლები x და y.
დღეს შევცვლით, რომ.
დღეს ნაცვლად გადადის ints და ბ ჩვენ ვაპირებთ კორიდორი 2 მისამართები.
იმ მისამართებზე მოხდეს აღვნიშნო, რომ ints, მაგრამ იმ მისამართებზე არ ints თავს.
ისინი მისამართები. ეს მოსწონს საფოსტო მისამართი ნაცვლად.
ახლა ჩვენ გვჭირდება უბრალოდ მივცეთ თავს ცოტა მეტი დეტალი ეკრანზე.
ეს არის ჩემი კომპიუტერის მეხსიერებაში, ეს იყო მთელი დღე.
ახლა ჩვენ გვჭირდება გარკვეული თვითნებური ნუმერაციის სქემა.
მოდით უბრალოდ, ვამბობთ, უბრალოდ შანსი, რომ ეს არის მეხსიერების მისამართი 123, 124.
მოდით უბრალოდ ვიტყვი, რომ ეს 125, ეს არის 126, და ა.შ., მაგრამ ეს სრულიად უკანონო.
ჩვენ უბრალოდ უნდა გარკვეული ნუმერაციის სქემა ჩემი მეხსიერება.
ასე რომ ახლა, როცა მე რეალურად კორიდორი x და y, მე არ ვაპირებ კორიდორი x და y;
მე ვაპირებ კორიდორი საფოსტო მისამართი, ასე ვთქვათ, X-ის და Y
ასე რომ, თუ რა ხდება აქ ინახება და აქ არ არის 1 და 2
მაგრამ თუ ხედავთ ჩემს პატარა ტექსტი, რა ხდება წელს მიღებული აქ და აქ?
[Inaudible სტუდენტი საპასუხოდ] >> ზუსტად. 123 იღებს დააყენა აქ და 124 იღებს დააყენა აქ.
>> ახლა, როდესაც მე ვარსკვლავი სწორედ ამ პირველი ხაზი გზა აქ ყველაზე,
ჩემი პროგრამა უბრალოდ იცის, რომ 123 და 124, მიუხედავად იმისა, რომ ისინი აშკარად რიცხვებით
რომ ნებისმიერი ადამიანის შეეძლო შეამჩნევთ, ისინი უნდა განიმარტოს, როგორც მისამართები, numeric მისამართები.
ისინი არ არიან და თავს ints, ისინი მისამართები,
და ეს იმიტომ, რომ მე არ მკაფიოდ დააყენა ვარსკვლავები არსებობს.
ახლა ჩემი პირველი, მეორე და მესამე ხაზის ფაქტობრივი კოდი რა ხდება აქ?
მოდით დავხატოთ დანარჩენი სურათზე.
TMP არის, ისევე, როგორც ეს იყო ორშაბათს. არაფერი სპეციალური შესახებ tmp.
ეს მხოლოდ ადგილობრივი 32 ბიტი ცვლადი, და შიგნით რომ მე აშკარად შენახვის ღირებულება *.
ახლა, თუ უბრალოდ თქვა tmp =, რა მე ზუსტად აქ? >> [სტუდენტი] 123.
123. მაგრამ ეს არ არის ის, რაც მე ვაკეთებ.
მე ვამბობ, tmp = *. Star საშუალებით წასასვლელად.
ასე რომ აქ არის, 123. როგორ შემიძლია იქ? იმიტირებული მოსწონს არსებობს arrow.
კარგად, იქ არის, 1. მერე რა იღებს შენახული tmp, სავარაუდოდ? მხოლოდ 1.
ასე რომ, სხვა სიტყვებით, tmp არის *, * საშუალებების წასვლა მისამართი, რომელიც ამჟამად,
რომელიც სავარაუდოდ 123.
>> Okay, აქ ჩვენ ვიმყოფებით საიდან 123, ვხედავ ნომერი 1,
ამიტომ მე ვაპირებ დააყენა ნომერი 1 იქ.
ახლა რა გავაკეთოთ ხაზი 2, * = * ბ?
ეს ერთი არის ცოტა უფრო ჩართული, ვინაიდან, ახლა, რა არის? ეს 123.
ასე * სადაც? უფლება, სადაც მე ვიყავი ადრე. ასე რომ იქ. Okay.
ახლა, ბოლოს, და მაშინ საბოლოოდ ამ დაიწყებს აზრი, იმედია,
* ბ ნიშნავს რა B? 124. ასე რომ უნდა წავიდეთ იქ, რომელიც 2.
რა შემიძლია დააყენა აქ?
2 გადადის აქ იმიტომ * ბ შედის *. ასე რომ, მე გავაკეთებ, რომ.
და შეგიძლიათ უკვე ვხედავთ, ალბათ, რომ ჩვენ კარგები უფრო ახლოს
გადაჭრას ეს სულელური, მარტივი პრობლემის სწორად პირველად
რადგან ახლა ჩვენ კვლავ უნდა მოგონებაა, თუ რა x იყო,
გვაქვს 2 ცალი, admittedly, რა Y,
მაგრამ ხაზი 3 ახლა ამბობს * ბ.
ასე რომ აქ ბ. * ბ საშუალებით წასასვლელად. ისე სად არის საიდან 124?
ეს აშკარად აქ. რა შემიძლია დააყენა აქ? ცხადია, tmp.
ასე რომ ახლა მე ამ. ასე მაქვს 1 აქ და 2 აქ.
და ახლა რაც შეეხება ყველა ამ, 123, 124, და 1?
როგორც კი swap ანაზღაურება, ამ მეხსიერების როგორც კარგი, როგორც დაკარგა
რადგან როგორც კი swap ანაზღაურება, ოპერაციული სისტემა
კი იყენებს, რომ მეხსიერების მომავალში თავიდან აცილება.
მხოლოდ ძირითადი ხსოვნას ბოლოში ამ ე.წ. დასტის ჩხირები ირგვლივ.
>> ასე რომ, ჩვენ საბოლოოდ აქვს ახლა სამუშაო ვერსია.
ნება მომეცით წასვლას swap.c და გავითვალისწინოთ შემდეგი.
ზედა პროგრამით მე შეიცვალა ჩემი პროტოტიპი იქნება int * და int * ბ.
ამიტომ ერთადერთი, რაც მე შეიცვალა წასვლა წითელი, რომელიც იყო ცუდი, მწვანე, რომელიც არის კარგი,
არის მე დასძინა ამ ვარსკვლავს დღეს.
მაგრამ შემდეგ ქვევით აქ სვოპ თავად მომიწია ასლი, პასტა, თუ რა იყო მხოლოდ slide.
მე ვარსკვლავი აქ, ვარსკვლავი აქ - რომ სიას პროტოტიპი -
და მაშინ ყველა ამ საკითხზე უკვე ვარსკვლავს გარდა tmp
რადგან გამოყენების დროებითი ცვლადი, არაფერი ახალი იქ.
მე უბრალოდ უნდა დროებითი შენახვისა და int.
ამიტომ, ჩვენ არ გვჭირდება ვარსკვლავი არსებობს.
ჩვენ უბრალოდ უნდა ვარსკვლავი ისე, რომ ჩვენ შეგვიძლია გადაკვეთს ამ სახის თვითნებური საზღვრის
შორის 2 ფარგლებში ჩემი კომპიუტერის მეხსიერებაში.
მაგრამ ერთი რამ ბოლო უნდა შეიცვალოს, და ალბათ glimpsed უკვე.
სხვა რა ხაზი აშკარად სხვადასხვა არის? >> [სტუდენტი] & x.
>> ჰო, ასე რომ 25 არის ბოლო ხაზი კოდი უნდა შეცვალოს ამ მუშაობას.
ერთი კვირის წინ და კიდევ ორშაბათს ხაზი 25 ჰგავდა ამ, სვოპ x და y,
და ეს მხოლოდ გატეხილი რადგან თუ ამბობთ swap (x, y)
თქვენ მიცემის ასლები x და y to სვოპ, მაშინ ის აკეთებს რამ,
მაგრამ თქვენ არასოდეს რეალურად შეცვლის x და y თავად.
ისე კი, თუ თქვენ არასოდეს მინახავს ეს პერსონაჟი სანამ ერთად ampersand კოდის,
უბრალოდ მიიღოს ამოიცნობთ. რას ampersand გავაკეთოთ, როგორც ჩანს?
[სტუდენტი] იღებს მისამართზე. >> იღებს მისამართზე.
ამიტომ ampersand ამბობს მომეცი მისამართი x.
ვინ იცის, სადაც ეს არის? ეს ხდება, რომ იყოს 123. არ მაინტერესებს. უბრალოდ მომეცი მისამართი x.
& Y ნიშნავს მომეცი მისამართი წ.
და იმ ეტაპზე ამბავი სავსებით შეესაბამება სურათზე ჩვენ გაამახვილა მომენტში წინ.
>> ასე რომ მე ვაღიარებ პოინტერები, რა თქმა უნდა, ჩემთვის, როცა მე პირველად დაიწყო სასწავლო ეს,
იყო ნამდვილად ერთი უმძიმესი რამ გადაიტანოთ ჩემი აზრით გარშემო.
მაგრამ გააცნობიეროს, განსაკუთრებით როგორც ჩვენ შევინარჩუნოთ თამაშობდა ასეთი რამ,
თუ დაარღვიოს მისი დანგრევა ამ სუპერ მარტივი სახის ინტელექტუალურად uninteresting პრობლემები
მხოლოდ მოძრავი ციფრები გარშემო, პასუხი ბევრი გაიგივება პოინტერები
მართლაც შეიძლება აღნიშნულიდან გამომდინარე ძალიან საბაზისო მექანიკა.
აქ მისამართზე. იქ ერთად ვარსკვლავი.
ან პირიქით, აქ ampersand. გაერკვნენ, რა მისამართზე რეალურად არის.
ყველა უფლება.
ისე სად არის ყველა ამ მეხსიერების მოდის?
ჩვენ შემუშავებული ამ სურათს რამდენჯერმე, და მე შენარჩუნება პერსპექტიული ჩვენ დავბრუნდებით კი
მაგრამ აქ არის წარმომადგენლობა თქვენი კომპიუტერის მეხსიერების
რომ ცოტა მეტი შეაფასა, ვიდრე ჩვენი chalkboard აქ არის.
ტექსტის სეგმენტის ზედა წარმოადგენს რა მიმართ თქვენი პროგრამა?
[Inaudible სტუდენტი საპასუხოდ] >> უკაცრავად? ვიმეორებ.
[სტუდენტი] ფაქტობრივი პროგრამა. >> ფაქტობრივი პროგრამა.
>> ამიტომ 0S და 1s, რომ თქვენ არ შედგენილი დაწერის შემდეგ C კოდი და შემდეგ გაშვებული Clang
და გამოიმუშავებს 0S და 1s მთავრდება მიღების tucked იქ მეხსიერება
რადგან, როდესაც თქვენ ორმაგად დაწკაპეთ ხატი თქვენს Mac ან PC
ან აწარმოებს ბრძანების მოსწონს mario თქვენს სწრაფი, თქვენი 0S და 1s საწყისი დისკზე
მისაღებად დატვირთული მეხსიერებაში ასე რომ კომპიუტერი შეიძლება მანიპულირება მათ
და შეასრულოს ისინი უფრო სწრაფად.
ასე რომ ინიციალიზაცია მონაცემები და uninitialized მონაცემები, ჩვენ არ გაიგო, თუ იმ,
მაგრამ იმ უბრალოდ გლობალური ცვლადები.
ინიციალიზაცია ნიშნავს გლობალური ცვლადები, რომ თქვენ მისცა ფასეულობები;
uninitialized ნიშნავს გლობალური ცვლადები, რომ თქვენ არ გაუკეთებია მისცეს ფასეულობები.
მაშინ არსებობს ამ გარემოს ცვლადები რომელიც მე სრულიად ტალღის ჩემი ხელი,
მაგრამ ისინი იქ და რომ მაღაზიებში რამ, როგორიცაა თქვენი სახელი
და სხვა სახის ქვედა დონეზე დეტალები.
მაგრამ juiciest ცალი მეხსიერების ს განლაგება არის ეს საგანი მოუწოდა დასტის და ბევრი.
დასტის ერთხელ, უნდა იყოს ნათელი, არის მეხსიერების რომ გამოიყენება, როდესაც ფუნქციები მოუწოდა,
როდესაც არსებობს ადგილობრივი ცვლადები
და მაშინ, როდესაც არსებობს პარამეტრების მიმდინარეობს გავიდა გარშემო.
ყველა რომ ხდება Stack.
ბევრი არ გვაქვს ისაუბრა, მაგრამ მიიღოს ვინ იყენებს ბევრი.
უბრალოდ სხვადასხვა ბლოკი მეხსიერება.
ეს ხდება, რომ იყოს აქ ზედა, მაგრამ ეს თვითნებური ფერწერული კონვენციას.
ვინ აშკარად იყენებს მეხსიერების საწყისი ბევრი კვირების განმავლობაში?
ეს ტექნიკურად, მაგრამ არაპირდაპირ. >> [სტუდენტი] GetString.
GetString და malloc. ასე რომ აქ ფუნდამენტური განსხვავება.
>> თქვენ იცით, რომ ბოლო რამდენიმე კვირის განმავლობაში, რომ თუ საჭიროა მეხსიერების, უბრალოდ განაცხადოს ცვლადი.
თუ თქვენ გჭირდებათ უამრავი მეხსიერება, განაცხადოს მასივი უფლება შიგნით თქვენი ფუნქცია.
მაგრამ პრობლემა ჩვენ წინაშე დგას ინახება არის თუ განაცხადოს ცვლადები ადგილობრივად შიგნით ფუნქციების,
როგორც კი ფუნქცია დააბრუნებს, რა მოხდება ხსოვნას და იმ ცვლადების?
უბრალოდ სახის ეს აღარ შენია, არა? უბრალოდ ქრება სახის კონცეპტუალურად.
ეს ჯერ კიდევ ფიზიკურად არ არსებობს, ბუნებრივია, მაგრამ ეს უკვე აღარ თქვენი გამოყენების უფლება.
ეს არის აშკარად პრობლემატური თუ გსურთ დაწეროთ ფუნქციების ცხოვრებაში
რომ რეალურად გამოყოს მეხსიერება და არ აძლევენ უკან დაუყოვნებლივ.
მაგალითია: GetString მიზანი ცხოვრებაში არის არ ვიცი წინასწარ
როგორ დიდი სიმებიანი მე ვაპირებ აკრიფეთ კლავიატურაზე,
მაგრამ რაღაც უნდა იყოს შეუძლია გამოყოს მეხსიერება გამართავს დავით ან მიესალმები
ან მთელი ესსე, რომ მომხმარებლის შესაძლოა აკრეფილი შემოსული
ამიტომ GetString უკვე გამოყენებით malloc.
Malloc ამიტომ უნდა გამოყენებით არ დასტის;
ნაცვლად ის იყენებს ამ რამ მოუწოდა ბევრი.
არაფერია განსხვავდება მეხსიერება. ეს არ არის სწრაფად ან ნელა ან არაფერი რომ.
უბრალოდ ფიზიკურად სხვადასხვა ადგილას.
>> მაგრამ წესი არის ის, რომ მეხსიერების რომ გამოყოფილი ბევრი
არასოდეს არ იქნება წაართვეს თქვენ სანამ რეკავთ - Take ამოიცნობთ - უფასო.
პირიქით, ნებისმიერი მეხსიერების თქვენ საჭიროა დასტის მხოლოდ გამოცხადების მასივი
ან გამოცხადების ცვლადი როგორიც ჩვენ აკეთებს კვირის განმავლობაში,
რომ იყოს მთავრდება on Stack.
და რომ მუშაობს დიდი 90%, მაგრამ იმ rarer შემთხვევები
სადაც გსურთ გამოყოს მეხსიერება და შეინახოს იგი დაახლოებით,
მაშინ თქვენ უნდა გამოვიყენოთ ფუნქცია, როგორიცაა malloc.
ან ჩვენ არ გამოიყენება ფუნქცია, როგორიცაა GetString, რაც თავის მხრივ იყენებს malloc.
ვნახოთ, სადაც ეს შეიძლება ჩაიშალოს და შემდეგ მიიღოს peek at Binky.
ჩვენ დაბრუნდება, რომ მომავალში.
აქ არის სუპერ მარტივი პროგრამა, რომელიც პირველ 2 ხაზი აკეთებს იმას?
ინგლისურ, რას ეს პირველი 2 ხაზი კოდი გავაკეთოთ შიგნით ძირითადი?
[Inaudible სტუდენტი საპასუხოდ]
ფრთხილად. ეს არ მაძლევს მისამართი x ან y.
[სტუდენტი] აძლევს მითითებას ints. >> კარგი. მომეცი 2 მითითებას რიცხვებით.
სხვა სიტყვებით, მომეცი 2 მოცულობით მეხსიერების რომ მე შენარჩუნება ნახაზი დღეს,
მიუხედავად იმისა, რომ მე წაშლილია ახლა, როგორც სკვერები.
მომეცი 2 მოცულობით მეხსიერება, ერთი მოუწოდა x, ერთი მოუწოდა Y -
ადრე დავურეკე მათ და T - და რა არის გაცნობის რომ ბლოკი მეხსიერება?
იგი აპირებს შესანახად მისამართზე.
ეს ტიპის int *.
>> ასე რომ მისამართი int საბოლოოდ ცხოვრობს x,
მისამართი int საბოლოოდ ცხოვრობს Y,
მაგრამ თავდაპირველად, რა შიგნით x და y? ვინ იცის? Garbage ღირებულებებს.
მას არაფერი აქვს საერთო პოინტერები.
თუ ჩვენ არ დააყენა რაღაც არსებობს, რომელმაც იცის რა არის რეალურად არსებობს?
ახლა x. რა ხდება აქ? ეს არის legit, რადგან X-ის მაჩვენებელი. ეს int *.
ასე რომ, რაც იმას ნიშნავს, შემიძლია დააყენა x მისამართი ზოგიერთი ბლოკი მეხსიერება.
რას malloc დაბრუნებას? სრულყოფილი, ის დააბრუნებს მისამართები,
მისამართი პირველი byte წელს მთელი ბლოკი მეხსიერება.
რამდენი ბაიტი ეს აშკარად გამოყოფის, მაგალითად, ელექტრო?
რა ზომის int? 4.
თუ ფიქრობთ თავში კვირაში 1, ეს არ super მნიშვნელოვანია ყოველთვის გვახსოვდეს, რომ,
მაგრამ ამ შემთხვევაში ეს სასარგებლო იცოდეს, 4 ბაიტი.
ასე რომ, ეს გამოყოფის თაობაზე ბევრი 4 ბაიტი
და ეს დაბრუნების მისამართი პირველი ჩემთვის თვითნებურად.
ახლა, რა არის x აკეთებთ?
* X = 42 აკეთებს რა?
თუ ამ დროისთვის ამბავი გვაქვს x, რომელიც ასე გამოიყურება რამდენიმე ნაგვის ღირებულება,
ამ არის Y ზოგიერთ ნაგვის ღირებულება, ახლა ხაზი 3 მე გამოყოფილი 4 ბაიტი.
ეს სურათი არსებითად ასე გამოიყურება.
ან უფრო კონკრეტულად, თუ ეს თვითნებური მისამართი 123, ეს არის ის, რაც ჩვენი ამბავი ახლა ჰგავს.
* X = 42 ახლა ნიშნავს რა? ეს იმას ნიშნავს, გადადით მისამართზე 123 და ამით ხმების 42 იქ.
მე არ უნდა მიაპყროს ამ ხაზების რადგან ჩვენ არ ვაკეთებთ სტრიქონები.
>> მე უნდა მხოლოდ წერილობითი მას მოსწონს, და მხოლოდ სადემონსტრაციოდ ის გულისთვის,
42 როგორც int ტიპის იკავებს დიდი ადგილი, 4 ბაიტი.
ასე რომ, რა მოხდა იქ, მაგრამ პრობლემა არის.
* Y = 13. რა მოხდება აქ?
პრობლემა ის არის, * Y ჩვენს გამარტივებული მსოფლიოს მხოლოდ იმას ნიშნავს, გადადით მისამართზე წ.
რა Y? ეს რაღაც ნაგავი ღირებულება.
მოდით ვივარაუდოთ, რომ ნაგვის ღირებულება შეადგენს 5551212, რაღაც გიჟური იგრძნობა.
* Y საშუალებით წასვლა მივმართო 5551212.
ასეთი მეტი აქ. ის არ არსებობს, მაგალითად.
ასე * Y იღებს 13 საშუალებებით ვცდილობ გავამახვილო 13 აქ. ის არ არსებობს.
მე გადააჭარბა სეგმენტი დაფაზე. რა მივიღო?
რომ cryptic გაგზავნა სეგმენტაცია ბრალია, რადგან ვცდილობ დასვა მეხსიერება
ღირებულება მოსწონს 13 ადგილზე რომ არ არსებობს.
დანარჩენი პროგრამა შესაძლოა მუშაობა okay, მაგრამ მანამდე ეს არ.
მოდით ცდილობენ ვუთხრა ეს ამბავი.
ჩვენ დავბრუნდებით რომ ერთხელ ჩვენ ვისაუბრეთ hex.
მოდით დავუბრუნდეთ ამ და დადოს ამ რამ მოუწოდა Binky,
რომელიც გაწვევას არის სტენფორდის პროფესორი ზის სახლში თამაშობდა claymation,
ვუთხრა ამბავი ზუსტად რომ იმავე პროგრამით.
უბრალოდ დაახლოებით 3 წუთის განმავლობაში. აქ Binky.
[კაცი პარლამენტის თავმჯდომარესთან video] Hey Binky, ვიღვიძებ. დროა მაჩვენებელი გართობა.
[Binky] რა არის რომ? ბუნებაში პოინტერები? ოჰ, GOODY!
[კაცი სპიკერი] ისე, უნდა დავიწყოთ, ვფიქრობ ჩვენ ვაპირებთ გვჭირდება რამდენიმე მითითებას.
>> [Binky] Okay. ეს კოდი გამოყოფს 2 პოინტერები რომელიც შეიძლება აღვნიშნო, რომ რიცხვებით.
[კაცი სპიკერი] Okay. ისე, მე ვხედავ 2 პოინტერები, მაგრამ ისინი არ ჩანს, მიუთითებს არაფერი.
[Binky] სწორედ უფლება. თავდაპირველად, პოინტერები არ აღვნიშნო, რომ არაფერს.
რამ მათ აღვნიშნო, რომ უწოდებენ pointees და ხუფებით დახურეს არის ცალკე ნაბიჯი.
[კაცი სპიკერი] Oh, უფლება, უფლება. ვიცოდი, რომ. Pointees განცალკევებული.
Er, ასე როგორ გამოყოფს pointee?
[Binky] Okay. ეს კოდი გამოყოფს ახალი რიცხვი pointee, და ეს ნაწილი ადგენს x აღვნიშნო მას.
[კაცი სპიკერი] Hey, რომ უკეთესია.
ასე რომ ეს რაღაც. >> [Binky] Okay.
მე dereference კურსორი x შესანახად ხმების 42 მის pointee.
ამ შეასრულა მე დაგჭირდებათ ჩემი ჯადოსნური ჯოხი of dereferencing.
[კაცი სპიკერი] შენი ჯადოსნური ჯოხი of dereferencing? სწორედ დიდი.
[Binky] ეს არის ის, რაც კოდი ჰგავს. მე უბრალოდ შეიქმნა ნომერი და ... [Popping sound]
[კაცი სპიკერი] Hey გამოიყურება, იქ მიდის.
ამით dereference on x შემდეგნაირად arrow წვდომისათვის მისი pointee,
ამ შემთხვევაში შესანახად 42 იქ.
Hey, სცადეთ ეს შესანახად ნომერი 13 გზით სხვა მაჩვენებელი, Y.
[Binky] Okay. მე უბრალოდ მეტი აქ Y და მიიღეთ ხმების 13 შეიქმნა
და შემდეგ მიიღოს კვერთხის of dereferencing და მხოლოდ ... [Buzzing sound] Whoa!
[კაცი სპიკერი] Oh hey, რომ არ მუშაობდა.
>> ამბობენ, Binky, არა მგონია, dereferencing Y არის კარგი იდეა
რადგან შექმნის pointee არის ცალკე ნაბიჯი
და არა მგონია, ჩვენ ოდესმე ეს.
[Binky] Hmm, კარგი წერტილი.
[კაცი სპიკერი] Yeah. ჩვენ გამოყოფილი მაჩვენებელი y მაგრამ ჩვენ არასოდეს ვაყენებთ მას აღვნიშნო, რომ pointee.
[Binky] Hmm, ძალიან დაკვირვებათა.
[კაცი სპიკერი] Hey, თქვენ ეძებთ კარგი იქ, Binky.
შეგიძლიათ დაფიქსირება ისე, რომ Y რაოდენობა იმავე pointee როგორც x? >> [Binky] რა თქმა უნდა.
მე გამოიყენოთ ჩემი ჯადოსნური ჯოხი of მაჩვენებელი საბუთი.
[კაცი სპიკერი] ის არის, რომ იქნება პრობლემა, როგორიცაა წინაშე?
[Binky] არა, ეს არ შეეხოთ pointees.
უბრალოდ ცვლის ერთ მომცეთ აღვნიშნო, რომ იგივე რამ, როგორც სხვა. [Popping sound]
[კაცი სპიკერი] Oh, ვხედავ. ახლა Y რაოდენობა იმავე ადგილას, როგორც x.
ასე რომ დაველოდოთ. ახლა Y დაფიქსირდა. მას აქვს pointee.
ასე, რომ თქვენ შეგიძლიათ სცადოთ კვერთხის of dereferencing კვლავ გამოაგზავნოს 13 დასრულდა.
[Binky] Uh, okay. აქ გადის. [Popping sound]
[კაცი სპიკერი] Hey, შევხედოთ, რომ. ახლა dereferencing სამუშაოები წ.
და რადგან მითითებები გაზიარებას, რომ ერთი pointee, ორივე ვხედავთ 13.
[Binky] ჰო, გაზიარება. როგორიც არ უნდა იყოს.
>> აქედან გამომდინარე, ჩვენ ვაპირებთ გადართვის ადგილებში ახლა?
[კაცი სპიკერი] Oh look, ჩვენ გარეთ დრო. >> [Binky] მაგრამ -
[კაცი სპიკერი] აბა გაიხსენეთ 3 კურსორი წესები.
ხმების 1, ძირითადი სტრუქტურა არის ის, რომ თქვენ გაქვთ მაჩვენებელი და ეს მიუთითებს იმ pointee.
მაგრამ კურსორი და pointee არიან ცალკე და საერთო შეცდომა შექმნას მაჩვენებელი
მაგრამ დავიწყება მისცეს მას pointee.
ხმების 2, კურსორი dereferencing იწყება კურსორი და შეასრულებს arrow მეტი
წვდომისათვის მისი pointee.
როგორც ვიცით, მუშაობს მხოლოდ მაშინ თუ არსებობს pointee,
რაც სახის იღებს თავში გამორიცხავს ნომერი 1.
ხმების 3, კურსორი დავალება იღებს ერთ კურსორი და ცვლის მას
უნდა აღვნიშნო, რომ იგივე pointee მორიგ მაჩვენებელი.
ამიტომ მას შემდეგ, რაც დავალება, 2 პოინტერები იქნება აღვნიშნო, რომ იგივე pointee.
ზოგჯერ, რომ ე.წ. გაზიარების.
>> და ეს ყველაფერი არსებობს, რათა ის რეალურად. Bye-bye არის.
ეს არის Binky. ეს არის CS50. ჩვენ დავინახავთ, თქვენ მომავალ კვირას. [ტაში]
>> [CS50.TV]