[? דן ARMADARAS:?] היי, אני [? דן Armadaras?].
היום, אנחנו הולכים להיות מסתכל על ניפוי.
לא רק שאנחנו הולכים ל מדבר על כמה טכניקות,
אבל גם אנחנו הולכים להסתכל על חלק מהתכונות כלול
בתוך IDE CS50 המאפשר לך באגים בקלות תכנית.
>> רק דוגמא אחת ל משהו שיכול להשתבש
וזה בעצם משהו שכבר ראו בעבר.
במקרה זה, מדובר בתכנית C שמקבל מספר שלם מהמשתמש,
חלק על ידי שתי, ומספק הפלט בחזרה למשתמש.
עכשיו ממה שראינו מוקדם יותר בהרצאות,
אנחנו יודעים שזה יהיה ממש לגרום ל סוגים מסוימים של בעיות החלוקה
כאשר יש לנו מספרים מוזרים.
>> באופן ספציפי, אנחנו פשוט לזרוק שום דבר אחרי הנקודה העשרונית.
עכשיו, אנחנו יודעים שזה קורה להיות המקרה.
ואם אנחנו מפעילים אותו, אנחנו יכולים לאשר החשדות שלנו, ראשון, על ידי העריכה.
ולאחר מכן, על ידי הפעלה ו הזנת מספר אי-זוגי.
>> זה לא חדש.
אבל זה בעצם דוגמא לבאג ש
יכול להתקיים בתוך תכנית גדולה יותר שהופך להיות קשה יותר לאתר.
למרות שאנו יודעים מה הבעיה הוא, עיקרו האמיתי של העניין
אולי מנסה לזהות במיוחד שבו מתרחשת השגיאה,
זיהוי מה בעיה ש הוא, ולאחר מכן לתקן את זה.
אז לספק את זה כדוגמא ממה שעלול להיות משהו
כי אנחנו כבר יודעים, אבל יכולים להיות קבורים בתוך אלמנטים אחרים של הקוד.
>> אז פתיחת מקור אחר זה קובץ קוד כדוגמא,
בעיה חלוקה זו היא עכשיו חלק מתכנית גדולה יותר.
עדיין יכול להיות קצת קצת מאולץ, ואנחנו
אולי תוכל בקלות לזהות אותו, במיוחד
מאז אנחנו רק דנים זה.
אבל אנחנו יכולים להבין שזה בעיה יכולה להתקיים בקנה מידה גדולה יותר.
>> אם אני לקמפל זה ועכשיו להפעיל אותו, להיכנס למספר אי-זוגי,
אנו יכולים לראות כי אנחנו לא מקבלים בדיוק התפוקה שאנחנו יכולים לצפות.
במקרה הספציפי הזה, אפשר לומר שאנחנו
רוצה לספור את כל המספרים מאחד עד כמה מספר ספציפי.
ואנחנו יכולים לראות ש יש מגוון רחב של נושאים
כאן אם אנחנו פלט, פשוט, 0 וכאשר 1 אנו מספקים קלט 5.
>> אז אנחנו כבר יודעים ש יש כאן בעיה.
אבל אנחנו לא יכולים לדעת בדיוק שבו הנושא הזה באמת קיים.
עכשיו אחת הדרכים ש אנחנו יכולים לנסות לתקן את זה
הוא משהו שיש לנו כבר הציג ל.
אנחנו רק יכולים להשתמש בו בקנה מידה גדולה יותר.
>> על קו 14, שיש לנו פונקציה זו printf,
אשר מאפשר לנו להדפיס את המדינה של חלקים שונים של מידע.
וזה משהו שאתה צריך למנף בתוך התכנית שלך
כדי לנסות להבין בדיוק מה קורה בקווים שונים של קוד.
אז גם אם זה לא פלט סופי שאנחנו באמת
רוצה לייצר מ תכנית זו, שעדיין
אולי יש כמה באגים ההצהרות שבו אנחנו
יכול לנסות להבין בדיוק מה קורה בתוך הקוד שלנו.
>> אז במקרה הזה, אני printf עם תג באגים.
במקרה זה, זה הוא רק מחרוזת באגים
כי אני כל כך שהוא הופך להיות לשים-עד מאוד ברור בתפוקה של הקוד שלי
מה זה שאני רוצה להראות.
ופלט כאן המספר שיש לנו מחושבים.
>> במקרה זה, אולי אני רוצה לדעת בדיוק
מה שקורה לפני ו לאחר כמה חישוב ספציפי.
אז אני יכול להשתמש printf לפני ואחרי השורה של קוד.
במקרה זה, אני אפילו יכול לעשות את זה קצת יותר ברור
באומרו באגים לפני ובאגים אחרי כל כך
שאני לא לבלבל עם עצמי מספר שורות שנראות זהה.
>> עכשיו, אם אנחנו הדר מחדש את זה ולרוץ זה, להזין מספר כמו חמש שוב,
אנחנו יכולים לראות שיש לנו עכשיו פלט לפני ואחרי
ומגלים שיש לנו לא נעשה ברור אגף או ברור שיש של המספר
שאנחנו באמת רוצים לעשות.
עכשיו במקרה זה, זה הוא לא ממש ברור פלט.
זה לא באמת תוצאה ברורה ש אנחנו רוצים מתוך תכנית מסוימת זו.
>> וזה שוב הוא,, קצת מאולץ.
אבל, אולי, אחד הדברים ש אנחנו יכולים לעשות אם המפרט אמר
כי אנחנו רוצים לחלק את זה על ידי 2 ולהוסיף 1-- כך במילים אחרות,
אנחנו רוצים לעגל אז up-- אנחנו יכולים לדעת שאנחנו יכולים
לעשות דבר מסוים ש, במקרה זה.
עכשיו כאן אנחנו יודעים שאנחנו יהיו תוכל להוסיף 1 למספר החצוי שלנו.
>> בואו הדר מחדש זה ולאשר שזה
מתנהג בדרך שאנחנו רוצים.
אנחנו יכולים לראות את זה עכשיו לפני ש יש, יש לנו את המספר 5.
לאחר ש, יש לנו את המספר 3, אשר על פי המפרט שלנו,
זה מה שאנחנו רוצים לעשות.
אבל אם אנחנו מסתכל על פלט כאן, אנחנו יכולים
רואה שאולי יש לנו עוד באג לגמרי, שהוא
כי אנחנו מתחילים לסופרנו מ0.
>> עכשיו שוב, זה משהו ש שראינו בעבר
ואנחנו יכולים לתקן די בקלות.
אבל במקרה הזה, אנחנו היה גם היתרון
של שימוש הצהרת printf ישירות בתוך לולאה
לדעת בדיוק היכן השגיאה שמתרחשת.
הצהרות אז printf הן שימושי מאוד לעזור
לך לקבוע היכן, דווקא בקוד המקור שלך,
שגיאה ספציפית מתרחשת.
>> וזה גם חשוב להבין כי, כפי שאנו כותבים קוד,
אולי יש לנו הנחות על המצב של תכנית.
או שאולי יש לנו הנחות על איזה חלק של התכנית
נכון או לא נכון, כאשר למעשה בשלב מאוחר יותר כפי שאנו בונים על תכנית ש
ולהפוך אותה לחלק מ מורכב ותכנית גדולה יותר
כי אנחנו מבינים שחלק מההיבט של שהוא למעשה מרכבה.
>> באמצעות printf באמת יכול לעזור לצמצם ולזהות
האזורים של תכנית שאולי לא להיות מתנהג בדיוק כפי שאנחנו
מצפה, המבוסס על ההנחות שלנו.
אבל יש כלים אחרים זמין, כמו גם,
המאפשר לנו לנסות להבין איפה שגיאה מתרחשת
וגם, באופן ספציפי, מה דברים קורים בתוך התכנית.
>> אז printf באמצעות מאוד שימושי כאשר אנו רוצים
לזהות אזורים ספציפיים של תכנית, כי יש כמה באגים.
אבל זה גם הופך משעמם אחרי כמה זמן.
במקרה זה, מדובר ב תכנית פשוטה יחסית
רק עם אחד או שני משתנים.
וזה הופך להיות קל מאוד עבורנו להדפיס את הערך של משתנים אלו
בהקשר של התכנית הגדולה יותר.
>> אבל אולי יש לנו שונה תכנית שיש משתנים רבים.
וזה לא יכול להיות די כל כך קל לשימוש printf
כדי לנסות להעריך מה שקורה לכל אחד מהמשתנים אלה
כתכנית ביצוע.
יש תכנית שקיימת נקרא תכנית הבאגים.
במקרה זה, אחד שיהיה שימוש הוא הבאגים של גנו, או GDB,
המאפשר לנו לבדוק את פנימי פעולתו של תכנית בצורה הרבה יותר
דרך מפורטת.
>> אנחנו באמת יכולים לבצע GDB משורת הפקודה
כאן פשוט על ידי הקלדת GDB ו הפקודה שאנחנו רוצים לאתר באגים.
במקרה זה, לספור.
עכשיו במקרה זה, אנו יכולים לראות כי זה מביא אותנו לפקודה שאומרת GDB.
ואנחנו באמת יכולים לבצע פקודות לGDB
למעשה להתחיל ביצוע תכנית, לעצור אותה בנקודות מסוימות,
להעריך את המשתנים ו לבדוק את המשתנים ש
קיים במדינת התכנית באותו הרגע,
וכן הלאה וכן הלאה.
הוא מספק הרבה כוח לנו.
>> אבל זה פשוט כל כך קורה שIDE CS50 גם
מספק GUI או משתמש ממשק לGDB ש
מאפשר לנו לעשות את זה ללא צורך ממשק שורת פקודה כלשהי
או בכלל אפילו.
הדרך שאני יכול לגשת ש הוא על ידי שימוש בכפתור באגים
בחלקו העליון של IDE CS50.
עכשיו בעבר, מה שיש לנו ראה הוא שאנחנו משתמשים בפקודה
קו לקמפל ולאחר מכן להפעיל תכנית.
>> כפתור באגים עושה שני צעדים אלה.
אבל זה יהיה גם להעלות את כרטיסיית הבאגים על ימין הקיצוני
המאפשר לנו לבדוק מגוון נכסים של התכנית
כפי שהוא מבצע.
אם אני לוחץ על באגים, בזה מקרה, זה יביא את
כרטיסייה חדשה בקונסולה חלון בתחתית מאוד.
>> ואתה יכול לראות שיש לו בכרטיסייה זו קצת מידע בחלקו העליון.
ואנחנו יכולים במידה רבה להתעלם מכך.
אבל אחד הדברים כי אנחנו רוצים לב
הוא שזה פלטי אותו הדבר שאנחנו
היית מקבל אם ננסה לרוץ לעשות ב תכנית C בחלון המסוף.
>> כאן, אנו יכולים לראות שזה פועל צלצול, ויש לה מגוון רחב של דגלים,
והוא קומפילציה קובץ count.c, שהיה הכרטיסייה שנבחרה בזמן
שאני מכה באגים.
אז זה מאוד שימושי משום ש כיום באמצעות כפתור באגים זה,
אנחנו יכולים בו זמנית לקמפל ולאחר מכן לבצע את התכנית שאנחנו באמת
רוצה לרוץ.
>> אחד הדגלים שהם חשוב, במקרה זה,
למעשה אנחנו כבר משתמשים למשך הזמן הארוך ביותר
אבל גם רק עשיתי קצת יד מנופף [לא ברור], ש
זה אחד ממש כאן.
בצלצול, זה אומר -ggdb3.
במקרה זה, מה שאנחנו אומר לי צלצול, מהדר שלנו,
הוא שאנחנו רוצים לקמפל את התכנית שלנו.
אלא גם לספק את מה שהם מידע סמל שנקרא
כך שיש מהדר למעשה גישה להרבה מידע הבסיסי
בתוך התכנית.
>> באופן ספציפי יותר, המספר פונקציות שיש לי,
השמות של פונקציות אלה, המשתנים, הסוגים
שמשתנים אלו, ועוד מגוון דברים אחרים שיעזרו הבאגים
לבצע את פעולתה.
עכשיו יש משהו אחר זה חשוב להזכיר
כאשר אנו דנים ריצה תכנית בדרך זו.
>> שימו לב שיש לו למעשה הביא את כרטיסייה חדשה בקונסולה שלנו
בחלק התחתון.
אנחנו כבר לא צריכים אינטראקציה ישירות עם חלון המסוף.
אבל כרטיסייה חדשה זה למעשה חלון מסוף.
זה פשוט הוא ספציפי לריצה תכנית שיצרנו.
>> שים לב כי בתחתית, ב שילוב עם כמה פלט
על ידי מצלצל מהדר וGDB, שבו אנו יכולים במידה רבה להתעלם,
זה באמת מראה את הפלט של התכנית שלנו בתחתית מאוד.
עכשיו זה חשוב להבין שחלון אחד זה בעצם
אראה לך פלט מהתכנית שלך
אבל גם יכול לקבל קלט לתכנית ש, כמו גם.
>> אז הודעה שאומרת נא להזין מספר,
אשר הוא אותו הפלט שהיו לנו היה בחלון המסוף לפני.
אבל עכשיו זה מוצג בכרטיסייה חדשה.
אני יכול להזין מספר.
וזה יהיה למעשה פונקציה כפי שאנו מצפים
מראה לנו באגים שלנו, תפוקה, הפלט שעשויה להיות מרכבה,
כפי שראינו בעבר.
ובתחתית מאוד, זה למעשה יש כמה פלט נוסף
מתמ"ג רק אומר ש תכנית זו השלימה.
>> עכשיו כפי שראית בזה טווח מסוים דרך,
זה לא היה במיוחד שימושי כי גם
למרות שהיה לנו לבוא תפריט הבאגים עד, זה עדיין היה תכנית ריצה.
בשום שלב לא זה באמת להשהות ביצוע עבורנו
כדי להיות מסוגל לבדוק כל המשתנים כלולים ב.
יש משהו אחר שאנחנו צריכים לעשות כדי
כדי לקבל GDB להכיר בכך שאנחנו רוצים כדי להשהות ביצוע התכנית
ולא רק לאפשר לו להמשיך בדרך כלל כפי שהיינו בכל מקרה אחר.
>> כדי להשהות ביצוע, בחלק שורה מסוימת,
אנחנו צריכים ליצור את מה ש נקרא נקודת פריצה.
ונוצר בקלות נקודת הפסקה בזה CS50 IDE על ידי לקיחת העכבר
ולחיצה ישירות לשמאל חלק מספר קו מסוים.
ברגע שאני עושה את זה, נקודה אדומה מופיע, דבר המצביע על
כי הקו שהוא כעת נקודת פריצה.
>> ובפעם הבאה שאני מפעיל GDB, זה יפסיק ביצוע שבנקודת הפריצה
כאשר הוא מגיע לקו זה של קוד.
עכשיו זה חשוב דבר לממש
שזה לא בהכרח מקרה שכל שורת קוד
נגיש למעשה.
אם הייתי ליצור פונקציה עד כאן, לf-- חלל example--
ופשוט לעשות את קו הדפסת כאן-- שלום world-- אם אני לא קורא לפונקציה זו,
זה יהיה המקרה ש, אם אני מגדיר נקודת הפסקה כאן,
הפונקציה לעולם לא תיקרא.
ולכן, זה נקודת פריצה מסוימת
אף פעם לא יהיה ממש להשהות ביצוע התכנית.
>> אז בואו נגיד שאני בצורה נכונה ליצור נקודת פריצה בחלק שורת קוד
זה בעצם להיות מוצא להורג.
עכשיו במקרה זה, זה הוא השורה הראשונה בפונקציה העיקרית.
אז זה בהחלט יהיה המקרה כי, ברגע שאני מתחיל ביצוע,
תהיה להגיע לשורה הראשונה.
GDB יהיה להשהות ביצוע.
ולאחר מכן, אני אהיה מסוגל אינטראקציה עם הבאגים.
>> באפשרותך להגדיר מספר שורות כ נקודות עצירה, אם ברצונך.
אנחנו יכולים גם ליצור עד קו כאן בקטע זה של קוד
שלעולם לא הגיעו.
ואנחנו גם יכולים להגדיר אחד בהמשך.
הסיבה שאנחנו הייתם רוצה לעשות זה אנחנו
להיכנס לקצת יותר פרט ברגע.
אז לעת עתה, תן לי רק להשבית נקודות מעבר נוספות אלה
כדי שנוכל להסתכל על מה שקורה כאשר יש לי הפסקה אחת
נקודה בתכנית שלי.
אני עשיתי כמה שינויים בתכנית זו.
אז אני צריך לשמור אותו.
אני לחץ באגים, כך שאני יכול להתחיל האוסף ולאחר מכן
ביצוע של הבאגים.
>> אנו רואים כי, לאחר רגעים, קו שנבחרנו כהפסקה
נקודה מודגשת בצהוב.
אנחנו גם יכולים להבחין כי ב ימני עליון בלוח באגים
שעל הסמל השהה הפך לסמל משחק קטן.
משמעות דבר היא שיש לנו הפסקה ביצוע, במקרה הספציפי הזה.
ולהכות את לחצן ההפעלה היה מאפשר לנו לחדש את הביצוע
שבנקודה מסוימת.
>> שימו לב שיש כמה אחרים כפתורים זמינים בלוח באגים זה,
גם כן.
לדרוך על, שמאפשר לי ביצוע ששורה אחת של קוד
ולדרוך על קו של הבא, אשר, במקרה זה,
היה אומר שprintf הצהרה מבוצעת.
ואז זה יהיה להשהות ביצוע על קו 13, כמו כל כך.
>> ויש גם צעד לפונקציה, ש
שימושי אם אני יצרתי אחר פונקציות במקום אחר בקוד המקור.
ואני רוצה להיכנס ל אלה פונקציות ולא
לבצע פונקציה שכולו.
אבל אנחנו נראים יותר בצעד לפונקציה ברגע.
עכשיו שמו לב כמה דברים אחרים ש למעשה קיימות בתוך פנל באגים זה.
>> יש לנו לוח זה נקרא קורא ערימה, שמראה לנו
איפה בדיוק אנחנו נמצאים.
במקרה זה, אנחנו נמצאים בתוך של הפונקציה העיקרית.
התסריט שלנו נקרא count.c.
ואנחנו במקרה ב קו 13, עמודה אחת, ש
זה בדיוק מה שהאזור המודגש של קוד המקור מצביע, כמו גם.
>> עכשיו שמו לב שזה גם מראה תחת הסעיף משתנה המקומי
כל המשתנים ש קיימים בתוך פונקציה זו.
חשוב לציין שכל המשתנים
יופיע במשתנה מקומית זה סעיף בתוך פונקציה,
עוד לפני שהם מוגדרים.
אנחנו יכולים לראות כאן שיש לנו משתנים בשם num, יש לו ערך ברירת מחדל של 0,
וזה של int הסוג.
>> עכשיו, לפני שאנחנו באמת לאתחל כל אחד מהמשתנים הללו,
אנחנו לא בהכרח מובטח לראות ערך של 0.
ובהתאם להוצאות להורג אחרות שבצעת
והמצב של הזיכרון כאשר אתה בעצם להפעיל את התכנית,
אתה עשוי לגלות כי אתה לא רואה ערכים של 0
ובמקום זאת, כמה מספרים מטורפים אחרים.
>> אבל אל תדאגו בקשר לזה.
זה לא הולך להיות רלוונטי עד אתה בעצם לאתחל את הערך.
עכשיו במקרה זה, אנו יכולים לראות כי אני בצעתי כמה יציאות.
ואני, עכשיו, עצרתי ביצוע.
אבל במקרה הזה, מה ש אני באמת רוצה לעשות
הוא צעד עכשיו על הקו הזה של קוד כך שלמעשה אני יכול
שאילתת המשתמש עבור int ש אנחנו רוצים להשתמש בתכנית שלנו.
>> עכשיו במקרה זה, כאשר אני מכה לדרוך על, הודעה
שהשהה או לייתר דיוק קורות החיים כפתור השתנה לכפתור השהה זה
בגלל קוד זה מבצע בפועל.
מה מתרחש עכשיו הוא שזה
מחכה לנו קלט קצת מידע כפי שניתן לראות בטקסט של הפלט שלנו
בתחתית מאוד.
>> אז עכשיו, זה הוא לא עצר למעשה,
למרות שזה, פחות או יותר, נראה להיות כי שום דבר לא קורה.
אבל זה פשוט כל כך קורה כי ב המקרה הספציפי שלי על קו 13,
אני מחכה לקלט ממשתמש.
וכך GDB הוא לא מסוגל לבדוק תכנית כפי שהוא פועל.
>> עכשיו בפעם הבאה שאני נכנסתי כמה input-- אז אני להזין את המספר ש5,
כפי שראינו ב past-- שבות פגעו, ואנחנו
שם לב ש, מייד, הפסקות GDB ו, שוב, מדגיש את השורה הבאה.
אבל שם לב שעכשיו, כ תוצאה שלנו מזין ערך,
יש לנו מתעדכן ערך שבתוך של המשתנים המקומיים שלנו, ש
מאוד שימושי לדעת בדיוק מה המספר שהיה בזיכרון.
>> עכשיו אני יכול להרשות לתכנית זו על מנת להמשיך לשחק עד סוף הביצוע שלה
על ידי להכות את קורות החיים.
אנו יכולים לראות כי מהר מאוד עושה סיום תכנית ביצוע
באותה התפוקה ש היה לפני, הבאגים סוגרים,
ועכשיו בתכנית זו הפסיק לחלוטין.
>> אני מראה שרק ל מטרות לראות מה
קורה כאשר אנו למעשה פגעו קורות חיים.
אבל אנחנו באמת הולכים רוצה לחזור לתכנית זו
כדי שנוכל לנסות באגים בדיוק מה שקורה.
עכשיו שאני משתמש הבאגים, יורשה לי לא צריכים הצהרות printf באגים אלה.
>> אז אני יכול להסיר אותם כמו שאני אעשה עכשיו רק כדי לחזור לקוד הפשוט שלנו
שהיה לנו לפני רגע.
עכשיו כשאני שומר לתכנת ולבצע את זה,
זה יהיה, שוב, ללכת לראשוני ש לשבור נקודה שהייתה לי על קו 11.
ואני אהיה מסוגל לבדוק המשתנים שלי כמו שאני רוצה לעשות.
>> זה פשוט כל כך קורה כי זה חלק לא מאוד מעניין,
ואני יודע שאני הולך להדפיס את ההצהרה זו.
נא להזין את המספר.
ולאחר מכן, אני יודע שאני הולך לשאול את המשתמש למספר שלם ש.
אז אולי, אני ממש רוצה לעוברי לשבור נקודה קצת יותר למטה.
>> אתה יכול להסיר נקודות הפסקה על ידי לחיצה, שוב, באופן ישיר
בצד השמאל של מספר הקו ש.
שהנקודה אדומה תיעלם, המציין שנקודת הפריצה כעת נעלמה.
עכשיו במקרה זה, ביצוע הושהה.
ואז זה לא באמת הולך תתחדש במקרה מסוים זה.
אבל אני יכול להגדיר הפסקה מצביע קצת מאוחר יותר.
>> וכאשר עכשיו אני קורות חיים שלי קוד, זה יהיה לחדש ולספר לי
נקודת שנקודת הפריצה.
שוב, אני מכה את קורות החיים.
לא נראה כמו שום דבר שקורה.
אבל זה בגלל ששלי קוד מחכה לקלט.
אני להזין מספר 5, על Enter, ו עכשיו נקודת ההפסקה הבאה תהיה מכה.
>> עכשיו במקרה זה, זה היא שורת קוד
כי, לפני, ידענו קרה לי להיות מרכבה.
אז בואו להעריך מה קורה בשלב מסוים זה בזמן.
כאשר קו מודגש, זה קו טרם בוצע.
אז במקרה הזה, אנחנו יכולים לראות כי יש לי מספר, ש
יש לי מספר שלם נקרא num שיש לו ערך 5.
ואני הולך להיות ביצוע קצת מתמטיקה על המספר הזה.
>> אם אני דורך על זה, אנחנו יכולים שם לב שהערך עבור num
השתנה בהתאם ל חשבון שאנחנו כבר ממש עשינו.
ועכשיו שאנחנו בתוך זה ללולאה
או החברה שללולאה עצמו מודגש,
אנו רואים שיש לנו חדש משתנה בשם i ש
הוא הולך להיות בשימוש שללולאה.
>> עכשיו לזכור לפני ש ציינו שלפעמים אתה
הולך לראות איזה משוגע מספרים כברירת מחדל לפני המספר ש
או משתנה שהוא אותחל למעשה.
אנחנו יכולים לראות שדווקא כאן במשתנה זה
בשמי, שבו יש לא עדיין אותחל
בעת הדגשה.
אבל אנחנו יכולים לראות שיש לו כמה מספר שלא היינו מצפים דווקא.
>> זה בסדר.
אל תדאגו בקשר לזה כי יש לנו לא ממש
אותחל מספר שעד ש לדרוך על הקו הזה ואת הערך
אני כבר אותחל לערך 1.
אז כדי לראות שזה בעצם המקרה, בואו לדרוך על.
כעת אנו יכולים לראות ש קו כבר הוצא להורג.
וכעת אנו מדגישים קו printf זה.
>> ועכשיו אנחנו יכולים לראות כיצד הערכים שלנו שלי ו -3 השתנו לאורך זמן.
זה מאוד שימושי לעשות, למעשה, הוא לדרוך על קווים שוב ושוב.
ואתה יכול למצוא את מה שבעצם קורה בתוך הלולאה שלך
ומה קורה ל משתנים הפנימיים של שללולאה
שכביצוע תכנית מתרחש צעד אחד בכל פעם.
>> עכשיו, בשלב זה, אני דלג מעל מספיק
כי אני עכשיו בסוף התכנית שלי.
אם אני דורך על זה, זה יהיה למעשה תחדל ביצוע
כפי שראינו בעבר.
תן לי להפעיל מחדש את זה, שוב, כל כך שאני יכול להצביע על משהו אחר,
גם כן.
>> במקרה זה, זה הוא עכשיו שואל אותי, שוב,
למספר, ש אני, שוב, להיכנס.
אבל הפעם, אני הולך להיכנס ב מספר גדול יותר, כך שעבור לולאה
יהיה לחזר יותר פעמים.
במקרה זה, אני הולך לזן ערך של 11.
>> עכשיו שוב כי הייתי להגדיר נקודת פריצה בקו 15,
זה הולך לסמן קו ש.
אנו יכולים לראות כי מספר 11 הוא נכון
מיוצג במשתנים המקומיים שלנו.
דורכים על זה, אנחנו יכולים עכשיו תראה מה קורה לשווי ההוגן שלי שלנו
ככל שנתקדם בתוך זה ללולאה.
הוא מקבל מוגדל כולנו זמן להגיע לראש שללולאה.
>> עכשיו אחד הדברים שאולי להיות שימושי לעשות במהלך ביצוע
של תכנית זו היא לי בעצם לשנות את אמצע הזרם משתנה לראות
מה קורה לתכנית שלי.
במקרה זה, אני באמת יכול לחץ לחיצה כפולה על הערך.
שימו לב שהוא הופך להיות שדה טקסט.
>> עכשיו אני יכול להיכנס שונה מעריך לגמרי
כדי לראות איך התכנית שלי מתנהגת כששיניתי משתנה ש.
עכשיו במקרה זה, משתנה עכשיו אני מכיל את הערך 10.
אבל התכנית היא עדיין עצר בביצוע.
כשאני דורך על, אני רואה ש אני ערך, שנכנסתי כ10,
לא גדול מהערך של num, שמייד גורם ללולאה
כדי לעצור את הביצוע.
>> עכשיו זה לא רק הסיבה שהיית
רוצה לשנות את המשתנה במקום.
ייתכן שבאמת רוצים כדי לנסות לשנות את זה כל כך
שתוכל להמשיך ביצוע של לולאה
או, כך שאתה יכול לשנות ערך כלשהו לפני ש
מגיע קבוצה מסוימת חלק מחשבון שאתה עומד לבצע.
>> אז עכשיו שאנחנו באמת לשנות את ערך שלי כתכנית ביצוע,
זה גרם ללולאה לפרוש בטרם עת פתאום משום,, אני
קרה להיות גדול מהערך של num, כלומר שעבור לולאה
אין עוד צורך בלהיות מוצא להורג.
יתר על כן, זה קרה להיות מקרה ששינינו את הערך של i
כאשר הקו 17 היה מודגש, שהייתה הנקודה בזמן
כי לביצוע לולאה למעשה נבדק.
>> אם אני השתניתי הערך של אני בקו שונה, אומר 19,
היינו רואה שונה התנהגות כי קו 19
הוציא להורג לפני הלולאה מצב היה הערכה מחודשת.
עכשיו, בשלב זה, אני, שוב, בסוף של תכנית זו.
ואני יכול לתת לזה להמשיך ל לאפשר התכנית שלי להפסיק באופן טבעי.
אבל יש כמה דברים שחשוב לקחת משם
מהדיון הספציפי הזה.
אתה צריך להעריך ההנחות שלך
על איך הקוד צריך להיות מתנהג.
בכל פעם שאתה חושב שפיסה של קוד אתה יודע שקורה לעבוד,
שעשוי להיות דגל אדום ללכת אחורה ולהעריך, ולהיות בטוח
שההנחה שלך איך הקוד שפועל
הוא למעשה אמיתי לאופן בו הוא בא לידי ביטוי בקוד המקור שלך.
>> אבל עוד יותר לנקודה היה, כאשר אנו משתמשים בהבאגים,
אתה יכול לשים נקודות עצירה ב קווים שונים של קוד,
אשר יגרום להבאגים להשהות ביצוע בכל אחד מהקווים האלה
כך שאתה יכול להעריך את זיכרון או אפילו לשנות אותו במקום.
ושוב, זכור כי אתה יכול ליצור נקודות עצירה מרובות, כך שאתה
יכול גם לחדש את הביצוע, לדלג על חלקים גדולים של קוד,
וזה יהיה באופן אוטומטי להשהות בנקודת ההפסקה הבאה.
>> יש למעשה יותר מתקדם תכונות של הבאגים, כמו גם.
אבל נצטרך להפנות אותך לכמה קטעי וידאו שלאחר מכן
כדי באמת להפריד איך כדי להשתמש בפונקציות מסוימות אלה.
לעת עתה, תודה הרבה מאוד לצפייה.
וניפוי מזל טוב.