[Powered by Google Translate] [კვირა 5]
[დევიდ ჯ Malan - ჰარვარდის უნივერსიტეტი]
[ეს არის CS50. - CS50.TV]
>> ეს არის CS50, კვირა 5.
დღეს და ამ კვირაში, ჩვენ წარმოგიდგინოთ ცოტა სამყაროში სასამართლო ექსპერტიზის
კონტექსტში პრობლემა უცნობია 4.
დღეს იქნება შემოკლებით ლექცია რადგან არსებობს სპეციალური ღონისძიება აქ შემდგომ.
ამიტომ ჩვენ მიიღოს peek და აჯავრებენ ორივე სტუდენტებისა და მშობლების მსგავსად დღეს
ზოგიერთ რამ, რომლებიც ჰორიზონტზე.
>> მათ შორის, როგორც ორშაბათს, ჩვენ კიდევ რამდენიმე თანაკლასელები.
EDX, ჰარვარდის და MIT-ის ახალი ონლაინ ინიციატივას OpenCourseWare და მეტი,
იწყებს on ჰარვარდის ს კამპუსში ორშაბათს, ე.ი. მოვა ორშაბათი
მოგიწევთ, როგორც ბოლო მონაცემებით, 86.000 დამატებითი თანაკლასელები
ვინ იქნება შემდეგ ერთად CS50-ს ლექციები და სექციები
და walkthroughs და პრობლემა კომპლექტი.
და, როგორც ნაწილი ამ, თქვენ წევრები გახდებიან დამფუძნებელი კლასი CS50 და ახლა CS50x.
როგორც ნაწილი ამ ახლა, გააცნობიეროს, რომ იქნება გარკვეული upsides ისევე.
მისაღებად მზად ამისათვის განკუთვნილი მასიური რაოდენობის სტუდენტები,
საკმარისია ითქვას, რომ მიუხედავად იმისა, რომ ჩვენ გვაქვს 108 TFs და CAS,
ეს არ საკმაოდ საუკეთესო სტუდენტი-მასწავლებელს კოეფიციენტი ერთხელ ჩვენ მოხვდა 80,000 სტუდენტების.
ჩვენ არ ვაპირებთ უნდა შეფასების ამდენი პრობლემა ადგენს ხელით,
ასე გააცნო კვირას პრობლემა კომპლექტი იქნება CS50 შემოწმება,
რომელიც იქნება ბრძანება ხაზი კომუნალური ფარგლებში ელექტრო მოწყობილობების
რომ თქვენ მიიღებთ ერთხელ თქვენ განაახლოთ იგი მოგვიანებით ამ კვირის.
თქვენ გექნებათ აწარმოებს ბრძანება, check50, საკუთარ pset,
და თქვენ მიიღებთ მყისიერი კავშირი იმის შესახებ თუ რამდენად თქვენი პროგრამის სწორია ან არასწორი
შესაბამისად სხვადასხვა დიზაინის სპეციფიკაციები რომ ჩვენ გათვალისწინებული.
უფრო, რომ პრობლემა კომპლექტი სპეციფიკაცია.
CS50x თანაკლასელები იქნება გამოყენებისას ასევე.
>> პრობლემა Set 4 არის ყველაფერი ექსპერტიზის,
და ამ pset ნამდვილად შთაგონებული ზოგიერთი რეალურ ცხოვრებაში პერსონალის
რის, როდესაც მე ვიყავი სკოლის მე სტაჟირება ხნით
ერთად MIDDLESEX ქვეყნის რაიონული ადვოკატმა ოფისში აკეთებს სასამართლო მუშაობას
მათი ტყვიის სასამართლო გამომძიებელი.
რა ამ შეადგინა, როგორც ვფიქრობ, აღნიშნული რამდენიმე კვირის წარსულში,
არის მასობრივი სახელმწიფო პოლიციის ან სხვა მოვიდოდა წელს,
ისინი Drop off რამ, როგორიცაა მყარი დისკები და CD და ფლოპი დისკები და მოსწონს,
და მაშინ მიზანი სასამართლო ექსპერტიზის ბიურო ადგენს
არსებობდა თუ არა ან არ იყო მტკიცებულება გარკვეული.
ეს იყო სპეციალურ გამოკვლევათა განყოფილება, ასე რომ თეთრი საყელო დანაშაული.
ეს უფრო შემაშფოთებელი სახის დანაშაული, რაც ეხება რაღაც ციფრული მედია.
თურმე არ არის, რომ ბევრი ადამიანი ვწერთ ელ სიტყვებით "მე ეს."
ამიტომ ხშირად, ამ სასამართლო მოძებნილი არ ოჯახიდან ყველა რომ ბევრი რამ ხილი,
მაგრამ ზოგჯერ ხალხი წერენ ასეთ წერილებს.
ასე რომ, ზოგჯერ, ძალისხმევა დაჯილდოვდნენ.
>> მაგრამ უხელმძღვანელოს მდე ამ სასამართლო pset, ჩვენ უნდა შემოღების წელს pset4 ცოტა გრაფიკა.
თქვენ სავარაუდოდ ეს ყველაფერი თავისთავად ცხადად - JPEGs, GIFs და მოსწონს - ამ დღეებში.
მაგრამ თუ მართლაც დაფიქრდით, გამოსახულება, ჰგავს რობ სახე,
შეიძლება მოდელირებული როგორც თანმიმდევრობა წერტილების ან pixels.
იმ შემთხვევაში, რობ სახე, არსებობს ყველა სახის ფერები,
და დავიწყეთ ვხედავ ინდივიდუალური წერტილები, სხვაგვარად ცნობილია როგორც პიქსელი,
ერთხელ დავიწყეთ zoom სისტემაში
მაგრამ თუ ჩვენ გამარტივება მსოფლიოში ბიტიანი და უბრალოდ ვთქვა, რომ ეს აქ არის რობ შავი და თეთრი,
წარმოადგინოს შავი და თეთრი, ჩვენ შეგვიძლია მხოლოდ გამოიყენოთ ორობითი.
და თუ ჩვენ ვაპირებთ გამოვიყენოთ ორობითი, 1 ან 0, ჩვენ შეგვიძლია გამოვხატოთ ამ იმავე სახედ
of Rob მისი მომღიმარი სახე ამ მაგალითზე ბიტი.
11000011 წარმოადგენს თეთრი, თეთრი, შავი, შავი, შავი, შავი, თეთრი, თეთრი.
და ამიტომ არ უზარმაზარი ნახტომი შემდეგ უნდა დაიწყოს ლაპარაკი ფერადი ფოტოსურათი,
რამ, რომ ნეტავ ნახე Facebook ან მოახდინოს ციფრული კამერა.
მაგრამ, რა თქმა უნდა, როდესაც საქმე ფერები, საჭიროა უფრო მეტი ბიტი.
და საკმაოდ გავრცელებულია მსოფლიოს ფოტოები, გამოვიყენოთ არ 1-bit ფერი,
როგორც ამ ვარაუდს, მაგრამ 24-bit ფერი, სადაც თქვენ რეალურად კიდევ მილიონობით ფერები.
ასე რომ, როგორც იმ შემთხვევაში, როდესაც ჩვენ zoomed წელს რობ თვალი,
რომ იყო ნებისმიერი რაოდენობის მილიონობით სხვადასხვა ფერად შესაძლებლობები.
ამიტომ ჩვენ ამ თანამედროვე პრობლემების Set 4 ისევე როგორც walkthrough,
რაც იქნება დღეს 3:30 ნაცვლად ჩვეულებრივი 2:30 გამო პარასკევის ლექცია აქ.
მაგრამ ვიდეო იქნება ხაზზე როგორც ყოველთვის ხვალ.
>> ჩვენ ასევე წარმოგიდგინოთ სხვა ფაილის ფორმატი.
ეს განზრახ ნიშნავდა თვალი დაშინებას თავდაპირველად,
მაგრამ ეს მხოლოდ ზოგიერთ დოკუმენტაცია C struct.
თურმე Microsoft წლის წინ დაეხმარა პოპულარიზაცია ამ ფორმატში
მოუწოდა Bitmap ფაილის ფორმატი, BMP, და ეს იყო სუპერ მარტივია, ფერადი გრაფიკული ფაილის ფორმატი
რომელიც გამოიყენება საკმაოდ გარკვეული დრო და ზოგჯერ მაინც ამისთვის ფონები on კომპიუტერები.
თუ ფიქრობთ თავში Windows XP და მოძრავი ბორცვები და ლურჯი ცა,
რომ იყო ტიპიურად bmp ან Bitmap image.
Bitmaps არიან fun ჩვენთვის, რადგან მათ უფრო მეტი სირთულის.
ეს არ არის საკმაოდ მარტივია, როგორც ამ ქსელში 0S და 1s.
ამის ნაცვლად, თქვენ გაქვთ რამ, როგორიცაა header დაწყების ფაილი.
ასე რომ, სხვა სიტყვებით, შიგნით. Bmp ფაილი მთელი bunch of 0S და 1s,
მაგრამ არსებობს რამდენიმე დამატებითი 0S და 1s იქ.
და აღმოჩნდება, რომ ის, რაც ჩვენ, ალბათ მიღებული გაიცემა წლის -
ფაილის ფორმატში. doc ან. XLS ან. mp3. mp4, რაც ფორმატის
რომ თქვენ იცნობს - რას კი ნიშნავს ფაილის ფორმატი,
იმიტომ, დღის ბოლოს ყველა ეს ფაილი გამოიყენება მხოლოდ 0S და 1s.
და იქნებ იმ 0S და 1s წარმოადგენს ABC მეშვეობით ASCII ან მოსწონს,
მაგრამ დღის ბოლოს, ის მაინც მხოლოდ 0S და 1s.
ასე რომ ადამიანები უბრალოდ ზოგჯერ გადაწყვეტენ გამოგონება ახალი ფაილის ფორმატი
სადაც ისინი standardize რა ნიმუში ბიტი რომელიც რეალურად ნიშნავს.
და ამ შემთხვევაში აქ, დაკარგულია შექმნილია Bitmap ფაილის ფორმატი
განაცხადა, რომ პირველივე byte წელს Bitmap ფაილი, როგორც აღნიშნა მიერ ოფსეტური 0 იქ,
იქ იქნება გარკვეული cryptically დაასახელა ცვლადში bfType,
რომელიც მხოლოდ დგას Bitmap ფაილის ტიპი, რა ტიპის Bitmap ფაილი ამ.
შეგიძლიათ infer ალბათ მეორე რიგის, რომ ოფსეტური 2, byte ნომერი 2,
აქვს ნიმუში 0S და 1s, რომელიც წარმოადგენს რა? ზომა რაღაც.
და ეს გრძელდება იქიდან.
ასე რომ პრობლემა Set 4, თქვენ უნდა ფეხით ისეირნა ზოგიერთი რამ.
ჩვენ არ დასრულდება მდე ზრუნვა ყველა მათგანი.
მაგრამ შენიშნავს იწყება მიიღოს საინტერესო გარშემო byte 54: rgbtBlue, მწვანე, და წითელი.
თუ თქვენ ოდესმე მსმენია აბრევიატურა RGB - წითელი, მწვანე, ლურჯი - ეს არის მინიშნება, რომ
რადგან თურმე შეგიძლიათ ხატავს ყველა ფერის Rainbow
ზოგიერთი კომბინაცია წითელი და ლურჯი და მწვანე.
ფაქტია, მშობლები ოთახში შეიძლება გავიხსენოთ ზოგიერთი ადრეული პროექტორები.
ამ დღეებში, უბრალოდ ვხედავ ერთი ნათელი შუქი გამოდის ობიექტივი,
მაგრამ უკან დღეში გქონდათ წითელი ობიექტივი, ლურჯი ლინზები, და მწვანე ლინზები,
და ერთად ისინი მიზნად ისახავს ეკრანზე და ჩამოყალიბდა ფერადი სურათი.
და საკმაოდ ხშირად, შუა სკოლებსა და უმაღლეს სასწავლებლებში ექნება იმ ლინზები
ოდესმე ისე ოდნავ askew, ასე რომ თქვენ იყო ერთგვარი ხედავს ორმაგი ან სამმაგი images.
მაგრამ ეს იყო იდეა. თქვენ ჰქონდა წითელი და მწვანე და ლურჯი შუქი ხატავდა სურათს.
და რომ იგივე პრინციპი გამოიყენება კომპიუტერებს.
>> ამიტომ შორის გამოწვევები მაშინ თქვენთვის პრობლემა Set 4 ვაპირებთ იყოს ცოტა რამ.
ერთი არის რეალურად შეცვლის გამოსახულება, მიიღოს in ნიმუში 0S და 1s,
გაერკვნენ, რომელიც მოცულობით 0S და 1s წარმოადგენენ რა სტრუქტურის მსგავსად,
და შემდეგ გაერკვნენ, თუ როგორ უნდა replicate პიქსელი - Reds, ბლუზის, მწვანილი -
შიგნით, ისე, რომ როდესაც სურათს ასე გამოიყურება თავდაპირველად,
ეს შესაძლოა ასე გამოიყურება ნაცვლად ამის შემდეგ.
შორის სხვა გამოწვევები ძალიან იქნება, რომ თქვენ უნდა გადასცეს სასამართლო გამოსახულება
საქართველოს ფაქტობრივი ფაილი ციფრული კამერა.
და რომ კამერა, ერთხელ, იყო მთელი bunch of ფოტო.
პრობლემა ჩვენ შემთხვევით წაშლილია ან ჰქონდა გამოსახულება დაზიანებულია როგორღაც.
ცუდი რამ მოხდეს ციფრული ფოტოკამერები.
და ამიტომ ჩვენ სწრაფად გადაწერა ყველა 0S და 1s გამორთვა რომ ბარათი თქვენ,
გადაარჩინა მათ ყველა ერთ დიდი ფაილი, და მაშინ საბოლოოდ დავრწმუნდებით გადასცემს მათ თქვენთვის პრობლემა უცნობია 4
ასე რომ, თქვენ შეგიძლიათ დაწეროთ პროგრამა C რომელთანაც ფეხზე ყველა იმ JPEGs, იდეალურად.
და აღმოჩნდება, რომ JPEGs, მიუხედავად იმისა, რომ ისინი გარკვეულწილად კომპლექსური ფაილის ფორმატი -
ისინი ბევრად უფრო რთული, ვიდრე ეს მომღიმარი სახე აქ -
აღმოჩნდება, რომ ყველა JPEG იწყება იგივე ნიმუში 0S და 1s.
ასე გამოყენებით, საბოლოოდ, ხოლო მარყუჟი ან ამისთვის მარყუჟი ან მსგავსი,
შეგიძლიათ iterate ყველა 0S და 1s ამ სასამართლო გამოსახულება,
და ყოველ ჯერზე ხედავთ სპეციალური ნიმუში რომ განსაზღვრული პრობლემა კომპლექტი სპეციფიკაცია,
თქვენ შეიძლება ვივარაუდოთ, აქ არის, ძალიან დიდი ალბათობით, დაწყების JPEG.
და როგორც კი შეამჩნევთ იგივე ნიმუში გარკვეული რაოდენობის ბაიტი
ან kilobytes ან მეგაბაიტები შემდეგ თქვენ შეიძლება ვივარაუდოთ, აქ არის მეორე JPEG,
ფოტო ავიღე შემდეგ პირველი.
ნება მომეცით შეჩერება კითხულობს, რომ პირველი ფაილი, წერა ამ ახლის,
და გამომავალი თქვენი პროგრამის pset4 იქნება, როგორც ბევრი როგორც 50 JPEGs.
და თუ ეს ასე არ არის 50 JPEGs, თქვენ გაქვთ ცოტა loop.
თუ თქვენ გაქვთ უსასრულო რაოდენობის JPEGs, თქვენ გაქვთ უსასრულო ციკლი.
ასე რომ ძალიან იქნება საკმაოდ გავრცელებული შემთხვევა.
ასე რომ რა ჰორიზონტზე.
>> Quiz 0 ჩვენს უკან, გააცნობიეროს თითო ჩემი ელ რომ უცვლელად არსებობს დაკარგულია ორივე ბედნიერი,
სახის ნეიტრალური, და სამწუხარო გარშემო ვიქტორინა 0 დრო.
და გთხოვთ, ნუ მივაწვდინოთ ჩემთვის, უფროსი TF Zamyla, თქვენი საკუთარი TF,
ან ერთი CAS რომ თქვენ იცით, თუ გსურთ განიხილავს, თუ როგორ წავიდა.
>> ასე რომ შთაბეჭდილების მშობლები აქ ოთახში, რა არის CS50 ბიბლიოთეკა?
[სიცილის] კარგად იმუშავა.
რა არის CS50 ბიბლიოთეკა? Yeah. >> [სტუდენტი] ეს წინასწარი წერილობითი კომპლექტი კოდი [inaudible]
Okay, კარგი.
ეს წინასწარი წერილობითი კომპლექტი კოდი, რომ ჩვენ თანამშრომლებს წერდა, ჩვენ უზრუნველყოფს თქვენ,
რომელიც უზრუნველყოფს ზოგიერთი საერთო ფუნქციონალური,
პერსონალის მოსწონს get me სიმებიანი, get me int - ყველა ფუნქციებს, რომლებიც აქ ჩამოთვლილი.
>> დაწყებული ახლა ჩვენ დავიწყებთ ნამდვილად მიიღოს ამ სასწავლო თვლები off.
ჩვენ ვაპირებთ დავიწყოთ წართმევას სიმებიანი თქვენგან,
რომელიც გაწვევას იყო სინონიმი რა ფაქტობრივი მონაცემების ტიპის? >> [მრავალჯერადი სტუდენტებს] ჩარ *.
ჩარ *. მშობლებისთვის, რომ იყო ალბათ [ხდის whooshing sound]. ეგ კარგია.
ჩარ * დავიწყებთ, რათა ეკრანზე უფრო როგორც ჩვენ ამოიღონ სიმებიანი ჩვენი ლექსიკა,
მინიმუმ როდესაც საქმე რეალურად წერა კოდი.
ანალოგიურად, ჩვენ შეწყვიტოს გამოყენებით ზოგიერთი ფუნქციების იმდენი
რადგან ჩვენი პროგრამების ვაპირებთ კიდევ უფრო დახვეწილი.
და არა მხოლოდ წერენ პროგრამებს, იჯდეს იქ სწრაფი მოციმციმე,
ელოდება მომხმარებელს აკრიფოთ რაღაც, თქვენ შეძლებთ თქვენი საშუალებებით საწყისი სხვაგან.
მაგალითად, თქვენ შეძლებთ მათ სერია ბიტი ადგილობრივ ხისტ დისკზე.
თქვენ ნაცვლად მიიღონ მათ მომავალში საწყისი ქსელის კავშირი,
ზოგიერთი ნახვა სადღაც.
>> მოდით კანი უკან ამ ფენას პირველად და გაიყვანოს up CS50 ელექტრო მოწყობილობების
და ეს ფაილი სახელად cs50.h, რომელიც თქვენ უკვე # ჩათვლით კვირების განმავლობაში,
მაგრამ მოდით რეალურად ხედავთ რა შიგნით ამ.
ზევით ფაილის ლურჯი მხოლოდ მთელი bunch of კომენტარები:
გარანტია ინფორმაცია და ლიცენზირებას.
ეს არის ერთგვარი საერთო პარადიგმის პროგრამული უზრუნველყოფა
რადგან ბევრი პროგრამული უზრუნველყოფის ამ დღეებში რასაც ღია წყაროებიდან,
რაც იმას ნიშნავს, რომ ვიღაცას არ გაუკეთებია კოდი და გახადა უფასოა
არა მხოლოდ გასაშვებად და გამოიყენოს მაგრამ რეალურად წაიკითხა და შეცვალოს და ინტეგრაციას საკუთარ სამუშაოს.
ასე რომ სწორედ ეს თქვენ უკვე გამოყენებით, ღია პროგრამული, თუმცა ძალიან მცირე ფორმით.
თუ მე გადახვევა ქვემოთ წარსულში კომენტარი, თუმცა, დავიწყებთ რამდენიმე უფრო ნაცნობი რამ.
Notice ზედა აქ რომ cs50.h ფაილი მოიცავს მთელი bunch of header ფაილი.
ყველაზე ამ, ჩვენ არ მინახავს ადრე, მაგრამ ერთი კარგად იცნობს.
ჩამოთვლილთაგან რომელი არ ჩვენ ვხედავთ, თუმცა მოკლედ, ჯერჯერობით? >> [სტუდენტი] სტანდარტული ბიბლიოთეკა.
ჰო, სტანდარტულ ბიბლიოთეკაში. stdlib.h აქვს malloc.
ერთხელ ჩვენ ალაპარაკდა დინამიური მეხსიერების გამოყოფის,
რაც ჩვენ დაბრუნდება მომავალ კვირას ასევე დავიწყეთ მათ შორის ფაილი.
თურმე bool და ჭეშმარიტი და ყალბი არ რეალურად არსებობს C თავისთავად
თუ თქვენ მოიცავს ამ ფაილის აქ.
ჩვენ კვირების განმავლობაში იყო მათ შორის stdbool.h
ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ცნება bool, ჭეშმარიტი ან მცდარი.
ამის გარეშე, თქვენ უნდა დაალაგოთ ფალსიფიცირებული და გამოიყენოთ int
და მხოლოდ თვითნებურად ვივარაუდოთ, რომ 0 არის ყალბი და 1 მართალია.
თუ ჩვენ გადახვევა ქვემოთ შემდგომი, აქ არის ჩვენი დეფინიცია სიმებიანი.
თურმე, როგორც ჩვენ დაწყებამდე განაცხადა, რომ სადაც ეს ვარსკვლავი არის ნამდვილად არ აქვს.
თქვენ კი აქვს სივრცის გარშემო.
ჩვენ ამ სემესტრში უკვე ხელშეწყობა, როგორც ეს ნათლად
რომ ვარსკვლავი არ უკავშირდება ტიპის,
მაგრამ რეალიზება ისევე როგორც საერთო, თუ არ უფრო საერთო,
არის დააყენოს ის არსებობს, მაგრამ ფუნქციურად ეს იგივე.
მაგრამ ახლა თუ ვკითხულობთ ქვემოთ შემდგომი, მოდით შევხედოთ GetInt
რადგან ჩვენ გამოიყენება, რომ შესაძლოა პირველ ადრე არაფერი ამ სემესტრში.
აქ არის GetInt. ეს არის რა? >> [სტუდენტი] პროტოტიპი. >> ეს არის მხოლოდ პროტოტიპი.
ხშირად, ჩვენ დააყენა პროტოტიპები დროს დაპყრობა ჩვენი. გ ფაილი
მაგრამ თქვენ შეგიძლიათ დააყენა პროტოტიპები in header ფაილი. თ ფაილი, როგორც ეს ერთი აქ
ასე რომ როდესაც წერთ ზოგიერთი ფუნქციების რომ გსურთ სხვა ხალხს შეძლებს გამოიყენოს,
სწორედ საქმე CS50 ბიბლიოთეკა,
თქვენ არა მხოლოდ განახორციელოს თქვენი ფუნქციების რაღაც cs50.c,
თქვენ ასევე დააყენა პროტოტიპები არ ზედა რომ ფაილის მაგრამ ზედა header ფაილი.
მაშინ რომ header ფაილი რა მეგობრებისა და კოლეგების მოიცავს
ერთად # მოიცავს საკუთარ კოდი.
ასე რომ მთელი ამ ხნის, თქვენ უკვე მათ შორის ყველა ამ პროტოტიპების,
ეფექტურად ზედა თქვენი ფაილის მაგრამ გზით ამ # მოიცავს მექანიზმი,
რომელიც არსებითად ასლები და პასტები ამ ფაილის შევიდა საკუთარი.
აქ არის რამდენიმე საკმაოდ დეტალური დოკუმენტაცია.
ჩვენ საკმაოდ ბევრი მიღებული მიანიჭა, რომ GetInt იღებს int,
მაგრამ აღმოჩნდება, რომ არსებობს კუთხეში შემთხვევებში.
რა მოხდება, თუ მომხმარებლის ტიპების ხმების რომ გზა ძალიან დიდია, quintillion,
რომ უბრალოდ ვერ ჯდება შიგნით int? რა არის მოსალოდნელი ქცევა?
იდეალურ შემთხვევაში, ეს პროგნოზირებადი.
ასე რომ, ამ შემთხვევაში, თუ თქვენ ნამდვილად წაიკითხა ჯარიმა ბეჭდვითი,
თქვენ რეალურად ვხედავთ, რომ თუ ხაზი არ იკითხება, ამ ბრუნდება INT_MAX.
ჩვენ არასდროს არ ისაუბრა, თუმცა ეფუძნება მის კაპიტალიზაცია, რა არის ეს, ალბათ?
[სტუდენტი] მუდმივი. >> ეს მუდმივი.
ეს რაღაც განსაკუთრებული მუდმივი რომ ალბათ განაცხადა ერთ იმ header ფაილი
რომ up მაღალია ფაილი, და INT_MAX ალბათ რაღაც უხეშად 2 მილიარდ
იდეა მყოფი რომ რადგან ჩვენ გვჭირდება, რათა როგორმე ნიშნავდეს, რომ რაღაც არ მოხდა ისე,
ჩვენ, დიახ, აქვს 4 მილიარდი ნომრები ჩვენს ხელთ არსებული: -2 მილიარდი მდე 2 მილიარდი, მისცეს ან მიიღოს.
ისე, რა არის საერთო პროგრამირებაში არის თქვენ მოიპაროს მხოლოდ ერთი იმ ნომრებს,
იქნებ 0, იქნებ 2 მილიარდი, იქნებ -2 მილიარდ
ასე რომ თქვენ ხარჯავთ ერთი თქვენი შესაძლო მნიშვნელობებია ასე რომ თქვენ შეგიძლიათ ჩაიდინოს მსოფლიოს
რაიმე რომ მიდის არასწორი, მე დაბრუნდება ამ სუპერ დიდი მნიშვნელობა.
მაგრამ არ გსურთ მომხმარებლის აკრეფით რაღაც cryptic მოსწონს 234 ..., მართლაც დიდი რაოდენობის.
თქვენ განზოგადება ის ნაცვლად, როგორც მუდმივი.
ასე ნამდვილად, თუ თქვენ მიმდინარეობდა anal ბოლო რამდენიმე კვირის განმავლობაში, ნებისმიერ დროს მოუწოდა GetInt,
თქვენ უნდა ყოფილიყო შემოწმების ერთად, თუ მდგომარეობა გააკეთეს მომხმარებლის ტიპის INT_MAX,
ან, უფრო კონკრეტულად კი, არ GetInt დაბრუნების INT_MAX, რადგან თუ ეს მოხდა,
რომ რეალურად ნიშნავს, რომ ისინი არ აკრიფოთ იგი. რაღაც მოხდა ისე ამ შემთხვევაში.
ასე რომ, ეს რა საყოველთაოდ ცნობილია, როგორც Sentinel ღირებულებით, რაც მხოლოდ იმას ნიშნავს, სპეციალური.
>> მოდით ახლა იქცეს. გ ფაილი.
C ფაილის არსებობდა ელექტრო გარკვეული დროის განმავლობაში.
და ფაქტობრივად, ელექტრო აქვს წინასწარ შედგენილი თქვენთვის შევიდა, რომ რამ ჩვენ მოუწოდა ობიექტის კოდი,
მაგრამ ეს უბრალოდ არ აქვს მნიშვნელობა თქვენ სადაც რადგან სისტემა იცის
ამ შემთხვევაში, სადაც ეს არის: ელექტრო მოწყობილობების.
მოდით გადახვევა ქვემოთ ახლა GetInt და ვნახავთ, როგორ GetInt მუშაობს ყველა ამ დროს.
აქ მსგავსი კომენტარები წინაშე.
ნება მომეცით დიდი ზომით უბრალოდ კოდი ნაწილი.
და რა გვაქვს ამისთვის GetInt ასეთია.
იგი იღებს არ შეყვანის.
ის დააბრუნებს int, ხოლო (ნამდვილი), ამიტომ ჩვენ გვაქვს მიზანმიმართულ უსასრულო ციკლი,
მაგრამ სავარაუდოდ ჩვენ შესვენება აქედან როგორღაც ან დაბრუნების შიგნიდან ამ.
>> ვნახოთ, როგორ ეს სამუშაოები.
ჩვენ როგორც ჩანს გამოყენებით GetString ამ პირველი ხაზი შიგნით მარყუჟის, 166.
ეს არის კარგი პრაქტიკა, რადგან თუ რა გარემოებებში შეიძლება GetString დაბრუნდნენ
სპეციალური სიტყვით NULL? >> [სტუდენტი] თუ რამე მიდის არასწორი.
თუ რამე მიდის არასწორი. და რა შეიძლება გადასვლა არასწორი როცა რეკავთ რაღაც GetString?
Yeah. >> [სტუდენტი] Malloc ვერ მისცეს მას ints.
Yeah. იქნებ malloc ვერ.
სადღაც ქვეშ Hood, GetString მოუწოდებს malloc, რომელიც გამოყოფს მეხსიერება,
რომელიც საშუალებას კომპიუტერულ მაღაზიაში ყველა გმირები
რომ მომხმარებლის ტიპის შევიდა კლავიატურაზე.
და ვარაუდობენ მომხმარებლის ჰქონდა მთელი ბევრი თავისუფალი დრო და აკრეფილი მეტი, მაგალითად,
ვიდრე 2 მილიარდი სიმბოლოების, უფრო გმირები, ვიდრე კომპიუტერში კი აქვს RAM.
GetString უნდა შეძლებს ნიშნავდეს, რომ თქვენ.
მაშინაც კი, თუ ეს არის სუპერ, სუპერ იშვიათია კუთხეში შემთხვევაში,
მას, რათა როგორმე შეძლებს გაუმკლავდეს ამ,
და ასე GetString, თუ წავედით უკან და წაიკითხეთ მისი დოკუმენტაცია, აქვს რეალურად დაბრუნების null.
ახლა თუ ვერ GetString მიერ დაბრუნების NULL, GetInt აპირებს ვერ მიერ დაბრუნების INT_MAX
ისევე როგორც Sentinel. ეს არის უბრალოდ ადამიანის კონვენციებს.
ერთადერთი გზა თქვენ ამას, რომ ეს არის საქმე, რომელსაც კითხულობს დოკუმენტაცია.
>> მოდით გადახვევა ქვემოთ სადაც int ფაქტობრივად მიღებული.
თუ მე გადახვევა ქვემოთ bit შემდგომი, შეესაბამება 170, გვაქვს კომენტარის ზემოთ აღნიშნული ხაზები.
ჩვენ განაცხადოს 172 int, N, და char, C, და შემდეგ ამ ახალ ფუნქციას,
რაც ზოგიერთი თქვენ stumbled მასშტაბით ადრე, sscanf.
ეს დგას სიმებიანი scanf.
სხვა სიტყვებით, მომეცი სიმებიანი და მე იქნება სკანირების ეს დარტყმები ინფორმაციის ინტერესის.
რას ნიშნავს ეს?
დავუშვათ, რომ მე აკრიფოთ, სიტყვასიტყვით, 123 ზე კლავიატურის და შემდეგ დააჭიროთ.
რა არის მონაცემები გაცნობის 123 როდესაც დაბრუნდა მიერ GetString? >> [სტუდენტი] სიმებიანი.
ეს აშკარად სტრიქონს, არა? მე მივიღე სიმებიანი.
ასე რომ 123 მართლაც, ციტირებით-unquote, 123 ერთად \ 0 მიწურულს იგი.
ეს არ არის int. ეს არ არის რიცხვი. როგორც ჩანს ხმების მაგრამ არა რეალურად.
რას GetInt უნდა გავაკეთოთ?
მას აქვს სკანირების რომ სიმებიანი მარცხნიდან მარჯვნივ - 123 \ 0 - და რატომღაც კონვერრტაციისთვის ფაქტობრივი რიცხვი.
თქვენ შეიძლება გაერკვნენ, თუ როგორ უნდა გავაკეთოთ ეს.
თუ ფიქრობთ თავში pset2, თქვენ სავარაუდოდ მიიღო პატარა კომფორტულად Caesar
ან Vigenere, ასე რომ თქვენ შეგიძლიათ iterate მეტი ტექსტი, თქვენ შეგიძლიათ დააკონვერტიროთ chars to ints.
მაგრამ heck, ეს მთელი ბევრი სამუშაოა.
რატომ არ გამოიძახა ფუნქცია, როგორიცაა sscanf რომ აკეთებს, რომ თქვენთვის?
ამიტომ sscanf მოელის არგუმენტი - ამ შემთხვევაში მოუწოდა ხაზი, რომელიც სიმებიანი.
მაშინ მოცემული შეთავაზებები, ძალიან ჰგავს printf, რას მოველით, რომ ნახოთ ამ სიმებიანი.
და რა მე ვამბობ, აქ მე მოველი, რომ ნახოთ ათობითი ნომერი და იქნებ ხასიათი.
და ვნახავთ, თუ რატომ არის ამ შემთხვევაში რაღაც მომენტში.
და აღმოჩნდება, რომ ამ ნოტაცია არის თქვენში პერსონალის ჩვენ ალაპარაკდა
მხოლოდ ერთი კვირის წინ.
რა არის & n და & C აკეთებს ჩვენთვის აქ? >> [სტუდენტი] მისამართი N და მისამართი გ.
Yeah. ეს მაძლევს მისამართი N და მისამართი გ. რატომ არის, რომ მნიშვნელოვანი?
თქვენ იცით, რომ ფუნქციონირებს C, თქვენ ყოველთვის შეგიძლიათ დაბრუნების ღირებულება ან ფასი არ არის.
თქვენ შეგიძლიათ დაბრუნების int, string, float, char, რასაც, ან შეგიძლიათ დაბრუნებას ბათილად,
მაგრამ შეგიძლიათ მხოლოდ დაბრუნებას ერთი რამ მაქსიმალურად.
მაგრამ აქ ჩვენ გვინდა sscanf დაბრუნების ჩემთვის იქნებ int, ათობითი რიცხვი,
და ასევე char, და მე რატომ char in მომენტში.
თქვენ ეფექტურად მინდა sscanf დაბრუნების ორი რამ, მაგრამ ეს უბრალოდ არ შეიძლება C.
თქვენ შეგიძლიათ იმუშაოთ გარშემო რომ გავლით ორ მისამართები
რადგან, როგორც კი თქვენ გადასცემს ფუნქცია ორი მისამართები,
რა შეიძლება, რომ გავაკეთოთ ფუნქცია მათთან? >> [სტუდენტი] დაწერეთ იმ მისამართებზე.
მას შეუძლია დაწეროს იმ მისამართებზე.
თქვენ შეგიძლიათ გამოიყენოთ ვარსკვლავი ოპერაცია და იქ, ყოველი იმ მისამართებზე.
ეს ერთგვარი ამ თავში კარის მექანიზმი, მაგრამ ძალიან ხშირი შეცვლის ღირებულებების ცვლადებსა
მეტი, ვიდრე უბრალოდ ერთი ადგილი - ამ შემთხვევაში, ორი.
ახლა შეამჩნია მე შემოწმება == 1 და შემდეგ დაბრუნების n თუ ეს ასეა, ფაქტობრივად, შეაფასებს ჭეშმარიტი.
ასე რომ, რა ხდება? ტექნიკურად, რიგში, ჩვენ ნამდვილად გვინდა მოხდეს GetInt ეს.
ჩვენ გვინდა გარჩევის, ასე ვთქვათ, ჩვენ გვინდა წაიკითხოთ string - ციტირებით-unquote 123 -
და თუ ეს ასე გამოიყურება არსებობს მთელი რიგი არსებობს, რა ჩვენ ვეუბნებით sscanf გავაკეთოთ
ისიც, რომ ნომერი - 123 - ამ ცვლადის N ჩემთვის.
რატომ მაშინ მე რეალურად ამ ისევე?
რა არის როლი sscanf ამბობდა თქვენ შესაძლოა, ასევე მიიღოთ ხასიათი აქ?
[Inaudible სტუდენტი საპასუხოდ] >> ათობითი წერტილი რეალურად შეეძლო მუშაობა.
მოდით გამართავს, რომ ეგონა, ერთი წუთით. რა?
[სტუდენტი] ეს შეიძლება იყოს null. >> კარგი აზრის. ეს შეიძლება იყოს null ხასიათი.
ეს რეალურად არ არის ამ შემთხვევაში. Yeah. >> [სტუდენტი] ASCII.
ASCII. ან ნება მომეცით განზოგადება კიდევ უფრო.
% C არსებობს მხოლოდ შეცდომა შემოწმებისას.
ჩვენ არ გვინდა იქ იქნება ხასიათი შემდეგ ნომერი,
მაგრამ რა ამ საშუალებას ჩემთვის გააკეთოთ შემდეგ.
თურმე sscanf, გარდა შენახვის ღირებულებების N და გ ამ მაგალითად აქ,
თუ რას ასევე ამჯამად არის ის დააბრუნებს რაოდენობის ცვლადები ეს დააყენა ღირებულებების სისტემაში
ასე რომ, თუ თქვენ მხოლოდ აკრიფოთ 123, მაშინ მხოლოდ% d აპირებს მატჩი,
და მხოლოდ N იღებს შენახვას ღირებულება მოსწონს 123,
და არაფერი იღებს დასვა გ.
C რჩება ნაგვის ღირებულება, ასე ვთქვათ -
ნაგვის რადგანაც ეს არასდროს ინიციალიზაცია ზოგიერთ ღირებულება.
ასე რომ ამ შემთხვევაში, sscanf დააბრუნებს 1, რადგან მე დასახლებულ 1 იმ მითითებას,
ამ შემთხვევაში დიდი, მე int მე გასათავისუფლებლად ხაზი უფასოა მეხსიერება
რომ GetString რეალურად გამოყოფილი, და მერე დაბრუნდნენ N,
სხვას თუ თქვენ ოდესმე გვაინტერესებდა, სადაც ეს გამეორება განაცხადი მოდის, მოდის უფლება აქ.
ასე რომ, თუ, პირიქით, მე აკრიფოთ 123foo - რამოდენიმე შემთხვევითი თანმიმდევრობა ტექსტი -
sscanf აპირებს ვხედავ ნომერი, ნომერი, ნომერი, ვ,
და ის გეგმავს 123 წელს n; ის გეგმავს ვ დო და შემდეგ დაბრუნების 2.
ამიტომ, უბრალოდ გამოყენებით ძირითადი განსაზღვრება sscanf ქცევა, ძალიან მარტივი გზა -
ასევე, რთული ერთი შეხედვით, მაგრამ დღის ბოლოს საკმაოდ მარტივი მექანიზმი -
საქართველოს ამბობდა არის int და თუ ასეა, ის არის, რომ ერთადერთი, რაც მე?
და whitespace აქ არის მიზანმიმართული.
თუ თქვენ წაიკითხავთ დოკუმენტაცია sscanf, ეს გიჩვენებთ, რომ თუ თქვენ მოიცავს ნაჭერი whitespace
დასაწყისში ან ბოლოს, sscanf ძალიან საშუალებას მისცემს მომხმარებელს, სხვადსხვა მიზეზის გამო,
მოხვდა სივრცეში ბარი 123 და რომ იქნება ლეგიტიმური.
თქვენ არ დაწეროთ ზე მომხმარებლის მხოლოდ იმიტომ, რომ ისინი მოხვდა სივრცეში ბარი
დასაწყისში ან დასასრულს, რომელიც მხოლოდ პატარა უფრო მოსახერხებელი.
>> ნებისმიერი კითხვები შემდეგ GetInt? Yeah. >> [სტუდენტი] რა მოხდება თუ თქვენ უბრალოდ დასვა char?
კარგი კითხვაა.
რა მოხდება, თუ თქვენ უბრალოდ აკრეფილი char მოსწონს ვ და დააჭიროთ გარეშე ოდესმე აკრეფით 123?
როგორ ფიქრობთ, ქცევის ამ ხაზი კოდი ამის შემდეგ იქნება?
[Inaudible სტუდენტი საპასუხოდ]
ჰო, ისე sscanf შეიძლება დაფაროს, რომ რადგან ამ შემთხვევაში, ის არ აპირებს შეავსოთ n ან გ.
იგი აპირებს ნაცვლად დაბრუნების 0, ამ შემთხვევაში მე ასევე არეალიდან, რომ სცენარი
რადგან მოსალოდნელ ღირებულების მინდა არის 1.
მე მხოლოდ მინდა ერთი და მხოლოდ ერთი რამ უნდა იყოს შევსებული. კარგი კითხვაა.
>> სხვა? ყველა უფლება.
>> მოდით არ გავლა ყველა ფუნქციების აქ,
მაგრამ ერთი, რომ, როგორც ჩანს, ალბათ დარჩენილი ინტერესი არის GetString
რადგან აღმოჩნდება, რომ GetFloat, GetInt, GetDouble, GetLongLong
ყველა punt ბევრი მათი ფუნქციებს GetString.
მოდით შევხედოთ თუ როგორ ხორციელდება აქ.
ეს ერთი გამოიყურება პატარა კომპლექსი, მაგრამ იგი იყენებს იგივე საფუძვლები
რომ ჩვენ ალაპარაკდა გასულ კვირას.
In GetString, რომელიც იღებს არ არგუმენტი როგორც პოსტი ბათილად აქ
და ის დააბრუნებს string, მე აშკარად ვაცხადებ სიმებიანი ბუფერული.
მე ნამდვილად არ ვიცი, რა, რომ იქნება გამოყენებული არ არის, მაგრამ ჩვენ დავინახავთ.
როგორც ჩანს სიმძლავრე იყოს 0.
არ დანამდვილებით, სადაც ეს ხდება, არ არის დარწმუნებული რა N აპირებს იქნას გამოყენებული არ არის,
მაგრამ ახლა ის მიღების ცოტა უფრო საინტერესო.
შეესაბამება 243, ვაცხადებთ, int, გ.
ეს არის ერთგვარი სულელური დეტალურად.
Char არის 8 ბიტი და 8 ბიტი შენახვა შეუძლია, თუ რამდენი სხვადასხვა ღირებულებების? >> [სტუდენტი] 256. >> 256.
პრობლემა ის არის, თუ გნებავთ აქვს 256 სხვადასხვა ASCII სიმბოლოებს, რომელიც არსებობს
თუ ფიქრობთ, რომ უკან - და ეს არ არის რაღაც გვემახსოვრება.
მაგრამ თუ თქვენ ფიქრობთ, თავში რომ დიდი ASCII ჩარტში გვქონდა კვირის წინ
იყო ამ შემთხვევაში 128 ან 256 ASCII სიმბოლოებს.
ჩვენ ყველა ნიმუში 0S და 1s up.
სწორედ პრობლემა თუ გსურთ შეძლებს აღმოაჩინოს შეცდომა
რადგან თუ თქვენ უკვე იყენებს 256 ფასეულობების თქვენი გმირები,
თქვენ არ ნამდვილად გეგმავენ ადრე რადგან ახლა არ გაქვთ გზა ამბობდა,
ეს არ არის legit ხასიათი, ეს არის გარკვეული მცდარი გაგზავნა.
მერე რა მსოფლიო ჯერ არის ისინი იყენებენ შემდეგი ფასეულობად, რაღაც int,
ასე, რომ თქვენ გაქვთ Crazy რაოდენობის ბიტი, 32, 4 მილიარდი შესაძლო მნიშვნელობებია
ასე რომ თქვენ შეგიძლიათ უბრალოდ დასრულდება up გამოყენებით არსებითად 257 მათგანი,
1 რომლის აქვს განსაკუთრებული მნიშვნელობა როგორც შეცდომა.
>> მოდით ვნახოთ, როგორ ეს სამუშაოები.
შეესაბამება 246, მაქვს ამ დიდი ხოლო loop, რომელიც მოუწოდებდა fgetc,
ვ მნიშვნელობა ფაილი, ასე getc და შემდეგ stdin.
თურმე ეს მხოლოდ უფრო ზუსტად გზა ამბობდა წაიკითხა შეიტანენ კლავიატურაზე.
მიწოდების სტანდარტული საშუალებებით კლავიატურის, სტანდარტულ გამოსავალზე ნიშნავს ეკრანზე,
და სტანდარტული შეცდომა, რომელიც ჩვენ ვხედავთ pset4, ნიშნავს ეკრანზე
მაგრამ განსაკუთრებული ნაწილი ეკრანზე ასე რომ ის conflated ფაქტობრივი გამომავალი
რომ თქვენ აპირებდით ბეჭდვა. მაგრამ უფრო, რომ მომავალში.
ამიტომ fgetc უბრალოდ ნიშნავს წაიკითხა ხასიათი კლავიატურის და ჩაწეროთ იგი აქ?
ჩაწერს მას გ.
და შემდეგ შეამოწმოთ - ასე მე უბრალოდ გამოყენებით გარკვეული ლოგიკური conjunctions აქ -
შეამოწმეთ, რომ არ თანაბარი - \ n, ამიტომ მომხმარებელს უკვე დააჭიროთ, ჩვენ გვინდა, შეწყვიტოს იმ ეტაპზე,
დასასრულს loop - და ჩვენ გვინდა შევამოწმოთ სპეციალური მუდმივი EOF,
რომელიც თუ იცით ან გამოიცნოს, რას უჭერენ მხარს? >> [სტუდენტი] ფაილის დასასრულს. >> ფაილის დასასრულს.
ეს არის სახის nonsensical რადგან თუ მე აკრეფის დროს კლავიატურაზე,
იქ მართლაც არ ფაილი ჩართული ამ,
მაგრამ ეს მხოლოდ სახის generic ტერმინს ვგულისხმობ
რომ არაფერი მოდის ადამიანის თითების.
EOF - ფაილის დასასრულს.
როგორც განზე, თუ თქვენ ოდესმე მოხვდა კონტროლის D თქვენს კლავიატურაზე, არ, რომ თქვენ ჯერ კიდევ -
თქვენ მოხვდა კონტროლის C - საკონტროლო D უგზავნის ამ სპეციალური მუდმივი მოუწოდა EOF.
ახლა ჩვენ მხოლოდ გარკვეული დინამიური მეხსიერების გამოყოფის.
>> ასე რომ, თუ (n + 1> სიმძლავრის). ახლა მე ახსნას n.
N არის ზუსტად რამდენი ბაიტი არის ამჟამად ბუფერული,
სიმებიანი რომ თქვენ გაკეთებული მშენებლობაზე საწყისი მომხმარებელს.
თუ თქვენ გაქვთ მეტი სიმბოლოების თქვენი ბუფერული ვიდრე თქვენ გაქვთ შესაძლებლობები ბუფერული,
ინტუიციურად, თუ რა უნდა გავაკეთოთ შემდეგ არის გამოყოს მეტი ტევადობის.
ამიტომ მე ვაპირებ skim მეტი ზოგიერთი არითმეტიკა აქ და ფოკუსირება მხოლოდ ამ ფუნქციას აქ.
თქვენ იცით, თუ რა არის malloc ან მინიმუმ ზოგადად იცნობს.
Take გამოიცანით რა realloc აკეთებს. >> [სტუდენტი] ამატებს მეხსიერება.
ეს არ საკმაოდ დასძინა მეხსიერება. ეს reallocates მეხსიერების შემდეგნაირად.
თუ მაინც ოთახი დასასრულს სიმებიანი გადმოგცეთ უფრო, რომ მეხსიერების
ვიდრე ეს თავდაპირველად გაძლევთ, მაშინ თქვენ მიიღებთ რომ დამატებითი მეხსიერება.
ასე რომ თქვენ შეგიძლიათ მხოლოდ შეინარჩუნოს აყენებს სიმებიანი მისი გმირები თავში დაბრუნება თავში დაბრუნება.
მაგრამ თუ ეს ასე არ არის საქმე, რადგან თქვენ დაელოდა გრძელია
და რაღაც შემთხვევითი გაბმულ plopped მეხსიერებაში არსებობს
მაგრამ არსებობს დამატებითი მეხსიერების ქვემოთ აქ, რომ okay.
Realloc აპირებს ყველა მძიმე მოხსნას თქვენთვის,
გადაადგილება string თქვენ იკითხება ამგვარად შორს აქ, დაუსვან მას იქ,
და შემდეგ მოგცემთ კიდევ რამდენიმე პოდიუმზე იმ ეტაპზე.
>> ამრიგად, ტალღა მხრივ, მინდა ვთქვა, რომ რა GetString აკეთებს
არის ის დაწყებული მცირე ბუფერული, იქნებ ერთი ხასიათი,
და თუ მომხმარებლის ტიპის ორ გმირები, GetString მთავრდება მოუწოდებდა realloc და აცხადებს,
ერთი პერსონაჟი არ იყო საკმარისი; მომეცი ორი სიმბოლო.
თუ წაიკითხავთ მეშვეობით ლოგიკა მარყუჟის, იგი აპირებს ამბობენ
მომხმარებლის აკრეფილი 3 გმირები; მომეცი ახლა არ 2 მაგრამ 4 სიმბოლოზე,
მაშინ მაძლევს 8, მაშინ მაძლევს 16 და 32.
ის ფაქტი, რომ მე გააორმაგოს მოცულობა ყოველ ჯერზე
იმას ნიშნავს, რომ ბუფერული არ აპირებს იზრდება ნელა, ის აპირებს იზრდება სუპერ სწრაფი.
და რა შეიძლება იყოს უპირატესობა რომ?
რატომ გააორმაგოს ზომა ბუფერული
მიუხედავად იმისა, რომ შესაძლოა მომხმარებლის უბრალოდ უნდა ერთი ზედმეტი ხასიათი კლავიატურის?
[Inaudible სტუდენტი საპასუხოდ] >> რა არის რომ? >> [სტუდენტი] თქვენ არ იზრდება, როგორც ხშირად.
სწორედ. თქვენ არ იზრდება, როგორც ხშირად.
და ეს მხოლოდ სახის თქვენ ხეჯირების თქვენი ფსონები აქ,
იდეა მყოფი რომ თქვენ არ მინდა მოვუწოდო realloc ბევრი რადგან ეს tends უნდა იყოს ნელი.
ნებისმიერ დროს თქვენ ჰკითხავთ მოქმედი სისტემის მეხსიერება,
როგორც თქვენ მალე დავინახავთ მომავალში პრობლემა კომპლექტი, იგი აპირებს გარკვეული დრო დაჭირდეს.
ასე რომ მინიმუმამდე შემცირების იმ დროის, თუნდაც თქვენ გაყვანაა გარკვეული სივრცე,
tends იყოს კარგია.
>> მაგრამ თუ ჩვენ წაკითხულად მეშვეობით დასკვნითი ნაწილი GetString აქ -
და ისევ გაგება თითოეული ხაზი აქ არ არის ასე მნიშვნელოვანი დღეს -
შეამჩნია, რომ ეს საბოლოოდ მოუწოდებს malloc ერთხელ
და ეს გამოყოფს ზუსტად როგორც ბევრი bytes როგორც სჭირდება სიმებიანი
და მაშინ ისვრის შორს დარეკვით უფასო ზედმეტად დიდი ბუფერული
თუ იგი მართლაც მიიღო გაორმაგდა ძალიან ბევრჯერ.
ასე მოკლედ, ასე GetString მუშაობს ყველა ამ დროს.
ყველა ეს სულაც წაკითხვის ერთი ხასიათი დროს ისევ და ისევ და ისევ,
და ყოველ ჯერზე მას სჭირდება დამატებითი მეხსიერება, იგი სთხოვს ოპერაციული სისტემის ეს
დარეკვით realloc.
>> ნებისმიერი კითხვები? ყველა უფლება.
>> თავდასხმა.
ახლა, როდესაც ჩვენ გვესმის პოინტერები ან თუნდაც უფრო იცნობს პოინტერები,
განვიხილოთ, თუ როგორ მთელი მსოფლიო იწყებს დაიშალოს
თუ თქვენ არ საკმაოდ წინააღმდეგ შეჯიბრებითობის მომხმარებლებს,
ადამიანები, რომლებიც ცდილობენ hack თქვენს სისტემას,
ადამიანები, რომლებიც ცდილობენ მოიპარონ თქვენი პროგრამული უზრუნველყოფა მიერ circumventing ზოგიერთი სარეგისტრაციო კოდი
რომ მათ შეიძლება სხვაგვარად უნდა აკრიფოთ სისტემაში
>> შეხედეთ ამ მაგალითს აქ, რაც არის C კოდი, რომელსაც აქვს ფუნქცია ძირითად ბოლოში
რომ უწოდებს ფუნქცია foo. და რა არის ის გვერდის ავლით, რათა foo?
[სტუდენტი] ერთჯერადი არგუმენტი. >> [Malan] ერთჯერადი არგუმენტი.
ამიტომ argv [1], რაც იმას ნიშნავს, პირველი სიტყვა, რომელიც მომხმარებლის აკრეფილი ბრძანებათა ზოლს
შემდეგ a.out ან რასაც პროგრამის ეწოდება.
ამიტომ foo ზედა იღებს in char *. მაგრამ char * მხოლოდ რა? >> [სტუდენტი] სიმებიანი.
[Malan] ტექსტი, ასე რომ არაფერი ახალი აქ.
რომ სტრიქონს თვითნებურად მიმდინარეობს მოუწოდა ბარი.
ამ ხაზის აქ, char გ [12], ხოლო სახის ნახევრად ტექნიკური ინგლისური, რა არის ეს ხაზი აკეთებს?
[სტუდენტი] მასივი - >> მასივი? >> [სტუდენტი] პერსონაჟები. >> პერსონაჟები.
მომეცი მასივი 12 სიმბოლოს. ასე რომ, ჩვენ შეიძლება მოვუწოდებთ ამ ბუფერულ.
ეს ტექნიკურად მოუწოდა C, მაგრამ ბუფერულ პროგრამირებაში მხოლოდ იმას ნიშნავს, bunch of სივრცეში
შეგიძლიათ განათავსოთ რაღაცები სისტემაში
მაშინ ბოლოს, memcpy ჩვენ არ გამოიყენება ადრე, მაგრამ თქვენ ალბათ შეუძლია გამოიცნოს, თუ რას აკეთებს.
ეს აკოპირებს მეხსიერება. რას აკეთებთ?
ეს აშკარად აკოპირებს ბარი, მისი შეყვანის, შევიდა გ მაგრამ მხოლოდ სიგრძეზე ბარი.
მაგრამ bug აქ. >> [სტუდენტი] თქვენ უნდა sizeof ხასიათი. >> Okay.
ტექნიკურად, ჩვენ უნდა ნამდვილად strlen (ბარი) * sizeof (char)). რომ სწორი.
მაგრამ უარეს შემთხვევაში აქ, მოდით ვივარაუდოთ, რომ that's -
Okay. მაშინ არსებობს ორი შეცდომები.
ამიტომ sizeof (char));
მოდით ამ პატარა უფრო ფართო.
ასე რომ ახლა მაინც bug, რაც? >> [Inaudible სტუდენტი საპასუხოდ]
ვცადოთ რა? >> [სტუდენტი] შეამოწმეთ for null.
ჩვენ უნდა ზოგადად იყოს შემოწმების for null რადგან ცუდი რამ ხდება
როდესაც თქვენი კურსორი არის NULL რადგან თქვენ შეიძლება დასრულდება მდე მიმდინარეობს,
და თქვენ არ უნდა იყოს ოდესმე აპირებს null მიერ dereferencing იგი ვარსკვლავი ოპერატორს.
ასე რომ კარგია. და რა ვაკეთებთ? ლოგიკურად, არსებობს ხარვეზი აქაც.
[სტუდენტი] შეამოწმეთ თუ argc არის> = to 2.
ამიტომ შეამოწმეთ თუ argc არის> = 2. Okay, ასე რომ სამი შეცდომები ამ პროგრამის აქ.
ჩვენ ახლა შემოწმების თუ მომხმარებელი რეალურად აკრეფილი არაფერი შევიდა argv [1]. კარგი.
რა არის მესამე bug? Yeah. >> [სტუდენტი] C შეიძლება არ იყოს დიდი საკმარისი.
კარგი. გადავამოწმეთ ერთი სცენარი.
ჩვენ მინიშნებით შემოწმდება არ კოპირება მეტი მეხსიერების ვიდრე იქნებოდა აღემატებოდეს სიგრძეზე ბარი.
ასე რომ, თუ სიმებიანი მომხმარებლის აკრეფილი არის 10 სიმბოლომდე
ამ ამბობს მხოლოდ კოპირება 10 სიმბოლოს. და ეს okay.
მაგრამ რა, თუ მომხმარებლის აკრეფილი სიტყვა ბრძანებათა ზოლზე მოსწონს 20-ხასიათი სიტყვა?
ეს ამბობს ასლი 20 სიმბოლოებს ბარი შევიდა რა?
C, სხვაგვარად ცნობილია როგორც ჩვენი ბუფერული, რაც იმას ნიშნავს, თქვენ უბრალოდ დაწერა მონაცემები
დან 8 byte ადგილებში, რომ თქვენ არ საკუთარი,
და თქვენ არ ფლობენ მათ გრძნობა, რომ თქვენ არასოდეს გამოყოფილი მათ.
ასე რომ, ეს რა საყოველთაოდ ცნობილია, როგორც ბუფერული overflow თავდასხმა ან ბუფერული overrun თავდასხმა.
და ეს თავდასხმა იმ გაგებით, რომ თუ მომხმარებელი ან პროგრამა რომ დაურეკეთ ფუნქცია
აკეთებს ამ maliciously, რაც სინამდვილეში ხდება შემდეგი შეეძლო რეალურად საკმაოდ ცუდი.
>> მოდით შევხედოთ ამ სურათს აქ.
ეს სურათი წარმოადგენს თქვენი დასტის მეხსიერება.
შეგახსენებთ, რომ ყოველ ჯერზე რეკავთ ფუნქცია თქვენ ამ პატარა ჩარჩო დასტის
და შემდეგ კიდევ ერთი და მერე კიდევ ერთი და სხვა.
და დღემდე, ჩვენ უბრალოდ სახის რეფერირებადი ამ როგორც მართკუთხედების
ან ფორუმში ან ეკრანზე აქ.
მაგრამ თუ ჩვენ მიუახლოვდით ერთ იმ მართკუთხედების, როცა რეკავთ ფუნქცია foo,
აღმოჩნდება, რომ არსებობს უფრო დასტის შიგნით რომ ჩარჩო ამ მართკუთხედი
ვიდრე მხოლოდ X და Y და A და B, ისე, როგორც ვსაუბრობთ swap.
თურმე არსებობს გარკვეული ქვედა დონის დეტალები, მათ შორის დაბრუნება მისამართი.
გამოდის, როდესაც მთავარ მოუწოდებს foo, მთავარ უნდა აცნობოს foo
რა ძირითად მისამართი არის კომპიუტერის მეხსიერების
რადგან, წინააღმდეგ შემთხვევაში, როგორც კი foo კეთდება შესრულებაში, როგორც ამ შემთხვევაში აქ,
ერთხელ თქვენ მიაღწიოს ამ დახურულ Curly გაუწიოს დასასრულს foo,
როგორ heck ამჯამად foo ვიცი სად კონტროლის პროგრამა უნდა წავიდეს?
თურმე პასუხი ამ კითხვაზე არის ამ წითელი სამკუთხედით აქ.
ეს წარმოადგენს მაჩვენებელი და ეს მდე კომპიუტერში შესანახად დროებით
on ე.წ. დასტის მისამართი ძირითად ასე რომ როგორც კი foo კეთდება შესრულებაში,
კომპიუტერი იცის სად და რა ხაზი მთავარ დაბრუნებოდნენ.
შენახული კარკასი მაჩვენებელი ეხება მსგავსად ამ.
ჩარ * ბარი აქ წარმოადგენს რა?
ახლა ეს ლურჯი სეგმენტი აქ არის foo-ს ფარგლებში. რა არის ბარი?
ბარი არის მხოლოდ არგუმენტი foo ფუნქცია.
ახლა ჩვენ უკან სახის ნაცნობი სურათი.
არსებობს უფრო პერსონალის და მეტი distractions ეკრანზე,
მაგრამ ამ ღია ლურჯი სეგმენტი მხოლოდ ის არის, რაც ჩვენ ხატვა chalkboard
ამისთვის რაღაც swap. სწორედ ფარგლებში ამისთვის foo.
და ერთადერთი, რაც მას ახლა არის ბარი, რომელიც ამ პარამეტრს.
მაგრამ რა უნდა იყოს დასტის მიხედვით ეს კოდი აქ?
[სტუდენტი] char გ [12]. >> [Malan] char გ [12].
ჩვენ ასევე უნდა ნახოთ 12 სკვერები მეხსიერების გამოყოფილი ცვლადში გ,
და მართლაც გვაქვს, რომ ეკრანზე.
ძალიან ზევით არის გ [0], და შემდეგ ავტორი ამ დიაგრამაზე
არ გადაიტვირთოთ ხატვის ყველა მოედნები, მაგრამ არსებობს მართლაც არსებობს 12
რადგან თუ გადავხედავთ ქვედა მარჯვენა, გ [11] თუ ითვლიან საწყისი 0 არის მე -12 ასეთი byte.
მაგრამ აქ პრობლემა.
თუ საით არის გ მზარდი?
სახის დაბრუნება ქვემოთ თუ იგი იწყება ზედა და იზრდება ბოლოში.
ეს არ ჰგავს ჩვენ დაუტოვებიათ საკუთარ თავს გაცილებით runway აქ ყველა.
ჩვენ სახის მოხატული საკუთარ თავს კუთხეში,
და რომ გ [11] არის სწორი წინააღმდეგ ბარი, რომელიც არის სწორი წინააღმდეგ შენახული კარკასი მაჩვენებელი,
რაც უფლებას წინააღმდეგ დაბრუნება მისამართი. არ არსებობს უფრო მეტი ოთახი.
ასე რომ რა მნიშვნელობა თუ თქვენ Screw up
და თქვენ ცდილობენ კითხულობს 20 ბაიტი შევიდა 12-byte ბუფერული?
სად არიან 8 დამატებითი bytes აპირებს? >> [სტუდენტი] Inside -
Inside ყველაფერი, რომელთაგან ზოგიერთი არის სუპერ მნიშვნელოვანია.
და ყველაზე მთავარია, პოტენციურად, არის წითელი ყუთი იქ დაბრუნება მისამართი,
რადგან ვარაუდობენ, რომ თქვენ ან შემთხვევით ან adversarially გადავაწერო იმ 4 ბაიტი,
რომ მომცეთ მისამართი, არა მხოლოდ ნაგვის მაგრამ ნომერი
ეს მოხდება, რათა წარმოადგინოს ფაქტობრივი მისამართი მეხსიერებაში.
რა გავლენა, ლოგიკურად? >> [სტუდენტი] ფუნქცია დაბრუნებას აპირებს სხვადასხვა ადგილას.
სწორედ.
როდესაც foo ბრუნდება და ჰიტები, რომ curly გაუწიოს, პროგრამა აპირებს გაგრძელება
არ დაბრუნებას მთავარი, ის დაბრუნებას აპირებს რასაც მისამართის რომ წითელი ყუთი.
>> იმ შემთხვევაში, circumventing პროგრამული რეგისტრაციის,
რა, თუ მისამართი რომ მიმდინარეობს დაბრუნდა ფუნქცია რომ ნორმალურად იღებს მოუწოდა
შემდეგ თქვენ გადახდილი პროგრამული და inputted თქვენი სარეგისტრაციო კოდი?
შეგიძლიათ სახის ხრიკი კომპიუტერის შევიდა არ აპირებს აქ არამედ აპირებს აქ.
ან თუ თქვენ ნამდვილად ჭკვიანი, მოწინააღმდეგის შეიძლება რეალურად აკრიფოთ ზე კლავიატურის, მაგალითად,
არ ფაქტობრივი სიტყვა, არ 20 სიმბოლო, მაგრამ ვარაუდობენ, იგი რეალურად ტიპები
ზოგიერთი გმირები რომ წარმოადგენენ კოდი.
და ეს არ იქნება C კოდი, სინამდვილეში იქნება გმირები
რომ წარმოადგენენ ორობითი მანქანა კოდი, 0S და 1s.
მაგრამ ვარაუდობენ, ისინი ჭკვიანი საკმარისი ამისათვის,
რათა როგორმე ჩასვით შევიდა GetString სწრაფი იმას, რაც არსებითად შედგენილი კოდი,
და ბოლო 4 ბაიტი გადავაწერო, რომ დაბრუნების მისამართზე.
და რა მისამართი ამჯამად რომ შეყვანის შემთხვევაში?
ეს ფაქტიურად ინახავს ამ წითელი სამკუთხედით მისამართი პირველი byte of ბუფერული.
ასე, რომ თქვენ უნდა იყოს მართლაც ჭკვიანი, და ეს არის ბევრი სასამართლო და შეცდომა ცუდი ხალხი არსებობს,
მაგრამ თუ შეგიძლიათ გაერკვნენ, თუ როგორ დიდი ამ ბუფერული არის
ისეთი, რომ ბოლო რამდენიმე bytes in შეტანის თქვენს მიერ მოწოდებული პროგრამის
მოხდეს უნდა იყოს ექვივალენტური მისამართი დაწყების თქვენი ბუფერული, შეგიძლიათ ამის გაკეთება.
თუ ვიტყვით ჩვეულებრივ მიესალმები და \ 0, არის ის, რაც მთავრდება ბუფერული.
მაგრამ თუ ჩვენ უფრო ჭკვიანი და ჩვენ შეავსოთ რომ ბუფერული რა ჩვენ მოვუწოდებთ generically თავდასხმა კოდი -
AAA, თავდასხმა, შეტევა, შეტევა - როდესაც ეს უბრალოდ რაღაც რომ ჯერ რაღაც ცუდი,
რა მოხდება, თუ თქვენ მართლაც ჭკვიანი, თქვენ შეიძლება ამის გაკეთება.
წითელ ყუთში აქ არის თანმიმდევრობა ნომრები - 80, C0, 35, 08.
გაითვალისწინეთ, რომ სიას ხმების რომ აქ.
ეს წელს საპირისპირო მიზნით, მაგრამ უფრო, რომ სხვა დროს.
გაითვალისწინეთ, რომ ამ დაბრუნების მისამართი უკვე შეგნებულად შეცვლილი
ერთნაირი მისამართი აქ, არ მისამართი ძირითადი.
ასე რომ, თუ ცუდი ბიჭი არის სუპერ ჭკვიანი, იგი აპირებს მოიცავს, რომ თავდასხმა კოდი
რაღაც წაშლა ყველა მომხმარებლის ფაილების ან კოპირება პაროლები
ან შექმნათ მომხმარებლის ანგარიში, რომ მე შეიძლება მაშინ შესვლა - არაფერი საერთოდ.
>> და ეს არის ორივე საფრთხე და ძალა C.
იმის გამო, რომ თქვენ გაქვთ მეხსიერების მეშვეობით პოინტერები
და შეგიძლიათ აქედან გამომდინარე წერენ არაფერი გსურთ შევიდა კომპიუტერის მეხსიერებაში,
შეგიძლიათ კომპიუტერის არაფერი გინდათ
უბრალოდ, რომელმაც მას ხტომა გარშემო ფარგლებში საკუთარი მეხსიერების სივრცე.
და ასე ამ დღეს ამდენი პროგრამები და ამდენი საიტებზე, რომლებიც კომპრომეტირებული
მოვხარშოთ ქვემოთ ხალხი უპირატესობების ამ.
და ეს ალბათ, როგორიცაა Super დახვეწილი თავდასხმა, მაგრამ ეს ყოველთვის არ დაიწყოს, რომ გზა.
რეალობაა ის, რომ რა ცუდი ხალხი ჩვეულებრივ გააკეთოთ,
თუ არა ეს პროგრამა ბრძანებაში ან GUI პროგრამის ან ნახვა,
თქვენ დავიწყო უზრუნველყოფს სისულელეა.
თქვენ აკრიფოთ მართლაც დიდი სიტყვა შევიდა საძიებო ველში და დააჭიროთ,
და თქვენ დაველოდოთ თუ ნახვა Crashes
ან თქვენ დაველოდოთ თუ პროგრამის მანიფესტებმა რაიმე შეცდომა გაგზავნა
რადგან თუ თქვენ გაქვთ გაუმართლა როგორც ცუდი ბიჭი და თქვენს მიერ მოწოდებული ზოგიერთი გიჟები შეყვანის
რომ Crashes პროგრამა, რაც იმას ნიშნავს, პროგრამისტი არ გავუსწრო თქვენი ცუდი საქციელის გამო,
რაც იმას ნიშნავს, თქვენ შეგიძლიათ ალბათ საკმარისი ძალისხმევა, საკმარისი სასამართლო და შეცდომა,
გაერკვნენ, თუ როგორ უნდა ეწარმოებინა უფრო ზუსტად თავდასხმა.
ასე რომ იმდენი ნაწილი უსაფრთხოების არა მხოლოდ თავიდან აცილების ამ თავდასხმების საერთოდ
მაგრამ გამოვლენის მათ და რეალურად შევხედავთ ჟურნალები
და ხედავს, რა გიჟები საშუალებებით აქვს ხალხს აკრეფილი თქვენს ნახვა,
რა ძიება პირობები არ ხალხს აკრეფილი თქვენს ნახვა
წელს იმედები overflowing ზოგიერთი ბუფერული.
და ამ ყველა boils ქვემოთ მარტივი საფუძვლები რა მასივი
და რას ნიშნავს გამოყოფას და გამოიყენოთ მეხსიერება.
>> დაკავშირებული, რომ მაშინ ძალიან არის ამ.
მოდით უბრალოდ შეხედვით შიგნით დისკის კიდევ ერთხელ.
თქვენ გავიხსენოთ საწყისი ორი კვირის წინ, რომ როდესაც თქვენ გადაიტანეთ ფაილები თქვენი recycle bin ან ნაგვის შეიძლება,
რა ხდება? >> [სტუდენტი] არაფერი. >> აბსოლუტურად არაფერს, არა?
საბოლოოდ, თუ თქვენ აწარმოებს დაბალი on დისკზე,
Windows ან Mac OS დაიწყება წაშლის ფაილი თქვენთვის.
მაგრამ თუ თქვენ გადაიტანეთ რაღაც არსებობს, რომ არ არის უსაფრთხო.
ყველა თქვენი roommate ან მეგობარს ან ოჯახის წევრს უნდა გააკეთოს არის ორმაგად დაწკაპეთ და, voila,
იქ ყველა sketchy ფაილი, რომელიც თქვენ სცადა წაშლა.
ყველაზე მეტად ჩვენს არანაკლებ ვიცით, რომ თქვენ უნდა მარჯვენა ღილაკით ან კონტროლის click
და ცარიელი სანაგვე ან რამე მაგდაგვარს.
მაგრამ მაშინაც რომ არ გააკეთოს საკმაოდ შეასრულა
რადგან ის, რაც ხდება, როდესაც თქვენ გაქვთ ფაილი თქვენს ხისტ დისკზე
, რომელიც წარმოადგენს გარკვეული Word დოკუმენტის ან JPEG, და ეს წარმოადგენს თქვენს ხისტ დისკზე,
და ასე ვთქვათ ამ sliver აქ წარმოადგენს, რომ ფაილი,
და ის შედგება მთელი bunch of 0S და 1s.
რა ხდება, როდესაც თქვენ არა მხოლოდ გადაათრიეთ რომ ფაილი ნაგვის შეიძლება ან recycle bin
არამედ დაცლას ეს? სახის არაფერი.
ეს არ არის აბსოლუტურად არაფერი არის.
ახლა კი უბრალოდ არაფერი, რადგან პატარა რამე მოხდება სახით ამ მაგიდასთან.
ამიტომ არსებობს გარკვეული მონაცემთა ბაზაში ან მაგიდასთან შიგნით კომპიუტერის მეხსიერების
რომ არსებითად ერთი სვეტი ფაილების 'სახელები და ერთი სვეტი ფაილების' საიდან,
სადაც ეს შეიძლება იყოს საიდან 123, მხოლოდ შემთხვევითი რიცხვების.
ასე რომ, ჩვენ შეიძლება რაღაც x.jpeg და საიდან 123.
რა მოხდება მაშინ, როდესაც თქვენ ნამდვილად დაცლას თქვენი ურნის?
რომ მიდის.
მაგრამ რა არ მიდიან არის 0S და 1s.
>> რა არის მაშინ კავშირი pset4?
ისე, ერთად pset4, მხოლოდ იმიტომ, რომ ჩვენ შემთხვევით წაშლილია კომპაქტური ფლეშ განყოფილებიდან
რომ ჰქონდა ყველა ეს ფოტოები ან უბრალოდ იმიტომ, რომ ეს ცუდი იღბალი გახდა კორუმპირებული
არ ნიშნავს, რომ 0S და 1s არ ვართ ჯერ კიდევ არსებობს.
იქნებ რამდენიმე მათგანი იკარგება, რადგან რაღაც გაბმულ კორუმპირებული
იმ გაგებით, რომ ზოგიერთი 0S გახდა 1s და 1s გახდა 0S.
ცუდი რამ შეიძლება მოხდეს, რადგან buggy პროგრამული უზრუნველყოფის ან წუნდებული აპარატურა.
მაგრამ ბევრი იმ ბიტი, შესაძლოა, 100% მათგანი, ჯერ კიდევ არსებობს.
უბრალოდ კომპიუტერი ან კამერა არ იცის სად JPEG1 დაიწყო
და სადაც JPEG2 დაიწყო.
მაგრამ თუ თქვენ, პროგრამისტი, ვიცი ერთად ცოტა საზრიანი სადაც JPEGs are
ან, რას ჰგავს, ასე რომ თქვენ შეგიძლიათ გაანალიზოს 0S და 1s და აცხადებენ JPEG, JPEG,
თქვენ შეგიძლიათ დაწეროთ პროგრამა არსებითად მხოლოდ ან ხოლო loop
რომ აღდგება ყოველ ერთ იმ ფაილებს.
ასე რომ გაკვეთილი შემდეგ უნდა დაიწყოს უსაფრთხოდ erasing ფაილი
თუ გსურთ თავიდან ასაცილებლად საერთოდ. დიახ.
>> [სტუდენტი] როგორ მოვა ნათქვამია თქვენს კომპიუტერში
რომ თქვენ უფრო მეტი მეხსიერება, ვიდრე გააკეთეთ თქვენ წინაშე?
კიდევ გაქვთ მეხსიერების ვიდრე გააკეთეთ თქვენ წინაშე - >> [სტუდენტი] უფრო ხელმისაწვდომი მეხსიერება.
Oh. კარგი კითხვაა.
რატომ შემდეგ ვასუფთავებ სანაგვე ყუთს ამჯამად თქვენს კომპიუტერში გითხრათ
რომ თქვენ უფრო მეტი თავისუფალი სივრცე, ვიდრე გააკეთეთ თქვენ წინაშე?
In მოკლედ, რადგან ეს ცრუობს.
გაძლიერებული ტექნიკურად, თუ თქვენ ჩვენგან უფრო სივრცეში, რადგან ახლა თქვენ არ განაცხადა
თქვენ შეგიძლიათ განათავსოთ სხვა პერსონალის სადაც ეს ფაილი ადრე იყო.
მაგრამ ეს არ ნიშნავს, ბიტი ვაპირებთ მოშორებით,
და ეს არ ნიშნავს, ბიტი მიმდინარეობს შეიცვალოს ყველა 0S, მაგალითად,
თქვენი დაცვა.
ასე რომ პირიქით, თუ თქვენ უსაფრთხოდ წაშალოთ ფაილი ან ფიზიკური განადგურებით მოწყობილობის,
რომ ნამდვილად არის ერთადერთი გზა ზოგჯერ გარშემო რომ.
>> მაშ რატომ არ გვაქვს დატოვება რომ ნახევრად საშინელი შენიშვნა, და ვნახავთ თქვენ ორშაბათს.
[ტაში]
>> [CS50.TV]