[მუსიკის დაკვრა]
>> დევიდ ჯ Malan: ყველა უფლება.
ეს არის CS50.
და ეს არის დაწყების კვირაში 5.
და როგორც თქვენ შეიძლება არ შეამჩნია, ზოგიერთი მასალა
დღითიდღე უფრო კომპლექსი, პატარა სქელი.
>> და ეს ძალიან ადვილია, განსაკუთრებით მაშინ, თუ თქვენ უკვე ჩვევად გარკვეული დროის განმავლობაში,
ცდილობთ scribble ქვემოთ საუკეთესო არაფერს ვაკეთებთ, ჩვენ ვამბობთ კლასში.
მაგრამ ვაცნობიერებთ, რომ არ არის, ალბათ, იდეალური პედაგოგიური მიდგომა
სწავლის ამ სახის მასალა, და მატერიალური ზოგადად.
ასე რომ, ჩვენ მოხარულები ვართ, რომ განვაცხადო, რომ CS50 საკუთარი Gheng
Gong დაიწყო მომზადება კანონიკური კომპლექტი შენიშვნები
, რა თქმა უნდა, იმ იმედით, რომელიც არის ის, რომ ერთი, ამ
არა მხოლოდ როგორც მითითება და რესურსი
განხილვის მასალა და აპირებს უკან მეშვეობით მასალა, რომელიც შესაძლოა,
გაიქცა თქვენ პირველად გარშემო, მაგრამ ასევე, ასე რომ თქვენი თავები შეიძლება იყოს უფრო
up-ზე ქვემოთ, როდესაც ის მოდის დრო, ლექცია,
ასე რომ თქვენ შეიძლება ჩაერთოს მეტი thoughtfully, როგორც
განსხვავებით უფრო Scribbly.
>> რომ განაცხადა, ის, რაც თქვენ იპოვით საიტი არ არის ისეთი დოკუმენტები, როგორც ეს.
და შეამჩნია, ზედა მარცხენა, არსებობს არა მხოლოდ სარჩევი,
არამედ დრო კოდები, მაშინვე აირჩიე თქვენ
შესაბამის ნაწილში ამ ვიდეო ონლაინ რეჟიმში.
და რა Chang აქ გააკეთა არსებითად, დოკუმენტურად
რა მოხდა ამ კერძოდ ლექცია.
და ბევრი ლექციები უკვე ამჟამად ამ URL.
და ჩვენ გავაგრძელებთ დატოვე დანარჩენი იმ ბოლოსთვის ამ კვირაში,
ასე რომ ისარგებლოს, რომ რესურსი.
>> ასე გარეშე ado, ჩვენ დავიწყეთ კანი უკან
ფენას, რომელიც უკვე string გარკვეული დროის განმავლობაში.
და რა მივიღეთ ამბობენ სიმებიანი რეალურად არის გასულ კვირას?
ასე რომ char ვარსკვლავი.
და char ვარსკვლავი, ასევე, რა საერთოდ, რომ ნამდვილად ნიშნავს?
ასევე, ყველა ამ დროს, თუ ჩვენ უკვე მოუწოდებენ ფუნქცია
როგორიცაა getString, და შენახვა ე.წ. დაბრუნება
ღირებულება getString წელს ცვლადი ეს ე.წ.
s ტიპის სიმებიანი ჩვენ წერილობით ხაზი კოდი up there ზემოთ.
და ეს მხოლოდ მაშინ, როცა ვხედავ, რომ ჩემი ხელწერა განადიდა აქ
მე გააცნობიეროს, თუ რამდენად ბარბაროსულ ეს.
>> თუმცა, მოდით ვივარაუდოთ, რომ, მარჯვენა მხარეს
, მიუხედავად ამისა, გონივრული გამოსახულებებით რა არის
უკვე მიმდინარეობს ეს ყველაფერი დრო getString.
getString, რა თქმა უნდა, იღებს ტექსტი.
მაგრამ რას ნიშნავს, ნამდვილად?
ეს იმას ნიშნავს, რომ იგი იღებს ბლოკი მეხსიერების საწყისი ოპერაციული სისტემა
დარეკვით ფუნქცია მოუწოდა malloc.
მაგრამ ამაზე მოგვიანებით.
და შემდეგ ეს populates რომ ბლოკი მეხსიერება
წერილები მომხმარებელს აქვს აკრეფილი, რასაც მოჰყვა, რა თქმა უნდა,
null ხასიათი, ან წარმატებული ნულოვანი ბოლომდე.
>> იმავდროულად, მარცხენა მხარეს ეს ამბავი, მთელი ამ დროის განმავლობაში,
ჩვენ ვაცხადებთ, რომ ცვლადი, როგორიცაა s.
და რომ ცვლადი რა არის დაიწყება მოუწოდებენ მაჩვენებელი.
ეს არ არის ყუთის შიგნით რომელიც ჩვენ დააყენა სიმებიანი, Daven, თავისთავად,
არამედ ჩვენ დააყენა, რომ მოედანზე ყუთი მარცხენა რა?
ჰო?
>> აუდიტორია: მისამართი სადაც ის მდებარეობს მეხსიერებაში.
>> დევიდ ჯ Malan: ზუსტად.
მისამართი სადაც Daven მდებარეობს მეხსიერებაში.
და არა იქ, სადაც ყველა Daven მდებარეობს, თავისთავად, მაგრამ კონკრეტულად მისამართი
რა?
ჰო?
>> აუდიტორია: პირველი ხასიათი.
>> დევიდ ჯ Malan: პირველი სიმბოლო in Daven, რომელიც, ამ შემთხვევაში,
მე შევთავაზე, იყო თვითნებურად და არარეალურად 1, OX1,
რომელიც მხოლოდ იმას ნიშნავს, რიცხვი 1.
მაგრამ ეს, ალბათ, უნდა ბევრად უფრო დიდი რაოდენობის
შეგვიძლია ერთად 0x როგორც პრეფიქსი,
წარმოადგენს თექვსმეტობითი ხასიათი.
და რადგან ჩვენ არ უნდა ვიცოდეთ, სად დანარჩენი გმირები Daven
არიან, რადგან ის, რაც მარტივი დიზაინი გადაწყვეტილება, რომ გაკეთდა მრავალი წლის წინ?
ჰო?
>> აუდიტორია: Backslash 0.
დევიდ ჯ Malan: ჰო, ზუსტად.
წარმატებული 0 საშუალებას გაძლევთ, თუმცა ხაზოვანი დროს, უნდა traverse string,
ფეხით მარცხნიდან მარჯვნივ, ამისთვის მარყუჟის, ან მაშინ, როცა
მარყუჟის, ან რაღაც რომ, და განსაზღვრავს, რა, აქ
არის ბოლომდე ამ კონკრეტულ სიმებიანი.
ასე რომ მხოლოდ მისამართი at დასაწყისში სიმებიანი,
ჩვენ შეგვიძლია წვდომის მთლიანობაში ეს იმიტომ, რომ მთელი ამ დროის,
სიმებიანი ახლახანს char ვარსკვლავი.
>> ასე რომ, ეს, რა თქმა უნდა ჯარიმა გამოყენება და გაგრძელება CS50 ბიბლიოთეკა და ამ აბსტრაქციის
ასე ვთქვათ, მაგრამ ჩვენ დაიწყოს ზუსტად
რა ხდება on ქვეშ მთელი ამ ხნის.
ასე, რომ თქვენ შეიძლება გავიხსენოთ ამ მაგალითად, ძალიან, ბოლო დროს, შედარების 0,
რომელიც პრაქტიკულად არ არის შედარების.
მაგრამ ჩვენ დავიწყეთ გადაჭრის ამ.
>> მაგრამ, ალბათ, ცოდნის გასაახლებლად, შეიძლება მე დაგაინტერესოთ ვინმე
ვარდისფერი სპილო დღეს, ასევე გააკეთა Chang?
როგორ შესახებ თქვენ წინაშე? [INAUDIBLE].
მოდის up.
>> და იმავდროულად, როგორც თქვენ ამუშავება, მოდით
განიხილოს მხოლოდ ერთი წუთით რა ეს კოდი იყო რეალურად აკეთებს.
ეს გამოცხადების ორი ცვლადი up ზედა, და ტ, ხოლო getString.
ეს არ არის ძალიან მოსახერხებელი პროგრამა, იმიტომ, რომ ეს არ გითხრათ რა უნდა გააკეთოს.
მაგრამ მოდით უბრალოდ ვივარაუდოთ, რომ ჩვენ აქცენტი წვნიანი ნაწილი.
და მაშინ ჩვენ გავაკეთოთ, თუ ტოლია შეადგენს t, უნდა ვთქვა printf,
თქვენ აკრეფილი იგივე.
Hello.
რა გქვია?
>> Janelle: Janelle.
დევიდ ჯ Malan: Janelle, კარგია თქვენთან შეხვედრა.
ასე რომ, თქვენი გამოწვევა ხელი ამ elephant
პირველ მიაპყროს სურათს რა არის წარმოდგენილი იმ პირველი ორი
ხაზები.
ასე და ტ შეიძლება იყოს წარმოდგენილია, თუ როგორ ეკრანზე?
და თქვენ შეგიძლიათ უბრალოდ შევაჩერო იგი თითის ამ დიდ ეკრანზე.
>> ასე რომ, არსებობს ორი halves to თითოეულ მხარეს, რომ განტოლება.
ასე რომ იქ s მარცხენა და მაშინ getString უფლება.
და მერე t მარცხენა, და შემდეგ getString უფლება.
ასე როგორ შეიძლება ჩვენ ვიწყებთ ნახატი, რომელიც
წარმოადგენს რა ხდება აქ მეხსიერება, იტყვით?
და ნება მომეცით ნება თქვენ ახსნას თუ რას აკეთებს, როგორც თქვენ.
>> Janelle: OK.
ისე, პირველი, ეს იქნებოდა ითხოვს თქვენ შემავალი სიმებიანი.
და ეს იქნებოდა store-- OH, უკაცრავად.
დევიდ ჯ Malan: OK.
კარგი.
და ეს ჰქვია, რა?
ოჰ, OK.
შენარჩუნებას აპირებს.
მე არ ნიშნავს, ხელი შეუშალოს.
Janelle: Sorry.
ასე რომ შეყვანის ის მისამართი of-- არ ვარ დარწმუნებული.
მე ვერ ზუსტად არ მახსოვს ნომერი, მაგრამ მე მჯერა, რომ ეს, დაწყებული 0.
>> დევიდ ჯ Malan: ეს ყველა უფლება, იმიტომ, რომ მე გააკეთა ნომრები up,
ასე რომ არ არის სწორი პასუხი.
>> Janelle: დაწყებული 0 რკალი.
>> დევიდ ჯ Malan: OK, ასე ელემენტს 0.
რა თქმა უნდა.
>> Janelle: და თუ იყო ისევე როგორც მხოლოდ ორი letter--
>> დევიდ ჯ Malan: OK, უკან თქვენ.
>> Janelle: So ელემენტი 0, და მაშინ ელემენტს 1 ან ელემენტი, 2.
დევიდ ჯ Malan: და რომელი სურათზე ხატავ ახლა?
ზარი getString?
ან დეკლარაცია s?
>> Janelle დეკლარაცია s, მე მჯერა.
ოჰ, getString, რადგან ეს იქნებოდა შეიძლება შეყვანა თითოეული [? სფეროში. ?]
>> დევიდ ჯ Malan: კარგი.
ზუსტად.
მიუხედავად იმისა, რომ ეს ეფექტურად ბრუნდება მასივი, გავიხსენოთ,
როდესაც ჩვენ დავუბრუნდეთ სიმებიანი, ჩვენ შეგვიძლია ინდექსი, რომ სიმებიანი გამოყენებით 01 და 2.
ტექნიკურად, ეს, ალბათ, წარმოდგენილია ინდივიდუალური მისამართები,
მაგრამ ეს ჯარიმა.
>> ასე რომ, ვფიქრობ, თუ მე შემიძლია უბრალოდ სწრაფი ველით, სადაც ჩვენ შეჩერდით
ბოლო დროს, თუ ერთი სიმები იყო გ ა ბ e,
წარმატებული 0, ამით წარმოადგენს Gabe მიერ input, როგორ შეიძლება ჩვენ წარმოვადგენთ ახლა?
თუ ეს მეხსიერება რომ დაუბრუნა getString?
>> Janelle: უნდა იყოს წარმოდგენილია რკალი?
>> დევიდ ჯ Malan: By რკალი?
კარგად, არ.
მოდით უბრალოდ, ვამბობთ, pictorially, ნება მომეცით წავიდეთ წინ
და შესთავაზოს, რომ თუ ეს s, ეს დაბრუნებული მნიშვნელობა getString.
და თქვენ შედგენილი ეს როგორც 0, 1, 2, სრულიად სამართლიანია, რადგან ჩვენ
ინდექსი სიმებიანი, როგორც ასეთი.
მაგრამ უნდა იყოს თანმიმდევრული ბოლო დროს, ნება მომეცით წავიდეთ წინ
და თვითნებურად შესთავაზოს, რომ ეს არის მისამართი 1, ეს არის მისამართი 2,
ეს არის მისამართი 3, და სხვ.
და ასე, უბრალოდ უნდა იყოს სუპერ ნათელია, თუ რა ხდება
წავიდეთ წინ, შედეგად, რომ პირველი ხაზი კოდი, იტყვით?
>> Janelle: მისამართი 1?
>> დევიდ ჯ Malan: ზუსტად.
ასე მიმართავენ 0x1.
და იმავდროულად, ნება მომეცით წავიდეთ წინ და დუბლიკატი ბევრი, რას ვაკეთებ
და დაამატოთ საკუთარი t აქ.
თუ მე აკრიფოთ Gabe ერთხელ, მეორედ,
როდესაც აიძულა getString, სადაც, რა თქმა უნდა, Gabe აპირებს?
ასევე, presumably--
>> Janelle: Like აქ?
დევიდ ჯ Malan: ჰო.
Janelle: ან ის ასევე იგივე ყუთები?
დევიდ ჯ Malan: ნება მომეცით შესთავაზოს, yeah, ზუსტად, ისე ამ დამატებითი საშუალებები.
მაგრამ რა არის გასაღები არის, რომ, მაშინაც კი, თუმცა მე შედგენილი ამ საკმაოდ ახლოს
together-- 0x1, ამ არის 0x2-- სინამდვილეში,
ეს ახლა, შესაძლოა, მისამართზე 0x10, მაგალითად, და 0x11 და 0x12,
და სხვ.
ასე რომ, თუ ეს საქმე, რა დასრულდება მდე აქ t?
>> Janelle: 0x10?
დევიდ ჯ Malan: ზუსტად.
ასე 0x10.
და ახლა, საბოლოო კითხვას.
თქვენ არ, გაცილებით, უწევდათ მუშაობა უმძიმესი სპილო დღემდე.
ახლა, თუ მე დახევის up კოდი ერთხელ, როცა ამის გაკეთება, შესაბამისად, სამი,
თუ ტოლია ტოლია t, რა ვარ მე რეალურად შედარებით, რომ ჩვენ შედგენილი აქ?
>> Janelle: ორი მისამართები?
დევიდ ჯ Malan: ზუსტად.
ამიტომ მე ვამბობ, არის ის თანაბარი ტოლია t?
სხვა სიტყვებით რომ ვთქვათ, 1 თანაბარი ტოლია 10?
და რა თქმა უნდა, ცხადია პასუხი, ახლა არის, არ არსებობს.
და ასე რომ ეს პროგრამა არის საბოლოო აპირებს ბეჭდვა რა, იტყვით?
>> Janelle: იქნება ეს, თქვენ აკრეფილი იგივე?
>> დევიდ ჯ Malan: ასე რომ, თუ s არის 1 და t არის 10?
>> Janelle თქვენ აკრეფილი სხვადასხვა რამ.
>> დევიდ ჯ Malan: ზუსტად.
თქვენ აკრეფილი სხვადასხვა რამ.
ყველა უფლება.
ასე რაუნდი ტაში, თუ ჩვენ შეგვიძლია, აქ.
[ტაში]
რომ იყო მტკივნეული.
მე ვიცი.
ლამაზად კეთდება.
ასე რომ, ახლა ვნახოთ, თუ ჩვენ არ შეგვიძლია აჯავრებენ გარდა რა სარემონტო იყო.
და რა თქმა უნდა, როდესაც ჩვენ დაფიქსირდა გაკეთება რომელიც მე ახლა წარმოადგენენ green--
ჩვენ გავაკეთეთ რამდენიმე გაუმჯობესებებს აქ.
პირველი, როგორც საღი აზრის შეამოწმეთ, მე პირველი შემოწმების
თუ ტოლია null და t = null.
და უბრალოდ უნდა იყოს წმინდა, როდესაც შეიძლება ან უ null კოდის მსგავსად?
როდესაც შესაძლოა ან უ null.
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ზუსტად.
თუ სტრიქონი აკრეფილი არის ძალიან დიდი ხნის განმავლობაში
ჯდება მეხსიერებაში, ან უცნაური კუთხეში შემთხვევაში, როგორც, რომ,
getString, როგორც ვნახავთ, ფაქტიურად დღეს, მისი დოკუმენტაცია,
ამბობს, რომ დაბრუნების null როგორც სპეციალური Sentinel ღირებულებით,
ან უბრალოდ ერთგვარი სპეციალური სიმბოლო ეს ნიშნავს, რომ რაღაც წავიდა არასწორი.
ასე რომ, ჩვენ გვინდა შევამოწმოთ რომ, იმიტომ, რომ თურმე
რომ null არის ძალიან საშიში ღირებულება.
>> ხშირად, თუ თქვენ ცდილობენ, რომ რამე null ჩართვის ფუნქცია გავლის
როგორც შეყვანა, instance-- რომ ფუნქცია შეიძლება ძალიან ავარიის და, მასთან ერთად,
, თქვენი მთელი პროგრამა.
ასე რომ, ეს მესამე ხაზი ახლა მხოლოდ საღი აზრის შემოწმება, შეცდომა შემოწმება, თუ გნებავთ.
ეს კარგი ჩვევა ახლა ჩვენთვის შეღწევას ნებისმიერ დროს ჩვენ
ცდილობენ გამოიყენონ ღირებულება, რომელიც შესაძლოა, პოტენციურად, შეიძლება იყოს null.
>> ახლა, მეოთხე ხაზი აქ, "თუ strcmp (s, t)," კარგად,
რა არის, რომ გულისხმობდა?
ასევე, ჩვენ ვთქვით, რომ ეს იყო ძალიან მოკლედ დაასახელა ფუნქცია სიმებიანი შედარებით.
და მისი მიზანი ცხოვრებაში არის შედარება მისი პირველი არგუმენტი ის წინააღმდეგ მეორე,
მაგრამ არა იმ თვალსაზრისით, მათი მისამართები, როგორც ჩვენ გავაკეთეთ უნებლიეთ მომენტი
ჯერ წითელი კოდი, მაგრამ უფრო სწორად, შევადაროთ ორი
სიმებისათვის ადამიანური ინტუიციური გზა შედარებით ეს, წინააღმდეგ,
წინააღმდეგ, წინააღმდეგ, და მაშინ შეჩერების, თუ როდის და ერთი
ან ორივე ჩემი თითები ჰიტები წარმატებული 0.
ასე რომ ვინმეს წლის წინ განხორციელებული strcmp განახორციელოს us ფუნქციონალური
ჩვენ იმედი გვქონდა, რომ უკვე მიღებული მხოლოდ შედარებით ორი მარტივი ღირებულებებს.
>> ახლა გულწრფელად ვამბობ, მე შენარჩუნება ნახაზი ყველა ამ სხვადასხვა ნომრები.
მაგრამ რეალობა ის არის, მე მიღების ეს მთელი დრო.
და ნება მომეცით, უბრალოდ წავიდეთ წინ და scribble ეს,
რათა წერტილი, რომ ბოლოს დღე და წინ მიდის,
ჩვენ ნამდვილად არ აპირებს აინტერესებს რა მიმართავს რამ რეალურად
მეხსიერებაში.
ასე რომ, მე არ ვაპირებ შევაჩერო ეს სახის ნომრები იმდენად აღარ,
მე უბრალოდ აბსტრაქტული ამ მოშორებით უფრო მეგობრული მხოლოდ ისრებით.
>> სხვა სიტყვებით, თუ ის მაჩვენებელი, კარგად, მოდით უბრალოდ შევაჩერო ეს, ფაქტიურად,
როგორც მაჩვენებელი, ისარი მიუთითებს თავად რაღაც,
და არ ინერვიულოთ ძალიან ბევრი უფრო მეტი minutia ამ მისამართებზე
რომელიც, კიდევ ერთხელ, მე მაინც.
მაგრამ ჩვენ დავინახავთ იმ მისამართებზე, ზოგჯერ, როდესაც გამართვის კოდი.
>> ახლა კი, რომელიც ამ პროგრამის აქ აფიქსირებს, რა თქმა უნდა,
რომ პრობლემა შედარებით იმ ორ strings.
მაგრამ ჩვენ შეუვარდნენ კიდევ ერთი პრობლემა.
ეს იყო ასლი პროგრამის ბოლო დროს,
რომლის დროსაც, მე ცდილობს, მხოლოდ პირველი პერსონაჟი სიმებიანი.
მაგრამ რა იყო სიმპტომია ჩვენ ვნახეთ ბოლო დროს, როდესაც
მომხმარებლის აკრეფილი ღირებულება, ისევე როგორც Gabe in ამას, s,
მაშინ ჩვენ მიერ ს შევიდა t, როგორც მესამე ხაზი არსებობს,
და შემდეგ მე შევეცადე კაპიტალიზაცია t bracket 0?
რა იყო ეფექტი იცვლება t bracket 0 აქ?
>> აუდიტორია: ეს შეიცვალა s.
>> დევიდ ჯ Malan: ჰო, მე შეიცვალა s, ისევე.
რადგან ის, რაც იყო სინამდვილეში?
ასევე, ნება მომეცით ვხედავ, თუ შეიძლება სუფთა ამ სურათს, შემდეგნაირად.
>> თუ არის, კიდევ ერთხელ, სიტყვა გ, a, b, e, წარმატებული, 0, და s
ჩვენ გავაგრძელებთ ნახაზის ყუთი აქ, მაგრამ აღარ მისამართები.
მოდით შევწყვიტოთ მიღების რამ up.
მოდით უბრალოდ მიაპყროს სურათი გამარტივება მსოფლიოში.
>> როდესაც ვაცხადებ t სიმებიანი t, რომელიც ქმნის, რომ ბლოკი მეხსიერება.
მოედანზე ხდება, რომ იყოს 32 ბიტი ყველაზე კომპიუტერებს.
რეალურად, თუ თქვენ ოდესმე მსმენია კომპიუტერული მქონე 32-bit არქიტექტურის,
მართლაც ლამაზი საუბარი, რომ მხოლოდ ეს იმას ნიშნავს რომ იყენებს 32-bit მისამართები.
და როგორც ტექნიკური გარდა, თუ თქვენ ოდესმე გვაინტერესებდა,
რატომ ძველი კომპიუტერები, თუ რეალურად ცდილობდა წვნიანი მათ უამრავი RAM,
შეიძლება, მაქსიმუმ ოთხი გიგაბაიტი ოპერატიული მეხსიერება,
ასევე იმიტომ, რომ, ფაქტიურად, თქვენი ძველი კომპიუტერის შეეძლო მხოლოდ
ითვლიან როგორც მაღალი, როგორც 4 მილიარდი, 4 მილიარდი ბაიტი,
იმიტომ, რომ ის გამოყენებით 32-bit ნომრები მისამართები.
>> მაგრამ ნებისმიერ შემთხვევაში, ამ მაგალითად, ამბავი ბევრად უფრო მარტივია.
t არის კიდევ ერთი მაჩვენებელი, ან მართლაც char ვარსკვლავი, aka სიმებიანი.
და როგორ არ მინდა, რომ განაახლოს ეს სურათი ახლა, რომ მეორე ხაზი კოდი,
შემდეგ dot, dot, dot?
როცა ამის გაკეთება string t = s მძიმით, როგორ ამჯამად ამ სურათს შეცვლის?
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ჰო.
ზუსტად.
მე უბრალოდ დააყენა arrow საწყისი t ყუთი იგივე მისამართზე,
იმავე პირველ წერილში მისცა.
ან ტექნიკურად, თუ ამ ბიჭი იყო ჯერ კიდევ 0x1,
ეს თითქოს მე მქონდა 0x1 აქ და 0x1 აქ.
მაგრამ კიდევ ერთხელ, ვინც ზრუნავს შესახებ მისამართები?
ეს არის იდეა, რომ ახლა მნიშვნელოვანია.
ასე რომ, ეს არის ის, რაც ხდება აქ.
ასე რომ, რა თქმა უნდა, თუ t bracket 0, რომელიც მასივი notation,
საქართველოს რა თქმა უნდა და გულწრფელად ვამბობ, ეს გამოიყურება როგორც იქ მასივი მეტი აქ,
მაგრამ ახლა არ არის ეს უცნაური რამ.
ვიცი, რომ პროგრამირების ენა, C, გთავაზობთ ამ ფუნქციის,
რომლის დროსაც, თუნდაც t არის კურსორი, ან s არის მაჩვენებელი,
თქვენ შეგიძლიათ კვლავ გამოიყენოთ, რომ იცნობს, კომფორტული კვადრატული ფრჩხილი
notation წასვლა პირველ ელემენტს, ან მეორე ელემენტი, ან რაიმე ელემენტი,
რომ ეს მაჩვენებელი არის მიუთითებს იმიტომ, რომ, სავარაუდოდ, ეს
არის, რადგან ამ შემთხვევაში, მიუთითებს რაღაც მასივი.
>> ასე როგორ უნდა დაფიქსირება ამ?
გულწრფელად ვამბობ, ეს არის, სადაც ეს მივიღე ცოტა გადაჭარბებული ერთი შეხედვით.
მაგრამ აქ არის ახალი და გაუმჯობესებული ვერსია.
>> ასე რომ, პირველი, მე მისაღებად მოშორება CS50 ბიბლიოთეკა,
უბრალოდ გამოამჟღავნონ, რომ არის მართლაც char ვარსკვლავი, სინონიმი.
და t ასევე char ვარსკვლავი.
მაგრამ რა ხდება იმ მარჯვენა მხარეს, რომ ხაზი
სადაც t ენიჭება მნიშვნელობა?
>> რა არის malloc?
რა რომ strlen?
რა არის sizeof (char)?
რატომ heck აკეთებს ამას ონლაინ სახე იმდენად რთული?
რას აკეთებს მაღალ დონეზე?
რა არის ის შენახვის t?
ჰო?
აუდიტორია: ეს განაწილების გარკვეული მეხსიერების სივრცე.
ეს შესანახად, ვფიქრობ, წერილები [INAUDIBLE].
>> დევიდ ჯ Malan: Perfect.
სრულყოფილი.
ის გამოყოფის გარკვეული თანხის მეხსიერების სივრცე
შესანახად, სავარაუდოდ, მომავალი წერილები.
კერძოდ, malloc ამიტომ დაბრუნების რა?
>> აუდიტორია: დავბრუნდეთ [INAUDIBLE]?
დევიდ ჯ Malan: ზუსტად.
დაბრუნების მისამართი, რომ მეხსიერება, რომელიც არის ლამაზი გზა ამბობდა,
დააბრუნებს მისამართი პირველი byte, რომ მეხსიერებაში.
Onus არის ჩემთან უნდა გვახსოვდეს რამდენი მეხსიერება მე რეალურად
გამოყოფილი ან სთხოვა malloc for.
>> ახლა, თუ რამდენად არის ეს?
ასევე, მიუხედავად იმისა, რომ არსებობს ბევრი ფრჩხილებში აქ,
malloc იღებს მხოლოდ ერთი არგუმენტი.
და მე დაზუსტების strlen of s, ასე რომ მე, როგორც ბევრი bytes როგორც არსებობს s,
მაგრამ დაამატოთ ერთი.
რატომ?
ჰო?
>> აუდიტორია: წარმატებული 0.
დევიდ ჯ Malan: ზუსტად.
ჩვენ მივიღეთ პატარა მომსახურება.
ასე რომ, იმიტომ, რომ იქ წარმატებული 0, ჩვენ უკეთეს გახსოვდეთ, რომ.
წინააღმდეგ შემთხვევაში, ჩვენ ვაპირებთ სტრინგის შექმნის, რომ
არ აქვს, რომ სპეციალური terminator.
>> იმავდროულად, მხოლოდ უნდა იყოს სუპერ anal, მაქვს sizeof (char),
მხოლოდ იმ შემთხვევაში, ვინმე გადის ჩემი კოდი არ CS50 ელექტრო მოწყობილობების,
მაგრამ იქნებ სხვადასხვა კომპიუტერულ საერთოდ, სადაც chars
არის ერთ ნაწილად, კონვენციას, მაგრამ ორი ბაიტს, ან რაღაც უფრო დიდი, ვიდრე, რომ.
ის უბრალოდ უნდა იყოს სუპერ, super averse შეცდომები.
მიუხედავად იმისა, რომ რეალურად, ის სავარაუდოდ იქნება 1.
>> ახლა კი, ამ დროს, წავიდეთ წინ და ასლი სიმებიანი, t bracket შეადგენს t bracket s.
და მე თვლიან, რომ გასული კვირის კოდის ნახოთ რა ხდება.
მაგრამ გასაღები takeaway და მიზეზი მე ზუსტად კოდი არის მწვანე,
იმიტომ, რომ ძალიან ბოლო ხაზი, t bracket 0 უდრის toupper,
აქვს ეფექტი capitalizing რომელიც სიმებიანი?
t ან / და s?
რომ ბოლო ხაზი კოდი.
>> უბრალოდ t, რადგან რა მოხდა ამ დროს,
თუ მე ოდნავ გაუქმება, რომ ბოლო ნაბიჯი, რა მოხდა არის, როდესაც მე მოვუწოდებ malloc,
მე არსებითად მისაღებად ბლოკი მეხსიერება რომ არის იგივე ზომა, როგორც ორიგინალური,
იმიტომ, რომ არითმეტიკული მე.
მე შენახვის t მისამართი რომ ბლოკი მეხსიერება.
მიუხედავად იმისა, რომ გამოიყურება ლამაზი და ლამაზი, ლამაზი და ცარიელი,
რეალობა არსებობს, ის, რაც ჩვენ შეინახოს მოუწოდებდა, ნაგვის ღირებულებების აქ.
რომ ბლოკი მეხსიერება, შესაძლოა, ძალიან ასევე გამოყენებულ იქნა ადრე,
რამდენიმე წამში, რამდენიმე წუთის წინ.
ასე რომ შეიძლება აბსოლუტურად ნომრები ან წერილებს, უბრალოდ შემთხვევით.
მაგრამ ისინი არ არის სწორი, სანამ მე თავს ცხოვრობენ ბლოკი მეხსიერება
ფაქტობრივი სიმბოლო, როგორც მე გავაკეთოთ, რომ მარყუჟი არსებობს.
ყველა უფლება?
>> ასე რომ, ახლა კულმინაციას ეს სამი მაგალითი
, რომლებიც, როგორც ჩანს, მოტეხილობა ბოლო დროს, ამ Swap მაგალითად, ამ ფუნქციის
მუშაობდა აზრი ის, რომ ქულების დასაგროვებლად და ბ.
მაგრამ ეს არ იმუშავებს, თუ რა სხვა აზრი?
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ზუსტად.
თუ მე უნდა მოვუწოდებთ ამ ფუნქციის საწყისი another-- მაგალითად,
ფუნქცია, როგორიცაა ძირითადი სადაც მაქვს ცვლადი, x და y, როგორც მე
როგორც გასულ კვირას, იგივე კოდი, და მე კორიდორი x და y
სვოპ, და შემდეგ Swap-- ამ, რა თქმა უნდა, არის სწორი ვერსია
არის ის, რაც ჩვენ შესახებ ვხედავ ეს არ იმუშავებს.
რა არის სარემონტო?
>> კარგად, ასე რომ უბრალოდ უნდა იყოს ნათელია, ნება მომეცით წავიდეთ წინ
and-- მომეცი ერთი მეორე აქ და ვნახავთ თუ შემიძლია გაჩვენოთ ბოლო, რომელიც
იქნება in-- ვნახოთ, თუ ვიპოვი ეს რეალური fast-- OK, [INAUDIBLE].
OK, ის არის.
ასე იგნორირება ბრძანებები მე უბრალოდ აკრეფით.
მე მინდა, რომ მიიღოთ ზე ბოლო წუთს მაგალითი
ბოლო დროს, რომელიც ახლა მოუწოდა swap.
>> ასე რომ არ Swap სადაც ჩვენ შეჩერდით ბოლო დროს,
რომლის დროსაც, მე ინიციალიზაცია x 1 და y 2.
მე მაშინ მოვუწოდებთ Swap გავლით 1 და 2.
და შემდეგ ამ ფუნქციის მუშაობდა გარკვეული თვალსაზრისით,
მაგრამ ეს არ ჰქონდა მუდმივი გავლენის x და y.
ასე რომ, კითხვა მხრივ, თუ როგორ არის ჩვენ რეალურად დაფიქსირება ამ პრობლემას?
რა არის გამოსავალი მხრივ?
>> ასევე, swap.c, რომელიც ახალი დღეს, შეამჩნია რამდენიმე განსხვავებები.
x და y იგივეა.
მაგრამ რა არის აშკარად განსხვავებული ხაზი 25?
რა არის ახალი აქ, თუ გახსოვთ ის, რაც ჩანდა მეორე წინ?
>> აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ჰო.
ასე რომ, ampersands არის ახალი ნაჭერი სინტაქსი არა მხოლოდ ამ პროგრამას,
არამედ ზოგადად CS50.
დღემდე, არა მგონია, ჩვენ ვნახეთ რაიმე მაგალითები
ან ნამდვილად ისაუბრა მათ ნებისმიერ დეტალურად, გარდა, შესაძლოა, წინასწარ
ნაწილში, ampersand მოსწონს ეს.
ასევე, თურმე ampersand არის ერთ ერთი ბოლო ცალი ახალი სინტაქსი
ჩვენ ვაპირებთ, რომ ისწავლონ.
ყველა ეს ნიშნავს იმას, მისამართი ზოგიერთი ცვლადი.
რა მისამართზე ამჯამად x ცხოვრობს?
მაგრამ რა მისამართზე Y ცხოვრობენ?
იმიტომ, რომ თუ ფუნდამენტური პრობლემის წინაშე
ის იყო, რომ x და y მიმდინარეობს გავიდა ასლი, რაც ჩვენ ნამდვილად გვინდა, რომ გავაკეთოთ
არის უზრუნველყოფს Swap მოსწონს საგანძური რუკა, რომელსაც მივყავართ, სადაც x და y რეალურად
არიან RAM, ასე რომ Swap შეუძლია დაიცვას, რომ რუკა
და წასვლა იქ, სადაც x და y აღნიშნავს ადგილზე და შეცვალოს რეალურ ღირებულებებს 1 და 2
არსებობს.
>> ასე Swap უნდა შეიცვალოს ოდნავ.
და ერთი შეხედვით, ეს შეიძლება როგორც ჩანს, ცოტა მსგავსი char ვარსკვლავი.
და ეს ნამდვილად.
ასე რომ მომცეთ რა სახის მონაცემები, ამ საფუძველზე ხაზგასმით ნაწილი?
ასე რომ, ეს int.
>> ასე რომ აღარ არის int, ეს მისამართი int.
და ანალოგიურად, ბ ახლა აპირებს უნდა იყოს მისამართი int.
ასე რომ, როდესაც ახლა მოვუხმობ Swap from მთავარი მე არ ვაპირებ, რათა Swap 1 და 2.
მე ვაპირებ, რათა ეს მოსწონს Ox-რაღაც და Ox-რამე,
ორ მისამართს, რომელიც მიგვიყვანს Swap ფაქტობრივი ადგილას
ჩემი კომპიუტერის მეხსიერებაში.
>> ახლა, ჩემი დარჩენილი განხორციელების უნდა შეიცვალოს tad.
რა არის აშკარად სხვადასხვა არის ამ სამი ხაზი კოდი?
იქ ეს რა ვარსკვლავები ყველა მეტი ადგილი, ყველა უფლება?
ასე რომ, რა ხდება აქ?
ჰო?
>> აუდიტორია: ეს აშკარად [INAUDIBLE].
>> დევიდ ჯ Malan: ზუსტად.
ასე რომ, ამ კონტექსტში და ეს არ იყო საუკეთესო დიზაინის გადაწყვეტილება, მართლაც,
წლის წინ.
ამ კონტექსტში, სადაც თქვენ უბრალოდ უნდა ვარსკვლავი,
და თქვენ არ აქვს მონაცემები ტიპის, როგორიცაა int, მაშინვე მარცხენა,
სამაგიეროდ, თანაბარი ნიშანი, ცხადია, ამ კონტექსტში, როცა ამბობენ, რომ ვარსკვლავი,
ეს ნიშნავს, რომ წავიდეს მისამართი რომ წელს.
დაიცავით საგანძური რუკა, ასე ვთქვათ.
>> და იმავდროულად, ხაზი 37, ეს იმას ნიშნავს, რომ იგივე.
გადადით მისამართზე, და ამით რა არის?
როგორიც არ უნდა იყოს ის არის, ადგილმდებარეობა რომ ბ განსაზღვრავს.
სხვა სიტყვებით, გადადით ბ.
მიიღეთ, რომ ღირებულება.
წასვლა და, თითო თანაბარი მოაწეროს, დავალება ოპერატორი,
ვთქვათ, რომ არც არსებობს.
>> ანალოგიურად, int temp მხოლოდ int.
არაფერი უნდა შეცვალოს temp.
უბრალოდ სათადარიგო მინის Annenberg ზოგიერთი რძე ან ფორთოხლის წვენი.
მაგრამ მე უნდა ვთქვა, რომ წავიდეს ბ.
წასვლა რომ დანიშნულების და ბოლო ღირებულების temp არსებობს.
ასე რომ, რა ხდება სინამდვილეში?
როდესაც მე სინამდვილეში Swap ამ დროს, თუ ეს პირველი უჯრა აქ წარმოადგენს მთავარი
ამ მეორე უჯრა წარმოადგენს Swap, როდესაც მე გაივლის ampersand x და y ampersand
მთავარი სვოპ, უბრალოდ უნდა იყოს წმინდა, რა არის ამ დასტის ჩარჩო მიმღები?
ჰო?
>> აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ზუსტად.
მისამართი x და მისამართი წ.
და შეგიძლიათ წარმოიდგინოთ, რომ ეს როგორიცაა საფოსტო მისამართები.
33 Oxford Street და 35 Oxford Street, და თქვენ
გინდა ორი შენობა , რომლებიც იმ ადგილას.
>> ეს ერთგვარი სასაცილოა იდეა, მაგრამ ეს ყველაფერი ნიშნავს მისამართზე.
სად მსოფლიოში შეგიძლიათ თქვენ იმ ორი ints?
სად მსოფლიოში შეგიძლიათ მოვძებნოთ იმ ორ შენობაში?
ასე რომ, თუ ბოლოს და ბოლოს, მას შემდეგ, რაც ყველა, ეს დრო წასვლას დღევანდელი კოდის და შეადგინონ
Swap და აწარმოებს ./swap ბოლოს, პირველად ჩვენ რეალურად ვხედავთ, რომ
ჩემი ღირებულებები მართლაც უკვე გაცვალეს წარმატებით.
და ახლა, ჩვენ კი მიიღოს ჩაინიშნეთ ეს, ვთქვათ, GDB.
>> ნება მომეცით წასვლას იგივე ფაილი.
ნება მომეცით წავიდეთ წინ და აწარმოებს GDB of ./swap.
და ახლა, შეცვლა, მე ვაპირებ წავიდეთ წინ და მითითებული შესვენების in მთავარი.
და ახლა მე ვაპირებ წავიდეთ წინ და აწარმოებს პროგრამა.
და ახლა ჩვენ ვხედავთ ჩემი კოდი ათვისება რომ ხაზი.
>> თუ წავიდეთ წინ და ბეჭდვა x, რა უნდა ნახოთ აქ?
ეს საკითხი.
ამბობენ, რომ კიდევ ერთხელ?
>> აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ასე რომ, შემთხვევითი ნომრები, იქნებ.
იქნებ მე იღბლიანი, და ეს ლამაზი და მარტივი, როგორც 0.
მაგრამ იქნებ ეს შემთხვევითი ნომერი.
ამ შემთხვევაში, მე მივიღე გაუმართლა.
ეს მხოლოდ ხდება, 0.
მაგრამ ეს მართლაც luck, იმიტომ, რომ სანამ არ
აკრიფოთ შემდეგი და შემდეგ ბეჭდვა x აქვს, რომ ხაზი კოდი, ხაზი 19, შესრულდა.
>> იმავდროულად, თუ მე აკრიფოთ შემდეგი ერთხელ და ბეჭდვა Y, მე ვაპირებ 2.
ახლა, თუ მე აკრიფოთ შემდეგი, რომ ის აპირებს კიდევ ცოტა დამაბნეველი, რადგან ახლა,
printf აპირებს გამოჩნდება ეკრანზე, როგორც ეს გააკეთეს. x არის 1.
>> მოდით ეს კიდევ ერთხელ გავაკეთოთ.
და ახლა, აქ, სადაც რამ საინტერესო.
ადრე მოვუწოდებ Swap ან თუნდაც ნაბიჯი ეს, მოდით ცოტა peek.
x, კიდევ ერთხელ, 1.
Y, რა თქმა უნდა, სწრაფი საღი აზრის შეამოწმეთ, 2, ასე რომ არ არის ძნელი არსებობს.
მაგრამ რა არის ampersand x?
პასუხი, ის სახის ხმაურიანი ეძებს.
მაგრამ int ვარსკვლავი ფრჩხილებში მხოლოდ მშპ გზა ამით არის მისამართზე.
ეს არ არის int, ეს მაჩვენებელი int, ან სხვაგვარად ცნობილია როგორც მისამართზე.
>> რა არის ამ გიჟები რამ?
ჩვენ არასოდეს მინახავს რაღაც საკმაოდ მომწონს, რომ ადრე.
ასე რომ, ეს არის მისამართი ჩემი კომპიუტერის ხსოვნას, სადაც x ხდება ცხოვრება.
ეს Ox რაღაც.
და ეს არის, სიმართლე გითხრათ, რატომ მე დაიწყო ხატვის ისრებით,
ნაცვლად, რადგან, ვინც ნამდვილად ზრუნავს
რომ თქვენი int არის ერთი კონკრეტული მისამართი აი ეს.
მაგრამ bffff0c4, ეს არის ყველა მართლაც თექვსმეტობითი ციფრები,
რომლებიც 0 მეშვეობით ვ.
>> ასე რომ, ჩვენ არ ვაპირებთ, რომ არენაზე ძალიან ხანგრძლივი რა იმ რამ.
მაგრამ თუ მე ამობეჭდოთ y, რა თქმა უნდა, ვხედავ 2.
მაგრამ ampersand y, მე ვერ ვხედავ ამ მისამართზე.
და შენიშნავს, რომ აინტერესებს, რამდენად შორს არის X და Y?
თქვენ შეგიძლიათ იგნორირება ყველაზე მისამართზე.
ოთხი ბაიტი.
და ეს შეესაბამება ჩვენს ადრე აცხადებენ, რომ რამდენად დიდი არის int?
ოთხი ბაიტი.
ასე რომ, ეს გამოიყურება ყველაფერი უგულებელყოფა up ლამაზად, როგორც თქვენ შესაძლოა, იმედი მაქვს, მეხსიერებაში.
>> ახლა, მოდით უბრალოდ სწრაფი წინ ბოლომდე ეს ამბავი.
მოდით წავიდეთ წინ და ტიპის ნაბიჯი, ჩაყვინთვის შევიდა swap ფუნქცია.
ახლა შეამჩნია, თუ მე აკრიფოთ, ეს იდენტური მისამართი x.
თუ მე აკრიფოთ b, იდენტური მისამართს y.
რა უნდა დაინახოს, თუ ამბობენ, წავიდეს მისამართი?
ასე ბეჭდვა ვარსკვლავი.
ასე ვარსკვლავი იმას ნიშნავს, იქ, ამ კონტექსტში.
Ampersand რას ნიშნავს ეს მისამართი.
ასე ვარსკვლავი საშუალება 1.
და ბეჭდვითი ვარსკვლავი b მაძლევს 2.
>> და ნება მომეცით ვივარაუდოთ, ამ ეტაპზე, რომ მინიმუმ კოდი, რომელიც
აგრძელებს შეასრულოს ახლა შეიძლება დასაბუთებული მეშვეობით, რომ გზა.
მაგრამ ჩვენ დავუბრუნდეთ ამ იდეას ადრე ხანგრძლივი.
ასე რომ, ეს მობილური Swap არის სწორი და საშუალებას იძლევა
us სვოპ ამ კონკრეტულ მონაცემთა ტიპის.
>> ასე რომ, ნებისმიერი კითხვები შემდეგ Swap?
On ვარსკვლავი?
On მისამართი?
და დაინახავთ, რომელზეც პრობლემა კომპლექტი 4, სახის,
მაგრამ პრობლემა კომპლექტი 5, აუცილებლად, თუ როგორ შეიძლება ამ რამ სასარგებლო და კიდევ უფრო მეტი
კომფორტული მათთან, როგორც შედეგი.
არაფერი ყველა?
ყველა უფლება.
ასე malloc, კიდევ ერთხელ, ამ ფუნქციის რომ უბრალოდ გამოყოფს მეხსიერება, მეხსიერება
გამოყოფა.
და რატომ არის ეს სასარგებლო?
ასევე, ყველა ამ დროს, თქვენ უკვე გამოყენებით malloc.
თუ თქვენ თვლით, ახლა როგორ getString სამუშაოები, სავარაუდოდ, ეს
უკვე ითხოვს ვინმე ბლოკი მეხსიერება, ნებისმიერ მომხმარებლის ტიპის სიმებიანი
, იმიტომ, რომ ჩვენ, რა თქმა არ ვიცი, რადგან CS50 პერსონალი,
როგორ დიდი იმ strings, რომ ადამიანები ვაპირებთ აკრიფოთ შეიძლება იყოს.
>> ასე რომ, მოდით, პირველად, დაიწყოს კანი უკან როგორ CS50 ბიბლიოთეკა სამუშაოები,
გზით რამდენიმე მაგალითები რომელიც მიგვიყვანს იქ.
ასე რომ, თუ მე ქმნის gedit და ქმნის scanf 0,
ჩვენ ვაპირებთ, რომ შემდეგი კოდი.
Scanf 0, ხელმისაწვდომია ვებგვერდზე დღეს, შედარებით რამდენიმე ხაზი კოდი
აქ, 14 დან 20.
და ვნახოთ, თუ რას აკეთებს.
იგი აცხადებს, int, მოუწოდა x.
ის ამბობს, რომ მსგავსი რამ, ნომერი გთხოვთ.
და ახლა ის ამბობს, scanf% i, და x.
ასე რომ, აქ არის რამოდენიმე ახალი პერსონალის არსებობს.
>> მაგრამ scanf, შეგიძლიათ სახის ვფიქრობ როგორც საპირისპირო printf.
printf, რა თქმა უნდა, ბეჭდავს ეკრანზე.
scanf სახის დაასკანირებს მომხმარებელს ს კლავიატურის რაღაც იგი აკრეფილი.
>> % I, ისევე, როგორც printf.
ეს იმას ნიშნავს, ველით, მომხმარებელს აკრიფოთ int.
და ახლა, რატომ გგონიათ, რომ მე შეიძლება გავლის scanf და x?
თუ მიზანი ცხოვრებაში scanf არის კიდევ რაღაც, შესახებ,
რა მნიშვნელობა აქვს გვერდის ავლით, და x, ახლა?
ჰო?
>> აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ზუსტად.
რასაც მე, ადამიანური, აკრიფოთ, ჩემი შეყვანის იქნება შენახული იყო.
ეს არ არის საკმარისი, გავიხსენოთ, რომ მხოლოდ კორიდორი x, რადგან ჩვენ ვნახეთ უკვე,
ნებისმიერ დროს თქვენ გაივლის, ისევე, ნედლეული ცვლადი, როგორც int, რომ ზოგიერთი სხვა ფუნქცია,
დარწმუნებული ვარ, რომ შეიძლება შეიცვალოს, რომ ცვლადი, მაგრამ არა მუდმივად.
მას არ შეუძლია ჰქონდეს ეფექტი მთავარი.
ეს შეიძლება მხოლოდ შეცვალოს თავისი ადგილობრივი ასლი.
მაგრამ თუ, ნაცვლად, თქვენ არ მომეცი ფაქტობრივი int,
მაგრამ მომეცი მიმართულებით რომ int, ახლა, როგორც scanf,
რა თქმა უნდა, შემიძლია, რომ მისამართი და დააყენა მთელი რიგი არსებობს
ასე, რომ თქვენ გაქვთ ის, ისევე.
>> ასე რომ, როდესაც მე აწარმოებს ამ პროგრამის, ვნახოთ.
რათა scanf 0 dot ხაზი, scanf 0.
და თუ ახლა აკრიფოთ ნომერი 50, მადლობა 50.
თუ მე ახლა აკრიფოთ ნომერი ასე უარყოფითი 1, უარყოფითი 1.
მე ახლა აკრიფოთ ნომერი ასე 1.5, hm.
რატომ ჩემი პროგრამა იგნორირება ჩემთვის?
ასევე, იმის გამო, უბრალოდ, ვუთხარი, ის უნდა ველოდოთ int მხოლოდ.
ყველა უფლება.
ისე, რომ ერთი ვერსია ამ.
ავიღოთ რამ up მაღალი დონის და ვთავაზობ, რომ ეს არ არის კარგი.
და აქ დევს ძალიან მარტივი მაგალითი როგორ შეიძლება დავიწყო წერა კოდი
რომ სხვა ადამიანების ექსპლუატაცია და კომპრომისზე ცუდად იქცეოდა.
ასე რომ, ხაზი 16, იმდენად მსგავსია სულითა ადრე,
მაგრამ მე არ გამოცხადების ეს int ამ დროს.
მე გამოცხადების ეს char ვარსკვლავი, aka სიმებიანი.
>> მაგრამ რას ნიშნავს, ნამდვილად?
ასე რომ, თუ მე არ დააკონკრეტა address-- და მე ამას თვითნებურად, ბუფერული,
მაგრამ მე ვერ ეძახით s, უნდა იყოს simple-- და მაშინ მე ამის გაკეთება, ახსნას ჩემთვის,
თუ შეიძლება, ეფუძნება წინა ლოგიკით, თუ რა არის scanf აკეთებს ხაზი 18,
თუ უღელტეხილზე% s და ბუფერული, რომელიც არის მისამართი?
რა არის scanf, თუ ვრცელდება ზუსტად იგივე ლოგიკა, როგორც მობილური: 0,
იმის გამო, აქ, როდესაც მომხმარებლის ტიპის რაღაც?
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ზუსტად.
Scanf, ლოგიკა ადრე, აპირებს მიიღოს სიმებიანი
რომ ადამიანის აკრეფილი in-- ეს არის ტექსტი,
ეს არ არის ნომერი, სავარაუდოდ, თუ იგი cooperates--
და ის აპირებს ცდილობენ დააყენა, რომ სიმებიანი მეხსიერებაში რასაც მისამართი
ბუფერული განსაზღვრავს.
და ეს არის დიდი იმის გამო, რომ ბუფერული მართლაც ნიშნავს, რომ მისამართზე.
>> მაგრამ აცხადებენ, რომ ამ პროგრამის buggy წელს ძალიან სერიოზული გზა, რადგან ის, რაც არც
ბუფერული იყოს?
რა არ მინდა ინიციალიზაცია შევიდა?
რა ბლოკი მეხსიერება?
მე არ, არა?
>> ასე რომ, მიუხედავად იმისა, რომ მე გამოყოფილი char ვარსკვლავი, რომ აღარ მოუწოდა s,
ის სანაცვლოდ მოუწოდა, buffer-- ასე მოდით დავხატოთ ცვლადი სახელი
ახლა, როგორც buffer-- თუ მე არ მოუწოდა GetString ან malloc აქ,
რომ იმას ნიშნავს, რომ ბუფერული მხოლოდ ზოგიერთი ნაგვის ღირებულება.
>> ახლა რას ნიშნავს ეს?
ეს ნიშნავს, რომ მე ვუთხარი scanf ველოდოთ string საწყისი მომხმარებელს.
და იცით რა?
რაც არ უნდა იყოს იმაზე მიუთითებს, რომელთა მიზანია და მე მიაპყროს კითხვის ნიშნის,
მაგრამ სინამდვილეში, ეს იქნება რაღაც OX1, 2, 3, არა?
ეს რაღაც ყალბი მნიშვნელობა, რომელიც მხოლოდ ხდება იქ ადრე.
ასე რომ, კიდევ ერთი გზა, , თითქოს ბუფერული მხოლოდ
მიუთითებს რაღაც მეხსიერებაში.
მე არ ვიცი, რა.
>> ასე რომ, თუ მე აკრიფოთ Gabe ახლა, ის აპირებს ვცდილობ g-a-b-e / 0 იქ.
მაგრამ ვინ იცის რა, რომ არის?
და წარსულში, ნებისმიერი დროს, ჩვენ შევეცადეთ შეეხოთ
მეხსიერება, რომელიც არ განეკუთვნება ჩვენთვის, თუ რა მოხდა?
ან თითქმის ყოველ ჯერზე.
სეგმენტაცია ბრალია, არა?
>> ეს ისარი, მე არ ვიცი, სადაც ეს მიუთითებს. ეს მხოლოდ შემთხვევითი ღირებულება.
და რა თქმა უნდა, თუ ინტერპრეტაცია შემთხვევითი არც როგორც მისამართი,
თქვენ აპირებს მისვლას შემთხვევითი დანიშნულების.
ასე რომ, Gabe შეიძლება მართლაც crash ჩემი პროგრამა, ამ შემთხვევაში აქ.
>> რა უნდა გააკეთოთ, რომ თითქმის როგორც ცუდი?
მიგვაჩნია, რომ ეს მესამე და საბოლოო მაგალითია scanf.
ეს ვერსია უკეთესია, რა გაგებით?
თუ თქვენ კომფორტულად წინა პრობლემა, ეს არის უკეთესი.
რატომ?
>> აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: კარგი.
ასე რომ, ამ შემთხვევაში line 16 უკეთესია, იმ გაგებით,
რომ ჩვენ მკაფიოდ გამოყოფის ზოგიერთი მეხსიერება.
ჩვენ არ იყენებს malloc, ჩვენ გამოყენებით week 2
მიდგომა მხოლოდ გამოცხადების მასივი.
და ჩვენ დაწყებამდე განაცხადა, რომ ტექსტი მხოლოდ მასივი გმირები,
ასე რომ ეს არის სრულიად ლეგიტიმური.
მაგრამ ეს, რა თქმა უნდა, თქვენ აღვნიშნო, ფიქსირებული ზომა, 16.
>> ასე რომ ამ პროგრამის სრულიად უსაფრთხო, თუ მე აკრიფოთ
ერთი ხასიათის სტრიქონები, ორი ხასიათი strings, 15 ხასიათის სტრიქონები.
მაგრამ როგორც კი დაიწყება აკრეფით 16, 17, 18, 1000 ხასიათის სტრიქონები,
არის ის, რომ სიმებიანი აპირებს დასრულდება up?
ის აპირებს დასრულდება მდე ნაწილობრივ აქ.
მაგრამ მაშინ ვინ იცის, რა არის საზღვრებს გარეთ
ამ კონკრეტულ მასივი?
>> ეს თითქოს მე განაცხადა 16 ყუთები აქ.
ასე რომ, ვიდრე გამოიყენოს ყველა 16, ჩვენ გამოგიგზავნით უბრალოდ ვიტყვი, რომ მე შედგენილი 16.
მაგრამ თუ მაშინ ცდილობენ წაიკითხონ სიმებიანი რომ არის ბევრად უფრო, 50 პერსონაჟი,
მე ვაპირებ დაიწყება აყენებს a, b, c, d, x, y, z.
და ეს, სავარაუდოდ, ზოგიერთი სხვა მეხსიერების სეგმენტი
, კიდევ ერთხელ, შეიძლება გამოიწვიოს ჩემი პროგრამის მისაწოდებლად,
იმიტომ, რომ მე არ სთხოვა არაფერი მეტი, ვიდრე უბრალოდ 16 ბაიტი.
>> ვინ ზრუნავს?
ისე, აქ CS50 ბიბლიოთეკაში.
და ყველაზე მეტად ეს მხოლოდ როგორიცაა ინსტრუქციები up დაბრუნება.
CS50 ბიბლიოთეკა, ყველა ამ დროს, ჰქონდა ეს ხაზი line 52.
ჩვენ ვნახეთ typedef, ან თქვენ ნახავთ, typedef
pset 4, რომელიც მხოლოდ ქმნის სინონიმი, რომლის char ვარსკვლავი შეიძლება იყოს უფრო
უბრალოდ იწოდებიან, როგორც სიმებიანი.
ასე რომ, ეს არის ერთ ერთი ყველაზე რამდენიმე სასწავლო დისკები
ჩვენ გამოიყენება ფარულად ქვეშ hood.
>> იმავდროულად, აქ ფუნქცია, getchar.
ახლა, როგორც ჩანს, არ არსებობს ორგანო, რომელიც მას.
და რეალურად, თუ მე შენარჩუნება სენსორული, მე არ რეალურად
ხედავთ რაიმე შესრულება ეს ფუნქციები.
როგორც საღი აზრის შემოწმება, თუ რატომ არის, რომ?
>> აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ჰო.
ასე რომ, ეს არის header ფაილი.
და header ფაილი შეიცავს პროტოტიპები, ასევე რამდენიმე სხვა პერსონალი, როგორც ჩანს,
როგორიცაა typedefs.
მაგრამ CS50.c, რომელიც ჩვენ არ მოგცათ აშკარა,
მაგრამ უკვე CS50 ელექტრო მოწყობილობების ყველა ამ დროს, ღრმა შიგნით მისი ფოლდერები,
შეამჩნია, რომ არსებობს მთელი bunch of ფუნქციები აქ.
>> ფაქტობრივად, მოდით გადახვევა ქვემოთ.
მოდით იგნორირება მათი უმრავლესობა, ახლა.
მაგრამ გადახვევა ქვემოთ getInt და ვნახოთ, როგორ getInt მუშაობს.
ასე რომ, აქ არის getInt.
და თუ თქვენ ოდესმე ნამდვილად ზრუნავენ, თუ როგორ მიიღონ int მუშაობს, აქ არის მისი დოკუმენტაცია.
და მათ შორის რამ ის ამბობს, რომ ის გიჩვენებთ
რა მერყეობს ღირებულებები მას შეუძლია დაბრუნდეს.
ეს არსებითად უარყოფითი 2 მილიარდი დადებითი 2 მილიარდი, მისცეს ან მიიღოს.
>> და თურმე, ეს ყველაფერი დროს, მიუხედავად იმისა, რომ ჩვენ არასდროს
რომ თქვენ შეამოწმოთ ეს, თუ რაღაც მიდის არასწორი,
გამოდის, რომ ყველა ამ დროს, getInt აქვს
უკვე დაბრუნების სპეციალური მუდმივი, არ null,
არამედ INT_MAX, რომელიც უბრალოდ პროგრამისტი ის კონვენციას.
ეს იმას ნიშნავს, რომ აქ არის განსაკუთრებული მნიშვნელობა.
შეამოწმეთ ეს, უბრალოდ იმ შემთხვევაში, თუ რაღაც მიდის არასწორი.
მაგრამ ჩვენ არ აწუხებს რომ დღემდე,
იმიტომ, რომ კიდევ ერთხელ, იგულისხმება, რომ გამარტივდეს.
>> მაგრამ, როგორ getInt მისაღებად განხორციელებული?
ასევე, ერთი, მას სჭირდება არანაირი არგუმენტი.
ჩვენ ვიცით, რომ.
ის დააბრუნებს int.
ჩვენ ვიცით, რომ.
ასე რომ, როგორ მუშაობს იგი ქვეშ hood?
>> ასე არ არის, როგორც ჩანს, უსასრულო loop, მინიმუმ გამოჩენა ერთი.
გაითვალისწინეთ, რომ ჩვენ გამოყენებით getString.
ასე, რომ საინტერესოა. getInt მოუწოდებს ჩვენი საკუთარი ფუნქცია, getString.
და ახლა რატომ შეიძლება იყოს ამ შემთხვევაში?
რატომ ვარ მე თავდაცვითი აქ ხაზი 165?
რა შეიძლება მოხდეს ხაზი 164, უბრალოდ უნდა იყოს წმინდა?
ეს არის იგივე პასუხი, როგორც ადრე.
შეიძლება უბრალოდ მეხსიერება ღალატობს.
რაღაც მიდის არასწორი getString, ჩვენ მივიღეთ შეძლებს გაუმკლავდეს, რომ.
და მიზეზი მე არ ბრუნდება null არის რომ ტექნიკურად null მაჩვენებელი.
getInt დააბრუნებს int.
ასე რომ მე თვითნებურად გადაწყვიტა, არსებითად,
რომ 2 მილიარდი, მისცეს ან მიიღოს, აპირებს უნდა იყოს განსაკუთრებული მნიშვნელობა, რომ მე ვერასოდეს
რეალურად მიიღონ შესახებ.
ეს მხოლოდ ერთი მნიშვნელობა, მე ვაპირებ დაგვრჩა წარმოადგენენ შეცდომის კოდი.
>> ასე რომ, ახლა რამ კიდევ პატარა ლამაზი.
და ეს არ არის იგივე ფუნქცია როგორც ადრე, მაგრამ ეს ძალიან ჰგავს.
ასე რომ შეამჩნია, ვაცხადებ, აქ, ხაზი 172, როგორც int n და char c.
და შემდეგ გამოვიყენო ეს ხმაურიანი ხაზი, sscanf, რომელიც თურმე
არ სკანირების სიმებიანი კლავიატურის.
იგი დგას არსებული სიმებიანი მომხმარებლის უკვე აკრეფილი.
ასე რომ, მე უკვე მოუწოდა getString, რომელიც იმას ნიშნავს, რომ სიმებიანი მეხსიერებაში.
sscanf არის ის, რაც ნეტავ მოვუწოდებთ parsing ფუნქცია.
ის უყურებს string მე აკრეფილი, ხასიათი ხასიათი,
და აკეთებს რაღაც სასარგებლო.
რომ სიმებიანი ინახება ონლაინ.
და მე ვიცი, რომ მხოლოდ აპირებს უკან აქ და ამბობდა, რა, OK,
მე მას არ არის ეს დრო, მაგრამ ონლაინ.
>> და ახლა ეს ცოტა განსხვავებული.
მაგრამ ეს იმას ნიშნავს, რომ, იმის გამო, ჩვენ გარკვეულწილად ტალღა ჩვენს ხელში დღეს,
რომ ჩვენ შემოწმების თუ მომხმარებლის აკრეფილი
და int და შესაძლოა კიდევ ხასიათი.
თუ მომხმარებლის აკრეფილი int, ეს იქნება შენახული n, რადგან მე ვარ
ჩაბარების ამ მისამართზე, ახალი ხრიკი ჩვენ ვნახეთ დღეს.
თუ მომხმარებელს ასევე აკრეფილი მსგავსად 123x, რომ x
აპირებს დასრულდება მდე წერილი ხასიათი c.
>> ახლა ირკვევა, რომ sscanf იქნება მითხრათ, ჭკვიანურად,
რამდენი ცვლადები იყო sscanf წარმატებით შეუძლია შეავსოს.
ასე რომ, ამ ლოგიკით, თუ ფუნქცია მე განხორციელების არის getInt,
მაგრამ მე შემოწმების, პოტენციურად, რომ შესახებ
არ აკრეფილი int მოყვება რაღაც,
რა მინდა sscanf მიერ დაბრუნების ღირებულება ნამდვილად უნდა იყოს?
თუ მიზანი არის მიიღონ უბრალოდ int საწყისი ხარ?
>> ასე რომ, თუ sscanf ბრუნდება 2, რას ნიშნავს ეს?
მომხმარებლის აკრეფილი რაღაც, ფაქტიურად,
123x, რომელიც უბრალოდ სისულელეა.
ეს შეცდომა მდგომარეობაში და მინდა შევამოწმო რომ.
>> ასე რომ, თუ მომხმარებელი სახის ეს, მიერ ამ ლოგიკით, რას sscanf დაბრუნებას,
იტყვით?
ასე რომ დაბრუნებას აპირებს 2, იმიტომ, 123 აპირებს წასვლა აქ
და x აპირებს დასრულდება up in აქ.
მაგრამ მე არ მინდა, რომ x უნდა შეივსოს.
მინდა sscanf მხოლოდ წარმატების შევსების პირველი ცვლადები.
და ამიტომაც მე მინდა sscanf დაბრუნების 1.
>> და თუ ეს არის ცოტა მეტი ხელმძღვანელი ამ ეტაპზე, რომ მთლიანად ჯარიმა.
გააცნობიეროს, მიუხედავად იმისა, რომ ერთი ღირებულებები getInt და getString
არის, რომ ჩვენ ვაკეთებთ heck საქართველოს ბევრი შეცდომა შემოწმების მოსწონს ეს ასე
რომ, დღემდე, თქვენ შეგიძლიათ საკმაოდ ბევრი აკრიფოთ არაფერი თქვენს კლავიატურაზე,
და ჩვენ დაიჭიროთ იგი.
და ჩვენ რა თქმა უნდა, პერსონალი, არავითარ შემთხვევაში არ
იყოს წყარო bug თქვენს პროგრამა, რადგან ჩვენ დაცვითი
შემოწმების ყველა სულელური რამ, რომ შესახებ შეიძლება გავაკეთოთ,
როგორიცაა აკრეფით ტექსტი, როდესაც თქვენ ნამდვილად სურდა int.
ასე რომ, ახლა ჩვენ მოვალთ თავში ეს ადრე long--
მაგრამ ამ დროს, getString და getInt აქვს
უკვე ქვეშ hood გამოყენებით ამ ძირითადი იდეა მისამართები მეხსიერება.
>> ახლა, მოდით, რათა რამ ცოტა უფრო მოსახერხებელი.
როგორც გახსოვთ, საწყისი Binky ბოლო time-- თუ ჩემი მაუსის cooperate-- ასე
ჩვენ გვქონდა ამ კოდი, რაც გულწრფელად ვამბობ, საკმაოდ აბსურდული.
ეს კოდი აღწევს არაფერი სასარგებლო, მაგრამ ეს იყო, მაგალითად
რომ პროფესორი Parlante გამოიყენება იმისათვის, რომ წარმოადგენს
რა ხდებოდა პროგრამა მოიცავს მეხსიერებაში.
>> ასე რომ, მოდით მოგითხროთ ამ ამბავი სუპერ მოკლედ.
პირველი ორი ხაზები, ინგლისური, რა, იტყვით?
უბრალოდ გონივრულად ადამიანის, მაგრამ ოდნავ ტექნიკური თვალსაზრისით, მიიღოს stab.
აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: OK, თქვენ შექმნის მისამართები თქვენი x და y ცვლადები.
არ საკმაოდ, რადგან x და y არ არის ცვლადები ტრადიციული გაგებით.
x და y მისამართები ან შესანახად მისამართზე.
მოდით ცდილობენ ამ კიდევ ერთხელ.
არ არის ცუდი დასაწყისია, თუმცა.
ჰო?
>> აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: კარგი.
მე ვფიქრობ, რომ ცოტა სუფთა.
გამოცხადების ორი პოინტერები, ორი რიცხვებით.
და ჩვენ მოუწოდებდა მათ x და y.
ან თუ ჩვენ მიაპყროს ამ სურათის, კიდევ ერთხელ,
გავიხსენოთ, უბრალოდ, რომ ყველა რას ვაკეთებთ, რომ პირველ ხაზზე
ხატვის ყუთი, როგორც ეს, ზოგიერთი ნაგვის ღირებულება ის,
და უწოდა x, და მაშინ ერთ ყუთში, როგორც ეს,
ზოგიერთი ნაგვის ღირებულება ეს უწოდა y.
ჩვენ განაცხადა, ორი მითითებას, რომ, საბოლოო ჯამში,
შესანახად მისამართი int.
ასე რომ, ეს ყველაფერი არსებობს.
>> ასე რომ, როდესაც Binky ეს გავაკეთეთ, თიხის უბრალოდ ჩანდა მოსწონს ეს.
და ნიკა მხოლოდ სახის დაასრულა ისრებით,
როგორც იმისა, რომ ისინი არ მიუთითებს სადმე კერძოდ, რადგან ისინი უბრალოდ
ნაგვის ღირებულებებს.
ისინი არ არის მკაფიოდ ინიციალიზაცია სადმე კერძოდ.
>> ახლა მომდევნო ხაზი კოდი, გაწვევა, სწორედ ეს იყო.
ასე რომ, გონივრულად, მოსახერხებელი, მაგრამ ცოტა ტექნიკური ინგლისური,
რა არის ეს ხაზი კოდი აკეთებს?
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: Perfect.
ის გამოყოფის ბლოკი მეხსიერება რომ ზომა int.
და რომ ნახევარი პასუხი.
თქვენ უპასუხა უფლება ნახევარი გამოხატულება.
რა ხდება მარცხენა მხარეს თანაბარი ნიშანი?
ჰო?
აუდიტორია: და ასიგნებების ეს ცვლადი x?
>> დევიდ ჯ Malan: ანიჭებს ეს ცვლადი x.
ასე რომ recap, მარჯვენა მხარეს გამოყოფს საკმარისი მეხსიერების შესანახად int.
მაგრამ malloc კონკრეტულად დააბრუნებს მისამართი
რომ ბლოკი მეხსიერება, რომელიც თქვენ მხოლოდ შემოთავაზებული იღებს შენახული x.
>> ასე რომ, რა Nick გავაკეთეთ ბოლო დროის Binky არის იგი გაიწელა, რომ მაჩვენებელი გარეთ, თიხა,
უნდა აღვნიშნო, ახლა თეთრ ბლოკი მეხსიერება რომ არის თანაბარი ზომის int.
და მართლაც, რომ ნიშნავდა to წარმოადგენს ოთხი ბაიტი.
>> ახლა, მომდევნო ხაზი კოდი ეს, ვარსკვლავი x იღებს 42.
ასე რომ 42 არის უშუალო შესახებ მარჯვენა მხარეს, მნიშვნელობა ცხოვრებაში.
მარცხენა მხარეს, ვარსკვლავი x რას ნიშნავს?
რომ ძალიან შეიძლება ჰქონდეს gone-- რომ კარგადაა.
OK.
>> აუდიტორია: ძირითადად, წასვლა [INAUDIBLE]
დევიდ ჯ Malan: კარგი.
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ზუსტად.
მარცხენა მხარეს ნიშნავს წასვლა x.
x არის მისამართი.
ეს იგივეა, რომ 33 Oxford Street, ან OX1.
და ვარსკვლავი x იმას ნიშნავს, რომ მიმართოს და ამით რა არის?
42.
>> ასე რომ, მართლაც, რომ ზუსტად ის, რაც Nick გააკეთა.
მან დაიწყო მიერ, არსებითად, გონებრივად
მიუთითებს თითს x, შემდეგ arrow
თეთრი ყუთი მარჯვენა მხარეს, და გამოსული ხმების 42 იქ.
მაგრამ მაშინ რამ მივიღე ცოტა საშიში, არა?
Binky ს შესახებ დაკარგავს თავის არეში.
>> Star y უდრის 13, ცუდი იღბალი, რას ნიშნავს?
ასე ვარსკვლავი y საშუალებით წასვლა მისამართზე წ.
მაგრამ რა არის მისამართი y?
ყველა უფლება, ეს ნაგვის ღირებულება, არა?
მიიპყრო იგი კითხვის ნიშნის.
Nick მიიპყრო, როგორც მოიგერია ისარი.
და როგორც კი თქვენ ცდილობენ ამის გაკეთება ვარსკვლავი y და განაცხადა, რომ იქ,
მაგრამ არ არის ლეგიტიმური მისამართი, მას რამდენიმე ყალბი ადგილმდებარეობა,
პროგრამის აპირებს მისაწოდებლად.
და Binky ს ხელმძღვანელი აპირებს ფრენა off აქ, როგორც ეს გააკეთეს.
>> ასე რომ, საბოლოო ჯამში, ამ პროგრამის იყო მხოლოდ ბინის გარეთ ხარვეზი.
ეს იყო buggy პროგრამა.
და ეს საჭირო დაფიქსირდა.
და ერთადერთი გზა, მართლაც, გაასწორონ ის იქნება, მაგალითად, ამ მიმართულებით,
რომელიც ჩვენ კი არ მიიღოთ, რადგან პროგრამა შეეჯახა ძალიან მალე.
მაგრამ, თუ ჩვენ უნდა დაფიქსირება ამ, რა ეფექტი აქვს აკეთებს Y ტოლია x გაქვთ?
ისე, ეს არსებითად მიუთითებს Y ზე რასაც ღირებულება x არის მიუთითებს.
>> ასე რომ, Nick ამბავი, ან Binky ამბავი, როგორც
x და y მიუთითებდნენ თეთრი ბლოკი მეხსიერება,
ასე რომ, ბოლოს, როდესაც თქვენ არ ვარსკვლავს y უდრის 13 ერთხელ,
თქვენ დასრულდება მდე გამოსული 13 შესაბამის ადგილას.
ასე რომ, ყველა ამ ხაზების შესანიშნავად ლეგიტიმური, გარდა ამ ერთი,
როდესაც ეს მოხდა, სანამ რეალურად დანიშნული y გარკვეული მნიშვნელობა.
>> ახლა, საბედნიეროდ, თქვენ არ უნდა ვიმსჯელოთ ყველა
ასეთი საკითხები თქვენი საკუთარი.
ნება მომეცით წავიდეთ წინ და გახსნა ტერმინალის ფანჯარაში აქ
და ქმნის, რაღაც მომენტში, სუპერ მოკლე პროგრამა, რომელიც
ასევე არის ერთგვარი უაზრო.
ეს მახინჯი.
ეს არ მივაღწევთ არაფერი სასარგებლო.
მაგრამ ეს იმას დემონსტრირება საკითხები მეხსიერება, მოდით შევხედოთ.
>> მთავარი, სუპერ მარტივი.
ეს აშკარად უწოდებს ფუნქცია, f, და შემდეგ დააბრუნებს 0.
ეს ერთგვარი რთული სასადილო up.
ასე რომ მთავარი არის საკმაოდ კარგი, ჯერჯერობით.
>> ასე რომ ვ პრობლემატურია.
და უბრალოდ არ დააყენა ბევრი ძალისხმევა შევიდა დასახელებისგან იგი
აქ, რათა აქცენტი კოდი.
ვ ორი ​​ხაზი.
და ვნახოთ რა ახლა ხდება.
ასე რომ, ერთი მხრივ, აქ და ნება მომეცით
ეს შეესაბამება წინა example-- ერთის მხრივ,
მარცხენა მხარეს არის აკეთებს რა, ინგლისურ ენაზე?
ეს is--
აუდიტორია: შექმნა მაჩვენებელი.
დევიდ ჯ Malan: შექმნა მაჩვენებელი to int და უწოდა x.
ასე რომ, ეს ქმნის ერთ იმ ყუთები მე შენარჩუნება ხატვის სენსორული.
და ახლა, მარჯვენა მხარეს, malloc, რა თქმა უნდა,
გამოყოფის ბლოკი მეხსიერება.
და უბრალოდ უნდა იყოს მკაფიო, თუ როგორ რამდენი მეხსიერება არის, როგორც ჩანს,
გამოყოფის, თუ, უბრალოდ, სახის მათემატიკის აქ?
>> ასე რომ, ეს 40 ბაიტი.
და მე ვიცი, რომ მხოლოდ იმიტომ, რომ მე ვიცი, int, on CS50 ელექტრო მოწყობილობების, მინიმუმ,
არის ოთხი ბაიტი.
ასე 10 ჯერ 4 არის 40.
ასე რომ, ეს არის შენახვის x, მისამართი პირველი out of 40 ints, რომ
გამოიყო სივრცეში, უკან, უკან, უკან.
>> და ეს რა არის გასაღები შესახებ malloc.
იგი არ იღებს პატარა მეხსიერება აქ, ცოტა აქ, ცოტა აქ.
ეს გაძლევთ კიდევ ერთი ბლოკი მეხსიერება, contiguously, ოპერაციული
სისტემა.
>> ახლა რაც შეეხება ამ, x bracket 10 უდრის 0?
თვითნებური ხაზი კოდი.
ეს არ მივაღწევთ არაფერი სასარგებლო.
მაგრამ საინტერესოა, რადგან x bracket 10--?
ჰო?
>> აუდიტორია: [INAUDIBLE]?
>> დევიდ ჯ Malan: x bracket 10 არ უნდა იყოს null.
Null დეტალური მხოლოდ ძალაში პიესა სიმები, ბოლოს სიმებიანი.
მაგრამ კარგი აზრის.
>> როგორ დიდი არის მასივი, მაშინაც კი, თუმცა მე გამოყოფილი 40 ბაიტი?
ეს 0 მეშვეობით ცხრა, არა?
ეს არის 10 ints, სულ.
40 ბაიტი, მაგრამ 10 ints, ინდექსირებული 0 საშუალებით 0.
>> ასე რომ, რა არის ის, რომ x bracket 10?
ეს, ფაქტობრივად, ზოგიერთი უცნობი ნაგვის ღირებულება.
ეს მეხსიერების რომ არ მეკუთვნის.
მე არ უნდა ეხება, byte ნომერი 41, 42, 43, 44.
მე ვაპირებ ოდნავ შორს.
>> და მართლაც, თუ მე აწარმოებს ამ პროგრამა, ეს შეიძლება ძალიან კარგად მისაწოდებლად.
მაგრამ ზოგჯერ, ჩვენ გაუმართლა.
და ასე მხოლოდ იმის დემონსტრირება, ამას და გულწრფელად,
თქვენ არასდროს არ ვიცი, სანამ არ it-- მოდით აწარმოებს ამ.
ის პრაქტიკულად არ მისაწოდებლად.
>> მაგრამ თუ შევცვალო ეს, მაგალითად, უნდა იყოს, როგორიც 1000
იმისათვის, რომ ეს ნამდვილად მიზანმიმართული, ვნახოთ
თუ ჩვენ შეგვიძლია მივიღოთ ის მისაწოდებლად ამ დროს.
OK, ეს არ მისაწოდებლად.
როგორ 100,000?
მოდით შევცვალოთ ის, და ახლა გამეორება.
OK.
Phew.
ყველა უფლება.
ასე რომ, სავარაუდოდ, კიდევ ერთხელ, ამ სეგმენტების მეხსიერება, ასე ვთქვათ,
გონივრულად დიდი, ასე რომ, ჩვენ შეგვიძლია გაუმართლა ერთხელ და ისევ.
თუმცა, საბოლოოდ, კიდევ სასაცილოა და მართლაც წავიდეთ შორს ეკრანზე,
თქვენ შეეხოთ მეხსიერების რომ ნამდვილად, ნამდვილად არ ეკუთვნის.
>> მაგრამ გულწრფელად ვამბობ, ამ სახის შეცდომები ვაპირებთ
უნდა იყოს უფრო და უფრო რთული გაერკვნენ თქვენი საკუთარი.
მაგრამ საბედნიეროდ, როგორც პროგრამისტები, ჩვენ გვაქვს ინსტრუმენტი, რომელიც საშუალებას მოგვცემს გავაკეთოთ ჩვენთვის.
ასე რომ, ეს, ალბათ, ერთი საქართველოს ugliest პროგრამები,
თუნდაც მახინჯი, ვიდრე gdb ის გამომუშავება.
მაგრამ ეს ყოველთვის ხაზის ან ორი რომ სუპერ სასარგებლო.
>> Valgrind არის პროგრამა, რომელიც ეხმარება თქვენ არ გამართვის პროგრამა, თავისთავად,
მაგრამ მოვძებნოთ მეხსიერების დაკავშირებული პრობლემები, სპეციალურად.
ეს ავტომატურად აწარმოებს თქვენი კოდი და ვეძებთ ორი რამ.
ერთი, ის, რომ თქვენ რაღაც შემთხვევითი როგორიცაა შეხება მეხსიერება
რომ არ გეკუთვნის?
ეს დაგეხმარებათ იმ შემთხვევაში.
>> და ორი, ის დაეხმარება თქვენ რაღაც მოუწოდა
მეხსიერების ტბები, რომელიც ჩვენ გვაქვს სრულიად იგნორირებულია, გულუბრყვილოდ,
გარკვეული დრო და ბედნიერად.
მაგრამ აღმოჩნდება, ყველა ამ დროს, როდესაც
თქვენ მოუწოდა getString in ამდენი პროგრამები,
თქვენ გეკითხებით ოპერაციული სისტემის მეხსიერება,
მაგრამ თქვენ გაქვთ რაიმე მეხსიერებაში ოდესმე ვაძლევთ მას
უკან, აკეთებს unalloc, ან თავისუფალი, როგორც მას უწოდებენ.
არა, რადგან ჩვენ არასდროს გთხოვეთ ამის გაკეთება.
>> მაგრამ ყველა ამ დროს, პროგრამები თქვენ უკვე წერა C
უკვე ჩამოდის მეხსიერება, გეკითხებით ოპერაციული
სისტემა უფრო და უფრო მეხსიერების strings და whatnot,
მაგრამ არასოდეს გადაცემის უკან.
და ახლა ეს ცოტა ერთი მიდგომა,
მაგრამ თუ თქვენ ოდესმე აწარმოებს თქვენი Mac ან თქვენი PC საკმაოდ გარკვეული დრო, გახსნის
უამრავი პროგრამების, იქნებ დახურვის პროგრამები,
და მიუხედავად იმისა, რომ თქვენი კომპიუტერული არ შეეჯახა,
ის მიღების იმდენად ნელა, თითქოს ეს მართლაც
გამოყენებით უამრავი მეხსიერების ან რესურსები, მიუხედავად იმისა,
თუ თქვენ კი არ ეხება კლავიატურის,
რომელიც შეიძლება be-- მაგრამ არა always-- იქნებოდა შეიძლება, რომ პროგრამები, თქვენ გაშვებული
თავად მეხსიერების გაჟონვის.
და ისინი ითხოვს OS უფრო და მეტი მეხსიერება, მაგრამ დავიწყება შესახებ,
რეალურად არ გამოყენება, მაგრამ აქედან გამომდინარე, მეხსიერების მოშორებით
სხვა პროგრამები, რომლებიც გსურთ იგი.
ასე რომ, საერთო ახსნა.
ახლა აქ არის, სადაც Valgrind მიერ გამომავალი სრულიად
ბარბაროსულ იმ ნაკლებად და უფრო კომფორტული alike.
მაგრამ საინტერესო პერსონალის უფლება აქ.
ის მეუბნებოდა, არასწორი ჩაწერის საქართველოს ზომა ოთხი ხდება, ეს პროგრამა,
კერძოდ, ხაზი 21 memory.c.
>> თუ მე ხაზი 21, hm, ნამდვილად არის არის არასწორი ჩაწერის ზომა ოთხ.
რატომ ზომის ოთხი?
ასევე, ამ number-- და შეიძლება იყოს არაფერი int.
ასე რომ, ეს ოთხი ბაიტი.
ასე რომ, მე აყენებს ოთხი ბაიტი სადაც მათ არ ეკუთვნის.
ის, რაც Valgrind ფაქტობრივად მეუბნებოდა.
უფრო მეტიც, ის ასევე მეუბნებოდა, როგორც ვნახავთ,
როგორც თქვენ აწარმოებს ამ წელს მომავალი pset, თუ და როდესაც თქვენ გაჟონა მეხსიერება, რომელიც მართლაც
მე, რადგან მე მოუწოდა malloc, მაგრამ მე არ რეალურად
მოუწოდა, ამ შემთხვევაში, თავისუფალი, რომელიც ჩვენ საბოლოოდ ვხედავთ
პირიქით, malloc.
>> ასე რომ, ახლა მე ვფიქრობ, საბოლოო მაგალითი.
ასე რომ, ეს ერთი ცოტა მეტი arcane, მაგრამ ეს, ალბათ,
ყველაზე დიდი მიზეზი, ფრთხილად, მეხსიერება,
და იმ მიზეზით, რომ ბევრი პროგრამების ან / და ვებ სერვერების, თუნდაც ეს დღე,
ასრულებს ცუდი ბიჭები სადმე ინტერნეტ რომლებიც როგორღაც
გაგზავნის გაყალბებულად პაკეტი თქვენს სერვერზე ცდილობს კომპრომისზე თქვენი ანგარიშები,
ან მიიღოს თქვენი მონაცემები, ან უბრალოდ ზოგადად მიიღოს მეტი მანქანა.
ბუფერული overflow, როგორც სახელი ვარაუდობს, საშუალება
გადადის არ არის int, მაგრამ ბუფერულ.
და ბუფერული არის მხოლოდ ლამაზი გზა ვთქვა, რომ ეს არის რამოდენიმე მეხსიერება.
>> და მართლაც, მე მოუწოდა სიმებიანი ადრე ბუფერული, ნაცვლად s.
რადგან თუ ეს ბუფერული, ისევე როგორც YouTube თვალსაზრისით,
ან ნებისმიერ დროს თქვენ თვალს ვიდეო, თქვენ შეიძლება არ მინახავს სიტყვა buffering,
dot, dot, dot.
ეს ძალიან შემაშფოთებელი.
და ეს მხოლოდ იმას ნიშნავს რომ თქვენი ვიდეო დამკვრელი
ცდილობს ჩამოტვირთოთ უამრავი ბაიტი, უამრავი bytes
საწყისი ვიდეო ინტერნეტში.
მაგრამ ნელი, ასე რომ ის ცდილობს ჩამოტვირთვა რამოდენიმე მათგანი
შეავსოთ ბუფერული, კონტეინერი, ისე, რომ თქვენ გაქვთ საკმარისი bytes რომ მას შეუძლია შემდეგ
გაჩვენებთ ვიდეო, გარეშე დაპაუზება მუდმივად.
მაგრამ აღმოჩნდება, თქვენ შეგიძლიათ აქვს ბუფერული ამ დიდი.
მაგრამ ვცდილობ მას ამ დიდი მონაცემები , და ძალიან ცუდი რამ შეიძლება მოხდეს.
ასე მაგალითად, მოდით შევხედოთ საბოლოო teaser მაგალითი.
ეს არის კიდევ ერთი პროგრამა რომ, ერთი შეხედვით,
არაფერს არ აკეთებს სუპერ სასარგებლო.
მას აქვს ძირითადი ფუნქცია , რომელიც მოუწოდებს, რომ ფუნქცია, ვ.
და რომ ფუნქცია, f, აქ, აქვს char array, მოუწოდა C, ზომა 12.
და მაშინ ის იყენებს ამ ახალი ფუნქცია მოუწოდა strncpy.
>> გამოდის, რომ, ეს მარტივი, მარტივი ხაზი კოდი, უბრალოდ ორი ხაზი,
ჩვენ, ჩემი მთელი პროგრამა, და, შესაბამისად, მთელი ჩემი კომპიუტერი,
და ჩემი მომხმარებლის ანგარიში და ჩემს მყარ მანქანა პოტენციურად დაუცველი ვინმეს
ვინც იცის და არ არის საკმარისი, რომ აწარმოებს ამ პროგრამის გარკვეული command line
არგუმენტი.
სხვა სიტყვებით, თუ ეს ცუდი ბიჭი აყენებს შიგნით argvargv [1] აკრეფით
კლავიატურის ძალიან სპეციალურად crafted ტექსტი, არ abc, 123, მაგრამ, არსებითად,
ორობითი სიმბოლოები, რომელიც წარმოადგენს შესრულებადი კოდი, პროგრამა, რომელიც იგი წერდა,
ეს მარტივი პროგრამა, რომელიც წარმომადგენლობითი ათასობით პროგრამები
, რომლებიც ასეთივე დაუცველი, daresay, მას შეუძლია საბოლოოდ წაშლა ყველა
ფაილი ჩემს მყარ დისკზე, მიიღოს მოციმციმე სწრაფი, ასე რომ მას შეუძლია
აკრიფოთ ბრძანებები საკუთარი, ელ ყველა ფაილი თავს.
რამე, რომ მე გავაკეთებ, ის მას შეუძლია გააკეთოს ეს კოდი.
>> ჩვენ არ საკმაოდ გადაწყვიტოს ეს არ არის.
და ფაქტობრივად, ის აპირებს ჩართვა ცოტა სურათი
მსგავსი, რომელიც ჩვენ მალე მოვა უნდა გვესმოდეს, ყველა უკეთესი.
მაგრამ დღეს, მოდით დასრულდება რა არის, იმედია, ოდნავ მეტი
გასაგებია xkcd ხუმრობა, სანამ ჩვენ განაახლებს მომავალი დრო.
ყველა უფლება.
თქვენ ოთხშაბათს.
>> [მუსიკის დაკვრა]
>> დინამიკები და ახლა, ღრმა აზრები, მიერ Daven Farnham.
მეხსიერების ჰგავს jumping შევიდა pile of ოქროს ფოთლები კვირა დღის მეორე ნახევარში.
ქარი აფეთქებით, სროლაში თქვენი hair-- oh, მენატრება დღის when--
>> [სიცილი]