>> [მუსიკის დაკვრა]
>> DOUG LLOYD: პოინტერები, აქ ვართ.
ეს არის ალბათ აპირებს ყველაზე რთული თემა
რომ ჩვენ ვსაუბრობთ CS50.
და თუ თქვენ წაიკითხოთ არაფერი პოინტერები
სანამ შეიძლება იყოს ცოტა დაშინებას აპირებს ამ ვიდეო.
მართალია, მითითებას გთხოვთ საშუალებას გაძლევთ უნარი
ალბათ, ხრახნიანი up საკმაოდ ცუდად, როდესაც თქვენ
მუშაობის ცვლადები, და მონაცემები, და იწვევს თქვენი პროგრამის მისაწოდებლად.
მაგრამ ისინი რეალურად სასარგებლო და ისინი საშუალებას მოგვცემს მართლაც დიდი გზა
გაივლის მონაცემები უკან და მეოთხე შორის ფუნქციები,
რომ ჩვენ სხვაგვარად ვერ გააკეთებს.
>> ასე რომ, რაც ჩვენ ნამდვილად მინდა აქ არის მატარებელი
თქვენ გაქვთ კარგი მაჩვენებელი დისციპლინის, ასე რომ რომ თქვენ შეგიძლიათ გამოიყენოთ პოინტერები ეფექტურად
იმისათვის, რომ თქვენი პროგრამა, რომელიც ბევრად უკეთესი.
როგორც ვთქვი მითითებას გვაძლევს სხვადასხვა გზა უნდა გაიაროს მონაცემები ფუნქციები.
ახლა თუ გახსოვთ, ადრე ვიდეო, როდესაც
ჩვენ ვსაუბრობთ ცვლადი ფარგლებს, აღვნიშნე,
რომ ყველა მონაცემები, რომ ჩვენ შორის გაივლის ფუნქციების C გავიდა ღირებულება.
და მე შეიძლება არ გამოიყენება, რომ ტერმინი,, რაც მე იმას ნიშნავდა,
იყო, რომ ჩვენ გადიან ასლები მონაცემები.
როდესაც ჩვენ გაიაროს ცვლადი ფუნქცია, ჩვენ რეალურად არ გავლის ცვლადი
ფუნქცია, არა?
ჩვენ გავლით ასლი რომ მონაცემები ფუნქცია.
ფუნქცია აქვს რა იქნება და ითვლის გარკვეული მნიშვნელობა,
და იქნებ ჩვენ ვიყენებთ მნიშვნელობა როდესაც იგი იძლევა უკან.
>> იყო ერთი გამონაკლისი ამ წესთან ღირებულება,
და ჩვენ დავბრუნდებით რა, რომ ცოტა მოგვიანებით ამ ვიდეო.
თუ ვიყენებთ მითითებას ნაცვლად გამოყენების ცვლადები,
ან იმის მაგივრად, რომ ცვლადები თავად ან ასლები ცვლადები,
ახლა ჩვენ შეგვიძლია გაივლის ცვლადებს გარშემო შორის ფუნქციების სხვადასხვა გზა.
ეს იმას ნიშნავს, რომ თუ ჩვენ ცვლილება ერთი ფუნქცია,
რომ ცვლილება პრაქტიკულად მოქმედებს სხვადასხვა ფუნქცია.
ისევ და ისევ, ეს არის ის, რომ ჩვენ არ შეგვეძლო ადრე,
და თუ თქვენ ოდესმე ცდილობდა სვოპ ღირებულება ორი ცვლადის ფუნქცია,
თქვენ შენიშნა, ამ პრობლემის სახის მცოცავი, არა?
>> თუ ჩვენ გვინდა, რომ სვოპ X და Y, და ჩვენ გადმოეცა ფუნქცია მოუწოდა swap,
შიგნით ფუნქცია სვოპ ცვლადები გავაკეთოთ გაცვლა ღირებულებებს.
ერთი ხდება, ორი ხდება ერთ-ერთი, მაგრამ ჩვენ არ რეალურად
შეიცვალოს რამე ორიგინალური ფუნქცია, აბონენტის.
იმის გამო, რომ ჩვენ არ შეგვიძლია, ჩვენ მხოლოდ მუშაობის ასლები მათ.
პოინტერები, თუმცა, ჩვენ შეგვიძლია რეალურად გაივლის X და Y ფუნქცია.
ეს ფუნქცია შეგიძლიათ გააკეთოთ რაღაც მათთან.
და იმ ცვლადების ღირებულებების შეიძლება რეალურად შეცვალოს.
ასე რომ, საკმაოდ ცვლილება ჩვენი მუშაობის უნარი მონაცემებით.
>> სანამ ჩვენ ჩაყვინთვის შევიდა მითითებას, მე ვფიქრობ, რომ ღირს
აღების რამდენიმე წუთში დაბრუნდეს საფუძვლებს აქ.
და აქვს შევხედოთ, თუ როგორ კომპიუტერის მეხსიერების სამუშაოები
იმის გამო, რომ ამ ორ სუბიექტს ვაპირებთ რეალურად იყოს საკმაოდ ურთიერთდაკავშირებულია.
როგორც თქვენ ალბათ იცით, თქვენი კომპიუტერის სისტემის
თქვენ მყარ დისკზე ან ალბათ მყარი დისკის,
გარკვეული ფაილების შესანახი ადგილმდებარეობა.
ეს, როგორც წესი, სადღაც სამეზობლოში 250 გბ
იქნებ რამდენიმე terabytes ახლა.
და ეს არის, სადაც ყველა თქვენი ფაილი საბოლოოდ ცხოვრობს,
მაშინაც კი, როდესაც თქვენი კომპიუტერი დახურეს off, შეგიძლიათ ჩართოთ ეს უკან
და თქვენ იპოვით თქვენი ფაილი არსებობს ერთხელ, როდესაც თქვენ გადატვირთეთ სისტემა.
მაგრამ მაგნიტური დისკები, როგორიცაა მყარი დისკის, ჰორიზონტალური ბურღვის, ან მყარი დისკის, SSD,
არის მხოლოდ შენახვის სივრცეში.
>> ჩვენ არ შეგვიძლია რეალურად არაფერი მონაცემები, რომ არის ხისტი,
ან მყარი დისკის.
იმისათვის, რომ რეალურად შეცვალოს მონაცემების ან გადატანა გარშემო,
ჩვენ უნდა გადავიდეს ეს RAM, ოპერატიული მეხსიერება.
ახლა RAM, თქვენ გაქვთ ბევრი ნაკლებად თქვენს კომპიუტერში.
თქვენ შეიძლება ჰქონდეს სადღაც სამეზობლოში 512 მბ
თუ თქვენ გაქვთ ძველი კომპიუტერი, იქნებ ორი, ოთხი, რვა, 16,
შესაძლოა ცოტა უფრო მეტიც, გბ ოპერატიული მეხსიერება.
ასე რომ, ბევრად უფრო მცირე, მაგრამ ეს სადაც ყველა არასტაბილურ მონაცემები არ არსებობს.
სწორედ იქ, სადაც ჩვენ შეგვიძლია შეცვალოს.
მაგრამ როდესაც ჩვენ რომ ჩვენი კომპიუტერის გამორთვა, ყველა მონაცემების RAM განადგურებულია.
>> ასე რომ, თუ რატომ უნდა ჰქონდეს მყარი დისკის ამისთვის უფრო მუდმივი ის,
ასე, რომ ეს exists-, რომ ის იქნება ნამდვილად ცუდია, თუ ყოველ ჯერზე ჩვენ
დღევანდელი ჩვენი კომპიუტერის გამორთვა, ყოველ ფაილი ჩვენს სისტემა, განადგურდა.
ასე რომ, ჩვენ მუშაობა შიგნით RAM.
და ყოველ ჯერზე ჩვენ ვსაუბრობთ მეხსიერება, საკმაოდ ბევრი, CS50,
ჩვენ ვსაუბრობთ RAM, არ მყარ დისკზე.
>> ასე რომ, როდესაც ჩვენ გადაადგილება რამ მეხსიერებაში, იგი იღებს გარკვეულ სივრცეში.
ყველა მონაცემთა ტიპები, რომ ჩვენ ვმუშაობთ ერთად
დასჭირდეს სხვადასხვა რაოდენობით სივრცეში RAM.
ასე რომ, ყოველ დროს, თქვენ შექმენით რიცხვი ცვლადი, ოთხი ბაიტი მეხსიერება
გათვალისწინებულია ამ RAM, ასე რომ თქვენ შეუძლია მუშაობა, რომ რიცხვი.
შეგიძლიათ განაცხადოს რიცხვი, შეცვლის, მივანიჭოთ მას
ღირებულება 10 incremented ერთ-ერთი, და ასე შემდეგ.
ყველა, რომ უნდა მოხდეს RAM, და თქვენ ოთხი ბაიტი
მუშაობა ყველა მთელი რიცხვი, რომელიც შექმნა.
>> ყოველ ხასიათი შექმნა იღებს ერთი ბაიტი.
ეს არის ის, თუ რამდენად დიდი სივრცე საჭირო შესანახად ხასიათი.
ყოველ float, ნამდვილი ნომერი, იღებს ოთხი ბაიტი
თუ ეს ორმაგი ზუსტი მცურავი წერტილი
ნომერი, რომელიც გაძლევთ საშუალებას აქვს უფრო ზუსტი და მეტი ციფრები
შემდეგ ათობითი წერტილი დაკარგვის გარეშე სიზუსტით,
რომელიც დასჭირდეს რვა ბაიტი მეხსიერება.
დიდხანს longs, მართლაც დიდი რიცხვებით, ასევე დასჭირდეს რვა ბაიტი მეხსიერება.
რამდენი ბაიტი მეხსიერება არ სიმები დასჭირდეს?
ისე მოდით დააყენოს pin, რომ კითხვა ახლა, მაგრამ ჩვენ დავბრუნდებით მას.
>> ასე რომ თავში ეს იდეა მეხსიერება, დიდი მასივი byte ზომის უჯრედები.
ეს მართლაც ყველა ის არის, რომ ეს უბრალოდ უზარმაზარი მასივი საკნები,
ისევე, როგორც ნებისმიერი სხვა მასივი, რომ თქვენ იცნობს და ვნახოთ,
გარდა ყოველ ელემენტს არის ერთი ბაიტი კარს.
და ისევე, როგორც მასივი, ყველა ელემენტს აქვს მისამართზე.
ყველა ელემენტს მასივი აქვს ინდექსი, და ჩვენ
შეგიძლიათ გამოიყენოთ ეს მაჩვენებელი უნდა გავაკეთოთ ე.წ. წვდომის on მასივი.
ჩვენ არ უნდა დაიწყოს დასაწყისში მასივი,
iterate მეშვეობით ყოველ ერთ ელემენტს მისი,
იპოვოს ის, რაც ჩვენ ვეძებთ.
შეგვიძლია ვთქვათ, უბრალოდ, მინდა მისაღებად 15 ელემენტი ან 100 ელემენტს.
და თქვენ შეგიძლიათ უბრალოდ გაივლის, რომ ნომერი და მიიღეთ მნიშვნელობა თქვენ ეძებთ.
>> ანალოგიურად ყველა ადგილმდებარეობა მეხსიერება აქვს მისამართზე.
ასე რომ, თქვენი მეხსიერება შეიძლება ასე გამოიყურება.
აქ არის ძალიან მცირე ბლოკი მეხსიერება, ეს არის 20 ბაიტი მეხსიერება.
პირველი 20 ბაიტი, რადგან ჩემი მიმართავს იქ ბოლოში
0, 1, 2, 3, და ასე ყველა გზა მდე 19.
და როცა ვაცხადებ, ცვლადები და როცა დაიწყება მათთან მუშაობა,
სისტემის შექმნას აპირებს გათვალისწინებულია გარკვეული სივრცე ჩემთვის
ამ მეხსიერების მუშაობა ჩემი ცვლადები.
ასე რომ, შეიძლება ითქვას, char c შეადგენს კაპიტალის H. და რა მოხდება?
ისე სისტემის აპირებს გათვალისწინებულია ჩემთვის ერთი ბაიტი.
ამ შემთხვევაში ეს აირჩია byte ნომერი ოთხი, byte, მისამართზე ოთხი,
და ის აპირებს შესანახად წერილი კაპიტალის H არსებობს ჩემთვის.
თუ მე ვთქვა int სიჩქარე ლიმიტი შეადგენს 65, ეს
აპირებს გათვალისწინებულია ოთხი ბაიტი მეხსიერების ჩემთვის.
და ის აპირებს მკურნალობა იმ ოთხი ბაიტი, როგორც ერთი ერთეული
რადგან ის, რაც ჩვენ ვმუშაობთ ერთად არის მთელი რიცხვი აქ.
და ის აპირებს შესანახად 65 იქ.
>> ახლა უკვე მე სახის გეუბნებოდით ცოტა ტყუილი,
უფლება, რადგან ჩვენ ვიცით, რომ კომპიუტერი მუშაობა ორობითი.
მათ არ ესმით აუცილებლად რა კაპიტალის H არის
ან რა 65 ის არის, რომ მხოლოდ მესმის, ორობითი, zeros და პირობა.
ასე რომ, რეალურად, რა ჩვენ შენახვის არსებობს
არ არის წერილში H და ნომერი 65, არამედ ორობითი წარმომადგენლობების
შესახებ, რომლებიც გამოიყურება ცოტა რაღაც მსგავსი.
და, კერძოდ, კონტექსტში მთელი ცვლადი,
ის არ აპირებს, უბრალოდ შამფურზე ის შევიდა, ის არ აპირებს მკურნალობა, როგორც ერთი ოთხი
byte ბლოკი აუცილებლად, ის რეალურად აპირებს
მისი მკურნალობა, როგორც ოთხი ერთი ბაიტი მოცულობით, რომელიც შეიძლება ასე გამოიყურება.
და მაშინაც კი, ეს არ არის მთლიანად ჭეშმარიტი ან,
იმის გამო, რომ რაღაც მოუწოდა endianness, რომელიც ჩვენ არ
ვაპირებ შეღწევას ახლა, მაგრამ თუ თქვენ დაინტერესდა,
შეგიძლიათ წაიკითხოთ up პატარა და დიდი endianness.
მაგრამ გულისთვის ამ არგუმენტის გულისთვის ამ ვიდეო,
მოდით უბრალოდ ვივარაუდოთ, რომ არის, ის ფაქტი, თუ როგორ რიცხვი 65 იქნება
იქნება წარმოდგენილი მეხსიერების ყოველ სისტემის,
მიუხედავად იმისა, რომ ეს მთლად ასე არ არის.
>> მაგრამ მოდით რეალურად მხოლოდ მისაღებად მოისპოს ყველა ორობითი მთლიანად,
და მხოლოდ ვიფიქროთ, როგორც H 65, ეს ბევრად უფრო ადვილია,
უნდა ვიფიქროთ, რომ, როგორც რომ როგორც ადამიანის.
ყველა უფლება, ასე რომ, როგორც ჩანს, შესაძლოა, პატარა შემთხვევითი, რომ I've- ჩემი სისტემა
არ მაძლევს bytes 5, 6, 7, და 8 შესანახად რიცხვი.
არ არსებობს მიზეზი, რომ, ძალიან, რომელიც ჩვენ არ მოხვდება ახლა, მაგრამ საკმარისია
იმის თქმა, რომ ის, რაც კომპიუტერი აკეთებს აქ
ალბათ კარგი ნაბიჯი მისი ნაწილი.
იმისათვის, რომ არ მომეცი მეხსიერება, რომ აუცილებლად თავში დაბრუნება.
მიუხედავად იმისა, რომ ის აპირებს ამის გაკეთება ახლა თუ მინდა, რომ კიდევ ერთი ტექსტი,
მოუწოდა გვარი, და მე მინდა, იმისათვის, რომ Lloyd არსებობს.
მე ვაპირებ უნდა ჯდება ერთი ხასიათი, ყოველ წერილს, რომ
აპირებს მოითხოვოს ერთი ხასიათი, ერთი ბაიტი მეხსიერება.
ასე რომ, თუ მე ვერ დააყენა Lloyd ჩემი მასივი მოსწონს ეს მე საკმაოდ კარგი წასვლა, არა?
რა აკლია?
>> გახსოვდეთ, რომ ყოველი სტრიქონი ჩვენ ვმუშაობთ ერთად C მთავრდება წარმატებული ნულოვანი,
და ჩვენ ვერ გამომრჩეს, რომ აქ, ან.
ჩვენ უნდა გათვალისწინებულია ერთი ბაიტი მეხსიერების გამართავს, რომ ასე რომ, ჩვენ
იცით, როდესაც ჩვენი სიმებიანი დასრულდა.
ასე რომ კიდევ ერთხელ ამ შეთანხმებას გზა რამ
როგორც ჩანს, მეხსიერების შეიძლება იყოს ცოტა შემთხვევითი,
მაგრამ ის რეალურად არის, თუ როგორ ყველაზე სისტემები შექმნილია.
იმისათვის, რომ ხაზის მათ up ჯერადი ოთხი, იმის გამო, კიდევ ერთხელ
რომ ჩვენ არ უნდა შეღწევას ახლავე.
მაგრამ ეს, ასე რომ საკმარისია ითქვას, რომ მას შემდეგ, რაც ამ სამი ხაზი კოდი,
ეს არის ის, რაც მეხსიერება შეიძლება გამოიყურებოდეს.
თუ მე უნდა მეხსიერების ადგილებში 4, 8 და 12 გამართავს ჩემი მონაცემებით,
ეს არის ის, რაც ჩემს მეხსიერებაში შეიძლება გამოიყურებოდეს.
>> და მხოლოდ განსაკუთრებით pedantic აქ, როდესაც
ჩვენ ვსაუბრობთ მეხსიერება მისამართები ჩვენ, როგორც წესი,
ასე გამოყენებით თექვსმეტობითი notations.
რატომ არ გადაიყვანოთ ყველა ამ საწყისი ათობითი თექვსმეტობითი ნოტაცია
მხოლოდ იმიტომ, რომ, ზოგადად, როგორ ჩვენ ეხება მეხსიერება.
ასე რომ, ნაცვლად იმისა, რომ 0-დან 19, რაც გვაქვს არის ნულოვანი
x ნულოვანი მეშვეობით ნულოვანი x1 სამი.
ეს არის 20 ბაიტი, მეხსიერება, რომ ჩვენ არ და ჩვენ შევხედავთ ამ სურათის
უფლება აქ.
>> ასე რომ, ყველა, რომ მიმდინარეობს განაცხადა, მოდით დახევას დაშორებით მეხსიერების მეორე
და უკან მითითებას.
აქ არის ყველაზე მნიშვნელოვანი რამ უნდა გვახსოვდეს
როგორც ჩვენ დაიწყოს მუშაობა მითითებას.
მაჩვენებელი არაფერია მეტი, ვიდრე მისამართზე.
მე ვიტყვი კიდევ ერთხელ იმიტომ, ის, რომ მნიშვნელოვანია,
მომცეთ არაფერია მეტი, ვიდრე მისამართზე.
პოინტერები მისამართების ადგილას მეხსიერებაში, სადაც ცვლადები ცხოვრობს.
იცის, რომ ეს ხდება იმედია ცოტა უფრო ადვილია მათთან მუშაობა.
კიდევ ერთი რამ მინდა უნდა გავაკეთოთ, არის ის, რომ სახის
დიაგრამების ვიზუალურად წარმოადგენს რა არის ხდება სხვადასხვა ხაზების კოდი.
და ჩვენ ყველაფერს გავაკეთებთ ამ ორი ჯერ მითითებას,
და როცა ჩვენ ვსაუბრობთ დინამიური მეხსიერების გამოყოფის ისევე.
იმის გამო, რომ მე ვფიქრობ, რომ ეს დიაგრამა შეიძლება იყოს განსაკუთრებით სასარგებლო.
>> ასე რომ, თუ მე ვიტყვი, მაგალითად, int k ჩემი კოდი, რა ხდება?
ისე, რა, ძირითადად, ხდება მე მიღების მეხსიერების გათვალისწინებულია ჩემთვის,
მაგრამ მე კი არ მინდა ვიფიქროთ, რომ, როგორც, რომ, მე
გვსურს ვიფიქროთ, რომ, როგორც ყუთში.
მაქვს ყუთი, და ეს ფერადი მწვანე იმიტომ, რომ მე
შეგიძლიათ დააყენა რიცხვებით მწვანე ყუთები.
თუ ეს იყო ხასიათი მე შეიძლება ჰქონდეს ცისფერ ყუთში.
მაგრამ მე ყოველთვის ვამბობ, თუ მე შექმნის ყუთი, რომელიც შეიძლება გამართავს რიცხვებით
რომ ყუთი მწვანეა.
მე და მარკერით და ვწერ k მხარეს იგი.
ასე რომ, მე ყუთში მოუწოდა k, რომელშიც მე ვერ დააყენა რიცხვებით.
ასე რომ, როდესაც ვამბობ, რომ int k, რომ რა ხდება, ჩემი უფროსი.
თუ მე ვიტყვი, k ტოლია ხუთ, რა ვარ მე?
ისე, მე აყენებს ხუთ ყუთში, მარჯვნივ.
ეს არის საკმაოდ მარტივია, თუ ვამბობ, რომ int k, შექმნა ყუთში მოუწოდა k.
თუ მე ვიტყვი, k შეადგენს 5, ბოლო ხუთი ყუთში.
იმედია, რომ ეს არ არის ძალიან ბევრი ნახტომი.
აქ, სადაც რამ წავიდეთ ცოტა საინტერესო, თუმცა.
თუ მე ვიტყვი, int * pk, კარგად კი, თუ მე არ ვიცით, რა ეს აუცილებლად არ ნიშნავს,
ეს აშკარად რაღაც უნდა გავაკეთოთ რიცხვი.
ასე რომ, მე ვაპირებ ფერი ეს ყუთი მწვანე-ish,
მე ვიცი, რომ რაღაც უნდა გავაკეთოთ რიცხვი,
მაგრამ ეს არ არის მთელი რიცხვი თავისთავად, იმიტომ, რომ ეს int ვარსკვლავი.
არსებობს რაღაც ოდნავ განსხვავებული შესახებ.
ასე რომ მთელი ის ჩართული, მაგრამ წინააღმდეგ შემთხვევაში ეს
არ განსხვავდება ის, რაც ჩვენ ვსაუბრობთ.
ეს ყუთი, მისი მივიღე ეტიკეტების, ის ტარება იარლიყი pk,
და ეს შეუძლია ჰოლდინგი int ვარსკვლავი, რასაც ესენი არიან.
მათ აქვთ რაღაც უნდა გააკეთოს მთელი რიცხვები, ნათლად.
აი ბოლო ხაზი თუმცა.
თუ მე ვიტყვი PK = & k, Whoa, რა მოხდა, არა?
ასე რომ, ეს შემთხვევითი ნომერი, ერთი შეხედვით შემთხვევითი ნომერი, იღებს დააგდეს შევიდა ყუთი იქ.
ყველა, რომ არის, არის pk იღებს მისამართი k.
ასე რომ, მე sticking სადაც k ცხოვრობს მეხსიერება, მისი მისამართი, მისამართი, მისი ბაიტი.
ყველა ვაკეთებ მე ვამბობ, რომ ღირებულება არის ის, რაც მე ვაპირებ
იმისათვის, რომ შიგნით ჩემი ყუთში მოუწოდა pk.
და რადგან ეს ყველაფერი პოინტერები, და რადგან ეძებს
სიმებიანი როგორიცაა ნულოვანი x რვა ნულოვანი გ შვიდი ოთხი რვა
ორი ნულოვანი, ალბათ, არ არის ძალიან მნიშვნელოვანი.
როდესაც ჩვენ, როგორც წესი, ვიზუალურად მითითებას, ჩვენ რეალურად ამის გაკეთება, როგორც მითითებას.
Pk გვაძლევს ინფორმაცია ჩვენ უნდა მოვძებნოთ k მეხსიერებაში.
ასე რომ, ძირითადად pk აქვს ისარი იგი.
და თუ ჩვენ ფეხით ხანგრძლივობა ისრის, წარმოიდგინეთ,
ეს რაღაც შეგიძლიათ სიარული, თუ ჩვენ ფეხით გასწვრივ სიგრძეზე arrow,
ძალიან წვერი რომ ისარი, ჩვენ ნახავთ განთავსების მეხსიერება
სადაც K ცხოვრობს.
და, ეს ძალიან მნიშვნელოვანია იმიტომ, რომ ერთხელ ჩვენ ვიცით, სადაც k ცხოვრობს,
ჩვენ შეგვიძლია დავიწყოთ მუშაობა მონაცემები შიგნით რომ მეხსიერებაში.
მიუხედავად იმისა, რომ ჩვენ ვიღებთ teeny ცოტა ადრე საკუთარ თავს ახლა.
>> რა არის მაჩვენებელი?
მაჩვენებელი არის მონაცემთა ნივთი, რომლის მნიშვნელობა მეხსიერების მისამართზე.
ეს იყო, რომ ნულოვანი x რვა ნულოვანი პერსონალი ხდება, რომ იყო მეხსიერებაში მისამართზე.
ეს იყო განთავსების მეხსიერებაში.
და ტიპის მაჩვენებელი აღწერს
მონაცემთა თქვენ იპოვით რომ მეხსიერების მისამართი.
ასე რომ არსებობს int ვარსკვლავი ნაწილი უფლება.
თუ მე დაიცვას, რომ ისარი, აპირებს გამოიწვიოს ჩემთვის ადგილმდებარეობა.
და რომ ადგილმდებარეობა, რაც მე ნახავთ იქ ჩემი მაგალითად,
არის მწვანე ფერის ყუთში.
ეს არის რიცხვი, რომ ის, რაც მე ნახავთ, თუ მე ამ მისამართზე.
მონაცემები ტიპის მაჩვენებელი აღწერს, თუ რა
თქვენ ნახავთ, რომ მეხსიერების მისამართზე.
ასე რომ აქ მართლაც მაგარი რამ, თუმცა.
პოინტერები საშუალებას გვაძლევს გაივლის ცვლადები შორის ფუნქციები.
და რეალურად გაივლის ცვლადები და არ გაივლის ასლები მათ.
იმიტომ, რომ თუ ჩვენ ზუსტად ვიცით, სად მეხსიერების მოძიების ცვლადი,
ჩვენ არ უნდა მიიღოს ასლი ის, რომ ჩვენ შეგვიძლია წავიდეთ, რომ ადგილმდებარეობა
და მუშაობა, რომ ცვლადი.
ასე რომ, არსებითად მითითებას სახის საქართველოს კომპიუტერულ გარემო
ბევრი უფრო რეალურ სამყაროში, მარჯვნივ.
>> ასე რომ, აქ ანალოგია.
ვთქვათ, რომ მე მაქვს ლეპტოპი, უფლება, და ეს სრული აღნიშნავს.
და მე მინდა თქვენ უნდა განაახლოს იგი.
თქვენ ხართ ფუნქცია, რომელიც განახლებები აღნიშნავს, მარჯვნივ.
ამ გზით ჩვენ უკვე სამუშაო ჯერჯერობით, რა
ხდება თქვენ მიიღებს ჩემი ნოუთბუქი, თქვენ გადადით ასლი მაღაზია,
თქვენ მიიღოს Xerox ასლი ყველა გვერდზე ნოუთბუქი.
თქვენ დავტოვებთ ჩემი ნოუთბუქი უკან ჩემს მაგიდასთან, როდესაც თქვენ გაკეთდეს,
თქვენ წავიდეთ და გადაკვეთა რამ ჩემს ნოუთბუქის რომ მოძველებულია ან არასწორი,
და მაშინ თქვენ გაივლის დაბრუნება მე დასტის Xerox გვერდები
რომ არის რეპლიკა ჩემი ნოუთბუქი ცვლილებები, რომ თქვენ გააკეთა ეს.
და იმ ეტაპზე, ეს იყო ჩემთვის, როგორც მოუწოდებდა ფუნქცია, როგორც აბონენტის,
გადაწყვიტოს, მიიღოს თქვენი შენიშვნები და მათ ინტეგრაციას ისევ ჩემი ნოუთბუქი.
ასე რომ, არსებობს ბევრი ნაბიჯები ჩართული აქ, მარჯვნივ.
ისევე, როგორც არ იქნება უკეთესი თუ მე უბრალოდ ამბობენ, hey, შეგიძლიათ
ჩემ ნოუთბუქი მე, გადასცემს თქვენ ჩემი ნოუთბუქი,
და შენ რამ და ფაქტიურად გადაკვეთა მათ
განახლება და ჩემი შენიშვნები ნოუთბუქი.
და მაშინ მაძლევს ჩემი ნოუთბუქი უკან.
ეს არის ერთგვარი რა პოინტერები საშუალებას გვაძლევს გავაკეთოთ,
ისინი ამ გარემოში ბევრი უფრო მოსწონს თუ როგორ ფუნქციონირებს რეალურად.
>> ყველა უფლება ისე, რომ ის, რაც კურსორი, მოდით ვისაუბროთ
იმაზე, თუ როგორ პოინტერები მუშაობა C, და როგორ შეგვიძლია დაიწყოს მათთან მუშაობა.
ასე რომ, არსებობს ძალიან მარტივი მაჩვენებელი დო მოუწოდა null მაჩვენებელი.
Null მაჩვენებელი რაოდენობა არაფერია.
ეს, ალბათ, როგორც ჩანს, ეს არის ფაქტობრივად, არ არის ძალიან სასარგებლო რამ,
მაგრამ, როგორც ვნახავთ, ცოტა მოგვიანებით, ის ფაქტი,
რომ ეს null მაჩვენებელი არსებობს რეალურად მოდის მოსახერხებელია.
და როდესაც თქვენ შექმნით მაჩვენებელი, და თქვენ არ მისი ღირებულება immediately-
მაგალითად შექმნის მისი ღირებულება დაუყოვნებლივ
იქნება რამდენიმე სლაიდები უკან სადაც მე ვთქვი pk ტოლია & k,
pk იღებს k მისამართი, რადგან ჩვენ დავინახავთ, რას ნიშნავს,
ჩვენ დავინახავთ, თუ როგორ კოდი, რომელიც shortly- თუ ჩვენ არ მისი ღირებულება, რომ რაღაც
მნიშვნელოვანი დაუყოვნებლივ, თქვენ ყოველთვის უნდა
მითითებული თქვენი მომცეთ აღვნიშნო, რომ null.
თქვენ უნდა მითითებული ეს აღვნიშნო, რომ არაფერი.
>> ეს არის ძალიან განსხვავებული, ვიდრე უბრალოდ ტოვებს მნიშვნელობა, რადგან ეს არის
და შემდეგ გამოცხადების მაჩვენებელი და მხოლოდ ვთქვათ,
ეს null იმიტომ, რომ იშვიათად მართალია.
ასე, რომ თქვენ ყოველთვის უნდა მითითებული ღირებულება მომცეთ
, null, თუ არ მისი ღირებულება რაღაც მნიშვნელოვანი დაუყოვნებლივ.
თქვენ შეგიძლიათ შეამოწმოთ თუ არა მაჩვენებელი ღირებულების არის null გამოყენებით თანასწორობის ოპერატორს
(==), ისევე, როგორც თქვენ შედარების ნებისმიერი რიცხვი ღირებულებები ან ხასიათი ღირებულებების გამოყენებით (==)
ისევე.
ეს არის განსაკუთრებული სახის მუდმივი მნიშვნელობა, რომელიც შეგიძლიათ გამოიყენოთ, რათა გამოსცადოს.
ასე რომ, ძალიან მარტივი მაჩვენებელი, null მაჩვენებელი.
კიდევ ერთი გზა, რათა შეიქმნას კურსორი არის ამონაწერი
მისამართი ცვლადი თქვენ უკვე შექმნილია,
და თქვენ ამ გამოყენებით და ოპერატორი მისამართი მოპოვება.
რომელ ჩვენ უკვე მინახავს ადრე პირველი სქემა მაგალითი მე აჩვენა.
ასე რომ, თუ x არის ცვლადი, რომელიც ჩვენ უკვე შეიქმნა ტიპის რიცხვი,
მაშინ და x არის მაჩვენებელი რიცხვი.
& x არის- მახსოვს, და აპირებს ამონაწერი მისამართი რამ უფლება.
მას შემდეგ, რაც კურსორი არის უბრალოდ მისამართი, მეტი და x არის მომცეთ მთელი რიცხვი
რომლის ღირებულება არის სადაც მეხსიერება x ცხოვრება.
ეს x მისამართი.
ასე რომ, და x არის მისამართი x.
მოდით ეს ერთი ნაბიჯია შემდგომი დაკავშირება და რაღაც
მე გააკეთა მინიშნება, რომ წინასწარი ვიდეო.
თუ arr მასივი ორადგილიანი, მაშინ და arr კვადრატული ფრჩხილი i მომცეთ
ორმაგი.
OK.
სია თურქეთიდან კვადრატული ფრჩხილი i, თუ arr მასივი ორადგილიანი,
მაშინ სია თურქეთიდან კვადრატული ფრჩხილი ი i-th ელემენტია, რომ მასივი,
და & სია თურქეთიდან კვადრატული ფრჩხილი i არის სადაც მეხსიერების i-ე ელემენტს arr არსებობს.
>> ასე რომ, რა მნიშვნელობა აქ?
კოლექტორები სახელი, გულისხმობს ამ მთელი რამ,
ის არის, რომ მასივი სახელი რეალურად თავად მაჩვენებელი.
თქვენ უკვე მუშაობს პოინტერები ყველა ერთად
ყოველ ჯერზე, რომ თქვენ გამოყენებული მასივი.
დამახსოვრება მაგალითზე ცვლადი ფარგლებში,
ახლოს დასასრულს ვიდეო წარმოგიდგენთ მაგალითად, სადაც ჩვენ გვაქვს ფუნქცია
მოუწოდა კომპლექტი int და ფუნქცია მოუწოდა კომპლექტი მასივი.
და თქვენი გამოწვევა, რათა დადგინდეს, თუ არა, ან რა
ფასეულობები, რომელიც ჩვენ იბეჭდება ბოლოს ფუნქცია,
ბოლოს ძირითადი პროგრამა.
>> თუ გავიხსენებთ, რომ, მაგალითად, ან თუ ვნახე ვიდეო,
თქვენ იცით, რომ როდესაც თქვენ-ზარი კომპლექტი int ეფექტურად არაფერს აკეთებს.
მაგრამ ზარის შექმნას მასივი აკეთებს.
და მე ერთგვარი დიდწილად მეტი რატომ რომ იყო შემთხვევა იმ დროს.
მე უბრალოდ ვთქვი, რომ ეს მასივი, ეს სპეციალური, თქვენ იცით, არ არსებობს მიზეზი.
ამის მიზეზი ის არის, რომ მასივი მიერ სახელი მართლაც მხოლოდ მაჩვენებელი,
და არსებობს ამ სპეციალური კვადრატული ფრჩხილი სინტაქსი, რომ
რათა რამ ბევრი გავალამაზოთ მუშაობა.
და ისინი იდეა მაჩვენებელი ბევრი ნაკლებად დაშინებას,
და ამიტომაც ისინი ერთგვარი წარმოდგენილი, რომ გზა.
მაგრამ ნამდვილად კოლექტორები მხოლოდ მითითებას.
და ამიტომაც, როდესაც ჩვენ ცვლილება მასივი,
როდესაც ჩვენ გავიდა მასივი, როგორც პარამეტრი ფუნქცია ან როგორც არგუმენტი
ფუნქცია, შინაარსი მასივი რეალურად შეიცვალა, როგორც Callee
და აბონენტის.
რომელიც ყველა სხვა სახის ცვლადი ჩვენ ვნახეთ არ იყო საქმე.
ასე რომ, უბრალოდ რაღაც შენარჩუნება იბადება, როდესაც თქვენ მუშაობა მითითებას,
ის არის, რომ სახელი და გვარი მასივი, ფაქტობრივად, მომცეთ
პირველი ელემენტი, რომელიც მასივი.
>> OK ასე რომ, ახლა ჩვენ ყველა ამ ფაქტები, მოდით შენარჩუნებას აპირებს, მარჯვნივ.
რატომ აინტერესებს სადაც რაღაც ცხოვრობს.
ისე როგორც მე ვთქვი, რომ ეს არის საკმაოდ სასარგებლო იცოდეს, სადაც რაღაც ცხოვრობს
ასე რომ თქვენ შეგიძლიათ იქ და შეცვლის.
მუშაობა და რეალურად აქვს ის, რომ თქვენ
მინდა ამის გაკეთება, რომ ცვლადი ძალაში, და არ შევა რამდენიმე ასლი.
ეს ეწოდება dereferencing.
ჩვენ წასვლა მინიშნება და შევცვალოთ ღირებულება არსებობს.
ასე რომ, თუ ჩვენ გვაქვს მაჩვენებელი და ეს ე.წ. კომპიუტერი, და ეს მიუთითებს, რომ ხასიათი,
მაშინ შეგვიძლია ვთქვათ * კომპიუტერი და * pc არის სახელი, რაც ჩვენ იპოვით, თუ ჩვენ
მითითებულ მისამართზე pc.
ის, რასაც ჩვენ იპოვით არსებობს ხასიათი და * pc არის, თუ როგორ ეხება მონაცემები, რომ
ადგილმდებარეობა.
ასე რომ, ჩვენ შეიძლება ითქვას, რაღაც * pc = D ან რამე მაგდაგვარს,
და ეს ნიშნავს, რომ რაც არ უნდა იყო მეხსიერების მისამართი pc,
რასაც გმირი იყო ადრე იქ, ახლა D, თუ ვამბობთ * pc = D.
>> ასე რომ, აქ ჩვენ კვლავ ერთად რაღაც უცნაური C პერსონალი, მარჯვნივ.
ასე რომ, ჩვენ ვნახეთ * ადრე, როგორც როგორღაც ნაწილი მონაცემები ტიპის,
და ახლა ის გამოიყენება ოდნავ სხვა კონტექსტში
წვდომის მონაცემები ადგილმდებარეობა.
მე ვიცი, რომ ეს ცოტა გაუგებარია და რომ რეალურად ნაწილი მთელი ეს
, რატომ მითითებას აქვს ამ მითოლოგია მათ გარშემო, როგორც იმდენად რთული,
სახის syntax პრობლემა, პატიოსნად.
მაგრამ * გამოიყენება როგორც კონტექსტში, როგორც ნაწილი ტიპის სახელი,
და ვნახავთ ცოტა შემდეგ რაღაც, ძალიან.
და ახლა არის dereference ოპერატორი.
ასე რომ, ის მიდის მინიშნება, ის იღებს მონაცემებს
ადგილმდებარეობის მაჩვენებელი, და გაძლევთ საშუალებას მანიპულირება სურვილისამებრ.
>> ახლა ეს ძალიან ჰგავს გამოჩენის თქვენი მეზობელი, მარჯვნივ.
თუ თქვენ არ იცით მეზობელი ცხოვრობს, თქვენ
არ დაკიდებული თქვენი მეზობელი.
თქვენ იცით, რომ თქვენ არ უნდა ვიცი, სადაც ისინი ცხოვრობენ,
მაგრამ ეს არ ნიშნავს, რომ ძალით, რომელსაც, რომ ცოდნა
თქვენ ინტერაქციაში მათ.
თუ გსურთ ურთიერთქმედება მათ, თქვენ უნდა წავიდეს საკუთარი სახლი,
თქვენ უნდა წავიდეს, სადაც ისინი ცხოვრობენ.
და კიდევ თქვენ, რომ, მაშინ თქვენ შეგიძლიათ ურთიერთქმედება
მათ ისევე, როგორც თქვენ მინდა.
და ანალოგიურად ცვლადები, თქვენ უნდა წასვლა მათი მისამართი
თუ გსურთ ურთიერთქმედება მათ, თქვენ არ შეგიძლიათ უბრალოდ ვიცი მისამართზე.
და ისე წასვლა მისამართი გამოყენება *, dereference ოპერატორი.
როგორ ფიქრობთ, რა ხდება თუ ჩვენ ვცდილობთ და dereference
მაჩვენებელი, რომლის ღირებულება არის null?
შეგახსენებთ, რომ null მაჩვენებელი მიუთითებს, რომ არაფერი.
ასე რომ, თუ თქვენ ცდილობენ და dereference არაფერი ან გადადით მისამართზე არაფერი,
როგორ ფიქრობთ რა ხდება?
ისე, თუ მიხვდა, სეგმენტაცია ბრალია, ნეტავ იყოს სწორი.
თუ თქვენ ცდილობენ და dereference null მაჩვენებელი,
თქვენ განიცდიან სეგმენტაცია ბრალია. მაგრამ დაველოდოთ,
არ მინდა, გითხრათ, რომ თუ თქვენ არ აპირებს
მითითებული თქვენი ღირებულება თქვენი მომცეთ რაიმე მნიშვნელოვანი,
თქვენ უნდა მითითებული null?
მე და რეალურად სეგმენტაცია ბრალი არის ერთგვარი კარგი საქციელი.
>> ოდესმე განაცხადა ცვლადი და არ არის დანიშნული, მისი ღირებულება მაშინვე?
ასე, რომ თქვენ, უბრალოდ, ვამბობთ int x; თქვენ არ რეალურად მივანიჭოთ მას არაფერი
და შემდეგ მოგვიანებით თქვენი კოდი, თქვენ ამობეჭდოთ ღირებულება x,
რომელსაც ჯერ კიდევ არ არის ენიჭება მას არაფერი.
ხშირად თქვენ მიიღებთ ნულოვანი, მაგრამ ზოგჯერ
შესაძლოა, შემთხვევითი ნომერი, და თქვენ არ ვიცი, სადაც იგი მოვიდა.
ანალოგიურად შეუძლია რამ მოხდება მითითებას.
როდესაც თქვენ გამოაცხადოს მაჩვენებელი int * pk მაგალითად,
და თქვენ არ მივანიჭოთ მას მნიშვნელობა, თქვენ ოთხი ბაიტი მეხსიერება.
როგორიც არ უნდა იყოს ოთხი ბაიტი მეხსიერების სისტემას შეუძლია
ნახავთ, რომ აქვს რამდენიმე მნიშვნელოვანი ღირებულება.
და არ შეიძლება ყოფილიყო რაღაც უკვე არსებობს, რომ
აღარ არის საჭირო სხვა ფუნქცია, ასე რომ თქვენ უბრალოდ უნდა
რასაც მონაცემები იყო.
>> რა მოხდება, თუ თქვენ სცადა ამის გაკეთება dereference ზოგიერთი მისამართზე, რომელიც თქვენ don't- იყო
უკვე bytes და ინფორმაციის არსებობს, რომ ახლა თქვენს მაჩვენებელი.
თუ თქვენ ცდილობენ და dereference რომ მომცეთ, თქვენ შეიძლება ძვირფასი გარკვეული მეხსიერება
რომ არ აპირებს სასადილო ერთად ეს ყველაფერი.
და რეალურად თქვენ ვერ გააკეთებს მართლაც რაღაც დამანგრეველი,
ისევე როგორც დაარღვიოს სხვა პროგრამა, ან შესვენება სხვა ფუნქცია,
ან რაიმე მუქარის, რომ თქვენ არ აპირებენ ამის ყველა.
და ისე, რომ, თუ რატომ არის რეალურად კარგი იდეა
მითითებული თქვენი მითითებას null თუ არ მითითებული მათ რაღაც მნიშვნელოვანი.
ეს, ალბათ, უკეთ დღის ბოლოს თქვენი პროგრამა
ავარიის შემდეგ ეს უნდა გააკეთოს ის, რომ ხრახნები
კიდევ ერთი პროგრამა ან სხვა ფუნქცია.
ეს საქციელი ალბათ კი ნაკლებად იდეალური, ვიდრე უბრალოდ crashing.
და ისე, რომ, თუ რატომ არის რეალურად კარგი ჩვევა
შეღწევას შექმნას თქვენი პოინტერები , null, თუ არ შეიქმნა მათ
სრულფასოვანი მნიშვნელობა დაუყოვნებლივ, მნიშვნელობა, რომ თქვენ იცით,
და რომ თქვენ შეგიძლიათ უსაფრთხოდ dereference.
>> მოდით ახლა და შევხედოთ საყოველთაო სინტაქსი სიტუაცია.
თუ მე ვიტყვი, int * p ;, რა მე უბრალოდ გაკეთდეს?
რა მე ვაკეთებ ამ.
მე ვიცი, ღირებულება p არის მისამართი იმიტომ, რომ ყველა მითითებები მხოლოდ
მისამართები.
შემიძლია dereference p გამოყენებით * ოპერატორი.
ამ კონტექსტში აქ, ძალიან დაბრუნება გავიხსენოთ * ნაწილია ტიპის.
Int * მონაცემები ტიპის.
მაგრამ მე შემიძლია dereference p გამოყენებით * ოპერატორი,
და თუ მე ამის გაკეთება, თუ მე რომ მისამართი, რა იქნება მე რომ მისამართი?
მე ნახავთ რიცხვი.
ასე int * p ძირითადად ამბობდა, p არის მისამართი.
შემიძლია dereference p და თუ მე, მე ნახავთ რიცხვი
რომ მეხსიერებაში.
>> OK, ასე ვთქვი, იქ იყო კიდევ ერთი შემაშფოთებელი რამ ვარსკვლავს
და აქ, სადაც, რომ შემაშფოთებელი რამ ვარსკვლავს.
ოდესმე ცდილობდა განაცხადოს მრავალი ცვლადი იგივე ტიპის
იმავე ხაზი კოდი?
ასე რომ, მეორე, ვიტყვი, რომ ხაზი, კოდი მე რეალურად იქ მწვანე
იქ არ არის და ეს უბრალოდ ამბობს int x, y, z ;.
რა, რომ ყველაფერს გააკეთებს, ფაქტობრივად შექმნა სამი მთელი ცვლადები თქვენთვის,
ერთი მოუწოდა x, ერთი ე.წ. y, და ერთი მოუწოდა z.
ეს არის გზა ამის გარეშე რომელსაც გაყოფილი გადატანა სამი ხაზი.
>> აი, სადაც ვარსკვლავები მისაღებად შემაშფოთებელი ერთხელ, თუმცა,
იმის გამო, რომ * ფაქტიურად ნაწილი ორივე ტიპის სახელი და ნაწილი
ერთი ცვლადის სახელი.
ასე რომ, თუ მე ვიტყვი, int * px, py, PZ, რაც მე რეალურად კიდევ არის მომცეთ მთელი რიცხვი
მოუწოდა px და ორი რიცხვებით, py და PZ.
და ეს, ალბათ, არ არის რა ჩვენ გვინდა, რომ ეს არ არის კარგი.
>> ასე რომ, თუ მინდა, რომ შევქმნათ მრავალი პოინტერები იგივე ხაზი, ერთი და იმავე ტიპის,
და ვარსკვლავები, რაც მე რეალურად უნდა უნდა ვთქვა int * pa, * pb * pc.
ახლა რომელმაც მხოლოდ ის განაცხადა, რომ და ახლა თქვენ გეტყოდით,
თქვენ, ალბათ, არასოდეს ამის გაკეთება.
და ეს, ალბათ, კარგია პატიოსნად, იმიტომ, რომ თქვენ შეიძლება უნებლიედ
გამომრჩეს ვარსკვლავი, რაღაც მსგავსი.
ეს, ალბათ, საუკეთესო შესაძლოა განაცხადოს მითითებას ინდივიდუალური ხაზები,
მაგრამ ეს მხოლოდ კიდევ ერთი იმ უსიამოვნოს სინტაქსი
რამ ვარსკვლავები, რომ პოინტერები ასე რთული მუშაობა.
იმის გამო, რომ ეს მხოლოდ ამ სინტაქსური სასადილო თქვენ უნდა ვიმუშაოთ მეშვეობით.
ერთად პრაქტიკა, ეს იმას მართლაც გახდეს მეორე ბუნების.
მე მაინც, რათა შეცდომები, ეს ჯერ კიდევ მას შემდეგ, რაც პროგრამირების 10 წლის განმავლობაში,
ასე არ უნდა დაარღვიოს თუ რამე მოხდება თქვენ, ეს არის საკმაოდ გავრცელებული პატიოსნად.
ეს მართლაც სახის ხარვეზი სინტაქსის.
>> OK ამიტომ ასეთი პირობა დადო , რომ ჩვენ დავუბრუნდეთ
კონცეფცია, თუ როგორ დიდი სიმებიანი.
ისე, თუ მე ვუთხარი, რომ სიმებიანი, ჩვენ მართლაც სახის
უკვე ცრუობს თქვენ მთელი დრო.
არ არსებობს მონაცემები ტიპის მოუწოდა სიმებიანი და სინამდვილეში მე
აღნიშნული ამ ჩვენი ერთ-ერთი ადრეული ვიდეო მონაცემთა ტიპები,
რომ სიმებიანი მონაცემები ტიპის რომ შეიქმნა თქვენთვის cs50.h.
თქვენ უნდა შეიცავდეს CS50.h, რათა გამოიყენოს იგი.
>> ისე string მართლაც მხოლოდ იგივე რაღაც
მოუწოდა char *, რომელიც მომცეთ ხასიათი.
ისე მითითებას, გავიხსენოთ, არის მხოლოდ მიმართავს.
ასე რომ, რა არის ზომა ბაიტი სიმებიანი?
ისე ეს ოთხი ან რვა.
და მიზეზი მე ვიტყვი, ოთხი ან რვა იმიტომ, რომ ეს რეალურად
დამოკიდებულია სისტემა, თუ თქვენ იყენებთ CS50 ide, char * არის ზომა char
* რვა, ეს არის 64-bit სისტემა.
ყველა მისამართი მეხსიერებაში არის 64 ბიტი ხანგრძლივი.
თუ თქვენ იყენებთ CS50 ელექტრო მოწყობილობების ან ნებისმიერი 32-bit მანქანა,
და თქვენ მოვისმინე, რომ ტერმინი 32-bit მანქანა, რა არის 32-bit მანქანა?
ისე ეს მხოლოდ იმას ნიშნავს, რომ ყოველ მისამართი მეხსიერებაში არის 32 ბიტი ხანგრძლივი.
ასე რომ, 32 ბიტი არის ოთხი ბაიტი.
ასე რომ, char * არის ოთხი ან რვა bytes დამოკიდებულია თქვენს სისტემაში.
და მართლაც ნებისმიერი მონაცემთა ტიპები, და მომცეთ რაიმე მონაცემები
ტიპის, მას შემდეგ, რაც ყველა მითითებები მხოლოდ მისამართები, ოთხი ან რვა ბაიტს.
მოდით დავუბრუნდეთ ამ გრაფიკაზე და მოდით დავასკვნათ
ეს ვიდეო ცოტა სწავლება აქ.
ასე რომ აქ სქემა ჩვენ შეჩერდით ერთად თავიდანვე ვიდეო.
ასე რომ, რა ხდება ახლა, თუ მე ვიტყვი, * pk = 35?
ასე რომ, რას ნიშნავს, როცა ამბობენ, * pk = 35?
მიიღეთ მეორე.
* pk.
ამ კონტექსტში აქ, * არის dereference ოპერატორი.
ასე რომ, როდესაც dereference ოპერატორი გამოიყენება,
ჩვენ წასვლა მისამართი აღნიშნა, რომ მიერ pk და შევცვლით იმას, რაც ჩვენ.
ასე * pk = 35 ეფექტურად ჯერ ეს სურათი.
ასე რომ, ძირითადად სინტაქსურად იდენტურია, რომელმაც განაცხადა, k = 35.
>> კიდევ ერთი.
თუ მე ვიტყვი, int მ, შევქმნა ახალი ცვლადში მ.
ახალი ყუთი, მწვანე ყუთი იმიტომ, ის აპირებს გამართავს მთელი,
და ეს შეაფასა, მ.
თუ მე ვიტყვი, m = 4, მე ბოლო მთელი შევიდა, რომ ყუთში.
თუ ვთქვათ PK = & m, როგორ ეს სქემა ცვლილება?
PK = & m, თქვენ გავიხსენოთ, თუ რა და ოპერატორი აკეთებს და ჰქვია?
გახსოვდეთ, რომ & ზოგიერთი ცვლადის სახელი არის მისამართი ცვლადის სახელი.
ასე რომ, რასაც ჩვენ ვამბობთ, არის pk იღებს მისამართი მ.
ასე რომ, ეფექტურად, თუ რა ხდება სქემა არის, რომ პკ აღარ რაოდენობა
ხვ, მაგრამ რაოდენობა მ.
>> ისევ მითითებას ძალიან სახიფათო მუშაობა
და ისინი ბევრი პრაქტიკა, არამედ იმიტომ, რომ
მათი უნარი საშუალებას გაძლევთ გაივლის მონაცემები ფუნქციები
და რეალურად იმ ცვლილებები ძალაში,
მიღების თქვენი უფროსი გარშემო მართლაც მნიშვნელოვანია.
ეს, ალბათ, ყველაზე რთული თემის განვიხილავთ CS50,
მაგრამ ღირებულება, რომ თქვენ მიიღონ გამოყენებით პოინტერები
აჭარბებს გართულებები რომ მოდის სწავლის მათ.
ასე რომ, გისურვებთ საუკეთესო გისურვებთ სწავლის შესახებ მითითებას.
მე Doug Lloyd, ეს არის CS50.