[Powered by Google Translate] GDB, GNU პროექტის Debugger, არის ძლიერი გამართვის ინსტრუმენტი C,
ერთად ბევრი სხვა ენებზე.
ეს გაძლევთ საშუალებას poke გარშემო შიგნით თქვენი C პროგრამებს ხოლო ისინი შესრულებაში,
და ეს ასევე გაძლევთ საშუალებას რომ ნახოთ ზუსტად რა ხდება
როდესაც თქვენი პროგრამის დამსხვრევაზე.
ეს საკმაოდ nifty, არა?
GDB არის თავისუფალი პროგრამა, და ის მუშაობს მრავალი პოპულარული UNIX და
Windows დაფუძნებული ოპერაციული სისტემა, ამიტომ ძალიან გავრცელებული ინსტრუმენტი.
>> თქვენ უნდა ვისწავლოთ მიყვარს.
GDB დადებითი აქვს ბევრად უფრო ადვილი დრო თვალთვალის ქვემოთ bugs
ვიდრე მათ, ვისაც muddle გამოყენებით შთაბეჭდილებები
და უსასრულო რაოდენობით ამონაწერი განცხადებებს.
GDB არის command-line ინსტრუმენტი, რაც იმას ნიშნავს, თქვენ შეგიძლიათ ურთიერთქმედება ის ტერმინალში
გაცემის ბრძანებებს მეშვეობით კლავიატურის ნაცვლად დაწკაპვით ღილაკები თქვენი მაუსი.
>> დაიწყოს up GDB, თქვენ სიტყვასიტყვით უბრალოდ ტიპის GDB ბრძანებათა ზოლში და დააჭიროთ.
თქვენ ნახავთ ზოგიერთ ხაზები ამობეჭდილი რომ ეკრანზე
გამოიჩინა ვერსია GDB რომ თქვენ გაშვებული,
მისი საავტორო უფლებების შესახებ, და ბოლოს დაინახავთ GDB ხაზში: (GDB).
ეს საშუალებას თქვენ იცით, რომ GDB მზად არის ბრძანებები.
ამ ეტაპზე, ყველაზე მთავარია, თუ როგორ უნდა გააკეთოთ დატოვა.
საბედნიეროდ, ეს საკმაოდ მარტივია.
დატოვა ბრძანება აკეთებს უბრალოდ რომ.
როგორც მალსახმობი, შეგიძლიათ უბრალოდ გამოიყენოთ Q ძალიან.
როგორც fun როგორც ჩატვირთვისას up GDB და შემდეგ სწრაფად წასვლის არის,
მოდით ახლა ვისაუბროთ გამოყენებით GDB რათა დაეხმაროს გამართვის პროგრამა.
>> უნდა დაიწყოს, მაქვს პროგრამა აქ factorial.c
რომ იღებს int და ცდილობს გამოთვლაც მისი factorial.
იმ შემთხვევაში თუ თქვენ არ მინახავს factorials ადრე ან არ მახსოვს მათ,
Factorial რაოდენობის n ტოლია პროდუქტი N - (n - 1), (N - 2) და ასე შემდეგ -
სანამ არ მოხვდა 1.
ამიტომ, factorial 3 არის 3 * 2 * 1, ან 6,
და factorial სულ 4 არის 4 * 3 * 2 * 1 ან 24.
Factorial ნულოვანი არის უცნაური შემთხვევაში, ეს 1,
და factorials უარყოფითი რიცხვებით არ არის გათვალისწინებული.
ყოველ შემთხვევაში, რაღაც ჩემს factorial პროგრამის ხმაურიანი.
როდესაც მე აწარმოებს, ეს ბეჭდავს out უცნაური ციფრები რომ აქვს საერთო არაფერი factorials.
>> ასე რომ, ჩვენ შეგვიძლია გამოვიყენოთ GDB რათა დაეხმაროს გაერკვნენ რა ხდება.
GDB მუშაობს შესრულებადი ფაილი,
რომლებიც ორობითი ფაილი მიერ წარმოებული compilation პროცესში.
ანუ, ჩვენ შეგვიძლია არ აწარმოებს GDB ჩვენს. გ ან. თ კოდის ფაილი მოსწონს factorial.c.
ჩვენ გვინდა, რომ გაუშვით მხოლოდ factorial ნაცვლად.
თუ პროგრამა საჭირო ნებისმიერი ბრძანება ხაზი არგუმენტები,
ეს არის სადაც ჩვენ მინდა დავაკონკრეტებ ამ საკითხებს.
ამ შემთხვევაში, factorial არ საჭიროებს რაიმე ბრძანების ხაზი არგუმენტები,
ამიტომ ჩვენ უნდა აკრიფოთ პერსპექტივაში ან R მოკლე.
>> ეს დაიწყება factorial პროგრამა გაშვებული.
როდესაც პროგრამა აჩერებს გაშვებული, მე კიდევ ჩემი GDB შეეკითხება უკან.
Okay, მოდით ვცდილობთ იგივე ერთხელ, factorial of 4.
ყველა უფლება, ჩვენ ვხედავთ, რომ ჩვენ ვიღებთ მსგავსი უსარგებლო აქ GDB.
არის, რომ პროგრამა დასრულდა,
ჩვენ არ შეგვიძლია წავიდეთ და დაშვების მისი ნებისმიერი სახელმწიფო,
ამიტომ ჩვენ უნდა დავიწყოთ ეს გაშვებული კიდევ ვხედავთ, რა ხდება.
თუმცა, ჩვენ გვჭირდება გზა შეჩერება ხოლო ის შუა მისი პერსპექტივაში.
>> ამისათვის, ჩვენ ვიყენებთ რასაც breakpoint.
Breakpoints გითხრათ GDB პაუზის პროგრამის კონკრეტული ფუნქციის ან კოდის ხაზი
ასე, რომ ჩვენ შეგვიძლია შეამოწმოს სახელმწიფო პროგრამის,
ღირებულებები ცვლადები, სახელმწიფო მეხსიერების და ასეთი, იმ ეტაპზე.
მას შემდეგ, რაც მე არ ვიცი, რა ვაპირებთ არასწორი,
>> მინდა დავიწყოთ გამართვის უფლება თავიდანვე,
უფლება, როდესაც მთავარ იწყება.
ჩვენ მითითებული breakpoint დასაწყისში ძირითად გამოყენებით შესვენების ბრძანება.
ჩვენ ასევე შეგიძლიათ ბ abbreviate შესვენების.
ახლა დავიწყოთ პროგრამა გაშვებული ერთხელ.
აქ ჩვენ წლის დასაწყისში ძირითად, ისევე GDB გვეუბნება.
ხაზი კოდი, რომ დაახლოებით შეასრულოს, მაგრამ ჯერჯერობით არ
არის printf ხაზი.
ჩვენ შეგვიძლია ვუთხრათ GDB შეასრულოს ამ ხაზი კოდი და გადასვლა შემდეგ ხაზზე
მომდევნო ან N ბრძანება.
>> ყველა უფლება, ახლა GDB გვეუბნება, რომ ჩვენ შესახებ GetInt ხაზი.
მე ვიცი, რომ როგორც ჩანს, printf ხაზი არ აწარმოებს
რადგან ჩვენ ვერ ვხედავთ "შეიყვანეთ მთელი რიცხვი დადებითი" ბეჭდვითი out ეკრანზე,
მაგრამ რეალურად აწარმოებს.
რა ჩვენ ვხედავთ არის ოპერაციული სისტემის ჩახშობა წერილობით არაფერი ეკრანზე
სანამ ის სრულიად უნდა, რომელიც რატომ გამართვის ერთად printouts
ზოგჯერ ჩანს არასანდო.
ყოველ შემთხვევაში, მოდით ისევ წასვლა შემდეგი ხაზი კოდი და შევა int.
ერთხელ, მოდით ტიპის 4.
ასე რომ, ეს გამოიყურება უცნაური. ჩვენ on line 12 მიხედვით GDB,
მაგრამ მეორე ხაზზე რომ უნდა შესრულდეს მხოლოდ Curly გაუწიოს.
>> რომ მხოლოდ იმას ნიშნავს, ჩვენ დასასრულს მარყუჟის, ჩვენი გავაკეთოთ ხოლო loop ფაქტობრივად,
და GDB ეუბნება, რომ შეწყვეტის მდგომარეობა, კერძოდ არა ნაკლები ნულოვანი,
განახორციელებს შემდეგი.
თუ ეს ოდესმე იღებს პატარა დამაბნეველი,
ჩვენ შეგვიძლია დახევის up კოდის in GDB ის სია ან ლ ბრძანება.
ეს ბეჭდავს out კოდის
რომ ორიენტირებული გარშემო ხაზი, რომ ჩვენ ამჟამად.
თუ ჩვენ ტიპების სიას ან ლ ისევ, ვნახავთ შემდეგი კომპლექტი ხაზები ამობეჭდოთ.
ჩვენ შეგვიძლია ამის გაკეთება, სანამ ჩვენ მოხვდა ფაილის ბოლოში.
>> დავუბრუნდეთ სად ვიყავით, ჩვენ შეგვიძლია მიაწოდოს სიაში ხაზის ნომერი,
ამ შემთხვევაში, ხაზი 12.
ყოველ შემთხვევაში, მოდით გადაადგილება.
ახლა ჩვენ შესახებ 4 loop.
მოდით დავრწმუნდეთ, რომ ჩვენი num ცვლადი შეიცავს 4.
ჩვენ ამას ვაკეთებთ, ერთად ბეჭდური, ან P, ბრძანება.
ასე რომ, GDB გვეუბნება, რომ num მართლაც შენახვის 4, როგორც ჩვენ გვგონია.
$ 1 რომ GDB ბეჭდავს out არის სპეციალური GDB ცვლადი
რომ არის მითითებული შესანახად ნომერი 4 ასევე.
შეგიძლიათ იგნორირება ამ დროისთვის, მაგრამ ეს GDB ცვლადები მოდის სუპერ მოსახერხებელი
უფრო მოწინავე შემთხვევები, როდესაც გინდათ გავიხსენოთ, თუ როგორი თქვენ გაკეთდეს წარსულში.
ყოველ შემთხვევაში, მოძრავი ერთად მომავალი, ჩვენ ვხედავთ, რომ ჩვენ დავიწყოთ მოძრავი მეშვეობით ამისთვის loop.
მოდით შენარჩუნება გადის აქ N ნელ bit.
იმის ნაცვლად აკრეფით N ყოველ ჯერზე, ასევე შეგიძლიათ მხოლოდ დააჭიროთ.
როდესაც თქვენ დააჭიროთ გარეშე აკრეფით არაფერი, უბრალოდ GDB იმეორებს წინა ბრძანება.
ახლა ჩვენ მოხვდა printf ზარი.
როგორც ჩანს ჩვენ მართლაც გაიარა ჩვენი ამისთვის მარყუჟის 4 ჯერ,
რაც ჩვენ გვინდა გავაკეთოთ იმისათვის, რომ გავამრავლოთ მიერ 1, 2, 3, და 4.
>> ყველაფერი თითქოს ეს მუშაობს
გარდა, როდესაც ჩვენ მოხვდა შემდეგი ერთხელ მივიღებთ ამ უზარმაზარი რაოდენობის ნაცვლად 24.
თუ ჩვენ ამობეჭდოთ ღირებულება factorial გამოყენებით P,
ჩვენ ვხედავთ, რომ factorial აქვს ამ მასიური ნომერი.
რაღაც ის აუცილებლად აპირებს არასწორია.
ამ ეტაპზე, თუმცა, ჩვენ თითქმის დასასრულს პროგრამა,
და ეს ძალიან გვიან დაფიქსირება არაფერს.
>> თუმცა, ჩვენ შეგვიძლია გადატვირთეთ პროგრამა აკრეფით R ერთხელ და შემდეგ Y დავადასტურო.
ახლა ჩვენ უკან ჩვენი breakpoint დასაწყისში ძირითადი.
ჩვენ ვიცით, რომ ყველაფერი, როგორც ჩანს, ჯარიმა კითხულობს in n.
ამიტომ ჩვენ შეგვიძლია ხტომა დააჩქაროს n.
გარდა ამისა, ჩვენ შეგვიძლია მითითებული ახალი breakpoint შემდეგ გააკეთებს ხოლო loop
და ხტომა იქ. მოდით, რომ.
როგორც ჩანს, ხაზი 14 მოდის მხოლოდ მას შემდეგ loop.
მოდით მითითებული breakpoint არსებობს.
კარგია პრაქტიკა დაზუსტება ფაილის სახელი ამ breakpoint ბრძანება
მას შემდეგ, რაც GDB შეიძლება დაბნეული თუ თქვენ მუშაობის რამოდენიმე ფაილი.
გადაადგილება ადრე ამ breakpoint, ჩვენ ვიყენებთ გაგრძელება ან გ ბრძანება.
>> Okay, აქ ჩვენ ვიმყოფებით იმ loop.
მოდით წავიდეთ 1 ვრცლად line შევიდა ამისთვის მარყუჟის,
და შემდეგ დავიწყებთ ბეჭდვის ცვლადები, რომ ნახოთ რა ხდება.
მოდით დავრწმუნდეთ, რომ მე მართლაც 1, როგორც მოსალოდნელი იყო.
Yup, რომ ყველა კარგი.
რაც შეეხება factorial თუმცა?
Whoa, რომ არ არის კარგი.
გვაქვს დიდი რაოდენობის ნეგატიური აქ.
How'd რომ მოხდეს?
ისე, თუ ჩვენ ვიხსენებთ კოდი,
ჩვენ ვხედავთ, რომ ჩვენ არასოდეს ინიციალიზაცია, ასე რომ ჩვენ უბრალოდ მიიღო ნაგვის იქ.
რომ აუცილებლად გადაყარეთ off ჩვენი გაანგარიშებით.
>> საბედნიეროდ, ჩვენ არ უნდა დატოვონ GDB დაფიქსირება ამ.
ჩვენ შეგვიძლია ინიციალიზაცია მას უფლება აქ და შეასწორეთ იგი კოდი მოგვიანებით გამოყენებით ბეჭდვითი ბრძანება.
ჩვენ ინიციალიზაცია მას 1 წლიდან factorials ნულოვანი და 1 ორივე 1,
და თუ ჩვენ ინიციალიზაცია იგი ნულის, მაშინ ჩვენ გვინდა ყოველთვის დასრულდება მდე ნულოვანი როგორც ჩვენი შედეგი.
შეგიძლიათ დააყენოთ ნებისმიერი ცვლადი ამ გზით, რომელიც სუპერ მოსახერხებელი.
ახლა, მოდით, გავაგრძელოთ ჩვენი პროგრამა.
მოდით დარწმუნდით ყველაფერი, სადაც ეს უნდა იყოს.
ცილინდრების უნდა იყოს 4, მე უნდა იყოს 1 და factorial უნდა იყოს 1 ძალიან.
ჩვენ შეგვიძლია Shortcut ამ პროცესში და ბეჭდვა ყველა ჩვენი ადგილობრივი ცვლადები
ერთად Super-გამოსადეგი ბრძანება ინფორმაცია ადგილობრივები,
რომელიც ბეჭდავს ყველა ჩვენი in-ფარგლებს ადგილობრივი ცვლადები.
ყოველ შემთხვევაში, როგორც ჩანს ყველაფერი კარგია წავიდეთ.
>> მოდით სხვა GO-გარშემო მარყუჟის მხოლოდ დარწმუნდით.
Okay, ყველაფერი გამოიყურება დიდი.
ახლა ჩვენ შეგვიძლია გამოვიყენოთ გაგრძელდება ბრძანება წასვლა ბოლომდე.
Sweet? 4 factorial ამობეჭდილი 24 როგორც მოსალოდნელი იყო.
ახლა ჩვენ შეგვიძლია წავიდეთ დაფიქსირება ამ ჩვენს კოდი.
იმის ნაცვლად, რომ დატოვა გარეთ GDB, ჩვენ შეცვალოთ ტერმინალის tab ამის გაკეთება.
უკან ჩვენი GDB tab, ჩვენ ახლა უნდა recompile ჩვენი გაშვება.
ერთი საუკეთესო რამ შესახებ GDB ის არის, რომ თქვენ არ გჭირდებათ დატოვონ GDB გასაშვებად მიიღოს.
ასე, რომ ჩვენ არ ინახავს hitting წლის breakpoints,
მოდით გამორთოთ მათ, თქვენ მიხვდა ეს, გამორთოთ ბრძანება.
ეს იქნება გამორთოთ ყველა ჩვენი breakpoints.
ახლა შეგვიძლია, გადატვირთეთ პროგრამა r და დარწმუნდით ყველაფერი okay.
როგორც ჩანს, ყველაფერი კარგია წავიდეთ.
Factorial 4 ბეჭდავს out 24, ისევე, როგორც გვეგონა.
GDB არის ერთერთი ყველაზე გამოსადეგი ინსტრუმენტები თქვენ მოხვდით თქვენს ყუთისთვის.
>> არსებობს ტონა რამ რომ თქვენ GDB,
ბევრად უფრო ვიდრე შეგიძლიათ გააკეთოთ მარტივი printouts.
შემდეგი დრო თქვენი პროგრამა არ აკეთებს რა გსურთ,
ვცდილობთ გაშვებული GDB გაერკვნენ რა ხდება შიგნით.
ერთად ცოტა პრაქტიკა, თქვენ გექნებათ საბურღი ქვემოთ უფლება ხარვეზის დრო არ.
ჩემი სახელი არის Nate Hardison. ეს არის CS50.