>> [მუსიკის დაკვრა]
>> ROB ბოდენი ყველა უფლება.
ასე რომ, პირველი, რაც პირველ რიგში, ვიდეო ეხლა ნაცნობი სახე.
>> [ვიდეო აღწარმოების]
>> -All უფლება.
ეს არის CS50, და ეს არის დაწყების კვირაში სამი.
მე ვწუხვარ მე ვერ იქნება იქ, თქვენთან ერთად დღეს, მაგრამ ნება მიბოძეთ წარმოგიდგინოთ
CS50 საკუთარი Rob ბოდენი.
>> [END ვიდეო აღწარმოების]
>> [ტაში და აპლოდისმენტების]
>> ROB ბოდენი: ფილმოგრაფია in რომ ვიდეო არის ფანტასტიური.
ყველა უფლება.
ასე რომ, პირველი, არსებობს კიდევ ერთი სადილი.
ის ხვალ, 1:15.
არ არსებობს ლანჩი ამ პარასკევს.
ეს არის Quora.
და ტომი არ არის აქ, მაგრამ ერთი ხალხი იქ არის ყოფილი ხელმძღვანელი CF,
Tommy McWilliam.
ასე რომ, ის fun guy.
თქვენ უნდა მოდის.
>> ყველა უფლება.
ასე რომ, გასულ კვირას, ჩვენ დავიწყეთ შეტევის გარდა იმაზე, თუ რა სიმებიანი ნამდვილად არის.
ჩვენ ცნობილია, წლის დასაწყისიდან, რომ ეს თანმიმდევრობა სიმბოლო.
მაგრამ გასულ კვირას, ჩვენ delved შევიდა ფაქტი რომ ის, რაც მართლაც თანმიმდევრობა
პერსონაჟები, ასევე, ჩვენ ახლა აქვს მასივები სიმბოლო.
და ვიცით, რომ სიმებიანი, ეს მასივი გმირები, ერთი ბოლომდე,
ჩვენ ამ სპეციალური null byte, ამ backslash 0, მიანიშნებს ბოლოს
სიმებიანი.
>> და ასე string არის მასივი პერსონაჟი, მაგრამ ჩვენ შეგვიძლია მეტი
მხოლოდ მასივი გმირები, ჩვენ შეგვიძლია მასივი ნებისმიერი
ტიპის რამ გვინდა.
ასე რომ, თუ გახსოვთ, გასულ კვირას, ასაკის პროგრამა, რომელიც დავით გააცნო
მართლაც სწრაფად.
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ გავაკეთოთ არის ვთხოვთ მომხმარებელს რიცხვი,
რაოდენობის ხალხი ოთახში.
მას შემდეგ, რაც ჩვენ გვაქვს, რომ რიცხვი, ჩვენ ვაცხადებთ მასივი.
ყურადღება მიაქციეთ ამ bracket სინტაქსი.
თქვენ აპირებს შეეგუოს, რომ.
>> ამიტომ ჩვენ ვაცხადებთ მასივი რიცხვებით ე.წ. ასაკის, და არსებობს n
რიცხვებით ამ მასივი.
ასე რომ, ეს ნიმუში სწორედ აქ, ამ 4 int i უდრის 0, i ნაკლებია, ვიდრე n, i პლუს
პლუს, რომელიც ასევე იქნება ნიმუში რომ თქვენ გაქვთ ძალიან გამოიყენება.
იმის გამო, რომ საკმაოდ ბევრი, თუ თქვენ ყოველთვის აპირებს iterate მეტი მასივები.
ასე მახსოვს, რომ n არის ხანგრძლივობა ჩვენი მასივი.
და ა.შ. აქ, ჩვენ არაერთხელ ითხოვს ასაკის ადამიანი ოთახში.
>> ამის შემდეგ ვეშვებით, და რაც თვითნებური გამო, ჩვენ მაშინ
ამობეჭდოთ რამდენი წლის ისინი აპირებენ უნდა იყოს ერთი წლის შემდეგ.
და გაშვებული რომ პროგრამა, მოდით რათა ასაკის, dot slash ასაკის.
ასე რომ, რაოდენობის ხალხი ოთახი, ვთქვათ არსებობს სამი.
და აცხადებენ, რომ პირველი პირი არის 13, შემდეგი არის 26, და ბოლო 30.
ასე რომ მაშინ ეს თქვენ iterate მეტი იმ სამი ადამიანი, ამობეჭდოთ 14, 27 და 31.
>> ასე მახსოვს, რომ როდესაც ვაცხადებთ მასივი ზომა N, მაჩვენებლების, რომ
მასივი, მასივი აქვს ფასეულობები და ინდექსების 0, 1, 2, ყველა გზა
მდე n მინუს 1.
ასე რომ, როდესაც ჩვენ თქმით, სამი ადამიანი ოთახში, და ჩვენ აქ
პირველი iteration მეშვეობით loop, i იქნება 0.
ასე რომ ინდექსი 0.
ჩვენ მინიჭების პირველი ასაკი შესახებ შემოდის.
შემდეგ მომდევნო ერთი, ჩვენ შევდივართ მეორე n მომხმარებლის შემოდის და
შემდეგ ორი, ბოლო n.
>> ასე რომ შეამჩნია, რომ მასივი ზომა სამი ამჯამად არ აქვს არაფერს
ინდექსი სამი.
ეს არ არის სწორი.
ყველა უფლება.
ასე რომ, ბრუნდება აქ.
ასე რომ, ახლა რომ ჩვენ შესძლეს მასივები, ჩვენ გვაქვს გარკვეული ცოდნა.
ახლა ჩვენ ვაპირებთ გადაადგილება ბრძანება ხაზი არგუმენტები, რომლებიც იქნება
საკმაოდ შესაბამისი ამ პრობლემის კომპლექტი.
>> ასე რომ, დღემდე, როდესაც თქვენ გამოაცხადეთ მთავარი ფუნქცია, ჩვენ
განაცხადა int ძირითადი ბათილად.
ასე რომ, ბათილად მხოლოდ იმას ნიშნავს, რომ ჩვენ არ ვართ ავლით ნებისმიერი
არგუმენტები ამ ფუნქციას.
ახლა ჩვენ ვაპირებთ ვხედავ, რომ მთავარი შეუძლია რამდენიმე არგუმენტები.
აქ ჩვენ მოვუწოდებთ მათ int argc და სიმებიანი argv ფრჩხილებში.
ფრჩხილებში, კიდევ ერთხელ, იმაზე მიუთითებს, რომ ჩვენ საქმე გვაქვს მასივები.
ასე რომ აქ, სიმებიანი argv ფრჩხილებში, ჩვენ საქმე მასივი სტრიქონები.
ასე რომ argc, რომ აპირებს მიუთითებს რამდენი არგუმენტები ჩვენ
გავიდა ეს პროგრამა.
და ვნახოთ, რას ნიშნავს, მოდით დახურვა.
>> OK.
ასე რომ, დღემდე, ჩვენ აწარმოებს ყველა პროგრამა მოსწონს dot slash ასაკის.
ჩვენ ასევე შეგვიძლია, ბრძანებათა ზოლს, წარსულში გაივლის არგუმენტები, ამიტომ ტერმინი, ბრძანება
ხაზი არგუმენტები.
ასე რომ, პირველი არგუმენტი, hello მსოფლიოში.
ასე რომ აქ, argc იქნება სამი.
ის რაოდენობა არგუმენტები ბრძანებათა ზოლს.
Argc ყოველთვის მინიმუმ 1, რადგან dot slash ასაკის, თავისთავად, ითვლის, როგორც ერთი
ბრძანების არგუმენტები.
>> მაშინ მიესალმები არის პირველი.
იმ შემთხვევაში, თუ dot slash ასაკის არის zeroth, მაშინ მიესალმები არის პირველი და მსოფლიოში არის
მეორე ბრძანების არგუმენტი.
ასე რომ სიმებიანი argv, ჩვენ ვაპირებთ, რომ ნახოთ, შეიცავს სიმები, dot slash
ასაკის, hello, და მსოფლიოში.
და, დავით თხოვნით, ჩვენ ვაპირებთ თამაში ვიდეო შემოღების რომ.
>> [ვიდეო აღწარმოების]
>> -Up აქამდე პროგრამების ჩვენ დაწერილი, ჩვენ ვაცხადებთ
მთავარი როგორც int ძირითადი ბათილად.
და ყველა ამ დროს, რომ ბათილად აქვს უბრალოდ მიუთითებს, რომ
პროგრამა არ მიიღოს ნებისმიერი ბრძანების არგუმენტები.
სხვა სიტყვებით, როდესაც მომხმარებელი გადის პროგრამა, მას შეუძლია ბრძანება
ხაზი არგუმენტები წერილობით დამატებითი სიტყვა ან ფრაზა შემდეგ პროგრამის
ასახელებს ბრძანებათა ზოლზე.
>> ისე, თუ გინდათ თქვენი პროგრამა მიიღოს ბრძანება ხაზი არგუმენტები, ერთი ან
ასეთი სიტყვებით, ჩვენ უნდა შეცვალოს ბათილად რამდენიმე არგუმენტები.
მოდით გავაკეთოთ ეს.
მოიცავს cs50.h.
მოიცავს სტანდარტული io.h.
Int მთავარი.
და ახლა, ნაცვლად ბათილად, მე ვაპირებ მიუთითოთ int მოუწოდა argc და
მასივი სტრიქონები ეწოდება argv.
ახლა, argc და argv არის უბრალოდ კონვენციები.
>> ჩვენ შეგვეძლო მოუწოდა ეს არგუმენტები ყველაზე არაფერი გვინდა.
მაგრამ რა არის მნიშვნელოვანი ის არის, რომ argc არის int, რადგან, ზოგადად, ეს არის
აპირებს შეიცავდეს არგუმენტი რაოდენობა, სიტყვების რაოდენობა, სულ რომ
მომხმარებელს ჯერ აკრეფილი ერთი მისი ზოლზე.
argv, იმავდროულად, არგუმენტი ვექტორი, არის აპირებს რეალურად იყოს მასივი შენახვა
ყველა სიტყვა, რომ მომხმარებელს აქვს აკრეფილი ერთი მისი ზოლზე.
>> მოდით გაგრძელება რაღაც ახლა ერთი ან მეტი ასეთი
ბრძანების არგუმენტები.
კერძოდ, მოდით წავიდეთ წინ და ბეჭდვითი რასაც სიტყვის მომხმარებლის ტიპის
შემდეგ პროგრამის სახელი ბრძანებათა ზოლზე.
ღია bracket.
Close bracket.
Printf პროცენტს s backslash და მძიმით.
და ახლა მე უნდა ვუთხრა printf რა ღირებულება შეაერთედ შევიდა, რომ placeholder.
მე მინდა, რომ პირველი სიტყვა, რომ მომხმარებელს აქვს აკრეფილი შემდეგ პროგრამის სახელი,
და ა.შ. მე ვაპირებ მიუთითოთ argv bracket 1, ახლო
ფრჩხილებში, მძიმით.
>> ახლა, რატომ bracket 1 და არა bracket 0?
ასევე, თურმე, ავტომატურად ინახება ამ argv 0 იქნება
პროგრამის ფაქტობრივი სახელით.
ასე რომ პირველი სიტყვა, რომელიც მომხმარებლის ტიპი მას შემდეგ, რაც პროგრამის სახელწოდება არის,
კონგრესზე იქნება შენახული argv 1.
მოდით ახლა კომპილირდება და აწარმოებს ამ პროგრამის.
>> რათა argv 0, dot slash argv 0.
და ახლა, სიტყვა hello.
შეიყვანეთ.
და იქ ჩვენ მას, hello.
>> [END ვიდეო აღწარმოების]
>> ROB ბოდენი ყველა უფლება.
დახურვა რომ.
ასე რომ შევხედოთ, რომ პროგრამა, რომელიც ჩვენ უბრალოდ გააცნო ჩვენთვის, ისევე, უბრალოდ
რათა ნახოთ, თუ ჩვენ ბეჭდვა argv 0, რათა, ახლა რა არის ეს, argv 0, dot slash argv 0.
ასე რომ, როგორც მოსალოდნელია, ეს დაბეჭდვისას პროგრამის დასახელება, რადგან argv 0 არის
ყოველთვის იქნება პროგრამის დასახელება.
მაგრამ მოდით რაღაც ცოტა უფრო საინტერესო.
>> ასე რომ, პრობლემა კომპლექტი, თქვენ გექნებათ გააცნო ამ ფუნქციის atoi.
ასე რომ, რას ვიყენებთ atoi ამისთვის?
რომ აპირებს გარდაქმნას სიმებიანი რიცხვი.
ასე რომ, თუ მე გაივლის სიმებიანი, ერთი ორი სამი, to atoi, რომ ყველაფერს კონვერტირება, რომ
რომ რიცხვი, ერთი ორი სამი.
ამიტომ, ჩვენ ვაპირებთ კონვერტირება პირველი ბრძანების არგუმენტი რიცხვი,
და შემდეგ უბრალოდ ბეჭდვა, რომ მთელი რიცხვი.
>> ასე რომ, ძირითადად, ჩვენ ერთგვარი reimplementing GetInt, მხოლოდ
რიცხვი შევიდა ბრძანებათა ონლაინ ნაცვლად პროგრამა
ინტერაქტიულად.
ასე რომ, რაც argv 0, მოდით ეს აქ, და დახუროს, რომ.
ასე გაშვებული argv 0, და მოდით შეიყვანოთ რიცხვი, ერთი ორი სამი, ოთხი, ერთი ორი.
ასე რომ თქვენ ბეჭდვა რიცხვი, ერთი ორი სამი, ოთხი, ერთი ორი.
არსებობს გარკვეული ნიუანსები to atoi რომ ეს თქვენ შეწყვიტოს ზრუნვა არაფერს
მიღმა მოქმედებს რიცხვითი ხასიათი, მაგრამ, რომ არ აქვს მნიშვნელობა.
>> ასე რომ, როგორ ფიქრობთ რა მოხდება თუ ამის გაკეთება?
სეგმენტაცია ბრალია.
რატომ არის, რომ?
თუ ვიხსენებთ ჩვენი პროგრამა, ჩვენ კონვერტაცია argv 1, პირველი არგუმენტი
მას შემდეგ, რაც პროგრამის სახელი, რიცხვი.
მაგრამ არ არსებობს არგუმენტი გავიდა მას შემდეგ, რაც პროგრამის სახელი.
ასე რომ, აქ ჩვენ ვხედავთ, რომ ეს არის buggy პროგრამა, რადგან, თუ ჩვენ ვცდილობთ, რომ აწარმოებს
ყოველგვარი არგუმენტების ეს იქნება მხოლოდ მისაწოდებლად.
>> ასე რომ, კიდევ ერთი საერთო ნიმუში თქვენ ნახავთ არის რაღაც, თუ argc ნაკლებია,
გარდა ორი, მიუთითებს, რომ იქ არ იყო მინიმუმ პროგრამის სახელი და
პირველი არგუმენტი, მაშინ ჩვენ რაღაც მოსწონს printf, არ არის საკმარისი,
ბრძანების არგუმენტები.
ეს, ალბათ, არ არის კარგი ერთი ბეჭდვა, ეს, ალბათ, რაღაც, როგორიცაა
თქვენ უნდა მიუთითოთ მთელი რიცხვი ბრძანებათა ზოლს.
მე უბრალოდ დასრულდება იგი.
ხოლო შემდეგ დაბრუნდნენ 1.
ასე მახსოვს, რომ დასასრულს ჩვენი პროგრამა, თუ ვბრუნდებით 0, რომ სახის
მიუთითებს წარმატება.
და ძირითადი ასევე ავტომატურად დააბრუნებს 0 თუ არა.
>> ასე რომ აქ, ჩვენ retuning 1 მიუთითოს რომ ეს არ არის წარმატება.
და თქვენ შეგიძლიათ დაბრუნებას რაც გაგიხარდებათ, უბრალოდ, 0 მიუთითებს, წარმატება და
არაფერი მიუთითებს უკმარისობა.
მოდით აწარმოებს ამ მობილური რამ.
ახლა, თუ ჩვენ არ შევა ბრძანების არგუმენტი, რომ ყველაფერს სწორად ვუთხრა
ჩვენთან, საკმარისი არ არის command line.
არ დაასრულებს სასჯელი.
სხვაგან, თუ ჩვენ რეალურად გაიაროს ეს ერთი, ეს შეიძლება დასრულდეს პროგრამა.
ასე რომ, ეს არის, თუ როგორ გამოიყენოთ argc in რათა შეამოწმოს ნომერი
ბრძანების არგუმენტები, რომ რეალურად გაიარა.
>> მოდით ამ პროგრამის უფრო მეტი რთული და შევხედოთ მეორე
iteration რამ.
ახლა, ჩვენ არა მხოლოდ დაბეჭდვის პირველი ბრძანების არგუმენტი.
აქ, ჩვენ iterating საწყისი int i შეადგენს 0, i არის ნაკლები ვიდრე argc, i პლუს
პლუს, და ბეჭდვითი argv, ინდექსი i.
ასე რომ, ეს ნიმუში, კიდევ ერთხელ, ეს არის იგივე ნიმუში როგორც ადრე, გარდა ნაცვლად
მოუწოდებდა ცვლადი n, ჩვენ გამოყენებით argc.
>> ასე რომ, ეს iterating მეტი თითოეული ინდექსი მასივი, და დაბეჭდვის თითოეული
ელემენტია, რომ მასივი.
ასე რომ, როდესაც ჩვენ აწარმოებს ამ პროგრამის, ასევე, მე არ მიუთითოთ ნებისმიერი ბრძანების
არგუმენტები, ასე რომ მხოლოდ ანაბეჭდები პროგრამის სახელი.
იმ შემთხვევაში, თუ მე შევა bunch რამ, რომ თქვენ ბეჭდვა ერთი, თითოეული საკუთარი ხაზი.
>> OK.
მოდით ამ ერთი ნაბიჯი შემდგომი.
და ნაცვლად დაბეჭდვის თითოეული არგუმენტი საკუთარი ხაზი, მოდით ბეჭდვა თითოეული
ხასიათი თითოეული არგუმენტი, საკუთარი ხაზი.
ასე მახსოვს, რომ argv არის მასივი სტრიქონები.
რა არის სიმებიანი, მაგრამ მასივი გმირები?
ასე რომ, ეს ნიშნავს, რომ argv მართლაც მასივი მასივი სიმბოლო.
ასე რომ, უპირატესობების, რომ მოდით იგნორირება ახლა.
მოდით უბრალოდ განიხილოს სიმებიანი argv 0.
>> ასე რომ, თუ ჩვენ გვინდა, რათა თითოეული ხასიათი argv 0 საკუთარი ხაზი, მაშინ მინდა
გავაკეთოთ ნიმუში ჩვენ გამოიყენება, მე არის ნაკლებია, ვიდრე სიგრძეზე მასივი,
რომელიც აქ არის strlen of, რომ არ რა მინდა, string
s უდრის argv 0.
ასე რომ ნაკლებია ხანგრძლივობა ჩვენი მასივი, რომელიც ამ შემთხვევაში არის მასივი
გმირები, i plus plus.
ასე რომ, როგორც დავინახეთ, გასულ კვირას, ეს იდეალური თუ ჩვენ გადაადგილება რომ strlen გარეთ
მდგომარეობა მას შემდეგ, რაც n შეისწავლით strlen of s ყოველ ჯერზე ჩვენ წავიდეთ
მეშვეობით loop, და ეს არ იქნება იცვლება.
ამიტომ ჩვენ ვაყენებთ მას ტოლი n აქ.
>> OK.
ახლა, ჩვენ iterating მეტი თითოეული მაჩვენებელი მასივი.
ასე რომ, თუ ჩვენ გვინდა ბეჭდვა თითოეული ხასიათი რომ მასივი, პროცენტი გ არის
დროშის ჩვენ გვინდა გამოვიყენოთ განთავსების სიმბოლო.
და ახლა bracket i იქნება ტექსტი, index ხასიათი i, ასე რომ, თუ
string იყო hello.
მაშინ დრიურის 0 იქნება h, დრიურის bracket 1 იქნება e, და ასე შემდეგ.
>> ახლა ჩვენ გვინდა გაერთიანდება ეს ორი რამ.
ჩვენ გვინდა ბეჭდვა თითოეული ხასიათი თითოეული ბრძანების არგუმენტი.
ამიტომ, ჩვენ ვაპირებთ აქვს წყობილი for loop.
და პირობითად, პირველი counter მე, მომავალი იქნება j, n
იქნება strlen of argv i, i ნაკლებია, ვიდრე n, i plus plus.
და ახლა ნაცვლად ბეჭდვა argv i, ასე რომ, argv bracket i აპირებს ინდექსი -
რომ აპირებს იყოს i-ე ბრძანების არგუმენტი, argv i, j აპირებს
იყოს jth ხასიათი i-th არგუმენტი.
მე თავი დაეღწია ამ up აქ არის რადგან ჩვენ ამას რომ loop.
ასე რომ, უდრის string s შეადგენს argv i, და შემდეგ ნანახია bracket კ.
>> ასევე, ჩვენ არ უნდა განაცხადოს ეს ცვლადი s.
სამაგიეროდ, ჩვენ უბრალოდ დააკავშიროთ ამ ორი შევიდა, რაც ჩვენ გვქონდა, argv i, j.
>> დინამიკები 1: [INAUDIBLE].
>> ROB ბოდენი: Good ზარი.
ასე რომ ეს არის გატეხილი.
თუ რეალურად გაიქცა ის, რომ ჩვენ მიხვდა ეს.
ასე რომ counter მე აინტერესებს ამ განსაკუთრებით
loop არის j, iterator.
ასე რომ თქვენ არ გადაეყარონ საკითხები, ალბათ უსასრულო ციკლი, თუ ჩვენ
არ იყო დაფიქსირებული, რომ.
ამიტომ, ჩვენ ასევე საუბარი შესახებ გამართვის დღეს.
>> OK.
მოდით აწარმოებს ამ პროგრამის.
და მოდით რეალურად დაამატოთ ცალკე printf სწორედ აქ, რომ იქნება მხოლოდ ბეჭდვა
მეორე ხაზი, რადგან ეს იმას ნიშნავს, რომ როდესაც ჩვენ გაუშვით პროგრამა, იქ იქნება ცარიელი
ონლაინ შორის თითოეული ხასიათი თითოეული ბრძანების არგუმენტი.
ისე, ჩვენ დავინახავთ, რას ნიშნავს ეს.
Oop.
რაღაც შეცდომა.
შეცდომა მინიშნებით გამოცხადების ბიბლიოთეკის ფუნქცია strlen.
>> ასე ბრუნდება ჩვენი პროგრამა, მე დაავიწყდა hash არის string.h.
ასე string.h იქნება header ფაილი, რომელიც აცხადებს,
ფუნქცია strlen.
OK, იგი ადგენს.
ახლა, მოდით გაუშვით.
ასე რომ, მხოლოდ, რომ.
ის აპირებს ამობეჭდოთ ჩვენი პროგრამის სახელი, hello მსოფლიოში.
ის აპირებს ბეჭდვა ყოველი ნივთი, თითოეული ხასიათი, საკუთარი ხაზი.
OK.
>> მოდით რეალურად მიიღოს ამ ერთი ნაბიჯი შემდგომი.
და ნაცვლად გამოყენებით string.h, მოდით ვიფიქროთ იმაზე, როგორ ჩვენ გვინდა განვახორციელოთ ჩვენი საკუთარი
strlen ფუნქცია.
ასე რომ მე დაუყოვნებლივ მისცეს ფუნქცია ხელმოწერით.
მოდით მოვუწოდებთ my_strlen, და ეს აპირებს string როგორც არგუმენტი,
და ჩვენ ველით, რომ დააბრუნოს ხანგრძლივობა რომ სიმებიანი.
ასე რომ, სად არის, რომ ბიჭი?
დიახ.
OK.
ასე მახსოვს ადრე slide, რომ ასევე გასულ კვირას, რომ
მასივი გმირები, ასევე, სიმებიანი, ასე ვთქვათ, ეს არის ჩვენი string s.
ასე რომ, თუ არის string, hello, მაშინ, H-E-L-L-O, მეხსიერებაში, რომ აპირებს
იყოს, და მაშინ ეს backslash 0 ხასიათი.
>> ასე როგორ უნდა მიიღოს სიგრძეზე s?
ისე, შეასრულა ეძებს ამ საწინააღმდეგოდ 0 ხასიათი, ეს null
terminator.
ასე ალგორითმი აპირებს უნდა იყოს რაღაც რამდენიმე
საკმარისი გმირები, რომ -
მოდით ამ მხრივ წარმოადგენს ზოგიერთი counter, მოდით მოვუწოდებთ ამ int სიგრძე.
ასე რომ, დაწყებული აქ, ჩვენ აპირებს iterate მეტი ჩვენი სიმებიანი.
>> ასე რომ, პირველი ხასიათი, ის H, და ის არ დაბრუნდა slash 0, ასე რომ
სიგრძე არის 1.
Iterate მომდევნო ხასიათი, E, და ეს არ backslash 0.
სიგრძე არის 2.
L, 3.
L, 4.
O, 5.
და ბოლოს, მივაღწევთ backslash 0, და ისე, რომ საშუალება, ასევე,
ეს კონტექსტი დასრულდა.
მოდით დაბრუნდება 5.
>> ასე რომ, რეალურად ახორციელებს, რომ, პირველ რიგში, ჩემი n სიგრძე უდრის 0, ჩემი მარჯვენა ხელი.
და ჩვენ ვაპირებთ iterate -
>> დინამიკები 1: [INAUDIBLE]
>> ROB ბოდენი: Oh, გადაღება.
კარგი ზარი.
Boom.
ასე n სიგრძე უდრის 0.
ახლა, ხოლო s ხანგრძლივობა არ თანაბარი და შემდეგ, backslash 0.
ასე მახსოვს, ამ backslash 0, ეს არის ფაქტობრივი ხასიათი, და ეს მიანიშნებს
ბოლოს string.
ისევე, როგორც, ასევე, backslash n არის ფაქტობრივი ხასიათი.
Backslash 0 აპირებს მიუთითებს ბოლოს ჩვენი სიმებიანი.
მე არ მინდა დააყენოს, რომ არსებობს.
ხოლო ნანახია ინდექსირებული მიერ ხანგრძლივობა არ არის ტოლი null terminator, მაშინ
ჩვენ უბრალოდ აპირებს ნამატი სიგრძე.
ასე შემდეგ, დასასრულს ჩვენი პროგრამის, სიგრძე საბოლოოდ აპირებს
იყოს 5 ამ შემთხვევაში.
და ჩვენ უბრალოდ დააბრუნოს სიგრძეზე.
>> OK.
ახლა ქვემოთ აქ, მე არ გავაკეთოთ my_strlen.
მოდით კომპილირება, რათა დავრწმუნდეთ, ყველაფერი მუშაობს გამართულად.
იყო მე აკეთებდა 2?
ან იყო, რომ 1?
ეს უნდა გავაკეთოთ.
ყველა უფლება.
ასე რომ, ეს არის argv 2.
მუშაობს როგორც მოსალოდნელია, თუმცა, ის იყო, რომ მე გააკეთა?
დიახ.
OK.
ამ მობილური რამ არ აქვს printf ახალი ხაზი შემდეგ, მაგრამ ეს
არ გაუკეთებია განსხვავება.
OK.
ასე მუშაობდა როგორც მოსალოდნელია.
>> ახლა ჩვენ შეგვიძლია კიდევ დააკავშიროთ ამ ერთი ნაბიჯით შემდგომ, სადაც გაფრთხილების აქ, ისევე,
პირველი, ჩვენ grabbing strlen of argv i, და მაშინ ჩვენ iterating მეტი
თითოეული პერსონაჟი რომ სიმებიანი.
ასე რომ ნაცვლად აკეთებს, რომ, თუ ჩვენ უბრალოდ დააკავშიროთ ამ ლოგიკით ელოდება
სანამ ჩვენ მოხვდა backslash 0 მარჯვენა ამ for loop?
ასე რომ iterate ხოლო argv i, j აკეთებს არ არის ტოლი backslash 0.
მოდით აწარმოებს პირველი.
>> ყველა უფლება.
ასე რომ აქ, ამ მდგომარეობაში ამბობს -
მოდით გარკვევა, რომ.
ახლა, მოდით ეს იყოს ჩვენი argv.
ასე რომ, როდესაც მე უბრალოდ გაიქცა, რომ პროგრამა ადრე, argv არის მასივი სტრიქონები.
ასე რომ, თუ მე გაუშვით dot slash argv 2, hello world, მაშინ argv
თავისთავად სიგრძე 3, for argv ნულოვანი, hello, და მსოფლიოში.
>> და შიგნით თითოეული ამ მაჩვენებლების თავად მასივი, სადაც ეს იქნება
dot, ეს იქნება ხაზი, მე არ ვიცი იყო თუ არა სწორი მიმართულებით, I
არ ვფიქრობ, რომ ეს იყო.
A-R-V ტირე, საჭიროა უფრო მეტი სივრცე.
მოდით მოჭრილი შევიდა ამ მასივი.
A-R-V dash 0, და შემდეგ backslash 0.
და მერე საგონებელში იქნება hello.
ვთქვათ, H-E backslash 0.
და ბოლოს, W-O backslash 0.
>> ასე რომ, ალგორითმი, რომ ჩვენ უბრალოდ დაწერა, წყობილი ამისთვის მარყუჟების, რა ისინი
აკეთებს, ჩვენ პირველად აქვს counter i და შემდეგ კ.
ეს იქნება ადვილი კოდექსის ეკრანზე, მოდით დავუბრუნდეთ ამ.
OK.
ასე რომ შეამჩნია, რომ მე არის iterator, რომ iterating მეტი თითოეული ბრძანება
ხაზი არგუმენტი.
და j არის iterator iterating მეტი თითოეული პერსონაჟი, რომ
ბრძანების არგუმენტი.
რა ეს innermost printf აკეთებს არის, ჩვენ printf argv 0 0, printf
argv 0 1, printf argv 0 2 0 3 0 4 0 5 0 6, მაგრამ ახლა, argv 0 7 აპირებს
თანაბარი backslash 0.
>> ასე რომ მაშინ ჩვენ გასასვლელად რომ loop, და ახლა მე iterates 1.
და ახლა ჩვენ ვაპირებთ ბეჭდვა argv 1 0, argv 1 1 -
კარგად, ახლა, მას შემდეგ, რაც მე დაჭრილი მიესალმები მოკლედ, argv 1 2 კვლავ იქნება
backslash 0.
ასე რომ, ნამატი მე და გაგრძელდება და ასე რომ, სანამ ჩვენ ამობეჭდოთ ყველა
მსოფლიოში, და იმ სამი ბრძანების არგუმენტები და ჩვენ გასასვლელად გარეთ
outermost მარყუჟი, და დასრულება ჩვენი პროგრამა.
OK.
>> მოდით დავბრუნდებით აქ.
ასე რომ თქვენ გარკვეული ცოდნა ბრძანების ხაზი არგუმენტები ამ
განსაკუთრებული პრობლემა კომპლექტი.
>> ახლა, გამართვის.
ასე რომ თქვენ ალბათ უკვე უნდა გაეკეთებინათ ზოგიერთი გამართვის თქვენი წინა
პრობლემა კომპლექტი.
და ერთი ძალიან მარტივი გზა გამართვის, პირველ რიგში, მოდით შევხედოთ buggy პროგრამა.
ისე, გავლით ამ პროგრამის ჩვენ ვაპირებთ, ვთხოვოთ მომხმარებელს
რიცხვი, აითვისებდა, რომ რიცხვი, შემდეგ კი, უკანონოდ, ჩვენ გვაქვს ხოლო loop რომ
უბრალოდ აპირებს decrement i სანამ ის ტოლი 10.
მოდით უბრალოდ ვივარაუდოთ მე შემოსვლა რიცხვი აღემატება 10.
ასე decrement i სანამ ის ტოლი 10.
>> და მაშინ ჩვენ გვაქვს ერთი ხოლო loop რომ მაშინ, როდესაც მე არ თანაბარი 0, ჩვენ
ვაპირებ decrement i 3.
ასე რომ, თუ ხედავთ მიზანი bug აქ, ის, რომ ამ ყველაფერს decrement i to
იყოს 10, და შემდეგ ამ ხოლო loop ნების decrement i 10, 7, 4, 1,
უარყოფითი 2, უარყოფითი 5, და ასე შემდეგ, უარყოფითი infinity, რადგან მე ამას
არასოდეს რეალურად ტოლი 0.
და შემდეგ დასასრულს ამ პროგრამის ჩვენ foo ფუნქცია რომელიც
მიმდინარეობს print, რომ i.
>> ასე რომ, ეს არის მოკლე და ტრივიალური პროგრამა, და bug აშკარაა,
განსაკუთრებით მას შემდეგ, მე უბრალოდ განაცხადა რა bug იყო.
მაგრამ განზრახვა აქ არის, კარგად, ეს შეიძლება რეალურად გამოიყურება ზოგიერთი თქვენი
გადაწყვეტილებების ხარბ გასული პრობლემა კომპლექტი, და იქნებ თქვენ უნდა
ზოგიერთი უსასრულო loop თქვენს პროგრამაში, და თქვენ არ ვიცი
რა იწვევს მას.
ასე რომ, ძალიან სასარგებლო debugging ტექნიკა არის უბრალოდ დაამატოთ printfs
მთელი თქვენი კოდი.
>> ასე რომ აქ მინდა printf გარეთ პირველი ხოლო loop.
და აქ მე მინდა მყავდეს printf, და მე უბრალოდ ბეჭდვა i.
მე კი ამის პირველი ხოლო მარყუჟის, i.
გარეთ, მეორე ხოლო loop.
კიდევ ერთხელ, ბეჭდვა შიგნით აქ, ღირებულება i.
და მოდით აწარმოებს ამ.
>> ასე dot slash გამართვის.
შეიყვანეთ მთელი რიცხვი.
მოდით 13.
და ბუმი.
ჩვენ ვხედავთ, რომ ჩვენ უსასრულო looping შიგნით მეორე ხოლო loop.
ახლა ჩვენ ვიცით, რა bug არის.
მაგრამ printf გამართვის სრულიად დიდი, მაგრამ ერთხელ თქვენი პროგრამების მისაღებად
აღარ და უფრო რთული, არსებობს უფრო დახვეწილი გადაწყვეტილებები
მიღების რამ მუშაობს.
მოდით ამოიღონ ყველა ამ printfs.
და მოდით დავრწმუნდეთ, მე არ შესვენება არაფერი.
OK.
>> ასე რომ, პროგრამა, ჩვენ ვაპირებთ დანერგვა ეწოდება
GDB, განთავსების GNU Debugger.
ისე, რეალურად, მოდით ამოიღონ გამართვის for მეორე, და გამართვის ერთხელ.
ისე, რეალურად, პირველ რიგში, კარგი გაკვეთილი ამ ბრძანების არგუმენტები.
გაითვალისწინეთ, რომ ეს Clang ბრძანება, რომ არის შედგენის ყველაფერი მიმდინარეობს გავიდა
ბრძანებათა ზოლს, ამ ბრძანების არგუმენტები.
ასე ზუსტად, თუ როგორ ვაპირებთ იყოს გამოყენებით ბრძანების ხაზი არგუმენტები, როგორც ჩვენ
აქამდე, და თქვენ ნება pset 2, ასე Clang გამოყენებით მათ.
>> ასე რომ შეამჩნია, რომ ეს პირველი დროშა, ტირე ggdb3, რა, რომ ვამბობ, არის, Clang,
თქვენ უნდა შეადგინონ ამ ფაილის განზრახვა, რომ ჩვენ საბოლოოდ
უნდა გამართვის იგი.
ასე რომ, სანამ თქვენ, რომ დროშა, მაშინ ჩვენ შეგვიძლია GDB გამართვის.
და ეს კიდე ქმნის GNU Debugger.
>> ასე რომ, არსებობს ბევრი ბრძანებები რომ თქვენ უნდა შეეგუოს.
პირველი, რომ თქვენ ალბათ სასწრაფოდ გვჭირდება Run.
ასე რომ, რა გაუშვით აპირებს?
ის აპირებს დაიწყოს ჩვენი პროგრამა.
ასე აწარმოებს, დაწყებული პროგრამა, პროგრამა გვთხოვს განთავსების რიცხვი, 13.
და შემდეგ ეს უსასრულო looping როგორც მოსალოდნელია, გარდა მე ამოღებულ
printfs, ასე რომ, ჩვენ კი არ ვხედავ, რომ.
დასრულების ნორმალურად.
Oh.
შესაძლებელია, რომ ეს გახვეული ყველა პირიქით, უკან - იგნორირება, რომ.
ვივარაუდოთ, რომ ეს არ გაითიშება ნორმალურად.
არსებობს რთული პასუხი რომ.
>> ახლა, ეს არ არის ძალიან სასარგებლო.
ასე რომ, უბრალოდ გაშვებული ჩვენი პროგრამა შიგნით ამ debugger არ დაგვეხმარება ნებისმიერ
სხვათა შორის, მას შემდეგ, რაც ჩვენ შეგვეძლო უბრალოდ გაკეთდეს dot slash გამართვის გარედან GDB.
ასე რომ, ერთი ბრძანება, რომ თქვენ ალბათ -
და მე ვტოვებ ამ.
Control-d ან დატოვა, როგორც მუშაობა.
მოდით გასახსნელად ისევ.
>> სხვა ბრძანება, რომ თქვენ ალბათ დაუყოვნებლივ სურს
შეეგუება არის Break.
ასე რომ, ჩვენ შესვენება მთავარ ახლა, და შემდეგ მე ახსნას რომ.
ისე, აქ ჩვენ ვხედავთ ჩვენ მითითებული breakpoint ამ ხაზის debug.c.
ასე რომ, რა შესვენების იმას ნიშნავს, რომ როდესაც მე აკრიფოთ პერსპექტივაში, პროგრამა აპირებს
გაგრძელდება გაშვებული სანამ მე მოხვდა breakpoint.
ასე რომ, როდესაც მე მოხვდა ტირაჟი, პროგრამა იწყება, და მაშინ იგი არღვევს, როგორც კი
შემოდის მთავარი ფუნქცია.
შესვენება მთავარ იქნება რაღაც თქვენ საკმაოდ ხშირად გააკეთოს.
>> და ახლა, წარმოგიდგინოთ ზოგიერთი უფრო ბრძანებები.
ყურადღება მიაქციეთ, რომ აქ, რომ ის ამბობდა ჩვენ მა ერთი ხაზი 11, რომელიც
printf, მიუთითოთ მთელი რიცხვი.
ასე რომ ბრძანება შემდეგი იქნება, თუ როგორ ჩვენ წასვლა მომდევნო ხაზი კოდი.
ეს აპირებს საშუალებას მოგვცემს ნაბიჯ ჩვენი პროგრამა ხაზს.
ასე შემდეგ.
>> ახლა ხაზი 12, ჩვენ ვაპირებთ მიიღოს რიცხვი.
შემდეგი.
და თუ უბრალოდ დააჭიროთ ერთხელ, ეს თქვენ მომხმარებელი ბოლო რაც თქვენ გააკეთეთ.
ასე რომ მე არ უნდა აკრიფოთ მომდევნო ყოველ ჯერზე.
ასე რომ შევა რიცხვი, 13.
ახლა, line 14, ხოლო i დიდია მეტი 10, და მე გავაკეთოთ შემდეგი.
და ჩვენ ვხედავთ, ჩვენ ვაპირებთ decrement i.
ამიტომ, ჩვენ ვაპირებთ, რომ decrement i ერთხელ.
>> ახლა, კიდევ ერთი სასარგებლო ბრძანება ბეჭდვა.
ასე დაბეჭდილი აპირებს ამობეჭდოთ ღირებულება ცვლადი.
მოდით მოუტანს out ღირებულება ცვლადი i.
მოდით ბეჭდვა i.
იგი აპირებს ამბობენ, მე 11.
ახლა ჩვენ შემდეგი ერთხელ ხოლო i მეტია 10.
ასე რომ კიდევ უფრო მეტია, ვიდრე 10, რადგან 11.
i მინუს მინუს.
მოდით ბეჭდვა i ერთხელ.
როგორც მოსალოდნელი იყო, ეს 10.
>> ახლა, მომდევნო.
ის ბრუნდება მდგომარეობაში, მე უფრო მეტი, ვიდრე 10, მაგრამ არის 10, ასე რომ,
ეს არ აღემატება 10, ამიტომ ჩვენ ველით, მას ცვენას ხოლო loop.
და ახლა ჩვენ ქვემოთ რომ ხაზი კოდი.
და კიდევ ერთი ბრძანება, სია, უბრალოდ აპირებს არიან წინა და შემდეგი
რამდენიმე ხაზი კოდი, თუ დაკარგული თავს.
ასე რომ, ჩვენ მხოლოდ დასრულების ამ ხოლო მარყუჟის, და ახლა ჩვენ შევედით ამ
ხოლო მარყუჟის, ხაზი 18.
ასე რომ სანამ მე არ თანაბარი 0.
და შემდეგი, მე შეადგენს i მინუს 3, და ჩვენ შეამჩნია, ამ ყველაფერს მხოლოდ შენარჩუნებას აპირებს.
და ჩვენ შეგვიძლია ბეჭდვა i.
>> თითოეული ბრძანება სახის აქვს კომბინაციები.
ასე რომ p არის მოკლე დაბეჭდილი.
ასე რომ ჩვენ შეგვიძლია p i.
უბრალოდ შეინახოს ჩატარების n, ან აკეთეთ შემდეგი.
ბეჭდვა i ერთხელ.
ხედავთ ახლა ეს ნეგატიური 167.
ასე რომ, ეს გაგრძელდება სამუდამოდ, მაგრამ არა მართლაც სამუდამოდ, რადგან თქვენ უბრალოდ დაინახა, რომ
რეალურად დასრულდება რაღაც მომენტში.
>> ასე რომ გემო GDB.
მაგრამ მოდით გავაკეთოთ კიდევ ერთი რამ GDB.
Uh, გამართვის.
ასე რომ, ამ კონკრეტულ შემთხვევაში, უსასრულო loop მოხდა იყოს შიგნით
ძირითადი ფუნქცია.
და ახლა, მხოლოდ მიიღოს, რომ, რომ მე ვარ აპირებს გადავიდეს უსასრულო loop შევიდა
foo ფუნქცია.
უბრალოდ გვახსოვდეს, რომ, ბოლოს ამ პროგრამა, ასევე, ამ თავდაპირველად
მოუწოდებს foo, რომელიც მხოლოდ აპირებს ბეჭდვა i.
მაგრამ ახლა ჩვენ მოუწოდებენ foo, რომელიც ვაპირებ decrement i სანამ ეს 0, და
შემდეგ ბეჭდვა, რომ ცვლადი.
OK.
გადავარჩინოთ რომ.
რათა გამართვის.
და ახლა, GDB გამართვის.
OK.
>> ასე რომ, თუ მე უბრალოდ გაუშვით მაშინ მე არ ვაპირებ შეძლებენ რეალურად დაიხევს მეშვეობით my
პროგრამა line-by-line.
მოდით შესვენება მთავარ, და შემდეგ აკრიფოთ პერსპექტივაში.
ასე რომ წავიდეთ ამ გზით, printf, შეიყვანოთ მთელი რიცხვი, მიიღოთ რიცხვი, 13.
ამიტომ, ჩვენ ვაპირებთ, რომ შევინარჩუნოთ decrementing სანამ მე მეტია 10.
მაშინ ჩვენ ვაპირებთ დაეცემა მეშვეობით ხოლო მარყუჟის, და მიიღეთ ხაზი -
მოდით გასახსნელად up ცალკე ფანჯარაში.
ასე რომ, ჩვენ decremented სანამ მე აღარ მეტი 10 და შემდეგ ჩვენ
მოუწოდა ფუნქცია, foo.
>> მერე რა მოხდა, როგორც კი მოხვდა ფუნქცია foo, ასევე, მე ე.წ. foo, და
მაშინ მე აღარ ჰქონდა კონტროლის GDB.
ასე რომ, როგორც კი მოხვდა შემდეგი ამ ხაზი, ყველაფერი გაგრძელდა ეს მოხდა,
სადაც პროგრამის დასრულების როდის -
ვივარაუდოთ, რომ ეს არ არსებობს საბოლოოდ.
თქვენ ნახეთ, რომ პაუზის ცოტა, თუმცა.
ასე რომ, რატომ დაკარგავს კონტროლს პროგრამა იმ ეტაპზე?
ისე, როდესაც მე აკრიფოთ მომდევნო, რომ მიდის ლიტერატურული შემდეგი ხაზი კოდი, რომ
განახორციელებს.
ასე შემდეგ ხაზი 21 შემდეგი ხაზი კოდი რომ განახორციელებს არის ხაზი 22,
რომელიც, არსებული მთავარი.
ასე რომ, მე არ მინდა, რომ უბრალოდ მომდევნო ხაზი კოდი.
მინდა წასვლას ფუნქცია, foo, და შემდეგ ასევე დაიხევს მეშვეობით
იმ ხაზების კოდი.
>> ასე რომ, ჩვენ გვაქვს ალტერნატივა.
მოდით დატოვა, რომ ერთხელ.
დაარღვიე მთავარი.
Uh, 1, შემდეგი, მომდევნო, 13, შემდეგი, შემდეგი, მომდევნო, ფრთხილად,
სანამ ჩვენ მოხვდა ხაზი foo.
OK.
>> ახლა, ჩვენ დროს ხაზი 21, სადაც ჩვენ მოვუწოდებთ foo.
ჩვენ არ გვინდა, აკრიფოთ შემდეგ, მას შემდეგ, უბრალოდ მოვუწოდებთ ფუნქცია foo, და
წასვლა მომდევნო ხაზი კოდი.
ის, რაც ჩვენ გვინდა გამოვიყენოთ არის ნაბიჯი.
ასე რომ არსებობს განსხვავება ნაბიჯი და შემდეგი, სადაც Step ნაბიჯები შევიდა
ფუნქცია, და შემდეგი მიდის მეტი ფუნქცია.
უბრალოდ ახორციელებს მთლიანად ფუნქცია და ინახავს აპირებს.
>> ასე ნაბიჯი აპირებს მიგვიყვანს შევიდა ფუნქცია, foo.
და ჩვენ ვხედავთ, აქ, ახლა, ჩვენ უკან ეს მაშინ, როცა მარყუჟის, რომ, თეორიულად,
აპირებს გაგრძელდება სამუდამოდ.
და თუ მოხვდა ნაბიჯი, როდესაც ის კი არ არის ფუნქცია მოვუწოდებთ, მაშინ ეს
იდენტური შემდეგი.
ასე რომ, ეს მხოლოდ მაშინ, როდესაც თქვენ ხაზი, მოუწოდებდა ფუნქცია, რომელიც ნაბიჯი
აპირებს განსხვავდება შემდეგი.
ასე ნაბიჯ მიგვიყვანს აქ.
ნაბიჯი, ნაბიჯი, ნაბიჯი, ნაბიჯი, ნაბიჯი, ნაბიჯი, და ჩვენ უბრალოდ უსასრულო loop სამუდამოდ.
>> ასე რომ თქვენ შეიძლება შეეგუოს, რომ როგორც თქვენი გზა საიდენტიფიკაციო უსასრულო მარყუჟების, არის
უბრალოდ ჩატარების ამ შეიყვანეთ გასაღები ვხედავ, სადაც თქვენ მიიღებთ დავრჩებოდით.
არსებობს უკეთესი გზა ამის გაკეთება, მაგრამ ახლა, რომ სავსებით საკმარისია.
და სტილისტურად, შეესაბამებოდეს სტილი 50, მე უნდა გაკეთდეს ეს.
OK.
>> ასე რომ ერთი ბოლო ბრძანება გააცნოს.
კარგად, მოდით GDB გამართვის შემოსული
ასე რომ ნაცვლად არღვევს მთავარ, თუ იცით foo ფუნქცია ასევე არის
პრობლემა, მაშინ მე ვერ მხოლოდ განაცხადა, შესვენება foo, ნაცვლად.
ვთქვათ მე შესვენება ორივე ძირითადი და foo.
ასე რომ, შეგიძლიათ, როგორც ბევრი breakpoints როგორც თქვენ გსურთ.
როდესაც მე აკრიფოთ პერსპექტივაში, ის აპირებს შეჩერება -
ooh, მოდით recompile, რადგან მე შეიცვალა ყველაფერი.
თქვენ ნახავთ ამ ხაზის Warning წყარო ფაილი ბოლოდროინდელი გარდა გაშვება.
ასე რომ, ეს ნიშნავს, რომ მე უბრალოდ წავიდა აქ და შეიცვალა ამ შეესაბამებოდეს სტილი
50, მაგრამ მე არ recompile პროგრამა.
ასე GDB მაიძულებს იცის, რომ.
მე დატოვა, რათა გამართვის ერთხელ, მოხვდა GDB გამართვის.
OK.
>> ახლა, უკან რა იყო აკეთებს.
შესვენება მთავარ, შესვენების foo.
ახლა თუ პროგრამის გაშვება, ამიტომ აპირებს გაგრძელდება მანამ, სანამ ჰიტები
breakpoint.
რომ breakpoint ხდება იყოს პირველი ერთი მთავარი.
ახლა, ნაცვლად აკეთებს შემდეგი, მომდევნო, შემდეგი, შემდეგი, მომდევნო, სანამ მოხვდა foo, I
შეგიძლიათ აკრიფოთ გაგრძელდება, რომელიც გააგრძელებს სანამ არ მოხვდა შემდეგი breakpoint.
მე უნდა მიუთითოთ რიცხვი პირველი.
გაგრძელდება გაგრძელდება მანამ, სანამ მოხვდა შემდეგი breakpoint, რომელიც არის ის, რომ
ფუნქცია foo.
>> ასე რომ Run გაგრძელდება თქვენ მოხვდა breakpoint, მაგრამ თქვენ მხოლოდ აკრიფოთ როცა
თქვენ დაწყებული პროგრამა, და შემდეგ, მას შემდეგ, ის გაგრძელდება.
იმ შემთხვევაში, თუ მე მხოლოდ გააკეთა შესვენება ძირითადი და შემდეგ გაიქცა, იგი ყველაფერს შესვენება
მთავარი, და შემდეგ გააგრძელოს.
მას შემდეგ, რაც მე არ მაქვს შესვენების წერტილი foo, შეიყვანეთ მთელი რიცხვი, მაშინ ახლა მე
არ აპირებს დაარღვიოს at foo.
ის უბრალოდ აპირებს უსასრულო loop მანამდე.
OK.
>> ასე რომ Intro to GDB.
თქვენ უნდა დაიწყოს გამოყენებით, თქვენი პრობლემა კომპლექტი.
ეს შეიძლება იყოს ძალიან სასარგებლო იდენტიფიცირება შეცდომები.
თუ თქვენ რეალურად მხოლოდ, line-by-line, წავიდეთ თქვენი კოდი და შედარება რა არის
რეალურად ხდება ის, რაც თქვენ ველით უნდა მოხდეს, მაშინ ეს საკმაოდ
ძნელია გამოგრჩეთ თქვენი შეცდომები.
OK.
>> ასე რომ, გასულ კვირას დავით აღიზარდოს ამ საიდუმლო გასაღები კრიპტოგრაფიის პერსონალის
პირველად, სადაც ჩვენ არ გვინდა, პაროლები უბრალოდ უნდა ინახება ჩვენს
კომპიუტერული ზოგიერთ უბრალო ტექსტური ფაილი, სადაც ვინმე გადმოდიოდნენ და მხოლოდ
გახსნა ეს და წაიკითხოთ.
იდეალურ შემთხვევაში, ისინი დაშიფრული რამდენიმე გზა.
და პრობლემა Set 2, თქვენ უნდა საქმე ერთი მეთოდი დაშიფვრის,
ან, ასევე, ორი მეთოდები, მაგრამ ისინი არც თუ ისე დიდი.
თუ თქვენ ჰაკერი გამოცემა, თქვენ ასევე ვაპირებთ იყოს საქმე
გაშიფვრის დროს მოხდენილი ზოგიერთი რამ.
>> ასე რომ, ეს საკითხი არის, ასევე, მაშინაც კი, თუ ჩვენ ძლიერი შიფრირების
ალგორითმი მსოფლიოში, თუ თქვენ განსაკუთრებით ცუდი დაგავიწყდათ, მაშინ იგი
არ დაგეხმარებათ ძალიან ბევრი, რადგან ხალხი მაინც შეძლებს გაერკვნენ ის.
მაშინაც კი, თუ ხედავს, რომ დაშიფრული სიმებიანი და ეს ჰგავს სასადილო ნაგავი
ეს ნიშნავს, რომ არაფერი, თუ ისინი კიდევ უბრალოდ უნდა შევეცადოთ რამდენიმე პაროლები
გაერკვნენ ის, მაშინ არ არის ძალიან უსაფრთხო.
ასე რომ, თვალს ვიდეო, ხდის, რომ წერტილი.
>> [ვიდეო აღწარმოების]
>> -მუზარადი, თქვენ ჯოჯოხეთის განსახიერება.
რა ხდება?
რას აკეთებთ ჩემი ქალიშვილი?
>> -ნებართვა ჩემთვის წარმოგიდგინოთ ბრწყინვალე ახალგაზრდა პლასტიკური ქირურგი, დოქტორი ფილიპ
Schlotkin, ყველაზე დიდი ცხვირი სამუშაო ადამიანი მთელი
სამყარო, და Beverly Hills.
>> -Your Highness.
>> ცხვირი სამუშაო?
მე არ მესმის.
ის უკვე ჰქონდა ცხვირი სამუშაო.
ეს იყო ტკბილი თექვსმეტი დღემდე.
>> -No.
ის არ არის რაც ფიქრობთ.
ეს ბევრად, ბევრად უარესი.
თუ არ მომეცი კომბინაცია საჰაერო ფარი, დოქტორ Schlotkin იქნება
მისცეს თქვენი ქალიშვილი უკან თავის ძველ ცხვირი.
>> -No.
სად კიდევ რომ?
>> -All უფლება.
მე გეტყვით.
არა, daddy.
არა, თქვენ არ უნდა.
>> -You're უფლება, ჩემო ძვირფასო.
მე მენატრება შენი ახალი ცხვირი.
მაგრამ მე არ ვუთხრა მას კომბინაცია, არ აქვს მნიშვნელობა რა.
>> -ძალიან კარგად.
დოქტორი Schlotkin, თქვენი უარესი.
>> -ჩემი სიამოვნება.
>> [ინსტრუმენტები მიმდინარეობს sharpened]
>> -No.
დაველოდოთ.
მე გეტყვით.
>> მე ვიცოდი, რომ ეს იმუშავებს.
ყველა უფლება.
Give it to me.
>> -კომბინაცია არის ერთი.
>> -One.
>> -ორი.
>> სამი.
>> ოთხი.
>> ხუთი.
>> -So კომბინაცია არის ერთი, ორი, სამი, ოთხი, ხუთი.
სწორედ stupidest მოედანზე მე ოდესმე მსმენია ჩემს ცხოვრებაში.
სწორედ ასეთი რამ იდიოტი ექნება თავისი ბარგი.
>> -მადლობა, თქვენი უდიდებულესობა.
>> რას აკეთებთ?
>> -I გამორთულია კედელი.
>> -No თქვენ არ.
თქვენ გამორთულია მთელი ფილმი.
>> -I უნდა დაპრესილი არასწორი ღილაკს.
>> -Well, დაუსვან მას უკან.
განათავსეთ ფილმის უკან.
>> დიახ, სერ.
დიახ, სერ.
>> მოდით წავიდეთ, არნოლდ.
მოდით, Gretchen.
რა თქმა უნდა, თქვენ იცით, მე მაინც უნდა ანგარიშსწორება თქვენ ამ.
>> [END ვიდეო აღწარმოების]
>> ROB ბოდენი ყველა უფლება.
ახლა რომ ჩვენ უკვე საუბარი უსაფრთხოების გარკვეულწილად, ლამაზი
პატარა ფილმი ვებ, ასე რომ უკანასკნელ დღის განმავლობაში, ამ თემებზე NSA
მონიტორინგის ყველაფერი.
ეს შეიძლება იყოს რთული გრძნობენ, როგორც თქვენ აქვს გარკვეული კონფიდენციალურობის
ამჟამად მსოფლიოში, თუმცა ვერ გეტყვით თქვენ ყველაზე დეტალებზე PRISM.
ასე რომ, მოძრავი მიღმა PRISM, ჩვენ არ ვაპირებთ უნდა ლაპარაკი, რომ ახლა
ვიფიქროთ თქვენი ლეპტოპი.
ასე რომ, აქ, მე მინდა გადართოთ ჩემს რეალურ ანგარიშზე,
ჩემი პატარა penguin.
ასე რომ, მე მაქვს დაგავიწყდათ კომპლექტი, და რომ პაროლის რასაც მინდა, რომ იყოს.
>> მაგრამ გახსოვდეთ, რომ ის, რაც მე ხე ერთად, ეს შესვლისას
სწრაფი, ზოგიერთი პროგრამა.
ეს რაღაც პროგრამა რომ იყო დაწერილი რამდენიმე პირი.
და ასე, რომ პირი, თუ ისინი განსაკუთრებით მუქარის, მათ შეეძლოთ
განაცხადა, ყველა უფლება, ასე რომ, თუ დაგავიწყდათ რომ მე შევა ტოლია ჩემი
ფაქტობრივი დაგავიწყდათ, ან ტოლია ზოგიერთი სპეციალური პაროლი -
დავით გასაოცარია ან რაღაც -
მაშინ მათ შემოსული
ასე რომ, მუქარის პროგრამისტი შეეძლო ხელმისაწვდომობა ყველა თქვენი Macs, ან
Windows, ან არაფერი.
>> ასე რომ არ არის ბევრი შეშფოთება, ვინაიდან, ვგულისხმობ, ეს არის login პროგრამა
რომ გაიგზავნება OS X, ასობით ან ათასობით ადამიანს აქვს
განხილული ამ კოდი.
ასე რომ, თუ, თქვენს კოდი სადღაც, თქვენ ამბობენ, რომ თუ ამ სტრიქონს შეადგენს შეადგენს
დავით გასაოცარია, login, მაშინ ვინმეს იქნება, ისევე, დაველოდოთ.
ეს არ არის სწორი.
ეს არ უნდა იყოს აქ.
ასე რომ ერთი გზა მივიღებთ რამ იყოს სახის უსაფრთხო.
>> მაგრამ ვიფიქროთ კი პროგრამები რომ წერთ.
ვთქვათ თქვენ წერდა შესვლისას პროგრამა.
ასე რომ, ეს შესვლისას პროგრამა, რომელიც თქვენ წერდა, ასე რომ, რა თქმა უნდა, თქვენ კარგი
პროგრამისტი.
თქვენ არ აპირებს დააყენოს ნებისმიერი მუქარის თუ x უდრის უდრის დავით awesome
თქვენს კოდი.
მაგრამ ეს პროგრამა, რას გამოყენება შეადგინონ ამ პროგრამის?
რაღაც Clang.
მერე რა, რომ პირი, რომელიც მოხდა დაწერა Clang სპეციალური cased in Clang
რაღაც, თუ მე შედგენის შესვლა პროგრამას, შემდეგ შეიყვანეთ ეს კოდი
შევიდა შესვლისას პროგრამა, რომელიც ამბობს, რომ თუ x უდრის უდრის დავით გასაოცარია?
ასე რომ, არ არის საკმაოდ, მაგრამ ჩვენ იგივე საკითხი აქ, სადაც Clang, ასევე,
ათასობით, თუ არ ათიათასობით ადამიანი, შევხედე Clang, აქვს
შევხედე მისი ხაზების კოდი და განაცხადა, ყველა უფლება, იქ არაფერი ცუდი აქ.
ცხადია, არავინ აკეთებს არაფერი ამ მუქარის.
>> მაგრამ რა არის Clang თავად, ისევე, რა მოხდება, თუ მე კომპილაციის Clang?
რა მოხდება, თუ მაქვს რამდენიმე შემდგენელი რომ ადგენს Clang რომ ჩანართები შევიდა Clang
ამ სპეციალური hack, რომელიც ამბობს, ყველა უფლება, როდესაც მე კომპილაციის Clang, მაშინ
შემსრულებელი მივიღებ უნდა სპეციალურად გამოიყურება შიგნით შესვლისას პროგრამა და ჩადეთ
ამ პაროლი შეადგენს შეადგენს Dave არის რა?
ასე რომ, გახსოვდეთ, რომ თქვენი შემდგენელი თავად უნდა იყოს შედგენილი რაღაც მომენტში.
ასე რომ, თუ რა თქვენ კომპილაციის Clang ერთად, თავად არის მუქარის, მაშინ
შეიძლება ბრალია მთელი გზა ქვევით ხაზი.
>> ასე რომ აქ, ჩვენ Ken Thompson და Dennis Ritchie.
ასე რომ, ეს არის iconic სურათი.
Dennis Ritchie არის სწორი.
იგი არის ძირითადი -
საკმაოდ ბევრი წერდა C. ასე რომ თქვენ შეგიძლიათ დიდი მადლობა გადავუხადო მას ამ კლასში.
კენ Thomson არის მარცხენა.
ორი მათგანი ძირითადად დაწერა UNIX.
ასევე, ისინი ძირითადი ავტორები in UNIX.
იყო გარკვეული სხვები.
ასე რომ, კენ ტომპსონი, რაღაც მომენტში, ის გაიმარჯვებს Turing ჯილდო.
და Turing ჯილდო, მე ყოველთვის ისმის ეს მითითებული ამ გზით, ის
ნობელის პრემიის კომპიუტერულ მეცნიერებათა.
>> ასე რომ Turing ჯილდო, მას აქვს თავის გამოსვლაში მიღების.
და იგი აძლევს ამ ძალიან ცნობილი გამოსვლა ახლა, ე.წ. მოსაზრებები ვაღიარებთ
Trust, რომელიც ჩვენ არ უკავშირდება იმისათვის, რომ, რა თქმა უნდა ნახვა.
და ამ სიტყვის, მისი თქმით, ყველა უფლება, ასე დავწერე UNIX და ახლა ყველა
თქვენ ადამიანი იყენებს UNIX.
ახლა, მახსოვს, რომ Linux არის პირდაპირი შთამომავალი UNIX.
OS X პირდაპირ იყენებს UNIX.
Windows არ იმდენად, მაგრამ ბევრი იდეები ამოღებულ იქნა UNIX.
>> ამიტომ იგი მიდის სცენაზე და აცხადებს, ყველა უფლება, მე დავწერე UNIX.
და მხოლოდ ასე რომ თქვენ ბიჭები ვიცი, მე ვარ შეუძლია შეხვიდეთ ყველა
ერთი თქვენი კომპიუტერი.
მას შემდეგ, რაც მე ზუსტად ერთი ასეთი განსაკუთრებული, თუ x უდრის უდრის Ken Thomson გასაოცარია,
მაშინ მე დაშვებული შესვლაზე.
ასე რომ, ადამიანებს, ისევე როგორც, ასევე, how'd თქვენ ამის გაკეთება?
ჩვენ შევხედე შესვლისას პროგრამა და არაფერი არ არსებობს.
ის მოსწონს, ასევე, მე განახლდა შემდგენელი შედით სისტემაში შესვლისას პროგრამა
ისე, რომ შესვლისას პროგრამა არის ექნება რომ x ტოლია ტოლია Ken Thompson
გასაოცარია.
>> და ამბობენ, ისე, რომ არ არის მართალი.
ჩვენ შევხედავთ შემდგენელი და შემდგენელი არ აქვს არც ერთი ხაზი
კოდი იგრძნობა.
ის მოსწონს, OK, მაგრამ რა ხარ შედგენის შემდგენელი ერთად?
და ჰგონიათ, და ის, როგორც, ასევე, მე ვარ, ვინც მისცა თქვენ შემდგენელი
თქვენ იყენებთ კომპილაციის შემდგენელი, ასე რომ, თქვენ შედგენის შემდგენელი, რომელიც
თავისთავად მუქარის, და იქნება შესვენება შესვლისას პროგრამა.
ასე რომ, ძირითადად, იმ ეტაპზე, არ არსებობს არანაირად თქვენ შეიძლება შევხედოთ წყარო
კოდი შესვლისას პროგრამა რა არის არასწორი.
თქვენ ვერ გამოიყურება კოდის შემდგენელი
რა არის არასწორი.
>> თქვენ უნდა შევხედოთ მანქანა კოდი, ფაქტობრივი ორობითი შესახებ
შედგენილი შემდგენელი ვხედავ, დაველოდოთ, ამ ხაზების კოდი არ უნდა იყოს აქ.
მაგრამ Ken Thompson მას ერთი ნაბიჯით შემდგომი და ვთქვი, რომ არსებობს
ამ სპეციალური პროგრამა, რომელიც რეალურად დაეხმაროს წაიკითხოთ ორობითი პროგრამების,
და ასე თუ ვინმე გამოყენებული, რომ პროგრამა წაკითხვის ორობითი, ისინი ვხედავთ ამ
ხაზი კოდი.
მან შეიცვალა იმ პროგრამების ვთქვა, ყველა უფლება, თუ თქვენ ეძებს
შემდგენელი, არ ჩანს ამ კონკრეტულ კომპლექტი ორობითი.
>> ასე რომ თქვენ უნდა მიიღოს, რომ ნაბიჯი შემდგომი და ძირითადად, რომ შეიძლება
მიღებული სხვადასხვა დონეზე indirection, და რაღაც მომენტში, არავინ რეალურად
იქნება შემოწმების.
ასე რომ, მორალური ამბავი, თქვენ არ იქნება წერა
Clang ამ კლასში.
თქვენ უნდა გამოყენებით ასვლა Clang ბევრი ამ კლასში.
ყველა იცით, Clang არის მუქარის პროგრამა, რომელიც საბოტაჟს ყველა
ერთი პროგრამის თქვენ ოდესმე შედგენილი.
და დატოვება თქვენ, რომ ძალიან საშიში გაითვალისწინოთ, რომ თქვენ ოთხშაბათს.
>> [ტაში]
>> დინამიკები 2: მომდევნო CS50.
>> დინამიკები 3: ხომ არ გაბედავს ვთქვა, რომ.
თქვენ შეგიძლიათ ამის გაკეთება.
თქვენ კეთდება ეს ადრე, თქვენ შეგიძლიათ ამის გაკეთება დღეს, თქვენ შეგიძლიათ ამის გაკეთება ხვალ.
თქვენ უკვე აკეთებს ამ წლების განმავლობაში.
უბრალოდ იქ და ამის გაკეთება.
თქვენ შეგიძლიათ ამის გაკეთება.
>> [მუსიკის დაკვრა]