[Powered by Google Translate] GDB, הפרויקט גנה Debugger, הוא כלי רב עצמה לאיתור באגים, C
יחד עם שפות רבות אחרות.
זה מאפשר לך לחטט בתוך תוכניות C שלך בזמן שהם מבצעים,
וזה גם נותן לך את ההזדמנות לראות בדיוק מה קורה
כאשר תכנית הקריסות שלך.
זה די מגניב, נכון?
GDB הוא תוכנה חופשיה, והיא מופעלת ברבי UNIX הפופולרי
מערכות הפעלה מבוססת Windows, כך שזה כלי נפוץ מאוד.
>> אתה צריך ללמוד לאהוב אותו.
יתרונות GDB יש זמן הרבה יותר קל לאתר את הבאגים
מאלו שלהסתדר איכשהו באמצעות ניחושים
וכמויות אינסופיות הצהרות תדפיסים.
GDB הוא כלי שורת פקודה, מה שאומר שאתה יכול לתקשר איתו במסוף
הנפקה באמצעות פקודות המקלדת במקום כפתורי לחיצה עם העכבר.
>> כדי להתחיל את GDB, אתה ממש ממש gdb סוג בשורת הפקודה וקש.
אתה תראה כמה שורות המודפסות מחוץ למסך
מראה לך את הגרסה של GDB שאתה מפעיל,
המידע על זכויות היוצרים שלו, ובסופו של דבר תראה GDB פקודה: (gdb).
זה מאפשר לך לדעת שGDB מוכן לפקודות.
בנקודה זו, הדבר החשוב ביותר שיודע איך לעשות אותו להתפטר.
למרבה המזל, זה די פשוט.
הפקודה להפסיק עושה בדיוק את זה.
כקיצור דרך, אתה יכול פשוט להשתמש q מדי.
כיף כמו באתחול GDB ומייד עזיבה הוא,
עכשיו בואו לדבר על שימוש GDB לעזור לדבג תכנית.
>> כדי להתחיל, יש לי תכנית כאן בfactorial.c
שמקבל int ומנסה לחשבו עצרת.
במקרה שלא ראו את factorials לפני או לא זוכר אותם,
העצרת של מספר n שווה למכפלה של n - (n - 1), (n - 2), וכן הלאה -
עד שתגיע 1.
לכן, העצרת של 3 היא 3 * 2 * 1, או 6,
ואת העצרת של 4 היא 4 * 3 * 2 * 1, או 24.
העצרת של אפס היא מקרה מוזר, זה 1,
וfactorials של מספרים שלמים שלילי אינו מוגדר.
בכל אופן, משהו על התכנית שלי הוא עצרת פאנקי.
כאשר אני מפעיל אותו, זה מדפיס את מספרים מוזרים שאין לי מה לעשות עם factorials.
>> לכן, אנו יכולים להשתמש GDB כדי לעזור להבין מה קורה.
GDB פועל על קבצי הפעלה,
אשר הם קבצים בינאריים המיוצרים על ידי תהליך ההידור.
כלומר, אנחנו לא יכולים לרוץ על GDB. C שלנו או. קבצי קוד מקור h כמו factorial.c.
אנחנו רוצים להפעיל אותו בעצרת בדיוק במקום.
אם התכנית נדרשת כל טיעוני שורת פקודה,
זה המקום שבו לציין אותם.
במקרה זה, עצרת אינה דורשת כל טיעוני שורת פקודה,
אז אנחנו פשוט הקלידו ריצה או r לקצר.
>> זה יתחיל בהפעלת תכנית העצרת.
כאשר התכנית מפסיקה לרוץ, אני אביא GDB לבקש בחזרה.
אוקיי, בואו ננסה את אותו הדבר שוב, עצרת של 4.
בסדר, אנחנו רואים שאנחנו מקבלים את אותו סוג של זבל כאן בGDB.
עכשיו, אחרי שהתכנית הסתיימה,
אנחנו לא יכולים להיכנס ולגשת לכל במדינתו,
ולכן אנחנו צריכים להתחיל אותו לפעול שוב לפני שנוכל לראות מה קורה.
עם זאת, אנחנו צריכים דרך לעצור את זה בזמן שהוא באמצע הטווח שלה.
>> כדי לעשות זאת, אנחנו משתמשים במה שנקרא נקודת עצירה.
נקודתי עצירה לספר GDB כדי להשהות את התכנית בפונקציה מסוימת או קו קוד מקור
כדי שנוכל לבחון את מצב התכנית,
הערכים של משתנים, המצב של זיכרון וכך, בשלב זה.
מכיוון שאני לא באמת יודע לאן הדברים הולכים בסדר,
>> אני רק רוצה להתחיל באגים ממש בהתחלה מאוד,
נכון כאשר ראשי מתחיל.
אנו נקבע את נקודת עצירה בתחילה עיקרית באמצעות פקודת ההפסקה.
אנחנו יכולים גם להשתמש ב לקצר הפסקה.
עכשיו בואו נתחיל את התכנית לפעול שוב.
כאן אנו נמצאים בתחילתו של ראשי, בדיוק כמו GDB מספר לנו.
שורת הקוד שעומדת לבצע, אך יש עדיין לא
הוא קו printf.
אנחנו יכולים לספר לי GDB לביצוע שורת קוד הזאת וללכת לשורה הבאה
עם הפקודה הבאה או n.
>> בסדר, עכשיו GDB אומר לנו שאנחנו בקו GetInt.
אני יודע שזה נראה כמו שורת printf לא ברחה
מכיוון שאנו לא רואים "זן חיובי שלמה" הדפסה על המסך,
אבל זה ממש לא לרוץ.
מה שאנו רואים הוא מערכת ההפעלה לדכא משהו כתיבה על המסך
עד שאין ברירה אחרת, שסיבת ניפוי באגים עם תדפיסים
יכול לפעמים נראה לא אמין.
בכל מקרה, בואו נלך שוב לשורה הבאה של קוד ולהיכנס בint.
שוב, בואו סוג 4.
אז זה נראה מוזר. אנחנו בקו 12 על פי GDB,
אבל השורה הבאה שעומדות לבצע היא רק סד מתולתל.
>> זה רק אומר שאנחנו בסופו של לולאה, לעשות בזמן לולאה למעשה,
וGDB אומר לנו שמצב הסיום, כלומר לא פחות מאפס,
יבצע הבא.
אם זה אי פעם נעשה קצת מבלבל,
אנחנו יכולים למשוך את קוד המקור בGDB עם הרשימה או פקודת הליטר.
זו מדפיסה את קוד המקור
זה מרוכז סביב הקו שאנחנו נמצאים כעת.
אם רשימה או הקלידו שוב אני, אנחנו נראה את הקבוצה הבאה של קווים להדפיס.
אנחנו יכולים לעשות את זה עד שנגיע לסוף הקובץ.
>> כדי לחזור למקום שבו היינו, אנו יכולים לספק רשימה עם מספר קו,
במקרה זה, קו 12.
בכל אופן, בואו נמשיך הלאה.
עכשיו אנחנו על 4 לולאה.
בואו נוודא שמשתנת num מכילה 4.
אנו עושים זאת עם הדפסה, או p, פקודה.
אז, GDB אומר לנו שאכן num אחסון 4, כפי שציפינו.
1 $ GDB שמדפיס הוא משתנה GDB מיוחד
שעכשיו מוגדר לאחסון 4 המספר גם כן.
אתה יכול להתעלם מזה לעת עתה, אבל משתני GDB אלה באים בסופר שימושיים
במקרים מתקדמים יותר כאשר ברצונך להיזכר במה שעשית בעבר.
בכל אופן, תעברו לגור איתי הבא, אנחנו רואים שאנחנו מתחילים לנוע דרך ללולאה.
בואו נשמור עובר כאן עם קצת n לאט.
במקום להקליד n בכל פעם, אתה יכול גם פשוט הקש על Enter.
כאשר אתה מקיש Enter ללא הקלדת כלום, פשוט חוזר על GDB הפקודה הקודמת.
אז עכשיו שפגענו שיחת printf.
זה נראה כמו מה שעברנו אכן דרכנו ללולאה 4 פעמים,
וזה מה שאנחנו רוצים לעשות על מנת להכפיל 1, 2, 3, ו 4.
>> הכל נראה כמו שזה עובד,
למעט כאשר אנחנו פוגעים הבאים שוב אנחנו מקבלים מספר עצום זה במקום 24.
אם להדפיס את הערך של p באמצעות עצרת,
אנו רואים שעצרת אינה צריך מספר עצום זה בזה.
משהו בהחלט לא תקין.
בשלב זה, אם כי, אנחנו כמעט בסוף התכנית,
וזה כבר מאוחר מדי לתקן כל דבר.
>> עם זאת, אנו יכולים להפעיל מחדש את התכנית על ידי הקלדת r שוב ואז Y לאישור.
עכשיו אנחנו שוב בנקודת העצירה שלנו בתחילה ראשית.
אנחנו יודעים שהכל נראה בסדר גמור עם הקריאה בn.
כדי שנוכל לקפוץ קדימה עם n.
לחלופין, אנו יכולים להגדיר נקודת עצירה חדשה לאחר לעשות בזמן לולאה
ולקפוץ לשם. בואו לעשות את זה.
נראה כמו קו 14 מגיע רק אחרי הלולאה.
בואו נקבענו נקודת עצירה שם.
זה תרגול טוב כדי לציין את שם הקובץ בפקודת עצירה זו
מאז GDB יכול להתבלבל אם אתה עובד עם קבצים מרובים.
כדי להתקדם לנקודת עצירה זו, אנו נשתמש להמשיך או פקודת ג.
>> אוקיי, הנה אנחנו בלולאה.
בואו נלך לקו 1 יותר ללולאה,
ואז תתחילו משתני הדפסה כדי לראות מה קורה.
בואו נוודא שהוא אכן 1, כצפוי.
כן, זה כל מה שטוב.
מה לגבי עצרת ש?
וואו, זה לא טוב.
יש לנו מספר שלילי גדול כאן.
איך זה קרה?
ובכן, אם אנחנו מסתכלים אחורה בקוד,
אנו רואים שמעולם לא אותחלנו את זה, אז רק שיש לנו זבל לשם.
זה בהחלט יהיה לזרוק את החישוב שלנו.
>> למרבה המזל, אין לנו לעזוב GDB כדי לתקן את זה.
אנחנו יכולים לאתחל אותו ממש כאן ולתקן את זה בקוד מאוחר יותר באמצעות פקודת ההדפסה.
אנחנו לאתחל אותו עד 1 מאז factorials של אפס ושניהם 1 1,
ואם אנחנו לאתחל אותו לאפס, אז הייתי תמיד בסופו של דבר עם אפס כתוצאה שלנו.
באפשרותך להגדיר כל משתנית בדרך זו, שהוא סופר שימושי.
עכשיו, בואו נמשיך בתכנית שלנו.
בואו נוודא שכל מה ששם זה אמור להיות.
מס צריך להיות 4, אני צריך להיות 1, והעצרת אמורה להיות 1 מדי.
אנחנו יכולים לקצר את התהליך הזה ולהדפיס את כל המשתנים המקומיים שלנו
עם המקומיים מידע פיקוד סופר המועילים,
אשר מדפיס את כל המשתנים המקומיים בהיקף שלנו.
בכל אופן, זה נראה כאילו הכול טוב ללכת.
>> בואו נעשה עוד ללכת סביב למעגל רק כדי לוודא.
אוקיי, הכל נראה נהדר.
עכשיו אנחנו יכולים להשתמש בפקודה להמשיך ללכת עד הסוף.
מתוק! 4 עצרת הדפיס 24, כצפוי.
עכשיו אנחנו יכולים ללכת לתקן את זה בקוד שלנו.
במקום לפרוש מGDB, תשתמשו כרטיסיית מסוף אחר לעשות את זה.
נחזור לכרטיסיית GDB, עכשיו אנחנו צריכים להדר ההפעלה שלנו.
אחד הדברים הטובים ביותר על GDB הוא שאתה לא צריך לעזוב את GDB לרוץ לעשות.
כך שאנחנו לא לשמור להכות את נקודתי עצירה הישנות,
בואו להשבית אותם עם, נחשת נכון, לבטל פקודה.
הפעולה זו תשבית את כל נקודתי העצירה שלנו.
כעת, אנו יכולים להפעיל מחדש את התכנית עם r ולוודא שהכול בסדר.
נראה כמו כל הדבר טוב ללכת.
עצרת של 4 הדפסים מתוך 24, בדיוק כמו שחשבנו.
GDB הוא האחד הכלים השימושיים ביותר שיש להם בארגז הכלים שלך.
>> יש המון דברים נוספים שאתה יכול לעשות עם GDB,
הרבה יותר ממה שאתה יכול לעשות עם הדפסים פשוטים.
בפעם הבאה שהתכנית שלך לא עושה את מה שאתה רוצה,
נסה להפעיל GDB כדי להבין מה קורה בפנים.
עם קצת תרגול, תוכל לקדוח ישר על הבאג שלך בתוך זמן קצר.
השם שלי הוא נייט Hardison. זה CS50.