1
00:00:00,000 --> 00:00:07,170

2
00:00:07,170 --> 00:00:09,100
>> לוקאס פרייטס: אוקיי, אני מניח
עכשיו אנחנו בשידור חי.

3
00:00:09,100 --> 00:00:11,220
ברוכים הבאים לCS50 Supersection.

4
00:00:11,220 --> 00:00:12,880
אנחנו נוחים פחות.

5
00:00:12,880 --> 00:00:13,870
השם שלי הוא לוקאס פרייטס.

6
00:00:13,870 --> 00:00:16,230
אני אחד CS50 ראש TFS.

7
00:00:16,230 --> 00:00:17,523
זוהי לורן.

8
00:00:17,523 --> 00:00:19,002
>> LAUREN קרבאליו: היי, אני לורן.

9
00:00:19,002 --> 00:00:21,330
אני גם TF הראש לCS50.

10
00:00:21,330 --> 00:00:24,730
>> לוקאס פרייטס: היום אנחנו פשוט הולכים
כדי לתת סקירה של כל מה שאתה

11
00:00:24,730 --> 00:00:28,440
החבר 'ה שלמדו בשבוע אחד, בתקווה
כדי לתת לכם טוב

12
00:00:28,440 --> 00:00:32,580
הגיוני מה שאתה צריך לדעת
לבעיה מוגדרת אחת.

13
00:00:32,580 --> 00:00:34,120
>> רק כמה הודעות.

14
00:00:34,120 --> 00:00:36,490
קודם כל, שעתי עבודה.

15
00:00:36,490 --> 00:00:41,580
שעתי עבודה מתרחשות מיום השנייה
עד יום חמישי בבתים שונים ב

16
00:00:41,580 --> 00:00:43,450
אננברג בכל יום.

17
00:00:43,450 --> 00:00:46,680
הם משאב טוב מאוד בשבילך
החבר 'ה לבוא ולשאול שאלות, ו

18
00:00:46,680 --> 00:00:49,470
לדבר עם TFS, ואפילו מטבע
רעיונות עם סטודנטים אחרים.

19
00:00:49,470 --> 00:00:55,420
אז כדי להיות בטוח לשימוש במשאב ש
לטובתך.

20
00:00:55,420 --> 00:00:59,790
>> הדבר השני הוא
CS50 Appliance.

21
00:00:59,790 --> 00:01:01,390
ל[ לא ברור] שעבר

22
00:01:01,390 --> 00:01:04,180
אתם לא צריכים באמת
יש מכשיר.

23
00:01:04,180 --> 00:01:06,910
אתה פשוט עשית הכל ב
המחשב האישי שלכם.

24
00:01:06,910 --> 00:01:10,330
אבל לבעיה זו, בעצם יש לך
יש מכונת וירטואלית, כדי להיות

25
00:01:10,330 --> 00:01:14,680
הקפד להוריד את CS50
מכשיר ולהגדיר אותו.

26
00:01:14,680 --> 00:01:18,670
>> והדבר השלישי הוא כדי להיות בטוח
להתחיל את הבעיה בהקדם האפשרי להגדיר רק

27
00:01:18,670 --> 00:01:22,740
כי זה הרבה יותר קל למצוא
לעזור כשאתה ב

28
00:01:22,740 --> 00:01:23,730
תחילת השבוע.

29
00:01:23,730 --> 00:01:27,540
מכיוון שאנשים נוטים לחכות עד
בשנייה האחרונה כדי להתחיל את סט הבעיה,

30
00:01:27,540 --> 00:01:29,730
ואז אתה הולך לשעתי עבודה,
ויש הרבה אנשים.

31
00:01:29,730 --> 00:01:33,020
שבו אם אתה הולך ביום שני, אתה הולך
כדי לראות שאתה יכול לדבר עם TFS

32
00:01:33,020 --> 00:01:35,870
די הרבה במשך כל הלילה,
והם הולכים להיות יותר מ

33
00:01:35,870 --> 00:01:37,790
תשמח לעזור לך.

34
00:01:37,790 --> 00:01:40,720
>> LAUREN קרבאליו: האם אני יכול פשוט להפסיק
אתה רק שני אחת?

35
00:01:40,720 --> 00:01:43,330
האם כולם הצליחו להוריד
מכשיר CS50?

36
00:01:43,330 --> 00:01:44,255
האם אנשים ניסו?

37
00:01:44,255 --> 00:01:47,120
>> לוקאס פרייטס: כדי להוריד, על ידי
אגב, אתה יכול לקבל הוראות ב

38
00:01:47,120 --> 00:01:48,045
cs50.net/appliance.

39
00:01:48,045 --> 00:01:48,817
>> LAUREN קרבאליו: נכון.

40
00:01:48,817 --> 00:01:53,120
וזה לוקח קצת זמן לנו
מנהלים sys כדי להביא לך רישיון

41
00:01:53,120 --> 00:01:55,450
מפתח, כדי להירשם לקבלת
ניסיון ללא תשלום ראשון.

42
00:01:55,450 --> 00:01:59,080
בדרך זו תהיה לך אותו ל30 ימים,
ולאחר מכן לחכות למפתח הרישיון שלך

43
00:01:59,080 --> 00:02:02,650
שאמורה לתת לו
לך לשנה.

44
00:02:02,650 --> 00:02:04,100
>> לוקאס פרייטס: קודם כל,
בואו נדבר קצת

45
00:02:04,100 --> 00:02:06,180
על מכשיר CS50.

46
00:02:06,180 --> 00:02:10,770
CS50 המכשיר הוא למעשה וירטואלי
מכונה שאתה הולך

47
00:02:10,770 --> 00:02:15,040
להפעיל במחשב שלך שהוא
בעצם פועל מחשב אחר

48
00:02:15,040 --> 00:02:16,010
בתוך המחשב שלך.

49
00:02:16,010 --> 00:02:16,800
וזה די מגניב.

50
00:02:16,800 --> 00:02:19,420
ולמעשה הוא משמש בכל מקום.

51
00:02:19,420 --> 00:02:23,150
אנשים שלטק היו יודעים כי
זה משמש כל הזמן.

52
00:02:23,150 --> 00:02:23,250
אתה?

53
00:02:23,250 --> 00:02:26,200
יכול להיות מספר מחשבים
במכשיר אחד.

54
00:02:26,200 --> 00:02:27,760
>> בואו באמת נסתכל
במכשיר.

55
00:02:27,760 --> 00:02:32,680

56
00:02:32,680 --> 00:02:36,640
כשאתה הולך למכשיר לאחר
רישום, אתה הולך צריך

57
00:02:36,640 --> 00:02:42,035
לשים את השם שלך ולהיכנס להרווארד
כדי שנוכל לקבל את כל מה שאתה רשום.

58
00:02:42,035 --> 00:02:46,570
אתה הולך לראות בעצם רק
טפטים, ולאחר מכן לבית ולאשפה,

59
00:02:46,570 --> 00:02:48,980
ולאחר מכן הסמלים הקטנים האלה.

60
00:02:48,980 --> 00:02:51,930
שלושה סמלים זו הם למעשה ביותר
דברים חשובים שאתה יכול להיות ב

61
00:02:51,930 --> 00:02:53,000
המכשיר שלך.

62
00:02:53,000 --> 00:03:00,270
>> הראשון הוא gedit, שהוא טקסט
עורך, בדיוק כמו פנקס רשימות או כמו

63
00:03:00,270 --> 00:03:01,440
כל סוג של עורך טקסט.

64
00:03:01,440 --> 00:03:09,750
זה פשוט משהו שאנו משתמשים כדי לכתוב
קוד ולאחר מכן לעשות את הדברים עם זה.

65
00:03:09,750 --> 00:03:11,770
>> הדבר השני שאנו
יש כאן הוא Chrome.

66
00:03:11,770 --> 00:03:13,910
אז אם אתה צריך להשתמש באינטרנט
במכשיר, זה

67
00:03:13,910 --> 00:03:15,030
מה שאתה יכול להשתמש.

68
00:03:15,030 --> 00:03:22,000
>> והדבר השלישי הוא המסוף,
שהוא למעשה מתוק מאוד.

69
00:03:22,000 --> 00:03:26,420
אנשים בדרך כלל סוג של פחד מן
המסוף בגלל זה זה מאוד

70
00:03:26,420 --> 00:03:32,320
יישום ישן נושן שבו אתה
פשוט הקלד בעצם כל דבר עם

71
00:03:32,320 --> 00:03:32,940
המקלדת שלך.

72
00:03:32,940 --> 00:03:34,730
אין הרבה אינטראקציה
עם העכבר.

73
00:03:34,730 --> 00:03:39,780
אבל בעצם המסוף
עושה דברים טובים מאוד.

74
00:03:39,780 --> 00:03:43,990
>> קודם כל, בואו פשוט לעבור
חלק מפקודות שאתה

75
00:03:43,990 --> 00:03:48,765
ניתן להשתמש במסוף.

76
00:03:48,765 --> 00:03:51,995
>> LAUREN קרבאליו: ואל תהסס לעצור
אותנו אם יש לך שאלות.

77
00:03:51,995 --> 00:03:52,830
>> לוקאס פרייטס: כן.

78
00:03:52,830 --> 00:04:01,950
אז הפקודה הראשונה שיש לנו
למסוף הוא ls.

79
00:04:01,950 --> 00:04:06,450
ls בעצם אומר הכל רשימה, כל
קבצים וכל הדירקטורים,

80
00:04:06,450 --> 00:04:09,540
שיש לי במקום שאני בבית.

81
00:04:09,540 --> 00:04:15,200
אז אם אני עושה ls כאן, אני הולך לראות
כי יש לי כמה ספריות.

82
00:04:15,200 --> 00:04:18,670
יש לי על שולחן העבודה, הורדות,
היומנים, וVHOSTs.

83
00:04:18,670 --> 00:04:21,260
אלה הם בכחול משום שהם
כל הספריות.

84
00:04:21,260 --> 00:04:24,160
>> ואז יש לך כמה קבצים אחרים.

85
00:04:24,160 --> 00:04:27,840
יש לך כמו שלום וhello.c, אשר
הם רק קבצים, והם נמצאים ב

86
00:04:27,840 --> 00:04:28,910
צבעים שונים.

87
00:04:28,910 --> 00:04:33,960
אז זו פקודה חשובה מאוד פשוט
אתה יכול לראות מה הם הקבצים

88
00:04:33,960 --> 00:04:37,690
וספריות שיש לך
במדריך זה

89
00:04:37,690 --> 00:04:39,410
אתה נמצא בבית במסוף.

90
00:04:39,410 --> 00:04:44,580
כאשר אתה רואה jharvard מכשיר ו
אז הסמל הקטן שם,

91
00:04:44,580 --> 00:04:49,185
טילדה, זה רק אומר שזה
ספרייה שאתה נמצא באותו הרגע.

92
00:04:49,185 --> 00:04:52,970
>> LAUREN קרבאליו: אז הקלדת ls היא כמעט
כמו לחיצה על התיקייה

93
00:04:52,970 --> 00:04:57,380
המופיע שם, במופעיו
את כל התוכן שאתה

94
00:04:57,380 --> 00:04:58,886
בתיקייה זו.

95
00:04:58,886 --> 00:05:04,232
>> קהל: האם יש טקסט
לאחר hello.c?

96
00:05:04,232 --> 00:05:10,070
>> LAUREN קרבאליו: אה, אתה לא יכול
רואה את זה, בגלל שזה כחול.

97
00:05:10,070 --> 00:05:12,490
>> לוקאס פרייטס: זה אומר
יומנים וVHOSTs.

98
00:05:12,490 --> 00:05:14,450
>> LAUREN קרבאליו: אלה הם
רק תיקיות אחרות.

99
00:05:14,450 --> 00:05:16,890
אני מצטער, זה ממש קשה לראות.

100
00:05:16,890 --> 00:05:19,090
אולי אם כיבו את האורות?

101
00:05:19,090 --> 00:05:23,002
קולטון, האם אתה רוצה לנסות ו
למצוא את מתג האור?

102
00:05:23,002 --> 00:05:24,960
מצטער על זה.

103
00:05:24,960 --> 00:05:25,675
אני לא חושב על זה.

104
00:05:25,675 --> 00:05:27,340
>> לוקאס פרייטס: אבל זה בעצם -

105
00:05:27,340 --> 00:05:30,310
כן, אם אתה יכול -

106
00:05:30,310 --> 00:05:32,278
>> LAUREN קרבאליו: זום במסך שלך.

107
00:05:32,278 --> 00:05:34,738
>> לוקאס פרייטס: אני לא
יש תכונה זו.

108
00:05:34,738 --> 00:05:35,988
>> LAUREN קרבאליו: [לא ברור].

109
00:05:35,988 --> 00:05:39,528

110
00:05:39,528 --> 00:05:40,001
על אישור.

111
00:05:40,001 --> 00:05:44,270
ובכן, יש רק הרבה טבעי
אור בחדר הזה גם כן.

112
00:05:44,270 --> 00:05:48,726
>> לוקאס פרייטס: בואו פשוט להניח כי
יש שתי ספריות אחרות שם.

113
00:05:48,726 --> 00:05:49,780
>> LAUREN קרבאליו: רק לשאת איתנו.

114
00:05:49,780 --> 00:05:54,200
זהו החלק היחיד שאתה יהיה
מחפש במסוף.

115
00:05:54,200 --> 00:06:00,160
>> לוקאס פרייטס: הפקודה הבאה היא
בעצם אולי אתה רוצה לארגן

116
00:06:00,160 --> 00:06:01,080
הקבצים שלך -

117
00:06:01,080 --> 00:06:05,015
לדוגמא, כל קבצי C שלך באחד
ספרייה, אבל אין לך

118
00:06:05,015 --> 00:06:07,180
ספרייה רק ​​בשביל C קבצים עדיין.

119
00:06:07,180 --> 00:06:11,590
אתה בעצם יכול ליצור ספרייה
שימוש במסוף, כמו גם, שהוא

120
00:06:11,590 --> 00:06:15,670
אותו דבר כמו לחיצה ימנית
ואומר על תיקייה החדשה.

121
00:06:15,670 --> 00:06:20,640
הפקודה היא להפוך את הספרייה, אשר
הוא mkdir, אז בעצם "עושה" ו

122
00:06:20,640 --> 00:06:21,260
"ספרייה".

123
00:06:21,260 --> 00:06:22,680
>> ואז אתה יכול לשים
שמו של המדריך.

124
00:06:22,680 --> 00:06:32,490
נניח שאני רוצה שייקרא,
אני לא יודע, נניח pset1 עושה

125
00:06:32,490 --> 00:06:33,900
זה, אני פשוט יצרתי ספרייה.

126
00:06:33,900 --> 00:06:35,910
בואו רק לבדוק שזה שם.

127
00:06:35,910 --> 00:06:40,870
אז אם אני עושה ls, עכשיו אני רואה את יומנים, ו
אז pset1, ולאחר מכן VHOSTs.

128
00:06:40,870 --> 00:06:44,360
אז יש לי את הספרייה החדשה שם.

129
00:06:44,360 --> 00:06:46,670
>> ואז אחרי שיש לך ספרייה חדשה,
אולי אתה רוצה לנווט

130
00:06:46,670 --> 00:06:51,760
לתוך זה, אז את הפקודה הבאה cd זה,
אשר רק בעצם אומר ללכת

131
00:06:51,760 --> 00:06:53,400
ספרייה מסוימת.

132
00:06:53,400 --> 00:06:58,377
אז אם אני רוצה ללכת לpset1,
אני רק יכול לעשות pset1 cd.

133
00:06:58,377 --> 00:07:01,550
>> LAUREN קרבאליו: cd מייצג שינוי
ספרייה, [לא ברור] מסוגל

134
00:07:01,550 --> 00:07:02,230
תזכור את זה.

135
00:07:02,230 --> 00:07:05,460
>> לוקאס פרייטס: ועכשיו אתה רואה את זה
ולא רק שיש jharvard

136
00:07:05,460 --> 00:07:09,150
מכשיר, יש לי jharvard מכשיר,
ולאחר מכן pset1, כי זה מראה

137
00:07:09,150 --> 00:07:14,150
לי איפה אני נמצא במחשב הזה.

138
00:07:14,150 --> 00:07:17,510
>> עכשיו, אם אני רוצה לחזור ל
ספרייה שהייתה לפני זה, אני

139
00:07:17,510 --> 00:07:22,950
יכול לעשות נקודת נקודה cd, שרק אומרת ללכת
לספרייה שהייתי בעבר,

140
00:07:22,950 --> 00:07:26,290
כמו ההורה של זה
ספרייה, בעצם.

141
00:07:26,290 --> 00:07:30,460
ועכשיו אני רואה שאני
חזרה לjharvard.

142
00:07:30,460 --> 00:07:36,050
>> הדבר הבא שאני יכול לעשות את זה
הוא rm, שהוא להסיר את קובץ.

143
00:07:36,050 --> 00:07:39,590
לדוגמא, בואו נעשה ls הראשון
כדי לראות מה יש לי כאן.

144
00:07:39,590 --> 00:07:41,790
יש לי שלום וhello.c.

145
00:07:41,790 --> 00:07:43,780
נניח שאני רוצה להסיר אותם.

146
00:07:43,780 --> 00:07:48,280
אני יכול לעשות שלום rm.

147
00:07:48,280 --> 00:07:52,770
זה הולך לומר "להסיר את הקובץ רגיל
הלו? "ואני אומר" כן. "ועכשיו אם אני

148
00:07:52,770 --> 00:07:56,410
לעשות ls, אני רואה שזה
כבר לא שם.

149
00:07:56,410 --> 00:07:59,700
>> אם אני מנסה להשתמש בrm לספרייה,
אם כי, זה לא הולך

150
00:07:59,700 --> 00:08:00,800
כדי לאפשר לך לעשות שום דבר.

151
00:08:00,800 --> 00:08:02,960
זה הולך לומר, היי, אתה
לא ניתן להסיר במדריך.

152
00:08:02,960 --> 00:08:08,100
אז אנחנו צריכים לבוא זה אחר נקרא rmdir,
אשר רק בעצם אומר

153
00:08:08,100 --> 00:08:09,800
הסר את המדריך.

154
00:08:09,800 --> 00:08:12,842
אני יכול, למשל, להסיר pset1.

155
00:08:12,842 --> 00:08:15,770
ואם אני עושה ls, אני לא
יש לו יותר.

156
00:08:15,770 --> 00:08:18,430
>> כל שאלות על זה?

157
00:08:18,430 --> 00:08:20,200
לא?

158
00:08:20,200 --> 00:08:20,595
כן?

159
00:08:20,595 --> 00:08:23,954
>> קהל: האם זה חשוב שאתה עוזב
רווח אחרי - כל פעם שאתה

160
00:08:23,954 --> 00:08:26,540
מתחיל להקליד משהו ב?

161
00:08:26,540 --> 00:08:26,830
>> לוקאס פרייטס: כן.

162
00:08:26,830 --> 00:08:32,080
אם אני עושה כמו CD והספרייה,
אני צריך לשים את החלל.

163
00:08:32,080 --> 00:08:33,350
מה שטח אתה מדבר?

164
00:08:33,350 --> 00:08:34,979
>> LAUREN קרבאליו: המרחב שבין
cd ו[ לא ברור].

165
00:08:34,979 --> 00:08:37,710
>> לוקאס פרייטס: כן, יהיה לך ל
לשים את הרווחים בגלל cd הוא

166
00:08:37,710 --> 00:08:42,770
הפקודה, ולאחר מכן את המחרוזת הבאה ש
סוגך הוא בעצם הספרייה.

167
00:08:42,770 --> 00:08:45,020
אז זה כמו ויכוח.

168
00:08:45,020 --> 00:08:45,360
כן?

169
00:08:45,360 --> 00:08:47,952
>> קהל: כשאתה ברשימה, כל אלה
מדריכים שונים, נכון?

170
00:08:47,952 --> 00:08:50,125
>> לוקאס פרייטס: כן, הם
נמצא בספרייה.

171
00:08:50,125 --> 00:08:53,524
>> קהל: מה הוא ההבדלים
בין הספריות?

172
00:08:53,524 --> 00:08:55,390
>> לוקאס פרייטס: הם פשוט
תיקיות שונות.

173
00:08:55,390 --> 00:08:57,366
מדריך הוא תיקייה
במחשב שלך.

174
00:08:57,366 --> 00:08:58,120
>> קהל: פתח את תיקייה.

175
00:08:58,120 --> 00:09:00,140
>> לוקאס פרייטס: כן, זה
רק תיקייה פתוחה.

176
00:09:00,140 --> 00:09:03,400
>> LAUREN קרבאליו: הנה, אלה
כי הם בכחול הם בפועל

177
00:09:03,400 --> 00:09:07,107
ספריות שאתה יכול להיכנס ו
לאחר מכן רואה חבורה של דברים שהם

178
00:09:07,107 --> 00:09:10,248
בתוך כך, וזה מצער
כי אתה לא יכול באמת לקרוא

179
00:09:10,248 --> 00:09:11,290
אלה בכחול.

180
00:09:11,290 --> 00:09:16,166
ואת אלה בלבן הם רק קבצים
הנמצאים בספרייה הנוכחית.

181
00:09:16,166 --> 00:09:17,870
>> לוקאס פרייטס: אז ספריות
הן תיקיות.

182
00:09:17,870 --> 00:09:18,810
האחרים הם קבצים.

183
00:09:18,810 --> 00:09:22,810
>> קהל: מה הפקוד
כדי לאפס אותו או כדי לנקות אותה?

184
00:09:22,810 --> 00:09:23,650
לוקאס פרייטס: כדי לנקות?

185
00:09:23,650 --> 00:09:24,362
LAUREN קרבאליו: כדי לנקות?

186
00:09:24,362 --> 00:09:27,985
לוקאס פרייטס: אני חושב
זה "ברור". כן.

187
00:09:27,985 --> 00:09:32,370
אז אתה פשוט להקליד ברור אם
המסך שלך זה מבולגן מדי.

188
00:09:32,370 --> 00:09:33,700
יש עוד שאלות?

189
00:09:33,700 --> 00:09:36,720
ואתה תלמד חבורה של אחרים
פקודות רק באופן טבעי במהלך

190
00:09:36,720 --> 00:09:38,405
סמסטר בגלל שהם מאוד שימושיים.

191
00:09:38,405 --> 00:09:42,380

192
00:09:42,380 --> 00:09:46,155
>> אז עכשיו בואו נדבר על העריכה.

193
00:09:46,155 --> 00:09:51,510

194
00:09:51,510 --> 00:09:54,730
דברנו על pseudocode ו
קוד מקור וקוד יעד.

195
00:09:54,730 --> 00:09:59,020
ויש הרבה קודים, ואולי
אתם מבולבלים לגבי זה.

196
00:09:59,020 --> 00:10:02,190
בואו נדבר קצת על מה
קורה כאשר אתה כותב תכנית,

197
00:10:02,190 --> 00:10:06,620
ולך לעבד אותו, והוא הופך להיות
קובץ הפעלה.

198
00:10:06,620 --> 00:10:10,190
כל אלה הם מילות שאתם
בטח שמע, ואולי אתה לא

199
00:10:10,190 --> 00:10:12,130
ממש בטוח מה קורה.

200
00:10:12,130 --> 00:10:15,540
>> נניח, למשל, שאני רוצה
לכתוב תכנית שאומרת "הלו".

201
00:10:15,540 --> 00:10:19,670
הדבר הראשון שעולה במוחך הוא
אתה סוג של מנסה לחשוב על איך אתה

202
00:10:19,670 --> 00:10:23,000
הולך לעשות את זה בראש שלך, ו
אתה בטח חושב באנגלית או

203
00:10:23,000 --> 00:10:25,550
לשון אחרת, כמו טבעי
שפה, כנראה.

204
00:10:25,550 --> 00:10:28,770
ואז אתה חושב, טוב, אם אני רוצה,
למשל, לכתוב תכנית ש

205
00:10:28,770 --> 00:10:32,630
אומר "שלום", הייתי מתחיל תכנית,
אני נדפיס שלום, ואז אני

206
00:10:32,630 --> 00:10:35,270
יציאה מהתכנית.

207
00:10:35,270 --> 00:10:36,350
זה pseudocode.

208
00:10:36,350 --> 00:10:41,740
זה פשוט בעצם אתה מנסה
לבוא עם רצף של אירועים

209
00:10:41,740 --> 00:10:46,510
כי אתה הולך לעשות כדי להיות
מסוגל לכתוב תכנית.

210
00:10:46,510 --> 00:10:49,610
>> אז יש לך את קוד המקור, ו
קוד המקור לא חייב

211
00:10:49,610 --> 00:10:53,240
במיוחד להיות בג אנחנו מדברים
קוד המקור ב-C על כי זה

212
00:10:53,240 --> 00:10:56,760
השפה שאנחנו לומדים, אבל כמובן
קוד יכול להיות פחות או יותר בכל

213
00:10:56,760 --> 00:10:59,160
שפת תכנות שיש לך.

214
00:10:59,160 --> 00:11:01,230
מאוחר יותר בסמסטר, אתה הולך
ללמוד שפות אחרות.

215
00:11:01,230 --> 00:11:03,230
זה גם קוד מקור.

216
00:11:03,230 --> 00:11:07,380
>> לדוגמא, הנה, זה המקור שלי
קוד, ולאחר מכן אני כולל

217
00:11:07,380 --> 00:11:10,170
ספרייה, ואז אני מתחיל
ראשי, ולאחר מכן אני מדפיס.

218
00:11:10,170 --> 00:11:14,510
ולורה הולכת לדבר קצת
קצת על כל זה.

219
00:11:14,510 --> 00:11:16,190
אז זה קוד המקור.

220
00:11:16,190 --> 00:11:19,590
>> ומה הוא קוד האובייקט?

221
00:11:19,590 --> 00:11:22,500
האובייקט הוא חבורה של אפסים
ואלה, בעיקרון.

222
00:11:22,500 --> 00:11:27,680
מה שקורה הוא בהתחלה יש לך
pseudocode, שהוא כולו באנגלית.

223
00:11:27,680 --> 00:11:29,020
ואני מתכוון, אתה מבין את זה.

224
00:11:29,020 --> 00:11:31,260
כנראה החברים שלך מבינים
את זה, ורוב האנשים היית עושה

225
00:11:31,260 --> 00:11:32,560
להבין את הרעיון.

226
00:11:32,560 --> 00:11:36,770
אבל מחשבים הם באמת מטומטמים, והם
לא מבין אנגלית, כך שאתה

227
00:11:36,770 --> 00:11:41,320
יש לתרגם את זה למשהו,
בדרך כלל מתורגם לכמה

228
00:11:41,320 --> 00:11:42,460
שפת תכנות.

229
00:11:42,460 --> 00:11:46,840
>> ואתה יכול לחשוב על תכנות
שפה כמו כמו סוג של שפה

230
00:11:46,840 --> 00:11:50,970
שאתה אומר איך המחשב שלך
לדבר ולהבין.

231
00:11:50,970 --> 00:11:54,160
אתה בעצם אתה כותב משהו ב
שפה שבה שניכם ושלך

232
00:11:54,160 --> 00:11:55,190
מחשב מבין.

233
00:11:55,190 --> 00:11:56,470
זה קוד המקור.

234
00:11:56,470 --> 00:12:00,580
pseudocode צורה כל כך הולך למקור
קוד, זה תלוי בך.

235
00:12:00,580 --> 00:12:03,130
זה בעצם אתה עושה התכנית שלך.

236
00:12:03,130 --> 00:12:06,740
>> אבל הבעיה היא ש
עושה אפילו לא מחשב

237
00:12:06,740 --> 00:12:08,360
להבין את שפת תכנות.

238
00:12:08,360 --> 00:12:10,320
הוא לא מבין
קוד מקור בכלל.

239
00:12:10,320 --> 00:12:12,520
זה למעשה רק מבין
אפסים ואחדים.

240
00:12:12,520 --> 00:12:16,570
אז יש לנו הדבר מאוד קסם הזה שנקרא
מהדר, אשר בעצם הוא

241
00:12:16,570 --> 00:12:19,755
הולך לקבל בשם המקור שאתה
כתב בשפה גם לך

242
00:12:19,755 --> 00:12:25,320
והמחשב שלך לדבר, ועכשיו אתה
הולך להפוך שב

243
00:12:25,320 --> 00:12:26,270
אפסים ואחדים.

244
00:12:26,270 --> 00:12:30,860
אז בעצם מה שעושה הוא מהדר
הוא מקבל את קוד מקור, במקרה זה C,

245
00:12:30,860 --> 00:12:34,100
זה הולך להפוך אותו לאפסים
ואלה שהמחשב

246
00:12:34,100 --> 00:12:37,440
מבין ויכול לעשות
קובץ הפעלה מחוץ לזה.

247
00:12:37,440 --> 00:12:40,900
>> האם זה הגיוני?

248
00:12:40,900 --> 00:12:45,300
אתה רק יכול לחשוב עליו כמהדר
איזה מתורגמן שהוא

249
00:12:45,300 --> 00:12:50,280
עוזר לך תסביר למחשב
בדיוק מה שהוא אמור לעשות.

250
00:12:50,280 --> 00:12:52,310
>> אבל איך אני לקמפל.

251
00:12:52,310 --> 00:12:59,680
בואו נחזור למכשיר, ו
נניח שאני עושה את התוכנית.

252
00:12:59,680 --> 00:13:04,220
ראשית אני הולך ליצור ספרייה
כאן, ואני הולך לקרוא לזה

253
00:13:04,220 --> 00:13:11,130
"בפועל". עכשיו אני הולך לניווט
לספרייה, ולכן בפועל cd.

254
00:13:11,130 --> 00:13:13,210
עכשיו אני בתוך תרגול.

255
00:13:13,210 --> 00:13:16,860
>> עכשיו אני רוצה להתחיל gedit,
אז איך אני עושה את זה?

256
00:13:16,860 --> 00:13:21,920
אני יכול ללחוץ כאן, או פשוט שאני יכול
פשוטו כמשמעו, הקלד "gedit," וזה הולך

257
00:13:21,920 --> 00:13:24,290
כדי לפתוח לי.

258
00:13:24,290 --> 00:13:28,100
>> עכשיו אני הולך לסוג התכנית שלי, אז
בדיוק מה שכתבתי בשקופית.

259
00:13:28,100 --> 00:13:30,360
אני מכריז על ספרייה.

260
00:13:30,360 --> 00:13:35,440
אני עושה int ראשי, מבוטל.

261
00:13:35,440 --> 00:13:39,180
ועכשיו אני עושה printf, הלו.

262
00:13:39,180 --> 00:13:46,530

263
00:13:46,530 --> 00:13:50,170
עכשיו אני הולך לשמור את זה.

264
00:13:50,170 --> 00:13:53,665
תן לי לשים את זה לפועל, ו
אני הולך להתקשר לhello.c זה.

265
00:13:53,665 --> 00:13:57,710

266
00:13:57,710 --> 00:13:59,590
אז עכשיו זה יישמר.

267
00:13:59,590 --> 00:14:03,250
>> אם אני רוצה לקמפל את זה, אני בעצם
יכול לעשות את זה בשני מקומות שונים.

268
00:14:03,250 --> 00:14:07,090
אני יכול לעשות את זה בחלון מסוף,
אז זה אחד גדול, או שאתה יכול

269
00:14:07,090 --> 00:14:09,860
להשתמש gedit שלמעשה יש
חלון מסוף ממש כאן.

270
00:14:09,860 --> 00:14:17,890
אז אתה יכול מאוד נוח פשוט לעשות
הקוד שלך, ואז אתה יכול פשוט להקליד

271
00:14:17,890 --> 00:14:20,670
מה כאן, ולנסות לעבד אותו.

272
00:14:20,670 --> 00:14:23,450
>> אז איך אני יכול לקמפל קוד?

273
00:14:23,450 --> 00:14:27,495
הדרך הקלה ביותר שיש לנו היא על ידי שימוש
לעשות, שהיא פונקציה ש

274
00:14:27,495 --> 00:14:29,590
הוא בעצם הולך
לקמפל את הקוד שלך.

275
00:14:29,590 --> 00:14:34,170
אתה פשוט צריך להגיד לעשות שלום, ולכן
"לעשות" ואת השם של התכנית.

276
00:14:34,170 --> 00:14:35,420
>> אופס.

277
00:14:35,420 --> 00:14:38,250

278
00:14:38,250 --> 00:14:39,280
זה מביך.

279
00:14:39,280 --> 00:14:41,738
>> LAUREN קרבאליו: אתה יכול [לא ברור]?

280
00:14:41,738 --> 00:14:45,182

281
00:14:45,182 --> 00:14:45,990
>> לוקאס פרייטס: מצטער.

282
00:14:45,990 --> 00:14:49,960
אני לא לשמור אותו ב
מדריך נכון.

283
00:14:49,960 --> 00:14:52,130
בואו להתאמן, ועכשיו
לשמור אותו כhello.c.

284
00:14:52,130 --> 00:14:54,750
אני מצטער.

285
00:14:54,750 --> 00:14:56,250
עכשיו זה יישמר.

286
00:14:56,250 --> 00:14:58,300
>> תן לי רק לעשות ls ולהיות
בטוח שזה כאן.

287
00:14:58,300 --> 00:14:59,460
אוקיי, עכשיו זה כאן.

288
00:14:59,460 --> 00:15:05,930
אז עכשיו אם אני עושה לעשות שלום, זה יורק
הרבה דברים, אבל אז זה רק נותן לי

289
00:15:05,930 --> 00:15:08,870
לי עוד קו למסוף, אשר
אומר שזה היה מוצלח.

290
00:15:08,870 --> 00:15:13,160
אז עכשיו אם אני עושה ls שוב, אני ממש
לראות קובץ זה בירוק, המהווה את

291
00:15:13,160 --> 00:15:15,470
קובץ הפעלה.

292
00:15:15,470 --> 00:15:21,700
>> ואז אם אני רוצה להפעיל אותו, כל מה ש
אני צריך לעשות הוא לחתוך נקודת שלום.

293
00:15:21,700 --> 00:15:25,830
זה הולך להגיד שלום כאן, כל כך
זה בדיוק מה שאני שואל אותו.

294
00:15:25,830 --> 00:15:29,620
>> יש דרך אחת יותר של העריכה,
אשר באמצעות צלצול.

295
00:15:29,620 --> 00:15:35,740
צלצול הוא רק מהדר שיש לנו,
וזה קצת יותר מפורט כדי

296
00:15:35,740 --> 00:15:36,390
לעבד אותו.

297
00:15:36,390 --> 00:15:40,180
אבל זה עובד באותה מידה.

298
00:15:40,180 --> 00:15:46,810
אז אם אני עושה את הצלצול, ולאחר מכן-o, ולאחר מכן
השם שאני רוצה לתת ל

299
00:15:46,810 --> 00:15:50,400
את קובץ ההפעלה, אז בואו נגיד
"שלום". ולאחר מכן את הקובץ שאני רוצה

300
00:15:50,400 --> 00:15:53,460
לקמפל, hello.c.

301
00:15:53,460 --> 00:15:55,900
זה גם הולך לקמפל.

302
00:15:55,900 --> 00:15:59,020
ויש לך את הקובץ כאן, ו
אני רק יכול לבצע את זה גם כן.

303
00:15:59,020 --> 00:16:00,610
אז שניהם עובדים.

304
00:16:00,610 --> 00:16:03,270
>> האם זה הגיוני?

305
00:16:03,270 --> 00:16:06,020
כל שאלה?

306
00:16:06,020 --> 00:16:09,020
>> קהל: אתה יכול להגדיל את התצוגה
בקצת?

307
00:16:09,020 --> 00:16:09,913
>> לוקאס פרייטס: סליחה?

308
00:16:09,913 --> 00:16:11,135
>> קהל: הגדלה?

309
00:16:11,135 --> 00:16:13,310
>> LAUREN קרבאליו: אני חושב שאתה
רק יכול לפקד בתוספת.

310
00:16:13,310 --> 00:16:14,295
>> לוקאס פרייטס: פיקוד מה?

311
00:16:14,295 --> 00:16:16,060
>> LAUREN קרבאליו: פיקוד בתוספת.

312
00:16:16,060 --> 00:16:17,000
>> לוקאס פרייטס: מס

313
00:16:17,000 --> 00:16:19,350
>> LAUREN קרבאליו: אה, זה לא
הולך לעבודה, כי -

314
00:16:19,350 --> 00:16:25,548
זה בגלל שאנחנו להגדיר את הרזולוציה
לדבר הזה.

315
00:16:25,548 --> 00:16:27,450
>> לוקאס פרייטס: אני לא
חושב שאנחנו יכולים להתמקד פנימה

316
00:16:27,450 --> 00:16:30,852

317
00:16:30,852 --> 00:16:34,130
כן, אנחנו לא יכולים להתקרב.

318
00:16:34,130 --> 00:16:36,200
האם יש לך עוד שאלה?

319
00:16:36,200 --> 00:16:36,680
סליחה.

320
00:16:36,680 --> 00:16:39,170
>> קהל: אתה יכול לחזור על צלצול?

321
00:16:39,170 --> 00:16:40,630
>> לוקאס פרייטס: הצלצול?

322
00:16:40,630 --> 00:16:44,190
צלצול הוא אותו הדבר כמו איפור, אבל
הבדל הוא שקודם אני הולך

323
00:16:44,190 --> 00:16:48,460
לכתוב צלצול, שהיא פקודה,
אז אני הולך לעשות -0, כל, שהוא

324
00:16:48,460 --> 00:16:51,680
בדיוק מה שאנחנו הולכים
ללמוד מאוחר יותר כדגל.

325
00:16:51,680 --> 00:16:54,440
אז אחשוב רק שאתה תמיד
צריך לשים-o.

326
00:16:54,440 --> 00:16:58,690
>> ולאחר מכן ראשון, אתה הולך לשים
את שמו של קובץ ההפעלה,

327
00:16:58,690 --> 00:17:00,680
בעצם הקובץ שאתה
הולך ליצור.

328
00:17:00,680 --> 00:17:06,430
אז אני יכול לומר, למשל, וhello2
לאחר מכן את הקובץ שאני רוצה לקמפל,

329
00:17:06,430 --> 00:17:07,800
המהווה את קובץ c..

330
00:17:07,800 --> 00:17:09,240
אז זה hello.c.

331
00:17:09,240 --> 00:17:10,871
האם זה הגיוני?

332
00:17:10,871 --> 00:17:12,635
>> קהל: שלום מה?

333
00:17:12,635 --> 00:17:13,076
מה זה?

334
00:17:13,076 --> 00:17:15,960
>> לוקאס פרייטס: Hello.c.

335
00:17:15,960 --> 00:17:19,849
ואם אני מתרגם אותו, ואם
אל ls, אני גם יש לי

336
00:17:19,849 --> 00:17:22,010
hello2 שאני רק הידור.

337
00:17:22,010 --> 00:17:26,339
ואם אני מנסה להפעיל אותו, זה הולך
לעשות בדיוק את אותו הדבר כמו שלום,

338
00:17:26,339 --> 00:17:27,089
פשוט להדפיס את שלום.

339
00:17:27,089 --> 00:17:31,660
>> קהל: איך לאיפור
אתה יכול לשים את hello.c אחרי?

340
00:17:31,660 --> 00:17:33,880
>> לוקאס פרייטס: באיפור, אתה
לא צריך לשים. ג.

341
00:17:33,880 --> 00:17:36,140
באיפור, אתה פשוט אומר
שם של התכנית.

342
00:17:36,140 --> 00:17:37,750
אתה לא צריך לומר. ג.

343
00:17:37,750 --> 00:17:39,020
אבל לצלצול, אתה צריך.

344
00:17:39,020 --> 00:17:44,040
>> קהל: עם צלצול אתה גם
צריך להוסיף [לא ברור]

345
00:17:44,040 --> 00:17:44,480
>> LAUREN קרבאליו: כן.

346
00:17:44,480 --> 00:17:46,180
אז יש לך גם לספרייה.

347
00:17:46,180 --> 00:17:51,170
>> לוקאס פרייטס: כן, זה משהו
אנחנו הולכים להשתמש מאוחר יותר.

348
00:17:51,170 --> 00:17:54,850
זה נקרא קישור, ואני חושב שאנחנו
הולך לדבר על זה מאוחר יותר.

349
00:17:54,850 --> 00:17:55,930
שאלה נוספת?

350
00:17:55,930 --> 00:17:59,927
>> קהל: האם אתה לשים
צלצול לוכסן נקודה?

351
00:17:59,927 --> 00:18:01,060
>> לוקאס פרייטס: מס

352
00:18:01,060 --> 00:18:06,040
לוכסן הנקודה הוא רק כדי לפתוח
את קובץ ההפעלה.

353
00:18:06,040 --> 00:18:09,440
אז צלצול, אתה פשוט לכתוב "צלצול", ו
אז אם אתה רוצה לפתוח את

354
00:18:09,440 --> 00:18:12,640
קובץ הפעלה שאתה פשוט
הידור, אז אתה מנקדים

355
00:18:12,640 --> 00:18:13,780
סלאש את השם.

356
00:18:13,780 --> 00:18:15,100
האם זה הגיוני?

357
00:18:15,100 --> 00:18:18,635

358
00:18:18,635 --> 00:18:22,435
>> קהל: אם היית רק שינוי
[לא ברור] לשלום עולם, אתה

359
00:18:22,435 --> 00:18:23,870
יש להדר מחדש את זה?

360
00:18:23,870 --> 00:18:24,750
>> לוקאס פרייטס: כן.

361
00:18:24,750 --> 00:18:36,650
אם אני רוצה לומר, למשל, "שלום
שם, "אני יכול פשוט לשמור אותו עכשיו, ואני

362
00:18:36,650 --> 00:18:38,020
רק לקמפל אותו שוב.

363
00:18:38,020 --> 00:18:41,910
אז תן לי לעשות איפור שלום.

364
00:18:41,910 --> 00:18:48,490
ואם אני עושה שלום, זה הולך
אומר "שלום לך." הגיוני?

365
00:18:48,490 --> 00:18:50,280
יש עוד שאלות?

366
00:18:50,280 --> 00:18:54,384
>> קהל: האם יש לך לכלול את
I / O הסטנדרטי כדי לתאם את העבודה?

367
00:18:54,384 --> 00:18:55,480
>> לוקאס פרייטס: כן.

368
00:18:55,480 --> 00:18:58,050
I / O הסטנדרטי הוא בעצם
הספרייה שיש

369
00:18:58,050 --> 00:19:00,050
יישום לprintf.

370
00:19:00,050 --> 00:19:03,450

371
00:19:03,450 --> 00:19:06,910
אז זה דבר נכון על
העליון כולל stdio.

372
00:19:06,910 --> 00:19:11,920
כי הוא כולל ספרייה ה
בעצם יש חבורה של שונה

373
00:19:11,920 --> 00:19:13,260
כלים שאתה יכול להשתמש.

374
00:19:13,260 --> 00:19:13,480
אחד?

375
00:19:13,480 --> 00:19:17,820
מהם הוא printf שהוא פונקציה
כי בעצם הדפסים

376
00:19:17,820 --> 00:19:21,290
הודעות על גבי המסך.

377
00:19:21,290 --> 00:19:23,200
>> יש עוד שאלות?

378
00:19:23,200 --> 00:19:24,700
לא?

379
00:19:24,700 --> 00:19:25,060
על אישור.

380
00:19:25,060 --> 00:19:31,620
אז עכשיו בואו נדבר על -

381
00:19:31,620 --> 00:19:33,948
>> LAUREN קרבאליו: בואו פשוט
ללכת למדריך הסגנון.

382
00:19:33,948 --> 00:19:35,896
האם אתה רוצה רק למצוא אותו כאן?

383
00:19:35,896 --> 00:19:37,880
>> לוקאס פרייטס: אז אנחנו הולכים
לדבר על סגנון.

384
00:19:37,880 --> 00:19:47,006

385
00:19:47,006 --> 00:19:50,430
>> LAUREN קרבאליו: אה, דוד
לא סיים.

386
00:19:50,430 --> 00:19:51,230
על אישור.

387
00:19:51,230 --> 00:19:53,870
למה אנחנו לא חוזרים ל
סגנון ממש בסוף?

388
00:19:53,870 --> 00:19:56,220
זה בעצם עודכן
כמו שאנחנו מדברים.

389
00:19:56,220 --> 00:19:56,810
>> לוקאס פרייטס: כן.

390
00:19:56,810 --> 00:19:58,300
בואו דרכו של דוד לכדי לסיים את זה.

391
00:19:58,300 --> 00:20:07,150

392
00:20:07,150 --> 00:20:08,600
>> LAUREN קרבאליו: Can
אנחנו עוברים בעצם?

393
00:20:08,600 --> 00:20:14,920

394
00:20:14,920 --> 00:20:17,200
>> אז אני מקווה שכולם היה
נהנה מסריטות.

395
00:20:17,200 --> 00:20:21,950
למרבה הצער, זה הזמן
להתרחק מזה -

396
00:20:21,950 --> 00:20:25,280
למרבה הצער זה זמן להתרחק
מהלוקים בתכנות האלה די

397
00:20:25,280 --> 00:20:28,530
לג אבל למזלנו, כל
תכנות בונה שיש לך

398
00:20:28,530 --> 00:20:32,370
עובד עם בגרד הם
ישירות לתרגום ל-C, ואנחנו

399
00:20:32,370 --> 00:20:35,130
הולך להתחיל ללמוד על
חלק מהם עכשיו.

400
00:20:35,130 --> 00:20:39,200
השיחה הראשונה הבה על תנאים
בביטויים בוליאנית.

401
00:20:39,200 --> 00:20:41,944
>> זה פועל על מילואים
כוח הסוללה.

402
00:20:41,944 --> 00:20:43,912
>> לוקאס פרייטס: איך הוא
שלא עובד?

403
00:20:43,912 --> 00:20:47,850

404
00:20:47,850 --> 00:20:48,010
על אישור.

405
00:20:48,010 --> 00:20:50,256
אתה הולך לשם, אני הולך לקבל -

406
00:20:50,256 --> 00:20:53,700

407
00:20:53,700 --> 00:20:57,390
>> LAUREN קרבאליו: אז תנאים
חשוב משום שהם מאפשרים לנו

408
00:20:57,390 --> 00:21:00,588
להציג את ההיגיון בתוכניות שלנו.

409
00:21:00,588 --> 00:21:04,620
הנה דוגמא של מצב
בתוך תכנית C.

410
00:21:04,620 --> 00:21:06,130
בואו שימו לב איך זה -

411
00:21:06,130 --> 00:21:11,324
אז לחסום את המצב הזה כאן, זה
שמירה על printf לא תבצע

412
00:21:11,324 --> 00:21:14,860
אלא אם כן המצב בתוך
סוגריים, n גדול מ 0,

413
00:21:14,860 --> 00:21:16,800
מעריך לנכון.

414
00:21:16,800 --> 00:21:20,780
>> עכשיו, כל התנאים בתוך f
הצהרות הן ביטויים בוליאנית,

415
00:21:20,780 --> 00:21:22,970
מה שאומר שיש
רק שתי אפשרויות.

416
00:21:22,970 --> 00:21:26,856
הם יכולים גם להעריך לנכון,
או שהם יכולים להעריך לשווא.

417
00:21:26,856 --> 00:21:33,174
אז הנה, אז זה הגיוני, נכון? n
גדול מ -0, ופירוש דבר הוא חיובי

418
00:21:33,174 --> 00:21:41,160
מספר, מה שאומר שהוא יודפס
מתוך "בחרת מספר חיובי."

419
00:21:41,160 --> 00:21:44,630
>> יש המון ביטויים בוליאנית
כי יכול להיווצר המצב עם

420
00:21:44,630 --> 00:21:47,190
שמירה על init.

421
00:21:47,190 --> 00:21:48,520
יש לנו פחות מ.

422
00:21:48,520 --> 00:21:50,950
זה פחות או שווה ל.

423
00:21:50,950 --> 00:21:52,200
זה [לא ברור] פשוט מצחיק.

424
00:21:52,200 --> 00:21:54,800

425
00:21:54,800 --> 00:22:01,630
אם אתה רוצה printf להתרחש אם זה
גדול או שווה ל -0, ולאחר מכן

426
00:22:01,630 --> 00:22:03,345
היית בוחר את זה.

427
00:22:03,345 --> 00:22:07,750
אז שווה פשוט מצרף תקין
לאחר יותר משלט.

428
00:22:07,750 --> 00:22:12,030
>> שווה שווה, וזה שונה מ
רק סימן אחד שווה, שווה שווה

429
00:22:12,030 --> 00:22:16,430
בעצם אומר שכל מה ששל על
צד שמאל של זה הוא אותו הדבר כמו

430
00:22:16,430 --> 00:22:20,610
מה יש בצד ימין של זה
שבו סימן אחד שווה הוא מה?

431
00:22:20,610 --> 00:22:23,333
מה הוא רק סימן אחד שווה?

432
00:22:23,333 --> 00:22:24,275
הקצאה.

433
00:22:24,275 --> 00:22:25,985
>> לוקאס פרייטס: מי אמר את זה?

434
00:22:25,985 --> 00:22:27,170
האם זה ממתק?

435
00:22:27,170 --> 00:22:27,370
הו, לא.

436
00:22:27,370 --> 00:22:27,885
סליחה.

437
00:22:27,885 --> 00:22:28,210
סליחה.

438
00:22:28,210 --> 00:22:30,400
שניכם לקבל ממתקים.

439
00:22:30,400 --> 00:22:31,510
אה, אוקיי!

440
00:22:31,510 --> 00:22:33,046
שלושה אנשים מקבלים ממתקים!

441
00:22:33,046 --> 00:22:37,393
>> LAUREN קרבאליו: אז זה אחד ממש כאן
הוא מפעילת המפץ הקודמת

442
00:22:37,393 --> 00:22:40,240
סימן השוויון, אז זה
לא שווה.

443
00:22:40,240 --> 00:22:46,560
אז אם זה היה בתוך המצב שלי,
את גופתו של המצב היית

444
00:22:46,560 --> 00:22:49,615
לבצע רק אם כל מה ששל ב
השמאל הוא לא אותו הדבר כמו

445
00:22:49,615 --> 00:22:52,540
מה בצד הימין.

446
00:22:52,540 --> 00:22:57,680
>> אני יכול גם להיות פשוט
סימן קריאה.

447
00:22:57,680 --> 00:23:01,250
למעשה אנו רואים בתכונה
החלק איך זה יהיה בשימוש.

448
00:23:01,250 --> 00:23:03,830
>> לוקאס פרייטס: יש שאלות?

449
00:23:03,830 --> 00:23:06,450
לא?

450
00:23:06,450 --> 00:23:10,460
>> LAUREN קרבאליו: אנחנו יכולים לשלב הבאים
ביטויים בוליאנית לבנות יותר

451
00:23:10,460 --> 00:23:12,500
משפטי תנאי מורכבים.

452
00:23:12,500 --> 00:23:19,680
אז הנה, אם כל מה ששל בצד השמאל
צד של הסורגים כפולים או

453
00:23:19,680 --> 00:23:23,160
כל מה שהוא בצד ימין של
הברים כפולים ערך TRUE,

454
00:23:23,160 --> 00:23:25,700
אז להדפיס את לא חוקי.

455
00:23:25,700 --> 00:23:29,503
וכאן למטה אז, אם כל מה ששל
בצד שמאל של שני

456
00:23:29,503 --> 00:23:33,480
סימן חיבור וכל מה של בצד הימין
צד של שני תווים האמפרסנד

457
00:23:33,480 --> 00:23:37,470
מעריך לנכון, אז
אנחנו להדפיס בתוקף.

458
00:23:37,470 --> 00:23:42,195
הברים כפולים נקראים הלוגי
או מפעיל סימן החיבור הכפול הם

459
00:23:42,195 --> 00:23:44,190
נקרא אופרטור הלוגי AND.

460
00:23:44,190 --> 00:23:44,648
כן?

461
00:23:44,648 --> 00:23:47,850
>> קהל: האם אלה רק
אותיות הקטנות l's?

462
00:23:47,850 --> 00:23:48,620
>> LAUREN קרבאליו: לא.

463
00:23:48,620 --> 00:23:50,890
הם בעצם -

464
00:23:50,890 --> 00:23:55,134
אתה יודע את תגובת הנגד, כמו
מעל מקש Return שלך?

465
00:23:55,134 --> 00:23:56,585
האם אתה רואה את זה?

466
00:23:56,585 --> 00:23:57,940
>> לוקאס פרייטס: זה בעצם בר.

467
00:23:57,940 --> 00:24:02,100
>> LAUREN קרבאליו: זה בעצם
רק שני ברים.

468
00:24:02,100 --> 00:24:05,724
>> קהל: אתה יכול להשתמש
שווה שווה למיתרים?

469
00:24:05,724 --> 00:24:07,000
>> לוקאס פרייטס: מס

470
00:24:07,000 --> 00:24:09,130
אנחנו הולכים ללמוד מאוחר יותר
משהו על זה.

471
00:24:09,130 --> 00:24:10,735
>> LAUREN קרבאליו: יש פונקציה
כי אתה יכול להשתמש.

472
00:24:10,735 --> 00:24:12,644
אבל אין לך
לדאוג כי עדיין.

473
00:24:12,644 --> 00:24:15,530

474
00:24:15,530 --> 00:24:18,270
>> מה אם אני נותן בתכנית זו
המספר 5?

475
00:24:18,270 --> 00:24:20,850
מה להדפיס?

476
00:24:20,850 --> 00:24:22,100
>> קהל: [לא ברור]

477
00:24:22,100 --> 00:24:27,780

478
00:24:27,780 --> 00:24:28,275
בתוקף.

479
00:24:28,275 --> 00:24:29,770
>> LAUREN קרבאליו: תקף?

480
00:24:29,770 --> 00:24:30,135
כן.

481
00:24:30,135 --> 00:24:34,092
אני לא יודע מי קיבלתי את זה.

482
00:24:34,092 --> 00:24:35,036
>> [שחוק]

483
00:24:35,036 --> 00:24:37,990
>> LAUREN קרבאליו: זה סוג
מפחיד [לא ברור].

484
00:24:37,990 --> 00:24:40,900
>> קהל: אז כפול ו,
זה רק אומר וש?

485
00:24:40,900 --> 00:24:41,740
>> LAUREN קרבאליו: כן.

486
00:24:41,740 --> 00:24:46,160
אז מספר 5 הוא גם גדול יותר
מ 0 ופחות מ 100.

487
00:24:46,160 --> 00:24:48,970
>> קהל: למה שזה יהיה אחד?

488
00:24:48,970 --> 00:24:51,350
>> LAUREN קרבאליו: אמפרסנד אחת הוא
בעצם משהו אחר, וזה

489
00:24:51,350 --> 00:24:53,390
מפעיל ביטים, אשר תוכל
ללמוד על מאוחר יותר.

490
00:24:53,390 --> 00:24:58,250
אבל זה משהו שבאמת עובד
עם הביטים של מספר נתון.

491
00:24:58,250 --> 00:25:00,872
>> לוקאס פרייטס: רק חושב שהם עושים לא
צריך לדאוג זה לעת עתה.

492
00:25:00,872 --> 00:25:04,590
>> LAUREN קרבאליו: אני חושב שזה כנראה
מגיע בשבוע הבא.

493
00:25:04,590 --> 00:25:06,420
>> לוקאס פרייטס: יש עוד שאלות?

494
00:25:06,420 --> 00:25:07,990
לא?

495
00:25:07,990 --> 00:25:12,480
>> LAUREN קרבאליו: אז שראינו כי
זה לחסום יכול לעמוד לבד, אבל זה יכול

496
00:25:12,480 --> 00:25:15,370
גם להיות יחד עם ועוד בלוק.

497
00:25:15,370 --> 00:25:18,880
אז במקרה הזה, אם n הוא גדול יותר מאשר
0, אנחנו הולכים להדפיס את "אתה

498
00:25:18,880 --> 00:25:23,855
הרים מספר חיובי. "אחר, כלומר,
אם זה הוא 0 או אם זה פחות

499
00:25:23,855 --> 00:25:27,170
מ 0, אנחנו הולכים להדפיס,
"אתה הרים מספר שלילי".

500
00:25:27,170 --> 00:25:30,390
>> הדבר המעניין כאן הוא כי אלה
הם בלעדיים של כל אחד אחר.

501
00:25:30,390 --> 00:25:33,940
מעולם לא הולך להיות מקרה
שבו זה ואת זה

502
00:25:33,940 --> 00:25:35,544
יכול גם להדפיס.

503
00:25:35,544 --> 00:25:38,190

504
00:25:38,190 --> 00:25:41,030
>> אני בטוח שאתה עבד עם אם / אחר
תיבה בגרד, כך זה צריך להיות

505
00:25:41,030 --> 00:25:42,392
די מוכר.

506
00:25:42,392 --> 00:25:42,874
כן?

507
00:25:42,874 --> 00:25:48,522
>> קהל: האם אנחנו צריכים את המרחב שבין
n int שווה GetInt אז חלל ב

508
00:25:48,522 --> 00:25:49,460
אם הצהרה?

509
00:25:49,460 --> 00:25:51,565
כמו שאנו משתמשים בקו [לא ברור]

510
00:25:51,565 --> 00:25:52,790
>> LAUREN קרבאליו: אה, החלל לכאן?

511
00:25:52,790 --> 00:25:56,742
>> קהל: כמו זה, אבל
אתה להכפיל חלל.

512
00:25:56,742 --> 00:25:58,718
לא, לעלות.

513
00:25:58,718 --> 00:25:59,706
לעלות.

514
00:25:59,706 --> 00:26:00,610
>> לוקאס פרייטס: רק את הקו?

515
00:26:00,610 --> 00:26:01,140
>> קהל: כן.

516
00:26:01,140 --> 00:26:02,870
>> לוקאס פרייטס: רק השורה הריקה?

517
00:26:02,870 --> 00:26:03,270
>> קהל: כן.

518
00:26:03,270 --> 00:26:04,070
>> LAUREN קרבאליו: שורה ריקה?

519
00:26:04,070 --> 00:26:04,470
לא.

520
00:26:04,470 --> 00:26:06,320
זה פשוט דבר סגנוני.

521
00:26:06,320 --> 00:26:09,360
>> לוקאס פרייטס: זה בדיוק כמו לפעמים
אתה פשוט לדלג על כמה שורות כל כך

522
00:26:09,360 --> 00:26:12,330
שהקוד לא נראה כמו
גוש טקסט ענק.

523
00:26:12,330 --> 00:26:15,800
>> LAUREN קרבאליו: אני חושב שמה שקרה
היה שהיו לנו תגובה כאן, אבל אני

524
00:26:15,800 --> 00:26:18,220
הוצאתי אותו, כך שאתה חבר 'ה תצטרך
לחשוב על הקוד ולא

525
00:26:18,220 --> 00:26:19,920
מאשר רק לקרוא את התגובה שלי.

526
00:26:19,920 --> 00:26:24,170
באופן כללי, לא יהיה מרווח באמת
להשפיע על האופן שהתכנית שלך פועלת.

527
00:26:24,170 --> 00:26:26,070
זה יותר עניין סגנוני.

528
00:26:26,070 --> 00:26:29,460
וכאשר יש לנו המדריך לסגנון מעודכן
ומוכן ללכת עד סוף

529
00:26:29,460 --> 00:26:33,260
supersection, נדבר
על זה יותר.

530
00:26:33,260 --> 00:26:34,660
>> יש משהו לא בסדר עם
תכנית זו, נכון?

531
00:26:34,660 --> 00:26:38,980
בגלל 0 הוא לא ממש
מספר שלילי.

532
00:26:38,980 --> 00:26:40,270
אז בואו נראה אם ​​אנחנו יכולים לתקן את זה.

533
00:26:40,270 --> 00:26:45,710

534
00:26:45,710 --> 00:26:48,370
>> אתם בטח יכולים לתאר לעצמך
עם זה אומר, נכון?

535
00:26:48,370 --> 00:26:52,850
אם n הוא גדול מ 0, אנחנו מדפיסים, "אתה
הרים מספר חיובי. "אז אחר

536
00:26:52,850 --> 00:26:57,340
אם n הוא פחות מ 0, "אתה הרים
מספר שלילי. "אחר," אתה הרים

537
00:26:57,340 --> 00:27:01,040
0 ".

538
00:27:01,040 --> 00:27:06,030
>> עכשיו הדבר המעניין הוא ש
זה יכול להימשך לנצח.

539
00:27:06,030 --> 00:27:10,020
יכול להיות לך אם לחסום, אחר אם
בלוק, אחר אחר אם בלוק, אחר אם,

540
00:27:10,020 --> 00:27:14,790
אם אחר, אם אחר, אחר, בעצם
כל עוד אתה רוצה.

541
00:27:14,790 --> 00:27:17,110
וכאשר נבנו כמו זה,
כל אלה הולכים להיות

542
00:27:17,110 --> 00:27:19,206
בלעדי של אחד את השני.

543
00:27:19,206 --> 00:27:19,650
כן?

544
00:27:19,650 --> 00:27:24,130
>> קהל: אז למה אתה לא יכול פשוט להשתמש
אחר אם במקום [לא ברור]?

545
00:27:24,130 --> 00:27:26,990
>> LAUREN קרבאליו: במקרה זה, כן אני
אפשר להשתמש אחר אם, וזה יהיה

546
00:27:26,990 --> 00:27:29,190
בסדר גמור, כי
תנאים עצמם

547
00:27:29,190 --> 00:27:30,600
בלעדי של אחד את השני.

548
00:27:30,600 --> 00:27:33,560
אבל אם התנאים לא היו בלעדיים
של כל אחד אחר, היית עושה את זה

549
00:27:33,560 --> 00:27:37,596
להכריח אותם לעולם גם להעריך,
אם זה נשמע הגיוני.

550
00:27:37,596 --> 00:27:44,195
>> קהל: במקרה זה, יכול אנו קן
השני, אם בתחילה אם?

551
00:27:44,195 --> 00:27:46,160
>> LAUREN קרבאליו: אם -
למה אתה מתכוון?

552
00:27:46,160 --> 00:27:49,660
>> קהל: אם שני תנאים
אינם סותרים?

553
00:27:49,660 --> 00:27:54,700
>> LAUREN קרבאליו: אם התנאים
אינם סותרים?

554
00:27:54,700 --> 00:27:58,000
אבל אתה רוצה רק אחד מהם לרוץ?

555
00:27:58,000 --> 00:28:00,260
>> קהל: אתה רוצה רק
אם במקום אחר.

556
00:28:00,260 --> 00:28:01,020
>> LAUREN קרבאליו: כן.

557
00:28:01,020 --> 00:28:03,630
יש תמיד הולכים להיות הרבה
דרכים שבן אתה יכול לעשות את זה.

558
00:28:03,630 --> 00:28:06,600
אתה בהחלט יכול קינם.

559
00:28:06,600 --> 00:28:10,390
ואתם תראו בשקופית שעתיד
אתה יכול לקבל את טענות מרובות, רק אחד

560
00:28:10,390 --> 00:28:11,680
בזה אחר זה.

561
00:28:11,680 --> 00:28:14,840
אבל זו דרך של לוגי
ארגון הזרימה של התכנית שלך.

562
00:28:14,840 --> 00:28:18,000
>> לוקאס פרייטס: ויש עוד אחד
דבר, הוא שאתה שאלת על לשים

563
00:28:18,000 --> 00:28:20,110
אם ואז עוד אחד, אם.

564
00:28:20,110 --> 00:28:25,240
שיעבוד בצורה מושלמת, אבל זה רע
עיצוב משום שבעצם אם אתה

565
00:28:25,240 --> 00:28:29,320
לבדוק תחילה אם, ושמתם לב ש
המספר גדול מ 0, אתה

566
00:28:29,320 --> 00:28:30,660
פשוט יכול לסיים את התכנית.

567
00:28:30,660 --> 00:28:33,080
אתה לא צריך לבדוק אם
זה פחות מ 0, נכון?

568
00:28:33,080 --> 00:28:37,510
>> אבל אם ואם ואם, זה הולך לבדוק
שניהם, בזמן שאם אני עושה אם אחר הוא,

569
00:28:37,510 --> 00:28:39,260
זה הולך לבדוק אם
זה גדול מ 0.

570
00:28:39,260 --> 00:28:43,500
אם זה הוא, זה לא הולך אפילו להסתכל
בקווים האחרים של הקוד.

571
00:28:43,500 --> 00:28:48,560
אז אתה בעצם בודק את זה כמו
פעמיים שלא לצורך, ולכן זו הסיבה שאנו

572
00:28:48,560 --> 00:28:50,750
לעשות אם אם אחר.

573
00:28:50,750 --> 00:28:52,350
יש עוד שאלות?

574
00:28:52,350 --> 00:28:56,547
>> קהל: אז את הפונקציונליות
של אחר אם זהה

575
00:28:56,547 --> 00:28:57,790
אם זה היה רק ​​אם?

576
00:28:57,790 --> 00:28:58,470
>> LAUREN קרבאליו: לא.

577
00:28:58,470 --> 00:29:02,720
למעשה, אתם הולכים לראות בי הבאים
החלק דוגמא שבו הוא יכול

578
00:29:02,720 --> 00:29:03,270
להיות שונה.

579
00:29:03,270 --> 00:29:05,690
במקרה זה, זה כמעט אותו הדבר.

580
00:29:05,690 --> 00:29:10,190

581
00:29:10,190 --> 00:29:15,410
>> אז הנה, יש לנו דוגמא של מספר
אם הצהרות, ו

582
00:29:15,410 --> 00:29:20,020
פונקציונלי הוא לא אותו הדבר
כאילו יש לי רק אמר שאם

583
00:29:20,020 --> 00:29:23,120
אחר, אם אחר, אם אחר.

584
00:29:23,120 --> 00:29:26,970
בואו רק לחשוב על מה שהייתי להדפיס
אם אני הזן את המספר 95

585
00:29:26,970 --> 00:29:27,715
לתכנית זו.

586
00:29:27,715 --> 00:29:29,764
>> קהל: [לא ברור]

587
00:29:29,764 --> 00:29:31,102
>> LAUREN קרבאליו: ואז?

588
00:29:31,102 --> 00:29:32,340
>> קהל: [לא ברור]

589
00:29:32,340 --> 00:29:33,680
>> LAUREN קרבאליו: כן.

590
00:29:33,680 --> 00:29:37,430
אז במקרה הזה, תנאים אלה הם
אינו סותרים אחד את השני.

591
00:29:37,430 --> 00:29:41,040
ומכיוון שאין שום דבר שעוצר
מצב זה מהערכה אם זה

592
00:29:41,040 --> 00:29:44,730
כבר יש אחד, הם רק
כל הולך להדפיס.

593
00:29:44,730 --> 00:29:46,222
אז איך אני יכול לתקן את זה?

594
00:29:46,222 --> 00:29:47,608
>> קהל: IFS אחר?

595
00:29:47,608 --> 00:29:48,910
>> LAUREN קרבאליו: אתה יכול להשתמש בטענות אחרת.

596
00:29:48,910 --> 00:29:50,590
אני יכול לשנות את הסדר
אלה, נכון?

597
00:29:50,590 --> 00:29:53,800
אם אני עשיתי את זה קודם?

598
00:29:53,800 --> 00:29:55,120
טוב, בעצם, לא.

599
00:29:55,120 --> 00:29:57,100
זה לא יעבוד עבור 95.

600
00:29:57,100 --> 00:29:58,490
>> לוקאס פרייטס: לא, רק טענות אחרת.

601
00:29:58,490 --> 00:30:01,720
>> טענות אחרת: LAUREN קרבאליו
היה קבוע זה.

602
00:30:01,720 --> 00:30:07,050
האם זה להבהיר את הבלבול
בין טענות ועוד טענות?

603
00:30:07,050 --> 00:30:11,480
>> קהל: אני רק רציתי לשאול אותך, אם
אתה לא משתמש אחר אם, היא תפסיק?

604
00:30:11,480 --> 00:30:11,840
>> LAUREN קרבאליו: נכון.

605
00:30:11,840 --> 00:30:13,330
אז רק זה ראשון.

606
00:30:13,330 --> 00:30:16,535
אם אני נכנסתי למספר 95, רק זה
היה מודפס, וזה אף פעם לא

607
00:30:16,535 --> 00:30:17,934
היה התקדם לאחר.

608
00:30:17,934 --> 00:30:22,570
>> לוקאס פרייטס: פשוט סוג של חושב
זה כאילו זה קורה, לעשות את זה.

609
00:30:22,570 --> 00:30:26,990
אחר הוא כמו אם לא, בדוק
לזה, ולאחר מכן לעשות את זה.

610
00:30:26,990 --> 00:30:28,690
אז כמו שכולם הדדי
בלעדי.

611
00:30:28,690 --> 00:30:30,270
אתה לא יכול להיכנס לשני פני אלה.

612
00:30:30,270 --> 00:30:32,800

613
00:30:32,800 --> 00:30:37,630
>> קהל: אתה יכול להשתמש לוגי
ולמצב הזה?

614
00:30:37,630 --> 00:30:39,370
>> LAUREN קרבאליו: כן.

615
00:30:39,370 --> 00:30:41,400
זו דרך שאנחנו יכולים עוד
תיקן את הבעיה הזו.

616
00:30:41,400 --> 00:30:43,470
אנחנו יכולים להיות מוגדרים
נע, נכון?

617
00:30:43,470 --> 00:30:49,410
כדי שאוכל אמר שאם n הוא גדול יותר
מ -90 ופחות מ -

618
00:30:49,410 --> 00:30:52,135
טוב, אני מניח שזה אחד לא ממש
משנה, אבל כאן אני יכול לומר אם

619
00:30:52,135 --> 00:30:53,960
n הוא גדול יותר מאשר 80 ופחות מ 90.

620
00:30:53,960 --> 00:30:55,570
יותר מ -70, פחות מ80.

621
00:30:55,570 --> 00:30:59,077
זה היה יכול להיות גם עבד.

622
00:30:59,077 --> 00:30:59,891
>> [שחוק]

623
00:30:59,891 --> 00:31:00,980
>> לוקאס פרייטס: היא מפחדת.

624
00:31:00,980 --> 00:31:02,070
>> LAUREN קרבאליו: אל תפחד.

625
00:31:02,070 --> 00:31:04,570
>> לוקאס פרייטס: זה לא
שזה יהיה בסדר.

626
00:31:04,570 --> 00:31:08,630
זה פשוט שזה שלא לצורך
מפורט.

627
00:31:08,630 --> 00:31:13,480
כמו במדעי מחשב, אחד צריך
להיות פשוט ככל האפשר, כל עוד

628
00:31:13,480 --> 00:31:14,730
יש לך את הפונקציונליות.

629
00:31:14,730 --> 00:31:16,725

630
00:31:16,725 --> 00:31:17,835
האם אתה רוצה הסוכרייה?

631
00:31:17,835 --> 00:31:19,084
>> קהל: לא צריך את זה.

632
00:31:19,084 --> 00:31:20,340
>> LAUREN קרבאליו: אתה מפחיד את
כולם, לוקאס.

633
00:31:20,340 --> 00:31:21,590
>> לוקאס פרייטס: מצטער.

634
00:31:21,590 --> 00:31:24,650

635
00:31:24,650 --> 00:31:29,510
>> LAUREN קרבאליו: דוד מוזכר גם
אלה לעבור שמירה בכיתה.

636
00:31:29,510 --> 00:31:33,180
בעיקרון מה שקורה הוא המתג
שמירה לוקחת משתנה.

637
00:31:33,180 --> 00:31:35,760
במקרה זה, אנחנו לוקחים את מספר שלם.

638
00:31:35,760 --> 00:31:39,220
>> אם המספר השלם הוא 1, אנחנו הולכים
להדפיס, "אתה הרים קטן

639
00:31:39,220 --> 00:31:42,000
מספר. "אם המספר השלם הוא 1," אתה
הרים מספר בינוני. "אם

640
00:31:42,000 --> 00:31:45,730
שלם הוא 3, "אתה הרים גבוה
מספר. "והיה לי גם מקרה של ברירת מחדל

641
00:31:45,730 --> 00:31:50,020
כאן למטה, אבל זה לא מראה
למעלה, וזה חבל מאוד.

642
00:31:50,020 --> 00:31:53,120

643
00:31:53,120 --> 00:31:55,360
>> בעיקרון, זה רק
תחביר אחר.

644
00:31:55,360 --> 00:31:58,640
אנחנו יכולים ליישם את זה מדויק
אותו דבר עם אם ואם אחר

645
00:31:58,640 --> 00:31:59,390
הצהרות.

646
00:31:59,390 --> 00:32:05,530
אבל כאשר יש הרבה שונה
תנאים והרבה שונים

647
00:32:05,530 --> 00:32:10,350
וריאציות על מה שאתה רוצה לעשות עבור
כל קלט, זו אופציה.

648
00:32:10,350 --> 00:32:13,262
אז זה רק תחביר טוב לדעת.

649
00:32:13,262 --> 00:32:15,099
כן?

650
00:32:15,099 --> 00:32:21,380
>> קהל: מדוע יש לא קו נטוי
n בראשון?

651
00:32:21,380 --> 00:32:23,340
>> LAUREN קרבאליו: לשם למעלה?

652
00:32:23,340 --> 00:32:27,600
אין קו נטוי n שם למעלה
בגלל GetInt -

653
00:32:27,600 --> 00:32:30,140
אם תנסה את זה, זה יהיה
אתן לך הנחיה זו.

654
00:32:30,140 --> 00:32:32,290
תן לי את מספר שלם בין 1 ו -3.

655
00:32:32,290 --> 00:32:35,550
ואם אני שם את n חריפה, זה היה
לקחת אותי לשורה הבאה, אבל אני פשוט

656
00:32:35,550 --> 00:32:38,690
רציתי שהם הקלד את המספר השלם
מייד אחרי המעי הגס.

657
00:32:38,690 --> 00:32:40,120
אתה יכול לשים את n התגובה החריפה.

658
00:32:40,120 --> 00:32:42,374
זה לא עניין גדול.

659
00:32:42,374 --> 00:32:43,288
כן?

660
00:32:43,288 --> 00:32:50,525
>> קהל: לקוד הזה, הוא זו
מקרה אחד, הוא שבגלל

661
00:32:50,525 --> 00:32:51,760
זה המקרה הראשון?

662
00:32:51,760 --> 00:32:52,260
כי -

663
00:32:52,260 --> 00:32:53,400
>> LAUREN קרבאליו: לא, לא, לא.

664
00:32:53,400 --> 00:32:56,480
אז זה נותן לי מספר שלם
בין 1 ל 3.

665
00:32:56,480 --> 00:32:59,070
אם n הוא 1, אני מדפיס את זה.

666
00:32:59,070 --> 00:33:02,740
אילו הייתי שואל למכתבים, יש לי יכולים
אמר לתת לי את מכתב בין

667
00:33:02,740 --> 00:33:04,935
וג ואז זה יהיה מקרה א

668
00:33:04,935 --> 00:33:05,910
>> קהל: [לא ברור].

669
00:33:05,910 --> 00:33:08,090
המקרה הייתי פשוט [לא ברור]

670
00:33:08,090 --> 00:33:11,260
>> LAUREN קרבאליו: כן, בטח.

671
00:33:11,260 --> 00:33:11,550
כן?

672
00:33:11,550 --> 00:33:14,861
>> קהל: מה אם אתה רוצה יש לי
יותר מביטוי יחסי?

673
00:33:14,861 --> 00:33:17,645
אז במקום לומר n
שווה 1, [לא ברור]

674
00:33:17,645 --> 00:33:21,050
n הוא גדול מ -1 במקרה הראשון?

675
00:33:21,050 --> 00:33:26,630
>> LAUREN קרבאליו: למעשה, אם אני לא
להגדיר חלק מהמקרים האלה, היית זה

676
00:33:26,630 --> 00:33:28,500
ניתן לבצע כלפי מטה.

677
00:33:28,500 --> 00:33:30,680
אז בעצם, אולי זה לא
מה שאתה מבקש.

678
00:33:30,680 --> 00:33:36,240
>> לוקאס פרייטס: אני חושב שהיא שואלת אם
המקרה היה n גדול מ 0, במקרה

679
00:33:36,240 --> 00:33:37,150
פחות מ 0.

680
00:33:37,150 --> 00:33:39,210
>> LAUREN קרבאליו: אולי את המתג
אמירה לא באמת מה שאתה רוצה

681
00:33:39,210 --> 00:33:39,880
לשימוש במקרה זה.

682
00:33:39,880 --> 00:33:42,420
>> לוקאס פרייטס: ההצהרה הבורר היא
רק בשביל ערך, אז אתה בודק של

683
00:33:42,420 --> 00:33:45,370
הערך הוא כמו זה או אחר.

684
00:33:45,370 --> 00:33:47,025
אז אתה לא יכול באמת
לשים תנאים.

685
00:33:47,025 --> 00:33:50,988

686
00:33:50,988 --> 00:33:55,920
>> קהל: מה אם האדם
סוגים עם [לא ברור]?

687
00:33:55,920 --> 00:33:58,240
>> LAUREN קרבאליו: זה היה יכול להיות
מקרה ברירת המחדל שלי, שלמרבה הצער

688
00:33:58,240 --> 00:33:58,910
אתה לא יכול לראות.

689
00:33:58,910 --> 00:34:02,240
>> לוקאס פרייטס: [לא ברור]
לגרום להם לראות.

690
00:34:02,240 --> 00:34:03,690
>> LAUREN קרבאליו: למעשה,
אתה יודע מה?

691
00:34:03,690 --> 00:34:07,795
בואו פשוט ללכת ללמוד 50, ואני
רק להתקרב בשקופיות על מחקר

692
00:34:07,795 --> 00:34:10,610
50, כי זה פשוט מעצבן.

693
00:34:10,610 --> 00:34:14,938
אז תן לי בעצם ללכת למצב.

694
00:34:14,938 --> 00:34:17,860
זה רק הולך
לקחת קצת זמן.

695
00:34:17,860 --> 00:34:26,940

696
00:34:26,940 --> 00:34:27,840
>> בסדר.

697
00:34:27,840 --> 00:34:29,590
אז, אני מצטער.

698
00:34:29,590 --> 00:34:33,625
לפחות עכשיו נהיה מסוגל לראות
כל מה שבלי זה ניתוק.

699
00:34:33,625 --> 00:34:36,230

700
00:34:36,230 --> 00:34:36,969
בסדר.

701
00:34:36,969 --> 00:34:43,800
>> אז אם הם שמים ב10, היינו ברירת מחדל
כאן למקרה ברירת המחדל שלי, ואני

702
00:34:43,800 --> 00:34:46,510
הייתי להדפיס רק חוקי, כי אני
ביקש מהם להיכנס שלם

703
00:34:46,510 --> 00:34:49,460
בין 1 ל 3.

704
00:34:49,460 --> 00:34:50,650
יש עוד שאלות?

705
00:34:50,650 --> 00:34:51,081
כן?

706
00:34:51,081 --> 00:34:57,590
>> קהל: נניח למקרה אחד, במקרה
שלוש, תגידו שאתה רצית שזה יהיה כל

707
00:34:57,590 --> 00:35:00,950
אותו דבר, ולכן בחרת מספר
זה לא מספר בינוני.

708
00:35:00,950 --> 00:35:03,840
במקרה כזה, זה יהיה מיותר?

709
00:35:03,840 --> 00:35:08,371
האם אתה יכול פשוט לשנות את הטקסט בשני
מהם, או שיהיה כמה

710
00:35:08,371 --> 00:35:08,617
יתירות?

711
00:35:08,617 --> 00:35:11,920
האם יש דרך לשלב
[לא ברור]?

712
00:35:11,920 --> 00:35:15,810
>> LAUREN קרבאליו: ישנן דרכים
לשלב אותם, אבל אני מאמין שאתה יכול

713
00:35:15,810 --> 00:35:18,730
רק לשלב סמוכים אלה.

714
00:35:18,730 --> 00:35:22,250
אז אם לא אני לא מגדיר שום דבר
למקרה שניים, היית זה

715
00:35:22,250 --> 00:35:24,130
חלים על שני המקרים.

716
00:35:24,130 --> 00:35:28,110
אה, אם אני לא הכנסתי שום דבר למקרה
אחד, זה יחול על שניהם

717
00:35:28,110 --> 00:35:30,620
מקרה אחד ושתיים.

718
00:35:30,620 --> 00:35:33,616
אם זה נשמע הגיוני.

719
00:35:33,616 --> 00:35:35,872
>> קהל: אתה יכול לחזור על זה?

720
00:35:35,872 --> 00:35:36,670
>> לוקאס פרייטס: אישור.

721
00:35:36,670 --> 00:35:39,950
אם עשית בעצם, כאילו, יש לך
את אותו הדבר, אבל אתה לא שמתי

722
00:35:39,950 --> 00:35:46,820
שום דבר כאן, אתה רוצה להיות גם עבור
מקרה אחד או במקרה שתיים, לעשות את זה.

723
00:35:46,820 --> 00:35:47,930
נכון?

724
00:35:47,930 --> 00:35:54,010
והפסקה זה אומר שאם אתה מקבל
למקרה זה, פשוט לעזוב.

725
00:35:54,010 --> 00:35:55,030
אז זה מה שאומר הבלם.

726
00:35:55,030 --> 00:35:59,755
אז אם אני רק עשיתי את זה, אתה מסתכל, זה
מקרה אחד, והיית עושה בדיוק את זה.

727
00:35:59,755 --> 00:36:02,110
אם זה היה מקרה שני, זה גם היית
פשוט לבוא לכאן ולעשות את זה.

728
00:36:02,110 --> 00:36:03,544
>> קהל: אבל אתה יכול לעשות את זה?

729
00:36:03,544 --> 00:36:05,140
אם יש משהו שעבור
מקרה שני [לא ברור]

730
00:36:05,140 --> 00:36:07,095
>> LAUREN קרבאליו: אני לא מאמין
אתה יכול לעשות את זה.

731
00:36:07,095 --> 00:36:09,380
אני לא חושב שאתה יכול לדלג בסביבה.

732
00:36:09,380 --> 00:36:11,070
האם אתה יכול לעשות את זה, רוב?

733
00:36:11,070 --> 00:36:13,300
לא נראה לי.

734
00:36:13,300 --> 00:36:16,548
>> קהל: אז רק מספר אחד
יכול ללכת אחרי מקרה, נכון?

735
00:36:16,548 --> 00:36:21,410
לא יכול להיות שיש מקרה אחד, פסיק, שתי?

736
00:36:21,410 --> 00:36:21,970
>> לוקאס פרייטס: לא, אתה לא יכול.

737
00:36:21,970 --> 00:36:25,085
אתה בהחלט לא יכול.

738
00:36:25,085 --> 00:36:28,770
>> LAUREN קרבאליו: אני מתכוון, הנקודה היא
זו אופציה, וזה אולי לא

739
00:36:28,770 --> 00:36:31,940
תתאים למקרה השימוש שלך, אז אתה
ישתמש אם תנאים.

740
00:36:31,940 --> 00:36:33,906
>> קהל: אז למה אתה עושה את זה?

741
00:36:33,906 --> 00:36:34,314
המתג?

742
00:36:34,314 --> 00:36:38,540
>> LAUREN קרבאליו: אני אשתמש בזה
אם מאוד שהגדרת -

743
00:36:38,540 --> 00:36:39,730
למעשה, לוקאס, הוא שאתה חוסם.

744
00:36:39,730 --> 00:36:40,982
>> לוקאס פרייטס: אה, סליחה.

745
00:36:40,982 --> 00:36:44,200
>> LAUREN קרבאליו: אם יש לך מאוד
התנהגויות מוגדרות הרצויה עבור

746
00:36:44,200 --> 00:36:48,105
כל קלט, זה יכול להיות
קצת יותר תמציתי מאשר לכתוב את

747
00:36:48,105 --> 00:36:49,530
אם הצהרה עבור כל אחד.

748
00:36:49,530 --> 00:36:51,210
>> קהל: מה עושה
לשבור אומר שוב?

749
00:36:51,210 --> 00:36:53,180
>> LAUREN קרבאליו: הפסקת פירושו להפסיק.

750
00:36:53,180 --> 00:36:56,860
זכור, אם לא היה לי הפסקה זה
כאן, היינו פשוט נפלתי

751
00:36:56,860 --> 00:36:58,110
למקרה הבא.

752
00:36:58,110 --> 00:37:00,820
>> לוקאס פרייטס: הפסקה אומרת לקבל
מתוך שמירה על המתג.

753
00:37:00,820 --> 00:37:03,400
מכיוון שאם זה 1, אני רוצה
כדי להדפיס את זה ולעזוב.

754
00:37:03,400 --> 00:37:04,640
אני לא רוצה לבדוק שום דבר אחר.

755
00:37:04,640 --> 00:37:05,790
>> קהל: אתה לא רוצה
להדפיס כל דבר אחר.

756
00:37:05,790 --> 00:37:06,730
>> לוקאס פרייטס: כן.

757
00:37:06,730 --> 00:37:08,260
בגלל שזה סותרים.

758
00:37:08,260 --> 00:37:11,378
>> קהל: והאם זה להמשיך רק
למקרה הבא אם במקרה הראשון

759
00:37:11,378 --> 00:37:11,850
לא נכון?

760
00:37:11,850 --> 00:37:14,120
או שהיא לבדוק את כל המקרים
באותו הזמן?

761
00:37:14,120 --> 00:37:16,300
>> לוקאס פרייטס: לא, זה
בדיקות ברצף.

762
00:37:16,300 --> 00:37:18,070
ברצף, כן.

763
00:37:18,070 --> 00:37:21,840
עוד שאלה אחת, אז אנחנו חייבים
להמשיך הלאה כדי שנוכל לכסות את הכל.

764
00:37:21,840 --> 00:37:22,300
כן?

765
00:37:22,300 --> 00:37:25,280
>> קהל: אז למקרה, יכול להיות
עשה משהו חוץ מזה רק אחד?

766
00:37:25,280 --> 00:37:27,680
האם אתה יכול לתת לו מגוון?

767
00:37:27,680 --> 00:37:28,580
>> לוקאס פרייטס: מס

768
00:37:28,580 --> 00:37:29,900
>> LAUREN קרבאליו: אני לא חושב
אתה יכול לתת לו מגוון.

769
00:37:29,900 --> 00:37:31,430
>> לוקאס פרייטס: אתה לא יכול לך
לא יכול לתת לו טווח.

770
00:37:31,430 --> 00:37:33,190
>> קהל: המקרה ספציפי
[לא ברור].

771
00:37:33,190 --> 00:37:34,840
>> לוקאס פרייטס: החלף
הוא סוג של ערכים.

772
00:37:34,840 --> 00:37:38,400
אתה עושה דברים שונים בהתאם
על ערך, ערך ספציפי.

773
00:37:38,400 --> 00:37:41,050
אתה לא יכול לעשות טווח, אתה לא יכול
לעשות שום דבר אחר.

774
00:37:41,050 --> 00:37:43,055
זה רק עוד כלי כדי לראות.

775
00:37:43,055 --> 00:37:46,570
>> LAUREN קרבאליו: רוב האנשים לא משתמשים
לעבור הצהרות מאוד בCS50,

776
00:37:46,570 --> 00:37:48,760
אבל זה שם.

777
00:37:48,760 --> 00:37:49,920
>> בסדר.

778
00:37:49,920 --> 00:37:53,870
אז הדבר הבא שאנחנו הולכים לדבר
עליו הוא המפעיל המשולש.

779
00:37:53,870 --> 00:37:56,650
זה רק סוג אחר
ממותנה.

780
00:37:56,650 --> 00:38:01,460
בעיקרון מה שקורה כאן הוא שאני
מבקש שלם, ואם n הוא

781
00:38:01,460 --> 00:38:05,550
יותר מ 100, אני הולך להדפיס את
"גבוה". אם זה לא, אני הולך

782
00:38:05,550 --> 00:38:07,010
להדפיס את "נמוך".

783
00:38:07,010 --> 00:38:11,230
>> אז מה הוא עושה הוא התנאי
ממש כאן בסוגריים, ואתה

784
00:38:11,230 --> 00:38:13,550
סוג של יכול לחשוב על השאלה
כמו שאני שואל אם

785
00:38:13,550 --> 00:38:15,030
זה נכון או לא.

786
00:38:15,030 --> 00:38:18,485
אם זה נכון, אני הולך לעשות את זה ראשון
דבר, ואם זה לא נכון, אני

787
00:38:18,485 --> 00:38:20,020
הולך לעשות דבר שני זה.

788
00:38:20,020 --> 00:38:23,520

789
00:38:23,520 --> 00:38:27,960
>> כל שאלות על
מפעיל משולש?

790
00:38:27,960 --> 00:38:30,880
>> לוקאס פרייטס: רק רוצה לציין מ
דוד הוא שכל פעם שיש לך

791
00:38:30,880 --> 00:38:33,346
מצב -

792
00:38:33,346 --> 00:38:35,690
>> LAUREN קרבאליו: אני מניח שהדוד של
צופה דרך הזרם החי.

793
00:38:35,690 --> 00:38:37,210
>> לוקאס פרייטס: הוא עושה
חיים זרם עכשיו.

794
00:38:37,210 --> 00:38:41,730
אז בכל פעם שיש לך מצב, אתה
אמור לשים סוגריים מסולסלים,

795
00:38:41,730 --> 00:38:45,320
בדיוק כמו שיש לנו במתג
אמירה כאן.

796
00:38:45,320 --> 00:38:46,750
יש לנו סוגריים מסולסלים כאן.

797
00:38:46,750 --> 00:38:49,560
לכל תנאים, אתה
אמור גם לשים את זה.

798
00:38:49,560 --> 00:38:50,820
>> LAUREN קרבאליו: אתה תראה
זה במדריך לסגנון.

799
00:38:50,820 --> 00:38:52,900
בעצם אין לנו
מדריך סגנון עכשיו.

800
00:38:52,900 --> 00:38:53,930
אני חושב שהדוד של עדיין עובד.

801
00:38:53,930 --> 00:38:55,100
>> לוקאס פרייטס: הוא אמר כי
זה פשוט עובד עכשיו.

802
00:38:55,100 --> 00:38:56,120
>> LAUREN קרבאליו: אה, זה עובד עכשיו?

803
00:38:56,120 --> 00:38:57,520
על אישור.

804
00:38:57,520 --> 00:39:02,060
אז, ככל הנראה, בשנה זו בסגנון
להדריך, גם אם אתה רק צריך שורה אחת,

805
00:39:02,060 --> 00:39:06,040
אתה חייב לשים אותם
סוגריים מסולסלים פנימה

806
00:39:06,040 --> 00:39:09,480
אתה לא בהכרח צריך ל
הפונקציונליות של התכנית.

807
00:39:09,480 --> 00:39:12,210
ואולי אנחנו צריכים פשוט לקחת הפסקה
לאחר התנאים וללכת ישר

808
00:39:12,210 --> 00:39:14,620
למדריך הסגנון כדי לנקות
עד כמה מהדברים האלה?

809
00:39:14,620 --> 00:39:15,010
>> לוקאס פרייטס: כן.

810
00:39:15,010 --> 00:39:15,775
האם יש לך שאלה?

811
00:39:15,775 --> 00:39:17,580
>> קהל: לא, אני רק לחכות
עד מדריך הסגנון.

812
00:39:17,580 --> 00:39:19,578
>> קהל: האם אתה יכול לחזור
למפעיל המשולש?

813
00:39:19,578 --> 00:39:23,360
>> LAUREN קרבאליו: משולש, כן.

814
00:39:23,360 --> 00:39:29,010
>> לוקאס פרייטס: מפעיל משולש הוא
בעצם אמירה אם אחרת, אבל

815
00:39:29,010 --> 00:39:33,590
במקום שיש שני קווים
בדיקה אם ולאחר מכן

816
00:39:33,590 --> 00:39:36,600
אחר, רק שיש לך שורה אחת.

817
00:39:36,600 --> 00:39:40,930
אז בעצם, אם אני רוצה לתת לי מחרוזת
ערך שלי גבוה או נמוך, ו

818
00:39:40,930 --> 00:39:46,270
רוצה לעשות גבוה אם n הוא גדול יותר מאשר
100 או נמוך אם זה פחות, מה אני יכול לעשות

819
00:39:46,270 --> 00:39:47,730
זה [לא ברור]

820
00:39:47,730 --> 00:39:53,060
המחרוזת הולכת להיות, ואז אני
לשאול את התכנית היא n גדולה מ 100?

821
00:39:53,060 --> 00:39:55,750
>> אז בגלל זה יש לי את הביטוי הזה
בסוגריים ולאחר מכן

822
00:39:55,750 --> 00:39:56,580
סימן השאלה.

823
00:39:56,580 --> 00:39:59,110
אני שואל את זה גדול יותר מ100?

824
00:39:59,110 --> 00:40:02,310
אם זה הוא, שזה הולך להיות גבוה.

825
00:40:02,310 --> 00:40:03,850
אם זה לא, זה הולך להיות נמוך.

826
00:40:03,850 --> 00:40:07,310
>> אז בעצם מה שאתה חושב שאתה שואל
שאלה, אז אתה שם בסוגריים

827
00:40:07,310 --> 00:40:08,620
המצב.

828
00:40:08,620 --> 00:40:11,160
ואז אתה שם את סימן השאלה
בגלל שאתה שואל את זה.

829
00:40:11,160 --> 00:40:15,240
ואם זה נכון, זה הולך להיות
בערך הראשון [לא ברור] כאן.

830
00:40:15,240 --> 00:40:18,176
אם זה לא, אני הולך לשים
ערך שאחרי הנקודתיים.

831
00:40:18,176 --> 00:40:21,580
האם זה הגיוני?

832
00:40:21,580 --> 00:40:24,730
>> זה גם משהו שהוא כמו
כלי ב-C, אבל אין לך

833
00:40:24,730 --> 00:40:25,700
במיוחד להשתמש בו.

834
00:40:25,700 --> 00:40:29,890
אבל אנשים בדרך כלל אוהבים שCS
כי זה פשוט חוסך קווים.

835
00:40:29,890 --> 00:40:31,050
>> LAUREN קרבאליו: זה מאוד אלגנטי.

836
00:40:31,050 --> 00:40:32,951
הוא עושה הרבה רק משפט אחד.

837
00:40:32,951 --> 00:40:36,077
>> קהל: אז סימן האחוזים הוא
רק מה שאת התוצאות על

838
00:40:36,077 --> 00:40:36,799
השורה הקודמת?

839
00:40:36,799 --> 00:40:38,260
>> LAUREN קרבאליו: אה, אני מצטער.

840
00:40:38,260 --> 00:40:42,670
סימן האחוזים זהו למעשה
מציינים מיקום זה זה.

841
00:40:42,670 --> 00:40:46,160
בהצהרת printf, יש לך את זה
מחרוזת כאן, וזה מה שהולך

842
00:40:46,160 --> 00:40:48,440
להדפיס, אבל אתה לא יכול פשוט
לשים את זה בזה שם.

843
00:40:48,440 --> 00:40:50,290
אחרת זה יהיה להדפיס
מתוך ים, פשוטו כמשמעו.

844
00:40:50,290 --> 00:40:54,070
אז אנחנו שמים אחוזים לכאן כדי לשמור על
במקום זה נערך לכל מה

845
00:40:54,070 --> 00:40:57,590
מגיע אחרי הפסיק.

846
00:40:57,590 --> 00:40:59,470
>> אז למחרוזת, יש לך אחוזים של.

847
00:40:59,470 --> 00:41:00,950
למספר שלם, אני אחוזים.

848
00:41:00,950 --> 00:41:03,330
למצוף, f אחוזים.

849
00:41:03,330 --> 00:41:06,960
אתה תראה אותם כפי שאנו
ראה דוגמאות נוספות.

850
00:41:06,960 --> 00:41:09,230
אבל אולי כדאי לך לדבר על
מדריך סגנון לזמן קצר, עכשיו

851
00:41:09,230 --> 00:41:10,480
כי זה תלוי.

852
00:41:10,480 --> 00:41:21,040

853
00:41:21,040 --> 00:41:24,010
>> לוקאס פרייטס: אם אתה הולך ל
cs50.net/style, אתה הולך לראות

854
00:41:24,010 --> 00:41:25,760
מדריך הסגנון.

855
00:41:25,760 --> 00:41:32,420
לסטי בעיה, הציון שלך עבור
סט בעיה מורכב מהיקפו,

856
00:41:32,420 --> 00:41:35,510
אשר בעצם אומר שאם אתה עשית את כל
החלקים של בעיה להגדיר או אם אתה

857
00:41:35,510 --> 00:41:37,170
ניסיתי משהו.

858
00:41:37,170 --> 00:41:41,120
הדבר השני הוא נכונותו, אשר
אמצעי הוא התכנית שלך עושה את מה שהוא

859
00:41:41,120 --> 00:41:44,520
היה אמור לעשות, או עושה את זה
יש באגים, או שזה לא עושה את מה

860
00:41:44,520 --> 00:41:45,620
זה אמור לעשות.

861
00:41:45,620 --> 00:41:51,420
>> הדבר השלישי הוא עיצוב, שפירושו
אתה מיישם זאת היטב, או שהם

862
00:41:51,420 --> 00:41:54,520
אתה משתמש בהצהרות מיותרות?

863
00:41:54,520 --> 00:41:59,400
כך למשל, אם ברצונך לחזור
מספר 10 פעמים, אתה כותב

864
00:41:59,400 --> 00:42:03,040
ללולאה או שאתה רק עושה את 10 פעמים
באותה ההצהרה, פשוט עושה

865
00:42:03,040 --> 00:42:04,060
העתקה והדבקה.

866
00:42:04,060 --> 00:42:05,760
אז עיצוב הוא בשביל זה.

867
00:42:05,760 --> 00:42:07,420
>> ולבסוף, יש לך סגנון.

868
00:42:07,420 --> 00:42:12,000
סגנון הוא בדיוק כמו לשפוט
אם הקוד שלך נראה

869
00:42:12,000 --> 00:42:14,050
קריא וסוג של די.

870
00:42:14,050 --> 00:42:16,520
זה פשוט בעצם אומר
הוא הקוד שלך קריא?

871
00:42:16,520 --> 00:42:20,560
הייתי מישהו אחר שחיפש הוא
הקוד שלך להיות מסוגל להבין מה

872
00:42:20,560 --> 00:42:21,250
הוא עושה?

873
00:42:21,250 --> 00:42:25,360
האם יש לו הערות וכדומה?

874
00:42:25,360 --> 00:42:30,430
>> בואו נדבר על הסגנון
אתה אמור להשתמש בו.

875
00:42:30,430 --> 00:42:32,200
הדבר הראשון הוא הערות.

876
00:42:32,200 --> 00:42:35,280
תגובות הן מאוד חשובות עבורך
קוד כי לפעמים אתה עושה

877
00:42:35,280 --> 00:42:38,750
התכנית שלך, ואתה יודע בדיוק מה
אתה רוצה לעשות, כך שאתה פשוט להתחיל

878
00:42:38,750 --> 00:42:43,120
קידוד, פשוט הקלד את חבורה של C. אבל
אם מישהו אחר מחפש אתה

879
00:42:43,120 --> 00:42:47,500
קוד, הם לא הולכים להיות מסוגלים
להבין את זה, כי הם לא יודעים

880
00:42:47,500 --> 00:42:51,420
הדברים שהם בראש שלך, כמו
pesudocode, אז אולי הם יהיו

881
00:42:51,420 --> 00:42:53,970
מתקשה להבין
מה הקוד עושה.

882
00:42:53,970 --> 00:42:57,900
>> אז הערות הן באמת שימושיות כדי להסביר
למי שמסתכל על

883
00:42:57,900 --> 00:43:00,880
הקוד שלך מה הוא עושה, ו
למעשה אפילו בשבילך,

884
00:43:00,880 --> 00:43:01,880
הם מאוד שימושיים.

885
00:43:01,880 --> 00:43:05,740
כמו שאתה הולך לPsets קשה יותר וקשה,
אתה הולך לראות שהקוד מקבל

886
00:43:05,740 --> 00:43:10,590
, ולאחר מכן הערות כבר באמת
חשוב שתזכור מה כל אחד

887
00:43:10,590 --> 00:43:13,320
חלק מהתכנית שלך עושה.

888
00:43:13,320 --> 00:43:16,920
>> כדי לשים את תגובה, אתה יכול פשוט לעשות
סלאש קו נטוי ולאחר מכן לכתוב תגובה.

889
00:43:16,920 --> 00:43:21,250
והקו כולו הוא חלק מתגובה,
ומה שאתה כותב למטה,

890
00:43:21,250 --> 00:43:24,550
זה לא הולך להיות
משמש לקוד שלך.

891
00:43:24,550 --> 00:43:27,993
זה בעצם כמו מהדר
הוא הולך להתעלם מזה.

892
00:43:27,993 --> 00:43:29,290
האם זה הגיוני?

893
00:43:29,290 --> 00:43:31,710
>> קהל: מה אתה עושה שוב
כדי לכתוב תגובה?

894
00:43:31,710 --> 00:43:33,260
>> לוקאס פרייטס: זה?

895
00:43:33,260 --> 00:43:36,020
הלוכסן לקצץ?

896
00:43:36,020 --> 00:43:39,810
בכל פעם שאתה מקליד קו נטוי קו נטוי, מה
עולים בקנה אחד כי הוא לא הולך

897
00:43:39,810 --> 00:43:42,260
כדי להיחשב ג כן?

898
00:43:42,260 --> 00:43:45,910
>> קהל: אז אחרי התגובה, אתה
רק להיכנס ולהתחיל שורה חדשה?

899
00:43:45,910 --> 00:43:47,120
>> לוקאס פרייטס: כן, בדיוק.

900
00:43:47,120 --> 00:43:50,010
>> LAUREN קרבאליו: הקו נטוי הקו הנטוי
הוא על הערות שורה אחת.

901
00:43:50,010 --> 00:43:52,910
>> לוקאס פרייטס: לדוגמא,
כאן יש לנו -

902
00:43:52,910 --> 00:43:54,160
תן לי להתקרב -

903
00:43:54,160 --> 00:43:56,530

904
00:43:56,530 --> 00:44:01,180
לדוגמא, הנה אני מכריז לצוף,
אבל אולי אם אתה רק לשים את זה

905
00:44:01,180 --> 00:44:04,980
בקוד שלך, כמוך אין לי מושג
מה זה עושה, כמו בעצם

906
00:44:04,980 --> 00:44:06,950
מישהו שמסתכל על הקוד הזה
הוא הולך להיות, כמו, מה

907
00:44:06,950 --> 00:44:09,190
לעזאזל קורה פה?

908
00:44:09,190 --> 00:44:12,890
>> אם אתה שם את תגובה אומרת "להמיר
פרנהייט לצלזיוס, זה עושה הרבה

909
00:44:12,890 --> 00:44:13,450
יותר הגיוני.

910
00:44:13,450 --> 00:44:15,480
אתה, כאילו, בסדר, אתה
ביצוע המרה.

911
00:44:15,480 --> 00:44:16,730
האם זה הגיוני?

912
00:44:16,730 --> 00:44:19,860

913
00:44:19,860 --> 00:44:24,960
אז זה פשוט משהו שעוזר לאנשים
מוכן הקוד שלך וגם לבצע

914
00:44:24,960 --> 00:44:28,290
שתוכל לארגן
הקוד שלך טוב יותר.

915
00:44:28,290 --> 00:44:33,080
>> הדבר השני הוא שאתה יכול לעשות
הערות רב קווים, ולכן יש אחד

916
00:44:33,080 --> 00:44:34,850
להגיב לחבורה של קווים.

917
00:44:34,850 --> 00:44:38,880
במקום שיש לשים קו נטוי קו נטוי,
הערות השורה הראשונה, לקצץ בקו נטוי,

918
00:44:38,880 --> 00:44:43,590
השורה השנייה, וכן הלאה, אתה
ניתן להשתמש בכוכבית הקו הנטוי.

919
00:44:43,590 --> 00:44:46,330
הדרך שבה אתה עושה את זה היא שעבור
השורה הראשונה של התגובה, אתה

920
00:44:46,330 --> 00:44:49,650
הולך לעשות כוכב כוכב לוכסן,
כך סתם ככה.

921
00:44:49,650 --> 00:44:56,900
בדיוק כמו כאן יש לנו את תחילתו של
תכנית, אתה בדרך כלל לשים מי אתה

922
00:44:56,900 --> 00:44:59,530
הם, מה התכנית הזו עושה,
ודברים כאלה.

923
00:44:59,530 --> 00:45:01,900
זה כמו סוג של כותרת
עבור התכנית.

924
00:45:01,900 --> 00:45:04,540
>> שוב, זה לא משהו ש
מהדר הולך אכפת, אבל

925
00:45:04,540 --> 00:45:07,570
זה חשוב לך לדעת מה זה
תכנית עושה או לאנשים אחרים

926
00:45:07,570 --> 00:45:09,960
לדעת מה התכנית שלך עושה.

927
00:45:09,960 --> 00:45:17,480
אז אתה לקצץ כוכב כוכב, ולאחר מכן
השורה האחרונה אתה הולך לעשות כוכב

928
00:45:17,480 --> 00:45:22,250
סלאש כדי להיות מסוגל לסגור
ההערה הזאת.

929
00:45:22,250 --> 00:45:26,140
אז בעצם לכל קווים האחרים,
רק אתה יכול לכתוב מה, וזה

930
00:45:26,140 --> 00:45:27,390
הוא כל הולך להתעלם ממנו.

931
00:45:27,390 --> 00:45:32,920

932
00:45:32,920 --> 00:45:37,780
>> וגם, בדיוק כמו סגנון, אתה רואה את זה
כל אחד מהקווים יש כוכבים, וכל

933
00:45:37,780 --> 00:45:39,380
הכוכבים מיושרים.

934
00:45:39,380 --> 00:45:41,605
אלו דברים חשובים כל כך
שהקוד שלך נראה יפה.

935
00:45:41,605 --> 00:45:42,855
נשמע טוב?

936
00:45:42,855 --> 00:45:45,320

937
00:45:45,320 --> 00:45:47,290
>> עכשיו, תנאים.

938
00:45:47,290 --> 00:45:52,240
מה דוד היה אומר שאנחנו צריכים
ממש לשים בשקופיות אלה, הוא כי

939
00:45:52,240 --> 00:45:55,810
כאשר יש לך כל סוג של אם דוחות
או כל סוג של תנאים,

940
00:45:55,810 --> 00:46:00,700
אתה צריך להשתמש בסוגריים מסולסלים כדי להראות כי
זה מה שהולך לקרות

941
00:46:00,700 --> 00:46:02,730
כאשר יש לך את המצב.

942
00:46:02,730 --> 00:46:07,560
מבחינה טכנית, כאשר יש לך מצב
ואז השורה הבאה היא רק אחד

943
00:46:07,560 --> 00:46:12,110
קו, אין לך מבחינה טכנית
לשים את הסוגריים המסולסלים.

944
00:46:12,110 --> 00:46:16,930
>> בעיקרון מהדר היה מבין
זה בכל מקרה כפי שמשתמע.

945
00:46:16,930 --> 00:46:21,100
אבל עבור CS50, אנו מבקשים מכם לשים
הסוגריים המסולסלים רק כדי ש

946
00:46:21,100 --> 00:46:24,560
הקוד הוא מאורגן יותר
וקריא יותר.

947
00:46:24,560 --> 00:46:28,200
מכיוון שהקוד שמקבל זמן רב יותר אם
אין לי פלטות וכזה מתולתלות.

948
00:46:28,200 --> 00:46:29,150
זה נהיה ממש מבולגן.

949
00:46:29,150 --> 00:46:31,410
>> LAUREN קרבאליו: זה בדיוק
מה דוד רק ציין

950
00:46:31,410 --> 00:46:33,000
בשקופיות הקודמות שלי.

951
00:46:33,000 --> 00:46:36,690
זה בהחלט עובד ללא מתולתל
פלטה, אבל מסיבות סגנוניות

952
00:46:36,690 --> 00:46:38,840
אנחנו הולכים לבקש ש
אתה לשים אותם פנימה

953
00:46:38,840 --> 00:46:42,400
>> וכשאתה מתחיל לרוץ style50,
שהוא סוג של הבדיקה 50 עבור

954
00:46:42,400 --> 00:46:44,860
סגנון, זה יזכיר לך לעשות את זה.

955
00:46:44,860 --> 00:46:49,710
>> לוקאס פרייטס: ועוד דבר
לזכור לשים סוגריים המסולסלים לאורך

956
00:46:49,710 --> 00:46:50,610
בכל שורה.

957
00:46:50,610 --> 00:46:52,490
אז אתה עושה, למשל, l's.

958
00:46:52,490 --> 00:46:56,910
עבור לשורה הבאה, פתח את המתולתל
סד, ואז אתה הולך לשורה הבאה.

959
00:46:56,910 --> 00:46:59,560
כניסה, שבו היא ארבעה חללים.

960
00:46:59,560 --> 00:47:03,570
אז אתה כותב מה, ואז עוד
הקו, וסגור את הסד המתולתל.

961
00:47:03,570 --> 00:47:06,870
אז כדי להיות בטוח ששני אלה מתולתל
פלטה נמצאות בקווים שונים.

962
00:47:06,870 --> 00:47:11,548
>> קהל: אז אם היה את הקוד הזה כמו
10 טענות אחרת, צריך את זה

963
00:47:11,548 --> 00:47:13,040
להיות 10 סטים של סוגריים?

964
00:47:13,040 --> 00:47:14,610
>> לוקאס פרייטס: כן, לכל אחד מהם.

965
00:47:14,610 --> 00:47:14,930
כן.

966
00:47:14,930 --> 00:47:17,980
אז אם, אם אחר, וכן הלאה.

967
00:47:17,980 --> 00:47:21,990
>> קהל: אתה יכול לא
הקש Tab כדי להזיז?

968
00:47:21,990 --> 00:47:25,350
>> לוקאס פרייטס: אנחנו שואלים אותך
החבר 'ה כדי להשתמש בארבעה חללים.

969
00:47:25,350 --> 00:47:30,060
עורכי טקסט מסוימים לתרגם כרטיסייה
כארבעה חללים באופן אוטומטי.

970
00:47:30,060 --> 00:47:34,850
gedit לא, אז יש לך ל
לעשות חלל חלל חלל החלל.

971
00:47:34,850 --> 00:47:37,920
זה גם משהו שקצת
מתכנתים לעשות רק כרטיסיות, כמה

972
00:47:37,920 --> 00:47:40,560
מתכנתים לעשות רק ארבעה חללים,
וכמה אנשים אחרים אפילו לעשות

973
00:47:40,560 --> 00:47:41,900
שניים או שלושה מקומות.

974
00:47:41,900 --> 00:47:44,040
זה רק שכאן אנחנו מבקשים
אתם לעשות ארבעה חללים.

975
00:47:44,040 --> 00:47:47,556
>> קהל: יש כמעט בודאות
חייב להיות דרך לgedit כדי

976
00:47:47,556 --> 00:47:48,645
באופן אוטומטי [לא ברור].

977
00:47:48,645 --> 00:47:50,480
אין כמותו [לא ברור] עושה את זה.

978
00:47:50,480 --> 00:47:51,150
>> לוקאס פרייטס: כן.

979
00:47:51,150 --> 00:47:53,165
אני חושב שאתה יכול ללכת להגדרות.

980
00:47:53,165 --> 00:47:55,270
>> קהל: זה כבר עושה את כל זה.

981
00:47:55,270 --> 00:47:56,410
>> לוקאס פרייטס: זה כבר עושה?

982
00:47:56,410 --> 00:47:56,890
על אישור.

983
00:47:56,890 --> 00:48:00,854
אז רק כדי להיות בטוח שאתה
יש ארבעה חללים.

984
00:48:00,854 --> 00:48:05,880
>> קהל: האם אנחנו צריכים לשים את מתולתל
סוגריים ללולאות, כמו גם?

985
00:48:05,880 --> 00:48:07,470
>> לוקאס פרייטס: כן.

986
00:48:07,470 --> 00:48:11,610
>> LAUREN קרבאליו: בכל פעם שלך
encapsulating בלוק של קוד, רק

987
00:48:11,610 --> 00:48:13,570
אנא השתמש בסוגריים המסולסלים.

988
00:48:13,570 --> 00:48:18,040
ולפני שאתה חושב שאנחנו פשוט
להיות מהדרים על זה לא טוב

989
00:48:18,040 --> 00:48:23,450
סיבה, אם אתם הולכים על מנת לקבל
התמחויות טק בחברות גדולות,

990
00:48:23,450 --> 00:48:26,020
הם יתנו לך מדריך סגנון, ו
הם יגידו לך שזה מה ששלך

991
00:48:26,020 --> 00:48:27,220
קוד צריך להיראות.

992
00:48:27,220 --> 00:48:31,120
ואף על פי שלמדת לקוד כמו
זה, אולי בהתמחות שלך

993
00:48:31,120 --> 00:48:32,680
תצטרך לעשות משהו
שונה לחלוטין.

994
00:48:32,680 --> 00:48:35,115
הם מצפים ממך לציית
לסגנון שלהם.

995
00:48:35,115 --> 00:48:39,800
>> לוקאס פרייטס: דבר ועוד אחד הוא
שמת לב איך יש לי כמו x,

996
00:48:39,800 --> 00:48:42,290
חלל, פחות, חלל, 0?

997
00:48:42,290 --> 00:48:44,640
בכל פעם שיש לך מפעיל -

998
00:48:44,640 --> 00:48:50,490
זה יכול להיות כמו פלוס, מינוס, פעמים, פחות,
כל מה שמפעיל גדול יותר, -

999
00:48:50,490 --> 00:48:57,560
אתה צריך לשים את חלל בצד השמאל
וזכותו של המפעיל.

1000
00:48:57,560 --> 00:49:00,570
>> LAUREN קרבאליו: אלה הם
קרא האופרנדים בינארי.

1001
00:49:00,570 --> 00:49:03,720
רק לוודא שאתה תמיד החלל
מתוך האופרנדים בינארי שלך.

1002
00:49:03,720 --> 00:49:05,465
>> לוקאס פרייטס: זה
לא האופרנד בינארי.

1003
00:49:05,465 --> 00:49:07,010
>> LAUREN קרבאליו: זה הוא
כי זה לוקח שתיים.

1004
00:49:07,010 --> 00:49:08,260
>> לוקאס פרייטס: הו, כן.

1005
00:49:08,260 --> 00:49:13,340

1006
00:49:13,340 --> 00:49:14,590
>> אוקיי, המתגים.

1007
00:49:14,590 --> 00:49:18,180

1008
00:49:18,180 --> 00:49:23,390
ראשית, אתה צריך לראות את זה בדיוק כמו
בהצהרה אם או אחרת, יש לך

1009
00:49:23,390 --> 00:49:28,280
לשים את הסד המתולתל בשורה הנפרדת
ותחת הסד המתולתל כאן.

1010
00:49:28,280 --> 00:49:32,240
שים לב שיש רווח יחיד
אחרי ההפעלה, בדיוק כמו באם ועוד

1011
00:49:32,240 --> 00:49:35,360
היו לנו חלל אחד בין
ושהסוגריים.

1012
00:49:35,360 --> 00:49:36,610
אז אתה צריך לשים את זה.

1013
00:49:36,610 --> 00:49:40,380

1014
00:49:40,380 --> 00:49:48,270
>> ואין שום מקום נכון לאחר כל
של הסוגריים או לפני הסוף

1015
00:49:48,270 --> 00:49:49,080
של הסוגריים.

1016
00:49:49,080 --> 00:49:52,612
אז אתה רואה שזה כולם ביחד,
וגם אוהב כאן.

1017
00:49:52,612 --> 00:49:53,940
>> כן?

1018
00:49:53,940 --> 00:49:58,040
>> LAUREN קרבאליו: אני חושב
אנחנו צריכים להמשיך הלאה.

1019
00:49:58,040 --> 00:50:02,340
>> לוקאס פרייטס: אז זה חלק מ
מדריך סגנון שיש לך לCS50.

1020
00:50:02,340 --> 00:50:06,520
הקפד ללכת לcs50.net/style
ותסתכל על זה.

1021
00:50:06,520 --> 00:50:09,250
כל אלה הם חשובים מאוד
לציון בסגנון שלך.

1022
00:50:09,250 --> 00:50:12,740

1023
00:50:12,740 --> 00:50:15,670
>> תן לי לחזור להצהרה.

1024
00:50:15,670 --> 00:50:17,070
>> LAUREN קרבאליו: אני מעדיף ש
פשוט להשתמש style50.

1025
00:50:17,070 --> 00:50:18,920
אנחנו רק הולכים
ישר ללולאות.

1026
00:50:18,920 --> 00:50:27,580

1027
00:50:27,580 --> 00:50:28,300
בסדר.

1028
00:50:28,300 --> 00:50:33,720
>> אז בואו נחזור לתוכן, עכשיו
שעברנו על המדריך לסגנון.

1029
00:50:33,720 --> 00:50:37,220
לולאות, אתה ראית אותם בגרד, ו
אנחנו הולכים לדבר עליהם ב

1030
00:50:37,220 --> 00:50:39,210
ג

1031
00:50:39,210 --> 00:50:44,400
>> ללולאה, יש
שלוש מנות ל

1032
00:50:44,400 --> 00:50:45,440
הכרזה זו ללולאה.

1033
00:50:45,440 --> 00:50:49,040
יש לך האתחול שלך ב
שאתה מגדיר את המשתנים שלך.

1034
00:50:49,040 --> 00:50:52,160
יש לך את המצב שלך, שהם
בדיקה כדי לראות אם משהו הוא

1035
00:50:52,160 --> 00:50:54,670
אמת או שקר והאם
לולאה צריכה להמשיך.

1036
00:50:54,670 --> 00:50:59,390
ויש לך העדכון שלך, שבו
הוא מעדכן המשתנים שלך.

1037
00:50:59,390 --> 00:51:05,310
>> בואו רק נעיף מבט מהיר על כמה
קוד C של זה ללולאה בפעולה.

1038
00:51:05,310 --> 00:51:08,860
מה קורה כאן ב
אתחול, אנחנו הגדרת i ל -0.

1039
00:51:08,860 --> 00:51:11,820
במצב שאנחנו בודקים
אם אני הוא פחות מ -10.

1040
00:51:11,820 --> 00:51:14,982
ובעדכון אנחנו
להגדיל כל i.

1041
00:51:14,982 --> 00:51:20,490
אז מה תהיה תוצאה של
זה ללולאה?

1042
00:51:20,490 --> 00:51:24,344
>> לוקאס פרייטס: למעשה, קודם כל,
האם אתם יודעים מה + + הוא אני?

1043
00:51:24,344 --> 00:51:25,850
>> קהל: גדל ב 1.

1044
00:51:25,850 --> 00:51:26,870
>> לוקאס פרייטס: עלייה של 1, כן.

1045
00:51:26,870 --> 00:51:30,020
אז זה אותו הדבר כמו
עושה לי שווה לי בתוספת 1.

1046
00:51:30,020 --> 00:51:35,890
ושים לב שאין לנו מקום
ביני ו+ +.

1047
00:51:35,890 --> 00:51:37,600
>> אז תדע לכם מה זה יעשה?

1048
00:51:37,600 --> 00:51:39,060
מישהו יכול להגיד לי?

1049
00:51:39,060 --> 00:51:41,463
ואולי לקבל קצת ממתקים
בגלל זה?

1050
00:51:41,463 --> 00:51:42,912
>> קהל: [לא ברור]

1051
00:51:42,912 --> 00:51:44,850
>> לוקאס פרייטס: אישור.

1052
00:51:44,850 --> 00:51:45,400
[לא ברור]

1053
00:51:45,400 --> 00:51:47,450
להראות לכולם בהמשך [לא ברור].

1054
00:51:47,450 --> 00:51:49,565
כן, זה הולך להראות "זה
הוא CS50 "10 פעמים.

1055
00:51:49,565 --> 00:51:52,150
>> LAUREN קרבאליו: אני מניח שזה היה
בכותרת של השקופית.

1056
00:51:52,150 --> 00:51:53,830
>> לוקאס פרייטס: הו, כן.

1057
00:51:53,830 --> 00:51:54,670
>> [שחוק]

1058
00:51:54,670 --> 00:51:56,790
>> לוקאס פרייטס: זה עוזר.

1059
00:51:56,790 --> 00:51:58,370
>> LAUREN קרבאליו: אז אלה
הם ללולאות.

1060
00:51:58,370 --> 00:52:03,200
אנחנו הולכים לראות כמה דוגמאות יותר
של לולאות בהמשך.

1061
00:52:03,200 --> 00:52:06,510
אבל בואו באמת נסתכל על
סוג שני של לולאה תיתקל

1062
00:52:06,510 --> 00:52:08,920
ב-C, וזה נקרא תוך הלולאה.

1063
00:52:08,920 --> 00:52:11,120
>> בלולאה בזמן, יש לך
פשוט יש לי מצב.

1064
00:52:11,120 --> 00:52:14,790
המצב הוא בדק ב
מתחיל, ואם מצב זה

1065
00:52:14,790 --> 00:52:18,450
מעריך לנכון אז הקוד, בתוך
הגוף של הבלוק תוך

1066
00:52:18,450 --> 00:52:20,380
יבצע.

1067
00:52:20,380 --> 00:52:23,000
והקוד ימשיך
לבצע כל כך הרבה זמן כמו ש

1068
00:52:23,000 --> 00:52:24,450
המצב נשאר נכון.

1069
00:52:24,450 --> 00:52:28,350

1070
00:52:28,350 --> 00:52:33,320
>> הנה דוגמא ללולאה בזמן בג
אנחנו הולכים להגדיר ספירה עד 10 ל

1071
00:52:33,320 --> 00:52:34,580
מלכתחילה.

1072
00:52:34,580 --> 00:52:41,800
כל זמן שהספירה היא גדולה מ 0,
אנחנו הולכים כדי לשמור על דפוס את זה

1073
00:52:41,800 --> 00:52:43,360
משתנה כאן.

1074
00:52:43,360 --> 00:52:47,080
אנחנו הולכים להפחת ספירה ו
לאחר מכן לבדוק את המצב שוב.

1075
00:52:47,080 --> 00:52:51,370
הדפסה, מפחית, צ'ק
המצב שוב.

1076
00:52:51,370 --> 00:52:54,530
>> כאן יש לנו דוגמא שנוגעת
לשאלתך קודם לכן.

1077
00:52:54,530 --> 00:52:57,340
היו לנו אחוזים של כשהיינו
מדפיס את מחרוזת, ועכשיו

1078
00:52:57,340 --> 00:53:03,420
אנחנו מדפיסים את int, יש לנו
אחוזים אני כמציין המיקום שלנו במקום.

1079
00:53:03,420 --> 00:53:09,250
האותיות צריכות להיות די
אינטואיטיבית, זה למחרוזת, i עבור int.

1080
00:53:09,250 --> 00:53:15,400
>> אז אם הפעלת הקוד הזה, אתה צריך
לספור את 10-0, הדפסה

1081
00:53:15,400 --> 00:53:15,925
כל מספר שלם.

1082
00:53:15,925 --> 00:53:19,460
>> לוקאס פרייטס: ואתה יכול לחשוב עליו
אחוזים כפי שהוא מרגיש כמו ריק

1083
00:53:19,460 --> 00:53:23,960
חלל, ואז אתה שם את זה
משתנה כאן בחלל ריק.

1084
00:53:23,960 --> 00:53:27,640
כך למשל, כאן יהיה לי רק
ריק ולאחר מכן אני שם את

1085
00:53:27,640 --> 00:53:30,262
לספור ממש שם,
ערך של הספירה.

1086
00:53:30,262 --> 00:53:32,710
האם זה הגיוני?

1087
00:53:32,710 --> 00:53:35,860
>> אני יכול פשוט לעשות כמו printf
ולאחר מכן מצטט, לספור?

1088
00:53:35,860 --> 00:53:36,840
האם זה עובד?

1089
00:53:36,840 --> 00:53:37,980
>> קהל: לא.

1090
00:53:37,980 --> 00:53:41,190
>> לוקאס פרייטס: לא, כי זה יהיה
בעצם להדפיס את המילה "ספירה"

1091
00:53:41,190 --> 00:53:42,850
במקום להדפיס את הערך.

1092
00:53:42,850 --> 00:53:46,080
זה איך אתה עושה את זה להדפיס את הערכים
הכיוון משתנה במקום

1093
00:53:46,080 --> 00:53:47,670
רק את שמו של משתנה.

1094
00:53:47,670 --> 00:53:48,530
כל שאלה?

1095
00:53:48,530 --> 00:53:53,060
>> קהל: למה אתה משתמש עבור
כמתנגד לזמן מה?

1096
00:53:53,060 --> 00:53:56,130
>> LAUREN קרבאליו: הייתי משתמש עבור
לולאה אם ​​אני יודע בדיוק כמה

1097
00:53:56,130 --> 00:53:59,520
חזרות אני רוצה הלולאה שלי לרוץ.

1098
00:53:59,520 --> 00:54:02,810
במקרה זה, זה לא משנה, כי,
אני מתכוון, אני רק מנסה

1099
00:54:02,810 --> 00:54:05,310
לחשוב באמת פשוט
דוגמא לשקופית זו.

1100
00:54:05,310 --> 00:54:09,990
אבל בואו נגיד שאתה רוצה משהו
כדי להמשיך ללכת בזמן -

1101
00:54:09,990 --> 00:54:14,480
>> לוקאס פרייטס: לדוגמא, אתה
מבקש קלט עד שהאדם

1102
00:54:14,480 --> 00:54:15,370
נותן לך את הקלט הנכון.

1103
00:54:15,370 --> 00:54:19,720
אז כמו בזמן שהקלט אינו
בסדר, כל זמן שואל על זה.

1104
00:54:19,720 --> 00:54:22,920
או כמו בזמן שאתה הורים לא נותנים
כספך, כל זמן שואל על זה.

1105
00:54:22,920 --> 00:54:23,430
>> [שחוק]

1106
00:54:23,430 --> 00:54:25,390
>> LAUREN קרבאליו: אתה לא יודע איך
פעמים רבות תהיה לך לעשות את זה.

1107
00:54:25,390 --> 00:54:27,292
>> לוקאס פרייטס: כי אתה לא
יודע כמה פעמים זה

1108
00:54:27,292 --> 00:54:28,010
הולך להמשיך.

1109
00:54:28,010 --> 00:54:30,397
>> LAUREN קרבאליו: אבל ללולאה,
אתה צריך לדעת כמה פעמים.

1110
00:54:30,397 --> 00:54:33,640

1111
00:54:33,640 --> 00:54:33,860
כן?

1112
00:54:33,860 --> 00:54:38,520
>> קהל: רק כדי להבהיר, אחוזים
אומר שזה משהו שעומד

1113
00:54:38,520 --> 00:54:42,415
לקרות, אני של למספר השלם,
וn הלוכסן ההפוך -

1114
00:54:42,415 --> 00:54:43,910
>> LAUREN קרבאליו: אמצעי?

1115
00:54:43,910 --> 00:54:45,820
מי יודע מה n הלוכסן ההפוך אומר?

1116
00:54:45,820 --> 00:54:47,770
קו חדש, כן.

1117
00:54:47,770 --> 00:54:48,130
בדיוק.

1118
00:54:48,130 --> 00:54:50,500
>> לוקאס פרייטס: אתה יכול לחשוב
של n כקו חדש.

1119
00:54:50,500 --> 00:54:52,258
>> LAUREN קרבאליו: ניס.

1120
00:54:52,258 --> 00:54:55,775
>> קהל: מה לספור כי
מקף מקף [לא ברור]?

1121
00:54:55,775 --> 00:55:00,240
>> לוקאס פרייטס: מינוס מינוס רוזן
אותו הדבר בתוספת כתוספת, אבל

1122
00:55:00,240 --> 00:55:02,160
במקום להגדיל,
זה ירידה של 1.

1123
00:55:02,160 --> 00:55:04,720

1124
00:55:04,720 --> 00:55:07,185
>> LAUREN קרבאליו: כל עוד
ואילו שאלות לולאה?

1125
00:55:07,185 --> 00:55:09,460
לא?

1126
00:55:09,460 --> 00:55:13,910
אה, היינו אמור
הייתי מדלג על.

1127
00:55:13,910 --> 00:55:14,950
>> זה לעשות בזמן לולאה.

1128
00:55:14,950 --> 00:55:18,950
דומה מאוד ללולאה בזמן, למעט ב
מקרה זה אנחנו בודקים את המצב לאחר

1129
00:55:18,950 --> 00:55:23,430
הקוד בגוף
לולאה מבצעת פעם אחת.

1130
00:55:23,430 --> 00:55:27,170
אז אנחנו לבצע את הקוד
ראשון לא משנה מה.

1131
00:55:27,170 --> 00:55:31,956
אז לבדוק את מצבו, לבצע
זה שוב אם התנאי מתקיים.

1132
00:55:31,956 --> 00:55:35,450

1133
00:55:35,450 --> 00:55:38,950
>> אתה תמצא את עצמך משתמש בזה בעת
אתה שואל לקלט ממשתמש.

1134
00:55:38,950 --> 00:55:42,080
בגלל שאתה תמיד תצטרך
שואל פעם אחת, ולאחר מכן, תלוי מה

1135
00:55:42,080 --> 00:55:46,570
קלט המשתמש הוא, שאולי יש לך
reprompt ולשאול שוב ושוב אם

1136
00:55:46,570 --> 00:55:50,670
הקלט לא היה מה שאתה
ציפיתי שזה יהיה.

1137
00:55:50,670 --> 00:55:53,610
>> קהל: אז זה כמו צורה
עבור אנשים שצריכים למלא.

1138
00:55:53,610 --> 00:55:56,010
>> LAUREN קרבאליו: כן, בדיוק.

1139
00:55:56,010 --> 00:55:59,720
אתה תמצא, אני חושב, בך הראשון
Pset, אתה הולך צריך

1140
00:55:59,720 --> 00:56:04,010
להשתמש בלולאה גם מטלות לאסוף
קלט מהמשתמש.

1141
00:56:04,010 --> 00:56:08,728
>> קהל: בהתאם למצב,
הלולאות בזמן שלך נוטות לרוץ יותר

1142
00:56:08,728 --> 00:56:12,805
לעתים קרובות יותר מאשר בזמן שלולאות, כמו
על ידי אחד או משהו?

1143
00:56:12,805 --> 00:56:14,080
>> LAUREN קרבאליו: אם זה מדויק -

1144
00:56:14,080 --> 00:56:17,400
>> לוקאס פרייטס: הם תמיד צריכים לרוץ
כמות פעמים המדויקת שאתה

1145
00:56:17,400 --> 00:56:19,130
רוצה את זה כדי לרוץ.

1146
00:56:19,130 --> 00:56:23,860
כמו שאנו משתמשים לעשות בזמן כי אנחנו באמת
רציתי לקבל את הקלט לפחות פעם אחת.

1147
00:56:23,860 --> 00:56:27,220
בלולאות זמן מה, לפעמים אתה לא רוצה
כדי לבצע את זה בכלל אם זה לא

1148
00:56:27,220 --> 00:56:28,540
המקרה לביצוע.

1149
00:56:28,540 --> 00:56:31,300
אז זה תלוי בעיצוב.

1150
00:56:31,300 --> 00:56:35,900
אני מתכוון, אתה יכול גם לעשות בזמן שימוש או
בזמן שכל עוד הקוד שלך עושה את זה

1151
00:56:35,900 --> 00:56:36,905
זה אמור לעשות.

1152
00:56:36,905 --> 00:56:38,470
>> LAUREN קרבאליו: אבל אני עושה
חושב שתשובה לשלך

1153
00:56:38,470 --> 00:56:40,540
שאלה היא כנראה כן.

1154
00:56:40,540 --> 00:56:42,190
נניח שהמצב היה כוזב.

1155
00:56:42,190 --> 00:56:45,498
במקרה אחד זה יהיה לרוץ פעם אחת, ו
מקרה אחר זה הייתי רץ אפס פעמים.

1156
00:56:45,498 --> 00:56:47,370
אז, כן.

1157
00:56:47,370 --> 00:56:49,260
>> עוד שאלות?

1158
00:56:49,260 --> 00:56:50,320
כן?

1159
00:56:50,320 --> 00:56:56,443
>> קהל: יכול להיות מצב הלולאה
ללולאה במונחים של משתנה אחר

1160
00:56:56,443 --> 00:56:57,385
מ [לא ברור].

1161
00:56:57,385 --> 00:57:01,700
>> LAUREN קרבאליו: כן,
זה יכול להיות כל דבר.

1162
00:57:01,700 --> 00:57:06,420
כנראה לPsets מתחיל, אתה
לא יצטרך להיתקל במקרה כזה, אבל

1163
00:57:06,420 --> 00:57:09,878
בהחלט זה יכול להיות כל דבר.

1164
00:57:09,878 --> 00:57:12,680
>> לוקאס פרייטס: אני חושב
אנחנו עושים כאן.

1165
00:57:12,680 --> 00:57:13,290
>> LAUREN קרבאליו: האם אנחנו?

1166
00:57:13,290 --> 00:57:13,480
לא?

1167
00:57:13,480 --> 00:57:13,870
>> לוקאס פרייטס: לולאות?

1168
00:57:13,870 --> 00:57:14,600
כן.

1169
00:57:14,600 --> 00:57:16,280
>> LAUREN קרבאליו: אנחנו לא צריכים להיות.

1170
00:57:16,280 --> 00:57:17,760
אה, אנחנו נעשה עם לולאות.

1171
00:57:17,760 --> 00:57:19,250
על אישור.

1172
00:57:19,250 --> 00:57:23,180
>> למעשה, בגלל שדברנו כל כך
הרבה, בואו בעצם כל לנווט

1173
00:57:23,180 --> 00:57:28,950
מעל לstudy.cs50.net/conditions.

1174
00:57:28,950 --> 00:57:34,460
ואתה הולך לניווט למטה
לבעיות יישומון.

1175
00:57:34,460 --> 00:57:39,090
ובכן, למעשה, בזמן שאנשים מקבלים
זה להגדיר, חקר CS50 הוא

1176
00:57:39,090 --> 00:57:42,620
הולך להיות כלי שTFS שלך יהיה
להשתמש בו כדי להתכונן לסעיפים וכי

1177
00:57:42,620 --> 00:57:45,230
אתם יכולים להשתמש אם אתה מתגעגע חלקים.

1178
00:57:45,230 --> 00:57:48,980
זה הולך להכיל חבורה של שקופיות,
כמה טיפים וטריקים עבור כל

1179
00:57:48,980 --> 00:57:54,030
נושא, וכמה בעיות בפועל
עם פתרונות.

1180
00:57:54,030 --> 00:57:57,200
>> מדוע פשוט לא כולם נסתכל
בבעיה זו כאן.

1181
00:57:57,200 --> 00:58:01,630

1182
00:58:01,630 --> 00:58:04,790
>> אני מצטער, הייתי צריך להזכיר
לאנשים להביא את מחשבים ניידים היום.

1183
00:58:04,790 --> 00:58:07,050
אבל אם אין לך
מחשב נייד, זה בסדר.

1184
00:58:07,050 --> 00:58:10,140
אתה פשוט יכול לרשום את זה על
פיסת נייר או להסתכל על

1185
00:58:10,140 --> 00:58:12,890
כתפו של השכן שלך.

1186
00:58:12,890 --> 00:58:16,380
>> בואו ננסה ולכתוב תכנית ש
מנחה את המשתמש לקחת ניחוש,

1187
00:58:16,380 --> 00:58:19,250
מספר ילדים ממוצע למשפחה
יחידה בארצות הברית.

1188
00:58:19,250 --> 00:58:22,265
מספר זה הוא 2, אגב, כפי שאתה
ניתן לראות מדוגמאות אלה.

1189
00:58:22,265 --> 00:58:24,770

1190
00:58:24,770 --> 00:58:29,030
>> אנחנו רוצים להדפיס את המספר ממוצע של
ילדים למשפחה בארה"ב, אז אנחנו

1191
00:58:29,030 --> 00:58:31,080
רוצה מה?

1192
00:58:31,080 --> 00:58:35,480
אנחנו רוצים לאסוף קלט
מהמשתמש.

1193
00:58:35,480 --> 00:58:41,290
ואז תלוי מה המשתמש של
קלט הוא, אתה הולך להדפיס

1194
00:58:41,290 --> 00:58:44,850
גם זה נכון
או שזה לא נכון.

1195
00:58:44,850 --> 00:58:48,040
>> והדבר הראשון שאתה
תראה, אם תלחץ על החץ הקטן ב

1196
00:58:48,040 --> 00:58:52,190
תחתית יישומון הבעיה היא
במקום לרשום כמה pseudocode.

1197
00:58:52,190 --> 00:58:53,340
אז אתה לא בתכנות עדיין.

1198
00:58:53,340 --> 00:58:56,740
אתה פשוט מקבל אותך
רעיונות לפי סדר.

1199
00:58:56,740 --> 00:58:59,620
>> האם מישהו רוצה לעזור לוקאס
לבוא עם הזכות

1200
00:58:59,620 --> 00:59:01,270
pseudocode לבעיה זו?

1201
00:59:01,270 --> 00:59:04,900
>> לוקאס פרייטס: מה הוא הדבר הראשון
כי אנחנו כנראה צריכים לעשות כאן?

1202
00:59:04,900 --> 00:59:07,010
מה אתם חושבים?

1203
00:59:07,010 --> 00:59:08,260
>> קהל: [לא ברור]

1204
00:59:08,260 --> 00:59:12,060

1205
00:59:12,060 --> 00:59:13,290
>> לוקאס פרייטס: כן, בסדר.

1206
00:59:13,290 --> 00:59:16,610
לכן, הדפסה.

1207
00:59:16,610 --> 00:59:19,480
רק תגיד ההדפסה ממוצעת זה
מספר האנשים?

1208
00:59:19,480 --> 00:59:20,470
על אישור.

1209
00:59:20,470 --> 00:59:23,450
שאלת הדפסה, נניח.

1210
00:59:23,450 --> 00:59:25,951
אחרי שאדפיס את השאלה הזאת,
מה עליי לעשות?

1211
00:59:25,951 --> 00:59:27,875
>> קהל: קבל קלט.

1212
00:59:27,875 --> 00:59:30,690
>> לוקאס פרייטס: קבל קלט.

1213
00:59:30,690 --> 00:59:32,864
כל דבר אחר?

1214
00:59:32,864 --> 00:59:34,114
>> קהל: מצב.

1215
00:59:34,114 --> 00:59:36,770

1216
00:59:36,770 --> 00:59:38,980
>> לוקאס פרייטס: במצב.

1217
00:59:38,980 --> 00:59:41,325
>> LAUREN קרבאליו: מה זה
מצב הולך להיות?

1218
00:59:41,325 --> 00:59:43,550
>> קהל: מספר [לא ברור].

1219
00:59:43,550 --> 00:59:44,440
>> LAUREN קרבאליו: נכון.

1220
00:59:44,440 --> 00:59:46,945
>> לוקאס פרייטס: אז מה אני הולך
כדי לבדוק במצב?

1221
00:59:46,945 --> 00:59:48,750
>> קהל: אם זה שווה 2.

1222
00:59:48,750 --> 00:59:50,640
>> LAUREN קרבאליו: אם זה שווה 2.

1223
00:59:50,640 --> 00:59:51,890
בדיוק.

1224
00:59:51,890 --> 00:59:58,340

1225
00:59:58,340 --> 01:00:00,140
>> לוקאס פרייטס: האם יש משהו
אחר שאני צריך לעשות?

1226
01:00:00,140 --> 01:00:01,390
>> קהל: רוזן.

1227
01:00:01,390 --> 01:00:05,184

1228
01:00:05,184 --> 01:00:08,110
>> לוקאס פרייטס: אז אם זה
שווה ל 2, נניח -

1229
01:00:08,110 --> 01:00:14,250

1230
01:00:14,250 --> 01:00:17,960
תן לי רק לכתוב אם קלט שווה
ל 2, אז מה אני הולך

1231
01:00:17,960 --> 01:00:23,665
לעשות הוא הדפסה נכונה.

1232
01:00:23,665 --> 01:00:26,230

1233
01:00:26,230 --> 01:00:31,826
ולאחר מכן אחר, אני הולך
להדפיס שגוי.

1234
01:00:31,826 --> 01:00:34,600

1235
01:00:34,600 --> 01:00:37,720
כל דבר אחר?

1236
01:00:37,720 --> 01:00:38,670
לא?

1237
01:00:38,670 --> 01:00:40,500
>> LAUREN קרבאליו: אז אתה
יכול ללחוץ על -

1238
01:00:40,500 --> 01:00:42,290
לכולם יש את זה?

1239
01:00:42,290 --> 01:00:44,680
>> לוקאס פרייטס: האם זה הגיוני?

1240
01:00:44,680 --> 01:00:46,226
אז עכשיו בואו ננסה את הקוד הזה.

1241
01:00:46,226 --> 01:00:50,140
>> LAUREN קרבאליו: אם תלחץ קצת
חץ, זה באמת חוסך

1242
01:00:50,140 --> 01:00:51,900
pseudocode, וזה באמת מרגש.

1243
01:00:51,900 --> 01:00:56,480
ואתה יכול לעשות אותם לתוך הערות אם
אתה רוצה רק להזכיר לעצמך

1244
01:00:56,480 --> 01:00:57,075
מה לעשות.

1245
01:00:57,075 --> 01:01:01,555
>> לוקאס פרייטס: כך למשל, ראשון
אני הולך להדפיס את השאלה, ולכן

1246
01:01:01,555 --> 01:01:05,930
איך אני הולך לעשות את זה, בעצם?

1247
01:01:05,930 --> 01:01:07,050
printf.

1248
01:01:07,050 --> 01:01:12,130
אז printf, והשאלה היא ממוצעת
מספר ילדים לכל

1249
01:01:12,130 --> 01:01:14,110
משפחה בארה"ב.

1250
01:01:14,110 --> 01:01:19,070

1251
01:01:19,070 --> 01:01:21,790
>> ואז אני הולך לקבל
קלט מהמשתמש.

1252
01:01:21,790 --> 01:01:29,050

1253
01:01:29,050 --> 01:01:31,324
אז איך אני יכול לעשות את זה?

1254
01:01:31,324 --> 01:01:32,200
>> קהל: קבל Int.

1255
01:01:32,200 --> 01:01:33,076
>> LAUREN קרבאליו: GetInt.

1256
01:01:33,076 --> 01:01:33,890
>> לוקאס פרייטס: אישור.

1257
01:01:33,890 --> 01:01:35,220
אז להכריז ראשון, נכון?

1258
01:01:35,220 --> 01:01:39,300
int, בואו נקראים לזה n שווה GetInt.

1259
01:01:39,300 --> 01:01:42,610

1260
01:01:42,610 --> 01:01:44,670
>> ועכשיו מצבו.

1261
01:01:44,670 --> 01:01:49,250
אז הרשה לי לומר שאני הולך
לכאן לבדוק את תשובה.

1262
01:01:49,250 --> 01:01:57,290
אז קודם כל, אם קלט, שהוא n, שווה
ל-- איך אני הולך לכתוב את זה?

1263
01:01:57,290 --> 01:01:58,480
>> קהל: שווה שווה.

1264
01:01:58,480 --> 01:02:00,000
>> לוקאס פרייטס: מושלם.

1265
01:02:00,000 --> 01:02:00,670
אז n.

1266
01:02:00,670 --> 01:02:04,600
ושימו לב שאני עושה את החלל,
שווה, שווה, מרחב, נכון.

1267
01:02:04,600 --> 01:02:06,930
ועכשיו מה אני צריך לעשות?

1268
01:02:06,930 --> 01:02:08,820
משהו חשוב מאוד לסגנון.

1269
01:02:08,820 --> 01:02:10,070
הסוגריים המסולסלים.

1270
01:02:10,070 --> 01:02:16,570

1271
01:02:16,570 --> 01:02:17,795
>> ואז אני הולך להדפסה.

1272
01:02:17,795 --> 01:02:19,790
כיצד אוכל להדפיס?

1273
01:02:19,790 --> 01:02:22,500
printf.

1274
01:02:22,500 --> 01:02:24,568
>> קהל: יכול להיות מהוון זה?

1275
01:02:24,568 --> 01:02:27,166

1276
01:02:27,166 --> 01:02:28,380
>> לוקאס פרייטס: מס

1277
01:02:28,380 --> 01:02:31,000
זה אמור להיות כל אותיות קטנות.

1278
01:02:31,000 --> 01:02:32,250
אז זה נכון.

1279
01:02:32,250 --> 01:02:40,990

1280
01:02:40,990 --> 01:02:44,870
>> האם זה יספיק לprintf
הצהרה, או שאני מפספס משהו?

1281
01:02:44,870 --> 01:02:46,265
>> קהל: קו חדש.

1282
01:02:46,265 --> 01:02:50,220
>> לוקאס פרייטס: קו חדש, כן.

1283
01:02:50,220 --> 01:02:51,250
ועכשיו אחר.

1284
01:02:51,250 --> 01:02:57,290
>> קהל: האם יש מקום
אחרי printf, או לא?

1285
01:02:57,290 --> 01:03:00,820
>> LAUREN קרבאליו: אנחנו צריכים
בדוק את המדריך לסגנון.

1286
01:03:00,820 --> 01:03:02,260
>> קהל: זה לא צריך להיות.

1287
01:03:02,260 --> 01:03:03,510
>> לוקאס פרייטס: לא צריך להיות, על אישור.

1288
01:03:03,510 --> 01:03:05,820

1289
01:03:05,820 --> 01:03:13,605
אז אחר, printf, "זה לא נכון".

1290
01:03:13,605 --> 01:03:17,105
>> LAUREN קרבאליו: אופס, הציטוטים שלך.

1291
01:03:17,105 --> 01:03:17,950
>> לוקאס פרייטס: אישור.

1292
01:03:17,950 --> 01:03:18,600
כל דבר אחר?

1293
01:03:18,600 --> 01:03:20,770
האם זה נראה טוב?

1294
01:03:20,770 --> 01:03:21,890
>> LAUREN קרבאליו: יהיה לנו לנסות את זה?

1295
01:03:21,890 --> 01:03:23,190
>> לוקאס פרייטס: כן, בוא להפעיל אותו.

1296
01:03:23,190 --> 01:03:25,880

1297
01:03:25,880 --> 01:03:29,070
אז זה הידור, וזה
נראה שזה עובד.

1298
01:03:29,070 --> 01:03:31,465
בואו ננסה את שני ילדים.

1299
01:03:31,465 --> 01:03:34,110
זה נכון.

1300
01:03:34,110 --> 01:03:37,300
ועכשיו בואו נרוץ שוב, אבל עכשיו במקום
לשים את שני ילדים, בואו

1301
01:03:37,300 --> 01:03:40,990
אומר שאני הולך לשים כמו חמש.

1302
01:03:40,990 --> 01:03:41,515
זה לא נכון.

1303
01:03:41,515 --> 01:03:42,670
אז זה נראה שזה עובד.

1304
01:03:42,670 --> 01:03:44,160
>> LAUREN קרבאליו: למה שלא תראה להם
מה קורה אם אתה שם משהו

1305
01:03:44,160 --> 01:03:45,055
מוזר, כמו כמה מכתבים.

1306
01:03:45,055 --> 01:03:45,790
>> לוקאס פרייטס: הו, כן.

1307
01:03:45,790 --> 01:03:47,430
בואו גם לבדוק את זה.

1308
01:03:47,430 --> 01:03:51,170
מה אם המשתמש מנסה בלגן
עם התכנית שלך, והם פשוט

1309
01:03:51,170 --> 01:03:57,430
לכתוב, אני לא יודע שתיים.

1310
01:03:57,430 --> 01:03:58,320
זה הולך לומר נסה שנית.

1311
01:03:58,320 --> 01:04:00,780
>> LAUREN קרבאליו: אז GetInt
הוא מבקש מהם לנסות שוב.

1312
01:04:00,780 --> 01:04:02,115
אנחנו לא צריכים לדאוג
מזה בעצמנו.

1313
01:04:02,115 --> 01:04:02,750
>> לוקאס פרייטס: כן.

1314
01:04:02,750 --> 01:04:06,853
אז אלא אם כן אני ממש לשים מספר, זה
הולך כל זמן שואל אותי לנסות שוב.

1315
01:04:06,853 --> 01:04:08,330
>> קהל: איך להפעיל אותו?

1316
01:04:08,330 --> 01:04:10,570
>> לוקאס פרייטס: פשוט לחץ
כפתור כוכב זה.

1317
01:04:10,570 --> 01:04:11,940
>> LAUREN קרבאליו: אתה אמור לעלות.

1318
01:04:11,940 --> 01:04:13,320
הנה לך.

1319
01:04:13,320 --> 01:04:15,550
>> לוקאס פרייטס: הכוכב
הלחצן ימני שם.

1320
01:04:15,550 --> 01:04:16,040
כן?

1321
01:04:16,040 --> 01:04:19,960
>> קהל: האם זה ינחה [לא ברור]
עם מספרים עשרוניים מדי?

1322
01:04:19,960 --> 01:04:21,235
>> LAUREN קרבאליו: אני מאמין שזה יהיה.

1323
01:04:21,235 --> 01:04:22,660
>> לוקאס פרייטס: אם היא עושה מה?

1324
01:04:22,660 --> 01:04:24,990
>> LAUREN קרבאליו: אם הם מקלידים
במספר עשרוני, אני חושב

1325
01:04:24,990 --> 01:04:25,880
זה הולך לבקש.

1326
01:04:25,880 --> 01:04:26,586
>> לוקאס פרייטס: בוא נראה.

1327
01:04:26,586 --> 01:04:28,360
>> LAUREN קרבאליו: כי
זה לא int.

1328
01:04:28,360 --> 01:04:32,056

1329
01:04:32,056 --> 01:04:33,442
>> לוקאס פרייטס: כן.

1330
01:04:33,442 --> 01:04:37,370
>> LAUREN קרבאליו: אז זה זה לא int,
קבל Int יבקש ממך לנסות שוב.

1331
01:04:37,370 --> 01:04:40,795
>> קהל: אז איפה בקוד זה יהיה
המקום העשרוני, המנחה את

1332
01:04:40,795 --> 01:04:46,005
משתמשים שיש להם להיכנס
שלם באופן ספציפי?

1333
01:04:46,005 --> 01:04:48,480
>> LAUREN קרבאליו: GetInt הוא למעשה
עושה את זה בשבילנו.

1334
01:04:48,480 --> 01:04:50,600
>> קהל: לא, אני מתכוון אם אנחנו רוצים
להיכנס [לא ברור]

1335
01:04:50,600 --> 01:04:55,070
>> לוקאס פרייטס: אתה יכול להגיד כמו ממוצע
מספר הילדים בארצות הברית.

1336
01:04:55,070 --> 01:04:56,120
אני לא יודע.

1337
01:04:56,120 --> 01:05:01,761
אנחנו יכולים לומר, למשל, "בבקשה
קלט מספר שלם. "

1338
01:05:01,761 --> 01:05:04,270
>> LAUREN קרבאליו: מספר שלם שווה
למספר הממוצע.

1339
01:05:04,270 --> 01:05:06,190
אני מתכוון, זה רק איך
אתה מילה זה, נכון?

1340
01:05:06,190 --> 01:05:06,520
>> לוקאס פרייטס: כן.

1341
01:05:06,520 --> 01:05:08,420
זה לא חלק מקידוד בפועל.

1342
01:05:08,420 --> 01:05:11,000
זה יותר כמו מה
אתה הולך רוצה

1343
01:05:11,000 --> 01:05:13,987
לכתוב בתכנית שלך.

1344
01:05:13,987 --> 01:05:17,723
>> קהל: איך היינו להפעיל אותו אם הוא
היה למעשה בgedit [לא ברור].

1345
01:05:17,723 --> 01:05:19,130
במקום ללחוץ על הצגה?

1346
01:05:19,130 --> 01:05:21,180
>> לוקאס פרייטס: אנו
הראשון לעבד אותו.

1347
01:05:21,180 --> 01:05:25,080
אנחנו יכולים לעשות את זה על ידי עושה את האיפור
ואת שמו של הקובץ.

1348
01:05:25,080 --> 01:05:29,896
ולאחר מכן להפעיל אותו, אנחנו נעשה את לוכסן נקודה
והשם של התכנית.

1349
01:05:29,896 --> 01:05:36,588
>> קהל: אני מניח מה שהתכוונתי אליו היה אם
אנחנו רוצים את התכנית כדי להגיב

1350
01:05:36,588 --> 01:05:42,010
הכניסה שלהם שגויה, לא חוקית,
אתה לא צריך לשים ב--

1351
01:05:42,010 --> 01:05:45,710
>> לוקאס פרייטס: אנחנו לא תהיינה מסוגלים
לעשות את זה כי הקוד זה אומר

1352
01:05:45,710 --> 01:05:50,350
נסה שוב מגיע מקבל Int שהוא
פונקציה שכבר מיושמת

1353
01:05:50,350 --> 01:05:55,790
עבורנו באמצעות ספריית CS50, ומאז
זה כבר מיושם שם,

1354
01:05:55,790 --> 01:05:58,340
לא יכול פשוט [לא ברור].

1355
01:05:58,340 --> 01:06:00,780
>> LAUREN קרבאליו: אם אתה לא משתמש
GetInt, אז אתה יכול לעשות את זה.

1356
01:06:00,780 --> 01:06:01,490
>> לוקאס פרייטס: כן.

1357
01:06:01,490 --> 01:06:03,750
אבל אם אתה משתמש GetInt, אתה לא יכול.

1358
01:06:03,750 --> 01:06:05,427
יש עוד שאלות?

1359
01:06:05,427 --> 01:06:12,938
>> קהל: האם יש לך הלך עם כמו
GetFloat ולאחר מכן להיות מסוגל לשים

1360
01:06:12,938 --> 01:06:14,381
זה בעשרוני?

1361
01:06:14,381 --> 01:06:15,343
>> לוקאס פרייטס: כן.

1362
01:06:15,343 --> 01:06:15,824
>> קהל: אישור.

1363
01:06:15,824 --> 01:06:19,210
ואז אתה פשוט יכול קלט
לצוף שווים -

1364
01:06:19,210 --> 01:06:19,950
>> LAUREN קרבאליו: כן.

1365
01:06:19,950 --> 01:06:22,740
בדיוק אותו הדבר, פרט
לצוף במקום int.

1366
01:06:22,740 --> 01:06:27,372
>> לוקאס פרייטס: פשוט לשים את זה כאן
ולאחר מכן GetFloat שם.

1367
01:06:27,372 --> 01:06:29,795
>> קהל: כרצונך
לראות או לא לראות -

1368
01:06:29,795 --> 01:06:31,327
>> LAUREN קרבאליו: יש לנו
לא הגעתי לשם עדיין.

1369
01:06:31,327 --> 01:06:36,490
>> קהל: - עושה אי שוויון עם
צף לא [לא ברור]

1370
01:06:36,490 --> 01:06:40,290
>> קהל: מה פסיק מתכוון?

1371
01:06:40,290 --> 01:06:43,220
>> LAUREN קרבאליו: פסיק פשוט
משמעות הדבר היא כי הצהרה זו היא מוחלטת,

1372
01:06:43,220 --> 01:06:45,030
ואנחנו הולכים ללכת
לשקופית הבאה.

1373
01:06:45,030 --> 01:06:47,040
>> קהל: אז זה הכרחי
בכל פעם?

1374
01:06:47,040 --> 01:06:48,330
>> LAUREN קרבאליו: כן.

1375
01:06:48,330 --> 01:06:53,130
טוב, בסדר, אז לא לתנאים אלה,
בגלל שהם

1376
01:06:53,130 --> 01:06:54,090
מתמצת משהו.

1377
01:06:54,090 --> 01:07:00,290
אז בעצם אם משהו גורם
לאחר מכן כדי ליצור סד מתולתל

1378
01:07:00,290 --> 01:07:03,000
בלוק, לא לשים פסיק
בסופו של הדבר.

1379
01:07:03,000 --> 01:07:04,200
>> לוקאס פרייטס: אבל הכל
אחר, כן.

1380
01:07:04,200 --> 01:07:06,670
לאחר שתסיים את משפט,
לשים פסיק.

1381
01:07:06,670 --> 01:07:10,380
ואם אתה שוכח פסיק,
מהדר הולך לכעוס עליך,

1382
01:07:10,380 --> 01:07:12,640
ואתה הולך להיות
כדי לנסות ולתקן את זה.

1383
01:07:12,640 --> 01:07:16,520
>> LAUREN קרבאליו: אם אני שם פסיק
כאן, זה יהיה לעצור את זה, ואני

1384
01:07:16,520 --> 01:07:18,780
אף פעם לא היית מקבל לביצוע מה
בפנים, דרך אגב.

1385
01:07:18,780 --> 01:07:21,113
אז זה אחד מאותם חרקים נפוצים.

1386
01:07:21,113 --> 01:07:22,390
>> קהל: תמיד ביצוע.

1387
01:07:22,390 --> 01:07:22,950
>> LAUREN קרבאליו: כן.

1388
01:07:22,950 --> 01:07:25,860
במקרה זה, אנחנו תמיד הייתם
לבצע את מה שבפנים.

1389
01:07:25,860 --> 01:07:29,050
>> קהל: הסגנון שלך [לא ברור]
לצרף את זה בשבילך, חשב.

1390
01:07:29,050 --> 01:07:29,802
>> LAUREN קרבאליו: אה, זה נכון.

1391
01:07:29,802 --> 01:07:34,298
>> קהל: [לא ברור] אחת
דבר שורה [לא ברור]

1392
01:07:34,298 --> 01:07:35,286
>> קהל: כן?

1393
01:07:35,286 --> 01:07:37,756
>> קהל: האם יש לך מספר רב של
תשומות עולות בקנה אחד?

1394
01:07:37,756 --> 01:07:41,214
אז כמו שאתה יכול לשאול את המשתמשים
כדי להדפיס שני דברים?

1395
01:07:41,214 --> 01:07:42,530
>> LAUREN קרבאליו: לא משתמש -

1396
01:07:42,530 --> 01:07:44,520
>> לוקאס פרייטס: מס

1397
01:07:44,520 --> 01:07:47,040
נניח שאני רוצה גם
כדי לקבל מ 'השלם הזה.

1398
01:07:47,040 --> 01:07:49,558
אני צריך לעשות את זה בקו שונה.

1399
01:07:49,558 --> 01:07:54,992
>> קהל: אם היית לרוץ
כי, איך [לא ברור]?

1400
01:07:54,992 --> 01:07:59,438
זה יהיה להדפיס את הפקודה
שם [לא ברור]

1401
01:07:59,438 --> 01:08:00,940
ואז היית נכנסים אחד ו--

1402
01:08:00,940 --> 01:08:01,840
>> LAUREN קרבאליו: טוב, להפעיל אותו.

1403
01:08:01,840 --> 01:08:04,365
אני מתכוון, אין שום דבר שעוצר אותנו מ
פשוט מפעיל אותו ולראות מה

1404
01:08:04,365 --> 01:08:06,610
לא יקרה.

1405
01:08:06,610 --> 01:08:08,080
>> לוקאס פרייטס: אני חושב שזה
הולך מתלונן עלינו

1406
01:08:08,080 --> 01:08:08,977
כי אנחנו לא משתמשים -

1407
01:08:08,977 --> 01:08:09,751
>> LAUREN קרבאליו: אופס.

1408
01:08:09,751 --> 01:08:12,580
>> לוקאס פרייטס: זה התלונן עלינו תקין
עכשיו, כי אנחנו לא משתמשים בזה

1409
01:08:12,580 --> 01:08:21,640
משתנה, אבל אם אני עשיתי, למשל,
n הוא שווה שווה, ושווה מ '

1410
01:08:21,640 --> 01:08:26,849
שווה, אז מה יהיה
יקרה במקרה זה?

1411
01:08:26,849 --> 01:08:28,830
מה היית בתכנית זו עושה?

1412
01:08:28,830 --> 01:08:30,330
>> קהל: אני רק תוהה
איך זה היית -

1413
01:08:30,330 --> 01:08:31,550
>> LAUREN קרבאליו: היא רק רוצה
לדעת איך זה נראה

1414
01:08:31,550 --> 01:08:34,189
כמו, אני חושב, נכון?

1415
01:08:34,189 --> 01:08:36,819
אז זה לקח אחד מהם, ולאחר מכן
זה לקח שנייה אחת.

1416
01:08:36,819 --> 01:08:41,279

1417
01:08:41,279 --> 01:08:43,069
>> אני חושב שאנחנו צריכים להמשיך הלאה,
כי יש לנו עוד אחד

1418
01:08:43,069 --> 01:08:44,689
שקופיות ללכת לפני -

1419
01:08:44,689 --> 01:08:46,269
אתה רוצה למשוך את המתמטיקה?

1420
01:08:46,269 --> 01:08:47,558
>> לוקאס פרייטס: כן, במתמטיקה.

1421
01:08:47,558 --> 01:09:00,033

1422
01:09:00,033 --> 01:09:02,206
>> LAUREN קרבאליו: תן
לי רק שני אחת.

1423
01:09:02,206 --> 01:09:07,390

1424
01:09:07,390 --> 01:09:14,260
>> ישנם כמה מספרי שונה
משתנים בנתונים ג נומרית ב-C

1425
01:09:14,260 --> 01:09:18,130
ניתן לסווג לסוגים שונים,
ואלה הם אלה שיצליחו

1426
01:09:18,130 --> 01:09:19,570
לראות בתדירות הגבוהה ביותר.

1427
01:09:19,570 --> 01:09:20,910
>> וint הוא מספר שלם.

1428
01:09:20,910 --> 01:09:23,189
אתה לא יכול להיות כל שברים עשרוניים.

1429
01:09:23,189 --> 01:09:27,754
במכשיר, זה לוקח
32 ביטים לאחסון int.

1430
01:09:27,754 --> 01:09:30,450
>> מצוף יכול להיות שברים עשרוניים.

1431
01:09:30,450 --> 01:09:34,330
זה גם לוקח 32 ביטים לאחסון
לצוף במכשיר.

1432
01:09:34,330 --> 01:09:42,270
>> כפול הוא מספר עם נקודה עשרונית
נקודה שלוקחת 64 ביטים לאחסן אותו,

1433
01:09:42,270 --> 01:09:44,470
מה שאומר שאתה יכול פשוט יש לי
דיוק רב יותר, כי

1434
01:09:44,470 --> 01:09:46,426
אתה יכול לקבל יותר -

1435
01:09:46,426 --> 01:09:47,785
מה שאתה קורא לזה?

1436
01:09:47,785 --> 01:09:48,640
>> לוקאס פרייטס: כן, זה יותר.

1437
01:09:48,640 --> 01:09:52,140
>> LAUREN קרבאליו: מקומות נוספים
לאחר הנקודה העשרונית.

1438
01:09:52,140 --> 01:09:57,140
ועוד ארוך הוא מספר שלם
שלוקח 64 ביטים ל

1439
01:09:57,140 --> 01:09:58,395
זה כואב במכשיר.

1440
01:09:58,395 --> 01:10:00,278
>> לוקאס פרייטס: אז זה יכול להיות
גדול יותר מints יכול להיות.

1441
01:10:00,278 --> 01:10:03,320

1442
01:10:03,320 --> 01:10:08,380
>> LAUREN קרבאליו: הדבר על נתונים
סוגים בC הוא שהם יגידו לך מה

1443
01:10:08,380 --> 01:10:11,050
סוג של נתונים אתה יכול לאחסן
במשתנה שלך.

1444
01:10:11,050 --> 01:10:15,860
הם אומרים לך איך אתה יכול להשתמש בזה
משתנה בתכנית שלך.

1445
01:10:15,860 --> 01:10:19,650
זה חשוב מאוד רק כדי לעקוב אחר
איזה סוג נתונים אתה משתמש, ואם

1446
01:10:19,650 --> 01:10:23,070
אתה צריך לעשות כדי להפיל מסוג הנתונים
למשנו, לוודא שאתה יודע

1447
01:10:23,070 --> 01:10:25,250
בדיוק מה שקורה כאשר זה
ליהוק מתרחש.

1448
01:10:25,250 --> 01:10:28,520
ואתם תראו דוגמא בהמשך
בשקופיות של אלה

1449
01:10:28,520 --> 01:10:31,490
טעות שיכול להתרחש.

1450
01:10:31,490 --> 01:10:35,300
>> בואו נסתכל קצת מתמטיקה ב-C ו
חושב באמת בזהירות, אני מניח,

1451
01:10:35,300 --> 01:10:38,470
על מה שקורה כאשר זה
המתמטיקה מתקיימת.

1452
01:10:38,470 --> 01:10:43,552
בשורה הראשונה, מה
קורה כאשר אני מצהיר x?

1453
01:10:43,552 --> 01:10:48,921
>> קהל: אתה מאפשר
x להיות משהו?

1454
01:10:48,921 --> 01:10:49,700
>> LAUREN קרבאליו: כן.

1455
01:10:49,700 --> 01:10:54,040
ובכן, אני באמת שואל את ההפעלה
מערכת ל32 ביטים של זיכרון, נכון?

1456
01:10:54,040 --> 01:10:57,890
שבו אני יכול לאחסן int, ו
אני הולך לקרוא לזה x int.

1457
01:10:57,890 --> 01:11:01,370
>> לוקאס פרייטס: הולך בעיקרון לזכרו
ומציאת מקום שיש 32

1458
01:11:01,370 --> 01:11:05,290
ביטים ואומרים, היי, אני רוצים את המרחב הזה,
וזה הולך להיקרא x.

1459
01:11:05,290 --> 01:11:08,590
אז אתה פשוט פחות או יותר ממצא
תיבה בזיכרון שלך כדי

1460
01:11:08,590 --> 01:11:10,440
ערכי חנות עבור x.

1461
01:11:10,440 --> 01:11:13,980
>> LAUREN קרבאליו: ואז אני לאתחל
x, מה שאומר שאני פשוט לאחסן

1462
01:11:13,980 --> 01:11:20,270
ערך של 2 במקום הזה, שהנתח
של זיכרון, שבקשנו הפעלה

1463
01:11:20,270 --> 01:11:21,860
מערכת ל.

1464
01:11:21,860 --> 01:11:25,090
וכאן מה שאנחנו עושים הוא
אנחנו בעצם הכרזה ו

1465
01:11:25,090 --> 01:11:29,060
אתחול y בשורה אחת במקום
בשתי שורות כמו שעשינו עד כאן,

1466
01:11:29,060 --> 01:11:33,960
אשר גם הוא בסדר גמור, אנחנו
הוספת 1 עד x, ואנחנו אחסון ש

1467
01:11:33,960 --> 01:11:34,950
הערך בy.

1468
01:11:34,950 --> 01:11:39,360
>> לוקאס פרייטס: אז בעצם מה זה
השורה עושה, הוא מוצא עכשיו תיבה עבור y,

1469
01:11:39,360 --> 01:11:41,990
ואז הערך שלו, כי הדבר
אתה הולך לשים בתוך הקופסה, הוא

1470
01:11:41,990 --> 01:11:43,800
הולך להיות הערך של x בתוספת 1.

1471
01:11:43,800 --> 01:11:45,850
אז יש לו תיבה זו עבור y.

1472
01:11:45,850 --> 01:11:49,980
הוא מקבל את הערך של x, נראה
כאן, ותראה שזה 2.

1473
01:11:49,980 --> 01:11:53,035
שים את זה שם, בתוספת 1, ולכן
זה מכניס 3 שם.

1474
01:11:53,035 --> 01:11:54,290
האם זה הגיוני?

1475
01:11:54,290 --> 01:11:55,780
אז y יהיה 2 במקרה זה.

1476
01:11:55,780 --> 01:11:58,993

1477
01:11:58,993 --> 01:12:00,770
>> LAUREN קרבאליו: בסדר, מגניב.

1478
01:12:00,770 --> 01:12:06,010
ראינו כמה בנוסף לכך, אז בואו עכשיו חושבים
על החלוקה בג הנה אני

1479
01:12:06,010 --> 01:12:11,490
הכרזה ואתחול לצוף
בשם תשובה וחלוקת 1 על ידי 10,

1480
01:12:11,490 --> 01:12:14,860
ולאחר מכן אני מדפיס את התשובה
לשני מקומות אחרי נקודה עשרונית.

1481
01:12:14,860 --> 01:12:18,800
ולציין כאן, בהצהרת printf שלי,
כשאני רוצה להדפיס משהו לשני

1482
01:12:18,800 --> 01:12:25,600
מקומות עשרוניים,% f .2 היא
מה שאני רוצה להשתמש בו.

1483
01:12:25,600 --> 01:12:28,880

1484
01:12:28,880 --> 01:12:31,760
אז הנקודה 2 היא רק אומרת
אני זקוק לשני מקומות אחרי

1485
01:12:31,760 --> 01:12:34,980
עשרוני הדפיס.

1486
01:12:34,980 --> 01:12:38,740
>> עכשיו, מה הולך לקרות
אם אני מפעיל את הקוד הזה?

1487
01:12:38,740 --> 01:12:40,500
האם יש למישהו רעיון?

1488
01:12:40,500 --> 01:12:42,721
מה היית להדפיס?

1489
01:12:42,721 --> 01:12:45,010
>> לוקאס פרייטס: מה הם
אנו מצפים לקבל.

1490
01:12:45,010 --> 01:12:46,810
>> LAUREN קרבאליו: מה לעשות
אנחנו קודם כל רוצים,?

1491
01:12:46,810 --> 01:12:48,871
>> לוקאס פרייטס: [לא ברור]

1492
01:12:48,871 --> 01:12:51,120
>> LAUREN קרבאליו: 0.1, כן.

1493
01:12:51,120 --> 01:12:52,325
אבל מה יהיה להדפיס?

1494
01:12:52,325 --> 01:12:53,275
>> קהל: [לא ברור]

1495
01:12:53,275 --> 01:12:56,760
>> LAUREN קרבאליו: ובכן, לא, בעצם.

1496
01:12:56,760 --> 01:13:01,400
זה מה שדיברתי עליו למה אתה
צריך לעקוב אחר זהיר מאוד של

1497
01:13:01,400 --> 01:13:02,550
סוגי הנתונים שלך.

1498
01:13:02,550 --> 01:13:05,000
אז, מה נתוני סוג זה?

1499
01:13:05,000 --> 01:13:06,250
האם int, נכון?

1500
01:13:06,250 --> 01:13:07,600
אין מקום עשרוני.

1501
01:13:07,600 --> 01:13:08,770
10 הוא גם int.

1502
01:13:08,770 --> 01:13:09,930
אין מקום עשרוני.

1503
01:13:09,930 --> 01:13:15,770
>> אם אני מחלק int ידי int, אני מקבל
int שאינו 0.1, כי ints

1504
01:13:15,770 --> 01:13:18,630
לא יכול להיות מקומות אחרי נקודה עשרונית, אבל רק 0.

1505
01:13:18,630 --> 01:13:21,005
בגלל int פשוט חותך
מהמקומות אחרי הנקודה העשרונית.

1506
01:13:21,005 --> 01:13:24,280
>> לוקאס פרייטס: אז בכל פעם שאתה עושה
פעולות עם ints, אתה הולך

1507
01:13:24,280 --> 01:13:25,990
לקבל int כתשובה.

1508
01:13:25,990 --> 01:13:28,930
אז בעצם, מה שהמחשב
הוא עושה, זה מתחלק 1 על ידי

1509
01:13:28,930 --> 01:13:31,520
10, והוא מקבל 0.1.

1510
01:13:31,520 --> 01:13:34,870
אבל אז זה כמו, רגע, זה הוא
אמור להיות מספר שלם, אז אתה פשוט

1511
01:13:34,870 --> 01:13:37,045
להתעלם 0.1, כך שזה עכשיו רק 0.

1512
01:13:37,045 --> 01:13:41,782
>> LAUREN קרבאליו: לכן, כאשר אני מדפיס את זה
החוצה, אני מקבל 0.00 במקום 0.10.

1513
01:13:41,782 --> 01:13:44,075
>> לוקאס פרייטס: האם זה הגיוני?

1514
01:13:44,075 --> 01:13:45,530
>> LAUREN קרבאליו: זה סוג
של מצער, נכון?

1515
01:13:45,530 --> 01:13:47,290
>> לוקאס פרייטס: אז איך אנחנו יכולים לתקן את זה?

1516
01:13:47,290 --> 01:13:48,620
>> LAUREN קרבאליו: בוא
לנסות ולתקן את זה.

1517
01:13:48,620 --> 01:13:51,570

1518
01:13:51,570 --> 01:13:54,810
הנה דוגמא של איפה אני
ליהוק 1 למעשה

1519
01:13:54,810 --> 01:13:56,650
ו10 לצפו.

1520
01:13:56,650 --> 01:13:58,800
אז עכשיו, 1 כבר לא int.

1521
01:13:58,800 --> 01:14:00,020
1 הוא לצוף.

1522
01:14:00,020 --> 01:14:02,590
דרך אגב, זה רק התחביר
כאשר אתה רוצה להפיל מאחד

1523
01:14:02,590 --> 01:14:03,410
סוג הנתונים למשנו.

1524
01:14:03,410 --> 01:14:07,140
אתה יכול פשוט לשים את סוג הנתונים ב
סוגריים ויש שפשוט להקדים

1525
01:14:07,140 --> 01:14:10,860
את הערך שאתה מטיל.

1526
01:14:10,860 --> 01:14:15,800
>> אז הנה, אני מחלק לצוף על ידי
מצוף כדי לקבל תשובה לצוף.

1527
01:14:15,800 --> 01:14:19,535
וכן, זה היית ב
למעשה להדפיס 0.10.

1528
01:14:19,535 --> 01:14:20,470
האם זה הגיוני?

1529
01:14:20,470 --> 01:14:24,110
>> לוקאס פרייטס: אז ליהוק הסוג הוא רק
המרה מסוג אחד למשנו.

1530
01:14:24,110 --> 01:14:29,460
אז לצוף 1 הוא למעשה 1.000.

1531
01:14:29,460 --> 01:14:33,400
לא בדיוק זה, אבל זה משהו
עם מקומות עשרוניים

1532
01:14:33,400 --> 01:14:34,715
כי הוא בעצם 1.

1533
01:14:34,715 --> 01:14:35,960
האם זה הגיוני?

1534
01:14:35,960 --> 01:14:36,260
כן?

1535
01:14:36,260 --> 01:14:40,990
>> קהל: מה אם עשה תשובה לצוף
שווה 1.0 מחולק 10?

1536
01:14:40,990 --> 01:14:43,940
>> LAUREN קרבאליו: אתה באמת הולך
לראות כי בשקופית הבאה.

1537
01:14:43,940 --> 01:14:47,150
זה בעצם השקופית הבאה מאוד שלנו.

1538
01:14:47,150 --> 01:14:50,740
זהו למעשה יותר נחמד
הקלד ליהוק, אני חושב.

1539
01:14:50,740 --> 01:14:53,470
אז שני אלה הם צף רק על ידי
טבעה של העובדה שהם

1540
01:14:53,470 --> 01:14:54,926
יש מקומות אחרי נקודה עשרונית.

1541
01:14:54,926 --> 01:14:55,300
כן?

1542
01:14:55,300 --> 01:14:57,670
>> קהל: מה אם עשה [לא ברור]

1543
01:14:57,670 --> 01:14:59,480
מחולק ב10?

1544
01:14:59,480 --> 01:15:02,270
>> LAUREN קרבאליו: למעשה לצוף
מחולק בint בעצם נותן לך

1545
01:15:02,270 --> 01:15:03,670
לצוף, כך שיעבוד בסדר גמור.

1546
01:15:03,670 --> 01:15:08,070

1547
01:15:08,070 --> 01:15:09,120
>> חכה, זה שכולם מבין את זה?

1548
01:15:09,120 --> 01:15:12,720
כי זה הולך להיות באמת
עסקה גדולה בPset1, בעצם.

1549
01:15:12,720 --> 01:15:13,130
כן?

1550
01:15:13,130 --> 01:15:14,762
>> קהל: האם אתה יכול פשוט במהירות
תעבור על החלק האדום?

1551
01:15:14,762 --> 01:15:16,380
>> LAUREN קרבאליו: החלק האדום, כן.

1552
01:15:16,380 --> 01:15:17,250
לוקאס, אתה רוצה?

1553
01:15:17,250 --> 01:15:18,020
>> לוקאס פרייטס: אישור.

1554
01:15:18,020 --> 01:15:20,570
אז לזכור כי אחוזים
הוא מציין מיקום.

1555
01:15:20,570 --> 01:15:22,150
זה כמו בחלל ריק.

1556
01:15:22,150 --> 01:15:26,240
אז בואו ננסה להבין הכל
מה שקורה כאן.

1557
01:15:26,240 --> 01:15:28,170
אחוזים אומר שזה מציין מיקום.

1558
01:15:28,170 --> 01:15:33,640
ואז יש לך את f, כלומר
מציין המיקום הזה הוא בשביל לצוף.

1559
01:15:33,640 --> 01:15:38,870
הדבר האחרון שיש לנו כאן הוא
.2, מה שאומר שאני רוצה שיהיה שני

1560
01:15:38,870 --> 01:15:42,410
מקומות עשרוניים למצוף.

1561
01:15:42,410 --> 01:15:48,510
>> אם אני רק היה f%, שהם זה יהיה לשים
חבורה של מקומות אחרי נקודה עשרונית.

1562
01:15:48,510 --> 01:15:54,170
אז רק אני יכול לשים .2 או .1 או .5, או
מה, וזה הולך לשים את זה

1563
01:15:54,170 --> 01:15:55,950
מספר המקומות עשרוניים.

1564
01:15:55,950 --> 01:15:59,950
הדבר היחיד הוא שאם אתה מכניס כמו
.100 או -1,000, זה לא ממש

1565
01:15:59,950 --> 01:16:04,200
הולך לשים את כל מקומות עשרוניים אלה
כי זה אין לו מספיק זיכרון

1566
01:16:04,200 --> 01:16:06,432
יש דיוק ש.

1567
01:16:06,432 --> 01:16:07,955
>> יש עוד שאלות?

1568
01:16:07,955 --> 01:16:08,450
כן?

1569
01:16:08,450 --> 01:16:12,970
>> קהל: אז תצוף רק מאפשר
לך ללכת מעבר למספרים שלמים?

1570
01:16:12,970 --> 01:16:13,720
>> לוקאס פרייטס: כן.

1571
01:16:13,720 --> 01:16:17,345
>> LAUREN קרבאליו: ובכן, לצוף רק
מאפשר לך יש מקומות אחרי נקודה עשרונית.

1572
01:16:17,345 --> 01:16:20,460
>> לוקאס פרייטס: זה רק אומר שאתה
עכשיו יכול להיות מספרים עשרוניים.

1573
01:16:20,460 --> 01:16:25,728
>> קהל: למה לנו
אי פעם להשתמש במספרים שלמים?

1574
01:16:25,728 --> 01:16:27,870
>> לוקאס פרייטס: למה שיהיה
אתה משתמש במספרים שלמים?

1575
01:16:27,870 --> 01:16:31,810
אולי אם אתה סומך 0-10,
ברצונך להשתמש דווקא מספר שלם.

1576
01:16:31,810 --> 01:16:33,370
אתה לא צריך להשתמש במצוף.

1577
01:16:33,370 --> 01:16:35,430
במצבים מסוימים, שאתה לא יודע
צריך בעצם -

1578
01:16:35,430 --> 01:16:37,040
>> LAUREN קרבאליו: אולי אתה
לא רוצה שברים עשרוניים.

1579
01:16:37,040 --> 01:16:38,600
>> לוקאס פרייטס: אולי אתה לא
רוצה להשתמש במצוף.

1580
01:16:38,600 --> 01:16:42,660
>> LAUREN קרבאליו: הדבר השני הוא,
זוכר, גם את המצוף וint

1581
01:16:42,660 --> 01:16:46,170
לקחת 32 ביטים לאחסן אותם, ואולי
אתה לא רוצה לבזבז ביטים על

1582
01:16:46,170 --> 01:16:48,062
מקומות אחרי נקודה עשרונית.

1583
01:16:48,062 --> 01:16:49,750
>> לוקאס פרייטס: כן.

1584
01:16:49,750 --> 01:16:51,910
אז כמו, רק לחשוב על זה.

1585
01:16:51,910 --> 01:16:55,200
יש לך 32 ביטים לשניהם
int ולצוף.

1586
01:16:55,200 --> 01:16:59,400
עבור int, כל 32 ביטים אלה
תלך לחלק המספר השלם.

1587
01:16:59,400 --> 01:17:03,460
אם אתה משתמש במצוף עם 32 ביטים, אתה
יש חלק בשימוש הזיכרון הזה

1588
01:17:03,460 --> 01:17:06,820
למספר, למספר השלם,
וחלק האחר בשימוש עבור

1589
01:17:06,820 --> 01:17:08,300
מקומות אחרי נקודה עשרונית.

1590
01:17:08,300 --> 01:17:12,370
אז זה אומר שאתה לא יכול להגיע אל
מספרים גדולים מאוד עם צף בגלל

1591
01:17:12,370 --> 01:17:16,020
לצוף כבר משתמש הרבה
זיכרון למקומות אחרי הנקודה העשרונית.

1592
01:17:16,020 --> 01:17:17,014
כן?

1593
01:17:17,014 --> 01:17:21,487
>> קהל: זה תשובה הראשונה,
מה בדיוק הוא עושה?

1594
01:17:21,487 --> 01:17:25,214
האם זה הגדרת הערך של float שווה
למיקום זה כדי שתוכל

1595
01:17:25,214 --> 01:17:26,954
זוכר אותו בשורה הבאה?

1596
01:17:26,954 --> 01:17:28,942
זה אומר לצוף תשובה.

1597
01:17:28,942 --> 01:17:29,770
>> לוקאס פרייטס: כן.

1598
01:17:29,770 --> 01:17:37,200
לכן, תשובה לצוף אומרת שאתה מקבל
עכשיו קצת דלי בזיכרון

1599
01:17:37,200 --> 01:17:40,050
מחזיק לצוף, וזה הולך
כדי להיקרא תשובה.

1600
01:17:40,050 --> 01:17:42,040
אז זה מה שתשובה עושה לצוף.

1601
01:17:42,040 --> 01:17:44,720
>> ואז אתה אומר שחלק פנימי של
זה, אתה הולך לשים

1602
01:17:44,720 --> 01:17:46,470
התוצאה של זה.

1603
01:17:46,470 --> 01:17:52,610
אז אתה הולך לעשות 1.0 מחולק
10.0, אתה מקבל 0.1, ולאחר מכן אתה מכניס

1604
01:17:52,610 --> 01:17:53,490
בתוך זה של תשובה.

1605
01:17:53,490 --> 01:17:57,540
>> LAUREN קרבאליו: אז בשורה אחת, אנחנו
הכרזה ואתחול לצוף זה

1606
01:17:57,540 --> 01:18:00,070
בשם תשובה.

1607
01:18:00,070 --> 01:18:04,470
>> לוקאס פרייטס: מעניין, אם כי
זה רק קו אחד, הוא עושה

1608
01:18:04,470 --> 01:18:05,570
פעולות מרובות.

1609
01:18:05,570 --> 01:18:08,800
זה פשוט דרך של הקזת C
אתה משתמש בפחות קוד.

1610
01:18:08,800 --> 01:18:12,310
זה אותו הדבר כמו משולש
מפעיל, איך אתה יכול פשוט לעשות

1611
01:18:12,310 --> 01:18:13,810
[לא ברור] בשורה אחת.

1612
01:18:13,810 --> 01:18:18,860
זה בעצם עושה את אותו דבר כמו
עושה תשובה לצוף, פסיק, ו

1613
01:18:18,860 --> 01:18:23,060
אז תשובה שווה את זה, אבל במקום
גורם לך לעשות שני קווים על כך,

1614
01:18:23,060 --> 01:18:24,160
זה כמו קיצור דרך.

1615
01:18:24,160 --> 01:18:24,520
כן?

1616
01:18:24,520 --> 01:18:27,929
>> קהל: אז אם אתה רץ זה,
זה יהיה 0.10?

1617
01:18:27,929 --> 01:18:30,120
>> לוקאס פרייטס: כן.

1618
01:18:30,120 --> 01:18:30,530
כן?

1619
01:18:30,530 --> 01:18:34,540
>> קהל: האם לענות למעשה קוד,
או שזה רק שם?

1620
01:18:34,540 --> 01:18:36,010
>> LAUREN קרבאליו: זה
הוא למעשה קוד.

1621
01:18:36,010 --> 01:18:37,750
זה מה שאנחנו הולכים
לשם המשתנה שלנו.

1622
01:18:37,750 --> 01:18:39,770
>> קהל: אז זה פשוט
שם [לא ברור].

1623
01:18:39,770 --> 01:18:40,270
>> LAUREN קרבאליו: כן.

1624
01:18:40,270 --> 01:18:44,670
אני יכול לומר x לצוף שווה 1.0.

1625
01:18:44,670 --> 01:18:47,160
>> לוקאס פרייטס: העניין הוא, כי
השם המשתנה הוא

1626
01:18:47,160 --> 01:18:48,400
משהו שאתה משתמש.

1627
01:18:48,400 --> 01:18:49,690
זה חשוב לך.

1628
01:18:49,690 --> 01:18:52,660
לתכנית בפועל, הדבר היחיד
מה שחשוב הוא הערך שאתה

1629
01:18:52,660 --> 01:18:55,570
יש בתוך הדלי.

1630
01:18:55,570 --> 01:18:59,270
הסיבה לכך שיש לך משתנה ו
שמות של משתנים הוא כל כך היית יודע

1631
01:18:59,270 --> 01:19:01,910
עם, כמו מה שיש לך עסק
איזה סוג של נתונים אתה

1632
01:19:01,910 --> 01:19:03,040
גישה בכל פעם.

1633
01:19:03,040 --> 01:19:07,580
אבל לקוד עצמו, אם אתה קורא
זה ענה או שאלה או משהו כזה,

1634
01:19:07,580 --> 01:19:09,530
פחות או יותר, זה לא משנה.

1635
01:19:09,530 --> 01:19:10,060
זה לא משנה.

1636
01:19:10,060 --> 01:19:12,910
כל עוד אתה עולה בקנה אחד בכל
ההתרחשות ואז אתה קורא לזה

1637
01:19:12,910 --> 01:19:13,620
משהו אחר.

1638
01:19:13,620 --> 01:19:14,880
כן?

1639
01:19:14,880 --> 01:19:17,208
>> קהל: האם המשתנים
מעבר לפונקציה?

1640
01:19:17,208 --> 01:19:20,902
כמו אם היית ליצור סוגר
, יכול [לא ברור] אתה פשוט

1641
01:19:20,902 --> 01:19:21,806
[לא ברור] לענות שוב?

1642
01:19:21,806 --> 01:19:22,550
>> LAUREN קרבאליו: לא.

1643
01:19:22,550 --> 01:19:23,300
>> קהל: [לא ברור]

1644
01:19:23,300 --> 01:19:24,200
>> LAUREN קרבאליו: לא.

1645
01:19:24,200 --> 01:19:26,930
זה יהיה מחוץ לתחום
של המשתנה הזה בפרט.

1646
01:19:26,930 --> 01:19:29,940
ובעצם, זה סוג של
מעניין, כי כאשר יש לנו

1647
01:19:29,940 --> 01:19:33,010
דברים כמו לולאות או אם אלה
תנאים, אם אתה מכריז על משתנה

1648
01:19:33,010 --> 01:19:36,330
בתוך קבוצה נוספת של סוגריים מסולסלים,
זה באמת קיים רק

1649
01:19:36,330 --> 01:19:39,800
בתוך הסוגריים המסולסלים האלה.

1650
01:19:39,800 --> 01:19:43,088
>> קהל: הערה אחת אחרון על
[לא ברור] צף.

1651
01:19:43,088 --> 01:19:46,076
למה אתה בכלל רוצה להשתמש ints?

1652
01:19:46,076 --> 01:19:49,562
זה יותר מהערה צדדית מ
שום דבר, אבל המחשב שלך הוא

1653
01:19:49,562 --> 01:19:53,048
טוב יותר באופן משמעותי בטיפול בints
ממה שהוא בצף טיפול.

1654
01:19:53,048 --> 01:19:55,040
זה כמו סדר
גודל מהר יותר.

1655
01:19:55,040 --> 01:20:00,360
אז אם אנחנו רק טיפלנו רק צף,
דברים יהיו הרבה יותר איטיים.

1656
01:20:00,360 --> 01:20:03,080
>> LAUREN קרבאליו: למעשה, נראה
להיות בעיה עם צף.

1657
01:20:03,080 --> 01:20:06,400
>> לוקאס פרייטס: סוג של הסיבה ל
כי, אתה יכול לחשוב, הוא כיצד בינארי

1658
01:20:06,400 --> 01:20:08,480
אתה יכול לייצג מספרים שלמים
על ידי הצבת של 0 ו -1 של.

1659
01:20:08,480 --> 01:20:09,980
>> LAUREN קרבאליו: זה
הדבר הבא.

1660
01:20:09,980 --> 01:20:10,480
>> לוקאס פרייטס: אישור.

1661
01:20:10,480 --> 01:20:10,740
מדהים.

1662
01:20:10,740 --> 01:20:11,480
>> LAUREN קרבאליו: רק
להחזיק את המחשבה הזאת.

1663
01:20:11,480 --> 01:20:13,800
>> לוקאס פרייטס: בסדר, אני
להגיד לך מאוחר יותר.

1664
01:20:13,800 --> 01:20:16,920
>> LAUREN קרבאליו: לפני שנגיע למה
לוקאס בדיוק אמר, מפעיל

1665
01:20:16,920 --> 01:20:17,420
קדימות.

1666
01:20:17,420 --> 01:20:18,220
זה שכל ישר.

1667
01:20:18,220 --> 01:20:20,830
אתם עשיתם את זה מספיק.

1668
01:20:20,830 --> 01:20:24,705
לכן, רק אם משהו לא בסוגריים,
זה יקרה קודם.

1669
01:20:24,705 --> 01:20:27,970
זה הכפל גובר
מעל בנוסף,

1670
01:20:27,970 --> 01:20:30,330
חיסור, דברים כאלה.

1671
01:20:30,330 --> 01:20:34,700
אז בעצם, רק האם מישהו רוצה
תגיד לי מה מספר אחד בפועל

1672
01:20:34,700 --> 01:20:36,674
מוערך כ?

1673
01:20:36,674 --> 01:20:37,638
>> קהל: 27.

1674
01:20:37,638 --> 01:20:39,090
>> LAUREN קרבאליו: 27?

1675
01:20:39,090 --> 01:20:39,550
כן.

1676
01:20:39,550 --> 01:20:41,975
>> לוקאס פרייטס: תן לי לתת לי
סוכריות לאנשים.

1677
01:20:41,975 --> 01:20:42,850
>> LAUREN קרבאליו: בסדר.

1678
01:20:42,850 --> 01:20:44,100
מה לגבי מספר שתיים?

1679
01:20:44,100 --> 01:20:46,880

1680
01:20:46,880 --> 01:20:48,340
מה לגבי מספר שתיים?

1681
01:20:48,340 --> 01:20:49,280
>> קהל: 22.

1682
01:20:49,280 --> 01:20:50,680
>> LAUREN קרבאליו: 22, כן.

1683
01:20:50,680 --> 01:20:51,570
אני לא יודע מי קיבלתי את זה.

1684
01:20:51,570 --> 01:20:52,694
מספר שלוש?

1685
01:20:52,694 --> 01:20:54,050
>> קהל: 10.

1686
01:20:54,050 --> 01:20:55,300
>> LAUREN קרבאליו: 10, כן.

1687
01:20:55,300 --> 01:20:58,150

1688
01:20:58,150 --> 01:20:58,490
מגניב.

1689
01:20:58,490 --> 01:21:01,280
אז מודולו.

1690
01:21:01,280 --> 01:21:03,700
לוקאס, אתה רוצה להסביר מודולו?

1691
01:21:03,700 --> 01:21:07,150
>> לוקאס פרייטס: מודולו הוא מפעיל זה
כי הוא בעצם מאוד שימושי עבור

1692
01:21:07,150 --> 01:21:09,470
חבורה של בעיות.

1693
01:21:09,470 --> 01:21:15,270
אם אני עושה 55 מודולו 10, מה שהיא עושה
זה נניח שאני רוצה

1694
01:21:15,270 --> 01:21:16,970
לחלק 55 ידי 10.

1695
01:21:16,970 --> 01:21:18,240
מה אני מקבל?

1696
01:21:18,240 --> 01:21:21,380
זה מרגיש בדיוק כמו אם אני למעשה רק
עושה את החלוקה, מה הוא

1697
01:21:21,380 --> 01:21:22,450
פעם הראשונה שיש לי את המספר השלם?

1698
01:21:22,450 --> 01:21:23,190
>> קהל: 5.

1699
01:21:23,190 --> 01:21:24,080
>> לוקאס פרייטס: 5.

1700
01:21:24,080 --> 01:21:26,230
ואז השארית היא 5, נכון?

1701
01:21:26,230 --> 01:21:29,250
אז זה כמו 5 פעמים 10 בתוספת 5.

1702
01:21:29,250 --> 01:21:35,570
בעיקרון, מה מודולו אין, הוא מנסה
מחלק את המספר הזה על ידי זה, ו

1703
01:21:35,570 --> 01:21:37,440
היא רואה מה היא השארית
של החטיבה.

1704
01:21:37,440 --> 01:21:40,080
>> LAUREN קרבאליו: אז זה פשוט
מחזיר את השארית.

1705
01:21:40,080 --> 01:21:41,920
אז מספר אחד הוא מה?

1706
01:21:41,920 --> 01:21:42,560
5.

1707
01:21:42,560 --> 01:21:43,336
מספר שתיים?

1708
01:21:43,336 --> 01:21:44,150
>> קהל: 3.

1709
01:21:44,150 --> 01:21:44,934
>> LAUREN קרבאליו: 3.

1710
01:21:44,934 --> 01:21:46,240
מספר שלוש?

1711
01:21:46,240 --> 01:21:47,190
0.

1712
01:21:47,190 --> 01:21:48,410
וארבעה הוא 1.

1713
01:21:48,410 --> 01:21:48,665
בדיוק.

1714
01:21:48,665 --> 01:21:49,915
>> לוקאס פרייטס: פשוט, לא?

1715
01:21:49,915 --> 01:21:54,270

1716
01:21:54,270 --> 01:21:56,560
>> LAUREN קרבאליו: למה שלא לדלג על זה
רק בגלל שבאמת אין לנו

1717
01:21:56,560 --> 01:21:59,780
זמן, ונראה שאנשים מבינים.

1718
01:21:59,780 --> 01:22:03,330
אז הנה מה שהיה לוקאס
רק מדבר.

1719
01:22:03,330 --> 01:22:08,030
>> לוקאס פרייטס: עוד סיבה למה אני
אשתמש ints במקום צף הוא

1720
01:22:08,030 --> 01:22:10,840
שצף הם מאוד לא מדויקים.

1721
01:22:10,840 --> 01:22:12,720
ומדוע הם לא מדויקים?

1722
01:22:12,720 --> 01:22:17,140
דוד אמר שכדי לייצג מספר שלם,
לדוגמא, אנו משתמשים 0 ו

1723
01:22:17,140 --> 01:22:17,810
1 של, נכון?

1724
01:22:17,810 --> 01:22:22,370
ואז אתה בעצם עושה
כפל, לעשות את כל אלה

1725
01:22:22,370 --> 01:22:30,000
פעולות לדעת מה מספר עשרוני
יש לך במקום בינארי.

1726
01:22:30,000 --> 01:22:33,040
>> מה קורה עכשיו אם אני מנסה
לשים נקודות עשרוניות?

1727
01:22:33,040 --> 01:22:37,680
למעשה, לדוגמא, אם יש לי
המספר כמו 3.33333?

1728
01:22:37,680 --> 01:22:40,250
זה מרגיש כמו 10 מעל 3.

1729
01:22:40,250 --> 01:22:44,950
איך אני הולך לאחסן את כל
3 זה שיש לי אחרי זה?

1730
01:22:44,950 --> 01:22:47,120
זה ממש קשה, נכון?

1731
01:22:47,120 --> 01:22:49,580
אתה לא יכול פשוט לומר למחשב,
היי, יש לי 3, ו

1732
01:22:49,580 --> 01:22:50,520
אז אתה עושה את זה לנצח.

1733
01:22:50,520 --> 01:22:52,810
למעשה המחשב אינו
מספיק חכם בשביל זה.

1734
01:22:52,810 --> 01:22:58,300
>> אז בעצם את כל המחשב שלך עושה הוא
שהוא מנסה לשים את ספרות רבות ככל

1735
01:22:58,300 --> 01:23:00,950
יכול אותו לזכר שיש לך.

1736
01:23:00,950 --> 01:23:05,890
אז בואו נגיד שזה הולך
אומר 3.3333, וזהו זה.

1737
01:23:05,890 --> 01:23:10,690
אז זה לא מסוגל להביע את בעצם
בדיוק מה הוא המצוף ש.

1738
01:23:10,690 --> 01:23:13,240
>> LAUREN קרבאליו: יש לנו מספר סופי
של ביטים, מה שאומר שלא

1739
01:23:13,240 --> 01:23:17,910
כל מספר עשרוני הולך להיות
תוכל להיות מיוצג באופן מדויק.

1740
01:23:17,910 --> 01:23:24,910
ולכן בדוגמא זו, אם ברצוננו
להדפיס את 0.1, אנחנו עכשיו בהדפסה

1741
01:23:24,910 --> 01:23:26,475
20 את מקומות.

1742
01:23:26,475 --> 01:23:30,250
>> לוקאס פרייטס: בדיוק כמו שאני אומר לי
חבר 'ה, אתה יכול לשים את כל מספר.

1743
01:23:30,250 --> 01:23:36,520
אבל אם אתה רק עשית שני מקומות,
היית מקבל 0.10, אבל אם אתה שם את 20

1744
01:23:36,520 --> 01:23:43,630
מקומות, זה הולך להראות לכם חבורה
מזה בגלל שזה מה שאתה יכול לשים

1745
01:23:43,630 --> 01:23:45,720
בזיכרון, נכון?

1746
01:23:45,720 --> 01:23:48,800
>> אבל כאן, עד 0,
ולאחר מכן הוא פשוט לשים אותו

1747
01:23:48,800 --> 01:23:50,030
חבורה של מספרים אקראיים.

1748
01:23:50,030 --> 01:23:52,590
זה כמו סוג של כמה -

1749
01:23:52,590 --> 01:23:56,190
>> LAUREN קרבאליו: סיבה לכך הוא שאנחנו
לא מסוגל לייצג עשרוני זה

1750
01:23:56,190 --> 01:23:58,320
דווקא עם המספר
ביטים יש לנו.

1751
01:23:58,320 --> 01:23:59,730
>> לוקאס פרייטס: ואז
מחשב הוא בעצם

1752
01:23:59,730 --> 01:24:01,470
נותן לך מספר אשפה.

1753
01:24:01,470 --> 01:24:04,530
זה לא ממש
ערך של המספר.

1754
01:24:04,530 --> 01:24:08,242
>> קהל: זה קרוב ככל
הוא יכול לקבל [לא ברור]

1755
01:24:08,242 --> 01:24:09,613
באמצעות [לא ברור].

1756
01:24:09,613 --> 01:24:12,685

1757
01:24:12,685 --> 01:24:18,830
>> LAUREN קרבאליו: אז המשמעות של
זה הוא שיניח שבמקום

1758
01:24:18,830 --> 01:24:27,680
להיות 0.100014, לא משנה מה,
מה אם זה היה .0999 -

1759
01:24:27,680 --> 01:24:30,470
כן, בסדר.

1760
01:24:30,470 --> 01:24:38,280
בואו נעמיד פנים שהתשובה בפועל
לזה היו .9999999.

1761
01:24:38,280 --> 01:24:40,740
זה קרוב מאוד ל -1, אך
זה לא בדיוק 1.

1762
01:24:40,740 --> 01:24:42,840
זה .99999.

1763
01:24:42,840 --> 01:24:48,140
>> זה אומר שאם אני לוקח את זה 0.999,
ואני הסבתי אותו ל int, אני מקבל 0.

1764
01:24:48,140 --> 01:24:49,460
אני לא מבין 1.

1765
01:24:49,460 --> 01:24:53,050
>> לוקאס פרייטס: כי זוכר, ליהוק
ממצוף לint, אתה פשוט

1766
01:24:53,050 --> 01:24:54,880
להתעלם מכל המקומות אחרי הנקודה העשרונית.

1767
01:24:54,880 --> 01:24:56,400
אתה פשוט להתעלם מהם.

1768
01:24:56,400 --> 01:25:00,170
אין דבר כזה כמו עיגול כזה
או ריצה במורד כאשר אתה חומר מודפס.

1769
01:25:00,170 --> 01:25:03,310
למעשה, יש בפונקציה זו ש
עושה עיגול, שהוא מאוד

1770
01:25:03,310 --> 01:25:08,840
חשוב, אבל אתה רק חושב שכאשר
אתה עושה ליהוק שחקנים, זה פשוט

1771
01:25:08,840 --> 01:25:09,720
הולך למחוק את הכל.

1772
01:25:09,720 --> 01:25:13,970
אז גם אם יש לך .99999, זה הולך
רק כדי לתת לי 0 אם חומר מודפס

1773
01:25:13,970 --> 01:25:14,800
[לא ברור] מספר שלם.

1774
01:25:14,800 --> 01:25:17,480
>> LAUREN קרבאליו: אז רק להיות ממש מודע
נקודה הצפה בדייקנות,

1775
01:25:17,480 --> 01:25:20,410
במיוחד כאשר אתה מתחיל
להשתמש צף בPset1.

1776
01:25:20,410 --> 01:25:22,790
אבל ההליכה בצריך
להזהיר אותך שגם כן.

1777
01:25:22,790 --> 01:25:26,100
>> לוקאס פרייטס: ולמעשה זה באמת
קשה, למשל, אם עשיתי

1778
01:25:26,100 --> 01:25:31,570
תשובה לצוף 1 שווה 1.0 מעל
10, ולאחר מכן תצוף תשובה 2

1779
01:25:31,570 --> 01:25:35,540
שווה 10.0 מעל 100.0.

1780
01:25:35,540 --> 01:25:36,890
הם אותו המספר, נכון?

1781
01:25:36,890 --> 01:25:38,540
0.1, נכון?

1782
01:25:38,540 --> 01:25:41,700
1 מעל 10 או 10 מעל 100.

1783
01:25:41,700 --> 01:25:46,360
אבל עכשיו אם אני מנסה לראות את השוויון,
כמו אם התשובה 1 היא שווה לענות 2,

1784
01:25:46,360 --> 01:25:49,300
אולי זה לא ממש הולך
להיות אותו הדבר.

1785
01:25:49,300 --> 01:25:50,720
אז צף הם כמו סוג של זה.

1786
01:25:50,720 --> 01:25:51,970
הם כמו עושים שוויון.

1787
01:25:51,970 --> 01:25:55,136