[Powered by Google Translate] [ნაწილი 5: ნაკლები კომფორტული]
[Nate Hardison, ჰარვარდის უნივერსიტეტი]
[ეს არის CS50.] [CS50.TV]
ასე რომ კეთილი იყოს უკან, ბიჭები.
კეთილი იყოს განყოფილებაში 5.
ამ ეტაპზე, რომელმაც დაასრულა ინტელექტუალური 0 და მას უნახავს, ​​როგორ გავაკეთეთ,
იმედია გრძნობთ მართლაც კარგია, რადგან ძალიან მოეწონა ქულით ამ სექციაში.
ჩვენი ონლაინ მაყურებელი, ჩვენ გვქონდა რამდენიმე კითხვები
დაახლოებით ბოლო ორი პრობლემები პრობლემა კომპლექტი - ან ინტელექტუალური, საკმაოდ.
ამიტომ, ჩვენ ვაპირებთ წასვლა იმ მართლაც სწრაფად, ისე, რომ ყველას ხედავს, თუ რა მოხდა
და როგორ გავლა ფაქტობრივი გადაწყვეტა, ვიდრე უბრალოდ ათვალიერებენ გადაწყვეტა თავად.
ჩვენ ვაპირებთ წასვლა უკანასკნელი რამდენიმე პრობლემები მართლაც სწრაფად, 32 და 33.
უბრალოდ, კიდევ ერთხელ, ასე რომ ონლაინ მაყურებელი ვხედავთ ამ.
>> თუ თქვენ ჩართოთ თქვენს პრობლემას 32, რომელიც გვერდზე 13,
13 out of 16, პრობლემა 32 ყველაფერი არის გაცვლებს.
ეს იყო ყველაფერი შევცვალე ორი რიცხვებით.
ეს პრობლემა, რომ ჩვენ გვინდა წავიდა მეტი რამდენიმე ჯერ ლექცია.
და აქ, რასაც ჩვენ ვითხოვდით თქვენ უნდა გააკეთოთ სწრაფი მეხსიერების კვალი.
შევსება ღირებულებებს ცვლადები როგორც ისინი დასტის
როგორც კოდი გადის ამ swap ფუნქცია.
კერძოდ, ის, რაც ჩვენ ვეძებთ at - I'm გეგმავს ამ iPad Down -
კერძოდ, რა ჩვენ შევხედავთ ეს ხაზი დანომრილი 6 უფლება აქ.
და ეს დანომრილი 6 მხოლოდ contiguity, წინა პრობლემა.
რაც გვინდა გააკეთოთ არიან ან წარწერა სახელმწიფო მეხსიერების
როგორც ეს იმ დროს, როდესაც ჩვენ შეასრულოს ამ ხაზის ნომერი 6,
რომელიც ეფექტურად დაბრუნების ჩვენი swap ფუნქციის უფლება აქ.
თუ ჩვენ გადახვევა ქვემოთ აქ, დავინახეთ, რომ მისამართები ყველაფერი მეხსიერების გაეწია ჩვენთვის.
ეს არის ძალიან გასაღები; ჩვენ დავბრუნდებით მას რაღაც მომენტში.
და შემდეგ ქვევით აქ ბოლოში, ჩვენ გვქონდა პატარა მეხსიერება დიაგრამაზე, რომ ჩვენ ვაპირებთ ეხება.
მე არ კეთდება ამ გარეთ ჩემი iPad.
ამიტომ მე ვაპირებ ალტერნატიული უკან და მეოთხე შორის iPad და ამ კოდექსით მხოლოდ მითითება.
>> დავიწყოთ. თავიდან, მოდით ფოკუსირება პირველი რამდენიმე ხაზების ძირითადი უფლება აქ.
დასაწყებად, ჩვენ ვაპირებთ ინიციალიზაცია x to 1 და Y-დან 2.
ასე რომ გვაქვს ორი რიცხვი ცვლადები, ისინი ორივე აპირებს განთავსდება Stack.
ჩვენ ვაპირებთ დააყენა 1 და 2 მათში.
ასე რომ, თუ მე Flip მეტი ჩემი iPad, იმედია, ვნახოთ -
Apple TV რეზერვაციის, და იქ წასვლა. Okay.
ასე რომ, თუ მე Flip მეტი ჩემი iPad,
მინდა ინიციალიზაცია x to 1 და Y-დან 2.
ჩვენ ამას ვაკეთებთ, რომ საკმაოდ უბრალოდ წერა 1 ყუთში აღინიშნება x
და 2 ყუთში აღინიშნება წ. საკმაოდ მარტივია.
ახლა მოდით დავუბრუნდეთ ლეპტოპი, ვნახოთ, რა მოხდება მომდევნო.
ასე რომ, ეს მეორე ხაზზე, სადაც რამ კიდევ სახიფათო.
ჩვენ გაიაროს მისამართი x და მისამართი Y როგორც პარამეტრების და ბ swap ფუნქცია.
მისამართი x და მისამართი Y ის საკითხებია, რომლებზეც ჩვენ არ შეგვიძლია გამოვთვალოთ
გარეშე გულისხმობდა ამ ტყვია მიუთითებს უფლება ქვემოთ აქ.
და საბედნიეროდ, პირველი ორი ტყვია რაოდენობა გვითხრათ ზუსტად რა პასუხი.
მისამართი x მეხსიერებაში არის 10, და მისამართი Y მეხსიერებაში არის 14.
ასე რომ ეს ის ღირებულებები, რომ მიიღოთ წელს მიღებული როგორც და ბ up დაბრუნება ჩვენს swap ფუნქცია.
ასე რომ კიდევ ერთხელ, კომუტაციის უკან ჩვენი სქემა, შემიძლია წერენ 10 წლის
და 14 წლის ბ.
ახლა, ამ ეტაპზე არის, სადაც ჩვენ გააგრძელოს swap.
ამიტომ flipping თავში ლეპტოპი ერთხელ,
ჩვენ ვხედავთ, რომ გზა swap მუშაობს არის მე პირველად dereference და შენახვის შედეგად tmp.
ამიტომ dereference ოპერატორი ამბობს, "Hey. Treat შინაარსი ცვლადი როგორც მისამართზე.
გადავიდეთ რაც ინახება, რომ მისამართი, და ჩატვირთეთ იგი. "
რა ჩატვირთვა გარეთ ცვლადი აპირებს ინახება ჩვენს tmp ცვლადი.
Flipping თავში iPad.
თუ ჩვენ მივდივართ მივმართო 10, ჩვენ ვიცით, რომ მისამართი 10 არის varible x
რადგან გვითხრეს, ჩვენი ტყვია პუნქტიანი რომ მისამართს x მეხსიერებაში არის 10.
ასე რომ ჩვენ შეგვიძლია წავიდეთ იქ, კიდევ ღირებულების ის, რომელიც 1, როგორც ვხედავთ ჩვენს iPad,
და ჩატვირთეთ რომ შევიდა tmp.
ისევ და ისევ, ეს არ არის საბოლოო შინაარსს.
ჩვენ ვაპირებთ გავლა და ჩვენ კიდევ ჩვენი საბოლოო სახელმწიფო პროგრამის დასასრულს.
მაგრამ ახლა, ჩვენ გვაქვს ღირებულება 1 შენახული tmp.
>> წინ კიდევ ერთი სწრაფი საკითხი აქ.
[ალექსანდრე] არის dereference ოპერატორი - ეს მხოლოდ ვარსკვლავი თვალწინ ცვლადი?
>> დიახ. ამიტომ dereference ოპერატორი, როგორც ჩვენ Flip უკან ჩვენი ლეპტოპი კიდევ ერთხელ,
ეს ვარსკვლავი თვალწინ.
ამ თვალსაზრისით, ეს არის - თქვენ განსხვავებით იგი გამრავლების ოპერატორი
რაც მოითხოვს ორი რამ; dereference ოპერატორი unary ოპერატორს.
Just მიმართა ერთ ღირებულება განსხვავებით ორობითი ოპერატორი,
სადაც თქვენ ვრცელდება ორ სხვადასხვა ღირებულებებს.
ასე რომ, რა მოხდება ამ ხაზის.
ჩვენ დატვირთული ღირებულება 1 და ინახება იგი ჩვენი დროებითი რიცხვი ცვლადი.
შემდეგი ხაზი, ჩვენ ვინახავთ შინაარსი ბ შევიდა -
ან, უფრო სწორად, ჩვენ ვინახავთ შინაარსი რომ B არის მიუთითებს შევიდა იმ ადგილას, სადაც არის მიუთითებს.
თუ გავაანალიზებთ ამ მარჯვნიდან მარცხნივ, ჩვენ ვაპირებთ dereference ბ,
ჩვენ ვაპირებთ მივმართო 14, ჩვენ ვაპირებთ დაიბრუნოს მთელი რიცხვი, რომელიც იქ,
და მაშინ ჩვენ ვაპირებთ წასვლა მისამართი 10,
და ჩვენ ვაპირებთ ჩააგდოს შედეგი ჩვენი dereference of ბ შევიდა, რომ სივრცეში.
Flipping უკან ჩვენი iPad, სადაც შეგვიძლია, რომ ეს ცოტა უფრო კონკრეტული,
ეს შესაძლოა, დაეხმაროს თუ ვწერ ნომრები ყველა მისამართები აქ.
ასე რომ, ჩვენ ვიცით, რომ Y, ჩვენ ვიმყოფებით მისამართი 14, x არის მისამართი 10.
როდესაც ჩვენ იწყება B, ჩვენ dereference ბ, ჩვენ ვაპირებთ დაიბრუნოს ღირებულება 2.
ჩვენ ვაპირებთ, რომ დაიბრუნოს ამ მნიშვნელობის რადგან ეს ღირებულება, რომელიც ცხოვრობს მისამართი 14.
და ჩვენ ვაპირებთ დააყენა იგი ცვლადი რომ ცხოვრობს მისამართი 10,
რაც უფლება არსებობს, შესაბამისი ჩვენი ცვლადი x.
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ცოტა overwriting აქ
სადაც ჩვენ დავაღწიოთ ჩვენი 1 და ნაცვლად ჩვენ წერენ 2.
ასე რომ ყველა არის კარგად და კარგი მსოფლიოში, მიუხედავად იმისა, რომ ჩვენ ინსტალერის x ახლა.
ჩვენ შენახული x ძველი ღირებულება ჩვენს tmp ცვლადი.
ასე რომ ჩვენ შეგვიძლია დავასრულოთ swap მომდევნო ხაზი.
Flipping უკან ჩვენი ლეპტოპი.
ახლა ყველა რომ რჩება მიიღოს შინაარსი ჩვენი დროებითი რიცხვი ცვლადი
და ვინახავთ მათ ცვლადი რომ ცხოვრობს, მისამართზე, რომ ბ მართავს.
ამიტომ, ჩვენ ვაპირებთ ეფექტურად dereference ბ მისაღებად ხელმისაწვდომობის ცვლადი
რომ არის, მისამართზე, რომ ბ ფლობს მას,
და ჩვენ ვაპირებთ პერსონალის ღირებულება რომ tmp მართავს მივანიჭო.
Flipping თავში iPad კიდევ ერთხელ.
შემიძლია წაშლას მნიშვნელობა აქ, 2,
და ნაცვლად ჩვენ კოპირება უფლება 1 მივანიჭო.
მაშინ მეორე ხაზზე, რომ ახორციელებს, რა თქმა უნდა -
თუ ჩვენ Flip თავში ლეპტოპი - არის ამ ეტაპზე 6,
რაც წერტილი სადაც გვინდოდა გვაქვს ჩვენი სქემა მთლიანად შევსებული.
ამიტომ flipping თავში iPad კიდევ ერთხელ, უბრალოდ, ასე რომ თქვენ შეგიძლიათ ნახოთ შევსებული სქემა,
თქვენ ხედავთ, რომ ჩვენ გვყავს 10 წელს, 14 წელს ბ, 1 წლის tmp, 2, x, და 1 წლის წ.
არსებობს რაიმე კითხვები შესახებ?
ამჯამად ამ უფრო გრძნობა, რომელმაც ფეხით ისეირნა ეს?
ჩადება ნაკლები გრძნობა? იმედია არ. Okay.
>> მითითებები ძალიან სახიფათო სათაური.
ერთი ბიჭები ვმუშაობთ აქვს ძალიან ხშირი განაცხადა:
"ამის გასაგებად გჭირდებათ, თქვენ უნდა გვესმოდეს, პირველი პოინტერები".
რაც, ჩემი აზრით არის ძალიან ნამდვილი. ეს არ მიიღოს ხოლო მისაღებად გამოიყენება იგი.
ვხატავთ უამრავი სურათები, გრაფიკა უამრავი მეხსიერების დიაგრამების მსგავსი ძალიან გამოსადეგი,
და შემდეგ თქვენ გავლა მაგალითად შემდეგ მაგალითი შემდეგ მაგალითად,
ეს დავიწყებთ, რათა ცოტა მეტი აზრი და ცოტა მეტი გრძნობა და ცოტა მეტი გაგებით.
და ბოლოს, ერთ დღეს, თქვენ ეს ყველაფერი მთლიანად აითვისა.
ნებისმიერი კითხვები სანამ ჩვენ გადასვლა მომდევნო პრობლემა? ყველა უფლება.
ამიტომ Flip თავში ლეპტოპი.
შემდეგი პრობლემა გვაქვს არის პრობლემა ნომერი 33 წლის ფაილის I / O.
მიუახლოვდით ამ ცოტა.
პრობლემა 33 - დიახ?
>> [დანიელ] მე უბრალოდ ჰქონდა სწრაფი კითხვა. ეს ვარსკვლავი, ან ვარსკვლავი,
ეს მოუწოდა dereferencing როდესაც თქვენ იყენებთ ვარსკვლავი წინაშე.
რა არის ერთ როდესაც თქვენ იყენებთ ampersand წინაშე?
>> Ampersand ადრე არის მისამართზე-ოპერატორის.
მოდით გადახვევა უკან მდე.
Oops. მე Zoom რეჟიმში მე ვერ გადახვევა.
თუ დავაკვირდებით ამ კოდექსით მართლაც სწრაფად სწორედ აქ,
ერთხელ, იგივე ხდება.
თუ დავაკვირდებით ამ კოდექსით უფლება აქ, ამ ხაზის სადაც ჩვენ მიიღოს ზარი სვოპ,
ampersand უბრალოდ რომ "კიდევ მისამართი სადაც ცვლადი x ცხოვრებაში."
როდესაც თქვენი შემდგენელი ადგენს თქვენი კოდი,
მას რეალურად ფიზიკურად გამოვყოფდით ადგილი მეხსიერებაში ყველა თქვენი ცვლადები ცხოვრება.
და მერე რა შემდგენელი შეგიძლიათ მაშინ ნუ ერთხელ ის შედგენილი ყველაფერი,
იგი დარწმუნებულია, "ოჰ, მე ზუსტად x საათზე მისამართი 10. მე Y ზე მისამართი 14."
მას შეუძლია შემდეგ შეავსონ ამ ღირებულებების თქვენთვის.
ასე, რომ თქვენ შეგიძლიათ შემდეგ - ეს შეიძლება მაშინ გაივლის ამ წელს და უღელტეხილზე & y in ისევე.
ეს ბიჭები კიდევ მისამართი, არამედ, როცა გაივლის მათ swap ფუნქციის,
ამ ტიპის ინფორმაციას, ამ int * უფლება აქ, ეუბნება შემდგენელი,
"Okay, ჩვენ ვაპირებთ იყოს წერით ამ მისამართზე, როგორც მისამართი რიცხვი ცვლადი."
როგორც მისამართი int, რომელიც განსხვავდება მისამართი ხასიათი ცვლადი
რადგან int იკავებს, on 32-bit მანქანა, იკავებს 4 ბაიტს სივრცეში,
ხოლო ხასიათი მხოლოდ იღებს up 1 byte სივრცეში.
ამიტომ მნიშვნელოვანია ვიცოდეთ, თუ რა არის - რა ცხოვრება, რა ტიპის ღირებულება
მცხოვრები მისამართზე, რომელიც კონკრეტულად გაიარა სისტემაში
ან მისამართი, რომ თქვენ საქმე.
ამ გზით, თქვენ იცით, რამდენი ბაიტი ინფორმაციის რეალურად ჩატვირთვა out თქვენი RAM.
და მაშინ, დიახ, ეს dereference ოპერატორი, თქვენნაირი ითხოვდნენ,
მიდის და ხელმისაწვდომი ინფორმაციის კონკრეტულ მისამართზე.
ასე რომ ამბობს, ამ ცვლადის აქ, მკურნალობა შინაარსი როგორც მისამართი,
წასვლა, რომ მისამართი, და გაიყვანოს, ჩატვირთვა შევიდა პროცესორი, დატვირთვის შევიდა რეგისტრაცია
ფაქტობრივი ღირებულებების ან შინაარსი, რომ ცხოვრობენ, რომ მისამართზე.
ნებისმიერი უფრო მეტი შეკითხვა? ეს არის კარგი შეკითხვა.
ეს ბევრი ახალი ტერმინოლოგია ძალიან.
ასევე სახის ხმაურიანი, ხედავს და და * სხვადასხვა ადგილებში.
>> ყველა უფლება.
ასე რომ თავში პრობლემა 33, ფაილის I / O.
ეს იყო ერთი იმ პრობლემებს, რომელიც ვფიქრობ, რამდენიმე რამ მოხდა.
ერთი, ეს საკმაოდ ახალი თემის.
ის არის წარმოდგენილი საკმაოდ მალე სანამ ვიქტორინა,
და მაშინ მე ვფიქრობ, რომ ეს იყო ერთგვარი მოსწონს ერთი იმ სიტყვას პრობლემები მათემატიკის
სადაც ისინი მოგცემთ უამრავ ინფორმაციას, მაგრამ თქვენ ნამდვილად არ დასრულდება მდე მქონე გამოიყენოს ტონა იგი.
პირველი ნაწილი ამ პრობლემას აღწერს რა CSV ფაილი.
ახლა, CSV ფაილი თანახმად, აღწერა, არის მძიმით-გამოყოფილი მნიშვნელობები ფაილის.
მიზეზი ეს არის ყველა საინტერესო იყო და მიზეზი ოდესმე მათი გამოყენება,
არის, რადგან, რამდენი თქვენ ოდესმე გამოიყენება პერსონალის მოსწონს Excel?
ფიგურა ყველაზე მეტად თქვენ არ, ალბათ, ან გამოიყენებს რაღაც მომენტში თქვენს ცხოვრებაში.
თქვენ გამოიყენებთ რაღაც Excel.
იმისათვის, რომ მიიღოთ მონაცემები გარეთ Excel-ის რაიმე სახის დამუშავება მასთან,
თუ უნდოდა დაწერა C პროგრამის ან პითონი პროგრამა, Java პროგრამა,
გამკლავება მონაცემები თქვენ არ ინახება იქ,
ერთი ყველაზე გავრცელებული გზა მისაღებად მას out არის CSV ფაილი.
და შეგიძლიათ გახსენით Excel და როდესაც მიდიხარ 'შეინახე როგორც "დიალოგის,
შეგიძლიათ გავიდნენ ფაქტობრივი CSV ფაილი.
>> Handy იცოდეს როგორ გაუმკლავდეს ეს ყველაფერი.
გზა მუშაობს ის არის, რომ ეს მსგავსი - ვგულისხმობ, ის არსებითად mimicking ცხრილების,
სადაც, როგორც ვხედავთ აქ, ძალიან დაუტოვებიათ-საუკეთესო პიესა,
ჩვენ გვაქვს ყველა გვარი.
ამიტომ Malan, მაშინ Hardison და შემდეგ Bowden, MacWilliam და შემდეგ Chan.
ყველა გვარი. და შემდეგ მძიმით ჰყოფს გვარი პირველი სახელები.
დავით, Nate, რობ, ტომი, და Zamyla.
მე ყოველთვის აღრევას Robby და ტომ.
და მაშინ, საბოლოოდ, მესამე სვეტის არის მისამართს.
ერთხელ თქვენ გვესმის, რომ, დანარჩენი პროგრამა საკმაოდ მარტივია განახორციელოს.
რაც ჩვენ გავაკეთეთ იმისათვის, რომ mimic ეს იგივე სტრუქტურა ჩვენს C პროგრამის
არის ჩვენ გამოყენებული სტრუქტურა.
ჩვენ დავიწყებთ თამაშს ამ ცოტა მეტი ასევე.
ჩვენ ვნახეთ მათ პირველად ცოტა პრობლემების კომპლექტი 3, როდესაც საქმე გვქონდა ლექსიკონები.
მაგრამ ეს პერსონალის struct ინახავს გვარი, სახელი და ელ.
ისევე, როგორც ჩვენი CSV ფაილი შენახვას.
ასე რომ, ეს უბრალოდ კონვერტირებას ერთი ფორმატი სხვა.
ჩვენ უნდა გარდაქმნას, ამ შემთხვევაში, პერსონალი struct შევიდა ხაზი,
მძიმით გამოყოფილი-ხაზი, ისევე, როგორც, რომ.
ამჯამად რომ აზრი? თქვენ ბიჭები არ ყველა მიღებული ვიქტორინა,
ამიტომ წარმოიდგინეთ თქვენ მინიმუმ ჰქონდა გარკვეული დრო ვიფიქროთ ამ.
>> In დაქირავება ფუნქცია, პრობლემა გვთხოვს მიიღოს in - we'll მიუახლოვდით ამ ცოტა -
მიიღოს თანამშრომლები სტრუქტურა, პერსონალი struct, სახელწოდებით s,
და დამატება მისი შინაარსი ჩვენს staff.csv ფაილი.
თურმე ეს საკმაოდ მარტივია გამოიყენოს.
ჩვენ სახის თამაშობენ გარშემო ამ ფუნქციების ცოტა მეტი დღეს.
მაგრამ ამ შემთხვევაში, fprintf ფუნქცია მართლაც გასაღები.
ამრიგად fprintf, ჩვენ შეგვიძლია ბეჭდვა, ისევე, როგორც თქვენ ბიჭები არ იყენებს printf ამ მთელი ვადით.
შეგიძლია printf ხაზი ფაილი.
ასე რომ ნაცვლად მხოლოდ მიღების ჩვეულ printf ზარის სადაც თქვენ მისცეს მას სტრიქონში
და მაშინ შეცვლის ყველა ცვლადები შემდეგი არგუმენტები,
ერთად fprintf, თქვენი პირველივე არგუმენტი ნაცვლად ფაილი გსურთ ჩაწერა.
თუ ჩვენ უნდა შევხედოთ ამ მოწყობილობის, მაგალითად, ადამიანი fprintf,
ვხედავთ განსხვავება printf და fprintf.
მე მიუახლოვდით აქ ცოტა.
ამრიგად printf, ვაძლევთ მას სტრიქონში, ხოლო შემდეგ მომდევნო არგუმენტები
ყველა ცვლადები ჩანაცვლებაზე ან ჩანაცვლებითი ჩვენს სტრიქონში.
ვინაიდან ერთად fprintf, პირველი არგუმენტი მართლაც ამ ფაილის * მოუწოდა ნაკადი.
>> Moving უკან მეტი აქ ჩვენი დაქირავება,
ჩვენ უკვე ჩვენი ფაილი * ნაკადი გაიხსნა ჩვენთვის.
სწორედ ამ პირველი ხაზი არ; იხსნება staff.csv ფაილი,
იხსნება ის დამატება რეჟიმში, და ყველა რომ დაუტოვებიათ ჩვენთვის გააკეთოთ
წერენ თანამშრომლები სტრუქტურა, რათა ფაილი.
და, ვნახოთ, ნუ მინდა iPad?
მე გამოიყენოთ iPad. ჩვენ გვყავს ბათილად - მოდით დააყენა ამ მაგიდაზე ისე შეგიძლიათ დაწეროთ ცოტა უკეთესი -
ბათილად დაქირავება და სჭირდება ერთ არგუმენტად, თანამშრომლები სტრუქტურა მოუწოდა s.
Got ჩვენი braces, გვაქვს ჩვენი ფაილი * მოუწოდა ფაილი,
ჩვენ გვაქვს ჩვენი fopen ხაზის მოცემული ჩვენთვის,
და მე უბრალოდ წერენ, როგორც წერტილების რადგან უკვე pedia.
და მერე ჩვენი მომავალი ხაზი, ჩვენ ვაპირებთ ზარი fprintf
და ჩვენ ვაპირებთ კორიდორი ფაილი რომ ჩვენ გვინდა ბეჭდვა,
და მაშინ ჩვენი სტრიქონში, რომელიც -
მე მოგცემთ ბიჭებს მითხრათ რა გამოიყურება.
როგორ შესახებ თქვენ, Stella? იცით, რა პირველი ნაწილი სტრიქონში ჰგავს?
[Stella] არ ვარ დარწმუნებული. >> შეგიძლიათ ვთხოვო ჯიმი.
იცით, ჯიმი?
[Jimmy] უნდა იყოს მხოლოდ ბოლო? მე არ ვიცი. მე არ ვარ დარწმუნებული მთლიანად.
>> Okay. როგორ შესახებ, საერთოდ ვინმე ამ სწორი on გამოცდა?
პოსტები ყველა უფლება.
თურმე აქ ყველა ჩვენ უნდა გავაკეთოთ არის გვინდა თითოეული ნაწილი ჩვენი თანამშრომლები სტრუქტურა
უნდა დაიბეჭდოს, როგორც სიმებიანი ჩვენს ფაილი.
ჩვენ მხოლოდ გამოიყენოთ სიმებიანი ჩანაცვლებითი ხასიათი სამი სხვადასხვა დროს, რადგან ჩვენ გვაქვს გვარი
მოჰყვა მძიმით, მაშინ სახელი მოჰყვა მძიმე,
და მაშინ საბოლოოდ Email მისამართი, რომელიც მოსდევს - რომელიც არ არის
fitting ჩემს ეკრანზე - მაგრამ ეს მოჰყვა სტრიქონების გადატანით ხასიათი.
ამიტომ მე ვაპირებ წერენ უბრალოდ დახვდა.
და შემდეგ შემდეგ ჩვენი სტრიქონში,
ჩვენ უბრალოდ უნდა substitutions, რომელიც ჩვენ შედიხართ გამოყენებით dot ნოტაცია
რომ ვნახეთ პრობლემა კომპლექტი 3.
ჩვენ შეგვიძლია გამოვიყენოთ s.last, s.first და s.email
შემცვლელად იმ სამი ღირებულებებს ჩვენს სტრიქონში.
ასე რომ, როგორ, რომ წავიდეთ? აზრი?
დიახ? არარის? შესაძლოა? Okay.
>> საბოლოო რამ, რასაც ჩვენ ვაკეთებთ შემდეგ ჩვენ დაბეჭდილი და შემდეგ ჩვენ გახსნა ჩვენი ფაილი:
როდესაც ჩვენ გახსნა ფაილი, ჩვენ ყოველთვის უნდა გვახსოვდეს, დახუროს იგი.
რადგან, წინააღმდეგ შემთხვევაში ჩვენ დასრულდება მდე ჩამოდის მეხსიერება,
გამოყენებით up ფაილი აღწერებს.
ასე რომ დახუროს ეს, რომელიც ფუნქციას ვიყენებთ? დანიელ?
[დანიელ] fclose? >> Fclose, ზუსტად.
ასე რომ ბოლო ნაწილი ამ პრობლემას იყო სათანადოდ დახურვა ფაილი, გამოყენებით fclose ფუნქცია,
რომელიც უბრალოდ ჰგავს, რომ.
არც ისე გიჟები.
ზემოთ.
ასე რომ პრობლემა 33 წლის ვიქტორინა.
გვექნება აუცილებლად მეტი ფაილის I / O ახლოვდება.
ჩვენ ყველაფერს გავაკეთებთ ცოტა მეტი ლექცია დღეს, ან ნაწილში დღეს,
იმიტომ, რომ ის, რაც ხდება შექმნას ნაყარი ამ დაგეგმილ pset.
მოდით გადაადგილება საწყისი Quiz ამ ეტაპზე. დიახ?
>> [Charlotte]] რატომ fclose (ფაილი) ნაცვლად fclose (staff.csv)?
>> Ah. რადგან გამოდის, რომ - ასე კითხვა, რომელიც დიდი ერთი,
ამიტომ, როდესაც ჩვენ წერენ fclose, ჩვენ წერილობით fclose (ფაილი) ვარსკვლავი ცვლადი
როგორც ეწინააღმდეგებოდა ფაილის სახელი, staff.csv? არის ის, რომ სწორი? Yeah.
მოდით შევხედოთ. თუ მე გადართოთ თავში ჩემი ლეპტოპი,
და მოდით შევხედოთ fclose ფუნქცია.
ამიტომ fclose ფუნქცია ხურავს ნაკადი და სჭირდება წელს მომცეთ ნაკადი, რომ ჩვენ გვინდა დახურვა,
როგორც ეწინააღმდეგებოდა ფაქტობრივი ფაილის სახელი რომ ჩვენ გვინდა დახურვა.
და ეს იმიტომ კულისებში, როდესაც თქვენ გააკეთებთ ზარი fopen,
როდესაც თქვენ გახსენით ფაილი, თქვენ რეალურად გამოყოფის მეხსიერება ინფორმაციის შესანახად ფაილის.
ასე რომ თქვენ არ ფაილის მაჩვენებელი, გააჩნია ინფორმაციას ფაილის,
როგორიცაა ის ღია, მისი ზომა, სადაც თქვენ ამჟამად ფაილის,
ასე რომ თქვენ შეუძლია კითხვა და წერა ზარები, რომ განსაკუთრებული ადგილი ფარგლებში ფაილი.
თქვენ დასრულდება up დახურვის კურსორის ნაცვლად დახურვის ფაილის სახელი.
>> დიახ? [დანიელ] ასე რათა დაქირავება, იტყვით - როგორ მიიღოთ მომხმარებლის შეყვანის?
ამჯამად fprintf ვმოქმედებთ GetString იმ გაგებით, რომ იგი ყველაფერს უბრალოდ დაველოდოთ მომხმარებლის შეყვანის
და გთხოვთ აკრიფოთ ამ - ან დაველოდოთ თქვენ აკრიფოთ ეს სამი რამ?
ან თქვენ უნდა გამოვიყენოთ რაღაც განახორციელოს დაქირავება?
>> Yeah. ასე რომ ჩვენ არა ვართ - კითხვა, როგორ უნდა მიიღოს მომხმარებლის შეყვანის
განსახორციელებლად დაქირავება? და რა გვაქვს აქ Caller of დაქირავება,
გაიარა ამ პერსონალის struct ყველა მონაცემები ინახება struct უკვე.
ამიტომ fprintf შეუძლია მხოლოდ წერენ, რომ მონაცემები პირდაპირ ფაილი.
იქ არ არის ველოდები მომხმარებლის შეყვანის.
მომხმარებლის უკვე მისცა შეყვანის მიერ სათანადოდ აყენებს მას ამ პერსონალის struct.
და რამ, რა თქმა უნდა, რომ შესვენება, თუ ნებისმიერი იმ პოინტერები იყვნენ null,
ამიტომ ჩვენ გადახვევა უკან აქ და შევხედავთ ჩვენი struct.
ჩვენ გვყავს სიმებიანი ბოლო, string პირველი, string ელ.
ახლა ჩვენ ვიცით, რომ ყველა იმ მართლაც, ქვეშ Hood, არის char * ცვლადები.
რომლებიც შეიძლება იყოს ან არ იყოს მიუთითებს null.
ისინი შეიძლება მიუთითებს მეხსიერების შესახებ ბევრი,
იქნებ მეხსიერების on Stack.
ჩვენ ნამდვილად არ ვიცით, მაგრამ თუ რომელიმე ამ მითითებები null, ან არასწორი,
რომ ნამდვილად ავარიული ჩვენი დაქირავება ფუნქცია.
ეს იყო ის, რაც იყო ერთგვარი სცილდება გამოცდა.
ჩვენ არ შემაშფოთებელია შესახებ, რომ.
დიდი. Okay. ასე რომ მოძრავი საწყისი ვიქტორინა.
>> მოდით დახურვა ბიჭი, და ჩვენ ვაპირებთ შევხედოთ pset 4.
ასე რომ, თუ თქვენ ბიჭები შევხედოთ pset Spec, ერთხელ შეგიძლიათ ვებგვერდზე, cs50.net/quizzes,
ჩვენ ვაპირებთ გავლა რამდენიმე მონაკვეთზე პრობლემებზე დღეს.
მე სენსორული Down - მონაკვეთზე კითხვები იწყება მესამე გვერდზე pset სპეც.
და პირველი ნაწილი მოგთხოვთ წავიდეთ და უყუროთ მოკლე on გადამისამართება და მილები.
რომელიც სახის Cool შემოკლებული, გიჩვენებთ რამდენიმე ახალი, გრილ command line tricks რომ თქვენ შეგიძლიათ გამოიყენოთ.
და შემდეგ ჩვენ მივიღეთ რამდენიმე კითხვები თქვენთვის ისევე.
ეს პირველი შეკითხვა ნაკადს, რომლის printf წერს ჩვეულებრივ,
ჩვენ სახის შეეხო მხოლოდ ცოტა მომენტში წინ.
ეს fprintf, რომ ჩვენ უბრალოდ მსჯელობენ იღებს in file * ნაკადი როგორც თავისი არგუმენტი.
fclose იღებს in file * ნაკადი ისევე,
და დაბრუნების ღირებულება fopen გაძლევთ ფაილის * ნაკადი ისევე.
მიზეზი ჩვენ არ მინახავს იმ ადრე, როდესაც ჩვენ შეეხო printf
ეს იმიტომ printf აქვს რა ნაკადი.
და რა ნაკადი რომელსაც იგი წერს
თქვენ გაეცნოთ მოკლე.
ასე რომ აუცილებლად შევხედოთ მას.
>> დღევანდელ მონაკვეთზე, ჩვენ ვაპირებთ გაიგო ცოტა შესახებ GDB,
მას შემდეგ, რაც მეტი ნაცნობი თქვენ მას, მეტი პრაქტიკა თქვენ მასთან ერთად
უკეთესი შეუძლია თქვენ რეალურად ნადირობის down შეცდომებს თქვენი საკუთარი კოდი.
ეს სიჩქარის პროცესის გამართვის up საოცრად.
ასე გამოყენებით printf, ყველა დროის გავაკეთოთ, რომ თქვენ უნდა recompile თქვენი კოდი,
თქვენ უნდა გაუშვათ ისევ, ზოგჯერ თქვენ უნდა გადავიდეთ printf ზარის გარშემო,
კომენტარის გარეთ კოდი, უბრალოდ იღებს ხოლო.
ჩვენი მიზანია ცდილობენ და დარწმუნება იმაში, რომ GDB, შეგიძლიათ არსებითად
printf არაფერი ნებისმიერი პუნქტი თქვენი კოდი და თქვენ არასოდეს არ recompile იგი.
თქვენ არასოდეს არ უნდა დაიწყოს და შენარჩუნებას გამოცნობა სად printf შემდეგი.
პირველი, რაც უნდა გააკეთოთ გადააკოპირეთ ეს ხაზი და მიიღოთ მონაკვეთის კოდი გამორთვა ვებგვერდი.
მე გადაწერა ეს ხაზი კოდი, რომ ამბობს, "wget ​​http://cdn.cs50.net".
მე ვაპირებ კოპირება.
მე ვაპირებ წასვლა მეტი ჩემს ელექტრო მოწყობილობების, დააშორებს ასე რომ თქვენ შეგიძლიათ ნახოთ თუ რა მე ვაკეთებ,
pasting ეს იქ, და როდესაც მე დააჭიროთ, ეს wget ბრძანება სიტყვასიტყვით არის ვებ მისაღებად.
იგი აპირებს გაიყვანოს ქვემოთ ამ ფაილის გამორთვა ინტერნეტი,
და ის აპირებს შეინახავთ მას მიმდინარე დირექტორია.
არის თუ ჩასვათ ჩემი მიმდინარე დირექტორიაში თქვენ ხედავთ, რომ მაქვს ამ section5.zip ფაილი უფლება იქ.
გზა გაუმკლავდეთ, რომ ბიჭი არის unzip იგი,
რომელიც შეგიძლიათ გავაკეთოთ ბრძანება ხაზი, უბრალოდ მოსწონს ეს.
Section5.zip.
რომ ყველაფერს unzip იგი, საქაღალდის შექმნა ჩემთვის,
inflate ყველა შინაარსი, დაუსვან მათ იქ.
ახლა შემიძლია წასვლას ჩემი განყოფილებაში 5 დირექტორია გამოყენებით CD ბრძანება.
წმინდა ეკრანზე გამოყენებით წმინდა. ასე რომ ნათელი ეკრანზე.
ახლა მაქვს ლამაზი სუფთა ტერმინალში გამკლავება.
>> არის თუ სიაში ყველა ფაილი, რომელიც მე ვერ ვხედავ ამ დირექტორიაში,
ხედავთ, რომ მაქვს ოთხი თამაშები: buggy1, buggy2, buggy3 და buggy4.
მე ასევე მივიღე მათი შესაბამისი. გ files.
ჩვენ არ ვაპირებთ შევხედოთ. გ ფაილი არის.
სამაგიეროდ, ჩვენ ვაპირებთ მათ გამოყენებას, როდესაც ჩვენ გახსენით GDB.
ჩვენ ინახება მათ გარშემო ისე, რომ ჩვენ გვაქვს წვდომა ფაქტობრივი კოდის როდესაც ჩვენ გამოყენებით GDB,
მაგრამ მიზანი ამ ნაწილის მონაკვეთის არის Tinker გარშემო GDB
და ვნახოთ, როგორ შეგვიძლია გამოვიყენოთ რომ გაერკვნენ, რა ხდება ცუდი თითოეულ ამ ოთხი buggy პროგრამები.
ასე რომ ჩვენ უბრალოდ აპირებს გარშემო ოთახში მართლაც სწრაფად,
და მე ვაპირებ ვკითხო ვინმეს გასაშვებად ერთი buggy პროგრამების,
და მაშინ ჩვენ წავიდეთ როგორც ჯგუფის მეშვეობით GDB და ვნახავთ, თუ რა შეგვიძლია გავაკეთოთ დაფიქსირება ამ პროგრამების,
ან მინიმუმ იდენტიფიცირება რა ხდება არასწორი თითოეულ მათგანს.
დავიწყოთ მეტი აქ დენიელ. თუ თქვენ აწარმოებს buggy1? ვნახოთ, რა მოხდება.
[დანიელ] განცხადებაში ნათქვამია, იქ განაცხადის ბრალია. >> Yeah. სწორედ.
ასე რომ, თუ მე აწარმოებს buggy1, მივიღებ seg ბრალია.
ამ ეტაპზე, მე ვერ წავიდეს და გახსენით buggy1.c,
სცადეთ და გაერკვნენ, თუ რა ხდება არასწორი,
მაგრამ ერთ ერთი ყველაზე ObnoXious რამ ამ seg ბრალია შეცდომა
ის არის, რომ ეს არ გითხრათ რა ხაზის პროგრამის რამ რეალურად წავიდა არასწორია და გატეხა.
თქვენ სახის უნდა შევხედოთ კოდი
და გაერკვნენ გამოყენებით ამოიცნობთ და შემოწმება ან printf დაინახოს რა ხდება არასწორი.
ერთი coolest რამ GDB ის არის, რომ ეს მართლაც, მართლაც ადვილი
გაერკვნენ ხაზი, რომლის დროსაც თქვენი პროგრამის დამსხვრევაზე.
ეს სრულიად ღირს მის გამოყენებას, მაშინაც კი, თუ მხოლოდ, რომ.
ასე რომ ჩატვირთვისას up GDB, I ტიპის GDB, და მერე მისცეს მას გეზი შესრულებადი რომ მინდა აწარმოებს.
აქ მე აკრეფის GDB ./buggy1.
'Enter. მაძლევს ყველა ამ საავტორო უფლებების შესახებ ინფორმაციის
და ქვევით აქ თქვენ ნახავთ ამ ხაზის რომ ამბობს, "წაკითხვის სიმბოლიკა საწყისი / მთავარი /
jharvard/section5/buggy1. "
და თუ ყველაფერი კარგად იქნება, თქვენ ნახავთ ეს ამობეჭდოთ გაგზავნა, რომ ასე გამოიყურება.
იგი ყველაფერს წაიკითხა სიმბოლიკა, ეს კიდე ამბობენ "მე კითხულობს სიმბოლიკა თქვენი შესრულებადი ფაილი"
და მაშინ ექნება ამ "კეთდება" გაგზავნა მეტი აქ.
თუ ხედავთ რაიმე სხვა ვარიაცია ამ, ან ხედავთ იგი ვერ იპოვა სიმბოლიკა
ან რამე მაგდაგვარს, რა, რაც იმას ნიშნავს, რომ თქვენ უბრალოდ არ შედგენილი თქვენი შესრულებადი სათანადოდ.
როდესაც ჩვენ კომპილაციის პროგრამების გამოყენება GDB, ჩვენ უნდა გამოვიყენოთ, რომ სპეციალური გ დროშა,
და ეს გაკეთდეს იყოს თუ კომპილაციის თქვენი პროგრამების, უბრალოდ აკრეფით მიიღოს
ან buggy ან ფეხზე, ნებისმიერი იმ.
მაგრამ თუ თქვენ შედგენის ხელით Clang, მაშინ თქვენ უნდა წავიდეს და მოიცავს რომ-G დროშა.
>> ამ ეტაპზე, არის, რომ ჩვენ გვაქვს ჩვენი GDB სწრაფი,
ეს საკმაოდ მარტივი პროგრამის გაშვება.
ჩვენ შეგიძლიათ აკრიფოთ პერსპექტივაში, ან ჩვენ შეგვიძლია უბრალოდ აკრიფეთ R.
ყველაზე GDB ბრძანებები შეიძლება შემოკლებით.
ჩვეულებრივ მხოლოდ ერთი ან რამდენიმე ასოს, რომელიც საკმაოდ ლამაზი.
ამიტომ Saad, თუ Type R და დააჭიროთ, რა ხდება?
[Saad] მე მივიღე SIGSEGV, სეგმენტაცია ბრალია, და შემდეგ ყველა ამ gobbledygook.
>> Yeah.
მსგავსად ჩვენ ვხედავთ ეკრანზე ახლავე, და მოსწონს Saad განაცხადა,
როდესაც ვწერთ run ან R და დააჭიროთ, ჩვენ მაინც იგივე seg ბრალია.
ასე გამოყენებით GDB არ გადაჭრას ჩვენი პრობლემა.
მაგრამ ეს გვაძლევს რამდენიმე gobbledygook, და აღმოჩნდება, რომ ამ gobbledygook
ფაქტობრივად გვეუბნება, სადაც ეს ხდება.
გარჩევის ამ ცოტა, ამ პირველი bit არის ფუნქცია, რომელიც ყველაფერს ხდება არასწორი.
არსებობს ამ __ strcmp_sse4_2, და ეს გვეუბნება, რომ ეს ხდება ამ ფაილის
მოუწოდა sysdeps/i386, ეს ყველაფერი, ისევ და ისევ, სახის არეულობა - მაგრამ ხაზი 254.
სწორედ ამგვარი მძიმე გარჩევის. ჩვეულებრივ, როდესაც თქვენ ხედავთ, პერსონალის მოსწონს,
რაც იმას ნიშნავს, რომ ის seg faulting ერთ სისტემის ბიბლიოთეკებს.
ასე რომ რაღაც არ უკავშირდება strcmp. თქვენ ბიჭები ვნახეთ strcmp ადრე.
არც ისე გიჟები, მაგრამ ნიშნავს ეს რომ strcmp ბრალია ან რომ არსებობს პრობლემა strcmp?
როგორ ფიქრობთ, ალექსანდრე?
[ალექსანდრე] არის, რომ - არის 254 სტრიქონში? და - არა ორობითი, მაგრამ არა მათი ჭერი,
და შემდეგ იქ სხვა ენაზე თითოეული ფუნქცია. ის არის, რომ 254 წელს, რომ ფუნქცია, ან -?
>> ეს ხაზი 254. როგორც ჩანს ამ. ფაილური, ამიტომ ასამბლეა კოდი ალბათ.
>> მაგრამ, ვფიქრობ, კიდევ უფრო მწვავე რამ არის, რადგან ჩვენ მიღებული seg ბრალია,
და როგორც ჩანს ის მოდის strcmp ფუნქცია,
ამჯამად ამ გულისხმობს, მაშინ, რომ strcmp ბრალია?
ეს არ უნდა, იმედია. ასე მხოლოდ იმიტომ, რომ თქვენ გაქვთ სეგმენტაცია ბრალია
ერთ სისტემის ფუნქციები, როგორც წესი, ეს იმას ნიშნავს რომ თქვენ უბრალოდ არ უწოდა სწორად.
სწრაფი რამ რაც უნდა გააკეთოთ, რათა გაერკვნენ, რა რეალურად მიმდინარეობს
როდესაც ხედავთ რაღაც Crazy მოსწონს, როცა ხედავთ seg ბრალია,
განსაკუთრებით იმ შემთხვევაში, თუ თქვენ გაქვთ პროგრამა, რომელიც იყენებს მხოლოდ ძირითად,
გამოყენება backtrace.
მე abbreviate backtrace წერილობით BT, როგორც ეწინააღმდეგებოდა სრული backtrace სიტყვა.
მაგრამ შარლოტა, რა მოხდება მაშინ, როდესაც თქვენ ტიპი BT და დააჭიროთ?
[Charlotte] აქედან ჩანს, ჩემთვის ორ ხაზს, ხაზის 0 და ხაზი 1.
>> Yeah. ასე ხაზის 0 და ხაზი 1.
ეს არის ფაქტობრივი დასტის ფარგლებში, რომლებიც ამჟამად პიესა როდესაც თქვენი პროგრამის შეეჯახა.
დაწყებული ზედოთ მდებარე ჩარჩო, ჩარჩოში 0, და აპირებს ქვედა საუკეთესო, რომელიც ჩარჩოში 1.
ჩვენი ზედოთ მდებარე ჩარჩო არის strcmp ჩარჩო.
შეგიძლიათ წარმოიდგინოთ, რომ ეს მსგავსი პრობლემა ჩვენ უბრალოდ აკეთებდა Quiz ერთად პოინტერები,
სადაც ჩვენ გვქონდა სვოპ დასტის ჩარჩოს თავზე ძირითადი დასტის ჩარჩო,
და ჩვენ გვქონდა ცვლადები რომ swap იყენებდა თავზე ცვლადები, რომ მთავარი იყო გამოყენებით.
აქ ჩვენი კრახი მოხდა ჩვენი strcmp ფუნქცია, რომელიც ეწოდა ჩვენი მთავარი ფუნქცია,
და backtrace გვაძლევს არა მხოლოდ ფუნქციების რომელშიც რამ ვერ მოახერხა,
მაგრამ ასევე გვეუბნება სადაც ყველაფერი დამირეკეს.
ასე რომ, თუ მე გადახვევა მეტი ცოტა მეტი მარჯვნივ,
ვხედავთ, რომ ჰო, ვიყავით on line 254 ამ strcmp-sse4.s ფაილი.
მაგრამ ზარის გაკეთდა buggy1.c, ხაზის 6.
ასე რომ, რაც იმას ნიშნავს, რომ ჩვენ შეგვიძლია გავაკეთოთ - არის შეგვიძლია უბრალოდ შეამოწმეთ და ვნახოთ რა ხდებოდა
ზე buggy1.c, ხაზის 6.
ერთხელ, არის რამდენიმე გზა ამის გაკეთება. ერთი არის გასასვლელად გარეთ GDB
ან აქვს თქვენი კოდი გაიხსნება მეორე ფანჯარა და ჯვარი მინიშნება.
, რომ და თავისთავად არის საკმაოდ მოსახერხებელი, ვინაიდან, ახლა, თუ თქვენ ოფისში საათის
და თქვენ მოხვდით seg ბრალია და თქვენი TF ის გაინტერესებთ, სადაც ყველაფერი იყო დარღვევის,
შეგიძლიათ უბრალოდ, ვამბობთ, "ო, ხაზის 6. არ ვიცი რა ხდება,
მაგრამ რაღაც შესახებ ხაზი 6 რამ გამოიწვია ჩემი პროგრამა მოხსნა. "
სხვა გზა ამის გასაკეთებლად არის შეგიძლიათ გამოიყენოთ ეს ბრძანება მოუწოდა სიაში GDB.
თქვენ ასევე შეგიძლიათ abbreviate იგი ლ.
ასე რომ, თუ ჩვენ მოხვდა ლ, რას მივიღებთ აქ?
ჩვენ კიდევ მთელი bunch of უცნაური ნივთები.
ეს არის ფაქტობრივი ასამბლეის კოდი
რომ არის strcmp_sse4_2.
ეს გამოიყურება სახის ხმაურიანი,
და მიზეზი ჩვენ ვიღებთ ეს იმიტომ ახლავე,
GDB აქვს ჩვენთვის ჩარჩო 0.
>> ასე რომ ნებისმიერ დროს შევხედავთ ცვლადები, ნებისმიერ დროს შევხედავთ კოდებს,
ჩვენ შევხედავთ კოდის რომ ეხება დასტის ჩარჩო ჩვენ გაკეთებული სისტემაში
ასე მისაღებად არაფერი აზრიანი, ჩვენ უნდა
გადასვლის დასტის ჩარჩო ხდის უფრო გრძნობა.
ამ შემთხვევაში, მთავარ დასტის ჩარჩო გახდის უფრო გრძნობა,
იმიტომ, რომ იყო ფაქტიურად კოდი, რომ ჩვენ წერდა.
არ strcmp კოდი.
გზით თქვენ შეგიძლიათ გადაადგილება შორის ფარგლებში, ამ შემთხვევაში, იმიტომ რომ ჩვენ გვაქვს ორი,
ჩვენ გვყავს 0 და 1,
თქვენ აკეთებთ, რომ up და down ბრძანებები.
თუ მე გადაადგილება ერთ ჩარჩოში,
ახლა მე ძირითად დასტის ჩარჩო.
შემიძლია ქვევით დაბრუნდეს იქ, სადაც მე ვიყავი,
ახვიდეთ ერთხელ, ქვევით კიდევ ერთხელ, და წავიდეთ ისევ.
თუ თქვენ ოდესმე გააკეთოს თქვენი პროგრამის GDB, თქვენ ავარიის, თქვენ backtrace,
და ხედავთ, რომ ზოგიერთ ფაილი, რომ თქვენ არ ვიცი რა ხდება.
თქვენ ცდილობენ სია, კოდი არ გამოიყურება ნაცნობი თქვენ,
შეხედეთ თქვენს ფარგლებში და გაერკვნენ, სადაც ხართ.
თქვენ ალბათ არასწორი დასტის ჩარჩო.
ან თუნდაც თქვენ დასტის ჩარჩო რომ არ არის ერთი, რომ შეგიძლიათ ნამდვილად გამართვის.
არის, რომ ჩვენ შესაბამის დასტის ჩარჩო, ჩვენ მთავარ,
ახლა ჩვენ შეგვიძლია გამოვიყენოთ სია ბრძანება გაერკვნენ, რა ხაზი.
და შეგიძლიათ მისი დანახვა; მას დაბეჭდილი ეს ჩვენთვის უფლება აქ.
მაგრამ ჩვენ შეგვიძლია მოხვდა სიაში ყველა იგივე, და სიაში გვაძლევს ამ ლამაზი ამონაწერი
ფაქტობრივი კოდის რომ ხდება აქ.
>> კერძოდ, ჩვენ შეგვიძლია შევხედოთ ხაზის 6.
ჩვენ ვხედავთ, რა ხდება აქ.
და როგორც ჩანს ჩვენ მიღების სიმებიანი შედარებით
შორის სტრიქონი "CS50 კლდეები" და argv [1].
რაღაც ამ წელს crashing.
ამიტომ მისის, გაქვთ რაიმე მოსაზრებები იმის შესახებ, თუ რა შეიძლება იყოს ხდება?
[Missy] არ ვიცი, რატომ ის crashing. >> თქვენ არ ვიცი რატომ ის crashing?
ჯიმი, ნებისმიერი აზრები?
[Jimmy] მე არ ვარ მთლიანად დარწმუნებული, მაგრამ ბოლო დროს ჩვენ გამოიყენება სტრინგის შევადარებთ,
ან strcmp, გვქონდა, როგორიც სამი სხვადასხვა შემთხვევებში მის ქვეშ.
ჩვენ არ გვქონდა ==, მე არ ვფიქრობ, სწორედ რომ პირველ ხაზზე.
ამის ნაცვლად იგი დაყოფილია სამ, ხოლო ერთი იყო == 0,
ერთი იყო <0, ვფიქრობ, და ერთი იყო> 0.
იქნებ რამე მაგდაგვარს? >> Yeah. ასე რომ არსებობს ამ საკითხის
საქართველოს ვაკეთებთ შედარებით სწორად?
Stella? ნებისმიერი აზრები?
[Stella] არ ვარ დარწმუნებული. >> დარწმუნებული არ არის. დანიელ? ფიქრები? Okay.
თურმე რა ხდება სწორედ აქ არის, როდესაც ჩვენ გაიქცა პროგრამა
და მივიღეთ seg ბრალია, როდესაც თქვენ გაიქცა პროგრამა პირველად, დანიელ,
არ მისცეს მას ნებისმიერი ბრძანების ხაზი არგუმენტები?
[დანიელ] მდებარ >> პოსტები ამ შემთხვევაში, რა არის ღირებულება argv [1]?
>> არ არსებობს ღირებულება. >> მარჯვენა.
ისე, არ არსებობს შესაბამისი სიმებიანი ღირებულება.
თუმცა, არსებობს გარკვეული მნიშვნელობა. რა არის ღირებულება რომ იღებს შენახული იქ?
>> ნაგვის მნიშვნელობა? >> ეს არც ნაგვის ღირებულება ან, ამ შემთხვევაში,
ბოლოს argv მასივი ყოველთვის წყდება ერთად null.
ასე რომ, რეალურად რა გაბმულ შენახული არსებობს null.
სხვა გზა მოსაგვარებლად, ვიდრე ფიქრი ის მეშვეობით,
ასეთია ბეჭდვას ის.
ეს არის სადაც მე ამბობდა, რომ გამოყენებით GDB დიდია,
იმიტომ, რომ თქვენ შეგიძლიათ ამობეჭდოთ ყველა ცვლადები, ყველა ღირებულებები, რომ გსურთ
გამოყენებით ამ მოსახერხებელი-Dandy P ბრძანება.
ასე რომ, თუ მე აკრიფოთ P და მერე აკრიფოთ ღირებულების ცვალებად და სახელით ცვლადი,
ამბობენ, argc, ვხედავ, რომ argc არის 1.
თუკი მინდა ამობეჭდოთ argv [0], მე შემიძლია ამის გაკეთება, ისევე, როგორც, რომ.
და როგორც ვნახეთ, argv [0] ყოველთვის სახელი თქვენი პროგრამა,
ყოველთვის სახელით გაშვება.
აქ ხედავთ ის მივიღე სრული გეზი სახელი.
შემიძლია ასევე ამობეჭდოთ argv [1] და ვნახოთ, რა მოხდება.
>> აქ მივიღეთ ამგვარი მისტიკური მნიშვნელობა.
ჩვენ ამ 0x0.
დამახსოვრება დასაწყისში ტერმინი, როდესაც ჩვენ ვისაუბრეთ თექვსმეტობითი ციფრები?
ან რომ პატარა შეკითხვა დასასრულს pset 0 შესახებ, თუ როგორ უნდა წარმოადგინოს 50 in hex?
გზა ჩვენ წერენ hex ნომრები CS, მხოლოდ იმიტომ, რომ არ აღრეული საკუთარ თავს
ერთად ათობითი რიცხვები, არის ჩვენ ყოველთვის პრეფიქსი მათ 0x.
ასე რომ, ეს პრეფიქსი 0x ყოველთვის მხოლოდ იმას ნიშნავს, ინტერპრეტაცია ნომერზე როგორც რიცხვი,
არა როგორც ტექსტი, არა როგორც ათობითი რიცხვი, არა როგორც ორობითი რიცხვი.
მას შემდეგ, რაც ხმების 5-0 არის სწორი ნომერი თექვსმეტობითი.
და ეს ნომერი ათობითი, 50.
ასე რომ, ეს არის, თუ რამდენად ჩვენ disambiguate.
ასე 0x0 საშუალებით თექვსმეტობითი 0, რომელიც არის ასევე ათობითი 0, ორობითი 0.
უბრალოდ ღირებულება 0.
თურმე ეს რა null არის, ფაქტობრივად, მეხსიერებაში.
Null მხოლოდ 0.
აქ ელემენტს ინახება argv [1] არის null.
ამიტომ, ჩვენ ვცდილობთ შედარების ჩვენი "CS50 კლდეები" string to null სიმებიანი.
ამიტომ dereferencing null, ცდილობს შედიხართ რამ საათზე null,
იმ ტიპიურად აპირებს გამოიწვიოს გარკვეული სეგმენტაცია ბრალია ან სხვა ცუდი რამ მოხდეს.
და აღმოჩნდება, რომ strcmp არ შეამოწმეთ
თუ არა თქვენ წელს მიღებული ღირებულების რომ null.
პირიქით, ის მხოლოდ მიდის წინ, ცდილობს თავისი ნივთი,
და თუ ეს seg ხარვეზებით, ეს seg ხარვეზებით, და ეს თქვენი პრობლემაა. თქვენ უნდა წავიდეს გაასწორონ ის.
მართლაც სწრაფად, როგორ შეიძლება ჩვენ დაფიქსირება ამ პრობლემას? Charlotte?
[Charlotte] თქვენ შეგიძლიათ შეამოწმოთ გამოყენებით, თუ.
ასე რომ, თუ argv [1] არის null, == 0, მაშინ დაბრუნდებიან 1, ან რაღაც [გაუგებარია].
>> Yeah. ასე რომ ერთი დიდი გზა ამის გაკეთება, როგორც შეგვიძლია შეამოწმეთ,
ღირებულება ჩვენ შესახებ გაიაროს შევიდა strcmp, argv [1], რომელიც მას null?
თუ ეს null, მაშინ შეგვიძლია ვთქვათ, okay, შეწყვეტილია.
>> გავრცელებული გზა ამის გამოყენება argc ღირებულება.
თქვენ ხედავთ, სწორედ აქ დასაწყისში ძირითად,
ჩვენ გამოტოვებული რომ პირველი გამოცდა რომ ჩვენ, როგორც წესი, როდესაც ჩვენ ვიყენებთ command line არგუმენტები,
რაც შესამოწმებლად თუ არა ჩვენი argc ღირებულება არის ის, რაც ჩვენ ველით.
ამ შემთხვევაში, ჩვენ ველოდებით მინიმუმ ორი არგუმენტები,
პროგრამის დასახელება პლუს ერთი სხვა.
იმის გამო, რომ ჩვენ უნდა გამოვიყენოთ მეორე არგუმენტი უფლება აქ.
ასე რომ გარკვეული სახის ტესტი წინასწარ, სანამ ჩვენი strcmp ზარის
რომ ტესტები თუ არა argv მინიმუმ 2, ასევე იგივე სახის რამ.
ჩვენ ვხედავთ, თუ, რომელიც მუშაობს მიერ გაშვებული პროგრამა ერთხელ.
თქვენ ყოველთვის შეგიძლიათ გადატვირთეთ პროგრამა ფარგლებში GDB, რომელიც მართლაც ლამაზი.
თქვენ შეგიძლიათ აწარმოებს, და როდესაც თქვენ კორიდორი არგუმენტები თქვენი პროგრამა,
თქვენ გაივლით მათ როცა რეკავთ აწარმოებს, არ როდესაც თქვენ ჩატვირთვისას up GDB.
ამ გზით თქვენ შეგიძლიათ შეინახოთ თქვენი ხელმძღვანელობა არა მარტო აპელირებს პროგრამის სხვადასხვა არგუმენტები ყოველ ჯერზე.
ასე აწარმოებს, ან ისევ და ისევ, მე შემიძლია Type R, და ვნახოთ რა მოხდება, თუ ჩვენ აკრიფოთ "Hello".
იგი ყოველთვის გკითხოთ, თუ გნებავთ დაიწყოთ იგი თავიდანვე ერთხელ.
ჩვეულებრივ, თქვენ გვინდა, რომ დაიწყოს ის დასაწყისში კვლავ.
და ამ ეტაპზე, ეს restarts კიდევ ერთხელ, ეს ბეჭდავს out
პროგრამა, რომელიც ჩვენ გაშვებული, buggy1, ერთად არგუმენტი Hello,
და ეს ბეჭდავს ამ სტანდარტის გარეთ, ის ამბობს: "თქვენ მიიღეთ D," სამწუხარო სახე.
მაგრამ ჩვენ არ seg ბრალია. მისი თქმით, პროცესის დასრულების ნორმალურად.
ასე რომ გამოიყურება საკმაოდ კარგი.
არა seg ბრალია, ჩვენ გახადა წარსულში,
ასე გამოიყურება, რომ მართლაც seg ბრალია bug რომ ჩვენ იღებდნენ.
სამწუხაროდ, გვეუბნება, რომ ჩვენ ვიღებთ დ
>> ჩვენ შეგვიძლია უკან და შევხედოთ კოდი და ვნახოთ რა ხდებოდა იქ
გაერკვნენ, თუ რა იყო - რატომ გახდა გვეუბნებოდა, რომ ჩვენ მივიღეთ დ
ვნახოთ, აქ იყო ამ printf ვამბობ, რომ შენ დ
თუ ჩვენ ტიპების სიას, როგორც თქვენ გაქვთ აკრეფით სიაში, ის ინახავს iterating ქვემოთ საშუალებით თქვენი პროგრამა,
ასე რომ შენ გაჩვენებ პირველი რამდენიმე ხაზი თქვენი პროგრამა.
მაშინ შენ გაჩვენებ მომდევნო რამდენიმე ხაზით და შემდეგი ბლოკი და შემდეგი ბლოკი.
და ეს გავაგრძელებთ ცდილობს დაცემას.
და ახლა ჩვენ მისაღებად "ხაზის ნომერზე 16 არის საზღვრებს სცილდება."
იმიტომ, რომ ეს მხოლოდ 15 ხაზები.
თუ თქვენ გაქვთ ამ წერტილი და თქვენი გაინტერესებთ, "რა გავაკეთო?" თქვენ შეგიძლიათ გამოიყენოთ დახმარება ბრძანება.
დახმარება და შემდეგ მისცეს მას სახელით ბრძანება.
და ხედავთ GDB გვაძლევს ყველა ამ სახის ნივთები.
იგი ამბობს: "ერთად არ არგუმენტი, ჩამოთვლილია ათი მეტი ხაზების შემდეგ ან გარშემო წინა ჩამონათვალი.
სია - ჩამოთვლილია ათი ხაზები ადრე - "
მოდით სცადეთ სია მინუს.
და რომ ჩამოთვლილია 10 ხაზები წინა; შეგიძლიათ ითამაშოთ გარშემო სია ცოტა.
ამის გაკეთება შეგიძლიათ სია, სია - თქვენ შეგიძლიათ კიდევ მისცეს სიაში ნომერი, როგორიც სიაში 8,
და ეს კიდე სიაში 10 ხაზები გარშემო ხაზი 8.
და თქვენ შეგიძლიათ ნახოთ თუ რა ხდება აქ თქვენ მოხვდით მარტივი, თუ სხვაგან.
თუ თქვენ აკრიფოთ CS50 კლდეები, იგი ბეჭდავს out "თქვენ ა"
წინააღმდეგ შემთხვევაში ეს ბეჭდავს out "თქვენ დ"
Bummer ქალაქში. ყველა უფლება. დიახ?
>> [დანიელ] ასე რომ, როდესაც მე შევეცადე აკეთებს CS50 ქანების გარეშე შეთავაზებები,
იგი ამბობს: "შენ კიდევ დ"
მჭირდებოდა შეთავაზებები მიიღოს ეს მუშაობა, რატომ არის, რომ?
>> Yeah. თურმე, როდესაც - ეს არის კიდევ ერთი პატარა fun tidbit -
როდესაც თქვენ აწარმოებს პროგრამა, თუ ჩვენ გაუშვით და ჩვენ აკრიფოთ CS50 კლდეები,
ისევე, როგორც დანიელ ამბობდა მან გააკეთა, და თქვენ 'Enter,
ის კვლავ აცხადებს, მივიღებთ დ
და კითხვაზე, თუ რატომ არის ეს?
და აღმოჩნდება, რომ ორივე ჩვენი ტერმინალი და GDB გარჩევის ეს როგორც ორი დამოუკიდებელი არგუმენტები.
რადგან, როდესაც არსებობს სივრცე, რომ იგულისხმება როგორც
პირველი არგუმენტი დასრულდა; შემდეგი არგუმენტი დაიწყო.
გზა დააკავშიროთ იმ ორ, ან უკაცრავად, ერთ არგუმენტს,
გამოყენება შეთავაზებები.
ახლა, თუ ჩვენ დააყენოს ის შეთავაზებები და გაუშვით ერთხელ, მივიღებთ ა
ასე რომ მხოლოდ recap, არ შეთავაზებები, CS50 და კლდეები, გაანალიზება, როგორც ორი დამოუკიდებელი არგუმენტები.
With შეთავაზებები, ის გაანალიზება, როგორც ერთი არგუმენტი საერთოდ.
>> ჩვენ ვხედავთ ამ breakpoint.
აქამდე ჩვენ გაშვებული ჩვენი პროგრამა და ეს უკვე გაშვებულია
სანამ არც ის seg ხარვეზებით ან Hits შეცდომა
ან სანამ იგი აღელვებული ადევნებს თვალყურს და ყველა მთლიანად ჯარიმა.
ეს არ არის აუცილებლად საუკეთესო გამოსადეგი რამ, რადგან ზოგჯერ
თქვენ გაქვთ შეცდომა თქვენს პროგრამაში, მაგრამ ეს არ იწვევს სეგმენტაცია ბრალია.
ეს არ იწვევს თქვენი პროგრამის შეჩერება ან არაფერი რომ.
გზა GDB პაუზის თქვენი პროგრამის განსაკუთრებული წერტილი
არის მითითებული breakpoint.
თქვენ შეგიძლიათ ან ამის გაკეთება მიიღწევა breakpoint on ფუნქციის სახელი
ან თქვენ დააჭერთ breakpoint კონკრეტულ ხაზი კოდი.
მე მიყვარს მითითებული breakpoints on ფუნქციის სახელები, რადგან - ადვილად დასამახსოვრებელი,
და თუ თქვენ ნამდვილად წავიდეს და შეცვალოს თქვენი კოდის up ცოტა,
მაშინ თქვენი breakpoint რეალურად დარჩება ერთი და იგივე ადგილზე განმავლობაში თქვენი კოდი.
ხოლო თუ თქვენ იყენებთ ხაზის ნომრები და ხაზის ნომრები შეიცვლება
იმიტომ, რომ თქვენ დაამატოთ ან წაშალოთ რამდენიმე კოდი, მაშინ თქვენი breakpoints ყველა მთლიანად ბრალია.
ერთი ყველაზე გავრცელებული რამ გავაკეთო არის მითითებული breakpoint მთავარ ფუნქციას.
ხშირად მე ჩატვირთვისას up GDB, მე აკრიფოთ ბ მთავარ, დააჭიროთ და რომ ნახავთ მითითებული breakpoint
მთავარ ფუნქციას, რომელიც მხოლოდ ამბობს: "პაუზის პროგრამა, როგორც კი თქვენ დაიწყოს გაშვებული,"
და რომ გზა, როცა აწარმოებს ჩემი პროგრამა, ვთქვათ, CS50 ქანების როგორც ორი არგუმენტები
და 'Enter, იგი იღებს ძირითად ფუნქციას და იგი შეწყვეტს უფლება პირველივე ხაზი,
უფლება სანამ აფასებს strcmp ფუნქცია.
>> მას შემდეგ, რაც მე ათვისება, ახლა შემიძლია დაიწყოს mucking გარშემო და ხედავს რა ხდება
ყველა ცვლადის სხვადასხვა, რომლებიც შევიდა ჩემი პროგრამა.
აქ შეგიძლიათ ამობეჭდოთ argc და ვნახოთ რა ხდება.
ვხედავთ, რომ argc არის 3, იმიტომ რომ მიიღო 3 სხვადასხვა ღირებულებების იგი.
ეს სახელწოდება მიიღეს პროგრამის, ის მივიღე პირველი არგუმენტი და მეორე არგუმენტი.
ჩვენ შეგვიძლია ბეჭდვა იმ მიერ ეძებს argv [0], argv [1], და argv [2].
ახლა თქვენ შეგიძლიათ ასევე, თუ რატომ ეს strcmp ზარის აპირებს ვერ,
რადგან ხედავთ, რომ ეს გაყოფილი up CS50 და ქანების ორ ცალკე არგუმენტები.
ამ ეტაპზე, რომ ერთხელ თქვენ მოხვდა breakpoint, შეგიძლიათ გაგრძელდება დახევას საშუალებით თქვენი პროგრამა
ხაზს, როგორც ეწინააღმდეგებოდა დაწყებული თქვენი პროგრამის ერთხელ.
ასე რომ, თუ თქვენ არ გსურთ დაიწყოს თქვენი პროგრამის ერთხელ და მხოლოდ გაგრძელდება, აქ
თქვენ შეგიძლიათ გამოიყენოთ გაგრძელდეს ბრძანება და გაგრძელდება მიიღებს პროგრამის ბოლომდე.
ისევე, როგორც ეს მოხდა აქ.
თუმცა, თუ მე გადატვირთეთ პროგრამა, CS50 კლდეები, ეს ურტყამს ჩემი breakpoint ერთხელ,
და ამ დროს, თუ არ გვინდა, უბრალოდ წავიდეთ ყველა გზა მეშვეობით დანარჩენი პროგრამა,
მე შეიძლება გამოიყენოს შემდეგი ბრძანება, რომელიც მე ასევე abbreviate ერთად n.
და ეს იქნება დაიხევს მეშვეობით პროგრამა ხაზს.
ასე, რომ თქვენ შეგიძლიათ უყუროთ როგორც რამ შეასრულოს, როგორც ცვლადებს ენის, როგორც რამ მიიღებთ განახლება.
რომელიც საკმაოდ ლამაზი.
სხვა cool რამ არის ვიდრე იმეორებს იმავე ბრძანების გამო და უსასრულოდ,
თუ თქვენ უბრალოდ დააჭირეთ - აქ ხედავთ მე არ აკრეფილი არაფერი -
თუ უბრალოდ დააჭიროთ, ის გაიმეოროს წინა ბრძანება,
ან წინა GDB ბრძანება, რომ მე უბრალოდ დააყენა სისტემაში
შემიძლია შენარჩუნება hitting შეიყვანეთ და ეს გავაგრძელებთ სტეპინგზე მეშვეობით ჩემი კოდი ხაზს.
მინდა მოგიწოდებთ თქვენ ბიჭებს წასვლა შეამოწმეთ სხვა buggy პროგრამების ასევე.
ჩვენ არ გვაქვს დრო, რომ მიიღოთ მეშვეობით ყველა მათგანი დღეს ნაწილში.
კოდის არსებობს, ასე რომ თქვენ შეგიძლიათ სახის ხედავთ რა ხდება
კულისებში თუ თქვენ გაქვთ დავრჩებოდით, ნამდვილად,
მაგრამ სულ მცირე, უბრალოდ პრაქტიკაში ჩატვირთვისას up GDB,
გაშვებული პროგრამის სანამ არღვევს თქვენ,
მიღების backtrace, მჭიდროდაა გარეთ რა ფუნქცია ავარიის იყო,
რა ხაზის ეს იყო, დაბეჭდვისას რამდენიმე ცვლადი ღირებულებებს,
უბრალოდ, ასე რომ თქვენ მიიღოთ შეგრძნებას, რადგან, რომელიც ნამდვილად დაგეხმარებათ წინსვლის.
ამ ეტაპზე, ჩვენ ვაპირებთ დატოვა გარეთ GDB, რომელიც თქვენ ჩვენგან გამოყენებით დატოვა ან უბრალოდ Q.
თუ თქვენი პროგრამა შუა გაშვებული მაინც, და ეს არ იწურება ვადა,
იგი ყოველთვის გკითხოთ, "დარწმუნებული ხართ რომ გინდათ გასვლა?"
შეგიძლიათ უბრალოდ მოხვდა დიახ.
>> ახლა ჩვენ ვაპირებთ შევხედოთ შემდეგი პრობლემა გვაქვს, რომელიც cat პროგრამა.
თუ თქვენ უყურებთ მოკლე on გადამისამართება და მილები, დაინახავთ, რომ Tommy იყენებს ამ პროგრამას
რომ ძირითადად ბეჭდავს ყველა გამოშვება ფაილი ეკრანზე.
ასე რომ, თუ მე აწარმოებს კატა, ეს არის რეალურად ჩამონტაჟებული პროგრამის ელექტრო მოწყობილობების,
და თუ თქვენ გაქვთ Macs ამისათვის თქვენს Mac ძალიან, თუ თქვენ გახსენით ტერმინალი.
და ჩვენ - კატა, ასე ვთქვათ, cp.c, და დააჭიროთ.
რა ეს ასე, თუ ჩვენ გადახვევა up ცოტა და ვნახოთ, სადაც ჩვენ გაიქცა ხაზი,
ან თუ გაიქცა cat ბრძანება, ეს სიტყვასიტყვით უბრალოდ ამობეჭდილი შინაარსი cp.c ჩვენს ეკრანზე.
ჩვენ შეგვიძლია გაუშვით ერთხელ და თქვენ შეგიძლიათ განათავსოთ რამდენიმე ფაილი ერთად.
ასე რომ შეგიძლიათ გააკეთოთ cat cp.c და შემდეგ ჩვენ შეგვიძლია ასევე concatenate cat.c ფაილი,
რაც პროგრამის ჩვენ შესახებ დაწერა,
და ეს კიდე ბეჭდვა ორივე ფაილი თავში დაბრუნება ჩვენი ეკრანზე.
ასე რომ, თუ ჩვენ გადახვევა up ცოტა, ჩვენ ვხედავთ, რომ როდესაც ჩვენ გაიქცა ამ cat cp.c, cat.c,
პირველი ეს ამობეჭდილი CP ფაილი, ხოლო შემდეგ ქვემოთ, ეს ამობეჭდილი cat.c ფაილი უფლება ქვემოთ აქ.
ჩვენ ვაპირებთ გამოვიყენოთ ეს უბრალოდ ფეხზე სველი.
თამაში გარშემო მარტივი ბეჭდვის to ტერმინალი, ვნახოთ, როგორ მუშაობს, რომ.
თუ ბიჭები გახსენით ერთად gedit cat.c, დააჭიროთ,
ხედავთ პროგრამა, რომელიც ჩვენ შესახებ დაწერა.
ჩვენ შედის ამ ლამაზი საქვაბე Plate, ამიტომ ჩვენ არ გვაქვს დროის გასატარებლად აკრეფის ყველა რომ.
ჩვენ ასევე შეამოწმოს რაოდენობის არგუმენტები გაიარა სისტემაში
ჩვენ ამობეჭდოთ ლამაზი გამოყენების გაგზავნა.
>> ეს არის ერთგვარი, რაც, კიდევ ერთხელ, ისევე როგორც ჩვენ ვსაუბრობთ,
ეს თითქმის ისევე, როგორც კუნთების მეხსიერება.
უბრალოდ მახსოვს აკეთეთ იგივე სახის პერსონალი
და ყოველთვის დაბეჭდვისას გარკვეული გამოსადეგი გაგზავნა
ისე, რომ ადამიანმა იცის როგორ აწარმოებს თქვენი პროგრამის.
With კატა, იგი საკმაოდ მარტივია, ჩვენ უბრალოდ აპირებს გავლა ყველა განსხვავებული არგუმენტები
რომ გადაეცა ჩვენი პროგრამა, და ჩვენ ვაპირებთ ბეჭდვა
მათი შინაარსის, რათა ეკრანზე ერთ დროს.
იმისათვის, რომ ბეჭდვა ფაილი აღმოჩნდება ეკრანზე, ჩვენ ვაპირებთ, რომ რამე ძალიან ჰგავს
თუ რა გავაკეთეთ დასასრულს ვიქტორინა.
დასასრულს ვიქტორინა, რომ აყვანის პროგრამა, მოგვიწია გახსენით ფაილი,
და მაშინ მოგვიწია ბეჭდვა მას.
ამ შემთხვევაში, ჩვენ ვაპირებთ გახსენით ფაილი და ჩვენ ვაპირებთ წაკითხვის მაგივრად.
მაშინ ჩვენ ვაპირებთ ბეჭდვა, ნაცვლად რომ ფაილი, ჩვენ ვაპირებთ ბეჭდვა ეკრანზე.
ასე ბეჭდვას, რათა ეკრანზე თქვენ ყველა გაკეთდეს ადრე ერთად printf.
ასე რომ ეს არ არის ძალიან გიჟები.
მაგრამ კითხულობს ფაილი სახის უცნაური.
ჩვენ გავლა, რომ ცოტა დროს.
თუ ბიჭები დაბრუნდეს, რომ ბოლო პრობლემა თქვენს ვიქტორინა, პრობლემა 33,
პირველი ხაზი, რომ ჩვენ ვაპირებთ აქ გახსნა ფაილი, ძალიან ჰგავს იმას, რაც გავაკეთეთ იქ.
ამიტომ Stella, რას ხაზის ჰგავს, როდესაც ჩვენ გახსნა ფაილი?
[Stella] Capital ფაილ *, ფაილი - >> Okay. >> - უდრის fopen. >> Yup.
რაც ამ შემთხვევაში არის? ეს ოფიციალურ კომენტარში.
>> ეს in კომენტარი? argv [i] და ს?
>> ზუსტად. უფლება. ამიტომ Stella სრულიად უფლება.
ეს არის ის, რაც ხაზს ჰგავს.
ჩვენ ვაპირებთ, რომ მიიღოთ ფაილი ნაკადი ცვლადი, ჩაწეროთ იგი ფაილ *, ასე რომ ყველა caps,
ი, *, და სახელი ამ ცვლადი იქნება ფაილი.
ჩვენ შეგვეძლო ეძახით რასაც მოგვწონს. ჩვენ შეგვეძლო ეძახით first_file, ან file_i, რაც ჩვენ გვინდა.
და მერე სახელით ფაილი არ იყო მიღებული ბრძანების სტრიქონში ამ პროგრამის.
ამიტომ შენახული argv [i] და შემდეგ ჩვენ ვაპირებთ გახსნა ამ ფაილის წაკითხვის რეჟიმში.
ახლა, როდესაც ჩვენ გახსნა ფაილი, რა საქმეა, რომ ჩვენ ყოველთვის უნდა გვახსოვდეს, რომ გააკეთოთ
როდესაც ჩვენ გახსნა ფაილი? ვხურავთ მას.
ამიტომ მისის, როგორ უნდა დახუროს ფაილი?
[Missy] fclose (ფაილი) >> fclose (ფაილი). სწორედ.
დიდი. Okay. თუ დავაკვირდებით ამ გავაკეთოთ კომენტარი უფლება აქ,
იგი ამბობს: "ღია argv [i] და ბეჭდვა მისი შინაარსი უნდა stdout."
>> სტანდარტული გარეთ არის უცნაური სახელი. Stdout მხოლოდ ჩვენი გზა ამბობდა
ჩვენ გვინდა ბეჭდვა მას ტერმინალში, ჩვენ გვინდა ბეჭდვა მას სტანდარტულ output stream.
ჩვენ შეგვიძლია რეალურად დავაღწიოთ ამ კომენტარის უფლება აქ.
მე ვაპირებ კოპირება და ჩასვით წლიდან არის ის, რაც ჩვენ გავაკეთეთ.
ამ ეტაპზე, ახლა უნდა წაიკითხოთ ფაილი ნელ bit.
ჩვენ განვიხილეთ რამდენიმე გზები კითხულობს ფაილი.
რაც პირობა არის თქვენი ფავორიტების აქამდე?
რაც გზები გინახავთ ან არ გახსოვთ, წაკითხვის ფაილი?
[დანიელ] fread? >> Fread? ამიტომ fread არის ერთი. ჯიმი, იცით რაიმე სხვები?
[Jimmy] მდებარ >> Okay. Nope. Charlotte? ალექსანდრე? ნებისმიერი სხვები? Okay.
ასე რომ სხვა პირობა არის fgetc, არის, რომ ჩვენ გამოვიყენოთ ლოტი.
არსებობს ასევე fscanf, თქვენ ბიჭებს ვხედავ ნიმუში აქ?
ისინი ყველა იწყება ვ. არაფერი არ უკავშირდება ფაილი.
არსებობს fread, fgetc, fscanf. ეს არის ყველა კითხულობს ფუნქციები.
წერა გვაქვს fwrite, ჩვენ გვაქვს fputc ნაცვლად fgetc.
ჩვენ ასევე არ fprintf როგორც ჩვენ ვნახეთ on ვიქტორინა.
რადგან ეს არის პრობლემა, რომელიც მოიცავს კითხულობს ფაილიდან,
ჩვენ ვაპირებთ გამოვიყენოთ ერთი ამ სამი ფუნქციები.
ჩვენ არ ვაპირებთ, გამოვიყენოთ ამ ფუნქციების ქვემოთ აქ.
ეს ფუნქციები ყველა ნაპოვნი სტანდარტული I / O ბიბლიოთეკაში.
ასე რომ, თუ თქვენ შეხედეთ ზევით ამ პროგრამის
თქვენ ხედავთ, რომ ჩვენ უკვე შედის header ფაილი სტანდარტული I / O ბიბლიოთეკაში.
თუ გვინდა, რომ გაერკვნენ, რომელიც ერთი ჩვენ გვინდა გამოვიყენოთ,
ჩვენ შეგვიძლია ყოველთვის ქმნის კაცი გვერდებზე.
ასე რომ ჩვენ შეგვიძლია აკრიფოთ კაცი stdio
და წაიკითხეთ ყველაფერი stdio და ჩასათვლელი ფუნქციების C.
და ჩვენ შეგვიძლია უკვე ვხედავთ OH, გამოიყურებოდეს. ეს მოხსენიების fgetc, ის ხსენებას fputc.
ასე რომ თქვენ შეგიძლიათ საბურღი ქვემოთ ცოტა და შევხედოთ, ვთქვათ, fgetc
და შეხედეთ მის კაცის გვერდზე.
თქვენ ხედავთ, რომ მიდის ერთად მთელი bunch სხვა ფუნქციები:
fgetc, fgets, getc, getchar, იღებს, ungetc და მისი შეყვანის პერსონაჟების და სიმებიანი.
ასე რომ, ეს როგორ ვკითხულობთ გმირები და სიმებიანი ფაილიდან სტანდარტული input,
რაც ძირითადად მომხმარებლის.
სწორედ ასე ჩვენ გავაკეთებთ რეალურ C.
ასე რომ, ეს არ იყენებს GetString და GetChar ფუნქციები
რომ ჩვენ გამოიყენება CS50 ბიბლიოთეკაში.
ჩვენ ვაპირებთ, რომ ეს პრობლემა რამდენიმე გზები
ასე რომ თქვენ შეგიძლიათ ნახოთ ორი სხვადასხვა გზა ამის გაკეთება.
ორივე fread ფუნქცია რომ დანიელ აღნიშნული და fgetc კარგი გზა გავაკეთეთ.
ვფიქრობ fgetc არის პატარა ადვილია, რადგან იგი მხოლოდ აქვს, როგორც ხედავთ,
ერთი არგუმენტი, ი * რომ ჩვენ წაკითხვის მცდელობისას ხასიათი,
და მისი დაბრუნების ღირებულება int.
და ეს არის პატარა დამაბნეველი, არა?
>> იმის გამო, რომ ჩვენ ვიღებთ ხასიათი, რატომ არ ამ დაბრუნების char?
თქვენ ბიჭები რაიმე იდეები რატომ ეს არ შეიძლება დაბრუნდეს char?
[Missy პასუხები, გაუგებარია] >> Yeah. ამიტომ მისის სრულიად უფლება.
თუ ეს ASCII, მაშინ ეს რიცხვი შეიძლება mapped to ფაქტობრივი char.
შეიძლება ASCII ხასიათი, და ეს უფლება.
სწორედ, რა ხდება.
ჩვენ გამოყენებით int უბრალოდ რადგან მას უფრო მეტი ბიტი.
ეს უფრო დიდია, ვიდრე char; ჩვენი char მხოლოდ 8 ბიტი, რომ 1 byte ჩვენს 32-bit მანქანები.
და int აქვს ყველა 4 ბაიტი ღირებულების სივრცეში.
და აღმოჩნდება, რომ გზა fgetc მუშაობს,
თუ ჩვენ გადახვევა ქვემოთ ჩვენს მოკლე შინაარსი ამ კაცს გვერდზე ცოტა,
გადახვევა ყველა გზა down. თურმე ისინი იყენებენ ამ მასივები მოუწოდა EOF.
ეს სპეციალური მუდმივი როგორც დაბრუნების ღირებულება fgetc ფუნქცია
როდესაც თქვენ მოხვდა ფაილის ბოლოში, ან თუ თქვენ გაქვთ შეცდომა.
და აღმოჩნდება, რომ ამის გაკეთება ამ შედარებები ერთად EOF სწორად,
გსურთ აქვს, რომ ზედმეტი რაოდენობით ინფორმაციას, რომ გაქვთ int
როგორც ეწინააღმდეგებოდა გამოყენებით char ცვლადი.
მიუხედავად იმისა, რომ fgetc ეფექტურად მიღების ხასიათი ფაილი,
გსურთ გახსოვდეთ, რომ იგი ბრუნდება რაღაც რომ ტიპის int თქვენ.
რომ განაცხადა, ეს საკმაოდ მარტივი.
იგი აპირებს მოგვცეს ხასიათი, ამიტომ ყველა უნდა გავაკეთოთ არის შეინახოს ეკითხება ფაილი,
"მომეცი შემდეგი ხასიათი, მომეცი შემდეგი ხასიათი, მომეცი შემდეგი ხასიათი,"
სანამ არ მივიღებთ ბოლომდე ფაილი.
და რომელიც გამოიყვანს ერთ ხასიათი დროს ჩვენი ფაილი,
და შემდეგ შეგვიძლია გავაკეთოთ რასაც მოგვწონს იგი.
ჩვენ შეგვიძლია ჩაწეროთ იგი, შეგვიძლია დაამატოთ ეს ტექსტი, ჩვენ შეგვიძლია ბეჭდვა იგი out.
რაიმე რომ.
>> Zooming უკან გარეთ და ბრუნდება ჩვენი cat.c პროგრამა,
თუ ჩვენ ვაპირებთ გამოვიყენოთ fgetc,
როგორ შეიძლება ჩვენ მივუდგეთ ამ შემდეგი ხაზი კოდი?
ჩვენ ვაპირებთ გამოვიყენოთ - fread გააკეთებს რაღაც ოდნავ განსხვავებული.
და ამ დროს, ჩვენ უბრალოდ აპირებს გამოიყენოს fgetc მისაღებად ერთი ხასიათი დროს.
პროცესში მთელი ფაილი, თუ რა შეიძლება ჩვენ უნდა გავაკეთოთ?
რამდენი სიმბოლოები იქ ფაილი?
ბევრია. ასე, რომ თქვენ ალბათ გვინდა ერთი
და მერე კიდევ სხვა და მიიღეთ საჩუქრად და მიიღეთ საჩუქრად.
როგორი ალგორითმი ფიქრობთ, შეიძლება უნდა გამოვიყენოთ აქ?
რა ტიპის -? [ალექსანდრე] ამისთვის loop? >> ზუსტად.
ზოგიერთი ტიპის loop.
ამისთვის loop ფაქტიურად დიდი, ამ შემთხვევაში.
და თქვენნაირი ამბობდნენ, ეს ჟღერს გსურთ loop მთელ ფაილი,
მიღების ხასიათი დროს.
რაიმე შემოთავაზება, თუ რა შეიძლება, რომ ჰგავს?
[ალექსანდრე, გაუგებარია]
>> Okay, უბრალოდ მითხრათ ინგლისურ თუ რას ცდილობთ? [ალექსანდრე, გაუგებარია]
ასე რომ, ამ შემთხვევაში, ეს ჟღერს ჩვენ უბრალოდ ვცდილობთ, მარყუჟის მთელ ფაილი.
[ალექსანდრე] So I <ზომის int? >> ზომა -?
ვფიქრობ ზომის ფაილი, არა? ზომა - we'll უბრალოდ დაწერა მოსწონს ეს.
ზომა ფაილი ამ დროისათვის, მე + +.
გამოდის, რომ გზა თქვენ ჩვენგან ამ გამოყენებით fgetc, და ეს არის ახალი,
ის არის, რომ არ არსებობს მარტივი გზა უბრალოდ ზომის ფაილების
ამ "sizeof" ტიპის მშენებლობას რომ თქვენ მინახავს ადრე.
როდესაც ვიყენებთ ამ fgetc ფუნქცია, ჩვენ შემოღების გარკვეული სახის
ახალი, ხმაურიანი სინტაქსი ამ for loop, სადაც ნაცვლად გამოყენებით მხოლოდ ძირითადი counter
წასვლა ხასიათი ხასიათი, ჩვენ ვაპირებთ გაიყვანოს ერთი ხასიათი დროს,
ერთი ხასიათი დროს, და გზა ვიცით ჩვენ დასასრულს
არ არის, როდესაც ჩვენ დათვლილი გარკვეული რაოდენობის სიმბოლოებს,
მაგრამ როდესაც ხასიათი ჩვენ გაიყვანოს ის არის, რომ სპეციალური ფაილის დასასრულს ხასიათი.
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ეს მიერ - მოვუწოდებ ამ ch, და ჩვენ ვაპირებთ ინიციალიზაცია ეს
ჩვენს პირველ ზარის მისაღებად პირველი ხასიათი გარეთ ფაილი.
ასე რომ ამ ნაწილში სწორედ აქ, ამ აპირებს მიიღოს ხასიათი გარეთ ფაილი
და ჩაწეროთ იგი შევიდა ცვლადი ch.
ჩვენ ვაპირებთ აკეთეთ ამ სანამ არ მივიღებთ ბოლომდე ფაილი,
რაც ჩვენ გავაკეთეთ მიერ ტესტირება ხასიათი არ ყოფნის ტოლფასია, რომ სპეციალური EOF ხასიათი.
და შემდეგ ნაცვლად აკეთებს ch + +, რომელიც მხოლოდ წუთობრივი ღირებულება,
ასე რომ, თუ ვკითხულობთ გარეთ ფაილი, კაპიტალის, ვთქვათ,
CH + + რომ მოგვცეს B, და შემდეგ ჩვენ გვინდა კიდევ C და შემდეგ დ.
სწორედ ნათლად არ არის რაც ჩვენ გვინდა. რა გვინდა აქ
ამ ბოლო bit არის ჩვენ გვინდა შემდეგი ხასიათი ფაილი.
>> ასე როგორ შეიძლება მივიღებთ შემდეგი ხასიათი ფაილი?
როგორ მივიღებთ პირველ ხასიათი ფაილი?
[სტუდენტური] fgetfile? >> Fgetc, ან, ბოდიში, თქვენ სრულიად უფლება.
მე misspelled ეს უფლება არსებობს. ამიტომ yeah.
აქ ნაცვლად აკეთებს ch + +,
ჩვენ უბრალოდ ვაპირებ მოვუწოდო fgetc (ფაილი) ერთხელ
და შესანახად შედეგი ჩვენს იმავე ch ცვლადი.
[სტუდენტური კითხვაზე, გაუგებარია]
>> ეს არის, სადაც ეს ფაილ * ბიჭები არიან სპეციალური.
გზა ისინი მუშაობენ, რომ ისინი - როდესაც თქვენ პირველად გახსნა - როდესაც თქვენ პირველად მიიღოს, რომ fopen ზარი,
ი * ეფექტურად ემსახურება როგორც მომცეთ დასაწყისში ფაილი.
და შემდეგ ყოველ ჯერზე რეკავთ fgetc, ის მოძრაობს ერთი ხასიათი მეშვეობით ფაილი.
ასე რომ როდესაც თქვენ დაარქვით, თქვენ დამატება ფაილის მაჩვენებელი ერთი ხასიათი.
და როცა fgetc ერთხელ, თქვენ მოძრავი მას სხვა ხასიათის
და კიდევ ერთი ხასიათი და სხვა ხასიათი და სხვა ხასიათი.
[სტუდენტური კითხვაზე, გაუგებარია] >> And that's - Yeah.
ეს ერთგვარი ამ ჯადოსნური ქვეშ hood.
თქვენ უბრალოდ გააგრძელეთ დამატება საშუალებით.
ამ ეტაპზე, თქვენ შეუძლია რეალურად მუშაობა ხასიათი.
ასე როგორ შეიძლება ჩვენ ბეჭდვა ამ გარეთ ეკრანზე, ახლა?
ჩვენ შეგვიძლია გამოვიყენოთ იგივე printf რამ, რომ ჩვენ გამოყენებული ადრე.
რომ ჩვენ იყენებს ყველა სემესტრში.
ჩვენ შეგვიძლია მოვუწოდებთ printf,
და ჩვენ შეგვიძლია გაივლის წლის ხასიათი ისევე რომ.
კიდევ ერთი გზა ამის გაკეთება არის ვიდრე გამოყენებით printf და მქონე ამის სტრიქონში,
ჩვენ ასევე შეგიძლიათ ერთ სხვა ფუნქციებს.
ჩვენ შეგვიძლია გამოვიყენოთ fputc, რომელიც ბეჭდავს ხასიათის ეკრანზე,
გარდა თუ დავაკვირდებით fputc - ნება მომეცით დააშორებს ცოტა.
ჩვენ ვხედავთ, რა ლამაზი არის სჭირდება in ხასიათი რომ ჩვენ წაიკითხა გამოყენებით fgetc,
მაგრამ, ჩვენ უნდა მისცეს მას ნაკადი to ბეჭდვა.
ჩვენ ასევე შეგიძლიათ putchar ფუნქცია, რომელიც დააყენა პირდაპირ სტანდარტულ out.
ასე რომ მთელი bunch სხვადასხვა პარამეტრები, რომ ჩვენ შეგვიძლია გამოვიყენოთ ბეჭდვა.
ისინი ყველა სტანდარტულ I / O ბიბლიოთეკაში.
როდესაც გსურთ ბეჭდვა - ასე printf, ჩვეულებრივ, ხელს ბეჭდვა სპეციალური სტანდარტი გარეთ ნაკადი,
რაც არის, რომ stdout.
ასე რომ ჩვენ შეგვიძლია მხოლოდ ეხება, როგორც სახის ამ ჯადოსნური ღირებულება, stdout აქ.
Oops. განათავსეთ მძიმით გარეთ.
>> ეს არის ბევრი ახალი, ხმაურიანი ინფორმაციის აქ.
ბევრი ეს ძალიან idiomatic, იმ გაგებით, რომ ეს კოდი
რომ წერია ეს გზა მხოლოდ იმიტომ, რომ ეს სუფთა წასაკითხი, ადვილად წასაკითხი.
არსებობს ბევრი სხვადასხვა გზა ამის გაკეთება, სხვადასხვა ფუნქციები შეგიძლიათ გამოიყენოთ,
მაგრამ ჩვენ ტენდენცია უბრალოდ მიჰყევით ამ საერთო თარგების მეტი და მეტი.
ასე რომ არ გაგიკვირდეთ, თუ ხედავთ კოდი მოსწონს ეს ახლოვდება ისევ და ისევ.
ყველა უფლება. ამ ეტაპზე, ჩვენ გვჭირდება შესვენება დღეში.
მადლობა მობრძანებისათვის. მადლობა თვალს თუ თქვენ შემოსული. ჩვენ დავინახავთ, თქვენ მომავალ კვირას.
[CS50.TV]