[Powered by Google Translate] [WEEK 5]
[დევიდ ჯ Malan, ჰარვარდის უნივერსიტეტი]
[ეს არის CS50.] [CS50.TV]
[ქალი] ის ცრუობს, იმაზე, თუ რა, არ ვიცი.
[Man] რა ვიცით?
[ქალი], რომ 9:15, Ray Santoya იყო ბანკომატით.
[Man] ასე საკითხი, თუ რა იყო ის აკეთებს 9:16?
[ქალი] Shooting 9 მმ ზე რაღაც.
შესაძლოა, მან დაინახა სნაიპერული.
[Man] ან ის მუშაობდა მასთან.
[ქალი] დაელოდეთ. დავბრუნდეთ ერთი.
[Man] რას ვხედავ?
[♫ Suspenseful მუსიკა ♫]
[ქალი] Bring მისი სახე up. Full screen.
[Man] მისი სათვალე. >> არსებობს ასახვა.
[♫ Suspenseful მუსიკა ♫]
[Man] სწორედ Nuevita მისი ბეისბოლის გუნდი. სწორედ მათი ლოგო.
[ქალი] და ის საუბარი, ვინც ის ტარება, რომ ქურთუკი.
>> [დავით Malan] ასე რომ, ეს არის CS50 კვირაში 5, და დღეს ჩვენ ჩაშლის ცოტა სატელევიზიო და კინო თქვენთვის.
ასე რომ როდესაც თქვენ თვალს შოუ მოსწონს ერთი აქ,
და Cops ამბობენ "შეგიძლიათ გაწმენდა, რომ?" ან "ამაღლება"
არ არსებობს გააძლიეროს რეალურ ცხოვრებაში.
ფაქტობრივად, რასაც თქვენ მართლაც მიიღოს არის პატარა რაღაც მსგავსი.
მე გამოყვანილია ერთ პერსონალის ფოტოები გვერდზე.
ეს არის პროგრამის მოუწოდა Photoshop. ეს არის 1 2 Bowdens,
1 3 Bowdens რეალურად, დღეს, იმიტომ რომ ჩვენ გვაქვს ქალბატონი Bowden აქაც ერთად Rob და პოლ.
მაგრამ აქ არის რობ ეკრანზე, და თუ ჩვენ მიუახლოვდით რომ glint ის ყოველთვის ჰქონდა საკუთარ თვალის,
რაც თქვენ რეალურად ვხედავ ის არის, რომ რასაც თქვენ დაინახავთ არის ის, რაც თქვენ მიიღებთ.
ეს არის "გაუმჯობესებული", ასე "CSI" აქვს ცოტა არასწორია.
თუმცა ერთი სხვა კლიპი, შევძლებთ თუ აირჩიეთ "CSI" უბრალოდ ცოტა აღარ.
ეს ერთი არის ლამაზი ფრაზა არაადამიანური ამიერიდან, თუ გსურთ
გასწავლოთ ტექნიკური თქვენს მეგობრებს, როდესაც, რეალურად, თქვენ ამბობდა აბსოლუტურად არაფერი.
>> [Man] კვირების განმავლობაში მე უკვე იძიებს Cabby Killer მკვლელობებს
გარკვეული morbid აღფრთოვანებას.
[ქალი # 1] ეს არის რეალურ დროში.
[ქალი # 2] მე შექმნა GUI ინტერფეისი გამოყენებით Visual Basic, თუ შემიძლია აკონტროლოთ IP მისამართი.
>> [Malan] ასე აუდიო გარეთ sync განზე, შექმნა GUI ინტერფეისი გამოყენებით Visual Basic
მწკრივზე IP მისამართი, უბრალოდ, არაგონივრულია.
ამ დღეებში თქვენ არ გამოიყენებს Visual Basic,
არსებობს საჭიროება არ GUI, და IP მისამართი იყო ტექნიკურად ზუსტი ტერმინი.
გააგრძელეთ თვალის გარეთ ამ, და ერთი ჩემი სანიშნეები:
ეს ერთი პატარა arcane, იმიტომ, რომ თქვენ უნდა იცოდეთ სხვადასხვა ენაზე.
არსებობს ენის მოუწოდა Objective-C, რომელიც superset of C.
რაც იმას ნიშნავს, მისი C Plus რამდენიმე დამატებითი ფუნქციები, მათ შორის ობიექტის ორიენტირებული პროგრამირება.
და ეს არის ენა, რომ Apple-მა პოპულარიზაციას ამისთვის iOS პროგრამირების.
და ა.შ. აქ კლიპი სხვადასხვა შოუ საერთოდ, საწყისი "რიცხვები"
რომ თუ თქვენ ნამდვილად ყურადღებით დავაკვირდებით თქვენს TiVo და პაუზის, შესაფერის მომენტში,
თქვენ ნახავთ, რომ რაც ისინი ეძებს დიდი ხნის არ არის, რა ხდება აღწერილი.
და ნება მომეცით ვცდილობთ სხვადასხვა აუდიო კონექტორი აქ და ვნახოთ, შევძლებთ თუ არა
შენარჩუნება აუდიო sync ამ დროს.
მე გაძლევთ "რიცხვები".
>> [Man # 1] ეს 32-bit IPv4 მისამართი.
[Man # 2] IP, რომ ინტერნეტში. >> პირადი ქსელში. ეს ანიტა კერძო ქსელის.
[Malan] Okay. ეს არის Objective-C, და ეს რაღაც საბავშვო საღებარი პროგრამა,
როგორც შეგიძლიათ ალბათ infer საწყისი სახელით ცვლადი არსებობს.
ასე რომ, მაშინ, იყო "რიცხვები". ასე რომ დღეს და ამ კვირაში ჩვენ გააცნობს
ცოტა სამყაროში კრიმინალისტთა და კონტექსტი, ამიტომ პრობლემები.
დღეს იქნება შემოკლებით ლექცია რადგან არსებობს სპეციალური ღონისძიება აქ
ამის შემდეგ, ასე რომ ჩვენ მიიღოს peek, და აჯავრებენ ორივე სტუდენტებისა და მშობლების მსგავსად დღეს
ზოგიერთ რამ, რომლებიც ჰორიზონტზე.
მათ შორის, როგორც ორშაბათს, ჩვენ კიდევ რამდენიმე თანაკლასელები.
EDX, ჰარვარდისა და MITs ახალი ონლაინ ინიციატივა ღია courseware
და მეტი, იწყებს on ჰარვარდის ს კამპუსში ორშაბათს.
რაც იმას ნიშნავს, მოვა ორშაბათს გექნებათ - როგორც ბოლო მონაცემებით,
86.000 დამატებითი თანაკლასელები იქნება შემდეგ ერთად CS50-ს ლექციები
და სექციები და walkthroughs და პრობლემა კომპლექტი.
და, როგორც ნაწილი ამ, თქვენ წევრები გახდებიან დამფუძნებელი კლასი
CS50 და ახლა CS50x.
>> როგორც ნაწილი ამ, არის, გააცნობიეროს, რომ იქნება გარკვეული upsides ისევე.
მისაღებად მზად ამისათვის განკუთვნილი მასიური რაოდენობის სტუდენტები,
საკმარისია ითქვას, რომ მიუხედავად იმისა, რომ ჩვენ გვაქვს 108 TFs და CAS,
არ საკმაოდ საუკეთესო სტუდენტი / მასწავლებელს კოეფიციენტი ერთხელ ჩვენ მოხვდა 80,000 სხვა სტუდენტებს.
ამიტომ ჩვენ არ ვაპირებთ უნდა შეფასების ამდენი პრობლემა ადგენს ხელით.
ასე გააცნო კვირას პრობლემა კომპლექტი იქნება CS50 შემოწმება,
რომელიც იქნება command line პროგრამა ფარგლებში ელექტრო მოწყობილობების
რომ თქვენ მიიღებთ ერთხელ თქვენ განაახლოთ იგი მოგვიანებით ამ კვირის,
და თქვენ შეძლებთ გაუშვათ ბრძანება, შეამოწმეთ 50,
საკუთარ pset, და თქვენ მიიღეთ რაიმე კავშირი თუ არა თქვენი პროგრამა
სწორი ან არასწორი მიხედვით სხვადასხვა დიზაინის სპეციფიკაციები რომ ჩვენ გათვალისწინებული.
ასე უფრო, რომ და პრობლემა კომპლექტი სპეციფიკაცია და
CS50x თანაკლასელები იქნება გამოყენებისას ასევე.
>> ასე რომ პრობლემა კომპლექტი 4 არის ყველაფერი ექსპერტიზის.
და ეს ნაჭერი იყო შთაგონებული ზოგიერთი რეალურ ცხოვრებაში პერსონალის,
რის, როდესაც მე ვიყავი სკოლის მე სტაჟირება ხნით ერთად
MIDDLESEX ქვეყნის რაიონული საადვოკატო ოფისი აკეთებს სასამართლო მუშაობას
მათი ტყვიის სასამართლო გამომძიებელი და რა ამ შეადგინა
არის, ვფიქრობ, აღნიშნული რამდენიმე კვირის წარსულში, არის მასობრივი სახელმწიფო პოლიციის ან სხვა
მოვიდოდა წელს, ისინი Drop off რამ, როგორიცაა მყარი დისკები და CD და ფლოპი დისკები
და მოსწონს, შემდეგ მიზანი სასამართლო ექსპერტიზის ბიურო ადგენს არის თუ არა
იყო ან არ იყო მტკიცებულება გარკვეული.
ეს იყო სპეციალურ გამოკვლევათა განყოფილება, ასე რომ თეთრი საყელო დანაშაული,
ეს უფრო შემაშფოთებელი სახის დანაშაულები,
რაც ეხება რაღაც ციფრული მედია; თურმე არ არის, რომ ბევრი ადამიანი
დაწერეთ ელ ამბობდა "მე მას".
ამიტომ ხშირად ამ ექსპერტიზის searches არ ოჯახიდან ყველა რომ ბევრი რამ ხილი,
მაგრამ ზოგჯერ ხალხი წერენ ასეთ წერილებს.
ასე რომ ხანდახან ძალისხმევა დაჯილდოვდნენ.
>> მაგრამ უხელმძღვანელოს მდე ამ სასამართლო pset, ჩვენ უნდა შემოღების წელს pset 4 ცოტა გრაფიკა.
ასე, რომ თქვენ სავარაუდოდ ეს ყველაფერი თავისთავად, JPEGs, GIFs და მოსწონს ამ დღეებში,
მაგრამ თუ მართლაც დაფიქრდით, გამოსახულება, ჰგავს რობ სახე,
შეიძლება მოდელირებული როგორც თანმიმდევრობა წერტილების, ან pixels.
ახლა კი, იმ შემთხვევაში, რობ სახე, არსებობს ყველა სახის ფერები,
და დავიწყეთ ვხედავ ინდივიდუალური წერტილები, otherwide ცნობილია როგორც პიქსელი,
ერთხელ დავიწყეთ zoom სისტემაში
მაგრამ თუ ჩვენ გამარტივება მსოფლიოში bit, და უბრალოდ, ვამბობთ, რომ ეს აქ არის რობ
შავი და თეთრი, ასევე, წარმოადგინოს შავი და თეთრი შეგვიძლია უბრალოდ გამოიყენოთ ორობითი.
და თუ ჩვენ ვაპირებთ გამოვიყენოთ ორობითი, 1 ან 0, ჩვენ შეგვიძლია გამოვხატოთ ამ იმავე სახედ
of Rob მისი მომღიმარი სახე ამ მაგალითზე ბიტი: 11000011 წარმოადგენს
თეთრი, თეთრი, შავი, შავი, შავი, შავი, თეთრი, თეთრი.
და ამიტომ არ უზარმაზარი ნახტომი, მაშინ, უნდა დაიწყოს ლაპარაკი ფერადი ფოტოსურათი.
რამ, რომ თქვენ ნახე Facebook ან მოახდინოს ციფრული,
მაგრამ, რა თქმა უნდა, როდესაც საქმე ფერები, საჭიროა უფრო მეტი ბიტი.
და საკმაოდ გავრცელებულია მსოფლიოს ფოტოები, გამოვიყენოთ არ 1-bit ფერი,
როგორც ამ ვარაუდს, მაგრამ 24-bit ფერი, სადაც თქვენ რეალურად კიდევ მილიონობით ფერები.
ასე რომ, როგორც იმ შემთხვევაში, როდესაც ჩვენ zoomed წელს რობ თვალი,
რომ იყო ნებისმიერი რაოდენობის მილიონობით სხვადასხვა ფერად შესაძლებლობები.
>> ამიტომ ჩვენ ამ თანამედროვე პრობლემების კომპლექტი 4 ისევე როგორც walkthrough,
რაც იქნება დღეს 3:30 ნაცვლად ჩვეულებრივი 2:30 გამო პარასკევის ლექცია აქ.
მაგრამ ვიდეო იქნება შემოსული, როგორც ყოველთვის, ხვალ.
ჩვენ ასევე წარმოგიდგინოთ სხვა ფაილის ფორმატი.
ასე რომ, ეს განზრახ ნიშნავდა თვალი დაშინებას თავდაპირველად,
მაგრამ ეს მხოლოდ ზოგიერთ დოკუმენტაცია C struct.
თურმე Microsoft, წლის წინ, დაეხმარა პოპულარიზაცია ამ ფორმატში,
მოუწოდა Bitmap ფაილის ფორმატი, BMP, და ეს იყო სუპერ მარტივია,
ფერადი გრაფიკული ფაილის ფორმატი, რომელიც გამოიყენება საკმაოდ გარკვეული დრო
და ზოგჯერ მაინც ამისთვის ფონები on კომპიუტერები.
თუ ფიქრობთ თავში Windows XP და მოძრავი ბორცვები და ლურჯი ცა,
რომ იყო ტიპიურად BMP, ან Bitmap image, და bitmaps
არიან fun ჩვენთვის, რადგან მათ უფრო მეტი სირთულის.
ეს არ არის საკმაოდ მარტივია, როგორც ამ ქსელში 0 და 1 ს;
ნაცვლად, თქვენ რამ, როგორიცაა header დაწყების ფაილი.
ასე რომ, სხვა სიტყვებით, შიგნით. Bmp ფაილი მთელი bunch of 0 და 1 ს,
მაგრამ არსებობს რამდენიმე დამატებითი 0 და 1 ს იქ.
და აღმოჩნდება, რომ ის, რაც ჩვენ, ალბათ მიღებული გაიცემა წლის განმავლობაში,
ფაილის ფორმატში. doc ან. XLS ან. mp3 ან. mp4,
რასაც ფორმატის რომ თქვენ იცნობს.
ისე, რას კი ნიშნავს ფაილის ფორმატი?
იმიტომ, დღის ბოლოს, ყველა ეს ფაილი გამოიყენება მხოლოდ 0 და 1 ს
და იქნებ იმ 0 და 1 ს წარმოადგენს, ბ, გ, მეშვეობით ASCII ან მოსწონს,
არამედ დღის ბოლოს, უბრალოდ 0 და 1 ს.
>> ასე რომ ადამიანები უბრალოდ ზოგჯერ გადაწყვეტენ გამოგონება ახალი ფაილის ფორმატი
სადაც ისინი standardize რა ნიმუში ბიტი რომელიც რეალურად ნიშნავს.
და ამ შემთხვევაში აქ, დაკარგულია შექმნილია Bitmap ფაილის ფორმატი
განაცხადა, რომ პირველივე byte წელს Bitmap ფაილი, როგორც აღნიშნა მიერ ოფსეტური 0, იქ,
იქ იქნება გარკვეული cryptically დაასახელა ცვლადში bfType,
რომელიც მხოლოდ დგას Bitmap ფაილის ტიპი, რა ტიპის Bitmap ფაილი ეს არის.
შეგიძლიათ infer, შესაძლოა, მეორე მწკრივი რომ ოფსეტური 2, byte ნომერი 2,
აქვს ნიმუში 0 და 1 ს, რომელიც წარმოადგენს რა?
ზომა რაღაც, და ეს გრძელდება იქიდან.
ასე რომ პრობლემა კომპლექტი 4, თქვენ უნდა ფეხით ისეირნა ზოგიერთი რამ.
>> ჩვენ არ დასრულდება მდე ზრუნვა ყველა მათგანი, მაგრამ შენიშნავს იწყება მიიღოს საინტერესო
გარშემო ხაზის ან byte 54, rgbtBlue, მწვანე და წითელი.
თუ თქვენ ოდესმე მსმენია აბრევიატურა RGB, წითელი მწვანე ლურჯი, ეს არის მინიშნება, რომ.
იმის გამო, რომ თურმე შეგიძლიათ ხატავს ყველა ფერის Rainbow
ზოგიერთი კომბინაცია წითელი და ლურჯი და მწვანე.
და, ფაქტობრივად, მშობლები ოთახში შეიძლება გავიხსენოთ ზოგიერთი ადრეული პროექტორები.
ამ დღეებში, უბრალოდ ვხედავ 1 ნათელი შუქი გამოდის ობიექტივი.
მაგრამ უკან დღეს, გქონდათ წითელი ობიექტივი, ლურჯი ლინზები, და მწვანე ლინზები
და ერთად ისინი მიზნად ისახავს ეკრანზე და ჩამოყალიბდა ფერადი სურათი.
ხშირად შუა სკოლებსა და უმაღლეს სასწავლებლებში ექნება იმ ლინზები
ოდესმე ისე ოდნავ askew, ასე რომ თქვენ იყო ერთგვარი ხედავს ორმაგი ან სამმაგი სურათებით,
მაგრამ რომ იყო იდეა. თქვენ ჰქონდა წითელი და მწვანე და ლურჯი შუქი ხატავდა სურათს.
და რომ იგივე პრინციპი გამოიყენება კომპიუტერებს.
>> ამიტომ შორის გამოწვევები, მაშინ, თქვენთვის პრობლემა მითითებული 4
ვაპირებთ იყოს ცოტა რამ, ერთი რეალურად შეცვლის გამოსახულება.
მიიღოს in ნიმუში 0 და 1 ს,
გაერკვნენ, რომელიც მოცულობით 0 და 1 ს წარმოადგენენ რა სტრუქტურის მსგავსად,
და შემდეგ გაერკვნენ, თუ როგორ უნდა replicate პიქსელი: Reds, ბლუზის, მწვანეები
შიგნით, ისე, რომ როდესაც სურათს ასე გამოიყურება თავდაპირველად, შესაძლოა, ასე გამოიყურება ნაცვლად ამის შემდეგ.
შორის სხვა გამოწვევები, ძალიან, იქნება, რომ თქვენ უნდა გადასცეს
სასამართლო იმიჯი ფაქტობრივი ფაილი ციფრული კამერა
და რომ კამერა, ერთხელ, იყო მთელი bunch of ფოტო.
პრობლემა, ჩვენ შემთხვევით წაშლილია ან ჰქონდა გამოსახულება დაზიანებულია როგორღაც.
ცუდი რამ ხდება ციფრული კამერები, და ამიტომ ჩვენ სწრაფად გადაწერა ყველა 0 და 1 ს
გამორთვა რომ ბარათი თქვენ გადაარჩინა მათ ყველა 1 დიდი ფაილი, და მაშინ საბოლოოდ დავრწმუნდებით გადასცემს მათ თქვენ
პრობლემების მითითებული 4 ისე, რომ თქვენ შეგიძლიათ დაწეროთ პროგრამა C რომელთანაც ფეხზე
ყველა იმ JPEGs, იდეალურად.
და აღმოჩნდება, რომ JPEGs, მიუხედავად იმისა, რომ ისინი გარკვეულწილად კომპლექსური ფაილის ფორმატი,
ისინი ბევრად უფრო რთული, ვიდრე ეს მომღიმარი სახე აქ.
თურმე ყველა JPEG იწყება იგივე ნიმუში 0 და 1 ს.
ასე გამოყენებით, ხოლო მარყუჟი ან ამისთვის მარყუჟი ან მსგავსი,
შეგიძლიათ iterate მთელ 0 და 1 ს ამ სასამართლო გამოსახულება
და ყოველ ჯერზე ხედავთ სპეციალური ნიმუში რომ განსაზღვრული პრობლემა კომპლექტი მისი სპეციფიკაცია,
თქვენ შეიძლება ვივარაუდოთ, 'ო, აქ არის, ძალიან დიდი ალბათობით,
დაწყების JPEG, და როგორც კი შეამჩნევთ იგივე ნიმუში,
ზოგიერთი ბაიტების რაოდენობას ან kilobytes ან მეგაბაიტები შემდეგ,
თქვენ შეიძლება ვივარაუდოთ, 'Ooh! აქ არის მეორე JPEG, ფოტო ავიღე შემდეგ პირველი.
ნება მომეცით შეჩერება კითხულობს, რომ პირველი ფაილი, წერა ამ ახალი. "
და გამომავალი თქვენი პროგრამის pset 4 იქნება, როგორც ბევრი როგორც 50 JPEGs.
და თუ ეს ასე არ არის 50 JPEGs, თქვენ გაქვთ ცოტა loop.
თუ თქვენ გაქვთ უსასრულო რაოდენობის JPEGs, თქვენ გაქვთ უსასრულო ციკლი.
ასე რომ, ძალიან, იქნება საკმაოდ გავრცელებული შემთხვევა.
სწორედ რა ჰორიზონტზე.
>> Quiz 0, ჩვენს უკან. გააცნობიეროს, თითო ჩემი ელ, რომ უცვლელად არსებობს FOLKS
რომლებიც ორივე ბედნიერი, ერთგვარი ნეიტრალური, და სამწუხარო გარშემო ვიქტორინა 0 დრო.
და გთხოვთ, ნუ მივაწვდინოთ ჩემთვის, უფროსი TFs, Zamyla, თქვენი საკუთარი TF
ან ერთი CAS რომ თქვენ იცით, თუ გსურთ განიხილავს, თუ როგორ წავიდა.
>> ასე რომ შთაბეჭდილების მშობლები აქ ოთახში,
რა არის CS50 ბიბლიოთეკა? კარგ საქმეს.
რა არის CS50 ბიბლიოთეკა? ჰო? [სტუდენტური პასუხები, გაუგებარია]
>> Okay, კარგი. ასე რომ prewritten კომპლექტი კოდი, რომ ჩვენ, პერსონალი, წერდა,
ჩვენ უზრუნველყოფს თქვენ, რათა უზრუნველყოს ზოგიერთი საერთო ფუნქციონალურობას.
პერსონალის like get me string; get me int, ყველა ფუნქციებს, რომლებიც აქ ჩამოთვლილი.
დაწყებული ახლა ჩვენ დავიწყებთ ნამდვილად მიიღოს ამ სასწავლო თვლები off.
ამიტომ, ჩვენ ვაპირებთ დავიწყოთ წართმევას "სტრინგი" თქვენგან,
რაც იხსენებენ, იყო უბრალოდ სინონიმი რა ფაქტობრივი მონაცემების ტიპის? char *.
ასე რომ მშობლებს, რომ იყო ალბათ - ეგ კარგია, ასე რომ char * დავიწყებთ ვიხილოთ
ეკრანზე უფრო როგორც ჩვენ ამოიღონ "სტრინგი" ჩვენი ლექსიკა,
მინიმუმ როდესაც საქმე რეალურად წერა კოდი.
ანალოგიურად, ჩვენ შეწყვიტოს გამოყენებით ზოგიერთი ფუნქციების იმდენი,
რადგან ჩვენი პროგრამების ვაპირებთ კიდევ უფრო დახვეწილი
და არა მხოლოდ წერენ პროგრამებს, იჯდეს იქ სწრაფი მოციმციმე,
ელოდება მომხმარებელს აკრიფოთ რაღაც სისტემაში
თქვენ მიიღებთ თქვენი საშუალებებით საწყისი სხვაგან.
მაგალითად, თქვენ შეძლებთ მათ სერია ბიტი ადგილობრივ ხისტ დისკზე.
თქვენ ნაცვლად მიიღონ მათ მომავალში საწყისი ქსელის კავშირი, ზოგიერთი ნახვა სადღაც.
მოდით კანი უკან ამ ფენას პირველად, და გაიყვანოს up CS50 ელექტრო მოწყობილობების
და ეს ფაილი სახელად CS50.h, რომელიც თქვენ უკვე მკვეთრი ჩათვლით კვირების განმავლობაში.
>> მაგრამ მოდით რეალურად ხედავთ რა შიგნით ამ.
ასე ზევით ფაილის ლურჯი მხოლოდ მთელი bunch of კომენტარები,
გარანტია ინფორმაცია და ლიცენზირებას. ეს არის ერთგვარი საერთო პარადიგმის
პროგრამული უზრუნველყოფა, რადგან ბევრი პროგრამული უზრუნველყოფის ამ დღეებში რასაც "ღია წყარო"
რაც იმას ნიშნავს, რომ ვიღაცას არ გაუკეთებია კოდი
და გახადა თავისუფლად არის შესაძლებელი და არა მხოლოდ გასაშვებად და გამოიყენოს,
მაგრამ რეალურად წაიკითხა და შეცვალოს და ინტეგრაციას საკუთარ სამუშაოს.
ასე რომ სწორედ ეს თქვენ უკვე გამოყენებით, ღია კოდების პროგრამული უზრუნველყოფა,
თუმცა ძალიან მცირე ფორმით.
თუ მე გადახვევა ქვემოთ წარსულში კომენტარი, თუმცა, დავიწყებთ რამდენიმე უფრო ნაცნობი რამ.
ასე რომ შეამჩნია ზედა აქ, რომ CS50.h ფაილი მოიცავს მთელი bunch of header ფაილი.
ახლა, ყველაზე ამ ჩვენ არ მინახავს ადრე, მაგრამ ერთი
ნაცნობი, რომელიც ამ არ ჩვენ ვხედავთ, თუმცა მოკლედ, ჯერჯერობით?
ჰო, სტანდარტულ ბიბლიოთეკებს. Stdlib.h აქვს malloc,
ასე ერთხელ დავიწყეთ ლაპარაკი დინამიური მეხსიერების გამოყოფის,
რაც ჩვენ დაბრუნდება მომავალ კვირას ასევე დავიწყეთ მათ შორის ფაილი.
თურმე bool და ჭეშმარიტი და ყალბი არ არსებობს დო, თავისთავად,
თუ თქვენ მოიცავს ამ ფაილის აქ.
ამიტომ ჩვენ, კვირების განმავლობაში, იყო მათ შორის სტანდარტული bool.h
ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ცნება bool, ჭეშმარიტი ან მცდარი.
ამის გარეშე, თქვენ უნდა დაალაგოთ ფალსიფიცირებული და გამოიყენოთ int
და მხოლოდ თვითნებურად ვივარაუდოთ, რომ 0 არის ყალბი და 1 მართალია.
>> ახლა, თუ ჩვენ გადახვევა ქვემოთ შემდგომი, აქ არის ჩვენი დეფინიცია სიმებიანი.
თურმე, როგორც ჩვენ დაწყებამდე განაცხადა, რომ სადაც ეს არის * ნამდვილად არ აქვს.
თქვენ კი აქვს სივრცის გარშემო.
ჩვენ, ამ სემესტრში, უკვე ხელშეწყობა, როგორც ეს ნათლად რომ * უნდა გააკეთოს ტიპის.
მაგრამ რეალიზება, როგორც საერთო, თუ არ უფრო საერთო, არის დააყენოს ის იქ
მაგრამ ფუნქციურად ეს იგივე.
მაგრამ ახლა, თუ ვკითხულობთ ქვემოთ შემდგომი, მოდით შევხედოთ აცხადებენ, GetInt,
რადგან ჩვენ გამოიყენება, რომ, ალბათ, ადრე არაფერი ამ სემესტრში.
აქ არის GetInt. ეს არის რა?
ეს არის პროტოტიპის. ამიტომ ხშირად, ჩვენ დააყენა პროტოტიპები დროს დაპყრობა ჩვენი. გ ფაილი
მაგრამ თქვენ შეგიძლიათ დააყენა პროტოტიპები in header ფაილი. თ ფაილი
მსგავსი აქ, ისე, რომ როდესაც წერთ ზოგიერთი ფუნქციების
რომ გსურთ სხვა ხალხს ვერ გამოიყენებთ, რომელიც არის ზუსტად საქმე CS50 ბიბლიოთეკა,
თქვენ არა მხოლოდ განახორციელოს თქვენი ფუნქციების რაღაც CS50.c,
თქვენ ასევე დააყენა პროტოტიპები არ ზედა, რომ ფაილი, მაგრამ ზედა header file,
მაშინ რომ header ფაილი რა მეგობრებს და კოლეგებს შორის,
მახვილი მოიცავს საკუთარ კოდი.
ასე რომ მთელი ამ ხნის თქვენ უკვე მათ შორის ყველა ამ პროტოტიპები
ეფექტურად ზედა თქვენი ფაილი, არამედ გზა ამ მკვეთრი მოიცავს მექანიზმი
რომ არსებითად ასლები და პასტები ამ ფაილის შევიდა საკუთარი.
ახლა, აქ არის რამდენიმე საკმაოდ დეტალური დოკუმენტაცია.
>> ჩვენ საკმაოდ ბევრი მიღებული მიანიჭა, რომ GetInt იღებს int,
მაგრამ თურმე არსებობს რამდენიმე კუთხეში შემთხვევებში, არა?
რა მოხდება, თუ მომხმარებლის ტიპების ხმების რომ გზა ძალიან დიდია?
Quintillion, რომ უბრალოდ ვერ ჯდება შიგნით int?
რა არის მოსალოდნელი ქცევა? ისე, იდეალურად, ეს პროგნოზირებადი.
ასე რომ, ამ შემთხვევაში, თუ თქვენ ნამდვილად წაიკითხა ჯარიმა ბეჭდვითი,
თქვენ ნახავთ, რომ თუ ხაზი არ იკითხება, ამ ბრუნდება INT_MAX.
ჩვენ არასდროს არ ისაუბრა, თუმცა ეფუძნება მის კაპიტალიზაცია,
რა არის ეს, ალბათ?
ეს მუდმივი, ამიტომ ზოგიერთი სპეციალური მუდმივი რომ ალბათ განაცხადა
ერთ იმ header ფაილი რომ up მაღალია ფაილი,
და INT_MAX ალბათ რაღაც, დაახლოებით, 2 მლრდ.
იდეა მყოფი რომ რადგან ჩვენ გვჭირდება, რათა როგორმე ნიშნავდეს, რომ რაღაც არ მოხდა ისე,
ჩვენ, დიახ, აქვს 4 მილიარდი ნომრები ჩვენს ხელთ არსებული,
უარყოფითი 2 მილიარდი მდე 2 მილიარდი, მისცეს ან მიიღოს.
ისე, რა არის საერთო პროგრამირებაში არის თქვენ მოიპაროს მხოლოდ ერთი იმ ნომრები.
იქნებ 0, იქნებ 2 მილიარდი, შესაძლოა ნეგატიური 2 მლრდ.
ასე რომ თქვენ ხარჯავთ ერთი თქვენი შესაძლო მნიშვნელობებია ასე რომ თქვენ შეგიძლიათ ჩაიდინოს მსოფლიოს
რაიმე რომ მიდის არასწორი, მე დაბრუნდება ამ სუპერ დიდი მნიშვნელობა.
მაგრამ არ გსურთ მომხმარებლის აკრეფით რაღაც cryptic როგორიცაა "2, 3, 4 ..."
საქართველოს მართლაც დიდი რაოდენობის, სადაც თქვენ განზოგადება ნაცვლად, როგორც მუდმივი.
ასე ნამდვილად, თუ თქვენ მიმდინარეობდა anal ბოლო რამდენიმე კვირის განმავლობაში,
ნებისმიერ დროს რეკავთ GetInt, თქვენ უნდა ყოფილიყო შემოწმების ერთად, თუ მდგომარეობა.
Did მომხმარებლის ტიპის INT_MAX, ან უფრო კონკრეტულად,
გააკეთა GetInt დაბრუნების INT_MAX? რადგან თუ ეს მოხდა,
რომ რეალურად ნიშნავს, რომ ისინი არ აკრიფოთ მას; რაღაც წავიდა არასწორი ამ შემთხვევაში.
ასე რომ, ეს რა საყოველთაოდ ცნობილია, როგორც "Sentinel" ღირებულება, რომელიც მხოლოდ იმას ნიშნავს, სპეციალური.
>> კარგად, მოდით ახლა იქცეს, რათა. გ files.
C ფაილის არსებობდა ელექტრო გარკვეული დროის განმავლობაში,
და, ფაქტობრივად, ელექტრო აქვს precompiled თქვენთვის
შევიდა, რომ რამ ჩვენ მოუწოდა "ობიექტის კოდი,"
მაგრამ ეს უბრალოდ არ აქვს მნიშვნელობა თქვენ სადაც რადგან სისტემა იცის,
ამ შემთხვევაში, სადაც, ელექტრო.
მაგრამ მოდით გადახვევა ქვემოთ ახლა GetInt და ვნახავთ, როგორ GetInt მუშაობს ყველა ამ დროს.
ასე რომ აქ გვაქვს მსგავსი კომენტარებს ადრე.
ნება მომეცით დიდი ზომით უბრალოდ კოდი ნაწილი,
და რა გვაქვს ამისთვის GetInt ასეთია.
იგი იღებს არ შეყვანის და ის დააბრუნებს int, ხოლო (ნამდვილი), ამიტომ ჩვენ გვაქვს მიზანმიმართულ უსასრულო loop
მაგრამ, სავარაუდოდ, ჩვენ შესვენება აქედან როგორმე, ან შიგნიდან ამ.
მოდით ვნახოთ, როგორ ეს სამუშაოები. ასევე, ჩვენ როგორც ჩანს გამოყენებით GetString
ამ პირველი ხაზი შიგნით მარყუჟის, 166.
ეს არის კარგი პრაქტიკა, რადგან რა გარემოებებში
შეიძლება GetString დაბრუნებას ამ სპეციალური სიტყვით, NULL?
თუ რამე მიდის არასწორი. რა შეიძლება გადასვლა არასწორი როცა რეკავთ რაღაც GetString?
ჰო? [სტუდენტური პასუხი, გაუგებარია] >> Yeah. იქნებ malloc ვერ.
სადღაც ქვეშ hood GetString მოუწოდებს malloc,
რომელიც გამოყოფს მეხსიერება, რომელიც საშუალებას კომპიუტერულ მაღაზიაში
ყველა გმირები, რომ მომხმარებლის ტიპის შევიდა კლავიატურაზე.
და ვარაუდობენ მომხმარებლის ჰქონდა მთელი უამრავი თავისუფალი დრო
და აკრეფილი მეტი, მაგალითად, ვიდრე 2 მილიარდი სიმბოლო.
სხვა გმირები, ვიდრე კომპიუტერში კი აქვს RAM.
ისე, GetString უნდა შეძლებს ნიშნავდეს, რომ თქვენ,
მაშინაც კი, თუ ეს არის სუპერ, სუპერ იშვიათია კუთხეში შემთხვევაში.
მას გააჩნია, რათა როგორმე შეძლებს გაუმკლავდეს ამ და ასე GetString,
თუ ჩვენ დავბრუნდებით და წაიკითხეთ მისი დოკუმენტაცია, ამჯამად, ფაქტობრივად, დაბრუნდნენ null.
ახლა თუ ვერ GetString მიერ დაბრუნების NULL, GetInt აპირებს ვერ
მიერ დაბრუნების INT_MAX, ისევე როგორც Sentinel.
ეს არის უბრალოდ ადამიანის კონვენციებს. ერთადერთი გზა თქვენ ამას, რომ ეს არის საქმეზე
არის კითხულობს დოკუმენტაცია.
მოდით გადახვევა ქვემოთ სადაც int ფაქტიურად GotInt.
>> ასე რომ, თუ მე გადახვევა ქვემოთ bit შემდგომი, შეესაბამება 170 გვაქვს კომენტარის ზემოთ აღნიშნული ხაზები.
ამიტომ ვაცხადებთ, რომ 172, int n და char c და შემდეგ ამ ახალ ფუნქციას
რაც ზოგიერთი თქვენ stumbled მასშტაბით ადრე, მაგრამ sscanf.
ეს დგას სიმებიანი სკანირების ვ.
სხვა სიტყვებით, მომეცი სიმებიანი და მე იქნება სკანირების ეს დარტყმები ინფორმაციის ინტერესის.
ასე რომ რას ნიშნავს ეს? ისე, ვივარაუდოთ, რომ მე აკრიფოთ, სიტყვასიტყვით, 1 2 3 საათზე კლავიატურა,
და შემდეგ დააჭიროთ. რა არის მონაცემები გაცნობის 1 2 3 როდესაც დაბრუნდა მიერ GetString?
ეს აშკარად სტრიქონს, არა? მე მივიღე სიმებიანი, ასე 1 2 3 მართლაც "1 2 3"
ერთად \ 0 მიწურულს იგი. ეს არ არის int.
ეს არ არის რიცხვი. როგორც ჩანს ხმების მაგრამ არა რეალურად.
რას GetInt უნდა გავაკეთოთ? მას აქვს სკანირების რომ სიმებიანი მარცხნიდან მარჯვნივ,
1 2 3 \ 0, და როგორღაც კონვერტირება მას ფაქტობრივი რიცხვი.
ახლა, თქვენ შეიძლება გაერკვნენ, თუ როგორ უნდა გავაკეთოთ ეს.
თუ ფიქრობთ თავში pset 2, თქვენ სავარაუდოდ მიიღო პატარა კომფორტული
ერთად Caesar ან vigenere ასე რომ თქვენ შეგიძლიათ iterate მეტი ტექსტი,
თქვენ შეგიძლიათ დააკონვერტიროთ chars to ints ერთად არჩევანი. სწორედ მთელი ბევრი სამუშაოა.
რატომ არ გამოიძახა ფუნქცია, როგორიცაა sscanf რომ აკეთებს, რომ თქვენთვის?
ამიტომ sscanf მოელის არგუმენტი, ამ შემთხვევაში მოუწოდა ხაზი, რომელიც სიმებიანი.
მაშინ დააკონკრეტა, რომ შეთავაზებები, ძალიან ჰგავს printf,
რას ველოდოთ ვხედავ ამ სტრიქონს?
რა მე ვამბობ, აქ არის, მე მოველი, რომ ნახოთ ათობითი ნომერი და იქნებ ხასიათი.
და ვნახავთ, თუ რატომ არის ამ შემთხვევაში რაღაც მომენტში.
თურმე ამ ნოტაცია არის თქვენში პერსონალის
ჩვენ დავიწყეთ ლაპარაკი მხოლოდ ერთი კვირის წინ.
>> რა არის & n და & C აკეთებს ჩვენთვის აქ? [სტუდენტური პასუხები, გაუგებარია]
>> Yeah. ეს მაძლევს მისამართი N და მისამართი გ.
ახლა, თუ რატომ არის, რომ მნიშვნელოვანი? კარგად, თქვენ იცით, რომ ფუნქციონირებს C
თქვენ ყოველთვის შეგიძლიათ დაბრუნების ღირებულება ან ფასი არ არის.
თქვენ შეგიძლიათ დაბრუნების int, string, float, char, რასაც.
ან თქვენ შეგიძლიათ დაბრუნების ბათილად, მაგრამ შეგიძლიათ მხოლოდ დაბრუნდნენ 1 რამ მაქსიმალურად.
მაგრამ აქ ჩვენ გვინდა sscanf დაბრუნების ჩემთვის იქნებ int, ათობითი რიცხვი,
და ასევე char, და მე რატომ char in მომენტში.
ასე, რომ თქვენ ეფექტურად მინდა ვ დაბრუნებას 2 რამ, რომ უბრალოდ არ შეიძლება C.
ასე რომ თქვენ შეგიძლიათ იმუშაოთ გარშემო რომ გადადის 2 მისამართები,
რადგან, როგორც კი თქვენ გადასცემს ფუნქცია 2 მისამართები, რა შეიძლება, რომ გავაკეთოთ ფუნქცია მათთან?
მას შეუძლია დაწეროს იმ მისამართებზე. თქვენ შეგიძლიათ გამოიყენოთ * ოპერაცია და "იქ" ყოველი იმ მისამართებზე.
ეს ერთგვარი ამ backdoor მექანიზმი, მაგრამ ძალიან ხშირი შეცვლის ღირებულებების ცვლადებსა
ზე მეტ მხოლოდ 1 ადგილი, ამ შემთხვევაში 2.
ახლა შეამჩნია მე შემოწმება == to1, ხოლო შემდეგ ბრუნდებიან n თუ ეს ასეა, ფაქტობრივად, შეაფასებს ჭეშმარიტი.
ასე რომ, რა ხდება? ისე, ტექნიკურად, რიგში, ჩვენ ნამდვილად გვინდა მოხდეს GetInt ეს.
ჩვენ გვინდა გარჩევის, ასე ვთქვათ, ჩვენ გვინდა, რომ წაიკითხა სიმებიანი
"1 2 3" და თუ ეს ასე გამოიყურება არსებობს მთელი რიგი არსებობს,
რა ჩვენ ვეუბნებით sscanf გააკეთოთ დააყენა, რომ ნომერი, 1 2 3, ამ ცვლადის N ჩემთვის.
რატომ, მაშინ, არ მაქვს ეს, ისევე?
რა როლი ენიჭება ასევე ამბობდა, sscanf, თქვენ შესაძლოა, ასევე მიიღოთ ხასიათი აქ.
[სტუდენტური მოლაპარაკე, გაუგებარია] >> არ - ათობითი წერტილი შეიძლება იმუშაოს.
მოდით გამართავს, რომ ეგონა, ერთი წუთით. რა?
[სტუდენტი გაუგებარია] >> ასე რომ, კარგი აზრის, ეს შეიძლება იყოს NULL ხასიათი.
ეს ფაქტობრივად არ, ამ შემთხვევაში. ჰო? [სტუდენტი გაუგებარია]
>> >> ASCII. ან ნება მიბოძეთ, განზოგადება კიდევ უფრო.
% C არსებობს მხოლოდ შეცდომის შემოწმება.
ჩვენ არ გვინდა იქ იქნება ხასიათი შემდეგ ნომერი,
მაგრამ რა ამ საშუალებას ჩემთვის გააკეთოთ შემდეგი:
თურმე sscanf, გარდა შენახვის ღირებულებების N და გ, ამ მაგალითში აქ,
თუ რას ასევე ამჯამად არის ის დააბრუნებს რაოდენობის ცვლადები ეს დააყენა ღირებულებების სისტემაში
ასე რომ, თუ თქვენ მხოლოდ აკრიფოთ 1 2 3, მაშინ მხოლოდ% d აპირებს ემთხვევა
და მხოლოდ N იღებს შენახვას ღირებულება, როგორიცაა 1 2 3 და არაფერი იღებს დასვა C;
გ რჩება ნაგვის ღირებულება, ასე ვთქვათ.
Garbage რადგანაც ეს არასდროს ინიციალიზაცია როგორც გარკვეული მნიშვნელობა.
ასე რომ ამ შემთხვევაში, sscanf დააბრუნებს 1, რადგან მე დასახლებული ერთ იმ მითითებას,
ამ შემთხვევაში, დიდი. მაქვს int, ამიტომ გასათავისუფლებლად ხაზი უფასოა მეხსიერება
რომ GetString რეალურად გამოყოფილი, და მერე დაბრუნდნენ n.
სხვაგან, თუ თქვენ ოდესმე გვაინტერესებდა, სადაც ეს გაიმეორეთ განაცხადი მოდის, მოდის უფლება აქ.
თუ, პირიქით, მე აკრიფოთ 1 2 3 foo,
რამოდენიმე შემთხვევითი თანმიმდევრობა ტექსტი, sscanf აპირებს ვხედავ,
Ooh, ნომერი, Ooh, ნომერი, Ooh, ნომერი, Ooh - ვ.
და ეს აპირებს დააყენოს 1 2 3 in n.
ის გეგმავს ვ დო, ხოლო შემდეგ დაბრუნდნენ 2.
ამიტომ, უბრალოდ გამოყენებით ძირითადი განსაზღვრება scanf ქცევა,
ძალიან მარტივი გზა - კარგად, კომპლექსი ერთი შეხედვით, მაგრამ დღის ბოლოს,
საკმაოდ მარტივი მექანიზმი ამბობდა, არსებობს int, და თუ ასეა, ის არის, რომ ერთადერთი, რაც მე?
და თეთრი სივრცე აქ არის მიზანმიმართული. თუ თქვენ წაიკითხავთ დოკუმენტაცია sscanf,
ეს გიჩვენებთ, რომ თუ თქვენ მოიცავს ნაჭერი თეთრი სივრცის დასაწყისში ან დასასრულს,
sscanf ძალიან საშუალებას მისცემს მომხმარებელს, სხვადსხვა მიზეზის გამო მოხვდა spacebar 1 2 3 და რომ იქნება ლეგიტიმური.
ეს არ დაწეროთ ზე მომხმარებლის მხოლოდ იმიტომ, რომ ისინი მოხვდა spacebar დასაწყისში ან დასასრულს,
რომელიც მხოლოდ პატარა უფრო მოსახერხებელი.
>> ნებისმიერი კითხვები, მაშინ, on GetInts? ჰო?
[სტუდენტური კითხვაზე, გაუგებარია]
>> კარგი კითხვაა. რა მოხდება, თუ თქვენ უბრალოდ აკრეფილი char, ისევე როგორც F, და დააჭიროთ
გარეშე ოდესმე აკრეფით 1 2 3; როგორ ფიქრობთ ქცევა ამ ხაზი კოდი ამის შემდეგ იქნება?
ამიტომ sscanf შეიძლება დაფაროს, რომ ძალიან, რადგან ამ შემთხვევაში,
ის არ აპირებს შეავსოთ n ან C; ის აპირებს ნაცვლად დაბრუნების 0.
რა შემთხვევაში, მე ასევე არეალიდან, რომ სცენარი, რადგან მოსალოდნელ ღირებულების მინდა არის 1.
მე მხოლოდ მინდა 1 და მხოლოდ 1 რამ ივსება. კარგი კითხვაა. სხვა?
>> ყველა უფლება, მოდით არ გავლა ყველა ფუნქციების აქ,
მაგრამ ერთი, რომ როგორც ჩანს, ალბათ, დარჩენილი ინტერესი
არის GetString რადგან აღმოჩნდება, რომ GetFloat, GetInt,
GetDouble, GetLongLong ყველა punt ბევრი მათი ფუნქციებს GetString.
მოდით შევხედოთ თუ როგორ ხორციელდება აქ.
ეს ერთი გამოიყურება პატარა კომპლექსი, მაგრამ იგი იყენებს იგივე საფუძვლები
რომ ჩვენ ალაპარაკდა გასულ კვირას. ასე რომ GetString,
რომელიც იღებს არ არგუმენტი როგორც პოსტი ბათილად აქ,
და ის დააბრუნებს string, ამიტომ მე ვაცხადებ სიმებიანი ბუფერული.
მე ნამდვილად არ ვიცი, რა, რომ იქნება გამოყენებული არ არის, მაგრამ ჩვენ დავინახავთ.
ჰგავს სიმძლავრე, ჩვეულებრივ, 0; არ დანამდვილებით, სადაც ეს ხდება.
არ არის დარწმუნებული რა N იქნება გამოყენებული არ არის.
მაგრამ ახლა ის მიღების ცოტა უფრო საინტერესო, ასევე ხაზი 243,
ვაცხადებთ int გ, ეს არის ერთგვარი სულელური დეტალურად.
Char არის 8 ბიტი და 8 ბიტი შენახვა შეუძლია, თუ რამდენი სხვადასხვა ღირებულებების?
256. პრობლემა ისაა, თუ თქვენ გინდათ რომ აქვს 256 სხვადასხვა ASCII სიმბოლოებს,
რაც არსებობს, თუ ფიქრობთ, რომ უკან, და ეს არ არის რაღაც გვემახსოვრება.
მაგრამ თუ თქვენ ფიქრობთ, თავში რომ დიდი ASCII ჩარტში გვქონდა კვირის წინ
იყო, იმ შემთხვევაში, 128 ან 256 ASCII სიმბოლოებს.
ჩვენ ყველა ნიმუში 0 და 1 არის up.
სწორედ პრობლემა თუ გსურთ შეძლებს აღმოაჩინოს შეცდომა.
რადგან თუ თქვენ უკვე იყენებს 256 ფასეულობების თქვენი გმირები,
თქვენ არ ნამდვილად გეგმავენ წინ, რადგან ახლა არ გაქვთ გზა ამბობდა,
"ეს არ არის legit ხასიათი, ეს ზოგიერთი მცდარი გაგზავნა."
მერე რა მსოფლიო ჯერ არის, ისინი იყენებენ შემდეგი ფასეულობად,
რაღაც int ისე, რომ თქვენ გაქვთ Crazy რაოდენობის ბიტი,
32 4 მილიარდი შესაძლო მნიშვნელობებია, ასე რომ თქვენ შეგიძლიათ უბრალოდ დასრულდება up გამოყენებით,
არსებითად, 257 მათგანი, 1 რომლის აქვს განსაკუთრებული მნიშვნელობა როგორც შეცდომა.
>> მოდით ვნახოთ, როგორ ეს სამუშაოები. შეესაბამება 246, მაქვს ამ დიდი ხოლო loop
რომელიც მოუწოდებდა fgetc ვ მნიშვნელობა ფაილი, getc და შემდეგ stdin.
თურმე ეს მხოლოდ უფრო ზუსტად გზა რომ "წაიკითხა შეიტანენ კლავიატურაზე."
მიწოდების სტანდარტული საშუალებებით კლავიატურის, სტანდარტულ გამოსავალზე ნიშნავს ეკრანზე,
და სტანდარტული შეცდომა, რომელიც ჩვენ ვხედავთ pset 4, ნიშნავს ეკრანზე,
მაგრამ განსაკუთრებული ნაწილი ეკრანზე ასე რომ ის conflated
ფაქტობრივი გამომავალი რომ თქვენ აპირებდით ბეჭდვა, მაგრამ უფრო, რომ მომავალში.
ამიტომ fgetc უბრალოდ ნიშნავს წაიკითხა ხასიათი კლავიატურის, და ჩაწეროთ იგი აქ?
ჩაწეროთ იგი C და შემდეგ შეამოწმეთ, ამიტომ მე უბრალოდ გამოყენებით გარკვეული ლოგიკური conjunctions აქ,
შეამოწმეთ, რომ არ თანაბარი \ n, ამიტომ მომხმარებელს უკვე დააჭიროთ.
ჩვენ გვინდა, რომ შეწყვიტოს იმ ეტაპზე, ბოლოს მარყუჟი, და ჩვენ ასევე გვინდა შევამოწმოთ
ამისთვის სპეციალური მუდმივი, EOF, რომელიც თუ იცით ან გამოიცნოს - რას უჭერენ მხარს?
ფაილის დასასრულს. ასე რომ, ეს სახის nonsensical, რადგან თუ მე აკრეფის დროს კლავიატურაზე,
იქ მართლაც არ ფაილი ჩართული ამ,
მაგრამ ეს მხოლოდ სახის generic ტერმინს ვგულისხმობ
რომ არაფერი მოდის ადამიანის თითების. EOF. ფაილის დასასრულს.
როგორც განზე, თუ თქვენ ოდესმე მოხვდა კონტროლის დ თქვენს კლავიატურაზე,
არ, რომ თქვენ ჯერ კიდევ; თქვენ მოხვდა კონტროლის გ.
მაგრამ კონტროლის დ უგზავნის ამ სპეციალური მუდმივი მოუწოდა EOF.
>> ახლა ჩვენ მხოლოდ გარკვეული დინამიური მეხსიერების გამოყოფის.
ასე რომ, თუ n + 1> მოცულობა, ახლა მე ახსნას n.
N არის ზუსტად რამდენი ბაიტი არის ამჟამად ბუფერული,
სიმებიანი რომ თქვენ გაკეთებული მშენებლობაზე საწყისი მომხმარებელს.
თუ თქვენ გაქვთ მეტი სიმბოლოების თქვენი ბუფერული ვიდრე თქვენ გაქვთ შესაძლებლობები ბუფერული,
ინტუიციურად, თუ რა უნდა გავაკეთოთ შემდეგ არის გამოყოს მეტი ტევადობის.
მე ვაპირებ skim მეტი ზოგიერთი არითმეტიკა აქ
და ფოკუსირება მხოლოდ ამ ფუნქციას აქ.
თქვენ იცით, თუ რა არის malloc, ან თუნდაც ზოგადად იცნობს.
Take გამოიცანით რა realloc აკეთებს. [სტუდენტური პასუხი, გაუგებარია]
>> Yeah. და ეს არ საკმაოდ დასძინა მეხსიერება; ეს reallocates მეხსიერების შემდეგნაირად:
თუ მაინც ოთახი დასასრულს სიმებიანი გადმოგცეთ უფრო, რომ მეხსიერების
ვიდრე ეს თავდაპირველად გაძლევთ, მაშინ თქვენ მიიღებთ რომ დამატებითი მეხსიერება.
ასე რომ თქვენ შეგიძლიათ მხოლოდ აყენებს სიმები გმირები თავში დაბრუნება თავში დაბრუნება.
მაგრამ თუ ეს ასე არ არის საქმე, იმიტომ, რომ თქვენ დაელოდა გრძელია
და რაღაც შემთხვევითი მიიღო plopped მეხსიერებაში არსებობს, მაგრამ არსებობს დამატებითი
მეხსიერების ქვემოთ აქ, რომ okay. Realloc აპირებს ყველა მძიმე მოხსნას თქვენთვის,
გადაადგილება string თქვენ იკითხება ამგვარად შორს აქ,
დააყენა მისი დანგრევა იქ და შემდეგ მოგცემთ კიდევ რამდენიმე პოდიუმზე იმ ეტაპზე.
ამრიგად, ტალღა მხრივ, მინდა ვთქვა, რომ რა GetString აკეთებს
არის ის დაწყებული მცირე ბუფერული, იქნებ 1 Single ხასიათი,
და თუ მომხმარებლის ტიპების 2 გმირები, GetString მთავრდება
მოუწოდებდა realloc და ამბობს, "Ooh, 1 სიმბოლოს საკმარისი არ იყო.
მომეცი 2 სიმბოლო. ' თუ წაიკითხავთ მეშვეობით ლოგიკა მარყუჟის,
იგი აპირებს ამბობენ, 'Ooh, მომხმარებლის აკრეფილი 3 სიმბოლო.
მომეცი ახლა არ 2 მაგრამ 4 სიმბოლოზე, მაშინ მომეცი 8, მაშინ მაძლევს 16 და 32. "
ის ფაქტი, რომ მე გააორმაგოს მოცულობა ყოველ ჯერზე
იმას ნიშნავს, რომ ბუფერული არ აპირებს იზრდება ნელა.
იგი აპირებს იზრდება სუპერ სწრაფი, და რა შეიძლება იყოს უპირატესობა რომ?
რატომ გააორმაგოს ზომა ბუფერული, მიუხედავად იმისა, მომხმარებლის
შეიძლება უბრალოდ უნდა 1 დამატებითი ხასიათი კლავიატურის?
[სტუდენტური პასუხი, გაუგებარია]. >> რა არის რომ?
სწორედ. თქვენ არ იზრდება, როგორც ხშირად.
და ეს მხოლოდ სახის - you're ხეჯირების თქვენი ფსონები აქ.
იდეა მყოფი რომ თქვენ არ მინდა მოვუწოდო realloc ბევრი, რადგან ეს tends უნდა იყოს ნელი.
ნებისმიერ დროს თქვენ ჰკითხავთ მოქმედი სისტემის მეხსიერება, როგორც თქვენ მალე ვხედავ
in მომავალი პრობლემა კომპლექტი, იგი აპირებს გარკვეული დრო დაჭირდეს.
ასე რომ მინიმუმამდე შემცირების იმ დროის, თუნდაც თქვენ გაყვანაა გარკვეული სივრცე, tends იყოს კარგია.
>> მაგრამ თუ ჩვენ წაკითხულად მეშვეობით დასკვნითი ნაწილი GetString აქ,
და ისევ, გაგება თითოეული ხაზი აქ არ არის ასე მნიშვნელოვანი დღეს.
მაგრამ შეამჩნია, რომ ეს საბოლოოდ მოუწოდებს malloc ერთხელ, და ეს გამოყოფს
ზუსტად ისე, როგორც ბევრი bytes როგორც სჭირდება სიმებიანი
და მაშინ ისვრის შორს დარეკვით უფასო, ზედმეტად დიდი ბუფერული,
თუ იგი მართლაც მიიღო გაორმაგდა ძალიან ბევრჯერ.
მოკლედ, ასე GetString მუშაობს ყველა ამ დროს.
ყველა ეს იმას წაკითხვის ერთი ხასიათი დროს ისევ და ისევ და ისევ
და ყოველ ჯერზე მას სჭირდება დამატებითი მეხსიერება, იგი სთხოვს ოპერაციული სისტემის ეს დარეკვით realloc.
ნებისმიერი კითხვები? ყველა უფლება.
>> თავდასხმა. ახლა, როდესაც ჩვენ გვესმის პოინტერები, ან თუნდაც
უფრო იცნობს პოინტერები,
განვიხილოთ, თუ როგორ მთელი მსოფლიო იწყებს დაიშალოს
თუ თქვენ არ საკმაოდ წინააღმდეგ შეჯიბრებითობის მომხმარებლებს,
ადამიანები, რომლებიც ცდილობენ hack თქვენს სისტემაში.
ადამიანები, რომლებიც ცდილობენ მოიპარონ თქვენი პროგრამული უზრუნველყოფა მიერ circumventing ზოგიერთი სარეგისტრაციო კოდი
რომ მათ შეიძლება სხვაგვარად უნდა აკრიფოთ სისტემაში
შეხედეთ ამ მაგალითს აქ, რაც არის C კოდი
რომ აქვს ფუნქცია ძირითად ბოლოში, რომ მოუწოდებს ფუნქცია foo,
და ეს რა არის გავლით უნდა foo? [სტუდენტური] ერთჯერადი არგუმენტი.
>> უცოლო არგუმენტი. ამიტომ argv [1], რაც იმას ნიშნავს, პირველი სიტყვა მომხმარებლის აკრეფილი
ბრძანებათა ზოლს შემდეგ a.out ან რასაც პროგრამის ეწოდება.
ამიტომ foo, ზედა, იღებს in char *, მაგრამ char * მხოლოდ რა?
სიმებიანი. არაფერია ახალი აქ, და რომ სტრიქონს თვითნებურად მიმდინარეობს მოუწოდა ბარი.
ამ ხაზის აქ, char გ [12], ხოლო სახის ნახევრად ტექნიკური ინგლისური, რა არის ეს ხაზი აკეთებს?
მასივი -? პერსონაჟები. მომეცი მასივი 12 სიმბოლოს.
ასე რომ, ჩვენ შეიძლება მოვუწოდებთ ამ ბუფერულ. ეს ტექნიკურად მოუწოდა C, მაგრამ ბუფერულ პროგრამირებაში
მხოლოდ იმას ნიშნავს, bunch of სივრცეში, რომ თქვენ შეგიძლიათ განათავსოთ რაღაცები სისტემაში
>> მაშინ ბოლოს, memcpy, ჩვენ არ გამოიყენება ადრე.
მაგრამ თქვენ ალბათ შეუძლია გამოიცნოს, თუ რას აკეთებს. ეს აკოპირებს მეხსიერება.
რას აკეთებთ? ისე, ეს აშკარად აკოპირებს ბარი, მისი შეყვანის, შევიდა გ,
მაგრამ მხოლოდ სიგრძეზე ბარი.
მაგრამ bug აქ.
Okay, ასე ტექნიკურად ჩვენ უნდა ნამდვილად strlen (ბარი) x sizeof (char), რომ სწორი.
მაგრამ უარეს შემთხვევაში აქ, მოდით ვივარაუდოთ, რომ that's - ასე, okay.
მაშინ არსებობს 2 ბაგები. ამიტომ sizeof (char), ყველა უფლება, მოდით ეს ცოტა ფართო.
ასე რომ ახლა მაინც bug, რაც?
[სტუდენტური პასუხი, გაუგებარია] >> შემოწმება რა? Okay, ამიტომ ჩვენ უნდა შემოწმების
for null, რადგან ცუდი რამ ხდება, როცა თქვენი კურსორი არის NULL,
იმის გამო, რომ თქვენ შეიძლება დასრულდება მდე მიმდინარეობს, და თქვენ არ უნდა იყოს ოდესმე აპირებს null
მიერ dereferencing იგი * ოპერატორი.
ასე რომ კარგია, და რა ვაკეთებთ? ლოგიკურად არსებობს ხარვეზი აქაც.
[სტუდენტური პასუხი, გაუგებარია]
>> ამიტომ შეამოწმეთ თუ argc ≥ 2?
Okay, ასე არსებობს 3 შეცდომები ამ პროგრამის აქ.
ჩვენ არ შემოწმების თუ მომხმარებელი რეალურად აკრეფილი არაფერი შევიდა argv [1], კარგი.
რა არის მესამე bug? ჰო?
[სტუდენტური პასუხი, გაუგებარია] >> კარგი.
ასე გადავამოწმეთ ერთი სცენარი. ჩვენ მინიშნებით შემოწმდება არ კოპირება მეტი მეხსიერების
ვიდრე იქნებოდა აღემატებოდეს სიგრძეზე ბარი.
ასე რომ, თუ სიმებიანი მომხმარებლის აკრეფილი არის 10 სიმბოლომდე
ეს ამბობს, "მხოლოდ კოპირება 10 სიმბოლოს. '
და ეს okay, მაგრამ რა, თუ მომხმარებლის აკრეფილი სიტყვა ბრძანებათა ზოლში
მოსწონს 20 ხასიათი სიტყვა, ეს არის და განაცხადა, რომ ასლი 20 სიმბოლოებს ბარი შევიდა რა?
გ, სხვაგვარად ცნობილია როგორც ჩვენი ბუფერული, რაც იმას ნიშნავს, თქვენ უბრალოდ დაწერა მონაცემები
დან 8 byte ადგილებში, რომ თქვენ არ საკუთარი,
და თქვენ არ ფლობენ მათ გრძნობა, რომ თქვენ არასოდეს გამოყოფილი მათ.
ასე რომ, ეს რა საყოველთაოდ ცნობილია, როგორც ბუფერული overflow თავდასხმა,
ან ბუფერული overrun თავდასხმა და ეს თავდასხმა იმ გაგებით, რომ თუ მომხმარებელი
ან პროგრამა რომ დაურეკეთ ფუნქცია აკეთებს ამ maliciously,
რა ხდება შემდეგი შეიძლება იყოს საკმაოდ ცუდი.
>> მოდით შევხედოთ ამ სურათს აქ.
ეს სურათი წარმოადგენს თქვენი დასტის მეხსიერება.
და გავიხსენოთ, რომ ყოველ ჯერზე რეკავთ ფუნქცია,
თქვენ ამ პატარა ჩარჩო დასტის და შემდეგ კიდევ ერთი და მერე კიდევ ერთი და მერე მეორე.
და დღემდე ჩვენ უბრალოდ სახის რეფერირებადი ამ მოშორებით როგორც მართკუთხედების
ან იქნება ფორუმში ან ეკრანზე აქ.
მაგრამ თუ ჩვენ მიუახლოვდით ერთ იმ rectangles,
როცა რეკავთ ფუნქცია foo, აღმოჩნდება, რომ არსებობს უფრო დასტის
შიგნით რომ ფარგლებში და რომ მართკუთხედი
ვიდრე მხოლოდ X და Y და A და B, ისე, როგორც ვსაუბრობთ swap.
თურმე არსებობს ქვედა დონის ინფორმაცია
მათ შორის დაბრუნების მისამართზე.
გამოდის, როდესაც მთავარ მოუწოდებს foo, მთავარ უნდა აცნობოს foo
რა ძირითად მისამართი არის კომპიუტერის მეხსიერებაში.
რადგან, წინააღმდეგ შემთხვევაში, როგორც კი foo კეთდება შესრულებაში, როგორც ამ შემთხვევაში აქ,
ერთხელ თქვენ მიაღწიოს ამ მჭიდრო Curly გაუწიოს დასასრულს foo,
როგორ heck ამჯამად foo ვიცი სად კონტროლის პროგრამა უნდა წავიდეს?
თურმე პასუხი ამ კითხვაზე არის, რომ წითელი მართკუთხედი აქ.
ეს წარმოადგენს მაჩვენებელი და ეს მდე კომპიუტერში შესანახად, დროებით,
on ე.წ. დასტის მისამართი ძირითად ასე რომ როგორც კი foo კეთდება შესრულებაში,
კომპიუტერი იცის სად და რა ხაზი მთავარ დაბრუნებოდნენ.
შენახული ჩარჩო მაჩვენებელი ეხება მსგავსად ამ.
ჩარ * ბარი აქ წარმოადგენს რა?
ისე, ახლა ეს ლურჯი სეგმენტი აქ არის foo-ს ფარგლებში, თუ რა არის ბარი?
Okay, ასე ბარი არის მხოლოდ არგუმენტი foo ფუნქცია.
>> ახლა ჩვენ უკან ნაცნობი სურათი.
არსებობს უფრო პერსონალის და მეტი distractions ეკრანზე
მაგრამ ამ ღია ლურჯი სეგმენტი არის ის, რაც ჩვენ ხატვა chalkboard რაღაც მოსწონს swap.
სწორედ ფარგლებში ამისთვის foo და ერთადერთი, რაც მას ახლა არის ბარი,
რაც ამ პარამეტრს.
მაგრამ რა უნდა იყოს დასტის თანახმად, ამ კოდექსით აქ?
ჩარ გ [12]. ამიტომ, ჩვენ უნდა ნახოთ 12 მოედანზე მეხსიერება,
გამოყოფილი ცვლადში გ.
მართლაც გვაქვს, რომ ეკრანზე.
ძალიან ზევით არის გ [0], და შემდეგ ავტორი ამ დიაგრამაზე
არ გადაიტვირთოთ ხატვის ყველა კვადრატების მაგრამ არსებობს მართლაც არსებობს 12
რადგან თუ გადავხედავთ ქვედა მარჯვენა, გ [11], თუ ითვლიან საწყისი 0, არის 12 ასეთი bytes.
მაგრამ აქ პრობლემა: თუ საით არის გ მზარდი?
სახის დაბრუნება ქვემოთ, არა? თუ ეს იწყება ზედა და იზრდება ბოლოში,
არ ჰგავს ჩვენ დაუტოვებიათ საკუთარ თავს გაცილებით runway აქ ყველა.
ჩვენ სახის მოხატული საკუთარ თავს კუთხეში,
და რომ გ [11] არის სწორი წინააღმდეგ ბარი, რომელიც არის სწორი წინააღმდეგ დასტის ჩარჩო მაჩვენებელი,
რაც უფლებას წინააღმდეგ დაბრუნების მისამართი; არ მეტი ოთახი.
ასე რომ რა მნიშვნელობა, მაშინ, თუ თქვენ Screw up,
და თქვენ ცდილობენ კითხულობს 20 ბაიტი შევიდა 12-byte ბუფერული?
სად არიან 8 დამატებითი bytes აპირებს?
Inside ყველაფერი, რომელთაგან ზოგიერთი არის სუპერ მნიშვნელოვანია.
და ყველაზე მთავარია, პოტენციურად, არის წითელი ყუთი იქ დაბრუნების მისამართზე.
იმის გამო, რომ ვივარაუდოთ, რომ თქვენ ან შემთხვევით ან adversarially
გადავაწერო იმ 4 ბაიტი, რომ მომცეთ მისამართი,
არა მხოლოდ ნაგვის, მაგრამ ნომერი, რომელიც ხდება წარმოადგინოს ფაქტობრივი მისამართი მეხსიერება?
რა არის implicaiton, ლოგიკურად?
[სტუდენტური პასუხები, გაუგებარია] >> ზუსტად. როდესაც foo ბრუნდება
და ჰიტები, რომ curly გაუწიოს, პროგრამა აპირებს გაგრძელება არ დაბრუნდეს ძირითად,
ის დაბრუნებას აპირებს რასაც მისამართის რომ წითელი ყუთი.
>> ახლა კი, იმ შემთხვევაში, circumventing პროგრამული რეგისტრაციის,
რა არის მისამართი რომელიც მიმდინარეობს დაბრუნდა ფუნქცია
რომ ნორმალურად იღებს მოუწოდა შემდეგ თქვენ გადახდილი პროგრამული და inputted თქვენი სარეგისტრაციო კოდი?
თქვენ შეიძლება სახის ხრიკი კომპიუტერის შევიდა არ აპირებს, მაგრამ ამის ნაცვლად, იზრდებოდა აქ.
ან, თუ თქვენ მართლაც ჭკვიანი, მოწინააღმდეგის შეიძლება რეალურად აკრიფოთ დროს კლავიატურაზე,
მაგალითად, არ რეალურ სიტყვას, არ 20 სიმბოლო, მაგრამ ვარაუდობენ, იგი
ტიპის ზოგიერთ გმირები რომ წარმოადგენენ კოდი?
და ეს არ იქნება C კოდი, ეს იქნება გმირები
რომ წარმოადგენენ ორობითი მანქანა კოდები, 0 და 1 ს.
მაგრამ ვარაუდობენ, ისინი ჭკვიანი საკმარისი ამისათვის, რათა როგორმე ჩასვით შევიდა GetString სწრაფი
იმას, რაც არსებითად შედგენილი კოდი,
და ბოლო 4 ბაიტი გადავაწერო, რომ დაბრუნების მისამართი, და რა მისამართი ამჯამად რომ შეყვანის შემთხვევაში?
იგი ინახავს ამ წითელი სამკუთხედით მისამართი პირველი byte of ბუფერული.
ასე, რომ თქვენ უნდა იყოს მართლაც ჭკვიანი, და ეს არის ბევრი სასამართლო და შეცდომა
ცუდი ხალხი არსებობს, მაგრამ თუ შეგიძლიათ გაერკვნენ, თუ როგორ დიდი ამ ბუფერული არის,
ისეთი, რომ ბოლო რამდენიმე bytes in შეყვანის რომ თქვენს მიერ მოწოდებული პროგრამის
მოხდეს უნდა იყოს ექვივალენტური მისამართი დაწყების თქვენი ბუფერული,
შეგიძლიათ ამის გაკეთება. თუ ვიტყვით, ჩვეულებრივ, hello, და \ 0, არის ის, რაც მთავრდება ბუფერული.
მაგრამ თუ ჩვენ უფრო ჭკვიანი და ჩვენ შეავსოთ რომ ბუფერული რა ჩვენ მოვუწოდებთ generically თავდასხმა კოდი,
,,,: თავდასხმა, შეტევა, შეტევა, თავდასხმა, სადაც ეს მხოლოდ რაღაც რომ ჯერ რაღაც ცუდი.
ისე, რა მოხდება, თუ თქვენ მართლაც ჭკვიანი, თქვენ შეიძლება ამის გაკეთება:
წითელ ყუთში აქ არის თანმიმდევრობა ნომრები: 80, CO, 35, 08.
გაითვალისწინეთ, რომ სიას ხმების რომ აქ.
ეს წელს საპირისპირო მიზნით, მაგრამ უფრო, რომ სხვა დროს.
გაითვალისწინეთ, რომ ამ დაბრუნების მისამართი უკვე შეგნებულად შეცვლილი
ერთნაირი მისამართი აქ, არ მისამართი ძირითადი.
ასე რომ, თუ ცუდი ბიჭი არის სუპერ ჭკვიანი, იგი აპირებს მოიცავს, რომ თავდასხმა კოდი
მსგავსი რამ, 'წაშლა ყველა მომხმარებლის ფაილი.'
ან "ასლი პაროლები," ან "შექმნა მომხმარებლის ანგარიში, რომ შემიძლია შეხვიდეთ. '
არაფერი მოხვედრა, და ეს ორივე საფრთხე და ძალა C.
იმის გამო, რომ თქვენ გაქვთ მეხსიერების მეშვეობით პოინტერები
და შეგიძლიათ აქედან გამომდინარე წერენ არაფერი გსურთ შევიდა კომპიუტერის მეხსიერებაში.
შეგიძლიათ გააკეთოთ კომპიუტერის არაფერი გსურთ უბრალოდ
რომელმაც მას ხტომა გარშემო ფარგლებში საკუთარი მეხსიერების სივრცე.
ასე რომ, ამ დღეს, ამდენი პროგრამები და ამდენი საიტებზე, რომლებიც კომპრომეტირებული
მოვხარშოთ ქვემოთ ხალხი უპირატესობების ამ.
და ეს ალბათ, როგორიცაა super-დახვეწილი თავდასხმა,
მაგრამ ეს ყოველთვის არ დაიწყოს, რომ გზა.
>> რეალობაა ის, რომ რა ცუდი ხალხი ჩვეულებრივ გააკეთოთ,
თუ არა ეს პროგრამა ბრძანებაში ან GUI პროგრამის ან ნახვა,
არის უბრალოდ დაიწყოს უზრუნველყოფს სისულელეა.
თქვენ აკრიფოთ მართლაც დიდი სიტყვა შევიდა საძიებო ველში და დააჭიროთ,
და თქვენ დაველოდოთ თუ ნახვა დამსხვრევაზე.
ან თქვენ დაველოდოთ თუ პროგრამის მანიფესტებმა რაიმე შეცდომა გაგზავნა.
რადგან თუ თქვენ იღბლიანი, როგორც ცუდი ბიჭი,
და თქვენს მიერ მოწოდებული ზოგიერთი გიჟები შეყვანის რომ Crashes პროგრამა,
რაც იმას ნიშნავს, პროგრამისტი არ გავუსწრო თქვენი ცუდი საქციელის
რაც იმას ნიშნავს, თქვენ ალბათ შეუძლია, თან საკმარისი ძალისხმევა,
საკმარისი სასამართლო და შეცდომა, გაერკვნენ, თუ როგორ უნდა ეწარმოებინა უფრო ზუსტად თავდასხმა.
ასე რომ იმდენი ნაწილი უსაფრთხოების არა მხოლოდ თავიდან აცილების ამ თავდასხმების საერთოდ, მაგრამ გამოვლენის მათ
და რეალურად შევხედავთ ჟურნალებისთვის და ხედავს, თუ რა გიჟები საშუალებებით აქვს ხალხს აკრეფილი თქვენს ნახვა.
რა ძიება პირობები არ ხალხს აკრეფილი თქვენს ვებგვერდზე იმედები overflowing ზოგიერთი ბუფერული?
და ამ ყველა boils ქვემოთ მარტივი საფუძვლები რა მასივი,
და რას ნიშნავს გამოყოფას და გამოიყენოს მეხსიერების?
და დაკავშირებული, რომ, ძალიან, არის ამ.
>> მოდით უბრალოდ შეხედვით შიგნით დისკის კიდევ ერთხელ.
ასე, რომ თქვენ გავიხსენოთ საწყისი ორი კვირის წინ, რომ როდესაც თქვენ გადაიტანეთ ფაილები
თქვენი recycle bin ან ნაგვის შეიძლება, რა ხდება?
[სტუდენტური] არაფერი. >> Yeah, აბსოლუტურად არაფერს. საბოლოოდ, თუ თქვენ აწარმოებს დაბალი
on დისკზე, Windows ან Mac OS დაიწყება წაშლის ფაილი თქვენთვის.
მაგრამ თუ თქვენ გადაიტანეთ რაღაც არსებობს, მაშინ ეს სულაც არ ემუქრება.
ყველა თქვენი კოლოკაცია, მეგობარი ან ოჯახის წევრი უნდა გააკეთოს არის ორმაგად დაწკაპეთ და voila.
აქ ყველა sketchy ფაილი, რომელიც თქვენ სცადა წაშლა.
ასე რომ ყველაზე მეტად ჩვენს არანაკლებ ვიცით, რომ თქვენ უნდა მარჯვენა ღილაკით ან გააკონტროლოს click
და ცარიელი სანაგვე, ან რამე მაგდაგვარს.
მაგრამ მაშინაც, რომ არ გააკეთოს საკმაოდ შეასრულა.
რადგან მთავარი, რაც ხდება, როდესაც თქვენ გაქვთ ფაილი თქვენს ხისტ დისკზე
, რომელიც წარმოადგენს გარკვეული სიტყვის დოკუმენტი ან JPEG?
და ეს წარმოადგენს თქვენს ხისტ დისკზე, და ასე ვთქვათ ამ sliver აქ წარმოადგენს, რომ ფაილი,
და ის შედგება მთელი bunch of 0 და 1 ს.
რა ხდება, როდესაც თქვენ არა მხოლოდ გადაათრიეთ რომ ფაილი trashcan ან recycle bin,
არამედ დაცლას ეს?
სახის არაფერი. ეს არ არის აბსოლუტურად არაფერი არის.
ახლა კი უბრალოდ არაფერს, რადგან პატარა რამე მოხდება სახით ამ მაგიდასთან.
ამიტომ არსებობს გარკვეული მონაცემთა ბაზაში ან მაგიდასთან შიგნით კომპიუტერის მეხსიერების
რომ არსებითად არის 1 სვეტი ფაილების სახელები,
და 1 სვეტი for file ადგილმდებარეობის, სადაც ეს შეიძლება იყოს საიდან 123, მხოლოდ შემთხვევითი რიცხვების.
ასე რომ, ჩვენ შეიძლება რაღაც x.jpg, და საიდან 123.
და მერე რა იქნება, როდესაც თქვენ დაცლას თქვენი ურნის?
რომ მიდის. მაგრამ რა არ მიდიან არის 0 და 1 ს.
>> ასე რომ, რა, მაშინ, კავშირი pset 4?
ისე, ერთად pset 4, მხოლოდ იმიტომ, რომ ჩვენ შემთხვევით წაშლილია
კომპაქტური ფლეშ ბარათი ჰქონდა ყველა ეს ფოტოები,
ან უბრალოდ იმიტომ, რომ ეს ცუდი იღბალი გახდა კორუმპირებული,
არ ნიშნავს, რომ 0 და 1 ს არ ვართ ჯერ კიდევ არსებობს.
იქნებ რამდენიმე მათგანი იკარგება, რადგან რაღაც გაბმულ კორუმპირებული
იმ გაგებით, რომ ზოგიერთი 0 ს გახდა 1 და 1 ს გახდა 0 ს.
ცუდი რამ შეიძლება მოხდეს, რადგან buggy პროგრამული უზრუნველყოფის ან წუნდებული აპარატურა.
მაგრამ ბევრი იმ ბიტი, შესაძლოა, 100% მათგანი ჯერ კიდევ არსებობს,
უბრალოდ კომპიუტერი ან კამერა არ იცის სად JPEG 1 დაიწყო
და სადაც JPEG 2 დაიწყო, მაგრამ თუ, პროგრამისტი,
ვიცი, ერთად ცოტა საზრიანი, სადაც იმ JPEGs არიან ან რაც მათ ჰგავს,
შეგიძლიათ ანალიზი 0 და 1 და ამბობენ, 'Ooh. JPEG. Ooh, JPEG. '
თქვენ შეგიძლიათ დაწეროთ პროგრამა არსებითად მხოლოდ ან ხოლო loop
რომ აღდგება თითოეული იმ ფაილებს.
ასე რომ გაკვეთილი მაშინ, უნდა დაიწყოს "საიმედოდ" erasing ფაილი
თუ გსურთ თავიდან ასაცილებლად საერთოდ. დიახ?
[სტუდენტური კითხვაზე, გაუგებარია]
>> Have მეტი მეხსიერების ვიდრე გააკეთეთ თქვენ წინაშე -
Oh! კარგი კითხვაა. რატომ, მაშინ, შემდეგ ვასუფთავებ სანაგვე ყუთს,
ამჯამად თქვენს კომპიუტერში გითხრათ, რომ თქვენ უფრო მეტი თავისუფალი სივრცე, ვიდრე გააკეთეთ თქვენ წინაშე?
In მოკლედ, რადგან ეს ცრუობს. გაძლიერებული ტექნიკურად, თუ თქვენ ჩვენგან უფრო სივრცეში.
რადგან ახლა თქვენ არ განაცხადა, თქვენ შეგიძლიათ განათავსოთ სხვა პერსონალის სადაც ეს ფაილი ერთხელ იყო,
მაგრამ ეს არ ნიშნავს, ბიტი ვაპირებთ მოშორებით,
და ეს არ ნიშნავს, ბიტი მიმდინარეობს შეიცვალა ყველა 0 ს, მაგალითად, თქვენი დაცვა.
ამის საპირისპიროდ, თუ თქვენ "საიმედოდ" წაშლას ფაილი, ან ფიზიკური განადგურებით მოწყობილობის,
რომ ნამდვილად არის ერთადერთი გზა, ზოგჯერ, გარშემო რომ.
მაშ რატომ არ გვაქვს დატოვება რომ ნახევრად საშინელი შენიშვნა, და ვნახავთ თქვენ ორშაბათს.
CS50.TV