>> [Theme Music]
>> დინამიკები 1: Hi, ყველას.
მივესალმებით თავში მონაკვეთზე.
კერეონი out-- რის გამოც, მე რა თქმა უნდა, არსებობს მხოლოდ ოთხი თქვენ აქ
და არა ჩვენი ჩვეულებრივი პაკეტი.
მე უკვე ავადმყოფი ამ კვირის ბოლოს.
ასე რომ, მე არ მაქვს Starburst თქვენ ბიჭები.
და მე შეიძლება დაიწყოს ხველა საშინლად მთელი ამ.
ასე რომ მხოლოდ აგებს ჩემთან ერთად.
მე ვაპირებ ნამდვილად ცდილობენ და მიიღეთ მეშვეობით პირველი,
თუმცა, ადრე მაქვს ხველა თავდასხმა.
მაგრამ მხოლოდ უნდა ადვილი ჩემთვის პატარა bit-- რომ ყველა ვთხოვ.
>> ასე რომ, ჩვენი დღის წესრიგი today-- მხოლოდ reminder-- თქვენი ვიქტორინა მომავალ კვირას.
მე ვუთხარი, გასულ კვირას, ასე რომ არ დაიჭიროთ თქვენ off მცველი.
ასე რომ, მე ახსენებს კიდევ ერთხელ.
მომავალ კვირას თქვენი ვიქტორინა.
ამ მიზნით, მომავალ კვირაში სექციაში იქნება ბევრად უფრო
of-- ვეცდები და მუშაობის ზოგიერთი მიმოხილვა.
ასე რომ, თუ თქვენ ბიჭები შეიძლება დამეხმაროთ გაგზავნით me
რამ, რომ თქვენ კომფორტულად ერთად, რომელიც თქვენ აწუხებს,
თემა, რომ გსურთ მე დასაფარავად, რომ მინდა იყოს დიდი.
ასე რომ, შემიძლია ცდილობენ და მუშაობა მათ ჩვენი სექცია მომდევნო კვირას
ან გამოგიგზავნით დამატებითი მასალა და მოსამზადებელი რომ თქვენ შეიძლება არ მიიღოთ სხვაგან.
>> ჰო!
უფრო მეტი ადამიანი მოდის!
მეგონა, გავაკეთო, რომ ცუდად ბოლო კვირას, რომ არავის არ სურს დავბრუნდებით?
მე შეშინებული.
ასე რომ, სხვა სამი რამ რომ ჩვენ ვაპირებთ წასვლა მეტი
არის გადამისამართება, ფაილის I / O და მაშინ პოინტერები და დინამიური მეხსიერების.
დარწმუნებული ვარ, თქვენ ყველა super აღელვებს პოინტერები ყველას საყვარელი თემაზე,
ასე მარტივი გასაგებია.
დარწმუნებული ვარ, ბიჭები ყველანი, არა?
>> ასე რომ, პირველი, რაც, პირველ რიგში, redirection-- ეს არის ძირითადად, მხოლოდ გზა
გაკონტროლება, თუ როგორ input რამ თქვენს პროგრამაში,
თუ როგორ გამომავალი რამ თქვენი პროგრამა.
მთავარი გზა, რომ თქვენ ბიჭები უკვე ინტერაქციაში ეს
არის მხოლოდ მეშვეობით სტანდარტი თქვენი print screen აქ.
მაგრამ არსებობს გზები, რათა pipe-- როგორც ვხედავთ აქ
ჩვენი ერთ-ერთი words-- სახის მილის, რომ ინფორმაცია
ან, რომ მონაცემების ფაილი ფაილი.
ეს მხოლოდ სხვადასხვა გზები მიღების რამ თქვენი პროგრამა
და შენი პროგრამის ნაცვლად, მხოლოდ დაბეჭდვის მათ ამ ეკრანზე
ან შესაყვანი რამ საწყისი ბრძანებათა სტრიქონიდან.
>> ასე რომ, პირველი ერთი პატარა მეტია caret.
ასე output-- ეს უბრალოდ ბეჭდავს გამომავალი to მაგივრად თქვენს ეკრანზე.
ასე რომ, თუ რამე ჰქონდა, ბეჭდვითი "Hello, World!" ეკრანზე,
თუ თქვენ დააყენა ის ნაცვლად to output.text, რომელიც
ქმნის ამ ფაილის მოუწოდა output.text.
და როცა გახსნა, ის ყველაფერს ამბობენ, რომ "Hello, World!" იქ.
ეს შეიძლება იყოს სუპერ სასარგებლო თუ თქვენ გაქვთ ტონა შეცდომები
რეალურად, როგორც ვხედავთ, ეს ერთი.
თუ თქვენ აკეთებთ ორი caret, ის ყველაფერს ბეჭდვა შეცდომა შეტყობინებები.
>> ასე რომ, თუ თქვენ მქონე პრობლემა შედგენა, მას აქვს ბევრი შეცდომები
და თქვენ მისაღებად bogged ქვემოთ ცდილობს გადახვევა მეშვეობით თქვენი command line
ყველა მათგანი, თქვენ შეგიძლიათ უბრალოდ ამობეჭდოთ მათ ფაილი,
ქმნის, რომ ფაილი, ასე რომ თქვენ შეგიძლიათ გადახვევა მეშვეობით მათ ადვილია.
მე რეალურად ათვისებულ, რომ ბევრი როდესაც მე გამართვის
ჩემი 181 psets მანქანა სწავლის.
ასე რომ, ეს შეიძლება იყოს სუპერ სასარგებლო მოგვიანებით.
ეს ასევე სასარგებლოა, თუ თქვენ გაქვთ პროგრამა რომ იქნებ მომტანი ბიბლიოთეკა
მომტანი მითითებული სიმები, და თქვენ
უნდა ნახოს, რომ ის გამოიმუშავებს სთხოვენ.
ეს არის გზა ამის გაკეთება.
>> ასე რომ, თუ თქვენ ბეჭდვა მათ ფაილი, უფრო ადვილად შეისწავლის მათ, არა?
წინააღმდეგ ცდილობს გადახვევა მეშვეობით ბრძანებათა ზოლში.
და მაშინ ერთი რამ აღვნიშნო, ის არის, რომ მხოლოდ დიდი
მეტი caret, თუ წერს ფაილი, რომელიც უკვე exists--
ამიტომ მინდა, თუ ჩვენ გაიქცა ამ პირველი დროს, ჩვენ, რომ ეს output.text,
და მაშინ ჩვენ გვქონდა მეორე პროგრამა რომ ნაბეჭდი ამ პროგრამის ორი
და გააკეთეს დიდი, ვიდრე output.text, იგი ჩაანაცვლებს that-- ასე
გადავაწერო რა იყო ოდესმე რომ ფაილი უნდა დაიწყოს.
>> ასე რომ, თუ გვინდა დამატება ფაილი, როგორც ვხედავთ, აქ,
უბრალოდ ორ მეტია ნიშნები.
და ეს დამატება მას.
ეს არ ჩაანაცვლებს მას.
ასე რომ, თუ თქვენ უნდა აწარმოებს სხვადასხვა პროგრამები და სახის შენარჩუნება
სიმღერა რა ყველა მათგანი დაბრუნების თქვენს ფაილი,
ეს გზა ამის გაკეთება.
თუ არ მაინტერესებს, რა არის თქვენი ფაილი და ეს დასაშვებია ინსტალერის
თქვენ შეგიძლიათ გამოიყენოთ მხოლოდ ერთი მეტი.
ამჯამად რომ აზრი ყველას?
>> აუდიტორია: Like dot slash მიესალმები მეტი მეტი გამომავალი dot ტექსტი, როგორც ორჯერ,
ეს უბრალოდ მხოლოდ აჩვენებს გამომავალი dot ტექსტი მეორე time--
>> დინამიკები 1: Right.
ასე რომ, ძირითადად, მხოლოდ სრულიად გადავაწერო რა იყო იქ უნდა დაიწყოს.
თუ ამ ფაილის აქ, output.text უკვე
არსებობს, ძირითადად, რასაც თქვენ ეძახით რომ კიდევ ერთხელ ერთი დიდი
შეგიძლიათ, ვიდრე უბრალოდ ვფიქრობ, რომ ეს როგორც მინდა, ის შეცვალა ფაილი.
ასე, როდესაც თქვენ გადარჩენის სიტყვა დოკუმენტის და თქვენ არ გადარჩენა, როგორც,
და თქვენ გაქვთ იგივე სახელი და ის მთლიანად overwrites it--
ეს არის იგივე რამ.
ვინმეს გაქვთ რაიმე შეკითხვები უბრალოდ outputting to ფაილი?
გასაოცარია.
>> ასე რომ, ცხადია, თუ დავამარცხებთ arrow მიმართულებით, მას შეუძლია გააკეთოს შეყვანა.
ასე რომ, როდესაც თქვენ ბიჭები როგორც კეისრის ან Visioneer
და თქვენ უნდა input რაღაც, თქვენ ჰქონდა ბრძანება ხაზი არგუმენტი
რომ რეალურად შეყვანის.
ეს არის კიდევ ერთი გზა ამის გაკეთება.
ასე რომ, ნაცვლად ელოდება ბრძანება სწრაფი,
ასე, როდესაც თქვენ სთხოვა თქვენი გაგზავნა Caesar ან Visioneer,
თუ თქვენ არ ჰქონდა ტექსტური ფაილი რომ ჰქონდა თქვენს გაგზავნა,
შეეძლო უბრალოდ აკრიფოთ შევიდა, რომ.
>> ასე რომ, თუ ეს იყო, როგორც dot slash Caesar 3 ზე ნაკლები arrow input ტექსტი, რომელიც
თქვენი გზავნილი იმისა, რომ აწარმოებს მხოლოდ ჯარიმა.
როდესაც თქვენი Caesar პროგრამის რეალურად სთხოვა შეყვანის შესახებ,
ეს იქნებოდა უკვე აქვს, რადგან თქვენ აკრეფილი ამ ფაილის.
ეს კიდევ ერთი გზა.
მხოლოდ საპირისპირო output-- უბრალოდ შეყვანის თქვენი მონაცემები.
>> და შემდეგ ბოლო ერთი მილსადენი.
ასე რომ, ეს ერთი საკმაოდ cool.
იმიტომ, რომ ეს საშუალებას გაძლევთ მიიღოს გამომავალი ერთი
პროგრამა და მას, როგორც შემავალი სხვა პროგრამა.
მე არ ვიცი, თუ თქვენ ითამაშა, რომელზეც Decipher
რომ CS50, შესაძლოა, მოცემული, მაგრამ ეს არ
გაძლევთ საშუალებას მიიღოს ზოგიერთი ნიმუში ფაილი, ჩაწერეთ იგი თქვენს დაშიფვრის,
და შემდეგ იქიდან ტიპი რომ თქვენს დეშიფრაციის
დარწმუნდით, რომ იგი აღმოჩნდა იგივე.
ასე რომ, ეს სახის მოსწონს სამი გზა loop.
წავიდეთ ეს.
>> აუდიტორია: თუ პროგრამა მრავლობითი საშუალებებით,
არის გზა ვუთხრა ის, რომელიც input გამოიყენოთ ტექსტური ფაილი ან გამომავალი?
>> დინამიკები 1: მას აქვს მრავალი საშუალებებით.
რაც არ უნდა შეიტანოს თქვენი შეყვანა, როდესაც ის ითხოვს შეტანის პირველად, ის
შეითავსებს, მე ვფიქრობ, რომ ეს აპირებს მილის მთელი ფაილი.
ასე რომ, თუ თქვენ გაქვთ მრავალჯერადი საშუალებებით, თქვენ იქნება წამოვიდეს რამოდენიმე ფაილი.
ასე რომ, თუ თქვენ ითხოვს შეტყობინებები სამჯერ თქვენი კოდი,
თქვენ აპირებს აყენებს სამი სხვადასხვა ფაილები.
და იგი იღებს გიჟები.
და თქვენ არ უნდა ფიქრი, რომ ახლა.
მაგრამ ეს იდეა.
>> ისე ჰო, მილის არის მხოლოდ გამომავალი ერთი პროგრამა იყენებს შეყვანის სხვა.
ყველას კარგი არსებობს?
ზემოთ.
OK.
თქვენ ალბათ არ ექნება ძალიან ბევრი რამის გაკეთება მას.
მაგრამ უნდა გვესმოდეს, გზები შეგიძლიათ გამოიყენოთ ეს.
და არის შემთხვევები, რომ თქვენ ალბათ გინდათ გამოიყენოთ იგი.
>> ასე შეიტანოს I / O-- მე ვიცი, რა თქვენ saying-- ჩვენ გამოიყენება კითხულობს
და წერილობით ჩვენი ეკრანზე იქ, რაც სტანდარტული და სტანდარტული გარეთ.
და ის, რაც თქვენ ბიჭები არ ყოფილა აკეთებს წლის დასაწყისიდან კლასის აქ.
მაგრამ თქვენ ასევე შეგიძლიათ წაიკითხოთ და დაწეროთ ფაილი, რომელიც ყველა ფაილის I / O-- ასე ფაილი შეყვანა,
გამომავალი არის ყველა ის დგას.
ასე რომ, ეს ნიშნავს იმას, რომ თქვენ შეგიძლიათ შეინახოთ თქვენი მონაცემები ახლა.
>> როდესაც თქვენ მხოლოდ ბეჭდვა ეს ეკრანზე, ის ძირითადად წავიდა, არა?
როგორც კი თქვენ მიიღოს "Hello მსოფლიოს "და პერსპექტივაში" Hello world "
იგი ბეჭდავს "Hello World" ეკრანზე.
მაგრამ თქვენ ნამდვილად ვერ გავაკეთებ არაფერი იქიდან.
თუ შესანახად ტექსტი ფაილი, შემდეგ მოულოდნელად
თქვენ ეს მონაცემები, რომ თქვენ საშუალება მანიპულირება ან დააყენოს ის ფაილი,
ან დააყენოს ის პროგრამის შემდეგ.
ერთ-ერთი მიზეზი რატომ ვაკეთებთ ამას, უბრალოდ
როგორც გზა შესანახად მონაცემები მოგვიანებით გამოყენება.
>> მე მაქვს რამდენიმე ნაბიჯი აქ უბრალოდ გავლით სტანდარტული
I / O. ნაბიჯი ერთი, თქვენ უნდა შექმნას მინიშნება
ფაილი ყველა caps ფაილი ვარსკვლავი ფაილი.
ისე, რომ ქმნის მაჩვენებელი ფაილი.
ასე შემდეგ გსურთ გახსნა.
და თქვენ ამბობთ, რომ, ფაქტიურად, უბრალოდ ფაილი შეადგენს fopen.
და ეს დაბრუნებას აპირებს მომცეთ ფაილი უბრალოდ გახსნა.
ვნახე რამოდენიმე თქვენ ბიჭები საათებში.
>> მაგრამ ერთი რამ არის გვახსოვდეს პოინტერები
შეიძლება გარკვეული მისამართი ან null, არა?
თუ ჩვენ ოდესმე გვაქვს საქმე, სადაც რაღაც შეიძლება შეიცვალოს null,
რას უნდა გავაკეთოთ სანამ ჩვენ ოდესმე გამოყენება?
ჩვენ უნდა შევამოწმოთ, თუ ეს null ან არ, არა?
რადგან თქვენ შეიძლება არ ჰქონდა საკითხი, სადაც, რასაც ობიექტი
იყო დაბრუნდა წარმოუდგენელი იყო null.
თქვენ ცდილობდა ასრულებს ზოგიერთი ფუნქციის იგი.
და თქვენს კომპიუტერში საიტი გააკრიტიკა.
არა?
მე დადებს რამდენიმე თქვენ შეიძლება არ ჰქონდა, რომ ამ საკითხთან დაკავშირებით.
>> ასე fopen, fopen იქნება ან დაბრუნების მაჩვენებელი ფაილი,
ან თუ რამე მიდის არასწორი, ის დაბრუნებას აპირებს null.
ასე რომ თქვენ ყოველთვის უნდა შეამოწმოს ის, რომ არ დაბრუნდა null
სანამ ცდილობენ არაფერი.
ეს არის როგორც სტანდარტული პარადიგმა რომ თქვენ ვაპირებთ გვჭირდება აქ.
თუ არსებობს ოდესმე შანსი, რომ რაღაც დაბრუნებას null,
შეამოწმეთ დარწმუნდით, რომ იგი არ სანამ გაგრძელება.
წინააღმდეგ შემთხვევაში, თქვენ აპირებს მისაღებად მშვენიერი საიტი ხარვეზებით.
და არავის არ მოსწონს გამკლავება იმ.
>> ასე რომ, როგორც ვხედავთ, პირველი არგუმენტი მხოლოდ ფაილის გეზი.
თუ ეს ფაილი არ არსებობს, ის აპირებს შექმნას ფაილი.
და ეს მხოლოდ იქნება ცარიელი.
და მაშინ მეორე არგუმენტი არის რეჟიმი, რომელიც გსურთ.
გვინდა, რომ წაკითხვის ამ ფაილის?
გინდათ დაწერა ეს?
გინდათ დამატება?
ასე რომ, რეალურად, რაც მე said-- თუ ფაილი არ არსებობს
და თქვენ ცდილობთ წაკითხვა ეს, ის აპირებს იმისათვის, რომ შეცდომა.
თუ ფაილის name-- მინდა თუ file.text ჯერ არ არსებობს
და გსურთ დაწეროთ ის, რომ ეს შევქმნით
ცარიელი ფაილი სახელად file.text თქვენთვის.
და თუ გვინდა დამატება, თქვენ უნდა გავაკეთოთ იგივე.
ამჯამად რომ აზრი?
თუ თქვენ ცდილობთ წაკითხვა ფაილი, რომელიც ჯერ არ არსებობს,
ეს სახიფათოა შეცდომა.
წინააღმდეგ შემთხვევაში, ეს ფაილის შექმნა თქვენ რა გსურთ იგი.
ზემოთ.
ახლა ჩვენ შეგვიძლია წაკითხვის ფაილი.
და ეს მხოლოდ სახის აპირებს მეშვეობით სხვადასხვა ფუნქციები
რომ ჩვენ გვაქვს ამისთვის ფაილის I / O. ეს ნება საჭირო იქნება ამ კვირის pset,
თუ სწორად მახსოვს.
დიახ, ეს სრულიად იქნება აუცილებელია ამ კვირის pset.
ამიტომ fgetc დააბრუნებს შემდეგი ხასიათი.
fgets მხოლოდ ბრუნდება ტექსტი.
იგი დაბრუნდება არაფერი მდე ახალი ხაზი, და ეს იქნება შესვენება.
ამიტომ fread ნათქვამია გარკვეული ბაიტების რაოდენობას და ადგილებში მათ
მასივი, რომელიც რაღაც თქვენ შეიძლება
გსურთ, რომ ხელახლა ზომა შეიძლება იყოს სასარგებლო.
>> რამდენი ადამიანი წაიკითხავს pset Spec, სხვათა შორის?
OK.
[INAUDIBLE]
>> დინამიკები 1: OK.
ყველა უფლება.
აუცილებლად წაიკითხონ that-- ეს fun pset.
თქვენ უნდა ფეხზე წაშლილი მეხსიერების ბარათი მართლაც საინტერესო, როდესაც ის მუშაობს.
მაგრამ ნამდვილად, დაიწყოს კითხულობს, რომ.
მოვიდა გაიგო ჩემთვის თუ გაქვთ შეკითხვები შესახებ.
>> OK, ასე რომ, როგორც მე ამბობდა, fread ნათქვამია გარკვეული რაოდენობის ბაიტი.
რომ ზოგიერთი თვითნებური რაოდენობა რომ თქვენ აპირებს შექმნას.
და შემდეგ fseek უბრალოდ გადადის გარკვეული პოზიცია.
იქნებ არ აინტერესებს მომდევნო 10 ბაიტი.
თქვენ უბრალოდ უნდა გამოტოვოთ ელის.
თქვენ არ აღელვებს იმ.
გსურთ წაკითხული დაწყებული byte 11.
fseek საშუალებას გაძლევთ ამის გაკეთება.
ასე რომ, ეს გაძლევთ საშუალებას შერჩევით თუ რას კითხულობს.
იმის გამო, რომ fgetc, fgets და fread წაკითხული გარკვეული ადგილი ფაილი.
>> გზა ვიფიქროთ, რომ ეს არის, თუ ეს ჩვენი ფაილი, როდესაც თქვენ გახსნა,
თქვენ უნდა ამ თანამდებობაზე ფაილი რომელიც იწყება დასაწყისში.
როცა მოვუწოდებთ fgetc, fgetf, ან fread,
ის აპირებს დაიწყოს ამ თანამდებობაზე მარკერი.
მოდით ვთქვათ, თქვენ უბრალოდ უნდა წაიკითხოთ ბლოკი მეხსიერება აქ.
თქვენ არ შეგიძლიათ უბრალოდ დარეკოთ.
თქვენ უნდა ვეძებოთ მეტი აქ და მერე წავიკითხე იქიდან
ან წაიკითხა, იღებს, ან getc, დამოკიდებულია რა გსურთ.
ასე რომ შეეცდება მხოლოდ გაძლევთ საშუალებას გაფართოებული ნაწილი მეხსიერება.
და ეს მხოლოდ გზა შეგიძლიათ გამოტოვოთ რამ
წაკითხვის გარეშე მათ თქვენი ბუფერული.
ამჯამად რომ აზრი ყველას?
>> ცხადია, არსებობს ბევრი პარალელურად აქ
ჩვენი გამომავალი, ან შეტანის გადამისამართება, თქვენ არ წაიკითხოს და დაწეროს.
ასე fputc უბრალოდ წერს ხასიათი ფაილი.
fputs წერს ხაზი.
Fprintf ბეჭდავს ფორმატირებული გამომავალი.
ასე რომ, თუ თქვენ გაქვთ ჩანართები ან სივრცე, ან whatnot.
და შემდეგ fwrite წერს ზოგიერთი მასივი ბაიტი ფაილი.
ასე რომ ეს არის იგივე გზა fwrite და fread ანალოგიური
opposites-- fgets, fputs და მაშინ fputc და fgetc-- უამრავი
გიჟები, სწრაფი რამ.
>> უბრალოდ სახის შენარჩუნება ამ handy-- თქვენ უნდა სხვადასხვა დროს
სადაც იქნებ უბრალოდ გვინდა ერთი ხასიათი დროს.
იქნებ გსურთ მთელი ხაზი.
თქვენი ლექსიკონი pset-- რაც ორ psets,
მე მჯერა, ჩვენ მოგცემთ მთელი ლექსიკონი ტექსტურ ფორმატში
რომელსაც აქვს ყველა სიტყვა გამოყოფილი ხაზი.
ასე რომ, თუ თქვენ სურდა წაიკითხოთ ერთი სიტყვით, იმ დროს,
რა შეიძლება იყენებთ თუ თქვენ კითხულობთ და ისინი ყველა გამოეყო ახალი ხაზები,
და თქვენ უბრალოდ ერთი სიტყვით დროს?
>> აუდიტორია: fgets
>> დინამიკები 1: Right.
Fgets-- იმიტომ, რომ ბრუნდება რაც არის ერთ ხაზს.
და თუ ყოველი სიტყვა არის მისი საკუთარი ხაზი, ჩვენ შეგვიძლია გამოვიყენოთ fgets.
ზემოთ.
ამჯამად რომ აზრი, ყველას?
მაგარი?
Yeah, ჩვენ ვაპირებთ, რათა გართობა ნაწილი პოინტერები
ძალიან მალე, სადაც თქვენ დაკავდით მათემატიკის.
და ეს იქნება დიდი.
>> ბოლო step-- დახუროთ თქვენი ფაილი.
ამდენი რამ აქ, ჩვენი ერთ-ერთი პარადიგმების
იმ შემთხვევაში, თუ მას შეუძლია დაბრუნდეს null, შევამოწმოთ null.
თუ გახსნა რამე, უმჯობესია დახუროს იგი.
OK, ასე რომ თქვენ არ კეთდება, სანამ თქვენ გაკეთდა თუ თქვენ უკვე დაიხურა.
სახის, როგორიც ის არ არის მეტი სანამ fat lady მღერის.
სწორედ ისევე, როგორც დახურვის თქვენი ფაილი.
როგორც ის ამბობს, აქ, უბრალოდ კიდევ ერთხელ უნდა აღინიშნოს, ყოველთვის
გახსენით თქვენი ფაილი სანამ თქვენ წერისა და კითხვის მას.
და ყოველთვის დახუროს იგი, თუ თქვენ გახსნა.
ყველა უფლება?
ზემოთ.
>> ასე რომ, აქ არის მაგალითი.
ასე tiny-- მე არ ვიცი, თუ ბიჭები ვხედავთ, რომ ძალიან კარგად.
თუ მხოლოდ ჩვენ შეგვიძლია გაზრდის სიკაშკაშე რატომღაც.
ნება მომეცით რეალურად ამის გაკეთება, თუ არ შემიძლია.
OK, თქვენ ბიჭები ნამდვილად ვერ , რომ ყველა, შეგიძლიათ?
OK, ჩვენ ვაპირებთ ამის გაკეთებას, მაშინ.
[INAUDIBLE]
>> მე ვივარაუდოთ, რომ ეს არის ბევრად უკეთესი, რომ.
შეიძლება ვინმეს ვხედავ, სადაც ჩემი თაგვის წავიდა არის კითხვა?
Ah, იქ is-- რა ცდილობს,
>> OK.
ძირითადად, თქვენ ბიჭები უნდა გვქონდეს იდეა, თუ რას აკეთებს.
ეს არ არის სრულყოფილი.
მაგრამ მე მირჩევნია ახსნას, ვიდრე დახარჯავს მეტი დრო ცდილობენ ფორმატის სწორად.
ძირითადად, როგორც ხედავთ აქ, ჩვენ დავიწყებთ ფაილის გახსნა.
და ჩვენ გვაქვს მონაცემთა ბაზის ფაილი რომ ჩვენ ვართ
გახსნის, რომელიც ამბობს, რომ ეს არის ჩვენი სტუდენტები.
და ჩვენ ვაპირებთ, რომ ვწერ ამას.
ასე რომ, რა თქმა უნდა, დაბრუნების null.
ამიტომ, ჩვენ უნდა შევამოწმოთ null.
და თუ ეს ასე არ არის null, ჩვენ გაიაროს.
და როგორც ხედავთ, ჩვენ looping მეშვეობით აქ.
არსებობს სტუდენტებს.
სტუდენტების hash განისაზღვრება, როგორც სამი.
ის, რასაც ჩვენ ვაკეთებთ არის ჩვენ ვართ ბეჭდვის ფაილი, არა?
მერე რა ჩვენ დაბეჭდვის ჩვენს ფაილი?
>> აუდიტორია: ქულები რომ არის მასივი?
>> დინამიკები 1: ჰო.
ქულების რომლებიც მასივი ზუსტად.
ასე რომ, ჩვენ ვხსნით ამ მონაცემთა ბაზის ფაილი, რომელიც
მე ვივარაუდოთ, არის გარკვეული შეფასების მონაცემთა ბაზაში.
და ჩვენ უბრალოდ დაბეჭდვისას ქულა თითოეული სტუდენტი რომ ფაილი.
მაგარი?
კარგი.
გასაოცარია.
OK.
მოდით დავუბრუნდეთ, რომელთა მიზანია:
>> აუდიტორია: მე მაქვს სწრაფი კითხვა.
არის printf არ for loop?
ეს მხოლოდ იმ შემთხვევაში, თუ loop?
დინამიკები 1: არა, ეს ამისთვის loop.
მე ვერ ვხედავ ჩემი მაუსის ძალიან კარგად აქ.
ასე რომ, მე იბრძვიან ფორმატი, რომელიც სწორად.
ამ bracket უნდა წავიდნენ.
ეს უნდა იყოს ქვემოთ აქ.
ეს არის ის, რაც თქვენს for loop.
არსებობს.
ახლა ეს საკმაოდ.
ასე რომ, თუ როგორ უნდა be-- გარდა რომ ბოლო bracket, რომ მე სამსახურიდან გაათავისუფლეს.
OK.
ამჯამად რომ აზრი ყველას?
OK.
ჩვენ ვაპირებთ, რომ გადაადგილება შემდეგი რამ then--
რომელიც, ფაქტობრივად, თქვენ აპირებს უნდა ნახოთ კოდი.
ასე რომ, მე მხოლოდ აპირებს ასლი, რომ მეტი ახლა.
OK.
ამიტომ, მე ვაპირებ, რომ ნახოთ, რომ თქვენ ბიჭები ეს კოდი.
და მე მინდა თქვენ ცდილობენ და ფიგურა თუ რას უნდა გავაკეთოთ.
>> ასე მოცემული that-- წუთი ან ასე.
სცადეთ და გაერკვნენ, თუ რა ხდება აქ.
>> ნებისმიერი იდეები?
>> ჩვენ ვიცით, რომ ჩვენ გვაქვს მინიმუმ ორი არგუმენტები ბრძანების, არა?
მე ვივარაუდოთ, რომელთაგან ერთი იქნება რომ [INAUDIBLE] ჩვენი პროგრამა
და მერე რაღაც.
იმიტომ, რომ თუ [INAUDIBLE] ნაკლებად ვიდრე ორი, ჩვენ დაწეროთ მათ.
არა?
და გამოყენება, როგორც ჩანს, ეს იქნება გარკვეული ფაილი.
ჩვენ ვთანხმდებით, რომ?
ასე რომ, ახლა, რა loop აკეთებს?
რა არის ის გადის?
>> აუდიტორია: ყველა ფაილი.
დინამიკები 1: ზუსტად.
ის გადის ყველა ფაილი, რომელიც ჩვენ გვაქვს input არსებობს.
ამიტომ თითოეული ფაილი, ის გახსნას რამდენიმე სტრიქონი იქ.
ის გახსნას ფაილი.
არა?
და ის კითხულობს იგი.
რა თქმა უნდა, შემოწმების, თუ ის null.
და შემდეგ ბეჭდვა.
თუ ეს null, უბრალოდ გვეუბნება, რომ ეს არ არის ფაილი, რომელიც არსებობს.
იმიტომ, რომ მახსოვს, წაიკითხეთ ჩვენი ფაილი უნდა არსებობდეს.
არა?
წერენ და დამატება, თქვენ შეგიძლიათ მიიღოს away მასთან.
მაგრამ წავიკითხე, ჩვენი ფაილი უნდა არსებობდეს.
>> და თუ ეს არ არსებობს, რას ვაკეთებთ აქ?
მოდით დავიწყო აქ.
რა არის ეს გააკეთოს ეს პირველი ხასიათი.
რას ვაკეთებთ?
იგი იღებს ერთი ხასიათი, არა?
ასე რომ, რა არის ეს აკეთებს?
ის მიღების პირველი ხასიათი.
ვინმეს ვიცი EOF?
>> აუდიტორია: End of ფაილი?
>> დინამიკები 1: End of ფაილი ზუსტად.
ასე რომ, ის აპირებს გაიაროს მთელი ფაილი, არა?
და მაშინ ის აპირებს განაახლოს მიერ მიღების ყოველ მომდევნო ხასიათი.
არა?
და რა აკეთებს?
აუდიტორია: ჩვენ რომ in--
>> დინამიკები 1: putchar ანაბეჭდები თქვენი Screensaver.
[INAUDIBLE] ხასიათი.
და მაშინ, როდესაც [INAUDIBLE] ეს იქნება დახურეთ ფაილი.
>> აუდიტორია: თქვენ არ უნდა [? სხვა? ?]
>> დინამიკები 1: არ არის აუცილებელი.
ვგულისხმობ, რომ სახის გულისხმობდა ამ.
იმის გამო, რომ ბრუნდება, თუმცა, როგორც ხანგრძლივი როგორც ეს არ დაჭერა ამ, თქვენ ჯარიმა.
ვგულისხმობ ეს ალბათ კარგი პრაქტიკაში ამის გაკეთება სხვა.
მაგრამ სხვაგან არ არის აუცილებელია, განსაკუთრებით
თუ თქვენ გაქვთ რაიმე მოსწონს დაბრუნების, რომელიც
იმას ნიშნავს, რომ ამ შემთხვევაში, თუ ის იჭერს ეს, თქვენი პროგრამის აპირებს დასრულდება
და არასდროს მიიღოთ ეს.
ეს უფრო იმ შემთხვევაში, თუ თქვენ არ არის აუცილებელი დაბრუნების რაღაც.
იმიტომ, რომ თუ ეს არ იყო დაბრუნების არაფერი,
ეს იმას ნიშნავს, რომ თუ ეს ასეა, დანარჩენი ამ მაინც აწარმოებს.
და ამ შემთხვევაში, თქვენ სურს, ცრუ აღმოჩნდა.
თუ ის დაბრუნდა, თქვენი პროგრამის დასასრული,
სხვაგან არ არის აუცილებელი ყველა იმ დროს, დამოკიდებულია კონტექსტში.
იაკობ, არც თქვენ გაქვთ შეკითხვა?
აუდიტორია: Yeah.
ასე რომ არ fgetc შემდეგი ხასიათი?
როგორ ამჯამად ხასიათი გაიზრდება?
დინამიკები 1: ჰო.
ამიტომ fgetc იღებს მომდევნო ხასიათი.
თქვენ შეგიძლიათ ვფიქრობ, რომ როგორც C ++ გრძნობა.
>> აუდიტორია: ასე რომ, რა იყო EOF?
>> დინამიკები 1: EOF არის ბოლომდე ფაილი.
ეს უბრალოდ marker რომელიც საშუალებას თქვენ იცით რომ თქვენ ბოლოს თქვენი ფაილი.
ასე რომ, ეს აპირებს ბეჭდვა თქვენი სტანდარტული out.
და მაშინ ის აპირებს დახუროს ფაილი, როდესაც ეს კეთდება.
და მაშინ მოდით წავიდეთ შემდეგი ფაილის, არა?
ასე რომ საერთო ჯამში, რას ამ პროგრამის?
>> [INAUDIBLE]
>> დინამიკები 1: ჰო.
უბრალოდ ბეჭდავს out ყველაფერი.
ასე თუ ბიჭები ოდესმე გამოიყენება CAT და შემდეგ სახელი ზოგიერთი ფაილი
მე არ ვიცი, თუ თქვენ გაქვთ ოდესმე კეთდება, რომ თქვენი ტერმინალში.
მაგრამ თუ ოდესმე გამოიყენოს ბრძანება CAT-- C-A-T--
და შემდეგ რაც ფაილი თქვენ უნდა იქ ის
ბეჭდავს out თქვენს ტერმინალში, რომელიც შეიძლება სუპერ მოსახერხებელი ზოგიერთი რამ.
გამოვიყენო ეს ბევრი.
ამჯამად რომ აზრი ყველას?
მაგარი?
>> OK, ასე რომ თქვენი ამოცანა ახლა ან საკუთარ თავს ან გარშემო მყოფ ადამიანთა you--
უბრალოდ დავწეროთ მარტივი პროგრამა რომელიც უბრალოდ დაწერა "Hello, World!"
იმისათვის, რომ ფაილი.
>> [INAUDIBLE]
>> დინამიკები 1: მე იყო, გააკეთა მე რომ ცუდად გასულ კვირას?
მე არ ვფიქრობ, რომ ეს იყო ცუდი.
მოხარული ვარ, რომ თქვენ ყველა აქ.
ეს ნამდვილად მახარებს.
მე გოგონა მარტივი pleasures.
მე უბრალოდ მიყვარს, როდესაც ჩემს განყოფილებაში ესწრება.
ასე რომ, მე მხოლოდ მიღების ამ დაიწყო თქვენ ბიჭები ასე რომ ჩვენ შეგვიძლია კოდექსში ერთად.
მე არ მიყვარს აყენებს ვინმეს ადგილზე თუ გსურთ, რომ იყოს.
>> აუდიტორია: ვიქტორინა, ნუ ჩვენ უნდა დავწეროთ პროგრამა?
>> დინამიკები 1: თქვენ შეიძლება სთხოვა დაწერა მარტივი პროგრამები ხელით.
Yup.
>> აუდიტორია: ვიქტორინა მომავალ კვირას, არა?
>> დინამიკები 1: ვიქტორინა არის შემდეგი ოთხშაბათს.
ეს ნიშნავს, რომ იქ lovely [? CSE?] შეფასების პარტიის შემდეგ, რაც
ნიშნავს, რომ თქვენ შეძლებთ თქვენი ქულა უკან რომ ღამე რა დროს?
ვინ იცის?
მაგრამ ეს იქნება, რომ ღამით.
>> ყველა უფლება.
როგორ გვინდა, რომ დაიწყოს ეს?
მე მივცემ თქვენ hint-- იწყება ეს.
>> აუდიტორია: თქვენ უნდა გახსნა ფაილი.
>> დინამიკები 1: ჰო.
ასე რომ, რას მინდა მოვუწოდო ამ?
უბრალოდ გვინდა, რომ მას "file"?
მოდით ეს არ არის ადვილი.
ასე fopen-- რა არის ჩვენი გამომავალი ტესტი იქნება?
მოვუწოდებთ მას "Hello".
და რა არის ჩვენი რეჟიმი?
რას ვაკეთებთ, რომ ეს ფაილი?
>> აუდიტორია: დაწვრილებით.
წერა.
დინამიკები 1: ჩვენ წერილობით იგი.
ლამაზი.
OK, ასე რომ, ჩვენ ეს ფაილი არის.
რა უნდა გავაკეთოთ?
აუდიტორია: შეამოწმეთ თუ null.
დინამიკები 1: შეამოწმეთ თუ null-- ზუსტად.
ეს არის ის, რაც მე მინდა, რომ მოისმინონ.
ეს უნდა იყოს ავტომატიკა, განსაკუთრებით საკმაოდ ბევრი ამ მომენტიდან.
თუ დაიწყება segfaulting, ალბათ, არ შეამოწმოთ for null სადღაც.
ცხრა ჯერ ათიდან, რომ იქნება თქვენი შეცდომა.
ასე რომ, თუ თქვენ შეიძლება მხოლოდ მიიღონ ჩვევა, ყოველთვის შეამოწმეთ თუ null,
თქვენი ცხოვრება იქნება ლამაზი და easy-- და ადვილი.
>> რათა შეამოწმეთ თუ ეს null.
ასე რომ, თუ ეს არ არის null, რომელიც არის ის, რაც bang ტოლია
იმას ნიშნავს, არ null-- ეს მოქმედებს.
რა გვინდა გავაკეთოთ?
ჩვენ უბრალოდ გვინდა ბეჭდვა რომ ფაილი, არა?
მერე რა ჩვენ ვაპირებთ გამოვიყენოთ?
>> აუდიტორია: fprintf
>> დინამიკები 1: Fprintf-- ლამაზი.
და fprintf იღებს ორი arguments-- სადაც ის აპირებს და რა გვინდა დაბეჭდილი.
რა არის პირველი?
სად მიდის?
>> აუდიტორია: File.
>> დინამიკები 1: იგი აპირებს შეიტანოს.
და რა გვინდა დაბეჭდილი?
"Hello, World!"
ყველა უფლება.
ჩვენ გვაქვს ერთი ბოლო რამ კიდევ ერთი დიდი პარადიგმა აქ.
აუდიტორია: დახურვა.
დინამიკები 1: დახურვა.
იქ წასვლა.
>> აუდიტორია: არის ასე თუ ფაილი null?
დინამიკები 1: არა, ეს არის, თუ ეს არ null.
აუდიტორია: Oh, თუ ეს not-- OK.
რომ fopen და შემდეგ ორი არგუმენტები, რომ წასვლა შიგნით,
რას პირველი არგუმენტი ნიშნავს კიდევ ერთხელ?
>> დინამიკები 1: არგუმენტი ისევე, როგორც ფაილის სახელი
რომ თქვენ მინდა წასვლა.
ასე რომ ამის შემდეგ გადის, თქვენ აკეთებთ აქვს გარკვეული ფაილი სახელად "Hello"
რომელიც იყო "Hello, world" ფარგლებში.
ეს ყველაფერი.
მხოლოდ სახელი.
>> აუდიტორია: და რადგან წერა, ფაილი არ უნდა უკვე არსებობს.
რომ ის, რაც თქვენ განაცხადა?
>> დინამიკები 1: Right.
ზუსტად.
თუ "Hello", როგორც ფაილი ჯერ არ არსებობს, ეს
ვაპირებთ, რომ შევქმნათ ფაილი სახელად Hello "და დაწეროთ თქვენ.
>> აუდიტორია: როცა ვეუბნებით პროგრამის დაწერა ფაილი,
რატომ წერენ "file" ნაცვლად სახელი ფაილი და fprintf--
>> დინამიკები 1: იმის გამო, რომ ამ შემთხვევაში, ჩვენ გვაქვს რომ დიდი ფაილი ყველა caps-- ვარსკვლავი,
შეიტანოს.
ასე, რომ ეს მაჩვენებელი ფაილი რომ თქვენ ვსაუბრობთ.
ეს არის გზა, რომ ჩვენ მხოლოდ ეხება.
ასე რომ, ამ შემთხვევაში, თქვენ შეიძლება ვიფიქროთ, რომ ფაილი aha,
ჩვენ შეგვიძლია გამოვიყენოთ ამას ფაილი აქ ეხება გახსნა "Hello"
და გაქირავების ეს დაწერა.
>> აუდიტორია: შეგვიძლია დააყენა "Hello" ნაცვლად [? მხოლოდ?] f ფაილი?
დინამიკები 1: არა, რადგან "Hello" უნდა იყოს ღია და ჩაწერა.
ფაილი აქ ჰგავს აღმნიშვნელს, რომელიც ამბობს, OK, ჩვენ
აქვს ამ ფაილის მიესალმები ჩვენ ვუყურებთ.
გაიხსნა.
და ჩვენ ვაპირებთ, რომ ვწერ ამას.
თუ მხოლოდ "Hello", რომელიც ლაკონურად იგი.
ასე რომ, ის აპირებს freak out.
ვგულისხმობ, თქვენ შეიძლება არ დაასახელა.
შეიძლება გაკეთდეს ფაილი, ვარსკვლავი, "Hello", ტოლობის, რომ.
მაგრამ საქმე იმაშია, რომ თქვენ გჭირდებათ ფაილი ვარსკვლავი მაჩვენებელი, რათა
შეძლებს გამოიყენოს ეს ფუნქციები.
აუდიტორია: იქნებ გავაკეთოთ ფაილი, ვარსკვლავი, ფაილი, "Hello"
ან თქვენ უნდა დააყენოს ფაილი ვარსკვლავი, ფაილი ეს?
დინამიკები 1: თქვენ ვერ გავაკეთოთ ფაილი, ვარსკვლავი, "Hello".
თქვენ შეგიძლიათ შეცვალოთ ეს ნებისმიერი სახელი გინდათ.
ეს არის სრულიად უკანონო რა, რომ სახელი.
შეგიძლიათ დაასახელოთ ის არაფერი.
დაარქვით საფრენი სპაგეტი, თუ უნდოდა.
>> აუდიტორია: რა არის "W" შეთავაზებები?
>> დინამიკები 1: "w" მხოლოდ რეჟიმში.
ასე რომ, ჩვენ წერა ამ ფაილზე.
ყველას კარგი?
ნათელი?
დიახ.
>> აუდიტორია: ასე რომ, როდესაც წერს ამ ფაილი, სად შემდეგ აღმოაჩინა, რომ ფაილი?
>> დინამიკები 1: ეს იქნება იგივე მომსახურება, რომ თქვენ გაკეთებული.
თუ თქვენ pset სამი და თქვენ აწარმოებს ამ, თქვენი pset
სამი ფოლდერი იქნება ეს ფაილი სახელად "Hello".
მაგარი?
ყველას კარგი?
მე ვგრძნობ, რომ თქვენ ყველა მისაღებად მას, რაც საკმაოდ დიდი.
OK.
ასე რომ, ისევ ჩემს slide show-- მე მიყვარს, როდესაც რამ მუშაობა.
OK, პოინტერები ხართ თუ არა ბიჭები აღფრთოვანებული?
მითითებები დიდი.
ისინი ცოტა გადაიტანოთ თქვენი უფროსი გარშემო.
ეს არის ჩემი მეორე წელი სწავლების მითითებას.
და ვფიქრობ, საბოლოოდ მივიღე ეს.
ასე რომ, თუ თქვენ ბრძოლა, ეს OK.
როგორც ვთქვი, ხატვის სურათები ეხმარება ბევრი რამ CS,
როგორც მე ვფიქრობ, რომ ადამიანი, როგორც წესი, ვფიქრობ, რომ ოჰ, ჩვენ კომპიუტერი.
ჩვენ უნდა უბრალოდ კოდი.
No-- ნახატი სურათები ნამდვილად დაგეხმარებათ.
და მე ნამდვილად მოგიწოდებთ თქვენ, დაკრავენ თქვენს kindergartner მხარეს
და მოიტანს ფანქრები ან მარკერები და გათამაშება.
იმიტომ, რომ ეს დაგეხმარებათ.
და თუ ჩემთვის საათებში, მე ტარების გარშემო stacks ქაღალდი
ერთად კალმები ხატვის რამ out.
>> ასე განსაკუთრებით პოინტერები გავამახვილო სურათები.
და დარწმუნებული ვარ, რომ ჩვენ რეალურად აპირებს უნდა ხატვის ზოგიერთი სურათები აქაც.
>> ასე, რომ თქვენ ბიჭები ყველა დაინახა Binky, ეს მაგარი claymation რამ.
და ჩვენ ვფიქრობთ, რომ ეს ნამდვილად სასაცილოა, როდესაც იგი აფეთქდა შევიდა bunch of ცალი.
ეს რაღაც კომიკური რელიეფის კლასი.
C [INAUDIBLE] ამ დიდი უნარი შეძლებს გააკონტროლოს მეხსიერება.
და ეს არის ერთ ერთი რამ, რომ ნამდვილად რაც მას ასეთი ძლიერი ენაზე.
მაგრამ დიდი ძალა მოდის დიდი პასუხისმგებლობაა.
და გიჟები რამ შეიძლება მოხდეს თუ თქვენ არ ფრთხილად.
ასე რომ, როდესაც თქვენ იყენებთ მითითებები, გინდათ
დარწმუნდით, რომ თქვენ ნამდვილად მესმის ზუსტად რას აკეთებს.
იმედია შემდეგი ცოტა დრო დაეხმარება მესმის
მითითებები, თუ როგორ გამოიყენოთ მათ, და როგორ მანიპულირება მათ.
>> ასე მეხსიერება დარწმუნებული ვარ, რომ ჩვენ გვაქვს ჩანს, რომ ეს სქემა ადრე.
ასე რომ, ეს უბრალოდ მარტივი სქემა როგორ რამ შეიძლება ინახება მეხსიერებაში.
ასე რომ თქვენ ძირითადად აქვს ამ დიდი მასივები ერთი byte ბლოკები
არის ის, რაც ჩვენ გვაქვს აქ მცირე მდე თითო დროს.
ეს არის hex [INAUDIBLE] ასე რვა ბიტიანი ბლოკები.
და ყველა ბლოკის უკავშირდება ზოგიერთი თექვსმეტობითი მისამართზე.
ასე რომ, თუ თქვენ ოდესმე ვხედავ 0x, რომ უბრალოდ notating
ის, რომ თექვსმეტობითი მისამართზე.
თქვენ შეიძლება ვივარაუდოთ, ეს იმას ნიშნავს, ზოგიერთი მისამართი მეხსიერებაში.
ჩვენ ვსაუბრობთ მეხსიერების მისამართები როდესაც ხედავთ თექვსმეტობითი.
>> ჩვენ გვაქვს ints არიან ცვლადები, მოძრავი ცვლადები, რომ შესანახად.
ასე ints მაღაზია ints.
მოძრავი მაღაზია მოძრავი.
ამიტომ ჩვენ ასევე გვაქვს პოინტერები რომ მაღაზიაში მეხსიერების მისამართები.
რომ ერთგვარი რუკების.
მითითებები მხოლოდ მეხსიერების მისამართები.
ასე რომ ჰგავს თქვენი ტიპის არსებობს.
თქვენი მოწყობილობის 32-bit, რაც იმას ნიშნავს, რომ თქვენი მეხსიერება მისამართზე ოთხი ბაიტი.
ასე რომ, ნებისმიერი მაჩვენებელი, რომ თქვენ უნდა ასევე იქნება ოთხი ბაიტი.
ანდა, თუ ეს ოთხი ბაიტი, მეხსიერების ოთხი ბაიტი.
პოინტერები შესანახად მეხსიერებაში.
აქედან გამომდინარე, ისინი ოთხი ბაიტი.
Cool-- უბრალოდ მინდა გაძლიერდეს, რომ.
>> თქვენ უნდა მიიღოს ამ კომიკური ახლა.
მე არ ვიცი, რამდენი არის xkcd თაყვანისმცემლებს, მაგრამ მე მიყვარს xkcd.
ეს არის დიდი.
>> ყველა უფლება.
ასე შექმნა პოინტერები როგორც ვთქვი, ეს საკმაოდ ბევრი ისევე, როგორც არაფერი.
თქვენ გაქვთ ტიპის.
თქვენ გაქვთ სახელი.
არა?
ის, რაც ჩვენ იქ. [? Hex?] ვარსკვლავი ნიშნავს ეს მაჩვენებელი,
და შემდეგ რასაც თქვენ გსურთ ეძახით.
ასე ტიპის წარმოადგენს რა შეგიძლიათ შესანახად.
ყველა უფლება?
იმავე გზით, თუკი ints, ჩვენ ვიცით, რომ თქვენ შენახვა int არსებობს.
ერთად მაჩვენებელი, ის ფლობს მეხსიერება მისამართზე.
მაგრამ რას ნიშნავს არის, რომ აქ, სადაც ნახაზი აპირებს მოდის მოსახერხებელი.
ასე რომ, ამ შემთხვევაში, ჩვენ გვაქვს ზოგიერთი ღირებულება, ასე ვთქვათ, ოთხი.
ოთხი არის მისამართი ერთი.
OK?
>> ეს პირველი აქ იმას ნიშნავს, რომ ეს მაჩვენებელი 2x.
არა?
ეს ზოგიერთი მაჩვენებელი x.
x შეიძლება იყოს რაღაც, რასაც.
როგორიც არ უნდა იყოს x is-- ვთქვათ, x არის ოთხი.
ის აპირებს შესანახად მეხსიერების მისამართი აქ.
ასე int, ვარსკვლავი, რომ X ეს არის ზოგიერთი სხვა სლოტი მეხსიერება
ვინ იცის, რა არის ეს.
მაგრამ ის აპირებს შესანახად მისამართზე აქ.
ასე რომ, ეს იქნება მოსწონს ამ შემთხვევაში, არ უნდა იყოს,
ინახება 0x1-- რაც ინახება მისამართზე, რომელიც ჩვენი მაჩვენებელი ფლობს,
ემთხვევა მდე ის, რაც ჩვენ დანიშნული.
ასე რომ, 0x1, ამ შემთხვევაში, ეს არის x.
ეს შეიძლება მხოლოდ ოდესმე იყოს int ხოლო ჩვენ გამოყენებისას.
>> ანალოგიურად, თუ ჩვენ გვაქვს სხვა 1y, რაც
მისამართი ინახება ერთად y აქვს იყოს char-- იგივე z.
იგივე გზა, როდესაც თქვენ ცდილობენ და ამის გაკეთება intx შეადგენს 0.4,
ის აპირებს დაწეროთ თქვენ და იყოს როგორც არ, თქვენ თქვით სასურველი int.
ეს უნდა იყოს int.
შეწყდეს ცდილობს, რათა ის float.
>> ასე რომ, მოდით რამ, რაც მათ უნდათ, რომ იყოს.
ნება რამ საკუთარ თავს.
ასე რომ, დიდი რამ არის მხოლოდ რასაც ტიპის მაჩვენებელი
ის არის, რომ ეს არის ერთადერთი რამ შეგიძლიათ შეინახოთ არსებობს.
OK?
პრაქტიკაში, როგორც გასულ კვირას, ყველაფერი
როგორც ჩანს, მართლაც ასეთი აბსტრაქტული.
ჩვენ ვაპირებთ, რომ პრაქტიკაში.
ეს უნდა გააკეთოს მეტი გრძნობა.
>> ასე მითითება და dereferencing-- ეს ნამდვილად მნიშვნელოვანია ამ სწორი.
მე მაინც უნდა ამოცნობა ყველა ახლა და შემდეგ.
და მე, როგორც ლოდინი, რომელიც ერთი მინდა?
ამიტომ ampersand, ფაქტობრივად, მისცეს თქვენ მინიშნება ან მისამართი.
ასე რომ, ეს დააბრუნებს მისამართი მეხსიერება, რომლის ცვლადი ინახება.
ასე რომ, ის აპირებს რეალურად დაბრუნდება თექვსმეტობითი, ხოლო dereferencing ეს
რეალურად აპირებს მოგცემთ მონაცემები, რომელიც ინახება იქ.
OK?
ამიტომ, ჩვენ ვაპირებთ შევხედოთ მაგალითი მართლაც სწრაფი, თუ რეალურად მომავალი.
>> OK.
ამიტომ, ჩვენ უნდა ვფიქრობ, რომ ნამდვილად ყურადღებით ამის შესახებ.
ასე რომ, აქ ჩვენ გვაქვს გარკვეული რიცხვი x.
მე ვაპირებ ცდილობენ და მიაპყროს ამ იმისათვის, რომ მაქსიმალურად ჩემი შესაძლებლობები.
ასე რომ, ჩვენ ვაპირებთ, რომ ამ სათამაშო x.
და ის შენახვის ხუთ.
მისი მისამართი 0x4.
მაგარი?
ყველა კარგი.
>> ახლა ჩვენ გვაქვს ეს მაჩვენებელი.
ეს იყო აქ.
და ampersand გვაძლევს მისამართი რაღაც.
ასე რომ, ამ შემთხვევაში, ეს არის მისამართი x.
რა არის მისამართი x?
04-- და ეს მაჩვენებელი არის 0x08.
მაგარი?
ასე რომ თქვენ შეგიძლიათ ვფიქრობ, რომ ამ მაჩვენებელი, 04, უბრალოდ მიუთითებს მეტი აქ.
და ისინი მოუწოდა პოინტერები იმიტომ, რომ, როგორც ჩვენ უფრო ამ,
თქვენ აპირებს ვხედავ მიუთითებს რამ.
და ერთი ბლოკი მიუთითებს სხვა ბლოკი გაცილებით მეტი გრძნობა.
ასე რომ აქ არის ორი.
და მაშინ ჩვენ გვაქვს ასლი, რომელიც what-- 0x0c.
და ის აპირებს dereference ჩვენი მაჩვენებელი.
>> ასე თუ რას ამბობდა არის OK, აქ არის ჩვენი მაჩვენებელი.
ღირებულება ინახავს არის 0x04, და რა ის ამბობს, გადადით ამ მისამართზე
და მითხრა, რა არის ეს.
ასე რომ ეფექტურად ის, რაც ამ arrow აკეთებს.
შეგიძლიათ წარმოიდგინოთ, რომ ეს, როგორც თქვენი ვარსკვლავი.
ასე OK, როდესაც ჩვენ გავაკეთებთ ვარსკვლავი, ეს ნიშნავს, რომ დაიცვას.
გადადით ამ მისამართზე.
და ეს, ძირითადად, მხოლოდ შემდეგ ეს ისარი მეხსიერების ბლოკი.
და მოგვცეს რა არის ის, რაც არის 5.
ის, რის გამოც ჩვენს ასლი ტოლი 5.
ამჯამად რომ აზრი?
ვინმეს უნდა ჩემთვის გავლა რომ კიდევ ერთხელ, ან უფრო ნელა?
თქვენ გსურს მეშვეობით კიდევ ერთხელ?
OK.
ჩვენ ვაპირებთ, შეეცვალა ეს კიდევ ერთხელ.
როდესაც ჩვენ ვიწყებთ, ჩვენ ყველა თანხმდება იმაზე, რომ ჩვენ გვაქვს ზოგიერთი ბლოკი მეხსიერება, რომ ცვლადი
x, რომ ჩვენ მითითებული ტოლი 5.
ჩვენ არ აკონტროლებენ, სადაც იგი მეხსიერებაში.
ასე რომ, ეს პოზიცია არის მხოლოდ თვითნებურად ენიჭება.
კარგი არსებობს?
OK.
მაშინ ჩვენ ინიციალიზაცია მომცეთ int.
სწორედ ამიტომ ეს ნებადართულია აღვნიშნო, რომ x, რადგან ჩვენ გვაქვს int აქ.
ჩვენ გვაქვს კიდევ ერთი ბლოკი მეხსიერების რადგან ეს მაჩვენებელი
ცვლადი, ისევე, როგორც არაფერი.
ის თვითნებურად ენიჭება ზოგიერთი სივრცეში მეხსიერებაში.
და რა ინახავს არის მისამართი x.
Ampersand ნიშნავს მისამართი x.
რა არის მისამართი x?
>> აუდიტორია: ეს ნულოვანი
დინამიკები 1: 0x04.
ასე then-- ბოლო ერთი.
ჩვენ გვაქვს გარკვეული copy-- ერთხელ მხოლოდ ერთი ცვლადი.
მოდით მივანიჭოთ რამდენიმე თვითნებური ადგილი.
და ჩვენ dereference ჩვენი მაჩვენებელი.
ვარსკვლავი ნიშნავს, რომ წავიდეს მისამართი ინახება ჩემი კურსორი.
მითხარით, რა არის იქ.
ასე მისამართი ინახება ჩვენს მაჩვენებელი 0x04.
ასე რომ, ჩვენ რომ მისამართი.
ეს მიუთითებს, რომ მისამართზე.
რა არის შიგნით ამ მეხსიერების ბლოკი?
ის ხუთ.
ასე რომ, ის, რაც ჩვენ დავნიშნოთ ჩვენი ასლი.
ყველას კარგი?
ზემოთ.
ერთხელ ნახატები.
>> ისე, თვალთვალის ღირებულებების აქ ვარ აპირებს მოგცემთ ბიჭები ვფიქრობ ამაზე.
შეგვიძლია კიდევ ერთი სურათი.
მაგრამ მე მინდა, რომ თქვენ ცდილობენ და მიზეზი ამ საკუთარ წუთი.
>> რადგან მათ არ მისცეს ჩვენთვის მაგალითად მისამართი,
მე უბრალოდ აპირებს ampersand რომ X რომელიც უნდა დაეხმაროს მართოს იგი სახლში.
Ampersand ნიშნავს მისამართზე.
>> ასე რომ, პირველი, ყველას წავიდეთ ერთად პირველი ხაზი.
ზოგიერთი x კომპლექტი ხუთ ზოგიერთი შემთხვევითი slot მეხსიერებაში.
Int ვარსკვლავი მაჩვენებელი უდრის მისამართის x, არა?
Int ვარსკვლავი მაჩვენებელი ქმნის ამ ბლოკში, მოუწოდებს მაჩვენებელი,
და ანიჭებს მას მისამართი x.
მე საშინელი ampersands.
>> ახლა, რასაც ჩვენ ვაკეთებთ არის ჩვენ ვამბობთ OK, dereference ჩვენი მაჩვენებელი.
ამიტომ ჩვენ OK, რა არის ჩვენი მაჩვენებელი?
ეს ampersand x.
გადასვლა ampersand x და reassign ის.
>> ასე რომ, ახლა, ampersand x იქნება 35.
ასე რომ, ძირითადად, როდესაც თქვენ dereferencing, თქვენ წავიდეთ OK.
თქვენ აპირებს ხატვის სურათები.
თქვენ აპირებს ხატვის თქვენი ისრებით ზე, სადაც ის არის.
ასე რომ ამ სათამაშო მეხსიერების და ან მაძლევს, რომ არც უკან, ან შეცვალოს იგი.
ამ შემთხვევაში, იმიტომ, რომ ჩვენ ამ ღირებულება, ჩვენ მინიჭება რომ იყოს 35.
ხოლო ბოლო ერთ-ერთი, თუ თქვენ შეამჩნევთ, რომ ჩვენ
იყო მინიჭება, რა იყო აქ რაღაც.
>> ასე, რომ მათ ამ გასაოცარია მაგიდასთან.
ეს არ არის, რომ ცუდი.
თქვენ ბიჭები მუშაობა.
მე ვაპირებ შევაჩერო ის ფორუმში.
ჩვენ ვაპირებთ, რომ შეავსოთ იგი out ერთად, OK?
ასე რომ დაიბრუნოს ზოგიერთი ქაღალდი, დაიბრუნოს პარტნიორი, დაიწყოს მუშაობა.
მე ვაპირებ მიიღოს დიდი ცარცი.
იმიტომ, რომ ეს იქნება ძალიან ბევრი.
OK.
პროფესორი: OK.
დავიწყოთ პირველ რიგში.
ჩვენ დავიწყებთ იქ, მაშინ ბიჭები შეგიძლიათ იქნებ მუშაობა მეშვეობით კიდევ რამდენიმე.
OK.
უდრის B-ჯერ გ ასე, რა არის?
ეს არ შეასრულა კითხვაზე, მე გპირდებით.
>> სტუდენტი: 4-ჯერ 5.
>> პროფესორი: 4-ჯერ 5.
20.
რა არის b?
სტუდენტი: 4.
>> პროფესორი: და გ?
სტუდენტი: 5.
პროფესორი: 5.
და ეს მხოლოდ აპირებს უნდა ampersand, ampersand b,
ampersand გ, არა?
ცუდი არ არის.
ეს არის მარტივი საკმარისი.
OK.
ასე რომ შემდეგი ერთი.
უდრის ჯერ გ, იმ შემთხვევაში, ვინმე იყო უცხო, რომ.
ყველას იცნობს ჯერ ტოლია?
OK, ეს ყველაფერი იმას ნიშნავს, რომ ეს არის სტენოგრამის ტოლია დროს გ.
თქვენ ასევე შეგიძლიათ ეს გააკეთოთ განყოფილება, დამატებით, გამოკლება.
შეგიძლიათ გააკეთოთ შეადგენს, ან პლუს შეადგენს გ ნიშნავს შეადგენს პლუს გ, მინუს თანაბარი
c იქნება უდრის მინუს გ.
ეს მხოლოდ სინტაქსური შაქარი.
>> ასე რომ, ამ შემთხვევაში, არის ტოლი ჯერ c მოგვცეს რა?
კიდევ ერთხელ, არ შეასრულა კითხვაზე.
>> სტუდენტი: 100.
>> პროფესორი: 100.
ჯერ არაფერი შეიცვლება?
პოსტები
იქნებ მე საბოლოოდ მიიღოს უკეთესი ჩემი ampersands.
>> სტუდენტი: OK, უკაცრავად, როგორ მიიღეთ 100?
პროფესორი: OK.
ასე რომ, უდრის ჯერ C, ისე ჯერ გ.
სტუდენტი: Oh, თქვენ იყენებთ რომ previous--
პროფესორი: დიახ.
ასე რომ ეს არის ჩვენი უახლესი ღირებულებებს.
ეს არის ის, რაც თქვენ უნდა გამოყენებით ჩვენ ქვევით, OK.
ასე რომ, b არის ერთადერთი იცვლება, უფლება?
მოდით შეავსოთ ყველაფერი.
ბ რა არის b იქნება?
უნდა იყოს ან არ უნდა იყოს.
ასე რომ, რა არის ეს აკეთებს?
რა არის ვარსკვლავი pa აკეთებს?
>> სტუდენტი: Code ადგილმდებარეობის pa.
>> სტუდენტი: არა, არ საკმაოდ.
ასე რომ, ეს d მითითება.
>> სტუდენტი: b არის გადასცა ღირებულება pa.
>> პროფესორი: ჰო, ასე pa არის მისამართი, უფლება?
ამიტომ ვამბობ, წავიდეთ იქ, სადაც არის ინახება და მისცეს მას, რომ ღირებულება.
რა არის b?
სტუდენტი: 100.
პროფესორი: 100.
სრულყოფილი.
OK, ასე რომ pc, რა იცვლება.
ყველაფერი, რჩება იგივე.
რა არის pc იქნება?
მარტივი დავალება.
Pc ტოლია pa, და რა არის pa?
>> სტუდენტი: ampersand.
პროფესორი: Perfect.
ახლა ჩვენ ვიღებთ საინტერესო.
OK, მოდით დაარღვიოს ეს ერთი ქვემოთ.
პირველი, რასაც ბ-ჯერ გ, იმიტომ, რომ ადვილი ნაწილი ამ ერთი, არა?
B-ჯერ გ is--
>> სტუდენტი: 500.
>> პროფესორი: ჰო, რა არის ეს ერთი აკეთებს,
თუ ეს ვარსკვლავი pb, რა იცვლება?
>> სტუდენტი: რა არის the--
პროფესორი: რა არის b?
სტუდენტი: რა არის სივრცე რომ საზოგადოებრივი მაუწყებლის მიუთითებს.
პროფესორი: და pb მიუთითებს, რომელთა მიზანია:
სტუდენტი: B.
პროფესორი ბ ასე მხოლოდ რამ იცვლება ბ, მარჯვნივ.
ასე რომ ბ-ჯერ გ, 500.
ასე რომ, ეს, რა ცვლილებები არის.
ზემოთ.
ლამაზი.
ბიჭები აკეთებენ დიდი.
ყველა უფლება, არღვევს ამ ერთი ქვემოთ.
C იცვლება, არა?
ასე რომ ჩვენ შეგვიძლია შეავსოთ ყველაფერი.
ვნახოთ.
OK.
ჩვენ ვიცით, რომ გ იქნება პროდუქტის ორი ნომერი, უფლება?
რა ორი ნომერი, თუმცა?
>> სტუდენტი: და გ?
>> პროფესორი: ასე არ არის უფლება პირველი.
ასე რომ, ჩვენ გვინდა მითითება p ერთი, არა?
P ერთი ქულა, ჩვენ ვიცით, რომ ეს იქნება 100-ჯერ რა?
ჯერ რას pc წერტილი?
მიუთითებს.
ასე რომ 100-ჯერ 100 10,000.
ამჯამად რომ აზრი?
ზემოთ.
მთავარი მონაკვეთი, ბიჭები, ბოლო row.
OK.
რა იცვლება აქ?
>> სტუდენტი: A.
პროფესორი: ა Perfect, ასე ყველაფერი შეიძლება იგივე რჩება.
OK.
და რა არის?
ასე რომ, ეს ჯერ რა?
ეს არის ვარსკვლავი pb.
ასე ვარსკვლავი pb ნიშნავს აქ საზოგადოებრივი მაუწყებლის, საზოგადოებრივი მაუწყებლის რაოდენობა ბ.
>> სტუდენტი: 500.
>> პროფესორი: 500.
ამიტომ, ჩვენ უნდა 500-ჯერ 100.
რომ არის 50,000.
Whew!
შეხედეთ, რომ.
>> სტუდენტი: რატომ უნდა და გ last--
პროფესორი: ბოდიში.
სტუდენტი: Oh, OK.
პროფესორი: ჩემი ცუდი.
უამრავი წერილობით.
ყველას კარგი?
არ არის ძალიან ცუდი, არა?
უბრალოდ იღებს პატარა ხოლო მუშაობის გზით.
თუ თქვენ შესვენება მას, გვესმოდეს რა თითოეული ნაწილი
გულისხმობდა, რომელთა მიზანია, როგორც ყველაფერი ის,
yes-- დაარღვიოს ეს ქვემოთ პატარა პრობლემები და შემდეგ recombine,
და შეგიძლიათ დაკავდით გასაოცარია პერსონალი.
არსებობს პასუხი, მაგრამ ჩვენ გავაკეთეთ, რომ.
მაჩვენებელი არითმეტიკული.
Ah.
ჩემი ხელები ყველა chalky.
ასე დასძინა გამოკლებით, int არეგულირებს მაჩვენებელი
ზომა ტიპის მაჩვენებელი.
მახსოვს, როგორ ყველა ტიპის აქვს სხვადასხვა ზომის?
ასე რომ, როგორც ორმაგი ან ხანგრძლივი ხანგრძლივი არის რვა და int არის ოთხი, მაგრამ char არის ერთი.
>> ასე რომ, რა გსურთ გააკეთოთ is-- ერთი რამ უნდა გვახსოვდეს
უბრალოდ, თუ რამდენად თქვენი მაჩვენებელი ღირებულება რეალურად ცვლის
იქნება დამოკიდებული ტიპის მაჩვენებელი, რაც არის.
ყველას კარგი ეს?
შემიძლია წაშლას ეს?
ჩვენ კარგად?
გასაოცარია.
>> ასე რომ, თუ ჩვენ გვაქვს გარკვეული მაჩვენებელი that-- ამ აპირებს be-- ვარ
ვაპირებთ, რათა ის int მაჩვენებელი.
იგი ინახავს ეს.
თუ თქვენ ვთქვა მაჩვენებელი პლუს ერთი, რას აპირებს,
არის ის აპირებს განაახლოს ეს ზომა int
იმიტომ, რომ ტიპის მაჩვენებელი, რაც არის.
>> With C, ყველაფერი ძალიან მკაცრი და მოწესრიგებული.
Int მაჩვენებელი აპირებს განახლება თანხის სივრცეში int დასჭირდება.
Int არის ოთხი ბაიტი.
>> ასე რომ, რა ამ იქცეს?
თქვენ მხოლოდ დასძინა ოთხი გადატანა ამ.
ახლა თქვენი მაჩვენებელი იქნება be-- OK.
>> ასე რომ, თუ char და ჩვენ გავაკეთეთ მაჩვენებელი პლუს ერთი, რა უნდა იყოს ახლა?
თუ ეს started-- თითქოს ჩვენ started-- ახლა ეს 0x08.
ახლა ამბობენ, რომ ეს იყო char მაჩვენებელი, და ჩვენ კიდევ ერთ.
რა უნდა შეიცვალოს, რათა?
რამდენი ბაიტი არის char?
>> აუდიტორია: ერთი.
>> დინამიკები 1: One.
აუდიტორია: ასე რომ 0x09.
დინამიკები 1: ასე რომ ეს იქნება ცხრა.
ასე რომ, უბრალოდ რაღაც მახსოვს.
მხოლოდ მაშინ, როდესაც თქვენ დაამატოთ ერთი, ეს არ არის დამატებით ერთი თუ ეს char.
ის დასძინა, რამდენი ბაიტი ტიპის, რომ ეს არის,
სწორედ ამიტომ ჩვენ გვაქვს ამ განტოლების აქ.
ასე რომ, ეს int ჯერ ზომა ტიპის მაჩვენებელი.
>> ასე რომ, ჩვენ გვაქვს მაგალითი აქ.
y დაევალა ღირებულება, 0x4, როდესაც ჩვენ გავაკეთეთ y + უდრის.
რა არის ეს, რა x, არ იცვლება.
რას ნიშნავს ცვლილება არის, რა არის y.
მისამართი ინახება y განახლება ოთხი იმიტომ, რომ არსებობს ოთხი ბაიტი int
და ეს int მაჩვენებელი.
>> ყველა უფლება.
ასე რომ, ახლა ჩვენ გვაქვს კიდევ ერთი ვარჯიში.
ასე რომ, კითხვა, რაც ბეჭდვა.
ნებისმიერი იდეები?
>> აუდიტორია: ნომერი გმირები ბედნიერი კატა?
დინამიკები 1: ზუსტად.
ისე მომწონს თქვენი string.
ამჯამად ყველას, რომ?
გვინდა გავლა?
>> დიახ, OK.
რა გვაქვს აქ მე მოსწონს ეს ასე ბევრად უფრო.
მე არ უნდა [INAUDIBLE] სასაცილოდ.
>> ასე რომ, ჩვენ გვაქვს ჩვენი სიმებიანი აქ, ბედნიერი კატა.
ლამაზი.
ჩვენ გვაქვს გარკვეული counter, რომ ჩვენ შენახვა სიმღერა.
ასე, რომ ჩვენ გვაქვს char * მაჩვენებელი რომ მხოლოდ არის ტოლი ქ.
რას აკეთებს არის ის, მინიჭება ზოგიერთი მაჩვენებელი
დასაწყისში თქვენი სიმებიანი.
რადგან დარწმუნებული ვარ, როგორც ეს აღინიშნა, ლექცია,
ჩვენ მოცემული ბიჭები ეს მონაცემები ტიპის სიმებიანი.
>> მაგრამ ნამდვილად სტრიქონები მხოლოდ მასივი of-- როგორიცაა char *.
ეს მაჩვენებელი bunch of გმირები რომ არის მომიჯნავე მეხსიერებაში.
ასე რომ, ეს უბრალოდ ადგენს, რომ უდრის ნებისმიერი სიმებიანი
განსაზღვრული, სადაც პირველი ხასიათი.
ასე რომ, ეს მხოლოდ შექმნის რაღაც მომენტში ტოლი დასაწყისში სიმებიანი.
ყველას კარგი არსებობს?
ზემოთ.
>> ასე რომ, ეს dereferencing ჩვენი მაჩვენებელი.
ასე რომ, ეს რეალურად აპირებს მოგვცეს გარკვეული მნიშვნელობა აქ,
ჩვენს სიმებიანი რომ ჩვენ ვსაუბრობთ.
და ჩვენ ვამბობთ, რადგან ეს არ არის null terminator.
ასე შენარჩუნებას აპირებს, სანამ არ ბოლოს სიმებიანი.
განაახლოთ თქვენი მაჩვენებელი ერთი.
ასე r, რეალურად განახლება ერთი ყოველ ჯერზე, რადგან ეს არის char,
char *.
>> ამიტომ აპირებს გაიაროს.
ის აპირებს განაახლოს.
ასე რომ, პირველად გადის, ის აპირებს, რომ აქ, თ.
ის აპირებს განაახლოს.
>> ეს იქნება.
ეს იქნება p, y, და ასე შემდეგ და ასე შემდეგ.
ჩვენ განაახლოთ counter.
როდესაც იგი აღწევს და ბოლოს, მას უბრალოდ ბეჭდავს რამდენად შორს ის მიღებული.
დიახ.
>> აუდიტორია: ასე რომ იგი ითვლის სივრცე, როგორც ერთი, არა?
OK.
>> დინამიკები 1: ასე ვფიქრობ.
ის არის, რომ კითხვა
>> აუდიტორია: [INAUDIBLE].
>> დინამიკები 1: არ აწუხებს.
ეს მე ამის გაკეთება.
ყველა უფლება, ასე ერთი რამ მესმის, რომ მასივი,
ასევე, შეგიძლიათ მკურნალობა, როგორც მაჩვენებელი, რადგან კოლექტორები მხოლოდ
უწყვეტი ლაქების მეხსიერება.
>> ასე რომ თქვენ შეგიძლიათ მკურნალობა იგივე გზით.
თქვენ შეგიძლიათ მანიპულირება პოინტერები, ძალიან.
ასე რომ ნაცვლად აკეთებს, ამ იმ შემთხვევაში, ანალოგიური რამ
იქნება მასივი 0 უდრის 1.
>> მაგრამ იმ გზით, რომ სიმებიანი განისაზღვრება
დაწყების, სადაც პირველი ხასიათი,
მასივი განისაზღვრება სადაც მისი პირველი ელემენტი.
რადგან ჩვენ ვიცით, რომ ჩვენ ვართ გარანტირებულია, რომ ეს
ვაპირებთ, რომ იყოს უწყვეტი ბლოკები მეხსიერება.
ეს არის ის, რაც საშუალებას გვაძლევს გავაკეთოთ ეს.
ჩვენ ვიცით, ისინი უწყვეტი ბლოკები მეხსიერება.
>> ასე რომ, ამ შემთხვევაში, dereferencing მხოლოდ მასივი, რომელიც გვეუბნება,
OK, გადადით დაწყება თქვენი მასივი, რომელიც აქ.
ასე რომ თქვენ შეგიძლიათ ეს უდრის.
და ამ შემთხვევაში, რასაც თქვენი მასივი ტიპის, როდესაც თქვენ განახლება ერთი,
რომ ისევე განახლება მას შემდეგ ინდექსი.
თქვენ შეგიძლიათ ამის გაკეთება, რადგან თქვენ იცით, რა არის თქვენი მასივი.
ასე რომ იცის, რამდენად განაახლოთ თქვენი მაჩვენებელი,
რა მისამართზე განახლება ისე, რომ თქვენ დროს შემდეგი ჭრილში.
>> ასე რომ, ეს უბრალოდ სხვადასხვა გზით წერა მასივი 0 უდრის 1,
მასივი 1 უდრის 2, array bracket 2 უდრის 3.
ეს არის კიდევ ერთი გზა ფიქრი მას.
იმიტომ, რომ ისინი უწყვეტი ბლოკები მეხსიერება,
შეგიძლიათ დაუკავშირდეთ მათ ან მიერ მასივი notation--
რომელიც მე პირადად მოვძებნოთ easier-- მაგრამ იქნებ
თქვენ უნდა მანიპულირება მკაცრად მეხსიერების მისამართები.
და ეს არის გზა, რომ თქვენ ამის გაკეთება.
სახის უფრო მოსწონს მაგარი რამ, რაც შეიძლება გავაკეთოთ
წინააღმდეგ შესაძლოა, არ არის რაღაც თქვენ რეალურად აპირებს განახორციელოს.
>> მე გამოიყენოს იგი 61.
თქვენ ბიჭები ალბათ არ უნდა ფიქრი მას ძალიან ბევრი.
მაგრამ თუ თქვენ დაინტერესებული, მიიღოს 61 მომავალ წელს.
ჩვენ სახლში მონაკვეთი ბიჭები.
მე ვიცი, რომ ეს ხანგრძლივი.
დინამიური მეხსიერება Allocation-- ასე რომ, ჩვენ ვიცით, რომ ერთი
რამ, როდესაც ჩვენ ვისაუბრეთ დროს ჩვენი პირველი სექციაში ერთად,
ჩვენ შევხედე swap ფუნქცია, სადაც იგი იყო
ფარგლებს გარეთ ჩვენი მთავარი ფუნქცია.
და ჩვენ გადადის ამ ფასეულობების რომ ეფექტურად ასლები.
>> და კიდევ swap დასრულდა შესრულებაში, იგი მხოლოდ დაუტოვებიათ Stack.
დამახსოვრება, ჩვენ გვაქვს დასტის ჩარჩო swap.
იგი ტოვებს და იმ ღირებულებები დატოვოს იგი.
და ისინი წავიდნენ.
ჩვენ ვერაფერს მათთან და ჩვენ სამწუხარო
იმიტომ, რომ ჩვენ არ სვოპ ფასეულობები.
>> მაგრამ C, როგორც აღვნიშნე, თქვენ აქვს ბევრი ძალაუფლება მეხსიერება.
რა შეგიძლიათ გააკეთოთ შეგიძლიათ გამოყოფს რამ ბევრი აქ
რომ დარჩება იქ, სანამ ვუთხრა, სხვაგვარად.
>> ისინი მოსწონს კარგი შვილი.
ისინი იქ.
ისინი არ დატოვებენ.
ისინი იქ დარჩებიან, სანამ თქვენ როგორიცაა, OK, თქვენ შეიძლება წავიდეს.
>> იმის გამო, რამ დასტის, who-- ისინი მოსწონს თავხედი ბავშვები.
ისინი უბრალოდ აწარმოებს დაშორებით, როდესაც გსურთ უნდა იყოს იქ და მაშინ ისინი გაქრება.
თქვენ არ შეგიძლიათ მიიღოთ მათ უკან.
>> ასე რომ, ბევრი is-- ჩვენ ვაპირებთ ვისაუბროთ malloc და თავისუფალი,
დარწმუნებული ვარ, რომ თქვენ ბიჭები სმენია ლექცია.
და ეს ძირითადად გზა აქვს ძალიან მტკიცე მონაცემები.
ასე რომ თქვენ შეგიძლიათ შეინახოთ მონაცემები გარშემო, როგორც თქვენ გსურთ.
Mhm.
>> აუდიტორია: თქვენ განსაზღვრავს ბევრი და დააწყობს?
არიან მსგავს ადგილებში დააყენოს რამ?
>> დინამიკები 1: ასე რომ, ისინი ძირითადად მხოლოდ ისინი
სხვათა შორის, ჩვენ ეხება მხოლოდ ხსოვნას.
ასე ბევრი უბრალოდ ის ადგილები, სადაც მეხსიერების გამოყოფილი დინამიურად,
ხოლო დასტის ეხება უფრო დასტის ფარგლებში
რომ უფრო ცენტრალური ფუნქციები, რომლებიც რეალურად გაშვებული.
თქვენ ნამდვილად არ კონტროლი.
>> დიდი განსხვავება, თქვენ უნდა კონტროლი მეტი ბევრი, თუ გსურთ.
თქვენ გაქვთ ნაკლები კონტროლი Stack.
დასტის დამოკიდებულია ფუნქციები, რომლებიც გაშვებული,
და იმისათვის, რომელშიც ისინი აწარმოებს, და თუ როგორ უბრუნდება.
ხოლო ერთად ბევრი, როგორც ჩვენ დავინახავთ, თქვენ შეიძლება ითქვას,
OK, მე მინდა ეს ღირებულება უნდა იყოს გარშემო, სანამ გეტყვით, წინააღმდეგ შემთხვევაში.
თქვენ არ გაქვთ უფლება, რომ თავი დავაღწიოთ მას.
თქვენ არ გაქვთ უფლება, გადაფაროს იგი.
თქვენ ვაპირებთ, რომ შევინარჩუნოთ ის გარშემო რადგან მე გეტყვით.
თქვენ უნდა იყოს ბოსი ბევრი, იმის გამო, რომ stack-- იქნებ თუ
როგორიცაა finagle გზა თქვენ შეიძლება იყოს ქურდი.
მაგრამ არა საკმაოდ.
და ეს მართლაც მხოლოდ მეხსიერებაში.
ეს მხოლოდ სხვადასხვა გზები გულისხმობდა მეხსიერება.
>> ზემოთ.
ასე რომ, თუ როგორ უნდა აკონტროლოთ თქვენი მეხსიერება.
ეს ერთად malloc, რომელიც თქვენ აპირებს გამოიყენოს.
ასე რომ, ეს მხოლოდ მოკლე მეხსიერების გამოყოფას.
ეს ყველაფერი არის.
აქ არის რამოდენიმე სხვა მაგარი ფუნქციები, რომელიც უნდა alloc ბოლოს,
და ისინი დგანან სხვადასხვა რამ.
>> ასე რომ, როდესაც თქვენ უნდა შესანახი რომ სჭირდება გაახანგრძლივოს მიმდინარე ფუნქცია ასე
რომ, როცა მიმდინარე ფუნქცია გარბის,
თქვენ ჯერ კიდევ გაქვთ მონაცემები, რომ თქვენ მიიღო იგი, თქვენ გინდათ გამოიყენოთ malloc.
რომ ინიციალიზაცია მას ბევრი.
და როგორც მე ვთქვი და შეინახოს ამბობდა, რომ თქვენ გაქვთ იქ
სანამ გეტყვით, წინააღმდეგ შემთხვევაში, რომელიც მნიშვნელოვანი რამ აქ.
>> ასე რომ ერთი რამ შეამჩნია და ეს როგორც წესი, მართლაც მნიშვნელოვანია,
არის, რომ ეს Sizeof სუპერ სასარგებლო გამოყენება
რადგან დამოკიდებულია ტიპის მანქანა თქვენ გაშვებული,
მას შეიძლება ჰქონდეს განსხვავებული რაოდენობით მეხსიერება, რომელიც სჭირდება.
ასე რომ თქვენ ყოველთვის გვინდა გამოვიყენოთ ზომა ისე, რომ თქვენ არ მანქანა დამოკიდებული,
ისე, რომ თქვენი კოდი, აწარმოებს ნებისმიერი მანქანა.
>> და ეს მხოლოდ ნაწილია წერის კარგი კოდი.
თუ იგი მუშაობს ერთი მანქანა, მაგრამ არა სხვა,
რამდენად სასარგებლოა იყო თქვენი პროგრამა?
ასე რომ თქვენ ყოველთვის გვინდა დარწმუნდით და გამოიყენოთ sizeof.
>> აუდიტორია: ასე რომ ის არის, რომ, როგორც ზომა 10 inches [INAUDIBLE]?
>> დინამიკები 1: ეს არის ზომა 10 ints.
yeah.
ასე ზომა ints დაბრუნდება რა ღირს ერთი int მიიღოს.
ან ზომა char, როგორ ღირს ერთი char მიიღოს.
და მერე რამდენი ბლოკები რომ გინდათ?
>> ასე რომ, ამ შემთხვევაში, ჩვენ გვინდა რაღაც ჩვენ შეგიძლიათ შეინახოთ 10 ints to.
და ის იმუშავებს მიუხედავად მანქანა, რომელიც არის მაგარი.
ასე რომ, რამდენი ბაიტი იქნება რომ, ფაქტობრივად, გადმოგცეთ?
სწრაფი მათემატიკის.
>> აუდიტორია: 40.
დინამიკები 1: 40.
ზუსტად.
ასე რომ კიდევ ერთი დიდი რამ.
მაჩვენებელი ან malloc შეიძლება დაბრუნდეს null.
>> ასე რომ კიდევ ერთხელ, ყოველთვის შეამოწმეთ იმ შემთხვევაში, თუ ის დაბრუნდა null
სანამ ცდილობენ და არაფერი მას.
თუ თქვენ ცდილობენ და dereference ეს მაჩვენებელი არის,
ეს მხოლოდ აპირებს segfault იმიტომ, რომ თქვენ წავიდა და შეეცადა
შეეხოთ null როდესაც თქვენ არ უნდა ჰქონდეს.
ასე რომ, ყოველთვის შევამოწმოთ null.
კიდევ ერთხელ, ყველა შეგიძლიათ გააკეთოთ.
>> შესაძლოა დაბრუნდეს null.
ეს კიდე დაბრუნდება null თუ თქვენ ან სივრცე, ან სხვადსხვა მიზეზის გამო
ეს შეუვარდნენ რამდენიმე მეხსიერების შეცდომა.
ეს ზოგჯერ მხოლოდ ბრუნდება null.
ასე რომ თქვენ მხოლოდ უნდა შევამოწმოთ იგი.
რომ ყველა ამ slide ამბობს.
და მერე რა ჩვენ აქ არის მოწოდება გასათავისუფლებლად.
ასე რომ, ისევე, რომ თუ გახსნას ფაილი თქვენ უნდა დახუროს ფაილი,
თუ malloc მეხსიერება, უნდა გასათავისუფლებლად, რომ მეხსიერებაში.
და თქვენ ბიჭები მიიღებს უნდა გავაკეთოთ მართლაც მაგარი რამეები.
>> და იქ პროგრამა შეგიძლიათ აწარმოებს ვნახოთ, თუ თქვენ ოდესმე ჩამოდის მეხსიერება.
მაგრამ თქვენ არ გვინდა, რომ გაჟონვის მეხსიერება.
ეს მართლაც ცუდია.
მხოლოდ არეულობას რამ.
>> ეს არის ცუდი, ამის გაკეთება მხოლოდ, როგორც პროგრამირების ბრძენი დიზაინის ეფექტურობა.
მაგრამ ეს ასევე არის მხოლოდ სახის ცუდი თქვენი კომპიუტერის.
ასე რომ, მხოლოდ free რამ როდესაც თქვენ malloc მათ.
>> თქვენ ბიჭებს ვხედავ სიმეტრიის აქ.
სუპერ მარტივია.
მხოლოდ თავისუფალი და მაშინ რაც თქვენს მაჩვენებელი,
რასაც სახელი თქვენი კურსორი, და ეს
იზრუნებს ათავისუფლებს მას თქვენთვის.
ზემოთ.
>> მაშინ ჩვენ გვაქვს ეს.
ასე რომ, ჩვენ უბრალოდ აპირებს გავლა ეს პროგრამა.
და მაშინ ბიჭები კეთდება.
>> ასე რომ, [INAUDIBLE] უბრალოდ ძირითადი.
ასე, რომ ჩვენ გვაქვს int * მაჩვენებელი.
ასე რომ, ჩვენ გვაქვს მაჩვენებელი რომ აპირებს გამართოს ints.
და რამდენი ints იგი აპირებს გამართავს?
მხოლოდ ერთი.
ზომა int.
>> შეამოწმეთ, თუ მაჩვენებელი არის null, რადგან ეს
არის, ჩვენ გვინდა, არაფერს არ აკეთებს.
ეს ცუდია.
ამიტომ ჩვენ ბეჭდვა შეცდომა გარეთ მეხსიერება, ყველაზე ხშირად დაბრუნდებიან 1,
როგორც შენ გამოიყენება.
>> და მაშინ ჩვენ გვაქვს აქ ჩვენ dereference ჩვენი მაჩვენებელი.
ეს კი იმას ნიშნავს, რომ ჩვენ ვაპირებთ შესანახად რაღაც განთავსების მოცემული ჩვენთვის.
Int * კურსორი, ან malloc ბრუნდება მისამართი, სადაც ეს გათვალისწინებულია ამ
მეხსიერების თქვენთვის.
ასე რომ, ძირითადად, გაძლევთ მოსწონს თუ
ვიფიქროთ bunch of სახლები სამეზობლოში
რომ გსურთ დააყენა თქვენი ავეჯი, malloc
ჰგავს OK, თქვენ წასვლა სახლში სამი.
და ეს გაძლევთ მისამართი სახლი სამი.
>> ასე რომ, სწორედ ახლა, ამ მაჩვენებელი მაღაზიები მისამართი,
ინახავს მისამართი თქვენს სახლში.
* Ptr საშუალებით, OK, მე ჩემს სახლში.
ზემოთ.
მე უნდა მიიღოთ გარკვეული რიცხვი.
>> ასე რომ, თქვენ ითხოვს ვინმე გადმოგცეთ ავეჯი ახლა.
ასე რომ თქვენ მიიღოთ გარკვეული int.
და ეს აყენებს მას თქვენს მაჩვენებელი სადაც იგი მიუთითებს.
>> და შემდეგ უბრალოდ ბეჭდავს გარეთ, შევიდა იქ, სადაც.
ისევ და ისევ, მითითება.
ასე რომ, ეს, როგორც თქვენ წავიდა ამ მისამართი და დაინახა, თუ რა იყო.
მაგარი?
>> და მაშინ, რა თქმა უნდა გავათავისუფლოთ მაჩვენებელი.
ნუ დაგავიწყდებათ გასათავისუფლებლად თქვენი მაჩვენებელი.
ნუ დაგავიწყდებათ, რათა შეამოწმოს null.
ნუ დაგავიწყდებათ გასათავისუფლებლად თქვენი მაჩვენებელი.
თქვენ გაქვთ ორი რამ გახსოვთ ამ, ან, რომ თქვენ უნდა გვახსოვდეს.
დიახ.
აუდიტორია: [INAUDIBLE] პერსონალი როგორც, რომ char * s.
როგორ მოხდა, რომ ჩვენ არასოდეს უფასო იმ?
>> დინამიკები 1: Hm?
>> აუდიტორია: არიან ისეთებიც, როგორც სიმები?
თქვენ განაცხადა, რომ სტრიქონები ისევე, როგორც char * s, არა?
რატომ არ ჩვენ გასათავისუფლებლად strings?
>> დინამიკები 1: თქვენ მხოლოდ უფასო თუ თქვენ mallocing.
აუდიტორია: Oh, თუ თქვენ mallocing.
დინამიკები 1: ასე malloc და თავისუფალი ორი რამ
რომ თქვენ ყოველთვის უნდა ერთად.
ვ ღია f ახლოს, ორი რამ თქვენ უნდა ერთად.
როგორც იმ შემთხვევაში, შევამოწმოთ null.
დიახ.
>> აუდიტორია: ასე რომ free არის მხოლოდ რომელიც საშუალებას რაღაც
უნდა იყოს შენახული იქ შემდეგ ეს პროგრამა გამოიყენება იგი?
>> დინამიკები 1: უბრალოდ ვამბობ, OK, მე გაკეთდეს ეს.
თქვენ არ უნდა შეინარჩუნოს ის გარშემო.
წინააღმდეგ შემთხვევაში, თქვენი კომპიუტერი ისევე, როგორც ცდილობენ და შეინახოს იგი იქ.
და მაშინ can't-- ის გადის მეხსიერება საკითხებზე მოგვიანებით.
თქვენ ყოველთვის გვინდა გასათავისუფლებლად, რადგან ის ეუბნება თქვენს კომპიუტერს, OK, მე
გაკეთდეს ამ ადგილზე მეხსიერება.
თქვენ შეგიძლიათ ეს უკან ჩემთვის გამოყენების შემდეგ.
მაგარი?
დიახ.
>> აუდიტორია: ასე რომ ჩვენ გამოყენებული% d მხოლოდ რადგან ორმაგი რომ ბრუნდებოდა,
ან რატომ is-- [INAUDIBLE].
>> აუდიტორია: შეგიძლიათ გამოიყენოთ% i?
>> დინამიკები 1: თქვენ შეგიძლიათ გამოიყენოთ% i.
ბოლო წუთს კითხვებს?
წავიდეთ წინ.
აუდიტორია: მე უბრალოდ სწრაფი კითხვა.
ასე ptr ცვლადი, that's-- მსგავსი, int * ptr = malloc,
ეს მხოლოდ ვამბობ, რომ ეს მიუთითებს ადგილს მეხსიერება
დინამიკები 1: გსურთ [INAUDIBLE]?
აუდიტორია: --that არის ზომა of-- არა, ეს OK.
მაგრამ ეს მხოლოდ იმაზე მიუთითებს, რომ ადგილი მეხსიერება, რომ ისევე, როგორც ოთხი ბაიტი.
დინამიკები 1: Right.
ასე malloc ზომა int ამბობს, OK, მე ვაპირებ წავიდეთ გაიქცევა,
მოვძებნოთ ოთხი ბაიტი მეხსიერების თქვენთვის.
როდესაც იგი აღმოაჩენს, რომ ოთხი bytes მეხსიერების,
გაძლევთ უკან მისამართი სადაც იწყება,
და ეს რა ინახება მაჩვენებელი, ან ptr.
კარგი.
თქვენ ბიჭები ნაკლებად დაბნეული, ვიდრე ყველაზე ადამიანი როცა გაიგო მაჩვენებელი,
ასე რომ მე ვარ საკმაოდ კარგი ახლა.
>> ყველა უფლება.
როგორც ყოველთვის, თქვენ ბიჭები უნდა ჰქონდეს ყველა მიღებული თქვენი pset2 შეფასება ახლა.
მე ვიცი, რომ გარკვეული wonky რამ, სადაც იგი აცხადებს, ფორმულა არ არის სწორი
ან რამე.
თუ თქვენ მიღების, რომ ყველა თქვენი შეფასება ძალაშია ჩემი მხრიდან.
ასე რომ, მე გამოგიგზავნით ეკრანის თქვენი შეფასება.
უბრალოდ ნება მომეცით ვიცი, თუ თქვენ რომელიმე შეფასება ან რამე
როგორც ჩანს, არ აქვს აზრი.
ჩემთან.
>> მე უკვე სუპერ ვამაყობ თქვენით ბიჭები უკვე, ასე რომ შევინარჩუნოთ ის.
და აქვს კარგი დანარჩენი თქვენი კვირაში.
დარწმუნებული ვარ, რომ მე ვხედავ რაღაც თქვენ ოფისში საათი.