1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] טומי MACWILLIAM: בואו נדבר על לולאות, האחד הנפוץ

2
00:00:09,760 --> 00:00:13,380
תכנות בונה נראים לאורך CS50.

3
00:00:13,380 --> 00:00:15,570
אנו נשתמש בלולאות כאשר אנו רוצים לבצע

4
00:00:15,570 --> 00:00:17,200
משימה יותר מפעם אחת.

5
00:00:17,200 --> 00:00:20,700
לדוגמה, אנו עשויים רוצים להדפיס "היי" 100 פעמים או הדפסה

6
00:00:20,700 --> 00:00:22,700
את כל האותיות האלפבית.

7
00:00:22,700 --> 00:00:26,030
בשני המקרים הללו, יש לנו דבר אחד שאנחנו רוצים לעשות

8
00:00:26,030 --> 00:00:28,700
מספר רבות של פעמים, להדפיס משהו.

9
00:00:28,700 --> 00:00:31,970
עם זאת, מה שאנחנו מדפיסים בכל פעם שיכולה להשתנות.

10
00:00:31,970 --> 00:00:34,530
אז אנחנו יכולים לעשות משהו קצת שונה על כל אחד

11
00:00:34,530 --> 00:00:37,820
איטרציה, או לרוץ דרך, של הלולאה.

12
00:00:37,820 --> 00:00:41,280
נצטרך לראות שלושה סוגים שונים של לולאות ב-C, ואילו

13
00:00:41,280 --> 00:00:44,700
לולאות, ללולאות, ולעשות בזמן שלולאות.

14
00:00:44,700 --> 00:00:47,850
למרות ששלושה סוגים אלו של לולאות יש תחביר שונה,

15
00:00:47,850 --> 00:00:50,630
רעיונות שמאחוריהם הם אותו הדבר.

16
00:00:50,630 --> 00:00:53,930
אנחנו להגדיר מספר בלוק של קוד בתוך סוגריים מסולסלים,

17
00:00:53,930 --> 00:00:57,810
נקרא הגוף של הלולאה, שאנחנו רוצים להיות מוצאים להורג

18
00:00:57,810 --> 00:00:59,790
כמה וכמה פעמים.

19
00:00:59,790 --> 00:01:03,370
על ידי שינוי הערכים של משתנים המשמשים בגוף, אנחנו

20
00:01:03,370 --> 00:01:07,570
יכול לעשות הלולאה שלנו לעשות משהו שונה בכל פעם שהוא מפעיל.

21
00:01:07,570 --> 00:01:10,750
עם כל לולאה שאנחנו כותבים, אנחנו גם צריכים להחליט מתי

22
00:01:10,750 --> 00:01:12,400
לולאה תפסיק לרוץ.

23
00:01:12,400 --> 00:01:15,650
אם אנחנו לא עושים את זה, אז המחשב הנאמן שלנו ימשיך

24
00:01:15,650 --> 00:01:19,040
כדי להפעיל לולאה שעד שיהרגו את התכנית.

25
00:01:19,040 --> 00:01:22,490
בהתחלה, אנחנו יכולים להשתמש חוזרים n הזמנים

26
00:01:22,490 --> 00:01:24,600
לחסום כדי ליצור לולאה.

27
00:01:24,600 --> 00:01:28,200
את כל החלקים בתוך בלוק שאמר חזור 10

28
00:01:28,200 --> 00:01:30,130
יהיה לרוץ 10 פעמים.

29
00:01:30,130 --> 00:01:34,160
ואז, הייתי עובר לחלקים לאחר שהלולאה.

30
00:01:34,160 --> 00:01:38,140
אז המצב שלנו היה פשוט להפסיק, לחסום את זה כבר

31
00:01:38,140 --> 00:01:39,830
לרוץ 10 פעמים.

32
00:01:39,830 --> 00:01:43,900
אז בואו לשחזר את זה בג על מנת לגרד כדי להבטיח

33
00:01:43,900 --> 00:01:46,920
שהחלקים בתוך הבלוק החוזר מבוצעים

34
00:01:46,920 --> 00:01:51,180
בדיוק 10 פעמים, שריטה צריכה לעקוב אחר כל

35
00:01:51,180 --> 00:01:53,750
ביצוע של הגוש החוזר.

36
00:01:53,750 --> 00:01:56,790
כדי לעקוב אחר כמה פעמי גוף הלולאה שלנו כבר

37
00:01:56,790 --> 00:02:00,360
להורג, בואו ליצור משתנה בשם i.

38
00:02:00,360 --> 00:02:03,400
נתחיל אותי בשעת אפס, מאז לולאתנו

39
00:02:03,400 --> 00:02:04,650
לא הופעל עדיין.

40
00:02:10,009 --> 00:02:10,949
אישור

41
00:02:10,949 --> 00:02:15,560
כעת אנו נשתמש במילת מפתח בזמן להתחיל הלולאה שלנו.

42
00:02:20,100 --> 00:02:24,180
עכשיו אנחנו נצטרך להבין מתי הלולאה שלנו תפסיק, אבל

43
00:02:24,180 --> 00:02:26,730
בואו נעזוב את זה עכשיו ואז לחזור אליו.

44
00:02:30,970 --> 00:02:32,150
בסדר.

45
00:02:32,150 --> 00:02:35,260
בתוך הלולאה שלנו, בואו פשוט להדפיס את הודעה, כמו

46
00:02:35,260 --> 00:02:38,535
"היי". אנחנו יכולים להשתמש בפונקצית printf לזה.

47
00:02:48,400 --> 00:02:49,230
בסדר.

48
00:02:49,230 --> 00:02:54,210
אז עכשיו אנחנו נחגוג ושאיטרציה של גוף הלולאה יש

49
00:02:54,210 --> 00:02:55,750
הוצא להורג.

50
00:02:55,750 --> 00:03:00,320
אנחנו יכולים לעשות את זה על ידי הוספת 1 עד, או הגדלה, נגדנו

51
00:03:00,320 --> 00:03:01,740
משתנה, אני.

52
00:03:01,740 --> 00:03:09,180
כדי לעשות זאת, אנו יכולים לומר שאני שווה לפלוס 1, או יותר

53
00:03:09,180 --> 00:03:16,520
פשוט, אני פלוס פלוס.

54
00:03:16,520 --> 00:03:17,320
גדול.

55
00:03:17,320 --> 00:03:21,810
אז עכשיו אנחנו יכולים לראות שבכל פעם שהלולאה שלנו היא לרוץ,

56
00:03:21,810 --> 00:03:24,500
כמונה עולה באחד.

57
00:03:24,500 --> 00:03:29,410
אז אנחנו יודעים בדיוק כמה חזרות אנחנו פגשנו עד כה.

58
00:03:29,410 --> 00:03:31,630
לאחר איטרציה אחת מהלולאה, הערך שלנו

59
00:03:31,630 --> 00:03:34,270
שלי יהיה 1.

60
00:03:34,270 --> 00:03:37,460
לאחר שתי חזרות, אני יהיה 2.

61
00:03:37,460 --> 00:03:42,640
ולאחר 10 חזרות, אני יהיה 10.

62
00:03:42,640 --> 00:03:46,780
לכן, אם אנחנו רוצים להפעיל לולאה זה בדיוק 10 פעמים, ולאחר מכן

63
00:03:46,780 --> 00:03:49,240
זה מתי שאנחנו רוצים לעצור.

64
00:03:49,240 --> 00:03:53,860
אז אנחנו רוצים להריץ את זה לולאה בזמן שהוא פחות מ 10, ו

65
00:03:53,860 --> 00:03:57,630
זה בדיוק מה שאנחנו כותבים, ואילו אני

66
00:03:57,630 --> 00:04:02,450
הוא פחות מ 10.

67
00:04:02,450 --> 00:04:06,380
מצב זה נראה בדיוק כמו התנאים שבם השתמשו באם

68
00:04:06,380 --> 00:04:07,830
בלוקים אחרים.

69
00:04:07,830 --> 00:04:11,690
אחרי שהגוף של הלולאה שלנו כבר להורג, התכנית שלנו

70
00:04:11,690 --> 00:04:14,690
יקפוץ חזרה למצב הלולאות.

71
00:04:14,690 --> 00:04:17,290
אם התנאי הוא אמיתי, ואז הגוף של

72
00:04:17,290 --> 00:04:18,990
לולאה תהיה לרוץ שוב.

73
00:04:18,990 --> 00:04:22,190
אם המצב הוא כבר לא נכון, אז הלולאה שלנו לא תהיה

74
00:04:22,190 --> 00:04:25,700
לברוח יותר ויעבור לשורה הבאה של קוד

75
00:04:25,700 --> 00:04:27,876
מתחת הלולאה שלנו.

76
00:04:27,876 --> 00:04:28,550
בסדר.

77
00:04:28,550 --> 00:04:30,740
אז בואו נסתכל על סוג שני של

78
00:04:30,740 --> 00:04:33,000
לולאה, ללולאה.

79
00:04:33,000 --> 00:04:37,310
ליד מילת המפתח בזמן, בסוגריים, יש לנו דבר אחד,

80
00:04:37,310 --> 00:04:39,840
המצב שצריך להיות נכון עבור

81
00:04:39,840 --> 00:04:42,010
גוף לולאה שיופעל.

82
00:04:42,010 --> 00:04:45,440
זה אומר שאנחנו צריכים ליצור משתנים נגדנו מחוץ

83
00:04:45,440 --> 00:04:48,760
של הלולאה ולזכור כדי להגדיל אותו בשלב מסוים

84
00:04:48,760 --> 00:04:51,050
בתוך הלולאה.

85
00:04:51,050 --> 00:04:54,320
הכותרת עבורנו ללולאה, לעומת זאת, יש שלוש

86
00:04:54,320 --> 00:04:58,510
חלקים, שכל אחד מהם יהיו מופרדים בנקודת פסיק.

87
00:04:58,510 --> 00:05:01,950
בשליש הראשון שלנו, אנחנו יכולים להכריז על כל תשובה או עוזר

88
00:05:01,950 --> 00:05:05,000
משתנים שירצו להשתמש בלולאה שלנו.

89
00:05:05,000 --> 00:05:07,350
בפועל, זה יכול להיות ממש מועיל.

90
00:05:07,350 --> 00:05:10,590
אנחנו באמת לא צריכים את משתנה זה, אני, אחרי כמה הזמן שלנו

91
00:05:10,590 --> 00:05:13,650
לולאה יש להפעיל, כדי שבאמת לא היית צריך להכריז עליה

92
00:05:13,650 --> 00:05:15,810
מחוץ לעניינים.

93
00:05:15,810 --> 00:05:19,080
השליש השני יהיה המצב שחייבת להיות נכונים

94
00:05:19,080 --> 00:05:21,850
לגוף יבוצע שוב, בדיוק כמו

95
00:05:21,850 --> 00:05:23,330
בלולאה בזמננו.

96
00:05:23,330 --> 00:05:26,350
בשליש האחרון שלנו, אנחנו יכולים לרוץ הצהרה שתהיה

97
00:05:26,350 --> 00:05:30,270
יבוצע לאחר כל איטרציה של הלולאה, ולכן אין לנו

98
00:05:30,270 --> 00:05:32,710
כדי לבנות אותו בגוף הלולאה.

99
00:05:32,710 --> 00:05:38,390
אז בואו נכתוב ללולאה שסופרת את 5-1.

100
00:05:38,390 --> 00:05:41,790
נתחיל עם מילת המפתח.

101
00:05:41,790 --> 00:05:44,680
אנחנו יכולים ליצור משתנים דלפק ראשון, שאנו נזכה

102
00:05:44,680 --> 00:05:47,840
להגדיר זמן זה עד 5 מאז שאנחנו בספירה לאחור,

103
00:05:47,840 --> 00:05:50,110
אחרי פסיק.

104
00:05:50,110 --> 00:05:53,660
הבא הוא המצב שלנו, שאנחנו נחזור ל.

105
00:05:53,660 --> 00:05:57,540
שלישית, אנחנו רוצים הפחה המונה לאחר

106
00:05:57,540 --> 00:05:59,620
כל איטרציה של הלולאה.

107
00:05:59,620 --> 00:06:04,740
אז במקום לומר לי בתוספת פלוס, אנחנו נגיד לי מינוס מינוס.

108
00:06:04,740 --> 00:06:05,300
בסדר.

109
00:06:05,300 --> 00:06:09,490
אז אנחנו רוצים גוף הלולאה לרוץ בזמן שהוא עדיין

110
00:06:09,490 --> 00:06:11,960
גדול מ 0.

111
00:06:11,960 --> 00:06:16,160
בגוף הלולאה, בואו להדפיס את הערך של i.

112
00:06:16,160 --> 00:06:20,480
כדי לעשות זאת, תצטרך להשתמש בפונקצית printf, באמצעות% d

113
00:06:20,480 --> 00:06:21,650
מציין מיקום.

114
00:06:21,650 --> 00:06:24,820
זכור, שמציינים המיקום יוחלף

115
00:06:24,820 --> 00:06:27,040
ערך של i.

116
00:06:27,040 --> 00:06:32,060
לבסוף, בואו נוסיף הצהרה אחרינו ללולאה.

117
00:06:32,060 --> 00:06:35,850
כאשר אנו מפעילים לולאה זה, אני אתחיל בשעת 5,

118
00:06:35,850 --> 00:06:38,070
כך 5 יודפסו.

119
00:06:38,070 --> 00:06:42,000
ברגע שאני מקבל 0, מצב ההמשך, אני הוא

120
00:06:42,000 --> 00:06:44,450
גדול מ 0, כבר לא מחזיק.

121
00:06:44,450 --> 00:06:47,330
אז הלולאה שלנו תפסיק ביצוע, וניתן לראותו

122
00:06:47,330 --> 00:06:49,850
הצהרה אחרי הלולאה.

123
00:06:49,850 --> 00:06:51,340
אז בואו להפעיל את הקוד הזה.

124
00:06:51,340 --> 00:06:52,700
ראשית, אנחנו לקמפל

125
00:06:52,700 --> 00:06:56,460
countdown.c עם לעשות ספירה לאחור.

126
00:06:56,460 --> 00:06:59,320
עכשיו, אנחנו יכולים להפעיל את הקוד הזה עם. / ספירה לאחור.

127
00:07:02,340 --> 00:07:06,040
בשתי לולאות זמן וללולאות, המשך אותנו

128
00:07:06,040 --> 00:07:09,010
מצב ייבדק לפני הגוף

129
00:07:09,010 --> 00:07:10,960
של הלולאה מבוצעת.

130
00:07:10,960 --> 00:07:13,840
זה אומר שאם המצב שלנו הוא לא בתחילה

131
00:07:13,840 --> 00:07:18,100
אמיתי, ואז הגוף של הלולאה שלנו לעולם לא לרוץ.

132
00:07:18,100 --> 00:07:22,060
אז לפעמים כדאי לבדוק את המצב לאחר

133
00:07:22,060 --> 00:07:25,150
גוף של הלולאה ולא לפניו.

134
00:07:25,150 --> 00:07:28,270
אז בואו לכתוב לולאה להציג למשתמש למספר

135
00:07:28,270 --> 00:07:30,990
עד מספר חיובי מסופק.

136
00:07:30,990 --> 00:07:34,740
אם תשומות המשתמש מספר שלילי, אנחנו רוצים לשאול אותם

137
00:07:34,740 --> 00:07:36,260
למספר אחר.

138
00:07:36,260 --> 00:07:38,940
אז אנחנו רוצים שזה יהיה בתוך פקודה

139
00:07:38,940 --> 00:07:41,050
גוף את הלולאה.

140
00:07:41,050 --> 00:07:44,730
עם זאת, כאשר הלולאה לרוץ בפעם הראשונה, המשתמש

141
00:07:44,730 --> 00:07:46,750
לא נתן לנו את המספר עדיין.

142
00:07:46,750 --> 00:07:49,640
אז זה לא הגיוני כדי לבדוק אם זה חיובי.

143
00:07:49,640 --> 00:07:54,020
במקום זאת, אנחנו רוצים לבדוק את המספר אחרי שהגוף של

144
00:07:54,020 --> 00:07:55,720
הלולאה לרוץ.

145
00:07:55,720 --> 00:08:00,310
אנחנו יכולים לעשות את זה עם הלולאה לעשות בזמן.

146
00:08:00,310 --> 00:08:03,560
ראשית, תיצרו משתנה, n, שיקיים

147
00:08:03,560 --> 00:08:05,230
הקלט של המשתמש.

148
00:08:05,230 --> 00:08:09,960
כעת אנו נשתמש במילת מפתח לעשות, ואחרי סוגריים מסולסלים ש

149
00:08:09,960 --> 00:08:12,930
יתחיל את הגוף של הלולאה שלנו.

150
00:08:12,930 --> 00:08:16,230
בגוף, אנחנו יכולים לבקש ממשתמש מספר עם

151
00:08:16,230 --> 00:08:18,480
GetInt פונקציה.

152
00:08:18,480 --> 00:08:23,230
כעת, תרצו את הגוף של לולאה זה כדי להפעיל שוב אם

153
00:08:23,230 --> 00:08:28,370
המשתמש הקליד מספר שלילי, ולכן אנחנו אומרים בזמן n

154
00:08:28,370 --> 00:08:30,420
הוא פחות מ 0.

155
00:08:30,420 --> 00:08:33,140
שים לב לפסיק כאן אחרי הצהרת הזמן מה.

156
00:08:38,909 --> 00:08:40,679
אז בואו להפעיל את הקוד הזה.

157
00:08:40,679 --> 00:08:44,780
ראשית, אנחנו לקמפל את זה עם להפוך חיובי.

158
00:08:44,780 --> 00:08:49,340
עכשיו אנחנו יכולים להפעיל את התכנית עם. / חיובי.

159
00:08:49,340 --> 00:08:52,660
אם אנחנו נותנים תכנית זה מספר שלילי, כמו שלילי

160
00:08:52,660 --> 00:08:56,560
4, ואם כך נהיה אתבקש שוב מספר מאז

161
00:08:56,560 --> 00:09:00,490
מצב של לעשות את שלנו, תוך הלולאה הייתה נכונה.

162
00:09:00,490 --> 00:09:04,690
ברגע שאנו נותנים מספר חיובי, כמו 8, ולאחר מכן

163
00:09:04,690 --> 00:09:08,560
מצב של לעשות את שלנו, תוך לולאה כבר לא תהיה נכונה.

164
00:09:08,560 --> 00:09:12,080
אז הלולאה לא תבוצע שוב.

165
00:09:12,080 --> 00:09:15,290
וזה הכל לשלושה הסוגים של לולאות אנו נשתמש בג

166
00:09:15,290 --> 00:09:18,840
השמי הוא טומי, וזה CS50.