>> [მუსიკის დაკვრა]
დევიდ ჯ Malan: ყველა უფლება.
ეს არის CS50, და ეს ბოლოს კვირა ოთხი.
და ერთი თემა დღეს ის არის, რომ ციფრული სასამართლო ექსპერტიზის,
ხელოვნების ანაზღაურების ინფორმაციას.
და მართლაც, მიუხედავად იმისა, თქვენ შუაგულში
ახლა მშვიდობის სამ და Breakout, მომავალ კვირას,
აქცენტი იქნება ზუსტად ამ სფეროში.
>> ასე რომ, ერთი coolest სამუშაო მე ოდესმე ის იყო, უკან ასპირანტურაში,
როდესაც მე მუშაობა ადგილობრივი MIDDLESEX ქვეყნის რაიონული ადვოკატმა
ოფისი, აკეთებს ექსპერტიზის მუშაობა.
ასე რომ, არსებითად, Massachusetts სახელმწიფო პოლიციის, ხანდახან,
როდესაც მუშაობა შემთხვევებში იქნებოდა რათა რამ, როგორიცაა მყარი დისკები
და ფლოპი დისკები და ბარათები და ასე შემდეგ.
და ისინი გადასცემს მე და ჩემი მენტორი,
და ჩვენი მიზანი იყო, რომ მტკიცებულება, იყო თუ არა, ამ მედიაში.
ახლა, თქვენ შეიძლება არ მინახავს glimpses ამ სამყაროში კრიმინალისტთა
მედია, ტელე და ფილმები.
მაგრამ სამუშაო არ მქონდა და daresay, რომ მსოფლიოში,
არ არის საკმაოდ, როგორც თქვენ მისი დანახვა.
მოდით შევხედოთ, თუ რა თქვენ ალბათ მინახავს.
[ვიდეო აღწარმოების]
-OK.
ახლა, მოდით, კარგი შევხედოთ თქვენ.
>> [მუსიკის დაკვრა]
>> -Hold იგი.
აწარმოებს, რომ უკან.
>> -Wait წუთი.
წავიდეთ უფლება.
მიზნით,.
გაყინვას, რომ.
-Full ეკრანზე.
>> -OK.
გაყინვას, რომ.
-Tighten Up on რომ, იქნება თქვენ?
>> -Vector წელს, რომ ბიჭი, რომელსაც უკანა წამყვანი.
>> -Zoom უფლება აქ, ამ ადგილას.
>> გამოიძიე უფლება აღჭურვილობა, გამოსახულება შეიძლება გაიზარდოს და კიდევ უფრო.
>> რა არის ეს?
>> -ეს გაფართოება პროგრამა.
>> იქნებ ნათელია, რომ up რაიმე?
>> მე არ ვიცი.
მოდით გაზრდის.
>> -Enhance განყოფილება A6.
I გაუმჯობესებულია დეტალურად and--
მე ვფიქრობ, რომ არსებობს საკმარისი იმისათვის, რომ გაზარდოს.
გათავისუფლების ეს ჩემი ეკრანზე.
>> მე გაუმჯობესებულია ასახვა მისი თვალი.
-Let აწარმოებს ამ გზით ვიდეო გაფართოება.
>> -Edgar, შეგიძლიათ გაზარდოს ეს?
>> -Hang შესახებ.
>> -I've მუშაობენ ამ ასახვა.
>> მიზნით, ის ვიღაცის ასახვა.
>> -Reflection.
-არის ასახვა ადამიანის სახე.
>> ანუ ასახვა?
მიზნით, ასახვა.
-Zoom წელს სარკეში.
თქვენ ხედავთ, ასახვა.
>> იქნებ აძლიერებს იმიჯი აქ?
იქნებ გაზრდის?
-შეიძლება ჩვენ გააძლიეროს ეს?
იქნებ გაზრდის?
-Hold მეორე.
მე გაღრმავებას.
-Zoom In კარზე.
ჯერ უფრო 10.
-Zoom.
-MOVE In.
-იმაზე.
-Wait, შეწყვიტოს.
-Stop.
-Pause იგი.
-როტაცია Us 75 გრადუსი გარშემო ვერტიკალური, გთხოვთ.
>> -Stop.
დავუბრუნდეთ ნაწილი კართან ერთხელ.
>> -Got იმიჯი Enhancer, რომელიც შეიძლება bitmap?
>> -Maybe ჩვენ შეგვიძლია გამოვიყენოთ Pradeep Singh საშუალებას ვხედავ შევიდა ფანჯრები.
>> ანუ პროგრამა არის დონით.
>> ანუ eigenvalue გამორთულია.
>> გამოიძიე უფლება კომბინაცია ალგორითმები
>> დიაგნოზი დაუსვეს მიერ მიღებული განათება ალგორითმები, რათა მომდევნო დონეზე,
და მე შეიძლება მათი გამოყენება აძლიერებს ამ ფოტოს.
>> -Lock On და გაფართოების z ღერძი.
>> -Enhance.
გაზარდოს.
-Enhance.
-Freeze და აძლიერებს.
[END ვიდეო აღწარმოების]
დევიდ ჯ Malan: ასე რომ ეს ყველა სიტყვა, მაგრამ ისინი არ იყვნენ
გამოიყენება სასჯელს სწორად.
და მართლაც, რომ მომავალში, ნებისმიერ დროს, გთხოვთ, გესმით ვინმეს ამბობენ, რომ სიტყვა,
"ამაღლება" chuckle უბრალოდ ცოტა.
რადგან, როდესაც თქვენ ცდილობენ გააძლიერონ, მაგალითად, ეს არის ის, რაც ხდება.
>> ასე რომ აქ gorgeous photo.
ეს არის CS50 საკუთარი Daven.
და ვფიქრობ, რომ ჩვენ გვინდოდა ფოკუსირება წელს twinkle მისი თვალი,
ან ასახვა ცუდი ბიჭი, რომელიც აშკარად
მიტაცებული უსაფრთხოების კამერა.
ეს არის ის, რაც ხდება, როდესაც თქვენ მიუახლოვდით, რომ გამოსახულება
მხოლოდ სასრულ ნომერი ბიტი მასთან.
>> რომ არის, რას დაიჭერს.
და მართლაც, Daven თვალი არის, მაგრამ ოთხი, შესაძლოა, ექვსი pixels
რომ დაკომპლექტებას ზუსტად რა იყო ჟუჟუნა არსებობს.
ასე რომ, პრობლემა მითითებული ოთხი საბოლოოდ თქვენ შეისწავლონ ამ სამყაროში, განსაკუთრებით
ბუნების რაღაც ჩვენ მოვუწოდებთ ფაილის I / O, სადაც
i / o მხოლოდ ლამაზი გზა განაცხადა, რომ შემავალი და გამომავალი.
>> ასე რომ, ჯერჯერობით, ყველა ურთიერთქმედების ჩვენ გვქონდა კომპიუტერი
დიდწილად თქვენი კლავიატურა და ეკრანი,
მაგრამ არა იმდენად ხისტი, ან გადარჩენის ფაილი მიღმა პირობა
თავს წერენ.
თქვენი პროგრამების დღემდე არ ქმნის, და გადარჩენის,
და განახლება საკუთარ ფაილი.
>> ისე, რა ფაილი?
ისე, რაღაც JPEG.
ეს არის იმიჯი ალბათ აქვს ან ატვირთოს Facebook,
ან ვხედავ სადმე ინტერნეტში.
მართლაც, რომ სურათი, ჩვენ მხოლოდ ხერხი of Daven იყო JPEG.
და რა არის საინტერესო ფაილი, როგორიცაა JPEGs
არის ის, რომ შესაძლებელია მისი იდენტიფიცირება როგორც წესი, გარკვეული ნიმუში ბიტი.
>> სხვა სიტყვებით რომ ვთქვათ, არის ის, რომ განასხვავებს JPEG საწყისი GIF
საწყისი PING საწყისი სიტყვა დოკუმენტის Excel ფაილი?
ისე, ეს მხოლოდ სხვადასხვა ნიმუში ბიტი.
და იმ სხვადასხვა ნიმუშებია როგორც წესი, დასაწყისში იმ ფაილებს.
>> ასე რომ, როდესაც თქვენი კომპიუტერი ხსნის Word doc, ან მაშინ, როცა კომპიუტერი ხსნის JPEG,
ეს გამოიყურება, როგორც წესი, პირველი რამდენიმე ბიტი ფაილში.
და თუ ის აღიარებს, ნიმუში, ის ამბობს, ო, ეს არის იმიჯი.
მიადევნე თვალი ცარიელია მას მომხმარებლის გრაფიკული.
ან, oh, ეს ჰგავს Word doc.
მიადევნე თვალი აჩვენებს, რომ მომხმარებელს, როგორც ესსე.
>> ასე მაგალითად, JPEGs, გამოდის, რომ არის
საკმაოდ დახვეწილი ქვევმოთ hood.
მაგრამ პირველი სამი ბაიტი უმეტეს ყოველ JPEG იწყება ამ სამი ნომრები.
ასე რომ byte ნულოვანი, ერთი, და ორი არიან, ყველაზე ყველა JPEG, 255, შემდეგ ნომერი
216, მაშინ ნომერი 255.
>> და რა თქვენ გექნებათ უნდა დაიწყოს ამით მომავალ კვირას
რეალურად გააღიზიანოს ქვეშ hood ფაილი როგორიცაა JPEGs
და როგორც bitmap ფაილი და ხედავს, რა ყოველთვის არსებობს მანამ,
როგორც თქვენ უკვე გამოყენებით კომპიუტერი.
>> მაგრამ რა არის არ არის, როგორც წესი, იწერებოდეს ათობითი ნომრები მოსწონს ეს.
კომპიუტერული მეცნიერები არ ტენდენცია საუბარი ათობითი.
ისინი ნამდვილად არ არის საუბარი ორობითი.
როგორც წესი, როდესაც გვინდა, გამოხატოს ნომრები,
რეალურად გამოვიყენოთ თექვსმეტობითი, რომელიც თქვენ შეიძლება გავიხსენოთ
, ვთქვათ, პრობლემა Set ერთი, რომელიც დაუპირისპირდა
თქვენ უნდა ვიფიქროთ იმაზე, სხვადასხვა სისტემის.
>> ჩვენ, რა თქმა უნდა, იცის ერთად ათობითი, ნულოვანი მეშვეობით ცხრა.
ჩვენ ვისაუბრეთ ორობითი.
და ჩვენ ნამდვილად არა აქვს უნდა გამოვიყენოთ, რომ ბევრი აქ
on, იმიტომ, რომ კომპიუტერი გამოვიყენოთ რომ.
მაგრამ პროგრამისტები კი ძალიან ხშირად, მაგრამ არა ყოველთვის,
გამოყენება თექვსმეტობითი, რომელიც მხოლოდ იმას ნიშნავს, თქვენ გაქვთ 16 ასოების ანბანი,
ნაცვლად ორი ან 10.
>> ასე რომ, როგორ ითვლიან უმაღლესი ცხრა თექვსმეტობითი?
მიდიხარ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, მხოლოდ კონვენციას.
მაგრამ რა არის გასაღები, რომ თითოეული ეს არის ერთი სიმბოლო.
არ არსებობს 10.
არსებობს 11, თავისთავად, იმიტომ, რომ თითოეული თქვენი ციფრები, ისევე, როგორც ათობითი
და ისევე, როგორც ორობითი, უნდა მხოლოდ იქნება ერთი ხასიათი, კონვენციას.
>> ასე რომ მაშინ არის ანბანი გვაქვს ჩვენს ხელთ ამისთვის თექვსმეტობითი.
რას JPEG გამოიყურება ასე, თუ თქვენ დაწერა იმ პირველი სამი
ბაიტი არ როგორც ათობითი მაგრამ, მაგალითად, როგორც თექვსმეტობითი?
და რატომ არის hex ყველაფერს, რაც სასარგებლოა?
>> ასევე, სწრაფი შევხედოთ მაგალითს.
ასე რომ, თუ წერენ, რომ ბიტი, წარმოადგენს ამ ათობითი ნომრები
ეს შეიძლება იყოს პატარა დაჟანგული ახლა რამდენიმე კვირის უკან,
მაგრამ მარცხენა და უფლება ერთი საკმაოდ მარტივია.
255 ყველაზე დიდი რაოდენობის ჩვენ შეიძლება წარმოადგენს რვა ბიტი.
ეს იყო ყველა პირობა.
ასე რომ, მხოლოდ ერთი, რომ რბილად საინტერესო ის არის, შუა ერთი.
და თუ ასეთი გავაკეთებთ მათემატიკის, თქვენ დავასკვნათ, რომ, მართლაც,
რომ ნიმუში ერთი და zeros წარმოადგენს 216.
მოდით უბრალოდ ითვალისწინებს ახლა, რომ ეს არის სწორი.
მაგრამ რატომ არის ეს საინტერესო?
>> ასევე, byte, რა თქმა უნდა, არის რვა ბიტი.
და აღმოჩნდება, რომ თუ თქვენ ფიქრობთ ერთი byte როგორც ორი მოცულობით ოთხი ბიტი,
მოსწონს ეს.
ნება მომეცით უბრალოდ დაამატოთ გარკვეული სივრცე.
ასე რომ, სანამ მას შემდეგ, რაც.
მე უბრალოდ დასძინა ზოგიერთი თეთრი სივრცე ვიზუალიზაცია გულისთვის აქ.
როგორ შეიძლება ჩვენ ახლა წარმოადგენენ, ვთქვათ, თექვსმეტობითი ყოველი quad ბიტი,
თითოეული კომპლექტი ოთხი ბიტი?
>> ასე მაგალითად, მარცხენა ახლა, ჩვენ გვაქვს 1111 წელს ორობითი.
რა არის ეს ნომერი ათობითი, თუ გარეთ მათემატიკის?
თქვენ უნდა პირობა ადგილი, twos ადგილი, ოთხივე ადგილი, და მერვე ადგილი.
>> აუდიტორია: 15.
დევიდ ჯ Malan: ეს 15.
ასე რომ, თუ ჩვენ გავაკეთებთ რვა პლუს ოთხი პლუს ორი პლუს ერთი, მივიღებთ 15.
ასე რომ მე ვერ დაწერეთ 15 ქვემოთ 1111, არამედ მთელი საქმე აქ
არის თექვსმეტობითი, არ ათობითი.
ასე რომ ნაცვლად წერა ქვემოთ 15, 1-5, მე ვაპირებ წერენ, რომ hex,
რომელიც, თუ თქვენ ფიქრობთ, თუ თქვენ გაქვთ ნულოვანი მეშვეობით f, რა არის 15 იქნება?
აუდიტორია: ვ.
დევიდ ჯ Malan: ასე რომ, აღმოჩნდება, რომ ეს ის F.
და შეგიძლიათ მუშაობა, რომ, სწორედ ამაზე კარგად, თუ არის 10, მაშინ OK, f არის 15.
ასე რომ, რა თქმა უნდა, ჩვენ ვერ გადაწერა ეს იგივე კომპლექტი ნომრები f f.
და შემდეგ, თუ ჩვენ ცოტა მათემატიკის, ჩვენ დავასკვნათ, რომ სწორედ დ.
რვა საკმაოდ მარტივია, რადგან ჩვენ გაქვთ ერთი მერვე ადგილი.
და მაშინ, ჩვენ გვაქვს რამდენიმე f f ს.
>> ასე რომ, რასაც ადამიანები, როგორც წესი, ამის გაკეთება კონვენციის როდესაც ისინი თექვსმეტობითი არის, რომ ისინი უბრალოდ
წერენ რომ ეს ცოტა უფრო მოკლედ, მოშორება ყველაზე მეტად, რომ თეთრი სივრცე.
და მხოლოდ სუპერ ნათელი მკითხველს, რომ ეს არის თექვსმეტობითი,
მარტივი კონვენციის შორის ადამიანებში წერთ zero
x, რომელსაც არ აქვს მნიშვნელობა სხვა ვიდრე ვიზუალური იდენტიფიკატორი,
აქ მოდის hex ნომერი.
>> და შემდეგ, თქვენ დააყენა ორი ციფრი, f f ამ შემთხვევაში, მაშინ d, მაშინ f f.
ასე მოკლედ, თექვსმეტობითი მხოლოდ tends
უნდა იყოს სასარგებლო, რადგან მისი თითოეული ციფრები, ნულოვანი მეშვეობით f, შესანიშნავად ხაზები
ერთად ნიმუში ოთხი ბიტი.
>> ასე რომ, თუ თქვენ გაქვთ ორი თექვსმეტობითი ციფრები, ნულოვანი მეშვეობით F, ისევ და ისევ,
რომელიც გაძლევთ სრულყოფილად რვა ბიტი ან ერთი ბაიტი.
ასე რომ, ამიტომ ეს ტენდენცია შეიძლება პირობითად სასარგებლო.
არ არსებობს ინტელექტუალური content ნამდვილად მიღმა,
გარდა მისი ფაქტობრივი სასარგებლო.
>> ახლა JPEGs არ არიან მხოლოდ ფაილის ფორმატების გრაფიკა.
თქვენ ალბათ გახსოვთ, რომ არსებობს ფაილები მოსწონს ეს მსოფლიოში,
თუნდაც რამდენიმე წლის უკან.
>> ასე რომ, ეს იყო, ფაქტობრივად, დაყენებული Windows XP
მილიონობით ები მთელს მსოფლიოში.
და ეს იყო Bitmap ფაილი, BMP.
და Bitmap ფაილი, როგორც თქვენ იხილეთ შემდეგი კვირას, მხოლოდ იმას ნიშნავს, წერტილების წყობა,
pixels, როგორც ისინი უწოდებენ, რუკა ბიტი, ნამდვილად.
>> რა საინტერესოა, თუმცა, ამ ფაილის ფორმატი, BMP, არის
რომ ქვეშ Hood, ეს მეტი, ვიდრე უბრალოდ სამი ბაიტი
რომ დაკომპლექტებას თავისი თავით, ისე ვთქვათ, პირველი რამდენიმე ნაკბენები.
ის რეალურად გამოიყურება პატარა ართულებს ერთი შეხედვით.
და თქვენ ვხედავთ ამ P კომპლექტი.
და სულ რაღაც განსაკუთრებით, ეს ახლა
ასე არ არის მნიშვნელოვანი, რადგან მხოლოდ ის ფაქტი, დასაწყისში ყველა bitmap
ფაილი, გრაფიკული ფორმატი, არსებობს მთელი bunch of ნომრები.
>> ახლა Microsoft, ავტორი ამ ფორმატში,
ტენდენცია მოვუწოდებთ მათ, რამ არ ints და სიმბოლო
და მოძრავი, მაგრამ სიტყვა და d სიტყვა და longs და ბაიტი.
ასე რომ, ისინი უბრალოდ სხვადასხვა ტიპის მონაცემები.
ისინი სხვადასხვა სახელები იგივე რამ.
მაგრამ დაინახავთ, რომ P კომპლექტი ოთხი.
>> მაგრამ ეს არის მხოლოდ იმის თქმა, რომ, თუ ადამიანს ორმაგი დაწკაპუნებით რამოდენიმე .BMP ფაილი მისი
ან მისი მყარ დისკზე, და ფანჯარა იხსნება აჩვენებს მას, რომ გამოსახულება,
რომ მოხდა იმიტომ, რომ ოპერაციული სისტემის სავარაუდოდ შენიშნა არა მხოლოდ
.BMP გაფართოება ფაილის სახელი,
არამედ ის ფაქტი, რომ არსებობს გარკვეული კონვენციის ნიმუში ბიტი
თავიდანვე რომ bitmap ფაილი.
>> მაგრამ მოდით ახლა ფოკუსირება ასეთი რთული ფაილი,
მაგრამ ნაცვლად რაღაც მსგავსი.
დავუშვათ, აქ gedit, I უბრალოდ დასაწყისი
პროგრამა, რომელიც საკმაოდ მარტივია.
მაქვს რამდენიმე მდე დაბრუნება.
ახლა მაქვს # include "structs.h", მაგრამ მე დავბრუნდები, რომ ამ მომენტში.
მაგრამ ეს სასარგებლო არ არის.
ასე რომ ეს არის პროგრამა, რომ აპირებს განახორციელოს
როგორიცაა რეგისტრატორის მონაცემთა ბაზაში.
მონაცემთა ბაზის სტუდენტები, და ყველა სტუდენტს მსოფლიოში
აქვს სახელი და სახლი და ალბათ ზოგიერთი სხვა პერსონალი, მაგრამ ამას შენარჩუნება ეს მარტივი.
ყველა სტუდენტს აქვს სახელი და სახლი.
>> თუ მინდოდა დაწერა პროგრამა, რომლის მიზანი ცხოვრებაში
იყო მხოლოდ iterate საწყისი ნულოვანი სამ,
თუ არსებობს სამი სტუდენტები ჰარვარდის უნივერსიტეტი.
და მინდა მიიღოთ გამოყენებით GetString, თითოეული სტუდენტის სახელი და სახლი,
და შემდეგ უბრალოდ ბეჭდვა იმ.
>> ეს არის სახის მოსწონს კვირა ერთი, კვირა ორი პერსონალის ახლა,
სადაც მე უბრალოდ for მარყუჟი ან რამე მაგდაგვარს.
და მინდა მოვუწოდო GetString რამდენიმე ჯერ, და შემდეგ ამობეჭდოთ f რამდენჯერმე.
ასე როგორ შეიძლება მე ამის გაკეთება, თუმცა, როდესაც ორივე სახელი და სახლი
ჩართული თითოეული სტუდენტი?
>> ასე რომ, ჩემი პირველი ინსტიქტი შეიძლება უნდა გავაკეთოთ მსგავსი რამ.
მე პირველ რიგში ვთქვათ, რომ მომეცი, ამბობენ, მასივი სიმები მოუწოდა სახელები.
და მე არ მინდა, რომ hardcode სამი აქ.
რა მინდა იქ?
ასე რომ სტუდენტებს, იმიტომ, რომ მხოლოდ მუდმივი გამოცხადდა ზედა,
უბრალოდ მე არ უნდა hardcode სამი სხვადასხვა ადგილებში.
ეს გზა, მე შეუძლია შეცვალოს ის ერთი ადგილი, და ეს გავლენას ახდენს ცვლილება ყველგან.
და შემდეგ, შეიძლება ამის გაკეთება string ტიპის სახლები სტუდენტებს.
>> და ახლა, მე შეიძლება რაღაც მოსწონს (int i = 0; i <სტუდენტები, i ++.
ამიტომ მე აკრეფით სწრაფად, მაგრამ ეს ალბათ იცნობს სინტაქსი არის.
>> და ახლა, ეს იყო ბოლოდროინდელი.
თუ მინდა, რომ დააყენა i-th სტუდენტის სახელი, მე ვფიქრობ, რომ ამის გაკეთება.
და მაშინ, არა სახელები მაგრამ სახლების bracket i.
მე ამის გაკეთება, GetString, და მოდით ჩემთვის უკან დაბრუნება და ამ ხაზის.
ეთანხმებით?
არ ვეთანხმები?
ეს არ არის ძალიან მოსახერხებელი.
მე არ უთხრა შესახებ, რაც უნდა გააკეთოს.
>> მაგრამ ახლა, თუ მე ასევე სასურველი შემდეგ, მოდით
ვთქვათ, ბეჭდვა ეს ყველაფერი აღმოჩნდა, ასე რომ TODO შემდეგ.
მე ვაპირებ უფრო მეტი ამას ეს სავარაუდოდ არის
სწორი განხორციელება მიღების სახელები და სახლები, სამი
მათ შორის სულ ყოველი, საწყისი მომხმარებელს.
>> მაგრამ ეს არ არის ძალიან კარგი დიზაინი, არა?
რა მოხდება, თუ სტუდენტი აქვს არა მხოლოდ სახელი და სახლი, არამედ პირადობის მოწმობის ნომერი,
და ტელეფონის ნომერი, და ელექტრონული ფოსტის მისამართი,
და შესაძლოა მთავარ გვერდზე და იქნებ Twitter სახელური,
და ნებისმიერი რაოდენობის სხვა დეტალები ასოცირებული სტუდენტი ან პირი,
ზოგადად.
როგორ გვინდა დაიწყოს დაამატოთ ფუნქციონირება ამ პროგრამაში?
>> ისე, მე ვგრძნობ, როგორიცაა მარტივი გზა შეიძლება უნდა გავაკეთოთ რაღაც, ასე ვთქვათ,
int პირადობის სტუდენტებს.
ასე, რომ შეიძლება დააყენოს ყველა მათი პირადობის მოწმობების არსებობს.
და შემდეგ, რაღაც როგორიცაა ტელეფონის ნომრები,
მე არ ვარ დარწმუნებული, თუ როგორ უნდა წარმოადგენს, რომ უბრალოდ არ არის.
მოდით წავიდეთ წინ და უბრალოდ დარეკეთ ამ Twitters სტუდენტი, რომელიც
ცოტა უცნაურია, but-- და bunch სხვა სფეროებში.
>> მე დაიწყო ეფექტურად დააკოპირეთ და ჩასვით აქ.
და ეს აპირებს იზრდება საკმაოდ unwieldy საკმაოდ სწრაფად, არა?
არ იქნება ლამაზი თუ იყო მსოფლიოში მონაცემები სტრუქტურა ცნობილია
არა როგორც int ან string, მაგრამ რაღაც მაღალ დონეზე, აბსტრაქცია, ისე
საუბარი, რომელიც ცნობილია როგორც სტუდენტი?
C არ მოდის ჩაშენებული ფუნქციონალური სტუდენტები,
მაგრამ რა, თუ მინდოდა მისცეს მას ასეთი?
>> ასევე, თურმე, მე ვაპირებ გახსნა ფაილი სახელად structs.h აქ,
და შეგიძლიათ ზუსტად რომ.
და ჩვენ ვაპირებთ დავიწყოთ ამით არის.
და ქვეშ hood of P კომპლექტი სამი, თქვენ უკვე აკეთებს ეს ახლა.
არ არსებობს ასეთი რამ, როგორც g rect ან გ ოვალური პროგრამირების ენა C.
>> ეგ სტენფორდის ხორციელდება იმ მონაცემთა ტიპები გამოყენებით ეს მიდგომა აქ,
გამოცხადების საკუთარი ახალი მონაცემები ტიპის გამოყენებით ახალი სიტყვით
ე.წ. struct და სხვა ერთი ე.წ. typedef.
და მართლაც, მიუხედავად იმისა, რომ სინტაქსი გამოიყურება ცოტა განსხვავებული პერსონალი
ჩვენ ვნახეთ ადრე, პრინციპში, ეს სუპერ მარტივი.
>> ეს უბრალოდ ნიშნავს "განსაზღვროს ტიპის."
რომ იქნება სტრუქტურა და სტრუქტურა
ისევე, როგორც საკონტეინერო მრავალჯერადი რამ.
და რომ ის აპირებს აქვს სიმებიანი მოუწოდა სახელი,
და სიმებიანი მოუწოდა სახლში.
და მოდით მოვუწოდებთ, უბრალოდ მოხერხებულობის, მთელი ამ მონაცემების სტრუქტურას სტუდენტი.
>> ასე რომ, ამ მომენტში თქვენ მისაღებად მძიმით, თქვენ ახლა
შექმენით თქვენი საკუთარი მონაცემები ტიპი ე.წ. სტუდენტი
რომელიც ახლა დგას ერთად int, და float და char, და სიმებიანი,
და გ rect და გ ოვალური, და ნებისმიერი რაოდენობის სხვა რამ ადამიანი გამოიგონეს.
>> ასე რომ, რა არის სასარგებლო ამ ახლა ის არის, რომ, თუ მე დაბრუნდეს
to struct 0 და დასრულდება ეს განხორციელება, რომელიც მე დავწერე
წინასწარ აქ შეამჩნევთ, რომ ყველა გარდაუვალი messiness, რომ
ვიყავი დაახლოებით უნდა დაიწყოს ხდება, როგორც მე დასძინა ტელეფონის ნომრები და Twitters და ყველა
ეს სხვა რამ სტუდენტის განმარტება,
ახლა კი მოკლედ დაასრულა როგორც მხოლოდ ერთი მასივი სტუდენტებს.
>> და თითოეული მათგანი, სტუდენტები აქვს მრავალი რამ შიგნით მას.
ასე რომ ტოვებს ერთი შეკითხვა.
როგორ იღებთ at სახელი, და სახლი, და ID,
და რიცხვში შიგნით სტუდენტი?
სუპერ მარტივია, ისევე.
ახალი სინტაქსი, მაგრამ მარტივი იდეა.
>> თქვენ უბრალოდ შევიდა მასივი, როგორც ჩვენ გავაკეთეთ გასულ კვირას და ეს.
და რაც აშკარად ახალი ნაჭერი სინტაქსი?
მხოლოდ., რაც ნიშნავს "შევსულიყავით სტრუქტურა და კიდევ სფეროში მოუწოდა
სახელი, კიდევ სფეროში მოუწოდა სახლი, კიდევ სფეროში მოუწოდა სტუდენტი. "
>> ასე რომ, P კომპლექტი სამი, თუ თქვენ ჯერ კიდევ მუშაობს, რომ,
და ყველაზე ეგ მაინც არიან, გააცნობიეროს, რომ, როგორც თქვენ
დაიწყოს გამოყენებით რამ, როგორიცაა გ rects და გ ovals
და სხვა რამ, რაც არ ჩანს მოდის კვირეული Zero, ერთი, ან ორი,
გააცნობიეროს, რომ სწორედ იმიტომ, რომ სტენფორდის განაცხადა რამდენიმე ახალი ტიპის მონაცემები.
>> და მართლაც, სწორედ ის, რაც ჩვენ გამოგიგზავნით ამის გაკეთება, ისევე, P კომპლექტი ოთხი, როდესაც
ჩვენ ვიწყებთ, უნდა მოგვარდეს რამ როგორიცაა სურათები, bitmaps, და სხვა.
ასე რომ მხოლოდ teaser და გონებრივი მოდელი რა არის მოვა.
ახლა, მე არ წარადგინეს ცოტა ამ დილით.
მე ასეთი საინტერესოა რა Microsoft ფონი რეალურად
ჰგავს დღეს.
და თურმე ვიღაცას 2006 რეალურად წავიდა თითქმის ზუსტად
იმავე ადგილზე ფოტოს სინამდვილეში როგორც ჩანს, რომ ამ დღეებში.
სფეროში არის პატარა overgrown.
>> ასე ვსაუბრობთ, სურათებით, მოდით, რათა დაიბრუნოს Daven აქ
ეკრანზე და ნიკოლოზი, და მხოლოდ შეგახსენოთ
რომ თუ მინდა შემოგვიერთდით ლანჩზე ამ პარასკევს, ხელმძღვანელი ჩვენი ჩვეულებრივი URL
აქ.
>> ასე რომ, სად ჩვენ დატოვონ off ორშაბათს?
ჩვენ გააცნო ამ პრობლემა, არა?
ეს, როგორც ჩანს, სწორი განხორციელების swap,
რომლის დროსაც თქვენ აღების ორი ints, ერთი ე.წ., ერთი მოუწოდა b,
სვოპ მათ, ისევე, როგორც Laura გააკეთა აქ სცენაზე ერთად რძე და წყალი,
გამოყენებით დროებითი ცვლადი, ან ცარიელი ჭიქა,
ისე, რომ ჩვენ შეგვიძლია b წლის და წელს b გარეშე მიღების სასადილო რამ.
ჩვენ ძალიან განსხვავებულია.
ეს ე.წ. დროებითი.
>> მაგრამ რა იყო ფუნდამენტური პრობლემა კოდი ორშაბათს?
რა იყო პრობლემა აქ?
Yeah.
>> აუდიტორია: ეს იკავებს მეტი სივრცე.
>> დევიდ ჯ Malan: იკავებს მეტი სივრცეში, რადგან მე გამოყენებით ცვლადი,
და ეს OK.
ეს მართლაც ასეა, მაგრამ მე ვაპირებ ვთქვა, რომ კარგადაა.
ის მხოლოდ 32 ბიტი გრანდიოზული სქემა რამ, ასე რომ არ არის დიდი გარიგება.
სხვა აზრები?
აუდიტორია: ეს მხოლოდ სვოპ ცვლადები ადგილობრივად.
დევიდ ჯ Malan: ზუსტად.
ეს მხოლოდ სვოპების ცვლადები ადგილობრივად.
რადგან ნებისმიერ დროს რეკავთ ფუნქცია როდესაც მქონდა ქაღალდის საწყისი Annenberg
ბოლო დროს, თქვენ უნდა main ბოლოში.
როგორც კი რეკავთ ფუნქცია მოუწოდა swap, swap არ მიიღოთ x და y,
ორიგინალური ღირებულებებს.
რას აკეთებს swap მიიღოს, ჩვენ არ მოითხოვოს?
აუდიტორია: ასლები.
დევიდ ჯ Malan: ასე რომ ასლები მათ.
ამიტომ იგი იღებს ერთი და ორი, თუ გავიხსენოთ ბოლო დროს,
მაგრამ ასლი ერთი და ორი წარმატებულად გაცვალეს.
მაგრამ, სამწუხაროდ, ბოლოს და ბოლოს, ეს ღირებულებები რჩება.
ასე რომ, ჩვენ ვხედავთ ამ ჩვენს ახალ მეგობარს, იმედია GDB,
რომ თქვენ ან TFs და Ca-ს აქვს უკვე სახელმძღვანელო თქვენ მიმართ ასეთია.
>> ასე რომ არ swap გაწვევას გამოიყურება მოსწონს მოდით გახსნას ამას ასე გამოიყურება.
ჩვენ ინიციალიზაცია x ერთი, y ორი.
მქონდა bunch of ბეჭდვითი ვ ს.
მაგრამ შემდეგ, გასაღები დარეკეთ აქ იყო სვოპ, რომელიც
არის ზუსტად კოდი ჩვენ უბრალოდ დაინახა მომენტში წინ.
რომელიც არის სწორი თავდაპირველად ერთი შეხედვით, მაგრამ ფუნქციურად
ეს პროგრამა არ იმუშავებს, რადგან ის მუდმივად არ სვოპ x და y.
>> მოდით ვნახოთ ეს, სწრაფი თბილი აქ GDB, ./noswap.
რამოდენიმე დიდი ინფორმაცია, რომ მე მოშორება კონტროლის L ახლა.
და ახლა, მე ვაპირებ წავიდეთ წინ და აწარმოებს მას.
და სამწუხაროდ, რომ არ იყო, რომ სასარგებლოა.
ის გაიქცა პროგრამა შიგნით პროგრამა მოუწოდა GDB, debugger,
მაგრამ ეს არ მინდა poke გარშემო.
>> ასე როგორ შეიძლება მე რეალურად პაუზის აღსრულების შიგნით ამ პროგრამის?
ასე შესვენება.
და მე შეიძლება დაარღვიოს ნებისმიერი ხაზის ნომერი, ერთი, 10, 15.
მაგრამ მე ასევე შეუძლია დაარღვიოს სიმბოლურად განაცხადა შესვენების მთავარი.
და რომ აპირებს შექმნას შესვენების წერტილი, როგორც ჩანს, შეესაბამება 16 მთავარი.
და სად არის line 16?
მოდით ახვიდეთ კოდი და ახვიდეთ noswap.
და მართლაც, ხაზი 16 არის პირველი პროგრამა.
>> ახლა, თუ მე წავიდეთ წინ და ტიპის აწარმოებს ამ დროს, Enter, ის ათვისება.
ასე რომ, მოდით poke გარშემო.
ბეჭდვა x-- რატომ არის x ნულოვანი?
და იგნორირება დოლარის ნიშანი.
ეს მხოლოდ fancier გამოყენება პროგრამა.
რატომ არის x ნულოვანი მომენტში?
Yeah.
>> აუდიტორია: ეს ათვისება სწორი, სანამ line 16, რეალურად არ on line 16.
დევიდ ჯ Malan: ზუსტად.
GDB, ჩვეულებრივ, უკვე შეჩერებულია შესრულების ადრე line 16.
ასე რომ, ეს არ შეასრულა, რომელიც ნიშნავს x არის რაღაც უცნობი ღირებულება.
და მივიღეთ გაუმართლა, რომ ეს რაღაც სუფთა, როგორიცაა ნულოვანი.
ახლა თუ მე აკრიფოთ შემდეგი, ახლა მას შესრულებული 16.
ის ელოდება ჩემთვის შეასრულოს 17.
ნება მომეცით წავიდეთ წინ და ბეჭდვა x.
ეს არის ერთ ერთი.
ნება მომეცით წავიდეთ წინ და ბეჭდვა y.
რა უნდა ახლა ვხედავ?
>> აუდიტორია: [INAUDIBLE]
>> დევიდ ჯ Malan: ცოტა ხმამაღალი.
>> აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: არ საკმაოდ კონსენსუსის საფუძველზე.
ასე რომ, დიახ, ჩვენ ვხედავთ, ზოგიერთი ნაგვის ღირებულება.
ახლა, y 134514064 არსებობს.
კარგად, უბრალოდ ზოგიერთი ნაგვის ღირებულება.
ჩემი პროგრამა იყენებს RAM სხვადასხვა მიზნით.
არსებობს სხვა ფუნქციებს.
სხვა ადამიანი წერდა შიგნით ჩემი კომპიუტერი.
ასე რომ, იმ ბიტი გამოიყენება სხვა ფასეულობები, და რა მე ხედავს
არის ნარჩენებისგან გარკვეული ადრე გამოყენებით, რომ მეხსიერებაში.
>> ასე რომ, არ არის დიდი გარიგება, რადგან როგორც კი როგორც მე აკრიფოთ შემდეგი და შემდეგ ბეჭდვა Y,
ის ინიციალიზაცია ღირებულება, რომელიც მინდა.
ახლა, მოდით, წავიდეთ წინ ცოტა უფრო სწრაფად.
N მომავალი.
მოდით ეს კიდევ ერთხელ.
მაგრამ მე არ მინდა მოხვდა აქ, იმიტომ, რომ, თუ მე
გვინდა ვნახოთ, რა ხდება შიგნით swap, რა ბრძანება?
>> აუდიტორია: ნაბიჯი.
>> დევიდ ჯ Malan: ნაბიჯი.
ასე რომ, ეს ნაბიჯები ჩემთვის შევიდა ფუნქცია, ვიდრე მას.
და ახლა, ცოტა cryptic პატიოსნად, მაგრამ ეს მხოლოდ
მეუბნებოდა, მე ხაზი 33 არის.
და მოდით ეს კიდევ ერთხელ გავაკეთოთ.
Print temp.
ნაგვის ღირებულება, ამჯერად უკვე ნეგატიური, მაგრამ ეს მხოლოდ კიდევ ნაგვის მნიშვნელობა.
ასე რომ, მოდით შემდეგი, ბეჭდვითი temp.
ის ინიციალიზაცია რომ 1, რაც იყო ღირებულება x, აკა.
>> ახლა, სად არიან ჩვენი და X მოდის?
ყურადღება მიაქციეთ, მთავარ, ჩვენ მოუწოდა ამ ღირებულებებს x და y.
ჩვენ მაშინ გადასცა სვოპ ასეთია.
X მოვიდა პირველი, მძიმე y.
და შემდეგ, გაცვლა შეიძლება მოვუწოდებთ მათ x და y.
მაგრამ სიწმინდე, ის უწოდა და ბ.
მაგრამ და ბ ახლა იქნება ასლები x და y, შესაბამისად.
>> ასე რომ, თუ მე უკან GDB, temp არის ერთი და არის ერთი.
მაგრამ, თუ მომდევნო და ახლა ბეჭდვითი , უკვე გადავიდა.
რძე შეედინება ყოფილი ფორთოხლის წვენი მინის, ან პირიქით.
>> და თუ მომდევნო ერთხელ და ახლა თუ ამობეჭდოთ როგორც საღი აზრის შემოწმება,
ჯერ კიდევ ორი, მაგრამ ბ არის ერთი.
გულწრფელად ვამბობ, რომ ჯერ კიდევ არსებობს.
მე არ მაინტერესებს, რა დროებითი.
მაგრამ როგორც კი მე ახლა აკრიფოთ, ასე ვთქვათ, კვლავაც დაბრუნდეს, ახლა მე ბოლოს
პროგრამა.
და სამწუხაროდ, x არის კიდევ ერთი და y ჯერ კიდევ ორი.
>> რა იყო სასარგებლო GDB იქ?
ეს არ დამეხმარება გაასწორონ პრობლემა თავისთავად,
მაგრამ ეს იმედია დამეხმარება მესმის, რომ ეს ხვდებიან
დიახ, ჩემი ლოგიკა არის სწორი, მაგრამ ჩემი კოდი არ საბოლოოდ მქონე
მუდმივი ზემოქმედება.
ასე რომ, ეს პრობლემა ჩვენ ვაპირებ ახლა გადაწყვიტოს დღეს.
>> მაგრამ მოდით კიდევ არსებობს გზა ამ.
სიმებიანი არის ტყუილი.
ეს, ძალიან, არ არის მონაცემები ტიპის რომ არსებობს C. ეს
უკვე სინონიმი გარკვეული დრო რაღაც,
და ჩვენ შეიძლება გამოავლინოს, რომ ასეთია.
>> ნება მომეცით წავიდეთ წინ და ქმნის პროგრამას სახელწოდებით შედარების 0.
და ვიდრე ამას ერთი, ჩვენ დავიწყებთ გავლა კოდი
მე უკვე წერდა, მაგრამ ეს მხოლოდ რამდენიმე ხაზი.
ასე რომ, ეს არის შედარება-0.
და პირველი, რაც მე ვაკეთებ დღითიდღე ტექსტი.
>> მაგრამ შეამჩნია რა მე ამით პირველად.
რა არის ნათლად line 21?
რეალურად, დაველოდოთ წუთში.
ეს არის ასლი ორი.
რომ არ არის სწორი პროგრამა.
ყველა უფლება spoiler alert.
ყველა უფლება, ასე არასოდეს იბადება, რომ.
რომ არის პასუხი, რომ მომავალში საკითხი.
>> აქ არის შედარება-0, და მე იმის შესახებ, რომ ტექსტი.
პროგრამის ბევრად უფრო მარტივია.
ასე რომ, ეს არის უშუალო.
ეს არის, როგორც კვირა ერთი, კვირა ორი პერსონალი მომენტში. string s = GetString.
ახლა, ამას კიდევ ერთხელ, აქ ქვემოთ.
string t = GetString.
და შემდეგ, ბოლო რამ ამ პროგრამა, როგორც მისი სახელი ვარაუდობს,
არის მე ვაპირებ ცდილობენ შედარება.
>> ასე რომ, თუ, პირველი ტექსტი, უდრის = t, მაშინ მე
აპირებს ვთქვა თქვენ აკრიფოთ იგივე.
სხვაგან, მე ვაპირებ ვთქვა, თქვენ აკრიფოთ სხვადასხვა რამ.
მოდით კომპილირება და აწარმოებს ამ პროგრამის.
ასე რომ შედარება ნულოვანი.
კარგად გამოიყურება.
არარის კოლექცია შეცდომები.
>> ნება მომეცით წავიდეთ წინ ახლა და ტიპის ./compare-0.
ნება მომეცით წავიდეთ წინ და ვთქვათ რაღაც : Daven და რაღაც: Rob.
და მე აკრიფოთ სხვადასხვა რამ.
ჯერჯერობით, იმდენად კარგი.
პროგრამა, როგორც ჩანს, სწორი.
>> მაგრამ მოდით გაუშვით ერთხელ.
ვთქვათ რაღაც: Gabe.
ყველა უფლება.
იქნებ მე მოხვდა სივრცეში ბარი ან რაიმე ხმაურიანი.
მოდით ეს კიდევ ერთხელ.
ასე Zamyla.
Zamyla.
სხვადასხვა რამ.
ასე რომ, რა ხდება?
>> ასე რომ, ჩვენ გვაქვს ამ ორ წყებას კოდი, GetString მიმდინარეობს მოუწოდა ორჯერ.
და მაშინ, მე უბრალოდ ვედრებით და ტ.
მაგრამ რა მერე ხდება?
ისე, ჩემი ხელწერა ს შესახებ ჯალათიც ეს მაგალითი გარკვეულწილად.
და მოდით რეალურად სახიფათოა ამ მეტი აქ, ისევე.
>> ამიტომ, ჩვენ უნდა ხაზი მოსწონს string s = GetString.
ასე რომ, ეს უბრალოდ პირველი საინტერესო ხაზი, რომ პროგრამა.
მაგრამ, რა ყველა ამ დროს უკვე ხდება ქვეშ hood?
ასევე, მარცხენა მხარეს არის string, რომელიც გარკვეული ტიპის ცვლადი,
და ეს ე.წ. s.
ასე რომ, მე ვიცი, რომ ეს იყენებს მეხსიერების, ან RAM, ჩემი კომპიუტერი რატომღაც.
ამიტომ, მე ვაპირებ აბსტრაქტულად მიაპყროს, რომ, როგორც მოედანზე.
32 ბიტი, თურმე, მაგრამ უფრო, რომ მომავალში.
და მაშინ, რა ხდება აქ?
>> ისე, GetString აშკარად იღებს string საწყისი მომხმარებელს.
და GetString მიიღო Zamyla ან Gabe ან Daven.
ასე რომ, მოდით ავირჩიოთ პირველი იმ, რომელიც Daven.
იმდენად ეფექტურად, რა GetString მიიღო მე რომ პირველ შემთხვევაში იყო D-a-v-e-n.
და მაშინ, რა გააკეთა ის მომეცი ფარულად?
აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: ჰო, / 0 ან null ხასიათი.
ასე რომ ეფექტურად მომცა სიმებიანი.
მაგრამ ჩვენ უკვე ვიცით წინა გამოიყურება, რომ სიმებიანი მხოლოდ მასივი
გმირები და ის წყდება ამ სპეციალური sentinel ხასიათი, / 0.
>> მაგრამ თუ ეს მართლაც ასეა, და ეს არის მოედანი,
ეს აშკარად ბევრად უფრო დიდი მართკუთხედი.
და მართლაც, ეს არის, მე პრეტენზია, მხოლოდ 32 ბიტი.
და ეს არის აშკარად მეტია, ვიდრე 32 ბიტი, იმიტომ, რომ ეს არის, ალბათ,
რვა პლუს რვა პლუს რვა პლუს რვა პლუს რვა,
მხოლოდ იმიტომ, რომ bytes in ASCII.
როგორ heck, ჩვენ ვაპირებთ, რათა შეწყობოდა Daven ამ პატარა ყუთს?
>> ისე, რა არის GetString რეალურად აკეთებს?
ასევე, ამ ქსელის აქ წარმოადგენს ჩემი კომპიუტერის მეხსიერების ან RAM.
ასე რომ, მოდით თვითნებურად ამბობენ, რომ თუ თითოეული ეს წარმოადგენს byte,
მაშინ ჩვენ შეგვიძლია ვიფიქროთ, თითოეულ byte, როგორც მისამართი,
როგორიცაა 33 Oxford Street, ან 34 Oxford Street, ან 35 Oxford Street.
>> ასე რომ, ისევე სახლებში მისამართები და შენობა მისამართები,
ასე რომ ინდივიდუალური ბაიტი მეხსიერების აქვს მისამართები და ნომრები
რომ ცალსახად ამოცნობა.
ახლა, ეს არის უკანონო.
მაგრამ შენარჩუნება ეს მარტივი, მე ვაპირებ გამოყენება თექვსმეტობითი მხოლოდ კონვენციის,
მაგრამ 0x არაფერს ნიშნავს სხვა ვიდრე "ეს არის თექვსმეტობითი."
და მე ვაპირებ იმის მტკიცებას, რომ "D" მთავრდება Byte ერთი მეხსიერებაში.
>> მე მივიღე არაფერი ხდება ამ მეხსიერება, ასე Daven მიიღო პირველ ადგილზე
at Byte ერთი.
აი, ეს იქნება 0x2.
ეს ხდება 0x3.
ეს იქნება 0x4.
ეს ხდება 0x5.
ეს იქნება 0x6.
>> მაგრამ ერთხელ თქვენ დაიწყოს ფიქრი იმაზე, თუ რა კომპიუტერული აკეთებს
ქვევმოთ hood, თქვენ შეგიძლიათ დაიწყოს ითქვას,
როგორ, რამდენიმე წლის წინ, რომ განვახორციელეთ C თავად.
რა არის GetString ალბათ returning--, რადგან იგი
იგრძნობა, რომ ეს არ არის დაბრუნების Daven, თავისთავად,
იმიტომ, რომ ის აუცილებლად არ აპირებს შეესაბამება ამ პატარა box--
რა არის GetString ალბათ დაბრუნების?
>> აუდიტორია: [INAUDIBLE]
>> დევიდ ჯ Malan: ადგილმდებარეობა Daven.
და ის აკეთებდა ამ მას შემდეგ, რაც კვირა ერთი.
რა GetString მართლაც დაბრუნების არ არის ტექსტი, თავისთავად.
ეს არის ერთ ერთი პატარა თეთრი ტყუილი.
ეს დაბრუნების მისამართი სიმებიანი მეხსიერებაში, უნიკალური მისამართი.
Daven ცხოვრობს 33 Oxford Street.
მაგრამ უფრო მოკლედ, Gavin ცხოვრობს at 0x1, მისამართი Number One.
>> მერე რა ხდება, რომ ამ პატარა ყუთი მაშინ, უნდა იყოს ნათელი,
უბრალოდ მისამართი რომ სიმებიანი.
ასე რომ, ყველა ამ დროს, უკვე მიმდინარეობს.
მაგრამ რა მიანიშნებს, ახლა ის არის, რომ, თუ ყველა ის აქვს
არის მთელი რიგი შიგნით, ვინ არის შეჩერება, პროგრამისტი,
აყენებს ნებისმიერი ნომერი ნებისმიერი ცვლადი და უბრალოდ jumping
რომ ბლოკი მეხსიერება?
და მართლაც, ჩვენ დავინახავთ, რომ არის საფრთხის დროს.
>> მაგრამ ახლა, ამ გრძნობს არასაკმარისია.
თუ მე ვიტყვი, ჩემთვის სიმებიანი, თქვენ მომეცი Daven.
მაგრამ თქვენ ნამდვილად არ მომეცი Daven.
ყველა მომეცი არის Daven მისამართი.
როგორ მერე ზუსტად ვიცი, სადაც Daven იწყება და ends--
ამბავი მიღების weird-- სადაც Daven იწყება და მთავრდება,
და შემდეგ, მომდევნო სიმებიანი მეხსიერებაში იწყება?
>> ასევე, თუ თქვენ გადაცემის მე დასაწყისში Daven,
არსებითად, თუ როგორ ვიცი სადაც ბოლოს მისი სახელი?
რომ სპეციალური null ხასიათი, რომელიც მით უფრო მნიშვნელოვანია,
თუ სიმები ქვეშ hood უბრალოდ განსაზღვრული
ცალსახად მათი ადგილმდებარეობა მეხსიერებაში.
ასე რომ, ყველა ამ დროს, რომ რა ხდება შემდეგ.
>> ამიტომ, როდესაც ჩვენ ახლა დავაკვირდეთ კოდი აქ, ახსნას
თუ გვინდა, რომ შეცდომის შეესაბამება 26.
რატომ არის Zamyla და Zamyla განსხვავებული?
რატომ არის Gabe და Gabe სხვადასხვა?
ჰო, წელს უკან.
>> აუდიტორია: მათ სხვადასხვა მისამართები.
>> დევიდ ჯ Malan: უბრალოდ იმიტომ, მათ სხვადასხვა მისამართები.
რადგან როცა რეკავთ GetString ერთხელ, რაც მე ამის სწრაფად,
თუ ეს არის მეორე ხაზი, string t, როგორც მე, რომ პროგრამა,
უდრის ერთი ზარი GetString.
მომავალი დრო მოვუწოდებ GetString, მე ვაპირებ
მიიღოს სხვადასხვა ბლოკი მეხსიერება.
>> GetString ნებადართულია ვთხოვო ოპერაციული
სისტემა უფრო და უფრო მეტი მეხსიერება.
ის არ აპირებს reuse იგივე ექვსი ბაიტი თითოეული დრო.
ის აპირებს მიიღოს ახალი ბლოკი მეხსიერება, რომელიც
ნიშნავს t აპირებს სხვა ღირებულება, მეტი აქ.
>> ასე რომ, როდესაც მე ტოლია = t, თქვენ არ შედარება
D წინააღმდეგ და წინააღმდეგ და V წინააღმდეგ.
თქვენ შედარებით ეს წინააღმდეგ, რომელიც
გულწრფელად საკმაოდ useful-- useless-- საკმაოდ აზრი, იმიტომ, რომ ვინც ნამდვილად
ზრუნავს, სადაც სტრიქონები მეხსიერებაში?
>> და მართლაც, ჩვენ არ გვაქვს.
და ჩვენ არ ვაპირებთ დაიწყოს განსაკუთრებით ზრუნავენ.
მხოლოდ იმდენად, რამდენადაც, რომ შეცდომები შეიძლება წარმოიშვას და უსაფრთხოების შეიძლება წარმოიშვას ნების
ჩვენ რეალურად დაიწყოს ზრუნვა შესახებ.
მოდით დაფიქსირება ამ პრობლემას.
თურმე, გაასწორონ ის super უბრალოდ.
>> და მოდით რეალურად, სანამ ცხადყოფს, რომ კიდევ ერთხელ, თუ რა
თქვენ თუ ამ CS50 კლასი, და თქვენ უნდა განახორციელოს
შედარებით წინააღმდეგ ორი სიმები.
თქვენ ნათლად შეგიძლიათ არა მხოლოდ გამოიყენოს ტოლია = ტ.
მაგრამ მხოლოდ ლოგიკურად, თუ როგორ შეადარებდით ამ სტრიქონს
წინააღმდეგ string გამოყენებით C კოდი?
Yeah.
>> აუდიტორია: უბრალოდ ამისთვის loop [INAUDIBLE]
დევიდ ჯ Malan: Perfect.
აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: ჰო.
უბრალოდ გამოიყენოთ ამისთვის მარყუჟი ან ხოლო მარყუჟის ან რასაც.
მაგრამ ვრცელდება ძირითადი იდეა, რომ თუ ეს არის ბლოკი მეხსიერება ან მასივი
და ეს არის, iterate ორივე ერთსა და იმავე დროს.
და უბრალოდ შედარება წერილებს.
>> და თქვენ მოხვდით იყოს ცოტა ფრთხილად, რადგან თქვენ
არ მინდა, ერთი თითი წავიდეთ წარსულში სხვა
იმიტომ, რომ ერთი სტრიქონი არის უმეტეს სხვა.
ასე რომ, თქვენ აპირებს გვინდა შევამოწმოთ ამ სპეციალური ღირებულება, ბოლოს null.
მაგრამ ეს ნამდვილად არის, ბოლოს, როგორც მარტივია, რომ.
და სიმართლე გითხრათ, ჩვენ არ გვჭირდება ხელახლა რომ წამყვანი.
აქ არის ორი ვერსია.
და რა მე ვაპირებ ვთქვა, ისაა, რომ ნაცვლად შედარებით ტოლია = t,
მე ნაცვლად თქმას, თუ string შედარება s მძიმე t უდრის = 0.
ახლა, რა სიმებიანი შედარების?
>> თურმე, ის ფუნქცია, რომელიც გააჩნია C, რომლის მიზანი ცხოვრებაში
შედარება ორი სიმები.
და აურიეთ შედარება, თუ ჩვენ წაიკითხა მისი კაცი ან დოკუმენტაცია ან CS50
მითითება, ის უბრალოდ გეტყვით, რომ აჟიოტაჟი
შედარების ბრუნდება ან უარყოფითი ნომერი ან დადებითი რიცხვი ან ნულოვანი,
სადაც ნულოვანი იმას ნიშნავს, ისინი თანაბარი.
>> ასე რომ მხოლოდ ვარაუდი.
რა შეიძლება იყოს ეს ნიშნავს, თუ აურიეთ შედარების ბრუნდება
უარყოფითად ან დადებითი მნიშვნელობა?
აუდიტორია: მეტი ან ნაკლები.
დევიდ ჯ Malan: ჰო, მეტია ან ნაკლები.
ასე რომ, თუ თქვენ სურდა დასალაგებლად მთელი bunch of სიმებისათვის dictionary--
როგორც ჩვენ საბოლოოდ ქვემოთ road-- სრულყოფილი ფუნქცია გამოიყენოს პოტენციურად,
იმიტომ, რომ ის აპირებს, რომ შედარება სიმები თქვენთვის, და ვუთხრა
თქვენ არ მოდის, სანამ ბ, ან არ ბ მოვიდეს წინაშე ალფავიტის.
ჩვენ შეგვიძლია გავაკეთოთ ზუსტად რომ.
>> და შეამჩნია მე ერთი სხვა რაც ამ მაგალითს.
სხვას რას შეიცვალა უმაღლესი up ამ მთავარი ფუნქცია?
Char *.
და ეს არის ის, რომ სხვა თეთრი ტყუილი.
ამ დროს, როდესაც თქვენ წერდა string,
ჩვენ უკვე ფარულად გადაწერა სიმებიანი char * ისე, რომ clang რეალურად
ესმის.
>> სხვა სიტყვებით რომ ვთქვათ, CS50.h და როგორც ჩვენ საბოლოოდ ვხედავთ,
ჩვენ მივიღეთ სინონიმი მოუწოდა სიმებიანი ეს არის იგივე მნიშვნელობა, როგორც char *.
და ახლა, ვიცით მხოლოდ ის, რომ * ამ კონტექსტში, როგორც მინიმუმ,
ნიშნავს მისამართი.
>> მისამართი რა?
ისე, ის ფაქტი, რომ მე ვთქვი char *, და არ არის int * ან ათწილადი *
იმას ნიშნავს, რომ char * მისამართი char.
ასე რომ, პატარა ყუთს, aka ტექსტი, მართლაც ტიპის char *,
რომელიც უბრალოდ ლამაზი გზა ამბობდა, ამ ყუთში წავა მისამართზე.
და რას ნიშნავს ეს მისამართი ეხება?
როგორც ჩანს, char.
>> თუმცა შეგვიძლია აბსოლუტურად აქვს int * და სხვა ნივთები.
მაგრამ ახლა, char * მართლაც ყველაზე პირდაპირი და ერთი ინტერესი.
ასე რომ, ეს პრობლემა იქნება მოიმატებს, თუმცა, კიდევ ერთხელ.
>> დავუშვათ, რომ გაიხსნას ეს პროგრამა.
მოდით ვნახოთ, თუ ახლა ჩვენ შეგვიძლია პროგნოზირება რა არის არასწორი ამ კოდექსით.
ასე რომ ამ პროგრამის, ასლი-0, მე ვაპირებ წავიდეთ წინ და კიდევ ერთხელ მოვუწოდებთ
GetString და შესანახად ღირებულების s.
>> და მაშინ, რატომ აკეთებს ამას, ისევე როგორც შეგახსენებთ კვირის წარსულში?
ჩვენ ვიტყვი, რომ GetString ზოგჯერ ბრუნდება null.
რას ნიშნავს ეს, თუ GetString ბრუნდება null?
რაღაც წავიდა არასწორი.
ეს ალბათ იმას ნიშნავს სიმებიანი ძალიან დიდი, კომპიუტერის მეხსიერება ღალატობს.
ეს ხდება სუპერ, სუპერ, სუპერ იშვიათად, მაგრამ ეს შეიძლება მოხდეს.
ჩვენ გვინდა შევამოწმოთ იგი, და რომ ყველა ვაკეთებთ.
>> რადგან ჩვენ ვხედავთ, თუ არ დაიწყოს შემოწმების, ჩვეულებად რამ
როგორიცაა null, თქვენ შეიძლება რეალურად დაიწყოს წასვლა
მისამართები მეხსიერებაში, რომ არასწორია.
და თქვენ ვაპირებთ დავიწყოთ იწვევს უფრო და უფრო მეტი სეგმენტაცია ხარვეზი.
ან Mac ან PC, მხოლოდ რამაც კომპიუტერული გათიშეთ
ან პროგრამა გაყინვას, პოტენციურად.
>> ახლა, მე აცხადებენ ასლი 0.c, რომ მე ვაპირებ კოპირება ამ strings გზით
ხაზი 28.
და შემდეგ მე ვაპირებ აცხადებენ, ბოლოში
აქ რომ მე ვაპირებ შეცვალოს ერთი მათგანი.
>> ასე რომ შეამჩნია ეს.
მე ამას ჩვენი ძველი მეგობარი strlen.
და მხოლოდ განმარტავენ, ინგლისური რა ამ ხაზის 34 აკეთებს?
რას აკეთებს t bracket 0 წარმოადგენს მარცხენა.
Yeah.
>> აუდიტორია: პირველი ხასიათი t?
დევიდ ჯ Malan: პირველი ხასიათი ტ.
ეს არის ის.
პირველი ხასიათი t, მე მინდა დაავალოს ზედა მობილური
პირველი პერსონაჟი t.
ასე რომ, ეს capitalizing პირველი წერილი.
და შემდეგ, ძალიან ბოლო რამ გავაკეთო ამ პროგრამის მე პრეტენზია აქ არის
ორიგინალური, s, და აქ არის ასლი, ტ.
>> მაგრამ საფუძველზე ამბავი ჩვენ უბრალოდ ამის შესახებ, რა strings ნამდვილად არის,
რა არის ხაზი 28 ნამდვილად აკეთებს და რა არის
შედეგად bug აპირებს უნდა იყოს ეკრანზე?
>> ასე რომ, პირველი, პირველი კითხვა, 28.
რა არის string t = s ნამდვილად აკეთებს?
თუ ჩვენ გვაქვს მარცხენა მხარეს აქ string t = s;
რომელიც მაძლევს ერთი ყუთი აქ და ერთი ყუთი აქ.
და ვფიქრობ ეს მისამართი 0x, ვთქვათ, 50 ამ დროს, თვითნებურად.
რას აკეთებს სიმებიანი t = s ამის გაკეთება ქვეშ hood?
>> აუდიტორია: [INAUDIBLE]
>> დევიდ ჯ Malan: იგი ინახავს მეხსიერება მიმართოს არსებობს, ამიტომ 0x50 მიდის იქ.
ასე რომ, თუ ახლა, მე კი პირველი პერსონაჟი t და ზედა იგი,
რა ვარ მე ეფექტურად აკეთებს, რათა s?
მე ნამდვილად აკეთებს იმავეს, არა?
იმიტომ, რომ თუ Address 0x50-- და უბრალოდ, მე არ გვაქვს ბევრი ოთახი ფორუმში აქ,
მაგრამ ვარაუდობენ, რომ ეს არის 0x50 ქვემოთ აქ, სადღაც ჩემი კომპიუტერის მეხსიერებაში.
>> და მე, მაგალითად, Gabe ამას აქ, მოსწონს ეს.
და მე ვთქვი, t bracket 0 ხდება კაპიტალიზაცია.
ასევე, t bracket 0 პირველი ასო ტ.
ასე რომ ცოტა გ აპირებს დიდი გახდა G. მაგრამ პრობლემა
არის, რას არის ასევე აღვნიშნო, რომ?
>> აუდიტორია: იგივე.
>> დევიდ ჯ Malan: ზუსტად იგივე რამ.
ასე მარტივი ახსნა, ალბათ, მაშინაც კი, თუ სინტაქსი არის ცოტა უცნაურია.
ასე რომ, მოდით ეს.
მიიღოს ასლი 0 და შემდეგ ./copy-0.
ვთქვათ რაღაც: Gabe.
და, სამწუხაროდ, ორივე მათ უკვე კაპიტალიზირდება,
მაგრამ, რომ უდევს მიზეზი იმისა, რომ ჩვენ უბრალოდ
ახლა საქმე მისამართები.
>> ასე რომ, ჩვენ ვიწყებთ address-- არ pun intended--
როგორ უნდა დაიწყოს მივმართო ამ პრობლემის?
ასევე, copy1.c, რამ ვაპირებთ ცოტა უფრო რთული.
მაგრამ მე მინდა, მოითხოვოს კონცეპტუალურად მარტივი გამოსავალი.
>> იმისთვის, რომ მიიღოთ ერთი შეხედვით.
არ იქნება ადვილი პირველი დროს თქვენ აკრიფოთ ის, ალბათ,
მაგრამ თუ პრობლემა ისაა, რომ უბრალოდ აკეთებს t = s მხოლოდ
ასლები მისამართი, რა, კიდევ ერთხელ, თუ შემიძლია აირჩიოთ თქვენ,
იქნება გამოსავალი რეალურად კოპირება სიმებიანი?
>> აუდიტორია: ჩვენ ალბათ გამოვიყენოთ loop ერთხელ.
>> დევიდ ჯ Malan: ჰო.
ამიტომ, ჩვენ ვაპირებთ გვჭირდება loop ერთხელ.
და იმიტომ, რომ თუ ჩვენ გვინდა კოპირება სიმებიანი შევიდა სხვა სიმებიანი,
ჩვენ ალბათ სურთ ამის გაკეთება ხასიათი ხასიათი.
მაგრამ პრობლემა ის არის, თუ ეს არის თავდაპირველად s,
ახლა ჩვენ უნდა დავიწყოთ პირდაპირ გამოყოფის მეხსიერების ტ.
>> სხვა სიტყვებით, მოდით გადაიხედება, ამ ბოლო დროს.
თუ ეს არის string s = GetString.
და მოდით დააყენა ამ მდე აქ, ისევე.
ეს არის GetString.
და შემდეგ, სურათზე რაღაც მინდა, რომ იქნება, როგორც ადრე,
g-a-b-ელ / 0.
რომ გამოიყურება პატარა რაღაც მსგავსი.
და ის შესაბამისად, ჩვენ მოვუწოდებთ ამ 0x50, და რომ იქნება 51, 52.
>> ასე რომ, ეს არის 0x50.
და მაშინ, მე სიმებიანი ტ.
მეხსიერება, რომელიც მხოლოდ აპირებს მომეცი ცოტა მოედანზე მოსწონს ეს.
რა არის გადამწყვეტი ახლა?
თუ მინდა კოპირება s შევიდა t, რა ცარიელი გვჭირდება შევსება აქ?
ან რას უნდა გავაკეთოთ მაღალ დონეზე?
ჰო?
ვინმე?
Yeah.
>> აუდიტორია: ჩვენ უნდა [INAUDIBLE].
დევიდ ჯ Malan: ჰო, ჩვენ უნდა შეავსონ ცარიელი.
მე ვერ დააკოპირეთ და შემდეგ ესარგებლა Gabe სახელი
სანამ მე ვთხოვთ ოპერაციული სისტემა სხვა ბლოკი მეხსიერება
ეს არის ის, მინიმუმ, როგორც დიდი, როგორც ორიგინალური.
ასე რომ ტოვებს us კითხვაზე.
>> როგორ შემიძლია ვთხოვო ოპერაციული სისტემის არა მხოლოდ მარტივი პატარა მაჩვენებელი
როგორც ეს ეწოდება, მისამართი, მაჩვენებელი არ
მარტივი პატარა ყუთი მოსწონს ეს მოუწოდა სიმებიანი?
როგორ შემიძლია ვთხოვო ოპერაციული სისტემა დიდი ბლოკი მეხსიერება?
ჯერჯერობით, მე მხოლოდ მიღებული, რომ უკან არაპირდაპირი მოუწოდებს GetString.
ასე რომ, როგორ არის GetString კი მიღების მისი მეხსიერება?
>> ისე, გამოდის, რომ არსებობს ეს სხვა ფუნქცია აქ
რომ ჩვენ ახლა დაიწყება გამოყენება.
ახლა, ეს გამოიყურება ისე, უფრო cryptic than-- მე ვარ ერთადერთი, ვინც შეგიძლიათ ნახოთ it--
ეს ხაზი გამოიყურება გზა უფრო cryptic მაშინ ეს უნდა ერთი შეხედვით.
მაგრამ მოდით აჯავრებენ გარდა.
>> მარცხენა მხარეს, მე char * t.
ასე რომ, ინგლისური, დავიწყოთ ფორმულირება სათანადო სასჯელს ტექნიკური jargon.
ასე რომ, ეს გამოყოფაზე ცვლადი ტიპის char * მოუწოდა ტ.
ახლა, რა, რომ ნამდვილად ნიშნავს?
>> ისე, რაც იმას ნიშნავს, რა ვარ მე აპირებს იმისათვის, რომ ამ ცვლადში t?
მისამართი char.
ასე რომ მხოლოდ მარტივი, უფრო გონივრული გზა
აღწერს მარცხენა მხარეს.
ისე, რომ ქმნის ეს ყუთი აქ მხოლოდ.
ასე რომ, მარჯვენა მხარეს, სავარაუდოდ, აპირებს
გამოყოს, რომ უფრო ბლოკი მეხსიერება, როგორ?
ასე რომ, მოდით აჯავრებენ ამ გარდა.
>> ეს აბსოლუტური ერთი შეხედვით, მაგრამ რა ხდება შიგნით აქ?
პირველი, malloc, რომელიც როგორც ჩანს, ჩვენი ახალი მეგობარი,
"მეხსიერების გამოყოფას."
ასე რომ, ეს არგუმენტი გავიდა ეს, ასე რომ საკმაოდ დიდი არგუმენტი.
ასე რომ, მოდით აჯავრებენ ამ გარდა.
>> strlen of, რა თქმა უნდა, წარმოადგენს the--
აუდიტორია: რაოდენობის სიმბოლოებს.
დევიდ ჯ Malan: Just რაოდენობის სიმბოლოების s.
ამიტომ სიგრძით s, ორიგინალური ტექსტი.
ასე რომ G-a-b-e.
ასე რომ, ალბათ ოთხი ამ შემთხვევაში.
რატომ ვაკეთებ +1 შემდეგ მოუწოდებდა strlen s?
აუდიტორია: [INAUDIBLE]
დევიდ ჯ Malan: იმისათვის, რომ სპეციალური null ხასიათი.
მე თუ მკითხავთ, რა არის ხანგრძლივობა Gabe სახელი, მე ვაპირებ ვთქვა, ოთხი.
ქვევმოთ hood, თუმცა, მე უნდა რომ მეხუთე byte for null ხასიათი.
ასე რომ, ამიტომ მე ვაკეთებ +1.
>> ახლა მხოლოდ იმ შემთხვევაში თუ თქვენ გაშვებული ეს პროგრამა კომპიუტერის გარდა, ამბობენ,
CS50 ელექტრო მოწყობილობების, სადაც ზომა char
შეიძლება იყოს სხვადასხვა ჩემი საკუთარი კომპიუტერი
გამოდის, რომ მე შემიძლია ამ ოპერატორი sizeof, ჰკითხეთ კომპიუტერი,
რა არის ზომა char კომპიუტერი?
>> და გამრავლებით ხუთ ამ მაგალითად ზომა char, რომელიც
საუკეთესო კომპიუტერები იქნება მხოლოდ ერთი, malloc
აპირებს გამოყოს ჩემთვის ეს დიდი ბლოკი მეხსიერების მეტი აქ უფლება.
და ის აპირებს დაბრუნდეს ეს არის ფუნქცია, ასე რომ
დაბრუნებას აპირებს რა?
აუდიტორია: მისამართი?
დევიდ ჯ Malan: მისამართი რა?
აუდიტორია: მეხსიერების გამოყოფილი?
დევიდ ჯ Malan: რა მეხსიერების გამოყოფილი.
ასე რომ, მე არ ვიცი, გულწრფელად, სადაც ეს ხდება დასრულდება.
მე ვაპირებ, რომ შესთავაზოს ის აპირებს დასრულდება up at 0x88.
სრულიად უკანონო, მაგრამ სადღაც, გარდა 0x50,
იმიტომ, რომ ოპერაციული სისტემა, რა Windows და Mac OS გააკეთებს ჩემთვის,
დარწმუნდით, რომ იგი აძლევდა me სხვადასხვა მოცულობით მეხსიერება.
>> ასე რომ, ეს ღირებულება, სადაც ეს ბლოკი მეხსიერება შეიძლება დასრულდება მდე.
ასე რომ, ეს არის ის, რაც მთავრდება აქ, 0x88.
ასე რომ, ახლა აშკარად, მე მესმის, რომ ეს არ არის იგივე, რაც ამ,
იმიტომ, რომ ისინი მიუთითებს სხვადასხვა მოცულობით მეხსიერება.
ასე რომ, თუ მე ახლა რეალურად გვინდა კოპირება ამ in, მოდით თქვენი შემოთავაზებული გადაწყვეტა.
>> მოდით უბრალოდ, შევქმნათ ამისთვის მარყუჟის, და ამის t bracket i იღებს s bracket i.
იმის გამო, რომ ახლა შემიძლია, ამ მასივი მსგავსი ჩანაწერები,
იმიტომ, რომ მიუხედავად იმისა, რომ malloc ძალიან generically გამოყოფს me მეხსიერება,
მეხსიერების მხოლოდ მომიჯნავე bytes.
Byte, byte, byte, უკან დაბრუნება თავში დაბრუნება.
>> დანამდვილებით შემიძლია, როგორც პროგრამისტი, მკურნალობა, როგორც მასივი, რომელიც
იმას ნიშნავს, რომ შეგიძლიათ გამოიყენოთ ეს საბოლოოდ ნაცნობი notation რამოდენიმე კვადრატულ ფრჩხილებში.
>> ნება მომეცით პაუზის არსებობს, იმიტომ, რომ ეს არის ბევრი ერთდროულად, მაშინაც კი,
მიუხედავად იმისა, რომ ძირითადი იდეა recap არის, რომ ტექსტი, მთელი ამ დროის განმავლობაში,
არ არის ახალი მონაცემები ტიპის თავისთავად.
უბრალოდ ე.წ. მაჩვენებელი, მისამართი ხასიათი,
რაც მხოლოდ იმას ნიშნავს, რომ ეს ნომერი რომ ადამიანის კონვენცია
ჩვენ, როგორც წესი, წერენ, როგორც 0x რაღაც.
>> მაგრამ ეს მხოლოდ ნომერი, როგორიცაა 33 Oxford Street,
რომელიც ხდება უნდა იყოს CS შენობის მისამართზე.
ნებისმიერი შეკითხვა ამ დეტალების?
ჰო?
>> აუდიტორია: რატომ ჩვენ შეამოწმოს ტ ტოლი null?
>> დევიდ ჯ Malan: რატომ შემოწმება t ტოლია null?
თუ გადავხედავთ documentation-- დიდი question-- ამისთვის malloc,
ის აპირებს ამბობენ ჯარიმა ბეჭდვითი, ზოგჯერ malloc შესაძლოა დაბრუნდეს null,
ისევე GetString.
და მართლაც, GetString ბრუნდება null თუ კი, თავის მხრივ, malloc ბრუნდება null,
რადგან GetString იყენებს malloc.
>> და რომ შეიძლება მოხდეს, თუ OS, Mac OS, Windows, რასაც, უბრალოდ,
გარეთ მეხსიერების თქვენთვის.
ასე რომ, რა მოხდა იქ.
>> და მოდით, გაგიმხელთ ერთი რამ რომ შეიძლება უბრალოდ აფეთქება თქვენი გონება
ან მთლიანად იქნება შორს მეტი ხაზი.
მაგრამ ნება მომეცით დახევის up იგივე loop კოპირება,
რომელიც მომენტში წინ, გაწვევა ეს. t bracket i იღებს s bracket i.
>> ლამაზი და მოსახერხებელი.
იგრძნობა კვირა ორი ერთხელ.
მაგრამ ეს ვერსია რეალურად შეიძლება იყოს გადაწერილი, როგორც ეს, რომელიც გამოიყურება cryptic.
ეს ტექნიკა მოუწოდა მაჩვენებელი არითმეტიკა, მისამართი არითმეტიკული.
მაგრამ რატომ აკეთებს ამას მუშაობა?
>> ახლა annoyingly, ავტორები C გადაწყვიტა გამოეყენებინა
* სიმბოლო სხვადასხვა მიზნით.
ჩვენ ვნახეთ, რომ გამოყენებული ერთხელ უკვე, char *, რაც ნიშნავს "მომეცი ცვლადი
რომ აპირებს შეიცავს მისამართი char ".
ასე რომ char *, ამ კონტექსტში, ნიშნავს "მომეცი ცვლადი".
>> სამწუხაროდ, თუ თქვენ იყენებთ * გარეშე სიტყვის წინ მას, როგორც char,
ის ახლა მოუწოდა dereference ოპერატორი.
და ჩვენ ვხედავთ, ეს ადრე უფრო დიდი ხნის განმავლობაში.
მაგრამ ეს მხოლოდ იმას ნიშნავს, "იქ".
ეს იგივეა, თითქოს ამბობდა, თუ ვინმე გადასცა ნაჭერი ქაღალდი "33 Oxford Street,"
თუ მე "* 33 Oxford Street," რაც იმას ნიშნავს, "ქვევით გზის CS შენობაში."
>> ასე * მხოლოდ იმას ნიშნავს, რომ თუ არ არსებობს სიტყვა წინ.
რა არის t, უნდა იყოს ნათელი?
t არის მისამართი ბლოკი მეხსიერება, რომელიც გადაეცა უკან ჩემთვის.
s არის მისამართი რა, უნდა იყოს ნათელი, მაგალითად ჩვენ განხილვას,
ამას Gabe?
s არის მისამართი of--
აუდიტორია: სიმებიანი.
დევიდ ჯ Malan: რა Gabe ორიგინალური სახელი.
ასე რომ, ეს მისამართი ბლოკი მეხსიერება.
ასე რომ, თუ მე ვიტყვი, t + შევიდე i, განცხადებების, მხოლოდ ჩვენი ძველი მეგობარი.
უბრალოდ ინდექსი ცვლადი რომ iterating ნულიდან on up
ხანგრძლივობა სიმებიანი.
ასე რომ, ეს უნდა იყოს ნულოვანი, მაშინ ერთი, შემდეგ ორი, სამი, მაშინ ოთხი.
ასე რომ, მოდით შეიკრიბება ეს ახალი Scratch-like თავსატეხი ცალი, თუ გნებავთ,
მიუხედავად იმისა, ერთხელ, სინტაქსი ბევრად უფრო arcane ვიდრე Scratch.
ასე t არის მისამართი + მე აპირებს მომეცი
ნომერი, იმიტომ, რომ ეს არის ყველა ციფრები, რომ ჩვენ უკვე ხატვის hex.
მაგრამ ისინი უბრალოდ ნომრები.
>> ასე რომ, თუ მისამართი t ჩვენ ვთქვით, იყო 0x88, რა 0x88 plus ნულოვანი.
მაშინაც კი, თუ თქვენ არ კომფორტული ერთად hex არ არის, მიიღოს ამოიცნობთ.
>> აუდიტორია: ორიგინალური.
>> დევიდ ჯ Malan: Still 0x88.
ასე რომ, რა * 0x88 ნიშნავს?
ეს ნიშნავს, რომ "იქ" რაც იმას ნიშნავს, ეფექტურად, "დააყენა თითის აქ."
და ახლა მარჯვენა მხარეს ეს გამოთქმა, და შემდეგ parens,
s + i ნიშნავს ის, რომელიც არის მისამართი აქ პატარა გ.
s + 0, რა თქმა უნდა, ის, რაც წინ არის.
>> ასე რომ, ახლა, ეს * s, რომელიც ისევე, როგორც * 33 Oxford Street ნიშნავს წასვლა მისამართი
s.
ასე რომ, აქ ამ თითი მარჯვენა ხელი.
რა ვარ მე აპირებს შევიდა რა?
რამ უფლება, რომელიც Gabe, პატარა გ აქ, შევიდა აქ.
>> და ასე ეფექტი რომ პირველი iteration of loop,
როგორც თქვენ შესთავაზა, მიუხედავად იმისა, რომ იგი გამოიყურება გიჟები უფრო რთული, ვიდრე არაფერი
ჩვენ ვნახეთ ადრე, უბრალოდ ვამბობ, აქ და ასლი, რომ ხასიათი აქ.
ის გაწვდით რუკა ორივე ადგილას.
>> და ჩვენ ვხედავთ, ბევრად უფრო ეს.
მაგრამ ახლა, იმედი მაქვს, უბრალოდ, დანერგვა ზოგიერთი ძირითადი იდეები.
და მართლაც, მოდით შევხედოთ ერთი საბოლოო პროგრამა აქ,
და შემდეგ დაპირებული claymation, რომელიც ყველაფერს ყველა უფლება.
ყველა უფლება.
ნება მომეცით გახსნა up-- იქ წასვლა.
ასე რომ, ნება მომეცით, ჩვენ დავბრუნდებით ამ სურათს ადრე ხანგრძლივი.
ნება მომეცით გახსენით საბოლოო მაგალითად აქ.
>> ასე რომ, აქ არის სუპერ, სუპერ პროგრამა, რომელიც ახორციელებს
არაფერი ცხოვრებაში, რომელიც აკეთებს შემდეგ.
ეს პირველი აცხადებს ორი ცვლადის, x და y, რომელიც არ არის ნომრები ამ დროს,
თავისთავად.
ისინი არ რიცხვებით, თავისთავად.
ისინი, როგორც ჩანს, int *.
ასე რომ მხოლოდ ვინმეს, რას ნიშნავს ეს თუ თქვენი მონაცემები ტიპის, თქვენი ცვლადი,
ტიპის int * ვარსკვლავი?
რომ არის მისამართი int.
>> ასე რომ, მე არ ვიცი, სად არის ის ამჟამად.
ეს უბრალოდ ნიშნავს "დააყენა, საბოლოოდ, მისამართი int აქ. "
0x50, 0x88, სადაც არ არის მეხსიერება, მისამართი მიმდინარეობს.
და ეს რა y არის იქნება, ასევე.
>> თუ მე ახლა ვიტყვი, x = malloc (sizeof (int)), ეს არის ლამაზი გზა ამბობდა,
hey ოპერაციული სისტემის მეშვეობით malloc, მომეცი საკმარისი მეხსიერება ზომა
int, რომელიც, სავარაუდოდ, იქნება 32 ბიტი ან ოთხი ბაიტი.
>> ასე რომ, რას malloc დაბრუნებას?
Malloc ბრუნდება მისამართზე.
ასე რომ, რა ხდება მისაღებად ინახება x?
მისამართი ბლოკი მეხსიერება, ოთხი ბაიტი, რომელიც malloc
უბრალოდ ი ჩემთვის მიერ გეკითხებით ოპერაციული სისტემა.
>> ახლა იმავდროულად, ხაზი ოთხ აქ, * x = 42.
უბრალოდ უნდა იყოს წმინდა, რა ხდება ქვემოთ იქ?
მარცხენა მხარეს, * x.
ასეთი * 33 Oxford Street.
ასე * x რას ნიშნავს?
>> აუდიტორია: გადასვლა.
>> დევიდ ჯ Malan: გადადით ამ მისამართზე.
იქ, სადაც ბლოკი მეხსიერების, წავიდეს იგი.
და თუ არსებობს, რა თქმა უნდა?
აუდიტორია: 42.
დევიდ ჯ Malan: 42.
ყველა უფლება, * Y, იგივე იდეა.
გადადით მისამართზე წ.
განათავსეთ ნომერი 13 იქ, მაგრამ რა არის y მომენტში?
აუდიტორია: არ არის მეხსიერების y.
დევიდ ჯ Malan: არსებობს არის მეხსიერების y.
ასე რომ, რას y ალბათ შეიცავდეს, როგორც ჩვენ ვამბობდით?
>> აუდიტორია: Garbage.
>> დევიდ ჯ Malan: ზოგიერთი ნაგვის ღირებულება.
ახლა, ნაგვის ღირებულება, ჯერ კიდევ არის.
ის მაინც უნდა იყოს ცდება მისამართზე.
ის თითქოს ვიღაცამ scribbled რაღაც ქვემოთ
მე და არასწორი ინტერპრეტაცია მას აზრი რამდენიმე შენობა ქვემოთ ქუჩაში.
და თუ უბრალოდ ცდილობენ წასვლას რამდენიმე შენობა არ ფლობენ,
ან ზოგიერთი ბლოკი მეხსიერება თქვენ არ მიეცა, ცუდი რამ შეიძლება მოხდეს.
კომპიუტერი შეიძლება ავარიის ან რაიმე სხვა დაუდგენელი ქცევა შეიძლება მოხდეს.
>> ასე რომ, intro, მაშინ, Binky არის.
მე მაინც მახსოვს, 20 რაღაც უცნაური წლის შემდეგ,
სადაც მე ვიყავი, როცა ბოლოს და ბოლოს, მიხვდა მითითებას.
>> რაც უნდა ითქვას, რომ, თუ დატოვონ აქ სამ წუთში
და ვფიქრობ, რომ არ გვესმის პოინტერები, გააცნობიეროს
მახსოვს 20 ახალი რაიმე გიჟები მიზეზი
როდის და რატომ საბოლოოდ ჩაიძირა in, სხდომაზე ჩემი სწავლების
თანამემამულე, Nishat Mehta in უკან Eliot სასადილო დარბაზი.
ახლა, მე გაიხსენა იმიტომ, რომ ეს იყო
ერთი თემა მე, კერძოდ, ბრძოლა.
და მაშინ, საბოლოოდ დააწკაპებთ, როგორც მე ვერ გაბედავს ამბობენ ბევრი თემები
საბოლოო ჯამში.
და ახლა, იმისათვის, რომ ეს გრძნობს ყველა ბედნიერი და ყველა უფრო დამაჯერებელი,
მოდით საბოლოო სახეს ჩვენი ბოლო სამი წუთი აქ Binky,
ჩვენი მეგობარი, ნიკ Parlante სტენფორდის.
>> [ვიდეო აღწარმოების]
>> -Hey, Binky.
ვიღვიძებ!
დროა მაჩვენებელი fun.
>> რა არის ეს?
ბუნებაში პოინტერები?
Oh, გუდი,
>> -Well, უნდა დავიწყოთ, ვფიქრობ, ჩვენ სჭირდება რამდენიმე მითითებას.
>> -OK.
ეს კოდი გამოყოფს ორ მითითებას, რომელიც შეიძლება აღვნიშნო, რომ რიცხვებით.
-OK.
ისე, მე ვხედავ ორი ​​პოინტერები, მაგრამ ისინი არ ჩანს, მიუთითებს, რომ არაფერი.
>> ანუ უფლება.
თავდაპირველად, პოინტერები არ აღვნიშნო, რომ არაფერი.
რამ მათ აღვნიშნო, რომ უწოდებენ pointees და დახურეს ის
ცალკე ნაბიჯი.
>> -Oh,, უფლება.
ვიცოდი, რომ.
Pointees ცალკე.
Er, ასე როგორ გამოყოფს pointee?
>> -OK.
ისე, ეს კოდი გამოყოფს ახალი რიცხვი pointee,
და ეს ნაწილი ადგენს x აღვნიშნო მას.
>> -Hey, რომ უკეთესია.
ასე რომ ეს რაღაც.
>> -OK.
მე dereference მაჩვენებელი x to შესანახად ხმების 42 თავის pointee.
ამ ნომრის, მე უნდა ჩემი ჯადოსნური ჯოხი of dereferencing.
>> -Your Magic Wand dereferencing?
That-- რომ დიდი.
>> _ ეს რა კოდი ჰგავს.
მე უბრალოდ შეიქმნა ნომერი, და [POP]
>> -Hey, გამოიყურება.
იქ მიდის.
>> ანუ, ამით dereference on x შემდეგნაირად arrow წვდომისათვის მისი pointee.
ამ შემთხვევაში, მაღაზია 42 იქ.
Hey სცადეთ ეს შესანახად ნომერი 13 გზით სხვა მაჩვენებელი, y.
>> -OK.
მე უბრალოდ მეტი აქ Y, და მიიღეთ ხმების 13 შეიქმნა.
და მაშინ, მიიღოს კვერთხის Dereferencing და მხოლოდ [BUZZ]
>> -Oh!
>> -Oh, Hey!
ეს არ იმუშავებს.
ამბობენ, Binky, არა მგონია, dereferencing Y არის კარგი იდეა, რადგან თქვენ იცით,
შექმნის pointee არის ცალკე ნაბიჯი.
და არა მგონია, ჩვენ ოდესმე ეს.
>> , კარგი წერტილი.
-Yeah.
ჩვენ გამოყოფილი მაჩვენებელი y, მაგრამ ჩვენ არასოდეს ვაყენებთ მას აღვნიშნო, რომ pointee.
>> -ძალიან დაკვირვებულობა.
-Hey, თქვენ ეძებთ კარგი იქ, Binky.
შეგიძლიათ დაფიქსირება ისე, რომ y რაოდენობა იმავე pointee როგორც x?
>> -Sure.
მე გამოიყენოს ჩემს Magic Wand საქართველოს მაჩვენებელი საბუთი.
>> რამდენად დიდია, რომ იქნება პრობლემა, როგორც ადრე?
არა.
ეს არ შეეხოთ pointees.
უბრალოდ ცვლის ერთ მომცეთ აღვნიშნო, რომ იგივე რამ, როგორც სხვა.
>> -Oh, მე ვერ ვხედავ.
ახლა Y რაოდენობა იმავე ადგილას, როგორც x.
ასე რომ დაველოდოთ.
ახლა, Y დაფიქსირდა.
მას აქვს pointee.
ასე რომ თქვენ შეგიძლიათ სცადოთ კვერთხის Dereferencing კვლავ გამოაგზავნოს 13 დასრულდა.
>> -Uh, OK.
აქ გადის. [POP]
>> -Hey, შევხედოთ, რომ.
ახლა dereferencing სამუშაოები y.
და რადგან მითითებები გაზიარებას რომ ერთი pointee, ორივე ვხედავთ 13.
-Yeah.
გაზიარებას, რასაც.
ასე რომ, ჩვენ ვაპირებთ გადართვის ადგილებში ახლა?
>> Oh, შეხედეთ.
ჩვენ გარეთ დრო.
>> -But--
>> -Just მახსოვს სამი მაჩვენებელი წესები.
Number One, ძირითადი სტრუქტურა არის, რომ თქვენ უნდა მომცეთ,
და ეს მიუთითებს იმ pointee.
მაგრამ კურსორი და pointee ცალკე,
და საერთო შეცდომა შეიქმნას მაჩვენებელი,
მაგრამ დავიწყება მისცეს მას pointee.
>> ნომერი ორი, კურსორი dereferencing იწყება მაჩვენებელი
და შემდეგნაირად arrow მეტი წვდომისათვის მისი pointee.
როგორც ვიცით, ამ მუშაობს მხოლოდ მაშინ თუ არსებობს
pointee, რაც ერთგვარი უბრუნდება წესი ნომერი ერთი.
>> ნომერი სამი, მაჩვენებელი დავალება იღებს ერთ კურსორი
და ცვლის მას უნდა აღვნიშნო, რომ იგივე pointee მორიგ მაჩვენებელი.
ამიტომ მას შემდეგ, რაც დავალება, ორი პოინტერები
აღვნიშნავთ, რომ იგივე pointee.
ზოგჯერ, რომ ე.წ. გაზიარების.
და ეს ყველაფერი არ არის, ნამდვილად.
Bye-bye არის.
[END ვიდეო აღწარმოების]
დევიდ ჯ Malan: ეს არის ის, CS50.
ჩვენ, თქვენ მომავალ კვირას.