1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? דן ARMADARAS:?] היי,
אני [? דן Armadaras?].

3
00:00:02,350 --> 00:00:04,410
היום, אנחנו הולכים
להיות מסתכל על ניפוי.

4
00:00:04,410 --> 00:00:06,697
לא רק שאנחנו הולכים ל
מדבר על כמה טכניקות,

5
00:00:06,697 --> 00:00:09,280
אבל גם אנחנו הולכים להסתכל על
חלק מהתכונות כלול

6
00:00:09,280 --> 00:00:14,170
בתוך IDE CS50 המאפשר
לך באגים בקלות תכנית.

7
00:00:14,170 --> 00:00:16,272
>> רק דוגמא אחת ל
משהו שיכול להשתבש

8
00:00:16,272 --> 00:00:18,730
וזה בעצם משהו
שכבר ראו בעבר.

9
00:00:18,730 --> 00:00:23,200
במקרה זה, מדובר בתכנית C
שמקבל מספר שלם מהמשתמש,

10
00:00:23,200 --> 00:00:27,580
חלק על ידי שתי, ומספק
הפלט בחזרה למשתמש.

11
00:00:27,580 --> 00:00:30,610
עכשיו ממה שראינו
מוקדם יותר בהרצאות,

12
00:00:30,610 --> 00:00:34,370
אנחנו יודעים שזה יהיה ממש לגרום ל
סוגים מסוימים של בעיות החלוקה

13
00:00:34,370 --> 00:00:35,860
כאשר יש לנו מספרים מוזרים.

14
00:00:35,860 --> 00:00:40,330
>> באופן ספציפי, אנחנו פשוט לזרוק
שום דבר אחרי הנקודה העשרונית.

15
00:00:40,330 --> 00:00:43,170
עכשיו, אנחנו יודעים שזה
קורה להיות המקרה.

16
00:00:43,170 --> 00:00:47,430
ואם אנחנו מפעילים אותו, אנחנו יכולים לאשר
החשדות שלנו, ראשון, על ידי העריכה.

17
00:00:47,430 --> 00:00:50,460
ולאחר מכן, על ידי הפעלה ו
הזנת מספר אי-זוגי.

18
00:00:50,460 --> 00:00:51,720
>> זה לא חדש.

19
00:00:51,720 --> 00:00:54,490
אבל זה בעצם
דוגמא לבאג ש

20
00:00:54,490 --> 00:00:58,810
יכול להתקיים בתוך תכנית גדולה יותר
שהופך להיות קשה יותר לאתר.

21
00:00:58,810 --> 00:01:02,640
למרות שאנו יודעים מה הבעיה
הוא, עיקרו האמיתי של העניין

22
00:01:02,640 --> 00:01:06,250
אולי מנסה לזהות
במיוחד שבו מתרחשת השגיאה,

23
00:01:06,250 --> 00:01:09,750
זיהוי מה בעיה ש
הוא, ולאחר מכן לתקן את זה.

24
00:01:09,750 --> 00:01:14,400
אז לספק את זה כדוגמא
ממה שעלול להיות משהו

25
00:01:14,400 --> 00:01:19,030
כי אנחנו כבר יודעים, אבל יכולים להיות קבורים
בתוך אלמנטים אחרים של הקוד.

26
00:01:19,030 --> 00:01:23,090
>> אז פתיחת מקור אחר זה
קובץ קוד כדוגמא,

27
00:01:23,090 --> 00:01:27,165
בעיה חלוקה זו היא עכשיו
חלק מתכנית גדולה יותר.

28
00:01:27,165 --> 00:01:29,040
עדיין יכול להיות קצת
קצת מאולץ, ואנחנו

29
00:01:29,040 --> 00:01:31,076
אולי תוכל בקלות
לזהות אותו, במיוחד

30
00:01:31,076 --> 00:01:32,450
מאז אנחנו רק דנים זה.

31
00:01:32,450 --> 00:01:38,250
אבל אנחנו יכולים להבין שזה
בעיה יכולה להתקיים בקנה מידה גדולה יותר.

32
00:01:38,250 --> 00:01:45,450
>> אם אני לקמפל זה ועכשיו
להפעיל אותו, להיכנס למספר אי-זוגי,

33
00:01:45,450 --> 00:01:49,816
אנו יכולים לראות כי אנחנו לא מקבלים בדיוק
התפוקה שאנחנו יכולים לצפות.

34
00:01:49,816 --> 00:01:51,690
במקרה הספציפי הזה,
אפשר לומר שאנחנו

35
00:01:51,690 --> 00:01:56,060
רוצה לספור את כל המספרים
מאחד עד כמה מספר ספציפי.

36
00:01:56,060 --> 00:01:58,130
ואנחנו יכולים לראות ש
יש מגוון רחב של נושאים

37
00:01:58,130 --> 00:02:03,880
כאן אם אנחנו פלט, פשוט, 0
וכאשר 1 אנו מספקים קלט 5.

38
00:02:03,880 --> 00:02:07,380
>> אז אנחנו כבר יודעים ש
יש כאן בעיה.

39
00:02:07,380 --> 00:02:11,662
אבל אנחנו לא יכולים לדעת בדיוק
שבו הנושא הזה באמת קיים.

40
00:02:11,662 --> 00:02:13,620
עכשיו אחת הדרכים ש
אנחנו יכולים לנסות לתקן את זה

41
00:02:13,620 --> 00:02:15,745
הוא משהו שיש לנו
כבר הציג ל.

42
00:02:15,745 --> 00:02:18,880
אנחנו רק יכולים להשתמש בו בקנה מידה גדולה יותר.

43
00:02:18,880 --> 00:02:21,680
>> על קו 14, שיש לנו
פונקציה זו printf,

44
00:02:21,680 --> 00:02:25,620
אשר מאפשר לנו להדפיס את המדינה
של חלקים שונים של מידע.

45
00:02:25,620 --> 00:02:28,880
וזה משהו שאתה
צריך למנף בתוך התכנית שלך

46
00:02:28,880 --> 00:02:33,100
כדי לנסות להבין בדיוק מה
קורה בקווים שונים של קוד.

47
00:02:33,100 --> 00:02:36,350
אז גם אם זה לא
פלט סופי שאנחנו באמת

48
00:02:36,350 --> 00:02:39,830
רוצה לייצר מ
תכנית זו, שעדיין

49
00:02:39,830 --> 00:02:42,300
אולי יש כמה באגים
ההצהרות שבו אנחנו

50
00:02:42,300 --> 00:02:46,970
יכול לנסות להבין בדיוק מה
קורה בתוך הקוד שלנו.

51
00:02:46,970 --> 00:02:51,210
>> אז במקרה הזה, אני
printf עם תג באגים.

52
00:02:51,210 --> 00:02:53,540
במקרה זה, זה הוא
רק מחרוזת באגים

53
00:02:53,540 --> 00:02:56,840
כי אני כל כך שהוא הופך להיות לשים-עד
מאוד ברור בתפוקה של הקוד שלי

54
00:02:56,840 --> 00:02:59,200
מה זה שאני רוצה להראות.

55
00:02:59,200 --> 00:03:04,410
ופלט כאן המספר
שיש לנו מחושבים.

56
00:03:04,410 --> 00:03:06,800
>> במקרה זה, אולי אני
רוצה לדעת בדיוק

57
00:03:06,800 --> 00:03:11,380
מה שקורה לפני ו
לאחר כמה חישוב ספציפי.

58
00:03:11,380 --> 00:03:16,224
אז אני יכול להשתמש printf לפני
ואחרי השורה של קוד.

59
00:03:16,224 --> 00:03:18,640
במקרה זה, אני אפילו יכול
לעשות את זה קצת יותר ברור

60
00:03:18,640 --> 00:03:21,960
באומרו באגים לפני
ובאגים אחרי כל כך

61
00:03:21,960 --> 00:03:26,540
שאני לא לבלבל עם עצמי
מספר שורות שנראות זהה.

62
00:03:26,540 --> 00:03:32,290
>> עכשיו, אם אנחנו הדר מחדש את זה ולרוץ
זה, להזין מספר כמו חמש שוב,

63
00:03:32,290 --> 00:03:35,090
אנחנו יכולים לראות שיש לנו
עכשיו פלט לפני ואחרי

64
00:03:35,090 --> 00:03:40,670
ומגלים שיש לנו לא נעשה ברור
אגף או ברור שיש של המספר

65
00:03:40,670 --> 00:03:43,680
שאנחנו באמת רוצים לעשות.

66
00:03:43,680 --> 00:03:48,660
עכשיו במקרה זה, זה הוא
לא ממש ברור פלט.

67
00:03:48,660 --> 00:03:52,440
זה לא באמת תוצאה ברורה ש
אנחנו רוצים מתוך תכנית מסוימת זו.

68
00:03:52,440 --> 00:03:54,427
>> וזה שוב הוא,,
קצת מאולץ.

69
00:03:54,427 --> 00:03:57,510
אבל, אולי, אחד הדברים ש
אנחנו יכולים לעשות אם המפרט אמר

70
00:03:57,510 --> 00:04:01,900
כי אנחנו רוצים לחלק את זה על ידי
2 ולהוסיף 1-- כך במילים אחרות,

71
00:04:01,900 --> 00:04:04,550
אנחנו רוצים לעגל אז up--
אנחנו יכולים לדעת שאנחנו יכולים

72
00:04:04,550 --> 00:04:08,060
לעשות דבר מסוים ש, במקרה זה.

73
00:04:08,060 --> 00:04:14,010
עכשיו כאן אנחנו יודעים שאנחנו יהיו
תוכל להוסיף 1 למספר החצוי שלנו.

74
00:04:14,010 --> 00:04:16,490
>> בואו הדר מחדש זה
ולאשר שזה

75
00:04:16,490 --> 00:04:18,860
מתנהג בדרך שאנחנו רוצים.

76
00:04:18,860 --> 00:04:21,980
אנחנו יכולים לראות את זה עכשיו לפני ש
יש, יש לנו את המספר 5.

77
00:04:21,980 --> 00:04:26,620
לאחר ש, יש לנו את המספר 3,
אשר על פי המפרט שלנו,

78
00:04:26,620 --> 00:04:29,292
זה מה שאנחנו רוצים לעשות.

79
00:04:29,292 --> 00:04:31,000
אבל אם אנחנו מסתכל על
פלט כאן, אנחנו יכולים

80
00:04:31,000 --> 00:04:33,760
רואה שאולי יש לנו עוד
באג לגמרי, שהוא

81
00:04:33,760 --> 00:04:36,940
כי אנחנו מתחילים לסופרנו מ0.

82
00:04:36,940 --> 00:04:39,390
>> עכשיו שוב, זה משהו ש
שראינו בעבר

83
00:04:39,390 --> 00:04:42,500
ואנחנו יכולים לתקן די בקלות.

84
00:04:42,500 --> 00:04:44,790
אבל במקרה הזה, אנחנו
היה גם היתרון

85
00:04:44,790 --> 00:04:48,940
של שימוש הצהרת printf
ישירות בתוך לולאה

86
00:04:48,940 --> 00:04:52,930
לדעת בדיוק היכן
השגיאה שמתרחשת.

87
00:04:52,930 --> 00:04:55,150
הצהרות אז printf הן
שימושי מאוד לעזור

88
00:04:55,150 --> 00:04:57,940
לך לקבוע היכן,
דווקא בקוד המקור שלך,

89
00:04:57,940 --> 00:05:00,620
שגיאה ספציפית מתרחשת.

90
00:05:00,620 --> 00:05:03,650
>> וזה גם חשוב להבין
כי, כפי שאנו כותבים קוד,

91
00:05:03,650 --> 00:05:06,052
אולי יש לנו הנחות
על המצב של תכנית.

92
00:05:06,052 --> 00:05:08,510
או שאולי יש לנו הנחות
על איזה חלק של התכנית

93
00:05:08,510 --> 00:05:13,020
נכון או לא נכון, כאשר למעשה
בשלב מאוחר יותר כפי שאנו בונים על תכנית ש

94
00:05:13,020 --> 00:05:15,950
ולהפוך אותה לחלק מ
מורכב ותכנית גדולה יותר

95
00:05:15,950 --> 00:05:19,700
כי אנחנו מבינים שחלק מההיבט
של שהוא למעשה מרכבה.

96
00:05:19,700 --> 00:05:22,680
>> באמצעות printf באמת יכול לעזור
לצמצם ולזהות

97
00:05:22,680 --> 00:05:26,430
האזורים של תכנית שאולי לא
להיות מתנהג בדיוק כפי שאנחנו

98
00:05:26,430 --> 00:05:29,500
מצפה, המבוסס על ההנחות שלנו.

99
00:05:29,500 --> 00:05:31,460
אבל יש כלים אחרים
זמין, כמו גם,

100
00:05:31,460 --> 00:05:34,860
המאפשר לנו לנסות להבין
איפה שגיאה מתרחשת

101
00:05:34,860 --> 00:05:39,930
וגם, באופן ספציפי, מה דברים
קורים בתוך התכנית.

102
00:05:39,930 --> 00:05:41,990
>> אז printf באמצעות מאוד
שימושי כאשר אנו רוצים

103
00:05:41,990 --> 00:05:45,900
לזהות אזורים ספציפיים של
תכנית, כי יש כמה באגים.

104
00:05:45,900 --> 00:05:47,730
אבל זה גם הופך
משעמם אחרי כמה זמן.

105
00:05:47,730 --> 00:05:50,500
במקרה זה, מדובר ב
תכנית פשוטה יחסית

106
00:05:50,500 --> 00:05:52,750
רק עם אחד או שני משתנים.

107
00:05:52,750 --> 00:05:57,260
וזה הופך להיות קל מאוד עבורנו
להדפיס את הערך של משתנים אלו

108
00:05:57,260 --> 00:05:59,670
בהקשר של התכנית הגדולה יותר.

109
00:05:59,670 --> 00:06:02,670
>> אבל אולי יש לנו שונה
תכנית שיש משתנים רבים.

110
00:06:02,670 --> 00:06:06,530
וזה לא יכול להיות די
כל כך קל לשימוש printf

111
00:06:06,530 --> 00:06:10,120
כדי לנסות להעריך מה שקורה
לכל אחד מהמשתנים אלה

112
00:06:10,120 --> 00:06:13,590
כתכנית ביצוע.

113
00:06:13,590 --> 00:06:16,960
יש תכנית שקיימת
נקרא תכנית הבאגים.

114
00:06:16,960 --> 00:06:20,320
במקרה זה, אחד שיהיה
שימוש הוא הבאגים של גנו, או GDB,

115
00:06:20,320 --> 00:06:24,260
המאפשר לנו לבדוק את פנימי
פעולתו של תכנית בצורה הרבה יותר

116
00:06:24,260 --> 00:06:25,700
דרך מפורטת.

117
00:06:25,700 --> 00:06:28,810
>> אנחנו באמת יכולים לבצע
GDB משורת הפקודה

118
00:06:28,810 --> 00:06:35,370
כאן פשוט על ידי הקלדת GDB ו
הפקודה שאנחנו רוצים לאתר באגים.

119
00:06:35,370 --> 00:06:37,550
במקרה זה, לספור.

120
00:06:37,550 --> 00:06:41,650
עכשיו במקרה זה, אנו יכולים לראות כי זה
מביא אותנו לפקודה שאומרת GDB.

121
00:06:41,650 --> 00:06:44,020
ואנחנו באמת יכולים
לבצע פקודות לGDB

122
00:06:44,020 --> 00:06:48,260
למעשה להתחיל ביצוע
תכנית, לעצור אותה בנקודות מסוימות,

123
00:06:48,260 --> 00:06:51,060
להעריך את המשתנים ו
לבדוק את המשתנים ש

124
00:06:51,060 --> 00:06:54,152
קיים במדינת התכנית
באותו הרגע,

125
00:06:54,152 --> 00:06:55,110
וכן הלאה וכן הלאה.

126
00:06:55,110 --> 00:06:57,240
הוא מספק הרבה כוח לנו.

127
00:06:57,240 --> 00:06:59,960
>> אבל זה פשוט כל כך קורה
שIDE CS50 גם

128
00:06:59,960 --> 00:07:05,870
מספק GUI או משתמש
ממשק לGDB ש

129
00:07:05,870 --> 00:07:11,120
מאפשר לנו לעשות את זה ללא צורך
ממשק שורת פקודה כלשהי

130
00:07:11,120 --> 00:07:13,560
או בכלל אפילו.

131
00:07:13,560 --> 00:07:16,930
הדרך שאני יכול לגשת ש
הוא על ידי שימוש בכפתור באגים

132
00:07:16,930 --> 00:07:20,120
בחלקו העליון של IDE CS50.

133
00:07:20,120 --> 00:07:24,280
עכשיו בעבר, מה שיש לנו
ראה הוא שאנחנו משתמשים בפקודה

134
00:07:24,280 --> 00:07:27,660
קו לקמפל ולאחר מכן להפעיל תכנית.

135
00:07:27,660 --> 00:07:29,790
>> כפתור באגים עושה
שני צעדים אלה.

136
00:07:29,790 --> 00:07:34,380
אבל זה יהיה גם להעלות את
כרטיסיית הבאגים על ימין הקיצוני

137
00:07:34,380 --> 00:07:38,280
המאפשר לנו לבדוק מגוון
נכסים של התכנית

138
00:07:38,280 --> 00:07:40,500
כפי שהוא מבצע.

139
00:07:40,500 --> 00:07:44,280
אם אני לוחץ על באגים, בזה
מקרה, זה יביא את

140
00:07:44,280 --> 00:07:48,230
כרטיסייה חדשה בקונסולה
חלון בתחתית מאוד.

141
00:07:48,230 --> 00:07:51,160
>> ואתה יכול לראות שיש לו בכרטיסייה זו
קצת מידע בחלקו העליון.

142
00:07:51,160 --> 00:07:52,670
ואנחנו יכולים במידה רבה להתעלם מכך.

143
00:07:52,670 --> 00:07:54,800
אבל אחד הדברים
כי אנחנו רוצים לב

144
00:07:54,800 --> 00:07:57,170
הוא שזה פלטי
אותו הדבר שאנחנו

145
00:07:57,170 --> 00:08:03,000
היית מקבל אם ננסה לרוץ לעשות ב
תכנית C בחלון המסוף.

146
00:08:03,000 --> 00:08:06,230
>> כאן, אנו יכולים לראות שזה פועל צלצול,
ויש לה מגוון רחב של דגלים,

147
00:08:06,230 --> 00:08:12,660
והוא קומפילציה קובץ count.c,
שהיה הכרטיסייה שנבחרה בזמן

148
00:08:12,660 --> 00:08:15,100
שאני מכה באגים.

149
00:08:15,100 --> 00:08:18,010
אז זה מאוד שימושי משום ש
כיום באמצעות כפתור באגים זה,

150
00:08:18,010 --> 00:08:23,280
אנחנו יכולים בו זמנית לקמפל ולאחר מכן
לבצע את התכנית שאנחנו באמת

151
00:08:23,280 --> 00:08:24,460
רוצה לרוץ.

152
00:08:24,460 --> 00:08:27,880
>> אחד הדגלים שהם
חשוב, במקרה זה,

153
00:08:27,880 --> 00:08:30,190
למעשה אנחנו כבר משתמשים
למשך הזמן הארוך ביותר

154
00:08:30,190 --> 00:08:32,450
אבל גם רק עשיתי קצת יד
מנופף [לא ברור], ש

155
00:08:32,450 --> 00:08:33,820
זה אחד ממש כאן.

156
00:08:33,820 --> 00:08:35,790
בצלצול, זה אומר -ggdb3.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
במקרה זה, מה שאנחנו
אומר לי צלצול, מהדר שלנו,

159
00:08:41,250 --> 00:08:43,820
הוא שאנחנו רוצים לקמפל את התכנית שלנו.

160
00:08:43,820 --> 00:08:46,810
אלא גם לספק את מה שהם
מידע סמל שנקרא

161
00:08:46,810 --> 00:08:50,940
כך שיש מהדר למעשה גישה
להרבה מידע הבסיסי

162
00:08:50,940 --> 00:08:52,610
בתוך התכנית.

163
00:08:52,610 --> 00:08:55,260
>> באופן ספציפי יותר, המספר
פונקציות שיש לי,

164
00:08:55,260 --> 00:08:58,000
השמות של פונקציות אלה,
המשתנים, הסוגים

165
00:08:58,000 --> 00:09:01,730
שמשתנים אלו, ועוד מגוון
דברים אחרים שיעזרו הבאגים

166
00:09:01,730 --> 00:09:04,350
לבצע את פעולתה.

167
00:09:04,350 --> 00:09:06,600
עכשיו יש משהו אחר
זה חשוב להזכיר

168
00:09:06,600 --> 00:09:10,280
כאשר אנו דנים ריצה
תכנית בדרך זו.

169
00:09:10,280 --> 00:09:13,660
>> שימו לב שיש לו למעשה
הביא את כרטיסייה חדשה בקונסולה שלנו

170
00:09:13,660 --> 00:09:14,780
בחלק התחתון.

171
00:09:14,780 --> 00:09:18,600
אנחנו כבר לא צריכים אינטראקציה
ישירות עם חלון המסוף.

172
00:09:18,600 --> 00:09:21,420
אבל כרטיסייה חדשה זה
למעשה חלון מסוף.

173
00:09:21,420 --> 00:09:26,710
זה פשוט הוא ספציפי לריצה
תכנית שיצרנו.

174
00:09:26,710 --> 00:09:29,270
>> שים לב כי בתחתית, ב
שילוב עם כמה פלט

175
00:09:29,270 --> 00:09:33,500
על ידי מצלצל מהדר וGDB,
שבו אנו יכולים במידה רבה להתעלם,

176
00:09:33,500 --> 00:09:37,570
זה באמת מראה את הפלט של
התכנית שלנו בתחתית מאוד.

177
00:09:37,570 --> 00:09:41,240
עכשיו זה חשוב להבין
שחלון אחד זה בעצם

178
00:09:41,240 --> 00:09:43,360
אראה לך
פלט מהתכנית שלך

179
00:09:43,360 --> 00:09:47,190
אבל גם יכול לקבל קלט
לתכנית ש, כמו גם.

180
00:09:47,190 --> 00:09:49,260
>> אז הודעה שאומרת
נא להזין מספר,

181
00:09:49,260 --> 00:09:53,050
אשר הוא אותו הפלט שהיו לנו
היה בחלון המסוף לפני.

182
00:09:53,050 --> 00:09:55,510
אבל עכשיו זה מוצג בכרטיסייה חדשה.

183
00:09:55,510 --> 00:09:56,550
אני יכול להזין מספר.

184
00:09:56,550 --> 00:10:00,900
וזה יהיה למעשה
פונקציה כפי שאנו מצפים

185
00:10:00,900 --> 00:10:05,890
מראה לנו באגים שלנו, תפוקה,
הפלט שעשויה להיות מרכבה,

186
00:10:05,890 --> 00:10:07,010
כפי שראינו בעבר.

187
00:10:07,010 --> 00:10:10,460
ובתחתית מאוד, זה
למעשה יש כמה פלט נוסף

188
00:10:10,460 --> 00:10:14,550
מתמ"ג רק אומר ש
תכנית זו השלימה.

189
00:10:14,550 --> 00:10:16,655
>> עכשיו כפי שראית בזה
טווח מסוים דרך,

190
00:10:16,655 --> 00:10:19,370
זה לא היה במיוחד
שימושי כי גם

191
00:10:19,370 --> 00:10:23,740
למרות שהיה לנו לבוא תפריט הבאגים
עד, זה עדיין היה תכנית ריצה.

192
00:10:23,740 --> 00:10:26,790
בשום שלב לא זה באמת
להשהות ביצוע עבורנו

193
00:10:26,790 --> 00:10:30,767
כדי להיות מסוגל לבדוק כל
המשתנים כלולים ב.

194
00:10:30,767 --> 00:10:32,850
יש משהו אחר
שאנחנו צריכים לעשות כדי

195
00:10:32,850 --> 00:10:36,910
כדי לקבל GDB להכיר בכך שאנחנו רוצים
כדי להשהות ביצוע התכנית

196
00:10:36,910 --> 00:10:42,820
ולא רק לאפשר לו להמשיך
בדרך כלל כפי שהיינו בכל מקרה אחר.

197
00:10:42,820 --> 00:10:45,530
>> כדי להשהות ביצוע,
בחלק שורה מסוימת,

198
00:10:45,530 --> 00:10:47,830
אנחנו צריכים ליצור את מה ש
נקרא נקודת פריצה.

199
00:10:47,830 --> 00:10:52,670
ונוצר בקלות נקודת הפסקה
בזה CS50 IDE על ידי לקיחת העכבר

200
00:10:52,670 --> 00:10:57,090
ולחיצה ישירות לשמאל
חלק מספר קו מסוים.

201
00:10:57,090 --> 00:10:59,920
ברגע שאני עושה את זה, נקודה אדומה
מופיע, דבר המצביע על

202
00:10:59,920 --> 00:11:02,300
כי הקו שהוא כעת נקודת פריצה.

203
00:11:02,300 --> 00:11:07,540
>> ובפעם הבאה שאני מפעיל GDB, זה
יפסיק ביצוע שבנקודת הפריצה

204
00:11:07,540 --> 00:11:10,280
כאשר הוא מגיע לקו זה של קוד.

205
00:11:10,280 --> 00:11:12,230
עכשיו זה חשוב
דבר לממש

206
00:11:12,230 --> 00:11:16,140
שזה לא בהכרח
מקרה שכל שורת קוד

207
00:11:16,140 --> 00:11:17,880
נגיש למעשה.

208
00:11:17,880 --> 00:11:23,780
אם הייתי ליצור פונקציה
עד כאן, לf-- חלל example--

209
00:11:23,780 --> 00:11:31,230
ופשוט לעשות את קו הדפסת כאן-- שלום
world-- אם אני לא קורא לפונקציה זו,

210
00:11:31,230 --> 00:11:34,770
זה יהיה המקרה ש,
אם אני מגדיר נקודת הפסקה כאן,

211
00:11:34,770 --> 00:11:36,220
הפונקציה לעולם לא תיקרא.

212
00:11:36,220 --> 00:11:38,310
ולכן, זה
נקודת פריצה מסוימת

213
00:11:38,310 --> 00:11:43,040
אף פעם לא יהיה ממש להשהות
ביצוע התכנית.

214
00:11:43,040 --> 00:11:48,020
>> אז בואו נגיד שאני בצורה נכונה ליצור
נקודת פריצה בחלק שורת קוד

215
00:11:48,020 --> 00:11:50,340
זה בעצם להיות מוצא להורג.

216
00:11:50,340 --> 00:11:53,470
עכשיו במקרה זה, זה הוא
השורה הראשונה בפונקציה העיקרית.

217
00:11:53,470 --> 00:11:56,630
אז זה בהחלט יהיה המקרה
כי, ברגע שאני מתחיל ביצוע,

218
00:11:56,630 --> 00:11:58,580
תהיה להגיע לשורה הראשונה.

219
00:11:58,580 --> 00:12:00,230
GDB יהיה להשהות ביצוע.

220
00:12:00,230 --> 00:12:04,100
ולאחר מכן, אני אהיה מסוגל
אינטראקציה עם הבאגים.

221
00:12:04,100 --> 00:12:08,480
>> באפשרותך להגדיר מספר שורות כ
נקודות עצירה, אם ברצונך.

222
00:12:08,480 --> 00:12:11,365
אנחנו יכולים גם ליצור עד קו
כאן בקטע זה של קוד

223
00:12:11,365 --> 00:12:12,490
שלעולם לא הגיעו.

224
00:12:12,490 --> 00:12:14,744
ואנחנו גם יכולים להגדיר אחד בהמשך.

225
00:12:14,744 --> 00:12:16,660
הסיבה שאנחנו הייתם
רוצה לעשות זה אנחנו

226
00:12:16,660 --> 00:12:19,119
להיכנס לקצת יותר
פרט ברגע.

227
00:12:19,119 --> 00:12:21,660
אז לעת עתה, תן לי רק להשבית
נקודות מעבר נוספות אלה

228
00:12:21,660 --> 00:12:24,940
כדי שנוכל להסתכל על מה שקורה
כאשר יש לי הפסקה אחת

229
00:12:24,940 --> 00:12:27,650
נקודה בתכנית שלי.

230
00:12:27,650 --> 00:12:29,410
אני עשיתי כמה
שינויים בתכנית זו.

231
00:12:29,410 --> 00:12:30,750
אז אני צריך לשמור אותו.

232
00:12:30,750 --> 00:12:34,490
אני לחץ באגים, כך שאני יכול
להתחיל האוסף ולאחר מכן

233
00:12:34,490 --> 00:12:36,880
ביצוע של הבאגים.

234
00:12:36,880 --> 00:12:40,632
>> אנו רואים כי, לאחר רגעים,
קו שנבחרנו כהפסקה

235
00:12:40,632 --> 00:12:43,360
נקודה מודגשת בצהוב.

236
00:12:43,360 --> 00:12:47,440
אנחנו גם יכולים להבחין כי ב
ימני עליון בלוח באגים

237
00:12:47,440 --> 00:12:50,940
שעל הסמל השהה הפך
לסמל משחק קטן.

238
00:12:50,940 --> 00:12:54,710
משמעות דבר היא שיש לנו הפסקה
ביצוע, במקרה הספציפי הזה.

239
00:12:54,710 --> 00:12:57,840
ולהכות את לחצן ההפעלה היה
מאפשר לנו לחדש את הביצוע

240
00:12:57,840 --> 00:13:00,000
שבנקודה מסוימת.

241
00:13:00,000 --> 00:13:03,240
>> שימו לב שיש כמה אחרים
כפתורים זמינים בלוח באגים זה,

242
00:13:03,240 --> 00:13:04,220
גם כן.

243
00:13:04,220 --> 00:13:09,470
לדרוך על, שמאפשר לי
ביצוע ששורה אחת של קוד

244
00:13:09,470 --> 00:13:14,030
ולדרוך על קו של
הבא, אשר, במקרה זה,

245
00:13:14,030 --> 00:13:17,060
היה אומר שprintf
הצהרה מבוצעת.

246
00:13:17,060 --> 00:13:22,310
ואז זה יהיה להשהות
ביצוע על קו 13, כמו כל כך.

247
00:13:22,310 --> 00:13:25,090
>> ויש גם צעד
לפונקציה, ש

248
00:13:25,090 --> 00:13:28,950
שימושי אם אני יצרתי אחר
פונקציות במקום אחר בקוד המקור.

249
00:13:28,950 --> 00:13:31,420
ואני רוצה להיכנס ל
אלה פונקציות ולא

250
00:13:31,420 --> 00:13:33,050
לבצע פונקציה שכולו.

251
00:13:33,050 --> 00:13:37,279
אבל אנחנו נראים יותר בצעד
לפונקציה ברגע.

252
00:13:37,279 --> 00:13:40,320
עכשיו שמו לב כמה דברים אחרים ש
למעשה קיימות בתוך פנל באגים זה.

253
00:13:40,320 --> 00:13:44,110
>> יש לנו לוח זה נקרא
קורא ערימה, שמראה לנו

254
00:13:44,110 --> 00:13:45,300
איפה בדיוק אנחנו נמצאים.

255
00:13:45,300 --> 00:13:48,550
במקרה זה, אנחנו נמצאים בתוך
של הפונקציה העיקרית.

256
00:13:48,550 --> 00:13:50,880
התסריט שלנו נקרא count.c.

257
00:13:50,880 --> 00:13:53,820
ואנחנו במקרה ב
קו 13, עמודה אחת, ש

258
00:13:53,820 --> 00:13:58,950
זה בדיוק מה שהאזור המודגש
של קוד המקור מצביע, כמו גם.

259
00:13:58,950 --> 00:14:02,435
>> עכשיו שמו לב שזה גם מראה
תחת הסעיף משתנה המקומי

260
00:14:02,435 --> 00:14:06,710
כל המשתנים ש
קיימים בתוך פונקציה זו.

261
00:14:06,710 --> 00:14:08,930
חשוב לציין
שכל המשתנים

262
00:14:08,930 --> 00:14:12,580
יופיע במשתנה מקומית זה
סעיף בתוך פונקציה,

263
00:14:12,580 --> 00:14:14,380
עוד לפני שהם מוגדרים.

264
00:14:14,380 --> 00:14:19,160
אנחנו יכולים לראות כאן שיש לנו משתנים
בשם num, יש לו ערך ברירת מחדל של 0,

265
00:14:19,160 --> 00:14:21,280
וזה של int הסוג.

266
00:14:21,280 --> 00:14:24,110
>> עכשיו, לפני שאנחנו באמת לאתחל
כל אחד מהמשתנים הללו,

267
00:14:24,110 --> 00:14:26,685
אנחנו לא בהכרח
מובטח לראות ערך של 0.

268
00:14:26,685 --> 00:14:29,200
ובהתאם להוצאות להורג אחרות
שבצעת

269
00:14:29,200 --> 00:14:32,020
והמצב של הזיכרון כאשר
אתה בעצם להפעיל את התכנית,

270
00:14:32,020 --> 00:14:34,605
אתה עשוי לגלות כי אתה
לא רואה ערכים של 0

271
00:14:34,605 --> 00:14:36,550
ובמקום זאת, כמה מספרים מטורפים אחרים.

272
00:14:36,550 --> 00:14:38,390
>> אבל אל תדאגו בקשר לזה.

273
00:14:38,390 --> 00:14:44,610
זה לא הולך להיות רלוונטי עד
אתה בעצם לאתחל את הערך.

274
00:14:44,610 --> 00:14:49,630
עכשיו במקרה זה, אנו יכולים לראות כי
אני בצעתי כמה יציאות.

275
00:14:49,630 --> 00:14:52,131
ואני, עכשיו, עצרתי ביצוע.

276
00:14:52,131 --> 00:14:53,880
אבל במקרה הזה, מה ש
אני באמת רוצה לעשות

277
00:14:53,880 --> 00:14:58,060
הוא צעד עכשיו על הקו הזה
של קוד כך שלמעשה אני יכול

278
00:14:58,060 --> 00:15:04,390
שאילתת המשתמש עבור int ש
אנחנו רוצים להשתמש בתכנית שלנו.

279
00:15:04,390 --> 00:15:07,060
>> עכשיו במקרה זה, כאשר
אני מכה לדרוך על, הודעה

280
00:15:07,060 --> 00:15:11,940
שהשהה או לייתר דיוק קורות החיים
כפתור השתנה לכפתור השהה זה

281
00:15:11,940 --> 00:15:14,022
בגלל קוד זה מבצע בפועל.

282
00:15:14,022 --> 00:15:15,730
מה מתרחש
עכשיו הוא שזה

283
00:15:15,730 --> 00:15:21,630
מחכה לנו קלט קצת מידע
כפי שניתן לראות בטקסט של הפלט שלנו

284
00:15:21,630 --> 00:15:23,600
בתחתית מאוד.

285
00:15:23,600 --> 00:15:25,787
>> אז עכשיו, זה הוא
לא עצר למעשה,

286
00:15:25,787 --> 00:15:28,620
למרות שזה, פחות או יותר, נראה
להיות כי שום דבר לא קורה.

287
00:15:28,620 --> 00:15:32,360
אבל זה פשוט כל כך קורה כי ב
המקרה הספציפי שלי על קו 13,

288
00:15:32,360 --> 00:15:34,210
אני מחכה לקלט ממשתמש.

289
00:15:34,210 --> 00:15:39,130
וכך GDB הוא לא מסוגל לבדוק
תכנית כפי שהוא פועל.

290
00:15:39,130 --> 00:15:43,370
>> עכשיו בפעם הבאה שאני נכנסתי כמה
input-- אז אני להזין את המספר ש5,

291
00:15:43,370 --> 00:15:46,140
כפי שראינו ב
past-- שבות פגעו, ואנחנו

292
00:15:46,140 --> 00:15:51,430
שם לב ש, מייד, הפסקות GDB
ו, שוב, מדגיש את השורה הבאה.

293
00:15:51,430 --> 00:15:55,320
אבל שם לב שעכשיו, כ
תוצאה שלנו מזין ערך,

294
00:15:55,320 --> 00:15:58,930
יש לנו מתעדכן ערך שבתוך
של המשתנים המקומיים שלנו, ש

295
00:15:58,930 --> 00:16:05,560
מאוד שימושי לדעת בדיוק
מה המספר שהיה בזיכרון.

296
00:16:05,560 --> 00:16:10,650
>> עכשיו אני יכול להרשות לתכנית זו על מנת להמשיך
לשחק עד סוף הביצוע שלה

297
00:16:10,650 --> 00:16:12,570
על ידי להכות את קורות החיים.

298
00:16:12,570 --> 00:16:16,410
אנו יכולים לראות כי מהר מאוד
עושה סיום תכנית ביצוע

299
00:16:16,410 --> 00:16:19,790
באותה התפוקה ש
היה לפני, הבאגים סוגרים,

300
00:16:19,790 --> 00:16:23,170
ועכשיו בתכנית זו
הפסיק לחלוטין.

301
00:16:23,170 --> 00:16:25,320
>> אני מראה שרק ל
מטרות לראות מה

302
00:16:25,320 --> 00:16:27,280
קורה כאשר אנו למעשה פגעו קורות חיים.

303
00:16:27,280 --> 00:16:30,640
אבל אנחנו באמת הולכים
רוצה לחזור לתכנית זו

304
00:16:30,640 --> 00:16:33,820
כדי שנוכל לנסות באגים
בדיוק מה שקורה.

305
00:16:33,820 --> 00:16:37,980
עכשיו שאני משתמש הבאגים, יורשה לי
לא צריכים הצהרות printf באגים אלה.

306
00:16:37,980 --> 00:16:43,860
>> אז אני יכול להסיר אותם כמו שאני אעשה
עכשיו רק כדי לחזור לקוד הפשוט שלנו

307
00:16:43,860 --> 00:16:45,950
שהיה לנו לפני רגע.

308
00:16:45,950 --> 00:16:48,790
עכשיו כשאני שומר
לתכנת ולבצע את זה,

309
00:16:48,790 --> 00:16:53,700
זה יהיה, שוב, ללכת לראשוני ש
לשבור נקודה שהייתה לי על קו 11.

310
00:16:53,700 --> 00:16:57,700
ואני אהיה מסוגל לבדוק
המשתנים שלי כמו שאני רוצה לעשות.

311
00:16:57,700 --> 00:17:00,695
>> זה פשוט כל כך קורה כי זה
חלק לא מאוד מעניין,

312
00:17:00,695 --> 00:17:04,364
ואני יודע שאני הולך
להדפיס את ההצהרה זו.

313
00:17:04,364 --> 00:17:05,280
נא להזין את המספר.

314
00:17:05,280 --> 00:17:08,099
ולאחר מכן, אני יודע שאני הולך
לשאול את המשתמש למספר שלם ש.

315
00:17:08,099 --> 00:17:13,329
אז אולי, אני ממש רוצה לעוברי
לשבור נקודה קצת יותר למטה.

316
00:17:13,329 --> 00:17:16,710
>> אתה יכול להסיר נקודות הפסקה
על ידי לחיצה, שוב, באופן ישיר

317
00:17:16,710 --> 00:17:18,460
בצד השמאל של מספר הקו ש.

318
00:17:18,460 --> 00:17:22,200
שהנקודה אדומה תיעלם, המציין
שנקודת הפריצה כעת נעלמה.

319
00:17:22,200 --> 00:17:24,780
עכשיו במקרה זה,
ביצוע הושהה.

320
00:17:24,780 --> 00:17:27,770
ואז זה לא באמת הולך
תתחדש במקרה מסוים זה.

321
00:17:27,770 --> 00:17:30,210
אבל אני יכול להגדיר הפסקה
מצביע קצת מאוחר יותר.

322
00:17:30,210 --> 00:17:33,880
>> וכאשר עכשיו אני קורות חיים שלי
קוד, זה יהיה לחדש ולספר לי

323
00:17:33,880 --> 00:17:36,190
נקודת שנקודת הפריצה.

324
00:17:36,190 --> 00:17:37,374
שוב, אני מכה את קורות החיים.

325
00:17:37,374 --> 00:17:39,040
לא נראה כמו שום דבר שקורה.

326
00:17:39,040 --> 00:17:41,450
אבל זה בגלל ששלי
קוד מחכה לקלט.

327
00:17:41,450 --> 00:17:47,900
אני להזין מספר 5, על Enter, ו
עכשיו נקודת ההפסקה הבאה תהיה מכה.

328
00:17:47,900 --> 00:17:50,570
>> עכשיו במקרה זה, זה
היא שורת קוד

329
00:17:50,570 --> 00:17:53,820
כי, לפני, ידענו
קרה לי להיות מרכבה.

330
00:17:53,820 --> 00:17:57,590
אז בואו להעריך מה קורה
בשלב מסוים זה בזמן.

331
00:17:57,590 --> 00:18:02,620
כאשר קו מודגש, זה
קו טרם בוצע.

332
00:18:02,620 --> 00:18:06,490
אז במקרה הזה, אנחנו יכולים לראות
כי יש לי מספר, ש

333
00:18:06,490 --> 00:18:11,610
יש לי מספר שלם נקרא
num שיש לו ערך 5.

334
00:18:11,610 --> 00:18:15,090
ואני הולך להיות ביצוע
קצת מתמטיקה על המספר הזה.

335
00:18:15,090 --> 00:18:20,130
>> אם אני דורך על זה, אנחנו יכולים
שם לב שהערך עבור num

336
00:18:20,130 --> 00:18:23,780
השתנה בהתאם ל
חשבון שאנחנו כבר ממש עשינו.

337
00:18:23,780 --> 00:18:26,810
ועכשיו שאנחנו
בתוך זה ללולאה

338
00:18:26,810 --> 00:18:29,090
או החברה שללולאה
עצמו מודגש,

339
00:18:29,090 --> 00:18:32,450
אנו רואים שיש לנו חדש
משתנה בשם i ש

340
00:18:32,450 --> 00:18:35,370
הוא הולך להיות בשימוש שללולאה.

341
00:18:35,370 --> 00:18:38,230
>> עכשיו לזכור לפני ש
ציינו שלפעמים אתה

342
00:18:38,230 --> 00:18:43,470
הולך לראות איזה משוגע
מספרים כברירת מחדל לפני המספר ש

343
00:18:43,470 --> 00:18:45,530
או משתנה שהוא
אותחל למעשה.

344
00:18:45,530 --> 00:18:49,040
אנחנו יכולים לראות שדווקא
כאן במשתנה זה

345
00:18:49,040 --> 00:18:51,345
בשמי, שבו יש לא
עדיין אותחל

346
00:18:51,345 --> 00:18:53,560
בעת הדגשה.

347
00:18:53,560 --> 00:18:57,070
אבל אנחנו יכולים לראות שיש לו כמה מספר
שלא היינו מצפים דווקא.

348
00:18:57,070 --> 00:18:57,620
>> זה בסדר.

349
00:18:57,620 --> 00:18:59,661
אל תדאגו בקשר לזה
כי יש לנו לא ממש

350
00:18:59,661 --> 00:19:04,970
אותחל מספר שעד ש
לדרוך על הקו הזה ואת הערך

351
00:19:04,970 --> 00:19:08,560
אני כבר אותחל לערך 1.

352
00:19:08,560 --> 00:19:11,400
אז כדי לראות שזה בעצם
המקרה, בואו לדרוך על.

353
00:19:11,400 --> 00:19:14,420
כעת אנו יכולים לראות ש
קו כבר הוצא להורג.

354
00:19:14,420 --> 00:19:17,000
וכעת אנו מדגישים
קו printf זה.

355
00:19:17,000 --> 00:19:22,230
>> ועכשיו אנחנו יכולים לראות כיצד הערכים שלנו
שלי ו -3 השתנו לאורך זמן.

356
00:19:22,230 --> 00:19:26,450
זה מאוד שימושי לעשות, למעשה,
הוא לדרוך על קווים שוב ושוב.

357
00:19:26,450 --> 00:19:30,480
ואתה יכול למצוא את מה שבעצם
קורה בתוך הלולאה שלך

358
00:19:30,480 --> 00:19:33,660
ומה קורה ל
משתנים הפנימיים של שללולאה

359
00:19:33,660 --> 00:19:39,200
שכביצוע תכנית
מתרחש צעד אחד בכל פעם.

360
00:19:39,200 --> 00:19:41,110
>> עכשיו, בשלב זה, אני
דלג מעל מספיק

361
00:19:41,110 --> 00:19:44,210
כי אני עכשיו בסוף התכנית שלי.

362
00:19:44,210 --> 00:19:46,980
אם אני דורך על זה, זה יהיה
למעשה תחדל ביצוע

363
00:19:46,980 --> 00:19:48,860
כפי שראינו בעבר.

364
00:19:48,860 --> 00:19:52,110
תן לי להפעיל מחדש את זה, שוב, כל כך
שאני יכול להצביע על משהו אחר,

365
00:19:52,110 --> 00:19:53,320
גם כן.

366
00:19:53,320 --> 00:19:55,350
>> במקרה זה, זה הוא
עכשיו שואל אותי, שוב,

367
00:19:55,350 --> 00:19:57,100
למספר, ש
אני, שוב, להיכנס.

368
00:19:57,100 --> 00:20:00,300
אבל הפעם, אני הולך להיכנס ב
מספר גדול יותר, כך שעבור לולאה

369
00:20:00,300 --> 00:20:02,540
יהיה לחזר יותר פעמים.

370
00:20:02,540 --> 00:20:06,090
במקרה זה, אני הולך
לזן ערך של 11.

371
00:20:06,090 --> 00:20:08,390
>> עכשיו שוב כי הייתי להגדיר
נקודת פריצה בקו 15,

372
00:20:08,390 --> 00:20:10,490
זה הולך לסמן קו ש.

373
00:20:10,490 --> 00:20:12,980
אנו יכולים לראות כי
מספר 11 הוא נכון

374
00:20:12,980 --> 00:20:15,560
מיוצג במשתנים המקומיים שלנו.

375
00:20:15,560 --> 00:20:22,460
דורכים על זה, אנחנו יכולים עכשיו
תראה מה קורה לשווי ההוגן שלי שלנו

376
00:20:22,460 --> 00:20:25,680
ככל שנתקדם בתוך זה ללולאה.

377
00:20:25,680 --> 00:20:31,960
הוא מקבל מוגדל כולנו זמן
להגיע לראש שללולאה.

378
00:20:31,960 --> 00:20:35,110
>> עכשיו אחד הדברים שאולי
להיות שימושי לעשות במהלך ביצוע

379
00:20:35,110 --> 00:20:40,490
של תכנית זו היא לי בעצם
לשנות את אמצע הזרם משתנה לראות

380
00:20:40,490 --> 00:20:42,450
מה קורה לתכנית שלי.

381
00:20:42,450 --> 00:20:46,540
במקרה זה, אני באמת יכול
לחץ לחיצה כפולה על הערך.

382
00:20:46,540 --> 00:20:48,040
שימו לב שהוא הופך להיות שדה טקסט.

383
00:20:48,040 --> 00:20:50,280
>> עכשיו אני יכול להיכנס שונה
מעריך לגמרי

384
00:20:50,280 --> 00:20:55,700
כדי לראות איך התכנית שלי מתנהגת
כששיניתי משתנה ש.

385
00:20:55,700 --> 00:20:59,560
עכשיו במקרה זה, משתנה
עכשיו אני מכיל את הערך 10.

386
00:20:59,560 --> 00:21:02,810
אבל התכנית היא עדיין
עצר בביצוע.

387
00:21:02,810 --> 00:21:07,610
כשאני דורך על, אני רואה ש
אני ערך, שנכנסתי כ10,

388
00:21:07,610 --> 00:21:12,170
לא גדול מהערך של num,
שמייד גורם ללולאה

389
00:21:12,170 --> 00:21:14,240
כדי לעצור את הביצוע.

390
00:21:14,240 --> 00:21:16,210
>> עכשיו זה לא רק
הסיבה שהיית

391
00:21:16,210 --> 00:21:19,450
רוצה לשנות את המשתנה במקום.

392
00:21:19,450 --> 00:21:22,210
ייתכן שבאמת רוצים
כדי לנסות לשנות את זה כל כך

393
00:21:22,210 --> 00:21:24,590
שתוכל להמשיך
ביצוע של לולאה

394
00:21:24,590 --> 00:21:27,370
או, כך שאתה יכול לשנות
ערך כלשהו לפני ש

395
00:21:27,370 --> 00:21:32,630
מגיע קבוצה מסוימת חלק מחשבון
שאתה עומד לבצע.

396
00:21:32,630 --> 00:21:36,210
>> אז עכשיו שאנחנו באמת לשנות את
ערך שלי כתכנית ביצוע,

397
00:21:36,210 --> 00:21:39,540
זה גרם ללולאה לפרוש
בטרם עת פתאום משום,, אני

398
00:21:39,540 --> 00:21:42,770
קרה להיות גדול מהערך
של num, כלומר שעבור לולאה

399
00:21:42,770 --> 00:21:45,410
אין עוד צורך בלהיות מוצא להורג.

400
00:21:45,410 --> 00:21:48,780
יתר על כן, זה קרה להיות
מקרה ששינינו את הערך של i

401
00:21:48,780 --> 00:21:53,270
כאשר הקו 17 היה מודגש,
שהייתה הנקודה בזמן

402
00:21:53,270 --> 00:21:56,280
כי לביצוע לולאה
למעשה נבדק.

403
00:21:56,280 --> 00:22:00,210
>> אם אני השתניתי הערך של
אני בקו שונה, אומר 19,

404
00:22:00,210 --> 00:22:03,360
היינו רואה שונה
התנהגות כי קו 19

405
00:22:03,360 --> 00:22:08,310
הוציא להורג לפני הלולאה
מצב היה הערכה מחודשת.

406
00:22:08,310 --> 00:22:11,900
עכשיו, בשלב זה, אני, שוב,
בסוף של תכנית זו.

407
00:22:11,900 --> 00:22:15,707
ואני יכול לתת לזה להמשיך ל
לאפשר התכנית שלי להפסיק באופן טבעי.

408
00:22:15,707 --> 00:22:18,290
אבל יש כמה דברים
שחשוב לקחת משם

409
00:22:18,290 --> 00:22:19,960
מהדיון הספציפי הזה.

410
00:22:19,960 --> 00:22:22,490
אתה צריך להעריך
ההנחות שלך

411
00:22:22,490 --> 00:22:24,710
על איך הקוד צריך להיות מתנהג.

412
00:22:24,710 --> 00:22:28,220
בכל פעם שאתה חושב שפיסה
של קוד אתה יודע שקורה לעבוד,

413
00:22:28,220 --> 00:22:30,940
שעשוי להיות דגל אדום ללכת
אחורה ולהעריך, ולהיות בטוח

414
00:22:30,940 --> 00:22:33,470
שההנחה שלך
איך הקוד שפועל

415
00:22:33,470 --> 00:22:38,290
הוא למעשה אמיתי לאופן בו הוא
בא לידי ביטוי בקוד המקור שלך.

416
00:22:38,290 --> 00:22:41,300
>> אבל עוד יותר לנקודה היה,
כאשר אנו משתמשים בהבאגים,

417
00:22:41,300 --> 00:22:43,920
אתה יכול לשים נקודות עצירה ב
קווים שונים של קוד,

418
00:22:43,920 --> 00:22:48,110
אשר יגרום להבאגים
להשהות ביצוע בכל אחד מהקווים האלה

419
00:22:48,110 --> 00:22:52,210
כך שאתה יכול להעריך את
זיכרון או אפילו לשנות אותו במקום.

420
00:22:52,210 --> 00:22:55,630
ושוב, זכור כי אתה יכול
ליצור נקודות עצירה מרובות, כך שאתה

421
00:22:55,630 --> 00:23:00,390
יכול גם לחדש את הביצוע, לדלג
על חלקים גדולים של קוד,

422
00:23:00,390 --> 00:23:04,790
וזה יהיה באופן אוטומטי להשהות
בנקודת ההפסקה הבאה.

423
00:23:04,790 --> 00:23:07,760
>> יש למעשה יותר מתקדם
תכונות של הבאגים, כמו גם.

424
00:23:07,760 --> 00:23:10,170
אבל נצטרך להפנות אותך
לכמה קטעי וידאו שלאחר מכן

425
00:23:10,170 --> 00:23:14,090
כדי באמת להפריד איך
כדי להשתמש בפונקציות מסוימות אלה.

426
00:23:14,090 --> 00:23:15,990
לעת עתה, תודה
הרבה מאוד לצפייה.

427
00:23:15,990 --> 00:23:18,080
וניפוי מזל טוב.