>> DOUG LLOYD ყველა უფლება GDB.
რა არის ზუსტად?
ასე რომ, GDB, რომელიც დგას იმ GNU Debugger,
მართლაც გასაოცარია ინსტრუმენტი, რომელიც ჩვენ შეგვიძლია გამოიყენოთ დაგვეხმარება გამართვის ჩვენი პროგრამების,
ან გაირკვეს, სადაც ყველაფერი მიდის არასწორი ჩვენი პროგრამების.
GDB არის საოცრად ძლიერი, მაგრამ გამომავალი და ურთიერთქმედება ის
შეიძლება ცოტა cryptic.
ეს, როგორც წესი ბრძანების ინსტრუმენტი, და მას შეუძლია ჩააგდოს ბევრი შეტყობინებები თქვენ.
და მას შეუძლია სახის მძიმე გაურკვეველი ზუსტად რა ხდება.
საბედნიეროდ, ჩვენ გადადგა ნაბიჯები, დაფიქსირება ამ პრობლემას თქვენთვის
როგორც თქვენ მუშაობთ მეშვეობით CS50.
თუ თქვენ არ იყენებთ გრაფიკული debugger, რომელიც ჩემს კოლეგას Dan
Armandarse უკვე ვესაუბრე საკმაოდ ცოტა შესახებ ვიდეო რომ
უნდა იყოს მეტი აქ ახლა, თქვენ უნდა
გამოიყენოს ამ ბრძანების ინსტრუმენტები მუშაობა GDB.
თუ თქვენ მომუშავე CS50 IDE, თქვენ არ უნდა გავაკეთოთ ეს.
მაგრამ თუ თქვენ არ მომუშავე CS50 IDE,
ალბათ გამოყენებით ვერსია of CS50 ელექტრო მოწყობილობების,
ან სხვა Linux ოპერაციული სისტემის GDB დამონტაჟებული,
თქვენ უნდა გამოვიყენოთ ამ ბრძანების ინსტრუმენტები.
>> მას შემდეგ, რაც თქვენ შეიძლება უნდა გავაკეთოთ, რომ ეს
სასარგებლო უბრალოდ უნდა გვესმოდეს, თუ როგორ GDB მუშაობს ბრძანების.
თუმცა ისევ და ისევ, თუ თქვენ გამოყენებით CS50 IDE, თქვენ
შეგიძლიათ გამოიყენოთ გრაფიკული debugger რომ არის ჩაშენებული IDE.
ასე რომ მიიღოს რამ მიმდინარეობს GDB, დაიწყოს გამართვის
პროცესში კონკრეტული პროგრამა, ყველა თქვენ უნდა გააკეთოთ
არის ტიპის GDB მოჰყვა მიერ პროგრამის სახელი.
ასე მაგალითად, თუ თქვენი პროგრამა Hello, თქვენ უნდა აკრიფოთ GDB hello.
>> როდესაც თქვენ, რომ, თქვენ აპირებს დახევის up GDB გარემოში.
თქვენი სწრაფი შეიცვლება, და ნაცვლად იმისა, რომ ის, რაც, როგორც წესი,
არის, როდესაც თქვენ აკრიფოთ რამ ბრძანება ხაზი ls,
cd-- ყველა თქვენი ტიპიური Linux ბრძანებები, დროული
შეიცვლება, ალბათ, რაღაც ისევე როგორც ფრჩხილებში GDB ფრჩხილებში.
ეს არის თქვენი ახალი GDB ზოლზე, რადგან თქვენ შიგნით GDB გარემოში.
მას შემდეგ, რაც შიგნით, რომ გარემო, არსებობს ორი ძირითადი ბრძანებები
რომ თქვენ ალბათ გამოიყენოთ შემდეგი თანმიმდევრობით.
>> პირველი არის ის, ბ, რომელიც მოკლე შესვენება.
მას შემდეგ, რაც თქვენ აკრიფოთ ბ, თქვენ, როგორც წესი, აკრიფოთ სახელით ფუნქცია,
ან თუ მოხდება უნდა იცოდეს დაახლოებით რა ხაზის ნომერი
თქვენი პროგრამა იწყება უნდა მოიქცეს ცოტა უცნაური,
შეგიძლიათ ჩაწეროთ ხაზი ნომერი იქ.
რა ბ, ან შესვენების აკეთებს არის ის საშუალებას თქვენი პროგრამა
აწარმოებს წლამდე გარკვეული თვალსაზრისით, კერძოდ, სახელით ფუნქცია
რომ თქვენს მიერ მითითებული და ხაზი ნომერი, რომელიც თქვენ დააკონკრეტა.
>> და ამ ეტაპზე, გაყინვას აღსრულება.
ეს არის მართლაც კარგია, რადგან ერთხელ შესრულების გაიყინა
თქვენ შეგიძლიათ დაიწყოს ძალიან ნელა მიმართეთ თქვენი პროგრამა.
როგორც წესი, თუ თქვენ უკვე გაშვებული თქვენი პროგრამების, ისინი საკმაოდ მოკლე.
როგორც წესი, თქვენ ჩაწერეთ dot slash რასაც სახელი თქვენი პროგრამა, Enter,
და სანამ თქვენ შეგიძლიათ დახუჭოს, თქვენი პროგრამა უკვე დასრულდა.
ეს ნამდვილად არ არის ბევრი დრო ცდილობენ და გაერკვნენ, თუ რა ხდება არასწორი.
ასე რომ, ეს ნამდვილად შეძლებს ნელი რამ ქვემოთ მიიღწევა შესვენების წერტილი b,
და შემდეგ სტეპინგზე.
>> მაშინ ერთხელ თქვენ მითითებული თქვენი შესვენების წერტილი, შეგიძლიათ პროგრამის გაშვება.
და თუ თქვენ გაქვთ რაიმე ბრძანების ხაზი არგუმენტები,
თქვენს მიერ მითითებული მათ აქ, არ არის, როდესაც თქვენ აკრიფოთ GDB თქვენი პროგრამის სახელი.
თქვენ მიუთითოს ყველა ბრძანების ხაზი არგუმენტები აღების r, ან პერსპექტივაში,
და შემდეგ რაც ბრძანების არგუმენტები შიგნით თქვენი პროგრამა.
არსებობს მთელი რიგი სხვა ნამდვილად მნიშვნელოვანი და სასარგებლო ბრძანებები
შიგნით მშპ-გარემო.
ნება მომეცით, უბრალოდ სწრაფად წავიდეთ მეტი რამდენიმე მათგანი.
>> პირველი არის ის, n, რომელიც მოკლე შემდეგი, და თქვენ შეგიძლიათ აკრიფოთ შემდეგი ნაცვლად n,
ორივე იმუშავებს.
და ეს მხოლოდ სტენოგრამის.
და როგორც თქვენ ალბათ უკვე მიღებული გამოიყენება, რათა ჩაწეროთ რამ
მოკლე ზოგადად უკეთესი.
და რას გააკეთებს ის არის, რომ ყველაფერს წინ გადადგმული ნაბიჯია ერთი ბლოკი კოდი.
ასე რომ, ეს წინსვლა სანამ ფუნქცია ზარი.
და მაშინ ნაცვლად diving, რომ ფუნქცია
და გადის ყველა, რომ ფუნქციები კოდი, ეს იქნება უბრალოდ ფუნქცია.
>> ფუნქცია დაერქმევა.
ის ყველაფერს გააკეთებს, რასაც მისი მუშაობა.
იგი დაბრუნდება ღირებულება ფუნქცია, რომელიც მას.
და მაშინ თქვენ გადაადგილება, რათა შემდეგი ხაზი, რომელიც მოუწოდებდა ფუნქცია.
თუ გსურთ დახევას შიგნით ფუნქცია,
ნაცვლად მხოლოდ მქონე იგი შეასრულოს, მით უმეტეს,
თუ ფიქრობთ, რომ პრობლემა შეიძლება ტყუილი შიგნით რომ ფუნქცია,
თქვენ შეიძლება, რა თქმა უნდა, მითითებული შესვენების მეტიც, შიგნით რომ ფუნქცია.
ან თუ თქვენ უკვე ჩართულია, შეგიძლიათ გამოყენება s წინ გადადგმული ნაბიჯია ერთი ხაზი კოდი.
>> ასე რომ, ეს იქნება გადადგას და ჩაყვინთვის შევიდა ფუნქციები,
ნაცვლად უბრალოდ უნდა შეასრულოს და გრძელდება ფუნქცია
რომ თქვენ გამართვის.
თუ თქვენ ოდესმე გვინდა ვიცოდეთ ღირებულება ცვლადი,
შეგიძლიათ ჩაწეროთ p, ან ბეჭდვა, და შემდეგ ცვლადის სახელი.
და რომელიც ამობეჭდოთ თქვენ, შიგნით GDB გარემო,
სახელი ცვლადი, რომელიც you-- ამართლებს ჩემთვის ღირებულება ცვლადი
რომ თქვენ დაასახელა.
თუ გსურთ იცოდეთ ღირებულებების ყოველ ადგილობრივი ცვლადი ხელმისაწვდომი, სადაც
თქვენ ამჟამად არის თქვენი პროგრამა, შეგიძლიათ ჩაწეროთ ინფორმაცია ადგილობრივები.
ეს არის ბევრი უფრო სწრაფად, ვიდრე აკრეფით P და მერე რასაც,
ჩამონათვალია ყველა ცვლადები, რომ თქვენ იცით, თუ არსებობს.
შეგიძლიათ აკრიფოთ ინფორმაცია ადგილობრივები, და ეს ამობეჭდოთ ყველაფერი თქვენთვის.
შემდეგი up არის bt, რომელიც მოკლე უკან კვალი.
ახლა, ზოგადად, განსაკუთრებით დასაწყისში CS50,
თქვენ ნამდვილად არ გვაქვს შემთხვევა გამოიყენოთ bt, ან უკან კვალი,
იმიტომ, რომ თქვენ არ მქონე ფუნქციები რომ მოვუწოდებთ სხვა ფუნქციები.
>> ალბათ მთავარი ზარი ფუნქცია, მაგრამ ეს, ალბათ, მას.
თქვენ არ გაქვთ, რომ სხვა ფუნქცია მოუწოდებს სხვა ფუნქცია, რომელიც
მოუწოდებს სხვა ფუნქცია, და ასე შემდეგ.
მაგრამ, როგორც თქვენი პროგრამების კიდევ უფრო რთული, და განსაკუთრებით
როდესაც თქვენ დაიწყოს მუშაობა ერთად უკან, უკან კვალი
შეიძლება მართლაც სასარგებლო გზა მოგცემთ სახის მისაღებად გარკვეული გარემოებების, სადაც
მე ვარ ჩემი პროგრამა.
ასე რომ ვთქვათ, თქვენ წერილობითი თქვენი კოდი და თქვენ იცით, რომ მთავარ მოუწოდებს ფუნქცია
f, რომელიც მოუწოდებს ფუნქცია g, რომელიც მოუწოდებს ფუნქცია სთ.
ასე რომ, ჩვენ გვაქვს რამდენიმე ფენა მობუდარი ხდება აქ.
>> თუ თქვენ შიგნით თქვენი GDB გარემო,
და თქვენ იცით თქვენი შიგნით თ, მაგრამ თქვენ დაგავიწყდებათ
იმაზე, თუ რა მივიღე თქვენ სადაც are-- შეგიძლიათ აკრიფოთ BT, ან უკან კვალი,
და ეს იქნება ამობეჭდოთ თ, გ, f მთავარი, ერთად რამდენიმე სხვა ინფორმაცია, რომელიც
გაძლევთ ნახავ, რომ, OK მთავარი მოუწოდა ვ ვ მოუწოდა გ, ზ მოუწოდა h,
და რომ სადაც მე გაკეთებული ვარ ჩემი პროგრამა.
ასე რომ, ეს შეიძლება მართლაც სასარგებლო, მით უმეტეს, რომ cryptic-Ness of GDB
ხდება ცოტა გადაჭარბებული, რომ გავარკვიოთ ზუსტად სადაც რამ.
და ბოლოს, მაშინ, როდესაც კეთდება, ან როდესაც თქვენ გაკეთდეს გამართვის ეს
და გსურთ დახევას დაშორებით საწყისი GDB გარემო,
ეს ხელს უწყობს ვიცი როგორ უნდა გავიდნენ ეს.
შეგიძლიათ აკრიფოთ q, ან გადადგომის გავიდნენ.
ახლა, სანამ დღევანდელი ვიდეო მე მზად buggy პროგრამა
მოუწოდა buggy1, რომელიც მე შედგენილი საწყისი ფაილი ცნობილია, როგორც buggy1.c.
როგორც თქვენ შეიძლება ველოდოთ, ეს პროგრამა ფაქტობრივად buggy.
რაღაც მიდის არასწორი როდესაც მე ვცდილობ და გაუშვით.
ახლა, სამწუხაროდ, მე უნებლიედ ამოღებულია ჩემი buggy1.c ფაილი,
ასე რომ, რათა ჩემთვის გაერკვნენ რა ხდება არასწორი ეს პროგრამა,
მე ვაპირებ უნდა გამოვიყენოთ GDB სახის ბრმად, ცდილობს
ნავიგაცია მეშვეობით ეს პროგრამა გაერკვნენ, თუ რა ხდება არასწორი.
მაგრამ მხოლოდ გამოყენებით ინსტრუმენტები ჩვენ უკვე შეიტყო,
ჩვენ შეიძლება საკმაოდ ბევრი ფიგურა ზუსტად ის, რაც არის.
მოდით უხელმძღვანელებს გადასცა CS50 IDE და აქვს სახე.
OK, ასე რომ, ჩვენ აქ ჩემი CS50 IDE გარემო,
და მე მიუახლოვდით ცოტა ასე რომ თქვენ ხედავთ ცოტა მეტი.
ჩემი ტერმინალის ფანჯარაში, თუ სიაში შინაარსი ჩემი ამჟამინდელი დირექტორი
ერთად ls, ჩვენ დავინახავთ, რომ მე აქვს რამდენიმე წყარო
აქ, მათ შორის ადრე განხილული buggy1.
რა ხდება, როდესაც მე ვცდილობ და გაუშვით buggy1.
კარგად მოდით გავარკვიოთ.
მე აკრიფოთ dot ხაზი, buggy, და მე დააჭიროთ.
>> სეგმენტაცია ხარვეზებით.
ეს არ არის კარგი.
თუ გავიხსენებთ, რომელიც სეგმენტაცია ბრალია, როგორც წესი,
ხდება, როდესაც ჩვენ მეხსიერება რომ ჩვენ არ უშვებენ შეეხოთ.
ჩვენ როგორღაც მიაღწია გარეთ საზღვრები
რა პროგრამა, შემდგენელი, მოგვცა.
ასე რომ, უკვე, რომ არის ნახავ შენარჩუნება ყუთისთვის
როგორც ჩვენ ვიწყებთ გამართვის პროცესში.
რაღაც წავიდა ცოტა არასწორია აქ.
>> ყველა უფლება, მოდით დაწყება მდე GDB გარემო
და თუ ჩვენ ვერ გაერკვნენ რა პრობლემა არის.
მე ვაპირებ გარკვევას ჩემი ეკრანზე, და მე ვაპირებ აკრიფოთ GDB
ერთხელ, შესვლის GDB გარემო, და პროგრამის სახელი
რომ მე მინდა გამართვის, buggy1.
ჩვენ კიდევ ცოტა გაგზავნა, კითხულობს სიმბოლოები buggy1, გაკეთდეს.
ყველა ეს ნიშნავს, რომ იგი გამოყვანილია ერთად ყველა კოდი,
და ახლა უკვე ჩაიტვირთება GDB, და ეს მზად ვართ წავიდეთ.
>> ახლა, რა უნდა გავაკეთოთ?
გახსოვთ, თუ რა პირველი ნაბიჯი, როგორც წესი,
მას შემდეგ, რაც მე შიგნით ამ გარემოში?
იმედია, თქვენ განაცხადა მითითებული შესვენების წერტილი, იმიტომ, რომ
ის ფაქტი, რომ ის, რაც მე მინდა.
ახლა, მე არ მაქვს კოდის ეს
ჩემს წინ, რომელიც, სავარაუდოდ, არ არის ტიპიური გამოყენების შემთხვევაში, სხვათა შორის.
თქვენ ალბათ.
ასე რომ, კარგი.
მაგრამ თუ გავითვალისწინებთ, არ, რა არის ერთი ფუნქცია, რომ თქვენ იცით,
არსებობს თითოეული C პროგრამა?
არ აქვს მნიშვნელობა, თუ რამდენად დიდი ან რთული ეს არის, ეს ფუნქცია ნამდვილად არსებობს.
მთავარი, არა?
>> ასე რომ, ვერ რიგში, ჩვენ შეგვიძლია მითითებული შესვენების დროს ძირითადი.
და ისევ, მე შეიძლება მხოლოდ ჩაწერეთ შესვენება მთავარ, ნაცვლად ბ.
და თუ აინტერესებს, თუ ოდესმე ტიპი გრძელი ბრძანება
და მერე ხვდები, რომ თქვენ აკრეფილი არასწორი რამ,
და გსურთ მოშორება ყველა, როგორც მე უბრალოდ გააკეთა,
თქვენ შეგიძლიათ აღებას U, რომელიც წაშლა ყველაფერი და მოუტანს თქვენ უკან
დასაწყისში კურსორი ხაზები.
ბევრი უფრო სწრაფად, ვიდრე უბრალოდ გეჭიროთ წაშლა, ან დარტყმის რამოდენიმე ჯერ
მეტი.
>> ასე რომ, ჩვენ მითითებული შესვენების დროს ძირითადი.
და როგორც ხედავთ, ის ამბობს, რომ ჩვენ მითითებული შესვენების დროს ფაილის buggy1.c,
და როგორც ჩანს, პირველი ხაზი კოდი მთავარი არის ხაზი შვიდი.
ისევ და ისევ, ჩვენ არ გვაქვს წყარო ფაილი აქ,
მაგრამ მე ვივარაუდოთ, რომ ეს მეუბნებოდა სიმართლე.
და მაშინ, მე უბრალოდ ცდილობს და პროგრამის გაშვება, r.
დასაწყისი პროგრამა.
ყველა უფლება, ასე რომ, ეს გაგზავნა ცოტა cryptic.
მაგრამ, ძირითადად, რა არის ხდება აქ არის, ეს მხოლოდ
მეუბნებოდა, მე მოხვდა ჩემი შესვენების წერტილი, შესვენების წერტილი ნომერი 1.
>> და მაშინ, რომ ხაზი კოდი, არსებობს ასეთი ფაილი ან დირექტორია.
ერთადერთი მიზეზი, რომ მე ვხედავ, რომ გაგზავნა
იმიტომ, რომ მე უნებლიედ ამოღებულია ჩემი buggy.c ფაილი.
თუ ჩემი buggy1.c ფაილი არსებობდა მიმდინარე მომსახურება,
რომ ხაზი არ გვინდა რეალურად მეუბნებოდა, თუ რა ხაზი კოდი
ფაქტიურად წერია.
სამწუხაროდ, მე წაშალა ის.
ჩვენ ვაპირებთ, რომ უნდა სახის ნავიგაცია მეშვეობით ეს ცოტა უფრო ბრმად.
>> OK, ასე რომ, ვნახოთ, რა მინდა აქ?
ისე, მინდა იცოდეს, თუ რა ადგილობრივი ცვლადები შესაძლოა ხელმისაწვდომია ჩემთვის.
მე დავიწყე ჩემი პროგრამა.
ვნახოთ, რა შეიძლება იყოს უკვე ინიციალიზაცია ჩვენთვის.
მე აკრიფოთ ინფორმაცია ადგილობრივები, არც ადგილობრივები.
ყველა უფლება, ისე, რომ არ მომეცი ტონა ინფორმაცია.
მე ვერ შეეცდება და ამობეჭდოთ ცვლადი, მაგრამ მე არ ვიცი არც ერთი ცვლადი სახელები.
მე ვერ შეეცდება უკან კვალი, მაგრამ მე შიგნით ძირითადი
მე ვიცი, მე არ გააკეთა სხვა ფუნქცია დარეკეთ ახლავე.
>> ასე რომ, როგორც ჩანს, ჩემი ერთადერთი ვარიანტი არის გამოიყენოს ო ან ასე და დაიწყოს ჩაყვინთვის.
მე ვაპირებ გამოიყენოს ო.
ასე რომ, მე აკრიფოთ n.
ოჰ ღმერთო, რა ხდება აქ.
პროგრამა მიღებული სიგნალების, SIGSEGV სეგმენტაცია ბრალია,
და შემდეგ მთელი bunch of პერსონალი.
მე უკვე overwhelmed.
ისე, იქ ფაქტიურად ბევრი უნდა შეიტყო აქ.
ასე რომ, რას გვეუბნება ეს?
ის, რაც გვეუბნება, ეს პროგრამა შესახებ, მაგრამ ჯერ კიდევ არ არის seg ბრალია.
კერძოდ, მე ვაპირებ მიუახლოვდით კიდევ უფრო აქ,
ეს დაახლოებით seg ბრალია შესახებ რაღაც მოუწოდა strcmp.
>> ახლა, ჩვენ შეიძლება არ განიხილა ამ ფუნქციის ინტენსიურად.
მაგრამ ეს is-- იმიტომ, რომ ჩვენ არ ვაპირებთ ვისაუბროთ ყველა ფუნქცია, რომელიც
არსებობს C სტანდარტული ბიბლიოთეკა მაგრამ ისინი ყველა ხელმისაწვდომი,
კერძოდ, თუ თქვენ მიიღოს შევხედოთ reference.cs50.net.
და strcmp არის მართლაც ძლიერი ფუნქცია, რომელიც არსებობს შიგნით
საქართველოს string.h header ფაილი, რომელიც არის header
ფაილი, რომელიც ეძღვნება ფუნქციების რომ მუშაობა და მანიპულირების სიმები.
>> კერძოდ, რა strcmp არ არის ადარებს ფასეულობები ორი სიმები.
ასე რომ, მე უნდა სეგმენტაცია ბრალია წლის ზარი strcmp ჩანს.
მე მოხვდა n, და, ფაქტობრივად, მივიღებ გაგზავნა, პროგრამა წყდება ერთად სიგნალი SIGSEGV
სეგმენტაცია ბრალია. ასე რომ, ახლა მე რეალურად არ seg გააკრიტიკა,
და ჩემი პროგრამა აქვს საკმაოდ გაცილებით ეფექტურად დათმობა.
ეს არის პროგრამის დასრულების შემდეგ.
ეს ჩაშალეს დაეჯახა.
ასე რომ, არ იყო ბევრი, მაგრამ მე რეალურად არ სწავლობენ საკმაოდ მწირი
ამ პატარა გამოცდილება.
რა ვისწავლე?
ისე, ჩემი პროგრამა ავარია საკმაოდ ბევრი დაუყოვნებლივ.
ჩემი პროგრამა დამსხვრევაზე ზარი stRCMP, მაგრამ მე
არ აქვს რაიმე ადგილობრივი ცვლადები ჩემი პროგრამა იმ დროს, რომ ეს ავარია.
ასე რომ, რა სიმებიანი, ან სიმები, შეიძლება მე შესაძლოა იყოს შედარებით.
თუ მე არ მაქვს რაიმე ადგილობრივი ცვლადები, ალბათ
ვივარაუდოთ, რომ მე ჰქონდეს იქ იქნებ არის გლობალური ცვლადი, რომელიც შეიძლება იყოს ჭეშმარიტი.
>> მაგრამ ზოგადად, როგორც ჩანს, როგორც მე შედარებით
რაღაც რომ არ არსებობს.
მოდით გამოიძიოს რომ ცოტა უფრო.
ამიტომ, მე ვაპირებ გარკვევას ჩემი ეკრანზე.
მე ვაპირებ, რათა გარეთ GDB გარემოს მეორე.
და მე ვფიქრობ, OK, ასე რომ, არსებობს ადგილობრივი ცვლადები ჩემი პროგრამა.
მაინტერესებს, თუ იქნებ მე უნდა გაიაროს სიმებიანი, როგორც ბრძანების არგუმენტი.
მოდით შეამოწმოთ ამ გარეთ.
მე არ კეთდება ეს ადრე.
>> მოდით ვნახოთ, თუ შესაძლოა, თუ მე აწარმოებს ამ პროგრამის ბრძანების არგუმენტი მუშაობს.
არა, არ სეგმენტაცია ბრალია არსებობს.
უბრალოდ მითხრა, რომ მე figured ის.
ასე რომ, შესაძლოა, რომ გადავწყვიტოთ აქ.
და მართლაც, თუ მე დაბრუნდეს და შევხედოთ ფაქტობრივი კოდის buggy1.c,
როგორც ჩანს, თითქოს, რასაც მე ვაკეთებ არის მე მიღების ზარი strcmp გარეშე
შემოწმების თუ არა სინამდვილეში argv [1] არსებობს.
ეს არის რეალურად კოდის buggy1.c.
ასე რომ, რაც მე ნამდვილად უნდა გავაკეთოთ აქ დაფიქსირება ჩემი პროგრამა,
ვთქვათ, მე მაქვს შეიტანოს ჩემს წინ, არის
უბრალოდ დაამატოთ გამშვები რათა დარწმუნებული ვარ, რომ argc უდრის 2.
ასე რომ, ეს, მაგალითად, ერთხელ, როგორც ვთქვი, ცოტა contrived, არა?
თქვენ ზოგადად არ აპირებს შემთხვევით წაშალოთ თქვენი კოდის
და მაშინ უნდა ვეცადოთ და გამართვისა პროგრამა.
მაგრამ იმედია, რომ მისცა თქვენ ილუსტრაცია
სახის რამ, რომ თქვენ შეიძლება ფიქრი
როგორც თქვენ გამართვის თქვენი პროგრამა.
>> რა არის სახელმწიფოს საქმეებში აქ?
რა ცვლადები მე გაქვთ ჩემთვის?
სად არის ჩემი პროგრამა crashing, რა ხაზი,
თუ რა ზარი რა ფუნქცია?
რა სახის clues, რომ ჯერ მომეცი?
და სწორედ სახის აზროვნების, რომ თქვენ
უნდა მისაღებად შევიდა, როდესაც თქვენ ფიქრი გამართვის თქვენი პროგრამებს.
>> მე Doug Lloyd.
ეს არის CS50.