>> დავით Malan: Hello, და მივესალმებით უკან CS50.
ასე რომ, ეს ბოლოს კვირაში ოთხი.
მხოლოდ ერთი განცხადება გააკეთა.
ასე რომ, ე.წ. მეხუთე ორშაბათს ახლოვდება ამ მოდის ორშაბათს.
ეს არის შესაძლებლობა, რომ შეიცვალოს SAT / UNSAT ასო კლასის, ან
წერილი კლასის SAT / UNSAT.
გამაღიზინებლად, რომ პროცესი არ საჭიროებს ხელმოწერის, რადგან თქვენ უნდა შეავსოთ
ერთი იმ ვარდისფერი დამატება / წვეთი ფორმები.
>> იმის გამო, რომ ტექნიკურად, SAT / UNSAT მობილური და წერილი კლასის მობილური
აქვთ მკაფიო კატალოგი ნომრები.
თუმცა არ არის დიდი გარიგება.
უბრალოდ ამუშავება მე ან ძარცვა ან ლორენ ნებისმიერ წერტილში.
ან მოგვწეროთ თუ არ აქვს სახის დოკუმენტებზე მუშაობის გჭირდებათ დღეს, და ჩვენ
იქნება დარწმუნებული დაგეხმაროთ მიიღოს ზრუნვა, რომ ორშაბათს.
>> ყველა უფლება, დღეს -
ფაქტობრივად, არ არსებობს ცოტა ეხმიანება.
შეგვიძლია ტონი me ქვემოთ ცოტა?
OK.
ასე რომ, დღეს, ჩვენ დანერგვა თემას ცნობილია, როგორც მითითებას.
და მე ვაღიარებ, რომ ეს არის ერთ ერთი უფრო რთული საკითხები, რომლებიც ჩვენ ტენდენცია
დაფარავს ამ კლასის, ან მართლაც ნებისმიერ შესავალი კურსი, რომელიც იყენებს C.
>> მაგრამ ჩემს სიტყვას, რომ განსაკუთრებით თუ თქვენი გონება გრძნობს ცოტა მოხრილი
დღეს და კვირის მოვა.
ეს არ არის წარმომადგენლის თქვენ მისაღებად ნებისმიერი უარესი, ამ უბრალოდ იმას ნიშნავს, რომ
ეს განსაკუთრებით დახვეწილი თემას რომ მე გპირდებით, რამდენიმე კვირაში
აქედან გამომდინარე, როგორც ჩანს ძალიან საოცრად პირდაპირი ამ დროის.
>> ისევ მახსოვს ამ დღეს.
მე იჯდა Elliott სასადილო დარბაზი, სხდომაზე მომავალ ჩემს TF Nishat Mehta,
ვინ იყო მკვიდრი Elliott სახლში.
და რატომღაც ამ თემის უბრალოდ იმოქმედებს.
რომელი ვთქვა, რომ მე ძალიან იბრძოდა მას გარკვეული დროის, მაგრამ მე
ყველაფერს გავაკეთებ, რათა დაეხმაროს თავი აარიდონ ისეთ ბრძოლა თემა, საბოლოო ჯამში,
საკმაოდ ძლიერი.
>> ფაქტობრივად, ერთი თემა განვიხილავთ ამ კვირის განმავლობაში მოვა ის არის, რომ
უსაფრთხოების, და როგორ შეიძლება რეალურად გამოყენებისათვის მანქანები გზები
რომელიც არ იყო განკუთვნილი.
და იმ exploitations არიან, როგორც წესი შედეგად შეცდომები, შეცდომები, რომ ჩვენ
ადამიანი, რომელსაც ვერ გაიგო ზოგიერთმა საქართველოს ძირითადი განხორციელება
დეტალების მეშვეობით, რომელიც პროგრამების განხორციელებას.
>> ახლა, რომ ეს, როგორც ჩანს, მით უფრო შესახებ მეგობრული, მეგონა, მე მინდა ითამაშოს 10
მეორე ესკიზი პატარა claymation ფიგურა დაასახელა Binky ვინც მიიყვანეს
ცხოვრების მეგობარს ჩვენი სტენფორდის, პროფესორი ნიკ Parlante.
ასე რომ, ნება მომეცით გადმოგცეთ ეს teaser of Binky აქ.
>> [ვიდეო აღწარმოების]
>> -Hey, Binky.
გაიღვიძეთ.
დროა მაჩვენებელი სახალისო.
>> -რა არის რომ?
შესწავლა მითითებას?
Oh, goodie.
>> [END ვიდეო აღწარმოების]
>> დავით Malan: ეს არის სტენფორდის კომპიუტერული მეცნიერება.
ასე რომ, უფრო, რომ მოვა.
>> [ტაში]
>> დავით Malan: უკაცრავად, ნიკ.
>> ასე რომ გავიხსენოთ, რომ ბოლო დროს ჩვენ დასრულდა ეს მართლაც საინტერესო cliffhanger
რომლის დროსაც ამ ფუნქციის უბრალოდ არ იმუშავებს.
ყოველ შემთხვევაში ინტუიციურად, ეს იგრძნო როგორც ეს უნდა იმუშაოს.
უბრალოდ შევცვალე ღირებულებები ორი რიცხვებით.
მაგრამ გავიხსენოთ, რომ როდესაც ჩვენ იბეჭდება ორიგინალური ღირებულებების ძირითადი, ერთი და
ორი, ისინი იყვნენ ჯერ კიდევ ერთი და ორი და არა ორი და ერთი.
>> ნება მომეცით, ფაქტობრივად გადართვის მეტი მოწყობილობების.
და დავწერე up ცოტა ჩონჩხის კოდი წინასწარ აქ, სადაც მე აცხადებენ, რომ x
იქნება 1, y იქნება 2.
მე მაშინ ამობეჭდოთ ორივე მათი ღირებულებები ბეჭვდითი ვ.
>> მე პრეტენზია ქვემოთ აქ ჩვენ ვაპირებთ სვოპ მათ.
დავტოვე ცარიელი ადგილზე აქ ჩვენთვის შევსება დღეს რაღაც მომენტში.
ამის შემდეგ, მე ვაპირებ მტკიცება, რომ ორი ცვლადის უკვე swapped.
ამის შემდეგ მე ვაპირებ ბეჭდვა მათ კიდევ ერთხელ.
ასე რომ, იმედია, მე უნდა გამოჩნდეს 1, 2.
2, 1.
აი სუპერ მარტივი მიზანი ახლა.
>> ასე რომ, როგორ უნდა წავიდეთ შესახებ შევცვალე ორი ცვლადის?
თუ მე ვთავაზობ, რომ ეს თასები შეიძლება წარმოადგენს მეხსიერების კომპიუტერი.
ეს არის რამდენიმე ნაკბენები, ამ არის კიდევ რამდენიმე ნაკბენები.
ვერ გვაქვს მოხალისე მოდის მდე და აურიეთ us ზოგიერთი სასმელების, თუ იცნობს?
კარგით up.
რა არის შენი სახელი?
>> Jess: Jess.
>> დავით Malan: Jess?
კარგით up, Jess.
თუ არ გათვალისწინებით, ჩვენ უნდა დააყენოს Google მინის თქვენ ასე რომ ჩვენ შეგვიძლია
immortalize ამ.
OK, მინა.
ჩაწერა ვიდეო.
და კი ბატონო, ჩვენ ვართ კარგი წასვლა Jess აქ.
ყველა უფლება.
კარგია თქვენთან შეხვედრა.
>> ასე რომ, რა მინდა თქვენ აქ - თუ შეიძლება, საკმაოდ სწრაფად -
მხოლოდ pours us ნახევარი ჭიქა ფორთოხლის წვენი და ნახევარი ჭიქა რძე,
წარმოადგენს ეფექტურად ნომრები 1 ერთ თასი და 2 სხვა თასი.
>> ეს იქნება კარგი კადრები.
>> Jess: უკაცრავად.
>> დავით Malan: არა, არა.
ეს OK.
ლამაზი.
ყველა უფლება, ამიტომ ჩვენ ოთხი bytes ღირებულების ფორთოხლის წვენი.
ჩვენ ყველაფერს უწოდა ღირებულება 1.
ახლა კიდევ ოთხი bytes ღირებულების რძე.
იქნება მას ვაფასებთ 2.
ასე რომ x და y, შესაბამისად.
>> ყველა უფლება, ასე რომ, ახლა, თუ დავალება მხრივ - თქვენ, Jess, წინ ყველა
თქვენი თანაკლასელები -
არის სვოპ ღირებულებები x და y ისეთი რომ ჩვენ გვინდა ფორთოხლის წვენი in
სხვა თასი და რძის ამ თასი, თუ როგორ შეიძლება თქვენ - სანამ რეალურად გააკეთებს
ეს - წავიდეთ შესახებ აკეთებენ?
>> კარგი, ჭკვიანი გადაწყვეტილება.
ასე რომ, თქვენ უნდა უფრო მეტი მეხსიერება.
მოდით გამოყოფს დროებითი თასი, თუ გნებავთ.
ახლა კი გაგრძელება სვოპ x და y.
>> შესანიშნავი.
ასე რომ, ძალიან კარგად გაკეთდეს.
ძალიან დიდი მადლობა, Jess.
აქ თქვენ ხართ.
პატარა სუვენირების.
>> OK, ასე თვალნათლივ, სუპერ მარტივი იდეით.
სრულიად გასაგები, რომ ჩვენ გვჭირდება ცოტა უფრო შენახვის სივრცეში - ამ ფორმით,
თასის - თუ ჩვენ რეალურად გვინდა სვოპ ამ ორ ცვლადს.
მოდით გააკეთოს ზუსტად რომ.
აქ შორის, სადაც მე პრეტენზია ვარ უნდა აკეთებს რაღაც შევცვალე, მე
წავიდეთ წინ და აცხადებენ, temp.
და მე მითითებული ეს ტოლია, ვთქვათ, x.
>> ამის შემდეგ მე ვაპირებ შეცვლას ღირებულება x ისევე, როგორც Jess გააკეთა აქ
რძე და ფორთოხლის წვენი როგორც თანაბარი წ.
და მე შეიცვლება შ უტოლდება რათა არ x, რადგან ახლა ჩვენ უნდა
მოხდა წრეში, არამედ დროებითი.
სადაც მე დროებით - ან სადაც Jess დროებით დააყენა ფორთოხლის წვენი
ადრე clobbering რომ თასის ერთად რძე.
>> ნება მომეცით წავიდეთ წინ არის და ეს.
ეს მოუწოდა noswap.c.
ახლა კი ნება მომეცით აწარმოებს გარეშე სვოპ.
მართლაც ვხედავ, თუ გაფართოებას ფანჯარა ცოტა, რომ
x 1, y 2.
და მაშინ x 2, y არის 1.
>> მაგრამ გავიხსენოთ, რომ ორშაბათს გავაკეთეთ რამ ცოტა განსხვავებულად რომლის I
ნაცვლად განხორციელებული დამხმარე ფუნქცია, თუ გნებავთ, რომ რეალურად ბათილად.
მე მას მოკლე.
მივეცი მას ორ პარამეტრების, და მე მოუწოდა მათ მე და მოუწოდა მათ ბ.
>> გულწრფელად ვამბობ, მე ვერ მოვუწოდებთ მათ x და y.
არაფერია შეჩერების ჩემს აკეთებს, რომ.
მაგრამ მე ამტკიცებენ, რომ ეს მაშინ ცოტა ბუნდოვანია.
იმის გამო, რომ გაწვევა for ორშაბათს, რომ ჩვენ ამტკიცებდა, რომ ამ პარამეტრების იყო
ასლები ღირებულებების გავიდა სისტემაში
ასე რომ, ეს უბრალოდ messes თქვენი გონება, მე ვფიქრობ, თუ თქვენ იყენებთ
ზუსტად იგივე ცვლადი.
>> ასე რომ მე ნაცვლად მოვუწოდებთ მათ და ბ, მხოლოდ სიცხადე.
მაგრამ ჩვენ შეგვიძლია მოვუწოდებთ მათ საუკეთესო არაფერი გვინდა.
და მე ვაპირებ დააკოპირეთ და ჩასვით ეფექტურად ამ კოდს იქ
ქვემოთ შევიდა აქ.
იმის გამო, რომ მე დავინახე, რომ ის მუშაობს.
ასე რომ, ამ საკმაოდ კარგი ფორმის.
და მე შეცვლა x to, ჩემი x to, ჩემი y to ბ და ჩემი Y to ბ.
>> ასე რომ, სხვა სიტყვებით, ზუსტად იგივე ლოგიკა.
ზუსტად იგივე, რაც Jess გააკეთა.
და მაშინ ერთი რამ უნდა გავაკეთოთ up აქ, რა თქმა უნდა, არის დაეყრდნოს ამ
ფუნქცია, ან დარეკეთ ამ ფუნქციას.
ასე რომ, მე მოვუწოდებ ამ ფუნქციის ორ საშუალებებით, x და y და ჰიტ შენახვა.
>> ყველა უფლება, პრინციპულად იგივე.
რეალურად, მე ალბათ გააკეთა პროგრამა ზედმეტად კომპლექსი მიერ
წერის ფუნქცია, უბრალოდ აღების ზოგიერთი ექვსი ხაზი კოდი, ხოლო I
ადრე განხორციელდა ეს მხოლოდ სამი.
>> ნება მომეცით წავიდეთ წინ არის და რიმეიკი ეს, არავითარი გაცვლა.
ყველა უფლება, I ბრალია აქ.
ეს უნდა იყოს შეცდომა, რომ თქვენ შეიძლება ვხედავთ სულ უფრო და უფრო ხშირად, როგორც თქვენი
პროგრამების კიდევ უფრო რთული.
მაგრამ ადვილი გადავწყვიტოთ.
ნება მომეცით გადახვევა უკან აქ.
>> და რაც პირველი შეცდომა მე ხედავს?
იმპლიციტური დეკლარაცია.
რას, როგორც წესი, მიუთითებს იმაზე?
ოჰ, დამავიწყდა პროტოტიპი.
დამავიწყდა ასწავლოს შემდგენელი რომ swap აპირებს არსებობს მიუხედავად იმისა რომ იგი
არ არსებობს თავიდანვე პროგრამის.
ასე რომ, მე მხოლოდ თქმას ბათილად, გაცვლა, int, int b, მძიმით.
>> ასე რომ, მე არ ვაპირებ reimplement იგი.
მაგრამ ახლა სიას რა ქვემოთ აქ.
და შეამჩნია, არარსებობის მძიმით აქ, რაც არ არის აუცილებელი, როდესაც
ახორციელებს.
>> ნება მომეცით რიმეიკი ამ, არანაირი გაცვლა.
ბევრად უკეთესი ფორმის.
გაშვება არ swap.
და რა იგი.
ახლა ჩვენ უკან სად ვიყავით ორშაბათს, სადაც რამ არ სვოპ.
>> და რაც ინტუიციური ახსნა თუ რატომ ეს იმ შემთხვევაში?
ჰო?
>> სტუდენტი: [inaudible].
>> დავით Malan: ზუსტად.
ასე და ბ არის ასლები x და y.
და სინამდვილეში, ნებისმიერ დროს თქვენ უკვე მოუწოდებენ ფუნქცია დღემდე რომ
გადის ცვლადები, როგორიცაა ints -
ისევე როგორც swap ელოდება აქ -
თქვენ ბიჭები უკვე გადადის ასლი.
>> ახლა ეს ნიშნავს, რომ სჭირდება ცოტა დრო, გაყოფილი მეორე, იმ
კომპიუტერული კოპირება bits ერთი ცვლადი შევიდა ბიტი ერთმანეთს.
მაგრამ ეს არ არის ისეთი დიდი გარიგება.
მაგრამ ისინი მაინც ასლი.
>> ასე რომ, ახლა, კონტექსტში გაცვლა, მე ვარ ფაქტიურად წარმატებით
იცვლება და ბ.
ფაქტია, მოდით სწრაფად საღი აზრის შესამოწმებლად.
ბეჭდვის ვ არის% i, ახალი ხაზი.
და მოდით plug in.
ახლა იგივეს რამ ბ.
და მოდით გავაკეთოთ იგივე აქ.
>> ახლა კი, ნება მომეცით კოპირება იმავე ხაზები ერთხელ ბოლოში ფუნქცია
შემდეგ სამი ხაზი საინტერესო შეეძლო შესრულებული და
ბეჭდვა და ბ კიდევ ერთხელ.
ასე რომ, ახლა მოდით ეს, არავითარი გაცვლა.
ნება მომეცით მიიღოს ტერმინალში ფანჯარა ცოტა taller, ისე, რომ ჩვენ ვხედავთ
მეტი ერთბაშად.
>> და აწარმოებს გარეშე სვოპ.
x 1, y 2. 1, ბ, 2.
და მაშინ, 2, B არის 1.
ასე რომ, ეს მუშაობს, ისევე, როგორც Jess გააკეთა აქ შიგნით swap.
მაგრამ, რა თქმა უნდა, ეს არ გააჩნია ეფექტი on ცვლადები მთავარ.
>> ასე რომ, ჩვენ ვნახეთ შეასრულა, რომლის დროსაც ჩვენ შეიძლება დაფიქსირება ამ, არა?
როდესაც თქვენ წინაშე აღმოჩნდა ამ სკოუპინგის საკითხთან დაკავშირებით, შეიძლება მხოლოდ punt და მიიღოს x
და Y, თუ რა სახის ცვლადები ნაცვლად?
>> თქვენ შესაძლოა მათ გლობალური.
იქნება მათთვის ძალიან დასაწყისში ფაილი როგორც ჩვენ გავაკეთეთ, თუნდაც თამაში 15.
ჩვენ ვიყენებთ გლობალური განსხვავებულია.
მაგრამ კონტექსტში თამაში 15 მიზანშეწონილი აქვს გლობალური
ცვლადი წარმოადგენს გამგეობის, რადგან მთლიანად of 15.c არის ყველა
დაახლოებით ახორციელებს, რომ თამაში.
სწორედ ფაილი არსებობს უნდა გააკეთოს.
>> მაგრამ ამ შემთხვევაში აქ ვარ მოუწოდებენ ფუნქცია გაცვლა.
მინდა მოკლე ორ ცვლადს.
და დაიწყება თავს უბრალოდ დაუდევარი თუ გამოსავალი ყველა ჩვენი
პრობლემები, როდესაც ჩვენ გადაეყარონ ფარგლებს საკითხი არის, რომ მას გლობალური.
იმის გამო, რომ ძალიან სწრაფად ჩვენი პროგრამა აპირებს გახდეს საკმაოდ სასადილო.
და ჩვენ გავაკეთეთ, რომ ძალიან sparingly შედეგად ამ 15.c.
>> მაგრამ აღმოჩნდება, რომ არსებობს უკეთესი გზა საერთოდ.
ნება მომეცით რეალურად დაბრუნდეს და წაშლა ბეჭდვა ვ ის, უბრალოდ უნდა გამარტივდეს ეს კოდი.
და ნება მომეცით ინიციატივით კი, ეს, რა თქმა უნდა, არის ცუდი.
მაგრამ, თუ ნაცვლად დაამატოთ ზოგიერთ asterisks და ვარსკვლავები, მე შემიძლია ნაცვლად, ვინც ეს
ფუნქციის ერთ, რომ რეალურად ფუნქციონირებს.
>> ნება მომეცით, დაბრუნდეს აქ და აღიარებს, ამბობდა asterisks ყოველთვის ძნელია,
ასე რომ მე ვთქვა ვარსკვლავი.
მე მხოლოდ Fess მდე გამო.
ყველა უფლება.
ახლა კი, რა ვარ მე აპირებს ამის გაკეთება ნაცვლად?
>> ასე რომ, პირველ რიგში, მე ვაპირებ დააკონკრეტა რომ ნაცვლად გავლის int შევიდა
swap ფუნქციის, მე ვარ ნაცვლად საქართველოს თქმას int ვარსკვლავი.
ახლა, რა ვარსკვლავი მიუთითოს?
ეს არის ის, რომ ცნება მაჩვენებელი, Binky, claymation ხასიათი, იყო
გულისხმობდა მომენტში წინ.
>> ასე რომ, თუ ვიტყვით, int ვარსკვლავი, მნიშვნელობა ეს ახლა ის არის, რომ არ აპირებს იყოს
მიღებული თავისი მნიშვნელობა.
ეს არ იქნება გადაწერილი სისტემაში
უფრო მეტიც, მისამართი არის უნდა გავიდა სისტემაში
>> ასე რომ გავიხსენოთ, რომ შიგნით თქვენი კომპიუტერი ეს არის მთელი bunch of მეხსიერება, წინააღმდეგ შემთხვევაში
ცნობილია როგორც ოპერატიული.
და რომ RAM მხოლოდ მთელი bunch of bytes.
ასე რომ, თუ თქვენი Mac ან თქვენს კომპიუტერს ორი გიგაბაიტი, თქვენ გაქვთ 2
მილიარდი bytes მეხსიერება.
>> ახლა მხოლოდ ვარაუდობენ, რომ უბრალოდ უნდა შენარჩუნება რამ ლამაზი და მოწესრიგებული, ჩვენ
დაავალოს მისამართი -
ნომერი -
ყველა byte ოპერატიული თქვენს კომპიუტერში.
პირველივე byte იმ 2 მილიარდი არის რაოდენობის მიხედვით ნულის ტოლია.
მომდევნო ერთი byte ნომერ, ნომერი ორი, ყველა გზა მდე, dot dot
dot, დაახლოებით 2 მილიარდი.
>> ასე რომ თქვენ რაოდენობის bytes მეხსიერების თქვენს კომპიუტერში.
მოდით ვივარაუდოთ, რომ ის, რაც ვგულისხმობთ მისამართი.
ასე რომ, როდესაც მე ვხედავ int ვარსკვლავი, თუ რა ხდება უნდა შევიდა swap ახლა არის
მისამართი.
არა მისი ღირებულება, მაგრამ რაც მის საფოსტო მისამართი, ასე ვთქვათ -
თავისი მდებარეობით ოპერატიული.
>> და ერთნაირად შეეხება ბ, მე ვაპირებ ვთქვა იგივე.
Int, ვარსკვლავი, ბ.
როგორც განზე, ტექნიკურად ვარსკვლავი შეიძლება წავიდეს სხვა ადგილებში.
მაგრამ ჩვენ სტანდარტიზაციისთვის წლის ვარსკვლავი მიმდინარეობს უფლება შემდეგ მონაცემების ტიპის.
>> ასე რომ სვოპ ხელმოწერის ახლა იმას ნიშნავს, მომეცი მისამართი int და მოწოდება
აღნიშნულ მისამართზე.
და მომეცი კიდევ ერთი მისამართი int და მოვუწოდებთ, რომ მისამართი ბ.
>> მაგრამ ახლა ჩემს კოდი აქ უნდა შეცვალოს.
იმიტომ, რომ თუ ვაცხადებ int temp -
რომელიც ჯერ კიდევ ტიპის int -
მაგრამ მე შესანახად მას, რა სახის მნიშვნელობა?
იმისათვის რომ ნათელი, მე აყენებს ერთად კოდი სახით, ახლა?
>> მე აყენებს ადგილმდებარეობა.
მაგრამ მე არ აინტერესებს ადგილმდებარეობა ახლა, არა?
Temp არსებობს მხოლოდ Jess "მესამე თასი არსებობდა, რა მიზნით?
შესანახად ღირებულება.
რძე ან ფორთოხლის წვენი.
არ რეალურად შესანახად მისამართი ან იმ რამ, რაც გრძნობს
ცოტა nonsensical ამ რეალური მსოფლიოს კონტექსტში მაინც.
>> ასე რომ, რეალურად, რა მინდა დააყენა temp არ არის მისამართი, მაგრამ
შინაარსი.
ასე რომ, თუ არის მთელი რიგი მოსწონს 123, ეს 123rd byte მეხსიერების რომ მხოლოდ
ხდება, რომ საოკუპაციო, რომ ღირებულება in ხდება, რომ საოკუპაციო.
>> თუ მე მინდა რომ მისამართი, მე უნდა ვთქვა ვარსკვლავი.
ანალოგიურად, მე რომ შეცვალოს რა შემდეგ მისამართზე, მე შეცვლის
ამ დასაწყებად.
თუკი მინდა მაღაზიის რა დროს ადგილმდებარეობა, თუ რა დროს ადგილმდებარეობა
ერთი ბ, ვარსკვლავი ბ ვარსკვლავი.
>> ასე რომ, მოკლე, მაშინაც კი, თუ ეს არ არის საკმაოდ იძირებოდა in ჯერ - და მე არ ველოდი
რომ ეს ასე სწრაფად -
გააცნობიეროს, რომ ყველა მე ვაკეთებ არის prefixing ამ ვარსკვლავს ჩემს ცვლადები,
გამონათქვამი არ დაიბრუნოს ღირებულებებს.
არ იცვლება ღირებულებები.
არამედ, წავიდეთ იმ მისამართები და მიიღეთ მნიშვნელობა.
გადასვლა რომ მისამართი და ცვლილება ღირებულება არსებობს.
>> ასე რომ, ახლა ნება მომეცით გადახვევა უკან რა, უბრალოდ დაფიქსირება ამ ხაზის აქ,
შეცვლის პროტოტიპი ემთხვევა.
მაგრამ მე ახლა უნდა გავაკეთოთ ერთი რამ.
ინტუიციურად, თუ მე შეიცვალა ტიპის არგუმენტი, რომ swap ელოდება,
მერე, მეტი რა უნდა იცვლება ჩემი კოდი?
>> როდესაც მე მოვუწოდებ გაცვლა.
იმის გამო, რომ სწორედ ახლა, რა ვარ მე გავლით სვოპ მაინც?
ღირებულება x და ღირებულება Y ან რძე და ფორთოხლის წვენი.
მაგრამ მე არ მინდა, რომ.
I ნაცვლად მინდა გავლა, თუ რა?
მდებარეობა x და მდებარეობა წ.
რა არის მათი საფოსტო მისამართები, ასე ვთქვათ.
>> ასე გავაკეთოთ, რომ არსებობს ampersand.
Ampersand სახის ჟღერს მისამართი.
ასე n, ampersand, მისამართი საქართველოს x, და მისამართი წ.
ასე რომ, ეს განზრახ, რომ ჩვენ ვიყენებთ ampersands დარეკვის ფუნქცია,
და ვარსკვლავები, როცა გამოცხადების და როდესაც ახორციელებს ფუნქცია.
>> და მხოლოდ ვფიქრობ ampersand როგორც მისამართი ოპერატორი, და ვარსკვლავი, როგორც
წავალთ ოპერატორი -
ან, უფრო სწორად, dereference ოპერატორი.
ასე რომ, მთელი ბევრი სიტყვები უბრალოდ უნდა ამბობენ, რომ ახლა, იმედია, გაცვლა აპირებს
უფრო სწორად.
>> ნება მომეცით წავიდეთ წინ და მიიღოს -
მოდით რეალურად გადარქმევა ფაილი, ნუუკუე ეს პროგრამა ჯერ კიდევ ეწოდოს არ swap.
I აცხადებენ, რომ ჩვენ მოვუწოდებთ მას swap.c არის.
ასე რომ, მოკლე.
Dot, ხაზი, მოკლე.
>> ახლა კი მართლაც, x, 1 Y არის 2.
და მაშინ, x 2, y არის ერთი.
ისე ვნახოთ, შევძლებთ თუ არა ამის გაკეთება ცოტა განსხვავებულად, თუ რა არის
ხდება აქ.
პირველ რიგში, ნება მომეცით დიდი ზომით ჩვენი ხაზვა აქ.
და ნება მომეცით შესთავაზოს ერთი წუთით - და მაშინ, როდესაც მე მიაპყროს აქ იქნება სარკისებული
იქ ახლა - ნება მომეცით ინიციატივით კი, აქ მთელი bunch of მეხსიერება, ან
RAM, შიგნით ჩემი კომპიუტერი.
>> და ეს იქნება bite ნომერი, ვთქვათ, 1.
ეს იქნება bytes ნომერი 2.
და მე გავაკეთებ მთელი bunch მეტი, და შემდეგ bunch of dot dot წერტილი უნდა
მიუთითებს იმაზე, რომ იქ 2 მილიარდ ამ საკითხზე.
4, 5, და ა.შ..
>> ასე რომ პირველი ხუთი bytes , ჩემი კომპიუტერის მეხსიერებაში.
ყველა უფლება?
ძალიან ცოტა გარეთ 2 მილიარდი.
მაგრამ ახლა მე ვაპირებ შესთავაზოს შემდეგ.
მე ვაპირებ ინიციატივით კი, x აპირებს შესანახად ნომერი 1 და y აპირებს
შესანახად ნომერი 2.
და ნება მომეცით წავიდეთ წინ არის და წარმოადგენს ეს ფასეულობები ასეთია.
>> მოდით ეს შემდეგნაირად.
მომეცი მხოლოდ ერთი მეორე.
ერთი მეორე.
OK.
მინდა, რომ ეს პატარა -
მოდით ეს კიდევ ერთხელ გავაკეთოთ.
წინააღმდეგ შემთხვევაში მე ვაპირებ და გამოყენების იგივე ნომრები, უნებლიეთ,
რამდენჯერმე.
>> ასე რომ, მხოლოდ ასე გვაქვს სხვადასხვა ნომრები ვისაუბროთ, მოდით მოვუწოდებთ ამ byte
ნომერი 123, 124, 125, 126, და dot dot dot.
და ნება მომეცით აცხადებენ, რომ მე ვაპირებ დააყენა ღირებულება 1 აქ და ღირებულება 2
აქ, წინააღმდეგ შემთხვევაში, ცნობილია, როგორც x და y.
ასე რომ, ეს მხოლოდ ასე ხდება, რომ ეს არის x, ეს წ.
>> და მხოლოდ რამდენიმე შემთხვევითი შანსი, კომპიუტერი, ოპერაციული სისტემა,
მოხდა დააყენოს x at მდებარეობა ნომერი 123.
და Y დასრულდა at ადგილმდებარეობა 124 -
რა იგი.
მე უნდა დაფიქსირდეს ეს.
Oh ადამიანი, შემიძლია ნამდვილად გსურთ ამის გაკეთება?
დიახ, მე მინდა დაფიქსირება ამ და ბ სათანადო შესახებ დღეს.
უკაცრავად, ახალი, ამ.
>> 127, 131, და მე არ მინდა, რომ ამ რთული, მაგრამ რატომ შევცვალო
ნომერი?
იმის გამო, რომ მინდა ints to სინამდვილეში ოთხი bytes.
მოდით ეს სუპერ anal შესახებ.
ასე რომ, თუ 1 მოხდება უნდა მიმართა 123, 2 აპირებს იყოს მისამართი
127 იმიტომ რომ მხოლოდ 4 byes მოშორებით.
ეს იყო.
და ჩვენ დაივიწყოს ყველა სხვა მისამართები მსოფლიოში.
>> ასე რომ x არის ადგილმდებარეობა 123, შ არის ადგილმდებარეობა 127.
ახლა კი, რა რეალურად გსურთ?
როდესაც მე მოვუწოდებ swap ახლა, რა რეალურად ხდება?
როცა მოვუწოდებ swap, მე გადადის მისამართი x და მისამართი წ.
ასე მაგალითად, თუ ეს ორი ცალი ქაღალდის ახლა წარმოადგენს ორი
არგუმენტები და ბ სვოპ, რა ვარ მე აპირებს დააწერონ პირველი ეს,
რომელიც მე ვაპირებ მოვუწოდო ეხება, როგორც?
>> სწორედ 123.
ასე რომ, ეს მე პრეტენზია.
ეს არის პარამეტრი.
მე აყენებს მისამართი x იქ.
>> რა არის ეს?
>> არა, არა.
ეს არის ის, OK.
მაინც კარგია, მაინც კარგია.
ასე რომ, ეს.
ახლა კი მეორე ცალი ქაღალდის, ეს იქნება ბ და რა ვარ მე
უნდა წერილობით ამ ცალი ქაღალდის?
127.
>> ასე რომ, ერთადერთი, რაც შეიცვალა ჩვენი წინა თხრობა ამ ამბავი,
ვიდრე ფაქტიურად 1 და 2, მე ვარ აპირებს გადის 123 და 127.
და მე ახლა, რომ ეს შიგნით ამ ყუთში, ყველა უფლება?
ასე რომ შავი ყუთი ახლა წარმოადგენს გაცვლა ფუნქცია.
>> იმავდროულად, მოდით ახლა ვინმე განახორციელოს swap ფუნქცია.
სად აქ მინდა მოხალისე?
კარგით up.
რა არის შენი სახელი?
ჩარლი.
ყველა უფლება, ჩარლი.
კარგით up.
>> ასე რომ, ჩარლი აპირებს ითამაშოს როლი ჩვენი შავი ყუთი.
ჩარლი, რა მინდა თქვენ ამის გაკეთება ახლა განხორციელება swap ისე
რომ, ამ ორი მისამართები, თქვენ რეალურად აპირებს
შეცვალოს ღირებულებებს.
და მე ჩუმად თქვენს ყურში როგორ უნდა აწარმოებს სატელევიზიო აქ.
>> ასე რომ წავიდეთ წინ, და თქვენ შავ ყუთში.
მიღწევა იქ.
რა ღირებულებების ხედავთ, და რა ღირებულებების ხედავთ ბ?
>> CHARLIE: არის 123 და ბ არის 127.
>> დავით Malan: კარგი, ზუსტად.
ახლა პაუზის იქ მხოლოდ ერთი წუთით.
პირველი, რაც თქვენ უნდა გავაკეთოთ ახლა, კოდექსის მიხედვით - რომელიც
მე ახლა დახევის up ეკრანზე -
იქნება გამოყოს პატარა ცოტა მეხსიერება მოუწოდა temp.
ამიტომ, მე ვაპირებ წავიდეთ წინ და გაძლევთ, რომ მეხსიერებაში.
>> ასე რომ, ეს იქნება მესამე ცვლადის რომ თქვენ გაქვთ ხელმისაწვდომი
თქვენ მოუწოდა temp.
და რას აპირებთ დაწერა on დროებითი ცალი ქაღალდის?
>> CHARLIE: პოინტერები, არა?
>> დავით Malan: კარგი, კარგად არ აუცილებლად მითითებას.
ასე რომ ხაზი კოდი, რომ მე ხაზი გაუსვა, როდესაც მარჯვენა მხარეს,
დავიწყოთ არსებობს.
განცხადებაში ნათქვამია, ვარსკვლავი.
ასე რომ, ამჟამად შენახვის ნომერი 123.
და მხოლოდ ინტუიციურად, თუ რა საერთოდ ვარსკვლავი 123 ნიშნავს?
>> მაგრამ კონკრეტულად, თუ არის 123, ვარსკვლავი იმას ნიშნავს, რა?
ღირებულება.
ან მეტი casually, წასასვლელად.
ნება მომეცით ინიციატივით კი,, ჩატარების შემდეგ თქვენი მხრივ, წავიდეთ წინ და მკურნალობა, რომ
თითქოს ეს რუკა.
და ფეხით თავს მეტი კომპიუტერის მეხსიერება და ჩვენი რა არის
ზე ადგილმდებარეობა 123.
ზუსტად.
>> ასე რომ, ჩვენ ვხედავთ დროს ადგილმდებარეობა 123 არის ის, რაც, ბუნებრივია?
OK, ასე რომ მნიშვნელობა ახლა ხარ აპირებს ამოქმედებული temp?
ზუსტად.
ასე რომ წავიდეთ წინ და გაგვაჩნია.
და წერა ნომერი 1 ცალი ქაღალდი, რომელიც გაკეთებული სახელწოდებით temp.
>> ახლა კი მორიგი ნაბიჯი, რომელიც თქვენ აპირებს განახორციელოს
იქნება რა.
ისე, მარჯვენა მხარეს მომდევნო ხაზი კოდი არის ვარსკვლავი ბ. ბ of
რა თქმა უნდა, ინახავს მისამართი.
ეს ეხება 127.
Star ბ ნიშნავს თუ რა, casually საუბარი?
>> გადასვლა იყო.
ასე რომ წავიდეთ წინ და ჩვენი რა ზე ადგილმდებარეობა 127.
OK.
რა თქმა უნდა, საიდან 127, ჯერ კიდევ ღირებულება 2.
ასე რომ, რას აპირებს ახლა შეინახეთ რაც არ არის იმ მდებარეობა?
ასე რომ ვარსკვლავი საშუალებით წასვლა ადგილმდებარეობა.
რა არის საიდან?
>> ზუსტად.
ასე რომ, ახლა, თუ გსურთ, რომ შეიცვალოს რა იმ ადგილას -
მე წავიდეთ წინ და აწარმოებს eraser არის აქ.
ახლა კი დააყენა მას უკან brush.
რა რაოდენობის აპირებთ დაწერა ამ ცარიელი ყუთი ახლა?
>> ზუსტად.
ასე რომ, ეს ხაზი კოდი, უნდა იყოს ნათელი - ნება მე პაუზის რა ჩარლი აკეთებს და
აღვნიშნო აქ, რა, რომ ის უბრალოდ გაკეთდეს არის წერენ შევიდა, რომ ყუთში ადგილმდებარეობა 123
ღირებულება, რომელიც ადრე ერთი ბ.
ასე რომ, ჩვენ ახლა განხორციელებული მართლაც ეს მეორე ხაზი კოდი.
>> ახლა, სამწუხაროდ, არ არსებობს ჯერ კიდევ ერთი ხაზი დარჩენილი.
ახლა რა არის დროებითი, ფაქტიურად?
ეს აშკარად ნომერ პირველი.
ეს არ არის მისამართი.
უბრალოდ ნომერი, ერთგვარი ცვლადი ეხლა კვირაში ერთი.
>> ახლა კი როცა ამბობენ, რომ ვარსკვლავი ბ, რაც იმას ნიშნავს, წასვლა მისამართი ბ, რომელიც
რა თქმა უნდა აქ.
ასე რომ, როგორც კი იქ -
მე წავიდეთ წინ და წაშლას რა ფაქტიურად იქ - და რა ხარ
აპირებს დაწეროს ახლა ადგილმდებარეობა 127?
>> CHARLIE: Temp, რომელიც ერთი.
>> დავით Malan: Temp, რომელიც ერთი.
და რა მოხდება, დროებითი საბოლოოდ?
ასევე, ჩვენ არ ვიცი.
ჩვენ ნამდვილად არ აღელვებს.
ნებისმიერ დროს ჩვენ განხორციელებული ფუნქცია ჯერჯერობით, არც ერთი ადგილობრივი ცვლადები თქვენ გაქვთ
მართლაც ადგილობრივი.
და მათ მხოლოდ გაქრება.
ისინი Reclaimed ოპერაციული სისტემაში საბოლოოდ.
>> ასე რომ, ის ფაქტი, რომ დროებითი კიდევ აქვს ღირებულება 1 სახის ფუნდამენტურად
უინტერესო ჩვენთვის.
ყველა უფლება, ასე რაუნდი ტაში თუ შეგვეძლო for ჩარლი.
ძალიან კარგად გაკეთდეს.
>> ყველა უფლება, ასე რომ უფრო აკეთებს ნიშნავს ეს შეგვიძლია გავაკეთოთ?
გამოდის, რომ ჩვენ ვეუბნებოდი რამდენიმე თეთრი ტყუილების
საკმაოდ გარკვეული დრო.
მართლაც, აღმოჩნდება, რომ ტექსტი, ყველა ამ დროს, არ არის ნამდვილად
თანმიმდევრობა ციფრები, თავისთავად.
ეს ერთგვარი ის არის, რომ ინტუიციურად.
>> თუმცა ტექნიკურად რომ ვთქვათ, სიმებიანი არის მონაცემთა ტიპის, რომ ჩვენ განვაცხადეთ, შიგნით
CS50 ბიბლიოთეკა გამარტივება მსოფლიოში პირველად რამდენიმე კვირის კლასის.
რა სიმებიანი მართლაც არის მისამართი საქართველოს ხასიათი სადღაც ოპერატიული.
სიმებიანი მართლაც რაოდენობის, ისევე როგორც 123 ან 127, რომელიც ხდება demarcate
სადაც სიმებიანი იწყება თქვენი კომპიუტერის მეხსიერებაში.
>> მაგრამ ეს არ წარმოადგენს ტექსტი, თავისთავად, თავად.
და ვხედავთ ამ ასეთია.
ნება მომეცით წავიდეთ წინ და ქმნის რამდენიმე კოდი, რომელიც არის შორის
დღევანდელ წყაროს კოდი მაგალითები.
და მე ვაპირებ წავიდეთ წინ და გახსნა up, ასე ვთქვათ, შედარება-0.c.
ეს არის buggy პროგრამა, რომელიც აპირებს განსახორციელებელი ასეთია.
>> პირველი.
მე ვაპირებ ვთქვა რაღაც.
ამის შემდეგ მე ვაპირებ წავიდეთ წინ და მიიღეთ ნახატზე შესახებ
ამ მეორე ხაზზე.
ამის შემდეგ მე ვაპირებ ვთქვა, კიდევ ერთხელ.
ამის შემდეგ მე ვაპირებ მიიღეთ საჩუქრად ნახატზე შესახებ.
>> და შეამჩნია, მე აჩვენებს ერთ სიმებისათვის ცვლადში s, და
კიდევ ერთი ამ strings ამ ცვლადში ტ.
ახლა კი მე ვაპირებ აცხადებენ, ძალიან გონივრულად, რომ თუ ტოლია ტოლია t,
strings იგივეა.
ამას იგივე.
სხვაგან, strings არის არ იგივე.
>> ყოველივე ამის შემდეგ, თუ ჩვენ შეტანის ორი ints, ორი სიმბოლო, ორი მოძრავი, ორი ორადგილიანი, რომელიმე
მონაცემთა ტიპები ჩვენ ვისაუბრეთ ჯერჯერობით შედარების მათ -
გავიხსენოთ, რომ ჩვენ ნათლად ხნის წინ რომ თქვენ არ გააკეთებს, რადგან
ერთ თანაბარი ნიშანი, რა თქმა უნდა დავალება ოპერატორი.
ასე, რომ ეს იქნება შეცდომა.
>> ჩვენ ვიყენებთ თანაბარი თანაბარი ნიშანი, რომელიც მართლაც ადარებს
რამ ჭეშმარიტი თანასწორობა.
მაგრამ მე აცხადებენ, რომ ეს არის buggy.
თუ მე წავიდეთ წინ და მიიღოს შედარების ნულის და მერე dot ხაზი შედარების ნულოვანი.
და მე აკრიფოთ, ასე ვთქვათ, hello.
და მაშინ მოდით მიესალმები ერთხელ.
ფაქტიურად იგივე, კომპიუტერი მოთხოვნებს, მე აკრეფილი სხვადასხვა რამ არის.
>> ახლა, შესაძლოა, უბრალოდ არასწორად აკრეფილი რაღაც.
მე აკრიფოთ ჩემი სახელი ამ დროს.
ვგულისხმობ, hello.
Hello.
ეს განსხვავებული თითოეული დრო.
>> ისე, თუ რატომ არის, რომ?
რა სინამდვილეში ქვეშ hood?
ისე, რა სინამდვილეში ქვეშ hood არის სიმებიანი შემდეგ
მე აკრეფილი, რომ პირველად მაგალითად არის სიტყვა hello, რა თქმა უნდა.
მაგრამ თუ ჩვენ წარმოვადგენთ ამ ქვეშ Hood, გავიხსენოთ, რომ
სიმებიანი არის მასივი.
და ჩვენ განაცხადა იმდენი წარსულში.
>> ასე რომ, თუ მე მიაპყროს, რომ მასივი ასე, მე ვარ აპირებს წარმოადგენს რაღაც
მსგავსია იმისა, რაც ჩვენ გავაკეთეთ მომენტში წინ.
და იქ, ფაქტობრივად, რაღაც სპეციალური აქაც.
რა მივიღეთ განსაზღვროს იყო ყოველი სიმებიანი?
ჰო, ეს წარმატებული ნულოვანი, რომელიც უბრალოდ გზა წარმოადგენს,
ფაქტიურად, 00000000.
რვა 0 ბიტი ზედიზედ.
>> მე არ ვიცი, გულწრფელად ვამბობ, რა არის ამის შემდეგ.
ეს მხოლოდ bunch მეტი RAM შიგნით ჩემი კომპიუტერი.
მაგრამ ეს მასივი.
ჩვენ ვისაუბრეთ მასივების ადრე.
და ჩვენ, როგორც წესი, საუბრობენ მასივების როგორც საიდან ნულის
მაშინ ერთი, შემდეგ ორი.
მაგრამ ეს მხოლოდ მოხერხებულობისთვის.
და ეს სრულიად ნათესავი.
>> როდესაც თქვენ რეალურად მიღების მეხსიერების დან კომპიუტერი, ეს, რა თქმა უნდა, ნებისმიერი
2 მილიარდ რაღაც უცნაური ბაიტი, პოტენციურად.
ასე რომ, ნამდვილად ქვეშ Hood, მთელი ამ ხნის, დიახ.
ეს შეიძლება ძალიან კარგად იქნება bracket ნულოვანი.
მაგრამ თუ გათხრა კიდევ უფრო ღრმა ქვეშ Hood, რომ მართლაც
სიტყვით ნომერი 123.
ეს არის მისამართი 124.
ეს არის მისამართი 125.
>> და მე არ ხრახნიანი up ამ დროს.
ეს არის ახლა ერთი ბაიტი გარდა რატომ?
რამდენად დიდია char?
Char მხოლოდ ერთი ბაიტი.
Int, როგორც წესი, ოთხ ბაიტს.
ასე რომ, თუ რატომ გააკეთა ეს 123, 127, 131 და სხვ.
ახლა კი შეგიძლიათ მათემატიკის მარტივი და მხოლოდ ამის პლუს 1.
და ეს არის ის, რაც სინამდვილეში აპირებს on ქვეშ hood.
>> ასე რომ, როდესაც თქვენ გამოაცხადოს მსგავსი რამ, სიმებიანი s, ეს არის რეალურად -
აღმოჩნდება, -
char ვარსკვლავი.
ვარსკვლავი, რა თქმა უნდა, იმას ნიშნავს, მისამართი, aka მაჩვენებელი.
ასე რომ, ეს მისამართი რაღაც.
რა არის მისამართი?
>> ასევე -
მე ვარ ერთადერთი, ვინც ხედავთ ძალიან მთავარია მე მიღების, ან ვფიქრობ
მე მიღების.
ასე რომ, სიმებიანი -
სამწუხარო ის არის, მე მაქვს მონიტორის სწორედ იქ, სადაც მე
შეეძლო ჩანს, რომ.
>> ყველა უფლება, სიმებიანი s არის ის, რაც მე განაცხადა ადრე.
მაგრამ აღმოჩნდება, წყალობით პატარა ჯადოსნური in CS50 ბიბლიოთეკაში, ეს ყველაფერი
დრო სიმებიანი აქვს ფაქტიურად ყოფილა char ვარსკვლავი.
ვარსკვლავი კვლავ ნიშნავს მაჩვენებელი ან მისამართი.
ფაქტია, რომ ის flanking სიტყვა char ნიშნავს ეს
მისამართი ხასიათი.
>> ასე რომ, თუ მიიღოს სიმებიანი ეწოდება, და მე აკრიფოთ in H-E-L-L-O, შესთავაზოს ახლა რა აქვს მიიღოს
სიმებიანი ფაქტიურად უკვე დაბრუნების ყველა ამ დროს, მიუხედავად იმისა, რომ ჩვენ საკმაოდ
oversimplified მსოფლიოში?
რას მიიღოს სიმებიანი რეალურად დაბრუნდება, როგორც მისი დაბრუნების მნიშვნელობა?
>> 123 ამ შემთხვევაში, მაგალითად.
ჩვენ ადრე განაცხადა, რომ მიიღოს სიმებიანი უბრალოდ ბრუნდება სიმებიანი, რიგითობა
სიმბოლო.
მაგრამ ეს ცოტა თეთრი ტყუილი.
გზა მიიღოს სიმებიანი ნამდვილად მუშაობს ქვეშ hood არის ის იღებს
ნახატზე შესახებ.
ეს Plops ნიშნებს, იგი ტიპის მეხსიერებაში.
იგი აყენებს წარმატებული ნულოვანი დასასრულს იმ რიგითობა სიმბოლოს.
>> მაგრამ რას მიიღოს სიმებიანი ფაქტიურად დაბრუნებას?
ეს სიტყვა დააბრუნებს მისამართი პირველივე bytes in RAM, რომ
ის, რომ ძალა.
და აღმოჩნდება, რომ მხოლოდ დაბრუნების ერთ მისამართი
პირველი პერსონაჟი სიმებიანი, რომ არის საკმარისი მოძიების მთლიანად of
სიმებიანი.
>> სხვა სიტყვებით, მიიღოს სიმებიანი არ გააჩნია დაბრუნებას 123 და 124 და 125.
იგი არ უნდა მომეცი ხანგრძლივი სიაში ყველა bytes რომ
ჩემი სიმებიანი იყენებს.
იმის გამო, რომ ერთი, ისინი ყველა დაბრუნდა უკან.
და ორი, დაფუძნებული პირველი მისამართი, I შეგიძლიათ გაერკვნენ, სადაც სიმებიანი მთავრდება.
როგორ?
>> სპეციალური null ხასიათი, წარმატებული ნულოვანი ბოლოს.
ასე რომ, სხვა სიტყვებით, თუ თქვენ გაივლის გარშემო -
შიგნით ცვლადის -
მისამართი char და ვივარაუდოთ, რომ ბოლოს ნებისმიერი ტექსტი, ნებისმიერი
თანმიმდევრობა ციფრები, რომლებიც, როგორც ჩვენ ადამიანები ვფიქრობ, სტრინგი, თუ ვივარაუდოთ, რომ
დასასრულს ასეთი სიმებიანი არსებობს წარმატებული ნულოვანი, თქვენ ოქროს.
იმის გამო, რომ თქვენ ყოველთვის იპოვის ბოლოს სიმებიანი.
>> ახლა რა სინამდვილეში შემდეგ აპირებს მე ამ პროგრამაში?
რატომ არის ეს პროგრამა, შედარების-0.c, buggy?
რა ხდება რეალურად მიმდინარეობს შედარებით?
ჰო?
>> სტუდენტი: [inaudible].
>> დავით Malan: ზუსტად.
ეს შედარებით ადგილას საქართველოს strings.
ასე რომ, თუ მომხმარებელს ჯერ აკრეფილი მიესალმები ერთხელ როგორც მე, მეხსიერება შეიძლება დასრულდეს up
ეძებს მოსწონს ეს.
თუ შესახებ შემდეგ ტიპების კომენტარი პირველმა კიდევ ერთხელ, მაგრამ დარეკვით მიიღოს სიმებიანი ერთხელ, გ არის
განსაკუთრებით ჭკვიანი თუ არ ასწავლიან რომ ეს ჭკვიანი წერილობით კოდი.
>> C -
და კომპიუტერები ზოგადად -
თუ აკრიფოთ სიტყვა მიესალმები ერთხელ, თქვენ იცით, თუ რას აპირებს.
თქვენ მხოლოდ აპირებს მეორე მასივში მეხსიერების, რომ, დიახ, ხდება იყოს
შენახვის H-E-L-L-O და სხვ.
>> იგი აპირებს გამოიყურებოდეს იგივე ჩვენს ადამიანებში, მაგრამ ამ მისამართზე
არ უნდა იყოს 123.
ეს შეიძლება მხოლოდ ასე მოხდეს, რომ ოპერაციული სისტემა აქვს ხელმისაწვდომი
ფართი ინსტანციის დროს ადგილმდებარეობა -
ვთქვათ რაღაც თვითნებური, ისევე, როგორც ეს არის ადგილმდებარეობა 200.
და ეს საიდან 201.
და ეს საიდან 202.
ჩვენ არ აქვთ, სად, რომ იქნება მეხსიერებაში.
>> მაგრამ რა ეს იმას ნიშნავს, ის არის, რომ ის, რაც უნდა ინახება საბოლოო ჯამში მდე?
ნომერი 123.
რა იქნება შენახული t, ამ უკანონო მაგალითად?
ნომერი 200.
და ყველა ეს ნიშნავს, რომ მაშინ აშკარად, 123 არ თანაბარ 200.
ასე რომ, თუ მდგომარეობა არასოდეს აფასებს ჭეშმარიტი.
იმის გამო, რომ Get სიმებიანი იყენებს სხვადასხვა მოცულობით მეხსიერება ყოველ ჯერზე.
>> ახლა ჩვენ ვხედავთ ეს კიდევ ერთხელ კიდევ ერთი მაგალითი.
ნება მომეცით წავიდეთ წინ და ქმნის ასლი-0.c.
მე ამტკიცებენ, რომ ეს მაგალითი აპირებს ვცდილობთ - მაგრამ ვერ - ნამუშევრის კოპირება ორი strings
ასეთია.
>> მე ვაპირებ რომ რაღაც მომხმარებელს.
მე მაშინ აპირებდა სიმებიანი და ეძახით s.
ახლა კი, მე ვაკეთებ ამ გამშვებ აქ.
ჩვენ აღნიშნული ამ ხოლო უკან.
მაგრამ როდესაც შესაძლოა სიმებიანი დაბრუნების null, კიდევ ერთი განსაკუთრებული ხასიათი, ან სპეციალური
სიმბოლო ვთქვათ.
თუ ეს მეხსიერება ღალატობს.
>> მაგალითად, თუ მომხმარებელს ნამდვილად როგორც რთული და ტიპის ბარბაროსულ
რიგი პერსონაჟების კლავიატურის და hits Enter.
თუ, რომ ნომერი პერსონაჟების უბრალოდ ვერ შეესაბამება RAM სხვადსხვა გიჟები
მიზეზი, ასევე მიიღოს სიმებიანი შეიძლება ძალიან კარგად დაბრუნების null.
>> ან თუ თქვენი პროგრამა თავად აკეთებს ბევრი სხვა რამ და იქ მხოლოდ
არ არის საკმარისი მეხსიერების Get სიმებიანი წარმატების, ეს შეიძლება დასრულდეს
up დაბრუნების null.
მაგრამ მოდით, უფრო ზუსტად თუ რა ეს.
რა არის s მონაცემებით ტიპის ნამდვილად?
Char ვარსკვლავი.
>> გამოდის, ახლა ჩვენ შეგვიძლია კანი უკან ფენის null.
გამოდის, null არის - კი, რა თქმა უნდა სპეციალური სიმბოლო.
მაგრამ რა არის ეს ნამდვილად?
მართლაც, null მხოლოდ სიმბოლო იმისა, რომ ჩვენ ადამიანები გამოიყენოთ წარმოადგენს ნულოვანი ასევე.
>> ასე რომ, ავტორები C და კომპიუტერები უფრო ზოგადად, გადაწყვიტა წლის წინ
რომ, იცით, რა.
რატომ არ გვაქვს უზრუნველყონ, რომ არც შესახებ მონაცემთა ოდესმე, ოდესმე, ოდესმე
ინახება bye ნულოვანი?
სინამდვილეში კი ჩემი თვითნებური მაგალითად ადრე, მე არ დაიწყოს ნუმერაციის
bytes ზე ნულოვანი.
დავიწყე ერთ.
იმის გამო, რომ ვიცოდი, რომ ხალხი მსოფლიოში გადავწყვიტეთ ვიტოვებთ ნულოვანი
byte არავის RAM, როგორც რაღაც განსაკუთრებული.
>> მიზეზი იმისა, ნებისმიერ დროს გსურთ სიგნალი, რომ რაღაც წავიდა არასწორი
ამასთან დაკავშირებით მისამართები, თქვენ დაბრუნდა null - სხვაგვარად ცნობილია როგორც ნულოვანი -
და რადგან თქვენ იცით, რომ იქ არ არის GE დაბრუნება მონაცემებს მისამართი ნულოვანი, ნათლად
ეს ნიშნავს, რომ შეცდომა.
სწორედ ამ მიზეზით, ჩვენ მიერ კონვენციის, შემოწმება for null და დაბრუნების რაღაც
როგორც ერთი იმ შემთხვევაში.
>> ასე რომ, თუ ჩვენ გადაფურცლეთ ქვემოთ, ახლა, ეს მხოლოდ შემდეგ რამდენიმე შეცდომა შემოწმება, მხოლოდ იმ შემთხვევაში
რაღაც წავიდა არასწორი [? გირაო?]
საერთოდ და გასვლა პროგრამა დაბრუნების გამო.
ეს ხაზი ახლა შეიძლება გადაწერილი რადგან ეს, რაც იმას ნიშნავს, თუ რა?
On მარცხენა მხარეს, მომეცი კიდევ ერთი მომცეთ ხასიათი, და უწოდებენ ტ.
რა ვარ მე შენახვის შიგნით t, საფუძველზე ამ ერთი ხაზი კოდი?
>> მე შენახვის ადგილას.
კერძოდ საიდან რომ იყო s.
ასე რომ, თუ მომხმარებელს ჯერ აკრეფილი hello, და რომ პირველი კომენტარი პირველმა ხდება დასრულდება
აქ, მაშინ ნომერი 123 არის აპირებს დაბრუნებას ეხლა მისაღებად
სიმებიანი და ინახება -
როგორც ვთქვით ადრე -
მდე.
>> როდესაც მე ახლა აცხადებენ, კიდევ ერთი მომცეთ char და მას t, რა რაოდენობის არის
ფაქტიურად აპირებს დასრულდება მდე t მიხედვით ამბავი?
ასე რომ, 123.
>> ასე რომ ტექნიკურად ახლა ორივე და ტ მიუთითებს ზუსტი
იგივე მოცულობით მეხსიერება.
ასე რომ შეამჩნია, რაც მე აპირებს ახლა ადასტურებენ, რომ ეს პროგრამა არის buggy.
>> პირველი მე ვაპირებ აცხადებენ, ერთად ბეჭდვითი ვ, capitalizing
ასლის მისაღებად.
ამის შემდეგ მე ვაპირებ, პატარა შეცდომა შემოწმება.
მე ვაპირებ რომ დავრწმუნდეთ.
მოდით დავრწმუნდეთ, რომ სიმებიანი t არის სულ ცოტა მეტია ნულოვანი სიგრძის,
ასე რომ ზოგიერთი ხასიათი არსებობს რეალურად ესარგებლა.
>> და მაშინ თქვენ ალბათ გახსოვთ ამ წინა მაგალითები.
2 ზედა - რომელიც ctype.h ფაილი.
T bracket ნულოვანი მაძლევს ნულოვანი ხასიათი სიმებიანი ტ.
და 2 ზედა იგივე ღირებულება, რომელიც რა თქმა უნდა, გარდაქმნის მას ზედა.
>> ასე რომ, ინტუიციურად, ამ ხაზი გაუსვა ხაზი საქართველოს კოდექსი capitalizing პირველი
წერილი ტ.
მაგრამ ეს არ არის capitalizing, ინტუიციურად, პირველი ასო s.
მაგრამ თუ თქვენ ფიქრი წინ, რა ვარ მე შესახებ, რომ ნახოთ, როცა აწარმოებს ამ პროგრამის
და ამობეჭდოთ ორივე ორიგინალური, s, და ე.წ. ასლი, უ?
>> ისინი რეალურად იქნება იგივე.
და რატომ არიან იქნება იგივე?
ისინი ორივე მიუთითებს ზუსტად იგივე.
ასე რომ, მოდით ეს.
>> მიიღოს ასლი ნულოვანი.
იგი ადგენს OK.
ნება მომეცით აწარმოებს ასლი ნულოვანი.
ნება მომეცით აკრიფოთ რაღაც მიესალმები in ყველა ამას შემდეგ დააჭიროთ.
და ეს ამტკიცებს, რომ ორივე ორიგინალური s და ასლი მართლაც იდენტურია.
>> ასე რომ, რა მოხდა აქ?
ნება მომეცით მეთოდით გადასინჯვის ამ სურათს მხოლოდ ვუთხრა ამბავი
ოდნავ სხვაგვარად.
რა სინამდვილეში ქვეშ hood როცა ვაცხადებ, რომ მსგავსი რამ
char დაწყების წინ, ან სიმებიანი s, მე მიღების მაჩვენებელი -
რაც ხდება, რომ ოთხი bytes ამ CS50 მოწყობილობების
და ბევრი კომპიუტერები.
და მე ვაპირებ მოვუწოდო ამ s.
ეს გაკეთებული აქვს გაურკვეველი ღირებულება.
>> როდესაც თქვენ გამოაცხადოს ცვლადი, თუ თქვენ არ თავს დააყენა ღირებულება არსებობს, რომელიც
იცის, რა არის იქ.
ეს შეიძლება იყოს გარკვეული შემთხვევითი რიგითობა ბიტი, წინა აღსრულება.
ასე რომ, როდესაც მე, ჩემი ხაზი კოდი გავაკეთოთ მისაღებად სიმებიანი და შემდეგ შესანახად დაბრუნების
ღირებულების s მიიღოს სიმებიანი რატომღაც -
ჩვენ გამოგიგზავნით საბოლოოდ კანი უკან რამდენად მისაღებად სიმებიანი სამუშაოები, რატომღაც გამოყოფს
მასივი, ალბათ გამოიყურება ცოტა მოსწონს ეს.
H-E-L-L-O, წარმატებული ნულოვანი.
>> დავუშვათ, რომ ეს არის მისამართი 123 მხოლოდ პირველი თანმიმდევრულობა.
ასე რომ სიმებიანი ბრუნდება, ამ ხაზი გაუსვა ხაზი არსებობს, ის დააბრუნებს
ნომერი ვთქვით, 123.
ასე რომ, რა მიდის შიგნით s აქ?
>> ისე, რა მიდის შიგნით s არის 123.
თუმცა გულწრფელად ვამბობ, მე მისაღებად პატარა დაბნეული ყველა ამ მისამართები,
ყველა ამ უკანონო ნომრები.
123, 124, 127.
მოდით რეალურად გაამარტივებს მსოფლიოს ცოტა.
>> როდესაც ვსაუბრობთ მითითებას, გულწრფელად ვამბობ, რომ ჩვენს ადამიანი, რომელმაც heck ზრუნავს, სადაც
რამ მეხსიერებაში?
ეს არის ის, სრულიად უკანონო.
იგი აპირებს დამოკიდებული, როგორ გაცილებით RAM მომხმარებელს აქვს.
იგი აპირებს დამოკიდებული, როცა დღეს თქვენ აწარმოებს პროგრამა, ალბათ, და
რა შეტანის შესახებ გაძლევთ.
ჩვენ აპირებს უმნიშვნელო დეტალებზე.
>> მოდით აბსტრაქტული მოშორებით და აცხადებენ, რომ, როდესაც თქვენ აწარმოებს ხაზი კოდი ასე,
char ვარსკვლავი s იღებს დაბრუნების ღირებულება Get სიმებიანი.
რატომ არ გვაქვს ნაცვლად უბრალოდ მიაპყროს, რაც ჩვენ შენარჩუნება მოუწოდებენ მაჩვენებელი, თითქოს ეს
მიუთითებს რაღაც?
ასე, რომ აცხადებენ, რომ s up არსებობს მაჩვენებელი -
ქვეშ hood ეს მისამართი.
მაგრამ ეს მხოლოდ მიუთითებს პირველი ბაიტი in
სიმებიანი, რომ უკვე დაბრუნდა.
>> თუ მე ახლა დაბრუნდნენ კოდი აქ, რა ხდება ამ ხაზის?
ასევე, ამ ხაზი გაუსვა ხაზი ახლა, მე გამოცხადების როგორც ჩანს, კიდევ ერთი
ცვლადში ტ.
მაგრამ ასევე მაჩვენებელი, ამიტომ მე ვაპირებ მიაპყროს მას, როგორც, თეორიულად, ზუსტი
იგივე ზომის ყუთი.
და მე ვაპირებ მოვუწოდო, რომ ეს ტ.
>> ახლა კი, თუ ჩვენ დაბრუნდეს კოდი კიდევ ერთხელ, როდესაც მე შესანახად s შიგნით t,
რა ვარ მე ტექნიკურად აყენებს შიგნით უ?
ისე ტექნიკურად, ეს იყო რიცხვი 123.
ასე რომ, მართლაც მე უნდა წერა ნომერი 123 იყო.
მაგრამ მოდით მას უფრო მაღალ დონეზე.
t, თუ ეს უბრალოდ მაჩვენებელი, ინტუიციურად, მხოლოდ, რომ.
ეს იყო, რომ ერთ ინახება იქ.
>> ასე რომ, ახლა, ბოლო საინტერესო ხაზები კოდის, როცა რეალურად წავიდეთ შესახებ
capitalizing ნულოვანი ხასიათი in t, რა ხდება?
ისე, ტ bracket ნულოვანი არის მიუთითებს თუ რა ხასიათის, სავარაუდოდ?
>> ეს მიუთითებს თ.
იმის გამო, რომ t bracket ნულოვანი -
გავიხსენოთ, რომ ეს არის ძველი სინტაქსი. t bracket ნულოვანი მხოლოდ იმას ნიშნავს, თუ t არის ტექსტი, ტ
bracket ნულოვანი ნიშნავს მიღების ნულოვანი პერსონაჟი, რომ ძალა.
მერე რა, რომ ნამდვილად ნიშნავს არის წასვლა ეს მასივი -
და დიახ, ეს შეიძლება იყოს 123, ეს შეიძლება იყოს 124.
მაგრამ ყველა ნათესავი, მახსოვს.
იმ შემთხვევაში, როდესაც ვსაუბრობთ მასივი, ჩვენ გვაქვს უპირატესობა ვსაუბრობთ
ნათესავი მაჩვენებლები.
>> ასე რომ, ახლა ჩვენ შეგვიძლია მხოლოდ ვივარაუდოთ რომ უ bracket ნულოვანი არის თ.
ასე რომ, თუ მოვუწოდებ 2 ზედა იგი, რა არის ნამდვილი ჩანაფიქრია capitalizing
ამას თ to ზედა H. მაგრამ, რა თქმა, რა არის s?
ეს მიუთითებს იმავე darn სიმებიანი.
>> ასე რომ, ეს ყველაფერი რომ ხდებოდა ამ კოდექსში ჯერჯერობით.
რა არის მაშინ გავლენა?
როგორ უნდა დააფიქსიროს ეს ორი პრობლემა?
როგორ უნდა შედარებით ფაქტობრივი strings?
>> ისე ინტუიციურად, როგორ თქვენ წავიდეთ შესახებ შედარებით ორი
strings ჭეშმარიტი თანასწორობა?
>> რას ნიშნავს თუ ორი strings თანაბარია?
ცხადია არა, რომ მათი მისამართები გაუტოლდება მეხსიერებაში, რადგან ეს არის ის დაბალი
დონეზე განხორციელების დეტალურად.
ყველა პერსონაჟი არის იგივე.
ნება მომეცით, შესთავაზოს, და ნება მომეცით წარმოგიდგინოთ in მობილური ერთერთი compare.c
აქ, ასე რომ შედარების-1.c.
>> ნება მომეცით შესთავაზოს, რომ ჩვენ მაინც მაჩვენებელი მოუწოდა s, და მაღაზიის მასში
დაბრუნების ღირებულება Get სიმებიანი.
მოდით იგივე ქ.
ასე რომ, არც ერთი კოდი განსხვავებულია.
მე ვაპირებ დავამატოთ ცოტა მეტი შეცდომა შემოწმების ახლა.
ასე რომ, ახლა რომ ჩვენ ერთგვარი peeling უკან ამ ფენების CS50, თუ რა სიმებიანი
ფაქტობრივად, ჩვენ უნდა იყოს უფრო anal დაახლოებით მიღების დარწმუნებული ვარ, რომ ჩვენ არ ბოროტად
ბათილად ღირებულებებს, როგორიცაა null.
>> ასე რომ, მე მხოლოდ აპირებს შეამოწმოს.
თუ არ თანაბარი ბათილად და უ არ თანაბარი null, ეს ნიშნავს, რომ ჩვენ ვართ OK.
მიიღეთ სიმებიანი არ ხრახნიანი up მიღების ან იმ strings.
და შეგიძლიათ, ალბათ ვხვდები ახლა, რა ამჯამად STR CMP სავარაუდოდ გაკეთება?
სიმებიანი შედარება.
>> ასე რომ, თუ თქვენ პროგრამა java ადრე, ეს მოსწონს შეადგენს მეთოდი
სიმებიანი კლასის.
მაგრამ იმ თქვენ, რომლებიც არ დაპროგრამებულია ადრე,
ეს მხოლოდ გ ფუნქცია.
ეს ხდება მოსვლა ფაილი სახელად string.h.
ეს არის ის, სადაც ეს განაცხადა.
>> და სიმებიანი შედარება -
მე რეალურად დაგვავიწყდეს მისი გამოყენება, მაგრამ გახსოვდეთ, რომ.
შეგახსენებთ, რომ ჩვენ შეგვიძლია გავაკეთოთ ადამიანი, აურიეთ შედარება.
და ეს ხდება აღზრდას Linux პროგრამისტების სახელმძღვანელო.
და ეს, გულწრფელად ვამბობ, ცოტა cryptic.
მაგრამ მე ვხედავ, რომ, Yep.
მე უნდა შეიცავდეს string.h.
>> და ეს ამბობს აქ სამუშაოდ აღწერა, " სიმებიანი შეადარეთ ფუნქცია ადარებს
ორი strings S1 და S2. "და S1 და S2 აშკარად ორი
არგუმენტები გავიდა სისტემაში
მე ნამდვილად არ მახსოვს რა const არის, მაგრამ ახლა შეამჩნია -
და შეიძლება მინახავს ეს უკვე როდესაც თქვენ გამოიყენოთ ადამიანი გვერდებზე თუ
ეს ყველაფერი -
რომ char ვარსკვლავი მხოლოდ სინონიმი ერთად სიმებიანი.
>> ასე რომ, ეს ადარებს ორი სიმები, S1 და S2, და ის დააბრუნებს რიცხვი ნაკლებია
მეტი ან ტოლია ან აღემატება ნულოვანი თუ S1 გვხვდება, შესაბამისად, უნდა იყოს
ნაკლები, ან ემთხვევა, ან იყოს მეტი S2.
ეს უბრალოდ ძალიან რთული გზა ამბობდა რომ სიმებიანი შედარების ბრუნდება
ნულოვანი თუ ორი strings არის ინტუიციურად იდენტურია, ხასიათი
ხასიათი ხასიათი.
>> ის დააბრუნებს უარყოფითი რიცხვი, თუ s, ალფავიტის მიხედვით, ვარაუდობენ
მოვა ადრე ტ.
ან დააბრუნებს დადებითი რიცხვი, თუ s უნდა მოვიდეს შემდეგ უ
ანბანური.
ამრიგად, ამ მარტივი ფუნქცია, შესაძლებელი იქნებოდა თქვენ, მაგალითად, დასალაგებლად
მთელი bunch of სიტყვები?
>> ასე რომ, ამ ახალი ვერსიის, მე ვაპირებ to წავიდეთ წინ და მიიღოს compare1.
Dot ხაზი შევადარებთ ერთი.
მე აკრიფოთ კომენტარი პირველმა ყველა ქვედა შემთხვევაში.
მე ვაპირებ აკრიფოთ კომენტარი პირველმა ყველა ამას კიდევ ერთხელ.
და საბედნიეროდ ახლა ეს ხვდება მე აკრეფილი იგივე.
>> ამასობაში, თუ აკრიფოთ მიესალმები ქვედა საქმე და HELLO ზემო შემთხვევაში და
შედარება, მე აკრეფილი სხვადასხვა რამ არის.
იმის გამო, რომ არა მხოლოდ მისამართები განსხვავებული, მაგრამ ჩვენ შედარებით
სხვადასხვა სიმბოლოების ისევ და ისევ.
>> ისე მოდით წავიდეთ და დააფიქსიროს ერთი მეორე პრობლემა არის.
ნება მომეცით ქმნის მობილური ერთი ასლი, რომელიც ახლა მიმართავს
ეს საკითხი შემდეგნაირად.
ეს ერთი აპირებს გამოიყურებოდეს ცოტა უფრო რთული.
მაგრამ თუ ფიქრობთ, რა პრობლემა უნდა გადაწყვიტოს, იმედია ეს იქნება
გარკვევა რაღაც მომენტში არის.
>> ასე რომ, ეს პირველი რიგის, char დაწყების t, in layman პირობები შეიძლება ვინმეს შესთავაზოს
რა ეს ხაზი აქ ნიშნავს?
Char ვარსკვლავი უ, რა არის, რომ აკეთებს?
>> კარგი.
შექმნა მაჩვენებელი ზოგიერთი ადგილზე მეხსიერებაში.
და ნება მომეცით დახვეწა ეს ცოტა.
აცხადებენ ცვლადი, რომელიც შესანახად მისამართი ზოგიერთი char მეხსიერებაში, უბრალოდ
უნდა იყოს უფრო სწორი.
>> OK, ასე რომ, ახლა, როდესაც მარჯვენა მხარეს, მე მინახავს ერთი ასეთი ფუნქციები
ადრე, malloc.
მაგრამ რა შეიძლება ნიშნავს ეს?
განაწილება მეხსიერება.
მეხსიერება განაწილებაზე.
>> ასე რომ, თურმე დღემდე ჩვენ არ ნამდვილად ჰქონდა ძლიერი გზა
ითხოვს ოპერაციული სისტემა, მომეცით მეხსიერება.
პირიქით, ჩვენ ახლა ფუნქცია მოუწოდა malloc რომ ჯერ ზუსტად რომ.
მიუხედავად იმისა, რომ ეს ცოტა განადგურების ახლა შეამჩნია, რომ
ორ ფრჩხილებში არის უბრალოდ იქნება ნომერი.
სად მე აკრეფილი კითხვა ნიშნები შეიძლება იყოს ნომერი.
>> და ეს რიცხვი ნიშნავს, მომეცი 10 ბაიტს.
მომეცი 20 ბაიტს.
მომეცი 100 bytes.
და malloc ყველაფერს გააკეთებს იმისათვის, რათა ვთხოვთ ოპერაციული სისტემა -
Linux, ამ შემთხვევაში -
hey, მათი 100 bytes ოპერატიული ხელმისაწვდომი?
თუ ასეა, დაბრუნდნენ იმ bytes ჩემს მიერ დაბრუნების მისამართი, რომელი
იმ ბაიტი, ალბათ?
პირველი ერთი.
>> ასე რომ, აქ ძალიან - და ეს არის უპირატესი in C, ნებისმიერ დროს თქვენ
საქმე მისამართები?
თქვენ თითქმის ყოველთვის საქმე პირველი ასეთი მისამართი, რაც არ უნდა დიდი
ბლოკი მეხსიერება თქვენ მიმდინარეობს გადასცა უკან, ასე ვთქვათ.
>> მოდით ჩაყვინთვის აქ.
ვცდილობ გამოყოფას თუ როგორ ბევრი ბაიტი, ზუსტად?
ასევე.
სიმებიანი ხანგრძლივობა s - მოდით ამის გაკეთება კონკრეტული მაგალითი.
თუ არის hello, H-E-L-L-O, რა სიმებიანი ხანგრძლივობა s, აშკარად?
ასე რომ, ხუთი.
მაგრამ მე ვაკეთებ პლუს 1, რომ, რატომ?
რატომ მინდა ექვსი bytes ნაცვლად ხუთ?
Null ხასიათი.
>> მე არ მინდა დატოვება off ამ სპეციალური null ხასიათი.
იმიტომ, რომ თუ მე ასლი განყოფილებაში და მხოლოდ ამის გაკეთება H-E-L-L-O, მაგრამ მე არ დააყენა
განსაკუთრებული ხასიათი, კომპიუტერი შეიძლება არ აქვს, შანსი, წარმატებული
ნულოვანი არსებობს ჩემთვის.
ასე რომ, თუ მე ცდილობენ გაერკვნენ ხანგრძლივობა ასლი, მე ალბათ ფიქრობთ, რომ
ეს 20 სიმბოლო გრძელი ან მილიონი სიმბოლო თუ უბრალოდ არ ხდება
მოხვდა წარმატებული ნულოვანი.
>> ასე რომ, ჩვენ გვჭირდება ექვსი bytes შესანახად H-E-L-L-O, წარმატებული ნულოვანი.
და მაშინ ეს მხოლოდ უნდა იყოს სუპერ anal.
დავუშვათ, რომ მე უნდა დაგვავიწყდეს, თუ რა ზომის char არის.
ჩვენ გვაქვს რომ ერთი ბაიტი.
და ეს, როგორც წესი, არის.
თეორიულად, ეს შეიძლება იყოს რაღაც სხვადასხვა, სხვადასხვა Mac ან
სხვადასხვა კომპიუტერი.
>> გამოდის, რომ არსებობს ამ ოპერატორი მოუწოდა sizeof, რომ თუ თქვენ გაიაროს ეს
სახელი მონაცემთა ტიპის - მსგავსი char, ან int, ან float -
იგი გეტყვით, დინამიურად, რამდენი bytes char იღებს ამ
კერძოდ კომპიუტერი.
>> ასე რომ, ეს ეფექტურად მხოლოდ ისევე როგორც ამბობდნენ ჯერ 1 ან
ჯერ არაფერი.
მაგრამ მე ვაკეთებ უბრალოდ უნდა იყოს სუპერ ანალური რომ მხოლოდ იმ შემთხვევაში, char განსხვავდება
თქვენს კომპიუტერში წინააღმდეგ აფეთქდა, ამ გზით მათემატიკის ყოველთვის აპირებს შეამოწმოს.
>> და ბოლოს, ქვემოთ აქ შემოწმება null, რომელიც ყოველთვის კარგი პრაქტიკა - ერთხელ,
ნებისმიერ დროს ჩვენ საქმე გვაქვს მითითებას.
თუ malloc ვერ შეძლო, რათა მე ექვსი byes - რაც
ნაკლებად სავარაუდოა, მაგრამ მხოლოდ იმ შემთხვევაში -
დაბრუნების ერთ დაუყოვნებლივ.
ახლა კი, წავიდეთ წინ და კოპირება სიმებიანი ასეთია.
და ეს ნაცნობი სინტაქსის, თუმცა სხვადასხვა როლი.
>> მე ვაპირებ წავიდეთ წინ და მიიღოს სიმებიანი ხანგრძლივობა და ჩაწერს მას ო.
მე მაშინ აპირებს iterate from i შეადგენს ნულოვანი მდე და მათ შორის ნ
მეტია ან ტოლი.
ასე რომ, თითოეულ iteration, მე დააყენა შ ხასიათის s in შ
ხასიათი ტ.
>> ასე რომ, თუ რა სინამდვილეში ქვეშ hood აქ?
ისე, თუ ეს, მაგალითად, s -
და მე აკრეფილი სიტყვა H-E-L-L-O და არ არსებობს წარმატებული ნულოვანი.
ისევ და ისევ, ეს s მიუთითებს აქ.
აქ ახლა არის ტ.
>> ეს კი მიუთითებს ახლა ასლი მეხსიერება, არა?
Malloc მომცა მთელი ბლოკი მეხსიერება.
არ ვიცი, თავიდან რა ნებისმიერ ამ ადგილებში.
ამიტომ, მე ვაპირებ, რომ ვფიქრობ, ეს როგორც მთელი bunch of კითხვის ნიშნები.
>> მაგრამ როგორც კი დავიწყებ looping ნულიდან მდე საშუალებით ხანგრძლივობა s, ტ
bracket ნულოვანი და უ bracket 1 -
და მე დააყენა ეს ახლა on ოვერჰედის -
t bracket ნულოვანი და s bracket ნულოვანი ნიშნავს რომ მე უნდა გადაწერა
iteratively სთ აქ, E-L-L-O. გარდა ამისა, იმის გამო, რომ მე პლუს
1, წარმატებული ნულოვანი.
>> ასე რომ, ახლა იმ შემთხვევაში, შედარების-1.c, საბოლოო ჯამში, თუ ამობეჭდოთ
კაპიტალიზაცია t, ჩვენ უნდა ვხედავთ, რომ არის უცვლელი.
ნება მომეცით წავიდეთ წინ არის და ამის გაკეთება.
ასე რომ copy1.
Dot ხაზი copy1.
მე ვაპირებ აკრიფოთ hello, შეიტანეთ.
ახლა კი შეამჩნია, მხოლოდ ასლი უკვე კაპიტალიზაცია.
იმის გამო, რომ მე ნამდვილად გვაქვს ორი მოცულობით მეხსიერება.
>> სამწუხაროდ, მაშინ ზოგიერთი საკმაოდ ცუდი და საკმაოდ საშიში რამ აქ.
ნება მომეცით გაიყვანოს up მაგალითად აქ არის, რომ გვაძლევს მაგალითს, რამდენიმე
სხვადასხვა ხაზები.
ასე რომ მხოლოდ ინტუიციურად აქ, პირველი ხაზი კოდის, int ვარსკვლავი x, არის გამოცხადების
ცვლადში x.
და რაც მონაცემთა ტიპის იმ ცვლადი?
რა არის მონაცემთა ტიპის, რომ ცვლადის?
ეს არ იყო cliffhanger.
>> მონაცემთა ტიპის int ვარსკვლავი.
ასე რომ, რას ნიშნავს ეს? x იქნება შესანახად მისამართი int.
მარტივია, რომ.
Y აპირებს შესანახად მისამართი int.
რა არის მესამე ხაზი კოდის აკეთებს იქ?
ეს გამოყოფის რამდენი ბაიტი, სავარაუდოდ?
ოთხი.
ამის გამო ზომის int არის ზოგადად ოთხი, malloc ოთხი აძლევს
ჩემს უკან მისამართი ბლოკი მეხსიერება, პირველ რომლის bytes არის
ინახება ახლა x.
>> ახლა ჩვენ გადავდივართ ცოტა სწრაფად.
ვარსკვლავი x ნიშნავს რა?
ეს იმას ნიშნავს, წასვლა რომ მისამართი და ამით რა რაოდენობის იქ?
განათავსეთ ნომერი 42 არსებობს.
ვარსკვლავი Y ნიშნავს წასვლა რა დროს შ და ამით ნომერი 13 არსებობს.
>> მაგრამ დაველოდოთ წუთში.
რა არის Y მომენტში?
რა მისამართია შ შენახვის?
ჩვენ არ ვიცით, არა?
ჩვენ არასდროს ერთხელ გამოიყენოთ დავალება ოპერატორი ჩართვის წ.
ასე რომ შ როგორც განაცხადეს მეორე ხაზი კოდი არის რამოდენიმე ნაგვის ღირებულება, დიდი
კითხვის ნიშნის ასე ვთქვათ.
შეიძლება მიუთითებს შემთხვევით არაფერი მეხსიერება, რომელიც
ზოგადად ცუდია.
>> ასე რომ, როგორც კი მოხვდა, რომ ხაზი იქ, ვარსკვლავი y ტოლია 13, რაღაც ცუდი,
რაღაც ძალიან ცუდი დაახლოებით უნდა მოხდეს, რათა Binky.
ასე რომ, ვნახოთ რა ხდება დასრულდება ხდება Binky აქ ამ წუთში
ან ასე გამოიყურება.
>> [ვიდეო აღწარმოების]
>> -Hey, Binky.
გაიღვიძეთ.
დროა მაჩვენებელი სახალისო.
>> -რა არის რომ?
შესწავლა მითითებას?
Oh, goodie.
>> -Well, უნდა დაიწყო, ვფიქრობ, ჩვენ აპირებთ უნდა რამდენიმე მითითებას.
>> -OK.
ეს კოდი გამოყოფს ორ მითითებას რომელიც შეიძლება აღვნიშნო, რომ რიცხვებით.
>> -OK, ასევე, მე ვხედავ ორ მითითებას.
მაგრამ ისინი არ ჩანს მიუთითებს არაფერი.
>> -ეს უფლება.
თავდაპირველად, მითითებას არ აღვნიშნავთ, რომ არაფერი.
რამ ისინი მიუთითებენ უწოდებენ pointees და დახურეს არის
ცალკე ნაბიჯი.
>> -Oh, უფლება, უფლება.
ვიცოდი, რომ.
Pointees ცალკე.
ასე რომ, როგორ შეიძლება ამის გამოყოფს pointee?
>> -OK.
ასევე, ამ კოდი გამოყოფს ახალი რიცხვებით pointee, და ეს ნაწილი განსაზღვრავს x
აღვნიშნო მას.
>> -Hey, რომ უკეთესია.
ასე რომ, ის გახდეს.
>> -OK.
მე dereference მაჩვენებელი x შესანახად ნომერი 42 მის pointee.
ამისათვის შეასრულა, მე უნდა ჩემი ჯადოსნური კვერთხი of dereferencing.
>> -შენი ჯადოსნური ჯოხი of dereferencing?
Uh, რომ დიდი.
>> -ეს არის ის, რაც კოდი გამოიყურება.
მე მხოლოდ წყობის ნომერი, და -
>> -Hey, გამოიყურება.
არსებობს მიდის.
ამით dereference on x შემდეგნაირად arrow წვდომის მისი pointee.
ამ შემთხვევაში, შესანახად 42 იქ.
Hey, ცდილობენ გამოყენება შესანახად ნომერი 13 გზით სხვა მაჩვენებელი, წ.
>> -OK.
მე უბრალოდ მეტი აქ Y-სა და მიიღეთ ნომერი 13 შეიქმნება.
და მერე ჯოხი of dereferencing და მხოლოდ -
Whoa,
>> -Oh, hey.
ეს არ იმუშავებს.
ამბობენ, Binky, არა მგონია, dereferencing Y არის კარგი იდეა,
რადგან შექმნის pointee ცალკე ნაბიჯი.
მე არ ვფიქრობ, რომ ჩვენ ოდესმე გააკეთა ეს.
>> -Hmm.
კარგი წერტილი.
>> -ჰო, ჩვენ გამოყოფილი მაჩვენებელი წ.
მაგრამ ჩვენ არასდროს ვაყენებთ მას მიუთითებენ pointee.
>> -Hmm.
ძალიან დაკვირვებულობა.
>> -ეი, თქვენ ვეძებთ კარგი იქ, Binky.
შეგიძლიათ დაფიქსირება ისე, რომ Y რაოდენობა ამავე pointee როგორც x?
>> -დარწმუნებული.
მე, ჩემი ჯადოსნური ჯოხი of მაჩვენებელი საბუთი.
>> -ის არის, რომ იქნება პრობლემა, როგორიც ადრე?
>> -No.
ეს არ შეხებია pointees.
ეს მხოლოდ ცვლის ერთ მაჩვენებელი აღვნიშნო to იგივე როგორც სხვა.
>> -Oh, მე ვერ ვხედავ.
ახლა შ რაოდენობა იმავე ადგილზე, როგორც x.
ასე რომ, დაველოდოთ.
ახლა შ დაფიქსირდა.
მას აქვს pointee.
ასე რომ, შეგიძლიათ ცდილობენ კვერთხი საქართველოს dereferencing ერთხელ
გაგზავნის 13 დასრულდა.
>> -OK.
აქ გადის.
>> -Hey, შეხედეთ, რომ.
ახლა dereferencing სამუშაოები წ.
და რადგან მითითებას ან სხვა რომ ერთ pointee, მათ
როგორც ვხედავთ, 13.
>> -ჰო.
გაზიარება.
როგორიც არ უნდა იყოს.
ასე რომ მივდივართ გადართვის ადგილებში ახლა?
>> -Oh, შეხედეთ.
ჩვენ მისთვის განკუთვნილ დროში.
>> მაგრამ -
>> -უბრალოდ გვახსოვდეს, სამი მაჩვენებელი წესები.
პირველი ნომერი, ძირითადი სტრუქტურა არის, რომ თქვენ გაქვთ მაჩვენებელი.
და ეს მიუთითებს გადასცა pointee.
მაგრამ მაჩვენებელი და pointee ცალკე.
ხოლო საერთო შეცდომა არის შეიქმნა მაჩვენებელი, არამედ
დაგვავიწყდეს, რომ მოცემულ pointee.
>> ხმების ორი, მაჩვენებელი dereferencing იწყება ერთი მაჩვენებელი და შეასრულებს
arrow მეტი წვდომის მისი pointee.
როგორც ვიცით, ეს მუშაობს მხოლოდ იმ შემთხვევაში, თუ არსებობს არის pointee, რომელიც იღებს უკან
გამორიცხავს ნომერ პირველი.
>> პუნქტების სამი, მაჩვენებელი დავალება იღებს ერთი მაჩვენებელი და ცვლილებები ის აღვნიშნო, რომ
იგივე pointee კიდევ ერთი მაჩვენებელი.
ასე რომ დავალების ორი მითითებას იქნება
აღვნიშნავთ, რომ იგივე pointee.
ზოგჯერ, რომ ე.წ. გაზიარება.
და ეს ყველაფერი არ არის იგი, ნამდვილად.
Bye bye არის.
>> [END ვიდეო აღწარმოების]
>> დავით Malan: ასე უფრო მითითებას, უფრო Binky მომავალ კვირას.
ჩვენ დავინახავთ, თქვენ ორშაბათს.