[? DAN ARMADARAS:?] Hi, მე ვარ [? Dan Armadaras?].
დღეს, ჩვენ ვაპირებთ ეძებს debugging.
არა მხოლოდ ჩვენ ვაპირებთ ვისაუბროთ ზოგიერთ ტექნიკას,
არამედ ჩვენ ვაპირებთ შევხედოთ ზოგიერთი თავისებურება შეიცავს
ფარგლებში CS50 IDE, რომელიც საშუალებას თქვენ ადვილად გამართვის პროგრამა.
>> მხოლოდ ერთი მაგალითი ის, რაც შეიძლება წავიდეთ არასწორი
და ეს არის რეალურად რაღაც რომ ჩვენ უკვე მინახავს ადრე.
ამ შემთხვევაში, ეს არის C პროგრამა რომელიც ადასტურებს რიცხვი შესახებ,
ყოფს მას ორი და უზრუნველყოფს გამომავალი უკან შესახებ.
ახლა, რაც ჩვენ ვნახეთ ადრე ლექციები,
ჩვენ ვიცით, რომ ეს რეალურად გამოიწვიოს კონკრეტული სახის სამმართველოს პრობლემები
როდესაც ჩვენ გვაქვს კენტი ნომრები.
>> კერძოდ, ჩვენ მხოლოდ გადაყარეთ არაფერი შემდეგ ათობითი წერტილი.
ახლა ჩვენ ვიცით, რომ ეს ხდება, რომ იყოს საქმე.
და თუ ჩვენ აწარმოებს, ჩვენ შეგვიძლია ადასტურებენ ჩვენი ეჭვები, პირველ რიგში, შედგენა.
და მაშინ, მიერ გაშვებული და შესვლის კენტი.
>> ეს არის ახალი არაფერია.
მაგრამ ეს არის რეალურად მაგალითად შეცდომა, რომ
შეიძლება არსებობდეს ფარგლებში უფრო დიდი პროგრამა რომ ხდება უფრო რთული მწკრივზე ქვემოთ.
მიუხედავად იმისა, რომ ჩვენ ვიცით, რა საკითხი არის, ჭეშმარიტი არსი საკითხზე
შეიძლება ცდილობს იდენტიფიცირება კონკრეტულად სადაც შეცდომა ხდება,
საიდენტიფიკაციო რა, რომ პრობლემა და შემდეგ აფიქსირებს მას.
ასე რომ გთავაზობთ, როგორც მაგალითად რა შეიძლება იყოს რაღაც
ჩვენ უკვე ვიცით, მაგრამ შეიძლება დაკრძალეს ფარგლებში სხვა ელემენტების კოდი.
>> ასე იხსნება სხვა წყარო კოდი ფაილი, როგორც მაგალითად,
ეს გაყოფა არის ნაწილი უფრო დიდი პროგრამა.
ჯერ კიდევ შეიძლება იყოს პატარა ცოტა ჩაიფიქრეს და ჩვენ
შეიძლება შეძლებთ ადვილად იდენტიფიცირება, მით უმეტეს,
მას შემდეგ, რაც ჩვენ უბრალოდ განხილული.
მაგრამ ჩვენ შეგვიძლია გაერკვნენ, რომ ეს პრობლემა შეიძლება არსებობდეს უფრო ფართო მასშტაბით.
>> თუ მე კომპილაციის და ახლა აწარმოებს, შეიყვანოთ უცნაური ნომერი,
ჩვენ ვხედავთ, რომ ჩვენ არ მიიღოს ზუსტად გამომავალი, რომ ჩვენ შეიძლება არ ელოდა.
ამ კონკრეტულ შემთხვევაში, შეიძლება ითქვას, რომ ჩვენ
გსურთ ითვლიან ყველა ნომრები ერთი მდე ზოგიერთი კონკრეტული რაოდენობა.
ჩვენ ვხედავთ, რომ ჩვენ აქვს სხვადასხვა საკითხებზე
აქ თუ ჩვენ outputting, უბრალოდ, 0 და 1 როდესაც ჩვენ გთავაზობთ შეყვანის 5.
>> ასე რომ, ჩვენ უკვე ვიცით, რომ არსებობს პრობლემა აქ.
მაგრამ ჩვენ შეიძლება არ ვიცი ზუსტად სადაც ეს საკითხი რეალურად არსებობს.
ახლა ერთ-ერთი გზა, რომ ჩვენ შეგვიძლია ცდილობენ დაფიქსირება ამ
არის ის, რომ ჩვენ უკვე გააცნო.
ჩვენ შეგვიძლია მხოლოდ გამოიყენოს იგი უფრო ფართო მასშტაბით.
>> On line 14, ჩვენ გვაქვს ამ printf ფუნქცია,
რაც საშუალებას გვაძლევს ამობეჭდოთ სახელმწიფო სხვადასხვა ცალი ინფორმაციას.
და ეს არის ის, რომ თქვენ უნდა ბერკეტები თქვენი პროგრამა
ცდილობენ გაერკვნენ, თუ რა არის ხდება სხვადასხვა ხაზების კოდი.
ასე რომ, მაშინაც კი, თუ ეს ასე არ არის საბოლოო გამომავალი, რომ ჩვენ რეალურად
გსურთ პროდუქციის გარეთ ამ პროგრამის, ჩვენ ჯერ კიდევ
ალბათ ზოგიერთი გამართვის განცხადებები, სადაც ჩვენ
შეგიძლიათ ცდილობენ გაერკვნენ, თუ რა ხდება შიგნით ჩვენი კოდი.
>> ასე რომ, ამ შემთხვევაში, მე printf ერთად გამართვის აქვს.
ამ შემთხვევაში, ეს არის უბრალოდ გამართვის string
რომ მე ვარ up აყენებს ასე რომ ხდება ძალიან ნათელი გამომავალი ჩემი კოდი
რა არის, რომ მე მინდა გაჩვენოთ.
და გამომავალი აქ რაოდენობის რომ ჩვენ გამოითვლება.
>> ამ შემთხვევაში, მე შეიძლება გვინდა ვიცოდეთ, ზუსტად
რა ხდება და მის მას შემდეგ, რაც კონკრეტული გამოთვლები.
ასე რომ, მე შეიძლება გამოიყენოთ printf ადრე და ამის შემდეგ ხაზი კოდი.
ამ შემთხვევაში, მე ვერ კი რათა ის ცოტა უფრო ნათელი
განაცხადა, გამართვის ადრე და გამართვის შემდეგ,
რომ მე არ აღრეული თავს სხვადასხვა ხაზები, რომ გამოიყურება იდენტურია.
>> ახლა თუ ჩვენ recompile ამ და პერსპექტივაში ის, შეიტანეთ ნომერი, როგორიცაა ხუთ ერთხელ,
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ახლა გამომავალი და მის შემდეგ
და ნახავთ, რომ ჩვენ არ კეთდება წმინდა გაყოფა და ნათელი, რომელსაც მთელი რიგი
რომ ჩვენ რეალურად გვინდა გავაკეთოთ.
ახლა ამ შემთხვევაში, ეს არის არ არის ნათელი გამომავალი.
ეს ნამდვილად არ არის ნათელი შედეგს, რომ ჩვენ გვინდა out ამ კონკრეტული პროგრამა.
>> და ეს არის, კიდევ ერთხელ, ცოტა ჩაიფიქრეს.
მაგრამ, ალბათ, ერთ-ერთი რამ, რომ ჩვენ შეგვიძლია ამის გაკეთება, თუ დაზუსტება განაცხადა
ჩვენ გვინდა, რომ გაყოფა ამ მიერ 2 და დაამატოთ 1-- ასე რომ, სხვა სიტყვებით რომ ვთქვათ,
ჩვენ გვინდა, რომ მრგვალ up-- შემდეგ ჩვენ შეიძლება ვიცით, რომ ჩვენ შეგვიძლია
გავაკეთოთ, რომ კონკრეტული რამ, ამ შემთხვევაში.
ახლა აქ ჩვენ ვიცით, რომ ჩვენ ვიქნებით შეუძლია დაამატოთ 1 ჩვენი განახევრდა ნომერი.
>> მოდით recompile ამ და დაადასტუროს, რომ ეს
იქცევა ისე, რომ ჩვენ გვინდა.
ჩვენ ვხედავთ, რომ ახლა, სანამ რომელსაც, ჩვენ გვაქვს 5 ნომერი.
მას შემდეგ, რაც, ჩვენ გვაქვს 3, რომლის თანახმად, ჩვენი დაზუსტება,
არის ის, რაც გვინდოდა ამის გაკეთება.
მაგრამ თუ გადავხედავთ გამომავალი აქ, ჩვენ შეგვიძლია
ვხედავ, რომ ჩვენ შეიძლება ჰქონდეს სხვა შეცდომის საერთოდ, რომელიც
რომ ჩვენ ვიწყებთ ჩვენი რაოდენობა 0-დან.
>> ახლა, ეს არის ის, რომ ჩვენ ვნახეთ წარსულში
და ჩვენ შეგვიძლია დაფიქსირება საკმაოდ ადვილად.
მაგრამ ამ შემთხვევაში, ჩვენ ასევე მქონდა სასარგებლოდ
გამოყენებით printf განცხადება პირდაპირ შიგნით ამისთვის loop
ვიცოდეთ, ზუსტად იქ, სადაც რომ შეცდომა იყო ხდება.
ასე რომ, printf განცხადებები, ძალიან სასარგებლო ეხმარება
თქვენ განსაზღვრავს, სადაც, ზუსტად თქვენი კოდის,
სპეციფიური შეცდომა ხდება.
>> და ეს ასევე მნიშვნელოვანია გვესმოდეს რომ, როგორც ჩვენ წერილობით კოდი,
ჩვენ შეიძლება ვარაუდები ამის შესახებ სახელმწიფო პროგრამა.
ან ჩვენ შეიძლება ვარაუდები იმაზე, თუ რა ნაწილი პროგრამა
რეალურად სწორი ან არასწორი, როდესაც მოგვიანებით, როგორც ჩვენ ავაშენოთ, რომ პროგრამა
და რათა ის ნაწილი რთული და დიდი პროგრამა
რომ ჩვენ გვესმის, რომ ზოგიერთი ასპექტი რომ არის რეალურად buggy.
>> გამოყენება printf ნამდვილად დაეხმარება ვიწრო ქვემოთ და იდენტიფიცირება
რეგიონებში პროგრამა, რომელიც არ შეიძლება იქცევიან ზუსტად ისე, რომ ჩვენ
ველით, ჩვენი ვარაუდები.
მაგრამ არსებობს სხვა ინსტრუმენტები შესაძლებელია, აგრეთვე,
რომელიც საშუალებას გვაძლევს, რომ ცდილობენ გაერკვნენ გარეთ, სადაც შეცდომა ხდება
და ასევე, კონკრეტულად, რა რამ ხდება შიგნით პროგრამა.
>> ასე გამოყენებით printf ძალიან სასარგებლო როდესაც ჩვენ გვინდა
იდენტიფიცირება კონკრეტულ სფეროებში პროგრამა, რომელიც აქვს გარკვეული შეცდომა.
მაგრამ ეს ასევე ხდება tedious შემდეგ, ხოლო.
ამ შემთხვევაში, ეს არის შედარებით მარტივი პროგრამა
მხოლოდ ერთი ან ორი ცვლადი.
და ეს ხდება ძალიან ადვილია, ამობეჭდოთ ღირებულება იმ ცვლადების
ამ კონტექსტში დიდი პროგრამა.
>> მაგრამ ჩვენ შეიძლება ჰქონდეს სხვადასხვა პროგრამა, რომელიც მრავალი ცვლადი.
და ეს არ შეიძლება იყოს საკმაოდ ასე მარტივი printf
ცდილობენ შეაფასონ, თუ რა ხდება ყოველი მათგანი იმ ცვლადების
როგორც პროგრამის შესრულებაში.
არსებობს პროგრამა, რომელიც არსებობს მოუწოდა debugger პროგრამა.
ამ შემთხვევაში, ერთი, რომ ჩვენ გამოყენება GNU debugger, ან GDB,
რომელიც საშუალებას გვაძლევს, რათა შეამოწმოს შიდა დამუშავებული პროგრამა ბევრად უფრო
დეტალურად.
>> ჩვენ შეგვიძლია რეალურად შეასრულოს GDB იმ ბრძანების
აქ უბრალოდ აკრეფის GDB და ბრძანება, რომ ჩვენ გვინდა გამართვის.
ამ შემთხვევაში, ითვლიან.
ახლა, ამ შემთხვევაში, ჩვენ ვხედავთ, რომ ეს მოაქვს სწრაფი, რომელიც ამბობს, GDB.
და ჩვენ შეგვიძლია რეალურად შეასრულოს ბრძანებები GDB
რეალურად იწყება აღსრულება პროგრამა, შეჩერება გარკვეული რაოდენობა,
შეაფასოს ცვლადები და შეამოწმოს ცვლადები, რომ
არსებობს პროგრამა სახელმწიფო იმ მომენტში,
და ასე შემდეგ და ასე შემდეგ.
ის უზრუნველყოფს ბევრი ძალა ჩვენთვის.
>> მაგრამ ეს ასე მოხდება, რომ CS50 IDE ასევე
უზრუნველყოფს GUI ან მომხმარებლის ინტერფეისი GDB, რომ
საშუალებას გვაძლევს, რომ ამის გაკეთება არ არის საჭირო ბრძანების ხაზი ინტერფეისი განაწილებაზე
ან საერთოდ კი.
ისე, რომ მე შეუძლიათ, რომ არის გამოყენებით გამართვის ღილაკს
ძალიან ზევით CS50 IDE.
ახლა წარსულში, რაც გვაქვს ჩანს, რომ ჩვენ გამოვიყენოთ ბრძანება
ხაზი შედგენა და შემდეგ გაუშვით პროგრამა.
>> გამართვის ღილაკს აკეთებს ორივე ნაბიჯები.
მაგრამ ეს ასევე გამოიტანს debugger tab on შორს უფლება
რომელიც საშუალებას გვაძლევს, რათა შეამოწმოს სხვადასხვა თვისებები პროგრამა
რადგან ის შესრულებაში.
თუ მე დააჭირეთ გამართვის, ამ შემთხვევაში, ეს გამოიტანს
ახალი tab კონსოლში ფანჯრის დროს ძალიან ბოლოში.
>> და თქვენ შეგიძლიათ ნახოთ, რომ ეს tab აქვს გარკვეული ინფორმაცია ძალიან დაბრუნება.
და ჩვენ შეგვიძლია მეტწილად ეს.
მაგრამ ერთი რამ ჩვენ გვინდა, რომ შეამჩნია
ის არის, რომ ეს შედეგები იგივე, რომ ჩვენ
დაიჭერს თუ ჩვენ შევეცადეთ აწარმოებს მიიღოს on რომ C პროგრამის ტერმინალის ფანჯარაში.
>> აქ, ჩვენ ვხედავთ, რომ ის გაშვებული clang, და მას აქვს სხვადასხვა დროშები,
და ის შედგენის ჩვენი count.c ფაილი, რომელიც შერჩეულ tab დროს
რომ მე მოხვდა გამართვის.
ასე რომ, ეს არის ძალიან სასარგებლო, რადგან ახლა გამოყენებით ამ გამართვის ღილაკს,
ჩვენ შეგვიძლია ერთდროულად შედგენა და შემდეგ შეასრულოს პროგრამა, რომელიც ჩვენ, ფაქტობრივად,
გსურთ აწარმოებს.
>> ერთ-ერთი დროშებით, რომ არის მნიშვნელოვანია, რომ ამ შემთხვევაში,
ჩვენ, ფაქტობრივად, გამოყენებით ყველაზე გრძელი დრო
არამედ უბრალოდ გააკეთა რაღაც მხრივ ფრიალი [INAUDIBLE], რომელიც
ეს არის ერთ-ერთი უფლება აქ.
In clang, იგი აცხადებს, რომ -ggdb3.
ამ შემთხვევაში, რაც ჩვენ ვართ ვეუბნებოდი clang, ჩვენი შემდგენელი,
ის არის, რომ ჩვენ გვინდა კომპილაციის ჩვენი პროგრამა.
მაგრამ ასევე რა არის ეწოდება სიმბოლო ინფორმაცია
ისე, რომ შემდგენელი რეალურად აქვს დაშვება ბევრი ძირითადი ინფორმაცია
შეიცავს პროგრამის ფარგლებში.
>> უფრო კონკრეტულად, ნომერი ფუნქციები, რომელიც მე მაქვს,
სახელები იმ ფუნქციებს, ცვლადები, სახის
რომ იმ ცვლადების, და სხვადასხვა სხვა რამ, რომ დაეხმაროს debugger
შეასრულოს თავისი ოპერაცია.
ახლა არის რაღაც რომ მნიშვნელოვანია, რომ აღარაფერი ვთქვათ
როდესაც ჩვენ მსჯელობენ გაშვებული პროგრამის ამ გზით.
>> გაითვალისწინეთ, რომ ეს ფაქტიურად აღიზარდოს ახალი tab ჩვენს კონსოლი
გასწვრივ ბოლოში.
ჩვენ უკვე აღარ გვაქვს ურთიერთობა პირდაპირ ტერმინალის ფანჯარაში.
მაგრამ ეს ახალი tab არის რეალურად ტერმინალის ფანჯარაში.
ეს უბრალოდ არის სპეციფიკური გაშვებული პროგრამა, რომელიც ჩვენ შევქმენით.
>> გაითვალისწინეთ, რომ ბოლოში, ერთად ზოგიერთ გამომავალი
მიერ clang შემდგენელი და GDB, რომელიც ჩვენ შეგვიძლია მეტწილად,
ეს რეალურად გვიჩვენებს გამოშვება ჩვენი პროგრამა ძალიან ბოლოში.
ახლა ეს მნიშვნელოვანია გვესმოდეს რომ ეს ერთი ფანჯრის რეალურად
გაჩვენებთ გამომავალი თქვენი პროგრამის
მაგრამ ასევე შეუძლია მიიღოს შეყვანის რომ პროგრამა, ისევე.
>> ასე რომ, ცნობა, რომელიც ამბობს, გთხოვთ შეიყვანოთ ნომერი,
რომელიც არის იგივე გამომავალი, რომ ჩვენ გვქონდა ჰქონდა ტერმინალის ფანჯარაში ადრე.
მაგრამ ეს ნაჩვენები ამ ახალ tab.
შემიძლია შეყვანის ნომერი.
და ის, ფაქტობრივად, ფუნქცია, როგორც ჩვენ ველით,
გვიჩვენებს, ჩვენი გამართვის, გამომავალი, გამომავალი, რომელიც შეიძლება იყოს buggy,
როგორც ჩვენ ვნახეთ ადრე.
და ძალიან ბოლოში, ის რეალურად აქვს რამდენიმე დამატებითი გამომავალი
საწყისი მშპ-ს უბრალოდ ვამბობ, რომ ეს პროგრამა დაასრულა.
>> ახლა, როგორც თქვენ ნახეთ ამ კერძოდ პერსპექტივაში მეშვეობით,
ეს არ იყო განსაკუთრებით სასარგებლოა, რადგან მაშინაც კი,
მიუხედავად იმისა, რომ ჩვენ გვქონდა debugger მენიუ მოდის up, ეს იყო ჯერ კიდევ გაშვებული პროგრამა.
ამის აზრი არ გააკეთა ეს, ფაქტობრივად, პაუზის აღსრულების ჩვენთვის
შეძლებს შეამოწმოს ყველა ცვლადები შეიცავს.
არსებობს რაღაც რომ ჩვენ უნდა გავაკეთოთ იმისათვის,
მისაღებად GDB იმის აღიარება, რომ ჩვენ გვინდა პაუზის აღსრულების პროგრამა
და არა მხოლოდ დაუშვებს, რომ გაგრძელება ჩვეულებრივ, როგორც ჩვენ გვინდა სხვა შემთხვევაში.
>> იმისათვის, რომ პაუზის შესრულების, რაღაც კონკრეტული ხაზი,
ჩვენ უნდა შევქმნათ რა არის მოუწოდა შესვენების წერტილი.
და შესვენების ძალიან ადვილად შექმნა ამ CS50 IDE აღების თქვენი მაუსის
და დაჭერით პირდაპირ მარცხენა კონკრეტული ხაზის ნომერი.
მას შემდეგ, რაც მე ამის გაკეთება, წითელი dot როგორც ჩანს, რაც მიუთითებს,
, რომ ხაზი არის შესვენების წერტილი.
>> და მომავალი დრო, რომ აწარმოებს GDB, ის შეწყდება შესრულების დროს, რომ შესვენების წერტილი
როდესაც იგი აღწევს, რომ ხაზი კოდი.
ახლა ეს არის მნიშვნელოვანი რამ უნდა გააცნობიეროს
ის, რომ არ არის აუცილებელი, იმ შემთხვევაში, რომ ყველა ხაზი კოდი
რეალურად ხელმისაწვდომი.
მე რომ შევქმნათ ფუნქცია აქ, მაგალითად ბათილად f--
და მხოლოდ ამის ბეჭდვითი ხაზის აქ მიესალმები world-- თუ მე არასოდეს მოვუწოდებთ ამ ფუნქციის
ეს იქნება საქმე, რომ, თუ მე მითითებული შესვენების აქ,
ფუნქცია არასოდეს არ იქნება მოუწოდა.
შესაბამისად, ეს კერძოდ შესვენების წერტილი
არასოდეს რეალურად პაუზის პროგრამის შესრულება.
>> მოდით ვთქვათ, რომ მე სწორად შექმნა შესვენების ზოგიერთი ხაზი კოდი
რომელიც რეალურად შესრულდება.
ახლა ამ შემთხვევაში, ეს არის პირველი ხაზი ძირითად ფუნქციას.
ასე რომ, ეს, რა თქმა უნდა იმ შემთხვევაში, რომ, როგორც კი დაიწყება აღსრულება,
პირველივე ხაზი იქნება მიღწეული.
GDB პაუზის აღსრულება.
და მაშინ, მე შეძლებს ურთიერთქმედება debugger.
>> შეგიძლიათ დააყენოთ მრავალი ხაზს Breakpoints, თუ გსურთ.
ჩვენ ასევე შეგიძლიათ შექმნათ გამოდიან აქ ამ სეგმენტის კოდი
რომ არასოდეს არ იქნება მიღწეული.
ჩვენ ასევე შეუძლია შექმნას კიდევ ერთი ქვემოთ.
მიზეზის გამო, რომ ჩვენ გვინდა გსურთ ამის გაკეთება ჩვენ გამოგიგზავნით
წასვლას ცოტა მეტი დეტალური რაღაც მომენტში.
ასე რომ, ახლა, ნება მომეცით უბრალოდ გამორთოთ ეს დამატებითი შესვენება რაოდენობა
ასე რომ ჩვენ შეგვიძლია შევხედოთ რა ხდება როდესაც მე მაქვს ერთი შესვენების
წერტილი ჩემი პროგრამა.
მე მივიღე რამდენიმე ცვლილებები ამ პროგრამაში.
ასე რომ, მე უნდა შეინახოთ.
მე დააწკაპუნეთ გამართვის ისე, რომ მე არ შემიძლია დაიწყოს კოლექცია და შემდეგ
აღსრულების debugger.
>> ჩვენ ვხედავთ, რომ მას შემდეგ, რაც მომენტები, ხაზი, რომ ჩვენ შერჩეული როგორც შესვენების
წერტილი მონიშნულია ყვითელი.
ჩვენ შეგვიძლია ასევე შეამჩნევთ, რომ ზედა მარჯვენა გამართვის პანელი
რომ პაუზის ხატი იქცა შევიდა პატარა პიესა ხატი.
ეს იმას ნიშნავს, რომ ჩვენ გვაქვს პაუზის შესრულების, ამ კონკრეტულ შემთხვევაში.
და დარტყმის Play ღილაკს რომ საშუალებას გვაძლევს განაახლონ შესრულების
იმ კონკრეტული წერტილი.
>> გავითვალისწინოთ, რომ არსებობს რამდენიმე სხვა ღილაკები შესაძლებელი ამ გამართვის პანელი,
როგორც.
ჩამოდი, რომელიც საშუალებას იძლევა ჩემთვის შეასრულოს, რომ ერთი ხაზი კოდი
და ნაბიჯ მეტი რომ ხაზი შემდეგ, რაც, ამ შემთხვევაში,
იმას ნიშნავს, რომ printf განაცხადი ხორციელდება.
და ეს მაშინ პაუზის აღსრულების on line 13, ასე.
>> და არსებობს ასევე ნაბიჯი შევიდა ფუნქცია, რომელიც
სასარგებლოა თუ მე შევქმენი სხვა ფუნქციები სხვაგან კოდის.
და მე მინდა დახევას შევიდა იმ ფუნქციებს, ვიდრე
შეასრულოს, რომ ფუნქცია, როგორც მთელი.
მაგრამ ჩვენ უფრო იმ ნაბიჯი შევიდა ფუნქცია რაღაც მომენტში.
ახლა შეამჩნია, ზოგიერთი სხვა რამ, რომ რეალურად არსებობს ამ გამართვის პანელი.
>> ჩვენ გვაქვს პანელი მოუწოდა მოვუწოდებთ დასტის, რომელიც გვიჩვენებს,
სადაც ზუსტად ვართ.
ამ შემთხვევაში, ჩვენ შიგნით მთავარი ფუნქცია.
ჩვენი Script მოუწოდა count.c.
და ჩვენ არ უნდა იყოს line 13, სვეტი ერთი, რომელიც
არის ზუსტად ის, რაც ხაზგასმით რეგიონში კოდის მიუთითებს, ისევე.
>> ახლა შეამჩნია, რომ ეს ასევე ადასტურებს, ქვეშ ადგილობრივი ცვლადი განყოფილებაში
ყველა ცვლადები, რომ არსებობს ამ ფუნქცია.
ეს მნიშვნელოვანია აღინიშნოს, რომ ყველა ცვლადები
გამოჩნდება ეს ადგილობრივი ცვლადი მონაკვეთის ფარგლებში ფუნქცია,
კი, სანამ ისინი განისაზღვრება.
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ცვლადი მოუწოდა num, აქვს, რა მნიშვნელობა 0,
და ეს არის ტიპის int.
>> ახლა, სანამ ჩვენ რეალურად ინიციალიზაცია ყველა ამ ცვლადების,
ჩვენ არ ემთხვეოდეს გარანტირებული ვხედავ მნიშვნელობა 0.
და დამოკიდებულია სხვა სიკვდილით დასჯის რომ თქვენ არ შესრულდა
და სახელმწიფო თქვენი მეხსიერების, როდესაც თქვენ რეალურად აწარმოებს ამ პროგრამის,
თქვენ ნახავთ, რომ თქვენ ვერ ვხედავ ღირებულებები 0
და ნაცვლად ამისა, ზოგიერთი სხვა Crazy ნომრები.
>> მაგრამ არ ინერვიულოთ შესახებ.
ეს არ იქნება შესაბამისი, ვიდრე თქვენ ნამდვილად ინიციალიზაცია ღირებულება.
ახლა, ამ შემთხვევაში, ჩვენ ვხედავთ, რომ მე არ შესრულდა გარკვეული შედეგები.
და მე, ახლა, შეჩერებულია აღსრულება.
მაგრამ ამ შემთხვევაში, რა მე ნამდვილად გსურთ ამის გაკეთება
არის ახლა დაიხევს ამ ონლაინ კოდი ისე, რომ მე შემიძლია რეალურად
შეკითხვის შესახებ, რომ int, რომ ჩვენ გვინდა გამოვიყენოთ ჩვენი პროგრამა.
>> ახლა ამ შემთხვევაში, როდესაც მე მოხვდა ნაბიჯი დასრულდა, ცნობა
რომ პაუზა ან საკმაოდ რეზიუმე ღილაკს შეიცვალა ამ პაუზა ღილაკს
იმიტომ, რომ ეს კოდი რეალურად შესრულებაში.
რა ხდება ახლა ის არის, რომ
ელოდება us შემავალი ზოგიერთი ინფორმაცია როგორც ვხედავთ, ჩვენი გამომავალი ტექსტი
ძალიან ბოლოში.
>> ასე რომ, ახლა, ეს არის რეალურად არ დააყოვნა,
მიუხედავად იმისა, რომ, ერთგვარი, როგორც ჩანს, იმის გამო, რომ არაფერი არ ხდება.
მაგრამ ეს ასე ხდება, რომ ჩემი კონკრეტულ შემთხვევაში on line 13
ველოდები მომხმარებლის შეყვანის.
ასე რომ, GDB არ შეუძლია შეამოწმოს პროგრამა, როგორც ეს არის გაშვებული.
>> ახლა მომავალი დრო, რომ მე შეიყვანოთ შეყვანის ასე რომ მე შევა, რომ ნომერი 5,
როგორც ჩვენ ვნახეთ past-- მოხვდა დაბრუნება, და ჩვენ
შეამჩნია, რომ დაუყოვნებლივ, GDB პაუზებით და კიდევ ერთხელ, ხაზს უსვამს, რომ მომდევნო ხაზი.
მაგრამ შეამჩნია, რომ ახლა, როგორც შედეგი ჩვენი შესაყვანი მნიშვნელობა,
ჩვენ ახლდება, რომ ღირებულება შიგნით ჩვენი ადგილობრივი ცვლადები, რომელიც
ძალიან სასარგებლოა ვიცი ზუსტად რა რიცხვი იყო მეხსიერებაში.
>> ახლა შემიძლია საშუალებას ეს პროგრამა გაგრძელდება სათამაშო ბოლომდე მისი შესრულების
დარტყმის რეზიუმე.
ჩვენ ვხედავთ, რომ ძალიან სწრაფად რა პროგრამა ფერი შესრულებაში
იგივე გამომავალი, რომ ჩვენ ჰქონდა ადრე, debugger იხურება,
და ახლა ამ პროგრამის მთლიანად შეწყვეტილია.
>> მე აჩვენებს, რომ მხოლოდ მიზნებისათვის ხედავს, თუ რა
ხდება, როდესაც ჩვენ რეალურად მოხვდა რეზიუმე.
მაგრამ ჩვენ რეალურად ვაპირებთ მინდა, რომ დაბრუნდეს ამ პროგრამის
ასე რომ ჩვენ შეგვიძლია ცდილობენ გამართვის ზუსტად რა ხდება.
ახლა, მე გამოყენებით debugger, მე შეიძლება არ გვჭირდება ამ გამართვის printf განცხადებები.
>> ასე რომ მე ვერ ამოიღონ მათ, როგორც მე ყველაფერს გავაკეთებ ახლა უბრალოდ უნდა დავუბრუნდეთ მარტივი კოდი
რომ ჩვენ გვქონდა მომენტში წინ.
ახლა, როდესაც მე გადარჩენა პროგრამა და შეასრულოს ის,
ეს იქნება, ერთხელ, რომ საწყის შესვენება წერტილი, რომელიც მე მქონდა on line 11.
და მე გექნებათ შეამოწმოს ჩემი ცვლადები როგორც მე მინდა ამის გაკეთება.
>> ეს უბრალოდ ისე ხდება, რომ ეს ნაწილი არის ძალიან საინტერესო,
და მე ვიცი, რომ მე ვაპირებ ბეჭდვა ეს განცხადება.
გთხოვთ შეიყვანოთ ნომერი.
და მაშინ, მე ვიცი, რომ მე ვაპირებ ვთხოვო შესახებ, რომ რიცხვი.
ასე რომ, ალბათ, მე რეალურად მინდა გადავიდეს ჩემი შესვენების წერტილი ცოტა უფრო ქვემოთ.
>> შეგიძლიათ ამოიღონ შესვენების რაოდენობა დაჭერით, კიდევ ერთხელ, პირდაპირ
მარცხნივ, რომ ხაზის ნომერი.
ეს წითელი dot გაქრება, რაც მიუთითებს, , რომ შესვენების წერტილი არის წასული.
ახლა, ამ შემთხვევაში, აღსრულების შეჩერებულია.
ასე რომ, ეს რეალურად არ აპირებს განახლდეს, რომ კონკრეტულ შემთხვევაში.
მაგრამ მე შემიძლია მითითებული შესვენების მეტიც, ცოტა მოგვიანებით.
>> და როდესაც მე ახლა განაახლებს ჩემი კოდი, იგი აღდგება და ვუთხრა
თვალსაზრისით, რომ შესვენების წერტილი.
ისევ და ისევ, მე მოხვდა რეზიუმე.
არ ჩანს როგორც არაფერი ხდება.
მაგრამ ეს იმიტომ, რომ ჩემი კოდი ელოდება შეყვანის.
მე შევა ნომერი 5, Enter, და ახლა შემდეგი შესვენების წერტილი იქნება მოხვდა.
>> ახლა, ამ შემთხვევაში, ეს არის ხაზი კოდი
რომ, სანამ ჩვენ ვიცოდით, მოხდა, რომ buggy.
მოდით შევაფასოთ, რა ხდება, ამ კონკრეტულ მომენტში.
როდესაც ხაზი გაუსვა ხაზი, რომ ეს ხაზი ჯერ კიდევ არ არის შესრულებული.
ასე რომ, ამ შემთხვევაში, ჩვენ ვხედავთ, რომ მე მაქვს ნომერი, რომელიც
მე მაქვს მთელი მოუწოდა num რომ აქვს მნიშვნელობა 5.
და მე ვაპირებ ასრულებენ ზოგიერთი მათემატიკის, რომ ნომერი.
>> თუ მე ნაბიჯი მეტი რომ, ჩვენ შეგვიძლია შეამჩნია, რომ მნიშვნელობა num
შეიცვალა შესაბამისად არითმეტიკული რომ ჩვენ რეალურად გაკეთდეს.
და ახლა, რომ ჩვენ ვართ შიგნით ამ loop
ან ახლა, რომ ამისთვის loop თავად არის ასახული,
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ახალი ცვლადში მე რომ
იქნება გამოყენებული, რომ მარყუჟი.
>> ახლა მახსოვს ადრე, რომ მე აღინიშნა, რომ ზოგჯერ თქვენ
აპირებს, რომ ზოგიერთი სახის გიჟები ნომრები, როგორც ნაგულისხმები ადრე, რომ ნომერი
ან, რომ ცვლადი რეალურად ინიციალიზაცია.
ჩვენ ვხედავთ, რომ ზუსტად აქ ამ ცვლადის
მოუწოდა i, რომელსაც არა ჯერ ინიციალიზაცია
დროს ხაზს უსვამს.
მაგრამ ჩვენ ვხედავთ, რომ მას აქვს გარკვეული რაოდენობის , რომ ჩვენ რეალურად არ ელის.
>> არაუშავს.
არ ინერვიულოთ შესახებ იმიტომ, რომ ჩვენ არ რეალურად
ინიციალიზაცია, რომ ნომერი, სანამ მე გადადგას ამ ონლაინ და ღირებულება
i უკვე ინიციალიზაცია ღირებულება 1.
ასე, რომ ნახოთ, რომ სინამდვილეში იმ შემთხვევაში, მოდით გადადგას მეტი.
ჩვენ ახლა ვხედავთ, რომ ხაზი უკვე შესრულებული.
და ჩვენ ახლა ხაზს უსვამს ამ printf ხაზი.
>> ჩვენ ახლა ვხედავთ, თუ ჩვენი ღირებულებები მე და 3 შეიცვალა დროთა განმავლობაში.
ეს არის ძალიან სასარგებლო, ფაქტობრივად, არის გადადგას მეტი ხაზები არაერთხელ.
და ნახავთ, თუ რეალურად რა ხდება შიგნით თქვენი ამისთვის loop
და რა მოხდება, ცვლადის შიგნით რომ მარყუჟი
იმის გამო, რომ პროგრამის შესრულების ხდება ერთი ნაბიჯი იმ დროს.
>> ახლა ამ ეტაპზე, მე გადააბიჯეს მხოლოდ საკმარისი
რომ მე ახლა ვარ ბოლოს ჩემი პროგრამა.
თუ მე ნაბიჯი მეტი რომ, ეს იქნება კი აღარ შესრულების
როგორც ვნახეთ წარსულში.
მიადევნე თვალი გადატვირთეთ ეს, კიდევ ერთხელ, ასე რომ, რომ მე შემიძლია აღვნიშნო რაღაც out,
როგორც.
>> ამ შემთხვევაში, ეს არის ახლა მთხოვდნენ, კიდევ ერთხელ,
რიგი, რომელიც მე, კიდევ ერთხელ, შევა.
მაგრამ ამ დროს, მე ვაპირებ შევა დიდი რაოდენობის ისე, რომ ამისთვის loop
იქნება iterate ჯერ.
ამ შემთხვევაში, მე ვაპირებ შესვლის ღირებულება 11.
>> ახლა ისევ იმიტომ, რომ მე მინდა მითითებული შესვენების წერტილი line 15,
ის აპირებს, რომ ხაზი გავუსვა, რომ ხაზი.
ჩვენ ვხედავთ, რომ ჩვენი ნომერი 11 არის სწორად
წარმოდგენილია ჩვენი ადგილობრივი ცვლადები.
Stepping გამო, რომ, ჩვენ შეგვიძლია ახლა უყურეთ რა მოსდის ჩვენს ღირებულება i
როგორც ვაგრძელებთ შიგნით ამ loop.
იგი იღებს incremented ყოველ ჯერზე ჩვენ მიღწევა ზევით რომ მარყუჟი.
>> ახლა ერთი რამ, რომ შეიძლება სასარგებლო იყოს უნდა გავაკეთოთ დროს აღსრულების
ამ პროგრამის ჩემთვის რეალურად შეცვალოთ ცვლადის midstream ვხედავ
რა მოხდება, რომ ჩემი პროგრამა.
ამ შემთხვევაში, მე შემიძლია რეალურად ორჯერ დააწკაპუნეთ მნიშვნელობა.
გაითვალისწინეთ, რომ ეს ხდება ველში.
>> ახლა შემიძლია შემოსვლა სხვადასხვა ვაფასებთ საერთოდ
როგორ ჩემი პროგრამა ისე იქცევა როდესაც მე შეიცვალა, რომ ცვლადი.
ახლა ამ შემთხვევაში, ცვლადი ახლა მე შეიცავს ღირებულების 10.
მაგრამ პროგრამა ჯერ კიდევ ათვისება აღსრულება.
როდესაც მე ნაბიჯ მეტი, მე ვხედავ, რომ მნიშვნელობა i, რომელიც მე შევიდა, როგორც 10,
არ არის უფრო დიდი, ვიდრე ღირებულება num, რომელიც მაშინვე იწვევს for loop
შეჩერება შესრულებაში.
>> ახლა, რომ ეს არ არის მხოლოდ მიზეზი, თუ რატომ გვინდა
შესაცვლელი ცვლადი ადგილზე.
თქვენ შესაძლოა, რეალურად სურს ცდილობენ ცვლილებები მას ასე
რომ შეგიძლიათ გაგრძელდება აღსრულების loop
ან ისე, რომ თქვენ შეგიძლიათ შეცვალოთ გარკვეული მნიშვნელობა, სანამ ეს
აღწევს ზოგიერთი კონკრეტული ნაკრები არითმეტიკული , რომ თქვენ უნდა შეასრულოს.
>> ახლა, რომ ჩვენ რეალურად შეცვლის ღირებულება მე როგორც პროგრამა შესრულებაში,
ეს გამოწვეულია იმ მარყუჟის დატოვა ნაადრევად იმიტომ, რომ უეცრად, i
მოხდა, რომ უფრო მეტი, ვიდრე ღირებულება საქართველოს num, რაც იმას ნიშნავს, რომ რომ მარყუჟი
აღარ არის საჭირო შესრულდება.
გარდა ამისა, მოხდა ისე, რომ საქმე, რომელიც ჩვენ შევცვალეთ ღირებულება i
მაშინ, როცა ხაზი 17 ხაზგასმით აღინიშნა, რომელიც იყო მომენტში
რომ ამისთვის loop შესრულების იყო რეალურად მიმდინარეობს შეაფასა.
>> თუ მე შეიცვალა ღირებულება i სხვადასხვა ხაზი, ვთქვათ, 19,
ჩვენ ვნახეთ სხვადასხვა ქცევა, რადგან ხაზი 19
შესრულებული ადრე ციკლი მდგომარეობა reevaluated.
ახლა ამ ეტაპზე, მე, კიდევ ერთხელ, ბოლოს ეს პროგრამა.
და შემიძლია დაუშვებს, რომ გაგრძელება საშუალებას ჩემი პროგრამა დატოვა ბუნებრივია.
მაგრამ არსებობს რამდენიმე რამ, რომელიც მნიშვნელოვანია წართმევას
ამ კონკრეტულ დისკუსია.
თქვენ უნდა შეაფასოს საკუთარი ვარაუდები
იმაზე, თუ როგორ კოდი უნდა იქცევა.
თუ თქვენ ფიქრობთ, რომ ზოგიერთი ცალი კოდი თქვენ იცით ხდება მუშაობა,
რომ შეიძლება იყოს წითელი დროშა წასვლა უკან და შეაფასოს, და რა თქმა უნდა
რომ თქვენი ვარაუდი როგორ, რომ კოდი ფუნქციონირებს
სინამდვილეში, თუ როგორ არის გამოიხატება თქვენი კოდის.
>> მაგრამ კიდევ უფრო წერტილი იყო, როდესაც ჩვენ გამოყენებით debugger,
თქვენ შეგიძლიათ განათავსოთ breakpoints ზე სხვადასხვა ხაზების კოდი,
რაც გამოიწვევს debugger რომ პაუზის შესრულების დროს თითოეული იმ ხაზები
ასე რომ თქვენ შეგიძლიათ შეაფასოთ მეხსიერების ან თუნდაც შეცვალოს ეს ადგილი.
ისევ და ისევ, გახსოვდეთ, რომ თქვენ შეუძლია შექმნათ მრავალი breakpoints ისე, რომ თქვენ
ასევე შეგიძლიათ განაახლონ აღსრულება, გაფართოებული მეტი დიდი ნაწილი კოდი,
და ეს თქვენ ავტომატურად პაუზის მომდევნო შესვენების წერტილი.
>> არსებობს ფაქტიურად უფრო მოწინავე თვისებები debugger, ისევე.
მაგრამ ჩვენ უნდა მიმართოს თქვენ ზოგიერთი მომდევნო ვიდეოები
იმისათვის, რომ რეალურად აჯავრებენ გარდა, თუ როგორ გამოიყენოს იმ კონკრეტული ფუნქციები.
ახლა, მადლობა ძალიან ბევრი უყურებს.
და წარმატებას debugging.