1
00:00:07,830 --> 00:00:12,200
[Powered by Google Translate] הדוד Malan: זה CS50, וזו תחילת השבוע, 1.

2
00:00:12,200 --> 00:00:15,520
מה שחשבנו שאנחנו היינו עושים היום היא לקחת מבט לאחור על

3
00:00:15,520 --> 00:00:18,290
משהו שרבים מכם כנראה עבר לחלק

4
00:00:18,290 --> 00:00:20,570
זמן עכשיו ואולי נראה קצת מוכר.

5
00:00:20,570 --> 00:00:23,720
זה כאן, זה, כמובן, הוא ב--

6
00:00:23,720 --> 00:00:24,155
קהל: מדע.

7
00:00:24,155 --> 00:00:26,030
הדוד Malan: מדע המרכז.

8
00:00:26,030 --> 00:00:28,940
אז זה בעצם אחד מהמחשבים המוקדמים

9
00:00:28,940 --> 00:00:30,220
לגבות מ 1940.

10
00:00:30,220 --> 00:00:33,790
זה היה אחד ממחשבי אלקטרו 1

11
00:00:33,790 --> 00:00:35,730
שהיה מסוגל ארוך במיוחד,

12
00:00:35,730 --> 00:00:38,450
חישובים עצמיים מתמשכים, ומה שאנחנו בעצם רואים ב

13
00:00:38,450 --> 00:00:41,580
מרכז המדע הוא רק חתיכה קטנה של הדבר הזה.

14
00:00:41,580 --> 00:00:44,170
מה שחשבנו שאנחנו היינו עושים אז הוא מעיף מבט לאחור בוידאו

15
00:00:44,170 --> 00:00:46,670
שנעשה לפני כמה זמן, זה מציג

16
00:00:46,670 --> 00:00:47,520
דבר לעולם.

17
00:00:47,520 --> 00:00:50,200
ותראה ממוסיקה והקול שאכן אלה

18
00:00:50,200 --> 00:00:52,070
היו זמנים מאוד שמחים.

19
00:00:54,885 --> 00:00:59,700
>> [השמעת וידאו]

20
00:00:59,700 --> 00:01:02,490
-נצחון של מיומנות מתמטית ומכאנית הוא זה

21
00:01:02,490 --> 00:01:06,340
מחשבון גדול חדש אוטומטי באוניברסיטת הרווארד.

22
00:01:06,340 --> 00:01:08,620
בעיות סבוכות במתמטיקה, והיא הוכנסה

23
00:01:08,620 --> 00:01:12,420
מכונה בצורה מוצפנת בקלטת, נפתרת באופן מדויק

24
00:01:12,420 --> 00:01:15,200
חלק זעיר מהזמן דרוש לאדם

25
00:01:15,200 --> 00:01:16,450
חישוב.

26
00:01:27,050 --> 00:01:30,600
נועד לזרז את כל הצורות מתמטיות ומדעי

27
00:01:30,600 --> 00:01:34,610
מחקר, המוח המכאני הענקי שיפעל לארצות

28
00:01:34,610 --> 00:01:36,570
צי אמריקאי עד לסוף המלחמה.

29
00:01:50,280 --> 00:01:52,980
>> הדוד Malan: אז מה שאתה אולי לא יודע הוא שזה היה ב

30
00:01:52,980 --> 00:01:56,310
אותו מכשיר שזה מונח שכולנו עכשיו תיקח די הרבה

31
00:01:56,310 --> 00:01:59,300
כמובן מאליו נטבע, זה של הבאג.

32
00:01:59,300 --> 00:02:01,140
אז אחת מהמהנדסים עובד במחשב זה

33
00:02:01,140 --> 00:02:05,280
מצא עש קטן במכונית שהביא פשוטו

34
00:02:05,280 --> 00:02:07,580
בכמה חישובים שגויים.

35
00:02:07,580 --> 00:02:10,410
וכסיפור הולך כך העש היה מודבק ליומן זה

36
00:02:10,410 --> 00:02:14,180
כתב עת כאן, חזרה מ9 ספטמבר בשנת 1940 ומשהו,

37
00:02:14,180 --> 00:02:16,550
וכך נולד "באג" המונח לעולם.

38
00:02:16,550 --> 00:02:19,880
אז מכאן ואילך אנו רואים באגים להיות כל סוג של טעויות ב

39
00:02:19,880 --> 00:02:23,290
תוכניות, בין אם מעשה ידי אדם או, במקרה זה, חרקים.

40
00:02:23,290 --> 00:02:25,030
>> אז כמה הכרזות, ככל שנתקדם.

41
00:02:25,030 --> 00:02:29,160
אז CS50 יש מסורת של מציעים ארוחות צהריים של מינים על

42
00:02:29,160 --> 00:02:31,600
רוב ימי שישי במהלך הסמסטר, שבו אנחנו לוקחים 30 עד

43
00:02:31,600 --> 00:02:34,650
40 סטודנטים לאש וקרח בכיכר למזדמנת

44
00:02:34,650 --> 00:02:36,390
פטפוטים, דיבורים על מדעי מחשב,

45
00:02:36,390 --> 00:02:37,420
לדבר על העתיד.

46
00:02:37,420 --> 00:02:40,000
אנו מזמינים את בוגרים וידידים מהתעשייה לשוחח עד

47
00:02:40,000 --> 00:02:40,690
תלמידים גם כן.

48
00:02:40,690 --> 00:02:44,020
ממש לקראת סוף עושה מה שכיתה גדולה למדי

49
00:02:44,020 --> 00:02:46,740
כל אינטימי יותר, לפחות פעם האחת ובאילו עבור

50
00:02:46,740 --> 00:02:47,710
תת קבוצות של תלמידים.

51
00:02:47,710 --> 00:02:50,940
אז אם אתה רוצה להצטרף אלינו ביום שישי הקרוב, בשעת 1:15, ללכת ל

52
00:02:50,940 --> 00:02:53,340
CS50.net/lunch לRSVP.

53
00:02:53,340 --> 00:02:55,840
ואנחנו נעשה את זה recurringly, אז שלא ידאג אם אתה לא

54
00:02:55,840 --> 00:02:57,930
בין ראשוני 30 או כך השבוע.

55
00:02:57,930 --> 00:02:59,070
>> אז הערות סופר.

56
00:02:59,070 --> 00:03:01,500
מילה על המשאבים שעכשיו תתחיל להיות זמין

57
00:03:01,500 --> 00:03:03,040
לתלמידים בכיתה.

58
00:03:03,040 --> 00:03:05,540
כך שהראש שלך לא צריך להיות למטה במהלך הרצאות

59
00:03:05,540 --> 00:03:08,560
ורשם את כל מה שאני אומר וכן הלאה, מה שאנחנו עושים

60
00:03:08,560 --> 00:03:10,765
במקום זאת היא מספק מסגל ההוראה

61
00:03:10,765 --> 00:03:11,920
סט הקנונית של הערות.

62
00:03:11,920 --> 00:03:14,850
אז יש לנו אחד מחברינו להוראה, אנדרו Sellergren,

63
00:03:14,850 --> 00:03:17,830
שמתיישב בכל שבוע, סוקר את קטעי וידאו, ולאחר מכן

64
00:03:17,830 --> 00:03:19,730
כותב את מה שאנחנו חושבים למדי

65
00:03:19,730 --> 00:03:21,840
סט סמכותי של הערות.

66
00:03:21,840 --> 00:03:24,180
וחיבתו של אנדרו, גם, של לשים את ההערות שוליות במתחכמות

67
00:03:24,180 --> 00:03:24,820
התחתון.

68
00:03:24,820 --> 00:03:27,300
אז אתה מקווה שתיהנה אלה כהתייחסות לספר

69
00:03:27,300 --> 00:03:30,230
כיף, וגם, בואו חידון זמן, כהזדמנות לסקור

70
00:03:30,230 --> 00:03:31,830
מה שקרה בהרצאות בודדות.

71
00:03:31,830 --> 00:03:33,580
אז אלה מקושרים בדף ההרצאות.

72
00:03:33,580 --> 00:03:35,300
>> סט הבעיה 0, בינתיים, הוא החוצה.

73
00:03:35,300 --> 00:03:37,470
ובמונחים של המשאבים העומדים לרשותך -

74
00:03:37,470 --> 00:03:38,020
ההדרכה.

75
00:03:38,020 --> 00:03:39,730
מילוא הוביל הראשון ביום שישי.

76
00:03:39,730 --> 00:03:41,470
הוא צולם, לשים באינטרנט על ידי שבת.

77
00:03:41,470 --> 00:03:44,030
וכך להבין, שאם אתה לא ממש בטוח מאיפה להתחיל,

78
00:03:44,030 --> 00:03:47,280
לזה או עתיד P-סדרות, תמיד לפנות תחילה ל

79
00:03:47,280 --> 00:03:49,300
הדרכה או ממנו הווידאו.

80
00:03:49,300 --> 00:03:52,950
החתך הוא בהתקדמות; בcs50.net/section הוא בך

81
00:03:52,950 --> 00:03:54,540
צריך להגיש את ההעדפות שלך, אם יש לך לא

82
00:03:54,540 --> 00:03:55,880
כבר, על ידי היום.

83
00:03:55,880 --> 00:03:58,140
בגלל סעיפים יתחילו ביום ראשון הקרוב, יום שני,

84
00:03:58,140 --> 00:03:58,760
ויום שלישי.

85
00:03:58,760 --> 00:04:02,470
אנחנו עושים את אותם קטעים השלושה ימים, כל שבוע של

86
00:04:02,470 --> 00:04:03,870
סמסטר על פי רוב.

87
00:04:03,870 --> 00:04:06,600
ואנחנו גם מציגים, שוב, מסלולים שונים.

88
00:04:06,600 --> 00:04:08,270
אז תתבקש על צורת החתך הזה, אם אתה

89
00:04:08,270 --> 00:04:10,350
לא ראה אותו כבר, אם אתה בין אלה שפחות

90
00:04:10,350 --> 00:04:12,800
נוח יותר, נוח יותר, או איפשהו באמצע.

91
00:04:12,800 --> 00:04:14,960
ואם אתה סוג של על הגדר, בדרך כלל אי ​​שם ב

92
00:04:14,960 --> 00:04:18,160
בין מה שרוב התלמידים בסופו של בדיקה.

93
00:04:18,160 --> 00:04:19,579
שעתי עבודה מתחילות הלילה.

94
00:04:19,579 --> 00:04:23,020
>> אז גרד הוא מפתח נמוך למדי, למרות שזה די טבעי

95
00:04:23,020 --> 00:04:25,300
לנתקלו בבאגים שונים, או להיות בטוח לגבי איך

96
00:04:25,300 --> 00:04:26,550
ליישם משהו.

97
00:04:26,550 --> 00:04:28,880
אז תבין שאנחנו נתחיל שעתי עבודה בשבוע.

98
00:04:28,880 --> 00:04:30,500
הם יהיו באננברג יום שני, יום שלישי, יום רביעי,

99
00:04:30,500 --> 00:04:34,300
יום חמישי, 20:00-11:00 בהפסקת המוח.

100
00:04:34,300 --> 00:04:38,160
classmen העליון יכול להיכנס, ואם אי פעם יש לך בעיה להגיע

101
00:04:38,160 --> 00:04:40,720
בדלת, כי הם יהיו swiping, פשוט דברים בדרך שלך

102
00:04:40,720 --> 00:04:42,560
ובלהסביר אתה איתי CS50.

103
00:04:42,560 --> 00:04:45,230
בדרך כלל 20 עד 30 מתוכנו בצוות תהיינה שם כדי לעזור

104
00:04:45,230 --> 00:04:46,190
אתה אחד על אחד.

105
00:04:46,190 --> 00:04:48,980
>> עם הגעת הרעיון הוא כזה: אתה תביא את המחשב הנייד שלך,

106
00:04:48,980 --> 00:04:51,300
יהיה לך המטען שלך, יהיה לנו כבלי חשמל נוספים,

107
00:04:51,300 --> 00:04:53,320
במיוחד לאורך הקיר הדרומי של אננברג בי

108
00:04:53,320 --> 00:04:55,080
יש המון שקעי חשמל.

109
00:04:55,080 --> 00:04:59,290
ונקודת הכניסה העיקרית לשעתי המשרד Q & A היא ללכת

110
00:04:59,290 --> 00:05:01,690
cs50.net/discuss ולפרסם

111
00:05:01,690 --> 00:05:02,580
השאלה שלך שם.

112
00:05:02,580 --> 00:05:05,600
ולתייג אותה עם pset 0 או pset 1, מה השבוע

113
00:05:05,600 --> 00:05:06,810
שעלול להיות.

114
00:05:06,810 --> 00:05:09,240
ואז מה שאנחנו הולכים לעשות זה יש טבלה של עמיתי הוראה

115
00:05:09,240 --> 00:05:12,040
ועוזרים כמובן, בדרך כלל 8 או 10 או משהו כזה שלנו,

116
00:05:12,040 --> 00:05:14,430
עובר, שמירה על עין על הלוח, ו

117
00:05:14,430 --> 00:05:16,810
תלש שאלות ממש מהר ככל שאנו יכולים,

118
00:05:16,810 --> 00:05:19,600
בהתייחסו לך הודעות הקשורות אם לא מצאת מי

119
00:05:19,600 --> 00:05:22,220
עצמכם, הפניות לאינטרנט, כנדרש.

120
00:05:22,220 --> 00:05:24,280
ואז, אם יש בעיות, כמו שיש באופן בלתי נמנע

121
00:05:24,280 --> 00:05:27,190
יהיה, או שזה פשוט יותר הגיוני לשבת אחד על אחד,

122
00:05:27,190 --> 00:05:28,660
לעבוד דרך בעיות עם מישהו.

123
00:05:28,660 --> 00:05:30,810
>> או שאתה רק נכנסת לשעתי עבודה באמת

124
00:05:30,810 --> 00:05:31,640
צורך החשיבה ש.

125
00:05:31,640 --> 00:05:33,400
אתה לא רוצה לעבור את הצורה האלקטרונית, אתה

126
00:05:33,400 --> 00:05:34,410
ממש רוצה להיפגש עם מישהו.

127
00:05:34,410 --> 00:05:37,240
לתקשר כי לנו, ומה יקרה כאשר

128
00:05:37,240 --> 00:05:40,620
השאלה כבר ראה ע"י חבר צוות, ואנחנו

129
00:05:40,620 --> 00:05:43,660
לקבוע, כן, זה אמור להישלח לאחד 20 או

130
00:05:43,660 --> 00:05:47,800
30 חברי צוות כאן ברמה אזורית, תוכל לראות בפינה שמאלית עליון זה

131
00:05:47,800 --> 00:05:51,590
קצת הזן את תור הלחצן מתחיל להבהב בcs50.net /

132
00:05:51,590 --> 00:05:52,165
לדון בו.

133
00:05:52,165 --> 00:05:55,260
וזה אומר לך שעכשיו כבר הוזמן, כך

134
00:05:55,260 --> 00:05:56,880
לדבר, כדי להזין את התור.

135
00:05:56,880 --> 00:05:59,090
ועל ידי לחיצה על הכפתור הזה, השם שלך יופיע על

136
00:05:59,090 --> 00:06:02,660
האייפד שמברך CS50, אחד מראשיו של הקורס, יהיה

137
00:06:02,660 --> 00:06:05,250
להיות מחזיק ליד הכניסה של אננברג, שאז יהיה

138
00:06:05,250 --> 00:06:08,630
רואה כמתואר כאן, את התלמידים שיש להם שאלות על

139
00:06:08,630 --> 00:06:11,630
מהשמאל, חברי צוות שנמצאים בצד ימין.

140
00:06:11,630 --> 00:06:14,830
ועם לחץ על ימין ועל שמאל, דפדפן האינטרנט שלך

141
00:06:14,830 --> 00:06:18,610
תתחיל להבהב בהקדם, למשל, פרופ 'McGonnagal

142
00:06:18,610 --> 00:06:21,460
הוא מוכן לראות אותך בשולחן מסוים באננברג.

143
00:06:21,460 --> 00:06:23,340
>> אז עשיתי כמה מהשנה שעברה.

144
00:06:23,340 --> 00:06:25,430
אנחנו כבר אתחלנו שעתי עבודה ו

145
00:06:25,430 --> 00:06:26,980
מחדש יישם הרבה של התוכנה.

146
00:06:26,980 --> 00:06:29,940
אז הבין שזה יהיה לחמם את זה שבוע.

147
00:06:29,940 --> 00:06:32,970
אבל גם מבין יותר מדי, בשנים האחרונות, כפי שאולי שמע

148
00:06:32,970 --> 00:06:35,710
מחברים, שעתי עבודה היו 50 עד אכן

149
00:06:35,710 --> 00:06:37,040
150 תלמידים בו זמנית.

150
00:06:37,040 --> 00:06:39,300
וזה פשוט לא אפשרי עבורנו להתמודד עם זה

151
00:06:39,300 --> 00:06:42,060
למעשה, אחד על אחד, לאורך כל הערב.

152
00:06:42,060 --> 00:06:44,570
וכך מה שאנחנו בעצם הולכים לנסות לעשות את זה שנה היא

153
00:06:44,570 --> 00:06:46,590
לנצל את העובדה שהרבה שאלות הן

154
00:06:46,590 --> 00:06:49,050
נפוץ ולעתים קרובות יכול להיות טוב יותר ענה

155
00:06:49,050 --> 00:06:50,030
באופן אסינכרוני.

156
00:06:50,030 --> 00:06:52,140
אז אתה יכול כאילו לחשוב על התגובה של צוות,

157
00:06:52,140 --> 00:06:54,360
ואנחנו יכולים לחשוב על הקוד שלך, בלי מחומם

158
00:06:54,360 --> 00:06:57,050
לחץ נאבק בהכרח

159
00:06:57,050 --> 00:06:58,210
דרך זה לצד זה.

160
00:06:58,210 --> 00:07:00,980
אז אנחנו מעריכים שבערך מחצית שלישית או מהשאלות

161
00:07:00,980 --> 00:07:03,500
יהיה שגר באופן אישי, ואנו ננסה למרוט את כ

162
00:07:03,500 --> 00:07:05,530
רבים כמחצית או יותר באופן אלקטרוני,

163
00:07:05,530 --> 00:07:06,710
בשעתי עבודה.

164
00:07:06,710 --> 00:07:08,070
ואנו נמשיך להשתמש בדיון

165
00:07:08,070 --> 00:07:09,990
במהלך השבוע גם כן.

166
00:07:09,990 --> 00:07:12,680
>> ולבסוף, להבין כי קורס זה ניתן לקחת עובר / נכשל.

167
00:07:12,680 --> 00:07:16,230
אז אם אתה על הגדר, או פשוט לחשוב שאתה באמת

168
00:07:16,230 --> 00:07:18,650
לא בטוח אם זה העולם בשבילך, או שזה באמת

169
00:07:18,650 --> 00:07:21,310
די זר לך, להבין שזו דרך נפלאה

170
00:07:21,310 --> 00:07:24,840
מצובר קצת ביטחון שבי להיכנס

171
00:07:24,840 --> 00:07:26,780
כיתה, כמו שאני עשיתי כנות, לפני שנים.

172
00:07:26,780 --> 00:07:28,630
ואז יש לי חמישה שבועות כדי למיין של דמות בשביל

173
00:07:28,630 --> 00:07:30,850
את עצמך אם אתה רוצה להישאר עובר / נכשלת, לעבור למכתב

174
00:07:30,850 --> 00:07:31,800
כיתה, או כמו.

175
00:07:31,800 --> 00:07:34,050
ובדרך כלל מה עובר / נכשל אין, לדעתי, לתלמידים הוא

176
00:07:34,050 --> 00:07:36,700
שאם אתה מכניס כי 10 שעות, 20 שעות, מה שזה

177
00:07:36,700 --> 00:07:38,830
יכול להיות בכמה בעיות, ואתה דופק את הראש שלך

178
00:07:38,830 --> 00:07:39,690
על הקיר,

179
00:07:39,690 --> 00:07:41,750
ואתה באמת לא יכול לרדוף אחרי משהו, ועליך

180
00:07:41,750 --> 00:07:44,230
יש כל כך הרבה דברים אחרים שאתה צריך לעשות, בכנות, מה אני

181
00:07:44,230 --> 00:07:46,070
חושב עובר / נכשל היא, זה לוקח את העוקץ של

182
00:07:46,070 --> 00:07:47,250
מצבים כאלה.

183
00:07:47,250 --> 00:07:49,350
איפה שצלמת את הדבר 90% מהדרך.

184
00:07:49,350 --> 00:07:50,830
אתה יודע, זה לא ממש מושלם.

185
00:07:50,830 --> 00:07:52,950
אבל יש לך הרבה ממנו, בכל זאת.

186
00:07:52,950 --> 00:07:55,440
אז לשקול עובר / נכשל כנותן לך

187
00:07:55,440 --> 00:07:57,590
מודל מנטלי, אולי.

188
00:07:57,590 --> 00:08:00,680
>> כל כך בשבוע שעבר הנכון, צלל אל גרד, ואנחנו

189
00:08:00,680 --> 00:08:03,610
דבר על תכנות ברמה גרפית גבוהה למדי.

190
00:08:03,610 --> 00:08:05,340
והיום אנחנו עושים את המעבר לשפה

191
00:08:05,340 --> 00:08:08,300
בשם C, שפת תכנות ברמה נמוכה יותר בחלק העליון של

192
00:08:08,300 --> 00:08:11,260
ששפות מודרניות רבות כיום בנויות, כוללות חלק

193
00:08:11,260 --> 00:08:13,010
מאלה שאנחנו משתמשים בי לקראת סופו של המונח.

194
00:08:13,010 --> 00:08:15,530
ותחבירי, איך שהם נראים

195
00:08:15,530 --> 00:08:17,330
כל די דומה.

196
00:08:17,330 --> 00:08:19,080
אז בואו נתחיל לעשות את המעבר הזה כאן.

197
00:08:19,080 --> 00:08:21,730
אז זו הייתה תכנית בשבוע שעבר שהיה פשוט ביותר

198
00:08:21,730 --> 00:08:22,910
שלום תוכניות בעולם.

199
00:08:22,910 --> 00:08:25,560
זה פשוט הדפיס לשלום עולם המסך, עם

200
00:08:25,560 --> 00:08:27,650
בועת דיבור קטנה שיוצאת מהחתול.

201
00:08:27,650 --> 00:08:30,590
ובכן, אם אנחנו מתחילים עכשיו לתרגם את זה למשנו

202
00:08:30,590 --> 00:08:33,419
שפה, מבין שרעיונות היום וביום רביעי

203
00:08:33,419 --> 00:08:36,450
זהים, אבל התחביר מתחיל להשתנות.

204
00:08:36,450 --> 00:08:39,370
אז אילו בשבוע שעבר היה לנו, כשהדגל ירוק לחץ, אומר

205
00:08:39,370 --> 00:08:40,340
שלום עולם.

206
00:08:40,340 --> 00:08:43,870
היום אנחנו הולכים להיות, חלל int, ראשי, printf,

207
00:08:43,870 --> 00:08:46,350
תמורה, עם חלק אחר בתחביר גם שם.

208
00:08:46,350 --> 00:08:49,200
סוגריים מסולסלים וסוגריים, וציטוטים, ומה לא.

209
00:08:49,200 --> 00:08:54,520
אבל מבין שהליבה של הרעיון כאן היא ההדפסה,

210
00:08:54,520 --> 00:08:58,470
וסופו של דבר העובדה שעיקרית עכשיו הוא הולך להיות

211
00:08:58,470 --> 00:09:00,770
שם נרדף להתחלה של תכנית.

212
00:09:00,770 --> 00:09:04,250
העיקרי הולך להיות בו הדגל הירוק בעיטות מחוץ דברים.

213
00:09:04,250 --> 00:09:06,390
>> אז עכשיו בואו להקניט מלבד כמה מאבני הבניין כאן

214
00:09:06,390 --> 00:09:08,650
לפני שנצלול לתוך כמה דוגמאות קונקרטיות.

215
00:09:08,650 --> 00:09:11,620
אז קרא את זה בשבוע שעבר הצהרה לפיה זה רק

216
00:09:11,620 --> 00:09:12,470
הוראה ולמידה.

217
00:09:12,470 --> 00:09:15,660
לעשות את זה - במקרה זה, אומר שלום עולם.

218
00:09:15,660 --> 00:09:18,400
ובכן ב-C, אם נסתכל רק כי קו, זה איך אנחנו

219
00:09:18,400 --> 00:09:20,920
תתחיל להביע שפיסת הפאזל מסוימת:

220
00:09:20,920 --> 00:09:24,780
printf ("hello world");.

221
00:09:24,780 --> 00:09:27,330
ועכשיו אנחנו נתגרה אלה בהפרש של יותר ויותר עם זמן,

222
00:09:27,330 --> 00:09:29,330
אבל להבין שיש כאן דפוס.

223
00:09:29,330 --> 00:09:31,870
אז אחד, יש לנו הדבר הזה שנקרא printf, שהוא

224
00:09:31,870 --> 00:09:34,310
למעשה מקביל למילה יגיד.

225
00:09:34,310 --> 00:09:35,800
זה מה שהוא הולך לעשות.

226
00:09:35,800 --> 00:09:37,870
Printf, וf כאן פירושו "מעוצב".

227
00:09:37,870 --> 00:09:39,270
אז זה רק אומר שאתה יכול להוסיף

228
00:09:39,270 --> 00:09:41,600
פרטים אסתטיים שונים.

229
00:09:41,600 --> 00:09:43,770
סוף הציטוט אז הוא תחילתו של מה שאנחנו הולכים

230
00:09:43,770 --> 00:09:45,340
כדי להתחיל לקרוא מחרוזת.

231
00:09:45,340 --> 00:09:47,110
מילה, משפט, משפט.

232
00:09:47,110 --> 00:09:50,220
מחרוזת בשפת תכנות היא רצף של אפס

233
00:09:50,220 --> 00:09:51,330
תווים או יותר.

234
00:09:51,330 --> 00:09:54,390
אז h-E-l-l-o, פסיק, וכן הלאה היא,

235
00:09:54,390 --> 00:09:56,290
סוף הציטוט, מחרוזת.

236
00:09:56,290 --> 00:09:58,710
ועכשיו קו הנטוי n, קצת מוזר מבחינה תחבירית, אבל אנחנו

237
00:09:58,710 --> 00:10:01,780
כבר הגדיר כי בשבוע שעבר כלמה התכוון?

238
00:10:01,780 --> 00:10:02,630
זה רק קו חדש.

239
00:10:02,630 --> 00:10:05,000
זה פשוט דרך של העברה למחשב שאתה רוצה

240
00:10:05,000 --> 00:10:07,700
מקבילה של להכות הזן שם, אבל אתה לא

241
00:10:07,700 --> 00:10:10,460
רוצה בעצם על Enter ולכן בלגן כל

242
00:10:10,460 --> 00:10:12,130
עיצוב של התכנית שלך בפועל.

243
00:10:12,130 --> 00:10:15,500
עכשיו הסוגריים מצרפים מחרוזת זו, פתוח וסוגר

244
00:10:15,500 --> 00:10:18,130
paren הקרוב, ובתוך כך היא המחרוזת שלנו.

245
00:10:18,130 --> 00:10:22,600
כי זה משום שבג' ותכנות, אחר

246
00:10:22,600 --> 00:10:27,510
שפות, דברים כמו printf לקחת טיעונים, או לקחת

247
00:10:27,510 --> 00:10:28,420
פרמטרים.

248
00:10:28,420 --> 00:10:31,490
>> אז להתחיל לחשוב עכשיו על הבלוק הזה הסגול כיגיד

249
00:10:31,490 --> 00:10:34,890
פונקציה, כשיטה, כנוהל.

250
00:10:34,890 --> 00:10:36,890
אתה באמת יכול לקרוא לזה איך שתרצה לעת עתה, אבל

251
00:10:36,890 --> 00:10:39,260
זה סוג של תכנית מיניאטורי שעושה אחד בלבד

252
00:10:39,260 --> 00:10:41,480
דבר, בשורה אחת, לא פחות.

253
00:10:41,480 --> 00:10:43,620
אז printf הוא גם מה שאנחנו הולכים להתחיל לקרוא

254
00:10:43,620 --> 00:10:46,680
פונקציה, ופונקציות לעשות משהו - במקרה זה

255
00:10:46,680 --> 00:10:49,320
מדפיס מחרוזת מעוצבת למסך -

256
00:10:49,320 --> 00:10:53,220
אבל גם לקחת פונקציות טיעונים או פרמטרים.

257
00:10:53,220 --> 00:10:55,880
ועל ידי טיעונים או פרמטרים, תודה לך, אנחנו מתכוונים

258
00:10:55,880 --> 00:11:01,220
שהתנהגותם יכולה להיות מושפעת ממה שעובר ב

259
00:11:01,220 --> 00:11:03,420
בתוך הסוגריים.

260
00:11:03,420 --> 00:11:06,460
אז במקרה הזה, צרכימי printf יגידו לי מה להדפיס, ואנחנו

261
00:11:06,460 --> 00:11:09,520
רק לעבור ב, במרכאות כפולות כאן, מחרוזת שאנו

262
00:11:09,520 --> 00:11:11,270
בעצם רוצה להדפיס.

263
00:11:11,270 --> 00:11:14,060
והפסיק בסופו של קו זה הוא פשוט

264
00:11:14,060 --> 00:11:18,020
מטרד הסטורי לפיה בסופו של רוב שורות קוד,

265
00:11:18,020 --> 00:11:21,170
אתה שם את פסיק לעשות סופר ברור למחשב

266
00:11:21,170 --> 00:11:23,020
כי הקו הזה של קוד מסתיים כאן.

267
00:11:23,020 --> 00:11:25,600
עכשיו זה טוב, כי כפי שנראים כתוכניות לקבל יותר

268
00:11:25,600 --> 00:11:29,030
מורכב, הפסיק יעשה בני אדם סופר ברור לנו,

269
00:11:29,030 --> 00:11:32,280
וגם במחשב, שבו שורות של קוד התחלה והסוף.

270
00:11:32,280 --> 00:11:34,360
מבין שחלק מהשפות אין חלק

271
00:11:34,360 --> 00:11:35,045
באותם פרטים אלה.

272
00:11:35,045 --> 00:11:37,870
ואכן, ב-JavaScript, שאתה לא תמיד צריך משהו

273
00:11:37,870 --> 00:11:38,670
כמו נקודת הפסיק.

274
00:11:38,670 --> 00:11:40,210
אבל גם על זה שיבוא.

275
00:11:40,210 --> 00:11:41,170
>> אז לולאות.

276
00:11:41,170 --> 00:11:43,520
היו לנו משהו כזה, מאוד אינטואיטיבי, ברור, לעשות

277
00:11:43,520 --> 00:11:44,860
משהו שוב ושוב ושוב.

278
00:11:44,860 --> 00:11:47,720
כמו ללבוש גרביים, או אמירת שלום, במקרה זה.

279
00:11:47,720 --> 00:11:51,090
ובכן, החל מיום ב-C, אנחנו יכולים להביע את שריטה זה

280
00:11:51,090 --> 00:11:54,970
לחסום כבזמן (אמיתי) printf ("hello world").

281
00:11:54,970 --> 00:11:57,630
אז שם לב שאנחנו מתחילים לבנות באופן מילולי את הפאזל

282
00:11:57,630 --> 00:11:58,480
חתיכה מקודם.

283
00:11:58,480 --> 00:12:01,310
יש לנו את אותו בלוק סגול, אבל זה בתוך זה

284
00:12:01,310 --> 00:12:04,880
בצע בלוק סוגריים, והדרך הטובה ביותר לתרגם את זה

285
00:12:04,880 --> 00:12:06,480
לC היא כדלקמן.

286
00:12:06,480 --> 00:12:08,130
אין תמיד מילת מפתח.

287
00:12:08,130 --> 00:12:10,940
אתה לא יכול פשוט להקליד f-o-r-e-V-e-R ב C.

288
00:12:10,940 --> 00:12:13,440
אז האנלוגי הקרובה ביותר הוא זמן.

289
00:12:13,440 --> 00:12:17,050
>> עכשיו, בזמן (נכון) נראה קצת טיפש, כי עושה את הערך

290
00:12:17,050 --> 00:12:18,700
שינוי האמיתי אי פעם?

291
00:12:18,700 --> 00:12:19,810
יש להניח שלא.

292
00:12:19,810 --> 00:12:22,770
זה כמו להגיד בזמן אחד, ואילו ב, תוך נכון.

293
00:12:22,770 --> 00:12:25,430
זה הכל אותו הדבר, נכון שתמיד קורה.

294
00:12:25,430 --> 00:12:29,860
אז זה לולאה היא למעשה גרימה איזה סוג של לולאה?

295
00:12:29,860 --> 00:12:31,210
פשוט לולאה אינסופית, נכון.

296
00:12:31,210 --> 00:12:32,930
לולאה לתמיד או כפי שכינינו זאת בשבוע שעבר,

297
00:12:32,930 --> 00:12:33,870
רק ללולאה אינסופית.

298
00:12:33,870 --> 00:12:35,250
אז לפעמים זה רע.

299
00:12:35,250 --> 00:12:37,060
לפעמים זה באג, לפעמים זה למה שאתה מקבל

300
00:12:37,060 --> 00:12:39,340
כדור מסתובב החוף או שעון חול או כמו.

301
00:12:39,340 --> 00:12:41,260
אבל במקרה הזה, אנחנו בכוונה, מכל

302
00:12:41,260 --> 00:12:43,040
סיבה, רצתה להדפיס את אותו הדבר שוב

303
00:12:43,040 --> 00:12:43,970
ושוב ושוב.

304
00:12:43,970 --> 00:12:45,900
או במקרה של כמו שעון, אתה רוצה לעשות

305
00:12:45,900 --> 00:12:47,470
משהו שוב ושוב ושוב.

306
00:12:47,470 --> 00:12:49,070
כך לולאות אינסופיות אולי הגיונית.

307
00:12:49,070 --> 00:12:53,560
וכך ב-C שאפשר לתרגם לתמיד לקוד.

308
00:12:53,560 --> 00:12:55,570
>> אז עכשיו זה קצת יותר ספציפי.

309
00:12:55,570 --> 00:12:58,880
היינו לנו לחזור 10 פעמים את המשפט הבא.

310
00:12:58,880 --> 00:13:02,490
אז בזמן (אמיתי) לא ממש עובד שם, כי האמת היא

311
00:13:02,490 --> 00:13:03,590
תמיד נכון.

312
00:13:03,590 --> 00:13:07,060
אז אם אנחנו במקום להסתכל על גרסת C, עכשיו התחביר מקבל

313
00:13:07,060 --> 00:13:08,180
קצת יותר מסתורי.

314
00:13:08,180 --> 00:13:11,380
אבל אם להיות כן ברגע שתתחיל לראות את זה, את כל זה מקבל

315
00:13:11,380 --> 00:13:12,600
די מוכר במהירות.

316
00:13:12,600 --> 00:13:14,370
אז זה מה שנקרא ללולאה.

317
00:13:14,370 --> 00:13:17,210
ללולאה הולך לספר את המחשב כדי לעשות משהו

318
00:13:17,210 --> 00:13:20,710
שוב ושוב ושוב במשך זמן רב ככל

319
00:13:20,710 --> 00:13:21,850
הדברים האלה הם אמיתיים.

320
00:13:21,850 --> 00:13:23,370
עכשיו למה אנחנו מתכוונים בכך?

321
00:13:23,370 --> 00:13:25,470
ובכן, יש שלושה חלקים ללולאה, ואנחנו הולכים

322
00:13:25,470 --> 00:13:28,240
תחזור לזה בהקשר של ממשי

323
00:13:28,240 --> 00:13:29,100
דוגמאות ברגע.

324
00:13:29,100 --> 00:13:31,650
אז אל תדאג אם זה לא די לשקוע בהכל בבת אחת.

325
00:13:31,650 --> 00:13:35,400
אבל אני int = 0 הם, סיפור ארוך קצר, ואמרו לי

326
00:13:35,400 --> 00:13:38,290
משתנה זה מסוג המספר שלם, אז תן לי מספר

327
00:13:38,290 --> 00:13:40,890
קרא לי, ולאתחל אותו ל 0.

328
00:13:40,890 --> 00:13:43,460
זה נותן לי כמו x משתנה אלגברית ו

329
00:13:43,460 --> 00:13:44,580
לאתחל אותו ל 0.

330
00:13:44,580 --> 00:13:46,250
אבל במקרה הזה שקראנו את זה אני.

331
00:13:46,250 --> 00:13:49,120
ואז באמצע, זה אומר שאני פחות מ 10.

332
00:13:49,120 --> 00:13:52,150
שאומר את המחשב לעשות דברים כל כך הרבה זמן הבאים

333
00:13:52,150 --> 00:13:53,770
כפי שהוא פחות מ 10.

334
00:13:53,770 --> 00:13:55,370
וכמובן, הוא מתחיל פחות מ 10 כי

335
00:13:55,370 --> 00:13:56,550
זה מתחיל ב 0.

336
00:13:56,550 --> 00:13:59,150
אז לבסוף, אתה יכול אולי לנחש מה + + אמצעים.

337
00:13:59,150 --> 00:14:02,140
זה קצת תחביר שרק אומר לי להגדיל.

338
00:14:02,140 --> 00:14:05,270
אז להוסיף 1 ל i, שוב ושוב ושוב.

339
00:14:05,270 --> 00:14:09,260
>> וכן, ככל שנראה לולאה זה, תחביר זה, אלא מיישם

340
00:14:09,260 --> 00:14:12,160
בדיוק אותו הדבר, כי, בכנות, בגרד היה פשוט כל כך

341
00:14:12,160 --> 00:14:13,250
הרבה יותר קל לבטא.

342
00:14:13,250 --> 00:14:15,170
חזור על 10, וסיימת.

343
00:14:15,170 --> 00:14:17,690
ב-C, וברוב שפות תכנות, אנחנו צריכים להיות

344
00:14:17,690 --> 00:14:20,190
קצת יותר מאלף למחשב ולמעשה

345
00:14:20,190 --> 00:14:21,630
לציין משהו כזה.

346
00:14:21,630 --> 00:14:23,730
אבל אנחנו עוד נחזור לזה ותחביר אחר.

347
00:14:23,730 --> 00:14:24,780
>> מה לגבי משתנים?

348
00:14:24,780 --> 00:14:26,940
בשריטה שהיינו לנו משהו כמו בלוקים הכתומים האלה,

349
00:14:26,940 --> 00:14:28,180
איפה אני יכול להצהיר על משתנה.

350
00:14:28,180 --> 00:14:30,000
בואו נקרא לזה באופן שרירותי דלפק.

351
00:14:30,000 --> 00:14:31,880
בואו לאתחל אותו ל 0, ולאחר מכן

352
00:14:31,880 --> 00:14:33,240
בואו לנצח לעשות משהו.

353
00:14:33,240 --> 00:14:35,760
במקרה זה בסריטות שאני אומר לדלפק, ולכן

354
00:14:35,760 --> 00:14:38,230
החתול הולך להיות בועת דיבור קטנה שמדברת

355
00:14:38,230 --> 00:14:40,010
המספר זה במשתנה זה.

356
00:14:40,010 --> 00:14:42,460
ואז יש לנו נגד שינוי על ידי 1.

357
00:14:42,460 --> 00:14:45,760
אז כל זה עטוף בתוך מנעול לנצח.

358
00:14:45,760 --> 00:14:48,960
אז אנחנו כבר עכשיו יש את אובניים הבניין בC עם

359
00:14:48,960 --> 00:14:50,040
אשר לתרגם את זה.

360
00:14:50,040 --> 00:14:51,650
>> אחת דרכים שאנחנו יכולים לעשות את זה הוא זה.

361
00:14:51,650 --> 00:14:53,890
תן לי מספר שלם, קורא לו דלפק.

362
00:14:53,890 --> 00:14:55,190
לאתחל אותו ל 0

363
00:14:55,190 --> 00:14:56,490
בשורה הראשונה שם.

364
00:14:56,490 --> 00:14:59,390
אמנם (נכון), אז אני גונב מרעיון שרק לרגע

365
00:14:59,390 --> 00:15:01,300
לפני, ללכת ולעשות את הדברים הבאים.

366
00:15:01,300 --> 00:15:04,880
הדפס את הדלפק, ולאחר מכן להגדיל את הדלפק,

367
00:15:04,880 --> 00:15:06,930
שוב, ושוב, ושוב.

368
00:15:06,930 --> 00:15:09,380
או שוב, + + רק אומר להוסיף 1 למשהו.

369
00:15:09,380 --> 00:15:11,030
אבל יש קטע חדש של תחביר כאן.

370
00:15:11,030 --> 00:15:15,730
מה קופץ החוצה ברגע לא בין הדוגמות הקודמות שלנו?

371
00:15:15,730 --> 00:15:17,190
כן, ד% זה.

372
00:15:17,190 --> 00:15:19,810
אז אתה אולי יכול להסיק מה זה עושה, בכנות, על הבסיס

373
00:15:19,810 --> 00:15:21,410
על מה לחסום סריטות הוא עושה.

374
00:15:21,410 --> 00:15:24,510
אבל שוב ב-C, אנחנו רק צריכים להיות קצת יותר ספציפיים

375
00:15:24,510 --> 00:15:25,990
כשזה מגיע לביטוי לעצמנו.

376
00:15:25,990 --> 00:15:30,560
>> אז printf ("% d \ n").

377
00:15:30,560 --> 00:15:32,320
ובכן רוב שאנחנו יכולים לזרוק כמוכרים.

378
00:15:32,320 --> 00:15:34,910
הציטוטים רק אומרים שזה מחרוזת, הקו הנטוי n

379
00:15:34,910 --> 00:15:35,970
רק קו חדש.

380
00:15:35,970 --> 00:15:38,860
אז הדבר החדש היחיד כאן הוא ד%.

381
00:15:38,860 --> 00:15:40,390
וכל מה שהוא מציין.

382
00:15:40,390 --> 00:15:43,510
ד% הולך לציון מספר עשרוני.

383
00:15:43,510 --> 00:15:47,820
ו% מחשב אמצעי ד, לשים מספר עשרוני כאן.

384
00:15:47,820 --> 00:15:49,450
ובכן, מה מספר שאתה רוצה לשים שם?

385
00:15:49,450 --> 00:15:52,400
ובכן, כפי שאתה אולי יכול להסיק, אחרי הפסיק אנחנו אומרים

386
00:15:52,400 --> 00:15:55,480
מונה, זה השם של משתנה שהוכרזנו או

387
00:15:55,480 --> 00:15:57,260
יצר כמה שורות קודם לכן.

388
00:15:57,260 --> 00:16:02,420
אז זה פשוט הדרך של C של חיבור משתנה לתוך

389
00:16:02,420 --> 00:16:04,480
מחרוזת באופן דינאמי.

390
00:16:04,480 --> 00:16:07,350
כי לעומת זאת, אם הייתי עושה משהו במקום כמו

391
00:16:07,350 --> 00:16:12,470
זה, printf ("נגד"), מה יעשה זה

392
00:16:12,470 --> 00:16:15,220
תכנית במקום לעשות, כנראה?

393
00:16:15,220 --> 00:16:17,260
זה ממש ידפיס "נגדי".

394
00:16:17,260 --> 00:16:18,750
וזה לא האפקט שאני רוצה.

395
00:16:18,750 --> 00:16:20,920
אני צריך להחליף בחלק הערך מספרי.

396
00:16:20,920 --> 00:16:24,340
כך אוכל לראות כי פונקציות אז, כמו printf, לא יכול לקחת

397
00:16:24,340 --> 00:16:26,930
רק טענות בודדות בלבד, כמו

398
00:16:26,930 --> 00:16:28,150
"שלום עולם".

399
00:16:28,150 --> 00:16:32,050
הם יכולים לקחת פסיק סוף הציטוט, ולאחר מכן כמה משתנים

400
00:16:32,050 --> 00:16:35,830
שיקבל להתחבר אליה, כפי שנראים במחרוזת הקודמת

401
00:16:35,830 --> 00:16:38,280
באמצעות מצייני סימן% אלה.

402
00:16:38,280 --> 00:16:39,660
>> ובכן מה עם ביטויים בוליאניים?

403
00:16:39,660 --> 00:16:42,200
ביטויים בוליאניים היו הערכים האלה, אמת או שקר.

404
00:16:42,200 --> 00:16:42,830
כן או לא.

405
00:16:42,830 --> 00:16:44,020
1 או 0.

406
00:16:44,020 --> 00:16:45,190
או ביטול.

407
00:16:45,190 --> 00:16:47,570
אז בגרד הם נראים כמו זה, ולהבחין כי

408
00:16:47,570 --> 00:16:50,170
בלוק תחתון כאן הוא למעשה שיתוף

409
00:16:50,170 --> 00:16:51,500
של שני רחובות קטנים יותר.

410
00:16:51,500 --> 00:16:53,610
אז אני סוג של גררתי והורדתי שלושה חלקי פאזל

411
00:16:53,610 --> 00:16:56,450
יחד כדי להפוך את חתיכת הפאזל כבר לא שם כדי שאני

412
00:16:56,450 --> 00:17:00,420
יכול להעביר את הרעיון שאני רוצה x להיות פחות מ Y ו

413
00:17:00,420 --> 00:17:02,540
y להיות פחות מ z.

414
00:17:02,540 --> 00:17:05,790
וכך אני יכול לתרגם שני קווים נפרדים אלה כך.

415
00:17:05,790 --> 00:17:08,650
הדף אחד יכול להיות מתורגם trivially מאוד ל-C,

416
00:17:08,650 --> 00:17:10,069
רק עם x <y.

417
00:17:10,069 --> 00:17:11,990
אולי עם סוגריים מסוימים למען סדר טוב.

418
00:17:11,990 --> 00:17:15,520
ולאחר מכן ב-C, אתה לא כותב ולציון

419
00:17:15,520 --> 00:17:16,819
שילוב של משהו.

420
00:17:16,819 --> 00:17:19,585
אתה במקום לכתוב &&.

421
00:17:19,585 --> 00:17:22,849
וכפי שסופו של דבר יראה, אמפרסנד אחת קורה

422
00:17:22,849 --> 00:17:23,880
התכוון למשהו אחר.

423
00:17:23,880 --> 00:17:27,530
אז && פשוט מציין את הרעיון ו.

424
00:17:27,530 --> 00:17:30,040
>> אז שוב, למרות שזה מתחיל להיראות מורכב למדי,

425
00:17:30,040 --> 00:17:32,560
אחת המטרות של החדרת סריטות, מלבד

426
00:17:32,560 --> 00:17:34,810
רק שיש סוג של כיף על רמפה שבו אתה יכול לעשות

427
00:17:34,810 --> 00:17:36,590
משהו שמאוד גרפי, ואנימציה, ו

428
00:17:36,590 --> 00:17:39,000
shareable וכדומה, גם להעביר את הרעיון כי

429
00:17:39,000 --> 00:17:42,010
כל הרעיונות שאנחנו מתחילים לצלול להיום ואילך

430
00:17:42,010 --> 00:17:44,300
כבר מגולם באפילו כך פשוט

431
00:17:44,300 --> 00:17:46,850
ממשק מאז יום אחד.

432
00:17:46,850 --> 00:17:47,790
מה דעתך על זה כאן?

433
00:17:47,790 --> 00:17:48,860
>> אז תנאים.

434
00:17:48,860 --> 00:17:50,590
אז בלוק השריטות בצד השמאל יש נראה

435
00:17:50,590 --> 00:17:51,610
קצת יותר מורכב.

436
00:17:51,610 --> 00:17:52,650
אבל זה רק חלק והגרירה

437
00:17:52,650 --> 00:17:54,140
נשירה של חלקים מוכרים.

438
00:17:54,140 --> 00:17:56,690
אם x קטן מ-y, אז תגיד.

439
00:17:56,690 --> 00:17:59,900
אחר אם x גדול מ-y, אז תגיד.

440
00:17:59,900 --> 00:18:02,460
אחר, אנו יכולים להניח שזה הגיוני להסיק כי

441
00:18:02,460 --> 00:18:03,580
הם חייבים להיות שווים.

442
00:18:03,580 --> 00:18:05,220
אז להגיד שהם שווים.

443
00:18:05,220 --> 00:18:07,690
עכשיו ב-C באותו הדבר הנכון, מדויק.

444
00:18:07,690 --> 00:18:09,730
ושים לב שהסוגריים המסולסלים הולכים להיות

445
00:18:09,730 --> 00:18:12,190
תכונה של C ושפות אחרות שלא עושות סוג זה

446
00:18:12,190 --> 00:18:13,210
של אנקפסולציה.

447
00:18:13,210 --> 00:18:15,470
בדיוק כמו אם בלוק הוא הדבר הצהוב הזה זה סוג של

448
00:18:15,470 --> 00:18:17,770
תופס בלוק הסגול בתוכו.

449
00:18:17,770 --> 00:18:19,480
כמו כן הן סיכות אלה -

450
00:18:19,480 --> 00:18:20,870
סיכות אלה מסולסלים -

451
00:18:20,870 --> 00:18:24,710
נועד להעלות באוב את אותו רעיון של אימוץ אחד או יותר

452
00:18:24,710 --> 00:18:27,680
שורות קוד שמסוכסך בתוכם.

453
00:18:27,680 --> 00:18:31,270
אז בצד הימני כאן, אם x קטן מ-y, printf

454
00:18:31,270 --> 00:18:32,270
("X קטן מ-y").

455
00:18:32,270 --> 00:18:34,980
אחר אם x גדול מ-y, להדפיס אותו.

456
00:18:34,980 --> 00:18:38,360
אחר להדפיס שהם שווים.

457
00:18:38,360 --> 00:18:41,750
>> אז בקיצור, יש מיפוי או תרגום ישיר למדי

458
00:18:41,750 --> 00:18:44,720
בשפה שראינו עד כה, כולל לחלק

459
00:18:44,720 --> 00:18:45,940
מהתכונות המתוחכמות יותר.

460
00:18:45,940 --> 00:18:48,680
אז אתה לא יכול להיות באמצעות זה לפרויקט שלך, ואולי גם לא

461
00:18:48,680 --> 00:18:51,150
להיות באמצעות זה לפרויקט שלך השבוע.

462
00:18:51,150 --> 00:18:54,650
אבל יש לנו את הדברים האלה קראו במערכי ג בלגרד,

463
00:18:54,650 --> 00:18:55,680
הם נקראים רשימות.

464
00:18:55,680 --> 00:18:59,370
וראינו את אלה עם Fruitcraft RPG בשבוע שעבר.

465
00:18:59,370 --> 00:19:01,320
הבחור הקטן והכחול שהסתובב, להרים

466
00:19:01,320 --> 00:19:03,010
דובדבנים ותפוזים וכדומה.

467
00:19:03,010 --> 00:19:05,110
ובכן בלגרד, שיושם עם זה כתום

468
00:19:05,110 --> 00:19:09,000
לחסום המכיל מילים, במקרה זה, אנחנו ממש

469
00:19:09,000 --> 00:19:10,800
הוספה "כתום" כדי

470
00:19:10,800 --> 00:19:12,460
משתנה בשם המלאי.

471
00:19:12,460 --> 00:19:14,910
אז ב-C, תחביר זה הולך להיות קצת יותר מסתורי.

472
00:19:14,910 --> 00:19:17,250
ואנחנו נחזור לזה בשבוע הבא ולעשות יותר

473
00:19:17,250 --> 00:19:21,060
דברים מעניינים בעולם של קריפטוגרפיה עם זה.

474
00:19:21,060 --> 00:19:23,990
אבל כאן בתחתית, שתי שורות אלה למעשה

475
00:19:23,990 --> 00:19:27,550
לתרגם את מה שאנחנו עושים בשריטה אחת לחסום שם למעלה.

476
00:19:27,550 --> 00:19:30,120
אבל גם על זה שיבוא.

477
00:19:30,120 --> 00:19:34,120
>> כדי לשים את זה ביחד, כאן הוא תכנית ב C. אז בואו

478
00:19:34,120 --> 00:19:36,590
להקניט את המהירות מלבד כמה חתיכות של תחביר כאן, אבל

479
00:19:36,590 --> 00:19:40,300
אז בואו באמת תתחילו לכתוב קצת קוד, להכיר

480
00:19:40,300 --> 00:19:42,440
אתה עם כמה מהכלים שאנחנו משתמשים, ולראות אם אנחנו

481
00:19:42,440 --> 00:19:45,400
יכול לבנות על עכשיו כמה מאבני הבניין הבסיסיים אלה מ

482
00:19:45,400 --> 00:19:49,150
בשבוע שעבר, עכשיו מבחינה תחבירית בC. אז בראש כאן, זה

483
00:19:49,150 --> 00:19:51,380
היא אולי האחת התוכניות המשעממות ביותר שאתה יכול

484
00:19:51,380 --> 00:19:53,130
לכתוב בכל שפת תכנות ביותר.

485
00:19:53,130 --> 00:19:55,010
אבל היא איכשהו יש משמעות מיוחדת בגלל שזה

486
00:19:55,010 --> 00:19:58,120
תכנית קנונים שכל מדען מחשב כותב כש

487
00:19:58,120 --> 00:19:59,620
ללמד מישהו שפת תכנות -

488
00:19:59,620 --> 00:20:01,230
תכנית שלום עולם.

489
00:20:01,230 --> 00:20:05,120
>> אז בחלקו העליון, אנו רואים את הרעיון הזה של # כולל

490
00:20:05,120 --> 00:20:08,180
ולאחר מכן, בסוגריים הזוויתיים, stdio.h.

491
00:20:08,180 --> 00:20:10,580
אנחנו הולכים לחזור לזה, אבל באמת מה ש

492
00:20:10,580 --> 00:20:13,770
פירוש דבר הוא כי קיים קובץ בעולם הזה שנקרא סטנדרטי

493
00:20:13,770 --> 00:20:17,670
I / O, stdio נקודת שעות, וזה רק קובץ טקסט ה

494
00:20:17,670 --> 00:20:19,240
מישהו כתב לפני שנים.

495
00:20:19,240 --> 00:20:22,550
ובתוך קובץ טקסט שהם קבוצה שלמה של

496
00:20:22,550 --> 00:20:25,840
פונקציות, או בשיטות או בנהלים, שמישהו אחר

497
00:20:25,840 --> 00:20:28,970
כתב שהם מקבלים, כי אנחנו

498
00:20:28,970 --> 00:20:31,420
כעת תוכל להשתמש בקוד של אותו האדם.

499
00:20:31,420 --> 00:20:33,070
את הפונקציות שהוא או היא כתבה.

500
00:20:33,070 --> 00:20:36,320
במקרה זה, printf זה לא משהו שאני כתבתי, זה

501
00:20:36,320 --> 00:20:37,500
לא משהו שCS50 כתב.

502
00:20:37,500 --> 00:20:40,290
זה משהו שמישהו כתב לפני שנים ולשים

503
00:20:40,290 --> 00:20:43,450
קובץ שנקרא stdio.h ואז, כבדרך אגב, לשים

504
00:20:43,450 --> 00:20:45,830
חלק אחר של הפונקציה בקובץ אחר.

505
00:20:45,830 --> 00:20:46,940
אבל אנחנו נגיע לשם.

506
00:20:46,940 --> 00:20:50,070
>> אז # כולל <stdio.h> הוא פשוט הדרך שלנו לומר, ב

507
00:20:50,070 --> 00:20:53,110
C, לתת לי גישה לפונקציות שמישהו אחר כתב.

508
00:20:53,110 --> 00:20:55,490
ובמקרה זה שאכפת לי כי אני רוצה printf.

509
00:20:55,490 --> 00:20:57,530
עכשיו אנחנו מקבלים int main (void).

510
00:20:57,530 --> 00:21:00,160
אז זה אחד מהדברים האלה, בכנות, כי ביום 0,

511
00:21:00,160 --> 00:21:02,400
די לי לסוג של את האיזור, כי זה פשוט

512
00:21:02,400 --> 00:21:03,260
לא מעניין

513
00:21:03,260 --> 00:21:04,780
מבחינה אינטלקטואלית, חלק מהתחביר.

514
00:21:04,780 --> 00:21:07,940
אבל לעת עתה יודע כי פונקציות, הידוע גם בכינויו

515
00:21:07,940 --> 00:21:11,660
נהלים, או שיטות, בדרך כלל לייצר איזה שהוא ערך.

516
00:21:11,660 --> 00:21:12,520
הם עושים משהו.

517
00:21:12,520 --> 00:21:13,810
הם באים עם תשובה.

518
00:21:13,810 --> 00:21:15,020
הם מייצרים פלט.

519
00:21:15,020 --> 00:21:18,780
אז int ליד עיקרי היא רק דרך הקיצור שלנו אומרים

520
00:21:18,780 --> 00:21:21,380
שפונקציה זו, הליך זה, סופו של דבר הוא הולכת

521
00:21:21,380 --> 00:21:22,650
כדי לתת לך חזרה מספר.

522
00:21:22,650 --> 00:21:24,370
ולמה שהוא, אנחנו נחזור אליו.

523
00:21:24,370 --> 00:21:27,810
העיקרי הוא הסטנדרט העולמי לברירת מחדל ברירת המחדל

524
00:21:27,810 --> 00:21:30,990
פונקציה שהולכת לקבל להורג בתכנית C כש

525
00:21:30,990 --> 00:21:31,860
אתה מפעיל את זה.

526
00:21:31,860 --> 00:21:34,160
החלל רק אומר את הדבר הזה, עיקרי, לא לוקח

527
00:21:34,160 --> 00:21:35,270
טיעונים, במקרה זה.

528
00:21:35,270 --> 00:21:36,400
אז אני סופר להיות מפורש.

529
00:21:36,400 --> 00:21:38,160
אין שום התחייבויות בשם, אין שום פסיקים.

530
00:21:38,160 --> 00:21:40,690
Void אומר שאין טיעונים לראשיים.

531
00:21:40,690 --> 00:21:44,350
>> עכשיו לבסוף, למרבה המזל, שתי השורות האחרונות הן מוכרות.

532
00:21:44,350 --> 00:21:46,160
בתוך הסוגריים המסולסלים יש לנו printf

533
00:21:46,160 --> 00:21:47,620
ויש לנו תמורה.

534
00:21:47,620 --> 00:21:50,450
והתמורה היא סוג של מזל שיש לנו כדי

535
00:21:50,450 --> 00:21:53,510
הכניס אותו לשם, כי במקרה הזה זה לא עושה את כל מה ש

536
00:21:53,510 --> 00:21:54,600
חלק גדול מעניין.

537
00:21:54,600 --> 00:21:58,790
אבל בתוכנת מחשב, כאשר פונקציה מחזירה 0,

538
00:21:58,790 --> 00:22:00,610
זה אומר שמכיל בסדר.

539
00:22:00,610 --> 00:22:01,820
שום דבר לא השתבש.

540
00:22:01,820 --> 00:22:06,170
לעומת זאת, אם פונקצית המחזירה 1, או 1 שלילי, או

541
00:22:06,170 --> 00:22:11,670
1337 שליליים, או כמה מספרים אקראיים כמו ש, כי

542
00:22:11,670 --> 00:22:14,020
בדרך כלל אומר שבעצם התרחשה שגיאה.

543
00:22:14,020 --> 00:22:16,150
אז אם אתה ב-Mac או במחשב האישי שלך, אם אי פעם ראית

544
00:22:16,150 --> 00:22:18,590
מסר כלשהו מעצבן כי המחשב שלך התרסק או

545
00:22:18,590 --> 00:22:20,660
קפוא, ויש הודעת שגיאה סתומה,

546
00:22:20,660 --> 00:22:23,320
ועוד קצת קוד, כמו קוד מערכת

547
00:22:23,320 --> 00:22:25,110
1,2,3,4, חלק מספר,

548
00:22:25,110 --> 00:22:29,270
כי בדרך כלל הוא פרט מיותר לספר

549
00:22:29,270 --> 00:22:32,110
רובנו בני האדם, אבל זה מה שאיזה אירוע כלשהו

550
00:22:32,110 --> 00:22:34,890
תכנית בעצם חזרה, ערך שאינו אפס.

551
00:22:34,890 --> 00:22:38,540
והיתרון של זה הוא ש0 פירוש כל, כמו גם, ו

552
00:22:38,540 --> 00:22:40,470
אז אתה בעצם יש מספר אינסופי של דברים ש

553
00:22:40,470 --> 00:22:41,130
יכול להשתבש.

554
00:22:41,130 --> 00:22:44,700
זאת הסיבה שהם בחרו 0 לטובים וערך שאינו אפס עבור

555
00:22:44,700 --> 00:22:46,450
רע, כפי שמייד תראו.

556
00:22:46,450 --> 00:22:47,870
>> אז בואו נלך קדימה ולכתוב את זה.

557
00:22:47,870 --> 00:22:51,610
אז זוכר שלפני כמה הימים הייתי מק להיפתח

558
00:22:51,610 --> 00:22:53,970
חלון מסוף, ולאחר מכן פתחתי את תכנית טקסט, כמו

559
00:22:53,970 --> 00:22:55,900
TextEdit, והתחלתי לכתוב קצת קוד.

560
00:22:55,900 --> 00:22:56,580
טוב, זה בסדר גמור.

561
00:22:56,580 --> 00:22:58,636
אבל הניסיון שלך הולך להיות שונים במקינטוש, או

562
00:22:58,636 --> 00:23:01,220
על Solaris מחשב, מחשב לינוקס, מה הפעלה

563
00:23:01,220 --> 00:23:02,810
מערכת יקרה לך להיות באמצעות.

564
00:23:02,810 --> 00:23:04,970
וכן בקורס, מה שבמקום להשתמש במשהו

565
00:23:04,970 --> 00:23:07,010
קרא CS50 Appliance.

566
00:23:07,010 --> 00:23:10,420
אז CS50 המכשיר הוא חתיכה להורדה של תוכנה

567
00:23:10,420 --> 00:23:13,640
שמאפשר לך להריץ מערכת הפעלה שנקראת לינוקס,

568
00:23:13,640 --> 00:23:16,810
במיוחד פדורה לינוקס, ב-Mac או במחשב האישי שלך.

569
00:23:16,810 --> 00:23:20,810
ואתה עושה את זה על ידי הורדת משהו שנקרא hypervisor.

570
00:23:20,810 --> 00:23:23,100
אז כל זה יהיה מתועד בסט בעיה 1.

571
00:23:23,100 --> 00:23:25,240
ואתה תהיה הובלת לכיוון מה שאתה צריך להוריד.

572
00:23:25,240 --> 00:23:27,510
אבל התוצאה הסופית, בין אם יש לכם מק או PC, היא

573
00:23:27,510 --> 00:23:29,080
להוריד כמה תוכנות חופשיות.

574
00:23:29,080 --> 00:23:32,340
לאחר מכן עליך להוריד את מכשיר CS50, ואתה אומר ש

575
00:23:32,340 --> 00:23:33,960
תוכנה חופשיה - hypervisor -

576
00:23:33,960 --> 00:23:38,080
כדי להפעיל את מכשיר CS50 בחלון במחשב שלך.

577
00:23:38,080 --> 00:23:39,490
ומה שקורה הוא זה.

578
00:23:39,490 --> 00:23:43,660
>> יש לי עכשיו, שים לב כאן, מה שנראה כמו שולחן עבודה

579
00:23:43,660 --> 00:23:44,130
הסביבה.

580
00:23:44,130 --> 00:23:46,150
ותנו לי באמת מתכווץ החלון הבודד הזה.

581
00:23:46,150 --> 00:23:49,640
אז זה כרגע הוא Mac שלי, עם חלון קטן כאן, ובתוך

582
00:23:49,640 --> 00:23:51,300
בחלון זה קורה להיות לחלוטין

583
00:23:51,300 --> 00:23:52,380
מערכת הפעלה אחרת.

584
00:23:52,380 --> 00:23:55,250
ואכן יש תפריט התחל זה כאן למטה, מזכיר

585
00:23:55,250 --> 00:23:57,990
חלונות, שיש לו חבורה שלמה של תפריט משנה, לרבות

586
00:23:57,990 --> 00:24:00,720
קישור לCS50 הידני, Dropbox, וכמו.

587
00:24:00,720 --> 00:24:03,480
ומה סביבה זו כרגע היא סביבה סטנדרטית

588
00:24:03,480 --> 00:24:06,280
שכל אחד מאיתנו יכול כעת להשתמש, כך שלא משנה מה שלך

589
00:24:06,280 --> 00:24:08,960
מחשב הוא, מה יש לך ולהתקין עליו, איזו גרסה

590
00:24:08,960 --> 00:24:11,430
של Mac OS או Windows שאתה מפעיל, כולנו עכשיו יש את

591
00:24:11,430 --> 00:24:12,800
אותה הסביבה.

592
00:24:12,800 --> 00:24:15,850
ועכשיו בסביבה זו אנו יכולים להתחיל לכתוב קוד כלשהו.

593
00:24:15,850 --> 00:24:18,480
>> אז אני הולך קדימה, לפתוח בתכנית בשם gedit.

594
00:24:18,480 --> 00:24:21,500
זה דומה לnotepad.exe, או

595
00:24:21,500 --> 00:24:22,790
TextEdit על מק.

596
00:24:22,790 --> 00:24:25,390
וזו רק תכנית לעריכת טקסט פשוטה סופר

597
00:24:25,390 --> 00:24:27,500
שנראה כך במבט הראשון.

598
00:24:27,500 --> 00:24:30,640
עכשיו בחלק עליון, יש לי לוח לבן, בתחתיתי

599
00:24:30,640 --> 00:24:33,860
יש חלון השחור הזה שאומר @ מכשיר jharvard.

600
00:24:33,860 --> 00:24:36,440
וזה משום שחשבון המשתמש שנוצרנו מראש,

601
00:24:36,440 --> 00:24:38,430
לכולם נקרא ג'ון הרווארד.

602
00:24:38,430 --> 00:24:41,490
יש לו תיקייה שבה כל הקבצים שלו הולכים לעבור, ו

603
00:24:41,490 --> 00:24:43,500
כאן מקום שבו אנחנו יכולים להתחיל לכתוב קוד כלשהו.

604
00:24:43,500 --> 00:24:45,810
אז תן לי ללכת קדימה פה ולהתקרב קצת, ואני

605
00:24:45,810 --> 00:24:51,550
הולך לעשות # include <stdio.h>, int main (void), ו

606
00:24:51,550 --> 00:24:57,470
אז אני הולך לעשות printf ("hello world")

607
00:24:57,470 --> 00:24:59,490
, להחזיר 0.

608
00:24:59,490 --> 00:25:01,400
עכשיו כל זה ממש שחור ולבן.

609
00:25:01,400 --> 00:25:03,830
>> תן לי ללכת קדימה ולעשות דבר אחד ללמד gedit מה אני

610
00:25:03,830 --> 00:25:04,510
בעצם עושה.

611
00:25:04,510 --> 00:25:06,140
תן לי ללכת לשמירה בשם.

612
00:25:06,140 --> 00:25:08,560
אני הולך לבחור בצד השמאל כאן jharvard.

613
00:25:08,560 --> 00:25:11,010
אז שוב, גם אם מעולם לא השתמש בלינוקס לפני, בכנות

614
00:25:11,010 --> 00:25:13,680
בימים אלה, כולם צללו לתוך המהות

615
00:25:13,680 --> 00:25:14,590
אותו סוג של ממשק -

616
00:25:14,590 --> 00:25:16,030
Mac OS, Windows ו-Linux.

617
00:25:16,030 --> 00:25:18,680
אז בחרתי תיקיית הבית של jharvard כאן.

618
00:25:18,680 --> 00:25:21,120
ואני הולך לשמור קובץ זה כhello.c.

619
00:25:21,120 --> 00:25:24,260
אז בחלקו עליון, שהקלדתי hello.c; שמות ג

620
00:25:24,260 --> 00:25:26,520
תכנית עם. הארכת ג היא

621
00:25:26,520 --> 00:25:27,570
מה מנהג נפוץ.

622
00:25:27,570 --> 00:25:28,650
ואני מכה על שמור.

623
00:25:28,650 --> 00:25:32,510
ועכשיו מה שיפה הוא שאני כבר למדתי ביעילות gedit,

624
00:25:32,510 --> 00:25:33,690
כי מדובר בתכנית C.

625
00:25:33,690 --> 00:25:36,470
שימו לב שהטקסט השחור ולבן שלי עכשיו מקודד לפי צבע, או

626
00:25:36,470 --> 00:25:39,330
התחביר הדגיש, שפשוט מושך את תשומת הלב ל

627
00:25:39,330 --> 00:25:41,540
חלקים סמנטיים שונים של התכנית.

628
00:25:41,540 --> 00:25:44,260
בחלק שמאלי העליון שם, כמו התוכניות שלי מורכבות יותר ויותר, אני

629
00:25:44,260 --> 00:25:47,060
הולך להיות סיכום של כל הדברים שכתבתי.

630
00:25:47,060 --> 00:25:48,050
אז זה אותו שם.

631
00:25:48,050 --> 00:25:52,350
אז תן לי עכשיו להתרחק ולרדת לחלון מסוף זה.

632
00:25:52,350 --> 00:25:54,570
>> אז זה אולי חדש לאנשים רבים.

633
00:25:54,570 --> 00:25:57,260
אם מעולם לא השתמשתי בסביבת שורת פקודה, אתה אף פעם לא

634
00:25:57,260 --> 00:26:00,020
שימוש DOS, או שמעולם לא השתמש לינוקס, או שמעולם לא נפתח

635
00:26:00,020 --> 00:26:02,550
חלון מסוף Mac OS שלך, יש הרבה דברים שאתה

636
00:26:02,550 --> 00:26:04,820
יכל לעשות עם GUI, כגון הצבעה, ולחיצה, ו

637
00:26:04,820 --> 00:26:07,080
גרירה ושחרור, וכדומה, אבל באופן כללי -

638
00:26:07,080 --> 00:26:09,360
בוודאי בעולם של מדעי מחשב -

639
00:26:09,360 --> 00:26:11,580
שימוש בשורת פקודה, שבו אתה לא צריך עכבר

640
00:26:11,580 --> 00:26:14,220
בדרך כלל, יש לך מקלדת שלך בלבד, הוא למעשה הרבה

641
00:26:14,220 --> 00:26:17,260
חזק יותר מממשק, ברגע שתתרגל ל

642
00:26:17,260 --> 00:26:18,580
פקודות שונות.

643
00:26:18,580 --> 00:26:20,940
ואתה בעצמך סוג של תשלום של צורך להצביע וללחוץ

644
00:26:20,940 --> 00:26:21,690
בכל דבר.

645
00:26:21,690 --> 00:26:23,890
אז בgedit נטפלנו בליהנות מהטוב שבשני העולמים.

646
00:26:23,890 --> 00:26:25,600
אנחנו יכולים לגרור ולשחרר את הטקסט, אנחנו יכולים לראות את זה

647
00:26:25,600 --> 00:26:26,840
נחמד וצבעוני.

648
00:26:26,840 --> 00:26:29,630
אבל כאשר זה מגיע זמן להפעיל את התכנית שלנו, לפעמים

649
00:26:29,630 --> 00:26:31,750
פשוט להשתמש בחלון הקטן הזה כאן.

650
00:26:31,750 --> 00:26:33,460
>> אז אני הולך קדימה ולעשות את זה.

651
00:26:33,460 --> 00:26:36,420
בחלון השחור ולבן התחתון, אני הולך קדימה

652
00:26:36,420 --> 00:26:37,890
ולכתוב קלאנג.

653
00:26:37,890 --> 00:26:40,130
וצלצולים, הוא השם של מהדר.

654
00:26:40,130 --> 00:26:43,310
מדובר בתכנית שממירה את קוד המקור שלי

655
00:26:43,310 --> 00:26:48,770
ל, ולכן, קוד אובייקט.

656
00:26:48,770 --> 00:26:51,270
0s ו 1s, שראינו בשבוע שעבר בקצרה.

657
00:26:51,270 --> 00:26:53,700
כזכור משבוע שעבר, הבטחתי שאנחנו הולכים

658
00:26:53,700 --> 00:26:55,920
ללכת ממשהו כזה - שהיינו צריך להיות

659
00:26:55,920 --> 00:26:57,010
משהו כמו זה -

660
00:26:57,010 --> 00:26:58,700
וזה בהחלט לא משהו שאדם הולך

661
00:26:58,700 --> 00:26:59,690
לעשות באופן ידני.

662
00:26:59,690 --> 00:27:01,980
אז במקום שאנחנו הולכים להשתמש בתכנית, וכי התכנית ב

663
00:27:01,980 --> 00:27:03,430
מקרה זה נקרא קלאנג.

664
00:27:03,430 --> 00:27:06,020
והשם של התכנית שלי הוא hello.c.

665
00:27:06,020 --> 00:27:09,670
אז כדי לקמפל מקוד המקור hello.c אל

666
00:27:09,670 --> 00:27:12,930
קוד יעד, או 0s ו 1s, זה צריך להספיק רק לעשות

667
00:27:12,930 --> 00:27:14,820
זה ולחץ על Enter.

668
00:27:14,820 --> 00:27:16,850
>> אוקיי, נראה כאילו כלום לא קרה.

669
00:27:16,850 --> 00:27:20,450
אבל אני יודע עכשיו, או משבוע שעבר, ששם ברירת המחדל של

670
00:27:20,450 --> 00:27:24,920
תכנית, כאשר כתבו ב-C, נקראת טיפשות a.out.

671
00:27:24,920 --> 00:27:26,610
שם לא מעניין ביותר שאתה יכול לבוא עם.

672
00:27:26,610 --> 00:27:28,790
היא האות הראשונה של האלפבית, את מה שהיה

673
00:27:28,790 --> 00:27:29,960
outputted, אבל ניחא.

674
00:27:29,960 --> 00:27:33,570
זו התכנית שלי, ועכשיו נקודת לוכסן, כפי שנראה, הוא

675
00:27:33,570 --> 00:27:36,170
למעשה רק סוג של תכונת אבטחה, כי

676
00:27:36,170 --> 00:27:38,250
a.out הוא תכנית שכתבתי.

677
00:27:38,250 --> 00:27:39,650
זה לא בא עם המחשב שלי, זה

678
00:27:39,650 --> 00:27:40,790
לא בProgram Files.

679
00:27:40,790 --> 00:27:42,910
זה לא בתיקיית היישומים של Mac OS.

680
00:27:42,910 --> 00:27:45,740
אני צריך להיות סופר מפורש עם המחשב, ואומר

681
00:27:45,740 --> 00:27:49,030
תכנית זו, a.out, היא בתיקייה הנוכחית,

682
00:27:49,030 --> 00:27:50,260
ספרייה נוכחית.

683
00:27:50,260 --> 00:27:53,160
והדרך שאתה מייצג זה בסביבה כזאת

684
00:27:53,160 --> 00:27:57,070
היא הנקודה מייצגת כל מה תיקייה שנמצאת כעת פנימה

685
00:27:57,070 --> 00:27:59,420
וכך. / רק אומר a.out לרוץ

686
00:27:59,420 --> 00:28:00,530
בתיקייה הנוכחית.

687
00:28:00,530 --> 00:28:04,830
ואני רציתי בזה עם זן, וזהו, התכנית הראשונה שלי.

688
00:28:04,830 --> 00:28:05,990
>> עכשיו בואו תיקחו אותי צעד אחורה.

689
00:28:05,990 --> 00:28:08,280
החלון זה קצת קטן, ולהבין שהתחתית

690
00:28:08,280 --> 00:28:10,340
השאיר במכשיר כאן הוא סמל אחר.

691
00:28:10,340 --> 00:28:12,660
אחת הוא כרום, שאמור להיות די מוכר, רק באינטרנט

692
00:28:12,660 --> 00:28:14,350
דפדפן הפנימי של המכשיר.

693
00:28:14,350 --> 00:28:16,340
וסמל שחור ולבן זה רק

694
00:28:16,340 --> 00:28:17,720
חלון מסוף גדול יותר.

695
00:28:17,720 --> 00:28:19,830
אז אם זה נעשה קצת מעצבן למיין של יש פשוט

696
00:28:19,830 --> 00:28:22,270
פרוסה זה קטנטן של חלון שבאינטראקציה

697
00:28:22,270 --> 00:28:24,370
עם תוכניות, אנחנו יכולים לעשות את זה במקום.

698
00:28:24,370 --> 00:28:26,640
ועכשיו הרשה לי להתחיל להקליד כמה בקרוב

699
00:28:26,640 --> 00:28:27,980
להיות פקודות מוכרות.

700
00:28:27,980 --> 00:28:28,900
ls.

701
00:28:28,900 --> 00:28:31,410
אז ls הוא הפקודה לרישום.

702
00:28:31,410 --> 00:28:33,900
אז ב- Mac OS או Windows, שהיית בדרך כלל ללחוץ פעמים

703
00:28:33,900 --> 00:28:36,510
תיקייה ולאחר מכן, וזהו, אתה רואה את כל קבצים השונים

704
00:28:36,510 --> 00:28:37,210
ותיקיות.

705
00:28:37,210 --> 00:28:39,650
בסביבת שורת פקודה, שבו אתה יכול להקליד רק

706
00:28:39,650 --> 00:28:42,390
פקודות או טקסט, ls היא שווה הערך.

707
00:28:42,390 --> 00:28:44,380
אז תראה לי מה שיש במדריך זה.

708
00:28:44,380 --> 00:28:46,540
>> עכשיו יש כאן חבורה של דברים, שהוא גם קטן

709
00:28:46,540 --> 00:28:48,190
מוכר וקצת לא מוכר.

710
00:28:48,190 --> 00:28:50,740
אבל שים לב שבדיוק כמו Windows ו-Mac OS, jharvard

711
00:28:50,740 --> 00:28:52,190
יש תיקיית שולחן עבודה.

712
00:28:52,190 --> 00:28:54,520
אז סמלים כלשהם שנמצאים בשולחן העבודה שלי יקרו

713
00:28:54,520 --> 00:28:55,650
להיות באותה תיקייה.

714
00:28:55,650 --> 00:28:57,250
יש תיקיית הורדות, דברים ש

715
00:28:57,250 --> 00:28:58,890
כרום יכול לשים שם.

716
00:28:58,890 --> 00:28:59,250
Dropbox.

717
00:28:59,250 --> 00:29:01,820
אז המכשיר מגיע עם תמיכה מובנית לDropbox

718
00:29:01,820 --> 00:29:04,500
כך שבמשך הסמסטר, אתה יכול לסנכרן עם Dropbox

719
00:29:04,500 --> 00:29:06,420
חשבון, כך שכל התוכניות שלך מגובה.

720
00:29:06,420 --> 00:29:08,050
הם נגישים במחשב האחר שלך.

721
00:29:08,050 --> 00:29:09,780
אם משהו משתבש עם המכשיר, אתה יכול

722
00:29:09,780 --> 00:29:11,340
מאוד בקלות להתאושש מDropbox.

723
00:29:11,340 --> 00:29:12,940
אז התיקייה שנמצאת שם בשביל זה.

724
00:29:12,940 --> 00:29:14,660
יש שני קבצים שנעשיתי - hello.c

725
00:29:14,660 --> 00:29:16,540
וa.out.

726
00:29:16,540 --> 00:29:18,530
ואז לימין יש כמה תיקיות אחרות שעוד

727
00:29:18,530 --> 00:29:20,710
להגיע לקראת הסוף הסמסטר, באינטרנט

728
00:29:20,710 --> 00:29:21,540
תכנות.

729
00:29:21,540 --> 00:29:26,160
אז כשאני עושה. /, A.out, Enter, זה אומר ללכת

730
00:29:26,160 --> 00:29:29,460
בספרייה אני ב, הספרייה הנוכחית, ולהפעיל את

731
00:29:29,460 --> 00:29:32,465
תכנית בשם a.out ממש שם.

732
00:29:32,465 --> 00:29:35,810
>> בסדר, כך שזה נחמד וטוב, אבל זה לא כל כך

733
00:29:35,810 --> 00:29:38,550
משכנע לכתוב תכנית בשם לעזור a.out.

734
00:29:38,550 --> 00:29:40,790
אז אנחנו באמת יכולים לעשות את זה קצת אחר.

735
00:29:40,790 --> 00:29:43,980
אז במקום סתם צלצול ריצה, hello.c, בואו נוסיף

736
00:29:43,980 --> 00:29:46,850
מה שנקרא ארגומנט שורת פקודה.

737
00:29:46,850 --> 00:29:50,730
אז טיעון של שורת פקודה, או מתג במקרה זה, הוא פשוט

738
00:29:50,730 --> 00:29:54,930
עוד מילה או צירוף מילים שהקלדתם בשורת פקודה לאחר

739
00:29:54,930 --> 00:29:56,290
התכנית שאתה רוצה לרוץ.

740
00:29:56,290 --> 00:29:59,970
אז במקרה הזה, צלצול הוא התכנית אני רוצה לרוץ,-O

741
00:29:59,970 --> 00:30:03,480
פלט באמצעות קובץ שכבר לא נקרא a.out.

742
00:30:03,480 --> 00:30:07,510
פלט קובץ בשם השלום, ולעשות זאת על ידי איסוף

743
00:30:07,510 --> 00:30:10,200
המילה אחרונה בשורה, hello.c.

744
00:30:10,200 --> 00:30:13,200
אז בקיצור, זה שיפור מאוד שולי, לפיה

745
00:30:13,200 --> 00:30:15,850
במקום שיש a.out קובץ בשם זה בטיפשות,

746
00:30:15,850 --> 00:30:21,430
עכשיו אני יכול לעשות צלצול-o שלום, אז hello.c, ו

747
00:30:21,430 --> 00:30:22,530
לאחר מכן על Enter.

748
00:30:22,530 --> 00:30:25,510
שום דבר לא נראה שיקרה, אבל שוב הרבה כמו עם 0 - כאשר

749
00:30:25,510 --> 00:30:28,510
נדמה ששום דבר יקרה זה אומר ששום דבר רע שקרה -

750
00:30:28,510 --> 00:30:31,460
אז בואו נעשה ls עכשיו, זן, ואכן אני עכשיו

751
00:30:31,460 --> 00:30:32,780
יש תכנית שלום.

752
00:30:32,780 --> 00:30:38,510
אז אם אני מקליד שלום עכשיו, פקודה לא נמצאה.

753
00:30:38,510 --> 00:30:39,440
בסדר,. /.

754
00:30:39,440 --> 00:30:40,220
אז בדיוק נכון.

755
00:30:40,220 --> 00:30:43,170
לכן, מכיוון שהתכנית שכתבתי, וזה לא בא עם

756
00:30:43,170 --> 00:30:45,810
המחשב,. / שלום, Enter, אומר

757
00:30:45,810 --> 00:30:47,350
עכשיו אני רץ שלום.

758
00:30:47,350 --> 00:30:48,440
>> אז זה מה שיש.

759
00:30:48,440 --> 00:30:51,070
עכשיו מה שנעשינו בסופו להגיע לשורת פקודה יותר ויותר

760
00:30:51,070 --> 00:30:54,110
טיעונים שמאפשרים לנו לעשות יותר, אבל רק לאלה ל

761
00:30:54,110 --> 00:30:57,760
מי זה יכול להיות כובע ישן, תן לי למעשה להיכנס

762
00:30:57,760 --> 00:31:01,910
ספרייה כאן ורק לתת לך טיזר של כמה אחר שאנו

763
00:31:01,910 --> 00:31:05,770
אפשר ללכת על יישום שלום העולם.

764
00:31:05,770 --> 00:31:10,730
תן לי ללכת לכאן, ואני הולך לפתוח אותו.

765
00:31:10,730 --> 00:31:13,090
כך שלמעשה, אני הולך להסביר מה אני עושה, ולכן

766
00:31:13,090 --> 00:31:15,610
זה שימושי.

767
00:31:15,610 --> 00:31:17,410
תן לי בחזרה למעלה.

768
00:31:17,410 --> 00:31:19,620
>> אז אני עושה את זה כבר זמן רב.

769
00:31:19,620 --> 00:31:23,030
אז שם לב מצד ימין יש כמה

770
00:31:23,030 --> 00:31:26,940
ספריות הנקראות בשמות מוזרים source1m וsource1w.

771
00:31:26,940 --> 00:31:28,830
זוהי רק מוסכמה המטופשת אנו משתמשים.

772
00:31:28,830 --> 00:31:31,825
מקור רק אומר שקוד מקור, 1 פירוש זה הוא שבוע אחד, ו

773
00:31:31,825 --> 00:31:34,000
מ 'אומר שזה יום שני, וw אומר שזה יום רביעי.

774
00:31:34,000 --> 00:31:34,900
כך ששום דבר מסתורי שם.

775
00:31:34,900 --> 00:31:37,830
זה פשוט סימון מקוצר.

776
00:31:37,830 --> 00:31:39,860
הדברים הכחולים האלה הם תיקיות, הידוע גם בכינויו

777
00:31:39,860 --> 00:31:40,630
ספריות.

778
00:31:40,630 --> 00:31:43,870
אני רוצה להיכנס לתיקייה שעכשיו, ועל מחשב רגיל

779
00:31:43,870 --> 00:31:45,710
אני יכול פשוט ללחוץ לחיצה כפולה על סמל תיקייה ו

780
00:31:45,710 --> 00:31:46,810
יש את כל הקבצים שלי.

781
00:31:46,810 --> 00:31:49,270
אבל בסביבת שורת פקודה, אני לא ממש יכול לעשות

782
00:31:49,270 --> 00:31:52,640
ש, אז במקום זה, אני צריך לשנות ספריות באופן ידני.

783
00:31:52,640 --> 00:31:57,900
אז אם אני מקליד CD ולאחר מכן source1m, Enter, תבחין כי

784
00:31:57,900 --> 00:32:01,180
הפקודה, הדבר בלבן בצד שמאל, פשוט השתנה.

785
00:32:01,180 --> 00:32:03,690
וכך אכן, כאשר הוא רק אמר סוגריים ולאחר מכן את

786
00:32:03,690 --> 00:32:06,450
שרבוט קטן, סמל טילדה, שנועד רק לי היה

787
00:32:06,450 --> 00:32:08,800
בספריית הבית של ג'ון הרווארד, מסמכיו שלי,

788
00:32:08,800 --> 00:32:10,390
הקבצים האישיים שלו.

789
00:32:10,390 --> 00:32:14,000
אבל עכשיו בסוגריים זה אומר ~ / source1m.

790
00:32:14,000 --> 00:32:17,090
זה רק אומר שאני בתיקייה בשם source1m

791
00:32:17,090 --> 00:32:19,160
זה בספריית הבית של ג'ון הרווארד.

792
00:32:19,160 --> 00:32:22,030
אז אם עכשיו אני רוצה להציג את הקבצים בתיקייה זו, קל

793
00:32:22,030 --> 00:32:25,300
שאלה, אני פשוט מקליד ls.

794
00:32:25,300 --> 00:32:28,860
ועכשיו אני רואה את כל קבצים שנוצרתי מראש להיום

795
00:32:28,860 --> 00:32:31,020
הרצאה, שכל, או רובם, תקרה

796
00:32:31,020 --> 00:32:32,740
לסיים ב. ג.

797
00:32:32,740 --> 00:32:36,210
>> אז תן לי ללכת קדימה עכשיו ולהפעיל gedit של תכנית בשם

798
00:32:36,210 --> 00:32:39,140
holloway.c, אשר נכתב על ידי כמה האקר אקראי

799
00:32:39,140 --> 00:32:42,920
באינטרנט, שנראה קצת כמו זה.

800
00:32:42,920 --> 00:32:44,880
ואנחנו לא מתכוונים לעבור על זה בכל

801
00:32:44,880 --> 00:32:48,530
פרטים, אבל עבור אלה נוחים יותר, בפרט, אם

802
00:32:48,530 --> 00:32:50,935
אתה רוצה לקחת ניחוש מה התכנית הזו עושה כאן.

803
00:32:57,950 --> 00:32:59,990
היה סמוך ובטוח, בין אם אתה פחות או יותר בנוח,

804
00:32:59,990 --> 00:33:01,655
אנחנו אפילו לא להגיע לדברים מהסוג הזה עד סוף

805
00:33:01,655 --> 00:33:02,160
בסמסטר הזה.

806
00:33:02,160 --> 00:33:05,390
זה מה שדוגמה של תחרות עורפלה C, ה

807
00:33:05,390 --> 00:33:08,390
אמצעי לכתוב תכנית מחפשת המסתורית ביותר שאולי

808
00:33:08,390 --> 00:33:10,820
יכול לעלות על אנשים חכמים אחרים, שהם באופן דומה

809
00:33:10,820 --> 00:33:13,010
מנסה לכתוב את הדברים ולהראות לעולם שהם יכולים לכתוב

810
00:33:13,010 --> 00:33:14,280
דברים נסתרים יותר ממך.

811
00:33:14,280 --> 00:33:17,290
אז זה לא דוגמה לתכנית כתובה היטב מ

812
00:33:17,290 --> 00:33:21,260
פרספקטיבה של סגנון, זה היא דוגמה לתכנית ש

813
00:33:21,260 --> 00:33:22,860
זוכה בתחרות, לאנשים שמנסים

814
00:33:22,860 --> 00:33:24,090
להיות מעורפל ומופשט.

815
00:33:24,090 --> 00:33:27,670
>> אז אם אנחנו מנהלים את הדבר הזה, תן לי ללכת לחלון המסוף שלי,

816
00:33:27,670 --> 00:33:28,110
אם אפשר לומר כך.

817
00:33:28,110 --> 00:33:29,650
אז סביבת שחור ולבן זה נקרא

818
00:33:29,650 --> 00:33:31,160
חלון מסוף באופן כללי.

819
00:33:31,160 --> 00:33:32,600
תן לי ללכת קדימה ולעבד אותו.

820
00:33:32,600 --> 00:33:34,440
אני לא מתכוון להשתמש בצלצול, כי תכנית זו היא

821
00:33:34,440 --> 00:33:36,340
לא ברור מספיק ושהוא צריך שונה

822
00:33:36,340 --> 00:33:38,190
מהדר, אחת בשם GCC.

823
00:33:38,190 --> 00:33:39,200
אבל זה עושה את אותו דבר.

824
00:33:39,200 --> 00:33:41,130
זה לוקח קוד מקור לקוד יעד.

825
00:33:41,130 --> 00:33:43,940
ועכשיו אם אני מפעיל a.out, תכנית שבה

826
00:33:43,940 --> 00:33:46,065
פשוט ראיתי שעושה זאת.

827
00:33:49,220 --> 00:33:51,170
כך שהבחור שזכתה בתחרות בשנה ש.

828
00:33:51,170 --> 00:33:54,020
בכל אופן, אנחנו לא הולכים בכיוון זה, כשלעצמו.

829
00:33:54,020 --> 00:33:57,400
>> אז בואו ננסה דווקא עכשיו להקניט בנפרד מה אנחנו יכולים לעשות

830
00:33:57,400 --> 00:33:59,540
עם אובניים הבניין הבסיסי אלה כדי להפוך יותר ויותר

831
00:33:59,540 --> 00:34:00,590
תוכניות מעניינות.

832
00:34:00,590 --> 00:34:02,800
אז כתבתי תכנית, נגמר לנו תכנית.

833
00:34:02,800 --> 00:34:05,780
עכשיו אנחנו באמת יכולים לפשט וכבר לא צריכים לכתוב

834
00:34:05,780 --> 00:34:07,210
מילת הצלצול בשורת הפקודה.

835
00:34:07,210 --> 00:34:10,710
מתברר שהתוכניות שלנו מקבלות יותר מסתוריות, שאנחנו יכולים, או

836
00:34:10,710 --> 00:34:14,699
יותר מורכב למדי, אנו יכולים למעשה מפעילים את הפקודה הזו.

837
00:34:14,699 --> 00:34:17,610
אז תן לי לחזור לספריית הבית שלי, אם אפשר לומר כך, הרשה לי

838
00:34:17,610 --> 00:34:20,750
להסיר - RM הוא פקודת ההסרה - אני הולך להסיר

839
00:34:20,750 --> 00:34:23,060
את הקובץ שנקרא a.out ושלום.

840
00:34:23,060 --> 00:34:25,489
ועכשיו שם לב בסביבת שורת פקודה, כמו ב

841
00:34:25,489 --> 00:34:27,800
GUI, אתה מקבל תתבקש לעשות זאת. אני לא יכול ללחוץ על כפתור ש;

842
00:34:27,800 --> 00:34:31,040
צריך להקליד y עבור כן, y עבור כן.

843
00:34:31,040 --> 00:34:33,460
ועכשיו אם אני מקליד ls שוב, שים לב שאלו ירוקים

844
00:34:33,460 --> 00:34:35,469
תוכניות - a.out ושלום -

845
00:34:35,469 --> 00:34:35,734
הם נעלמו.

846
00:34:35,734 --> 00:34:37,340
היזהר rm.

847
00:34:37,340 --> 00:34:39,739
הוא יכול לעשות דברים רעים, בדיוק כמו שתוכל על ידי גרירה

848
00:34:39,739 --> 00:34:40,810
דברים לזבל שלך.

849
00:34:40,810 --> 00:34:43,989
>> אז עכשיו בוא נלך קדימה - ואני יכול לעשות את זה - צלצול-O

850
00:34:43,989 --> 00:34:45,139
הלו, הל -

851
00:34:45,139 --> 00:34:46,884
אני כבר משועמם הקלדת פקודה ש.

852
00:34:46,884 --> 00:34:48,080
למרות שהקלדתי אותו קצת מהירות.

853
00:34:48,080 --> 00:34:51,870
אז אנחנו יכולים לעשות במקום לעשות שלום.

854
00:34:51,870 --> 00:34:53,880
אז להפוך אינו מהדר.

855
00:34:53,880 --> 00:34:57,720
זה רק תכנית ידידותית שמגיעה עם לינוקס, בזה

856
00:34:57,720 --> 00:34:59,070
מקרה - מערכת ההפעלה -

857
00:34:59,070 --> 00:35:02,480
שממכן את תהליך קומפילצית תוכניות.

858
00:35:02,480 --> 00:35:05,555
אז במקום לזכור את שם קובץ ומצלצל-O

859
00:35:05,555 --> 00:35:08,190
אז כן הלאה, במיוחד ברגע שהקווים האלה מקבלים יותר ו

860
00:35:08,190 --> 00:35:10,110
יותר, אני יכול רק לכתוב לעשות.

861
00:35:10,110 --> 00:35:12,030
וזה הולך לו לפלוט את כל חבורה של דברים ש

862
00:35:12,030 --> 00:35:13,940
סופו של דבר יראה בסמסטר הזה.

863
00:35:13,940 --> 00:35:17,500
אבל שם לב עכשיו אם אני ls הסוג, שלום הוא חזרה בספרייה שלי.

864
00:35:17,500 --> 00:35:19,850
ואכן אני יכול להפעיל אותו עם. / שלום.

865
00:35:19,850 --> 00:35:23,330
אז לעשות רק לאוטומטי את התהליך של ריצה מה שהיה,

866
00:35:23,330 --> 00:35:26,910
במקרה זה,, פקודה מורכבת יותר עוד הרבה זמן.

867
00:35:26,910 --> 00:35:29,060
אז אנחנו הולכים להתחיל להשתמש באיפור, רק בגלל שזה הרבה

868
00:35:29,060 --> 00:35:30,530
יותר ידידותי למשתמש.

869
00:35:30,530 --> 00:35:32,770
>> אבל עכשיו בואו נעשה את תכנית מעניינת יותר

870
00:35:32,770 --> 00:35:34,650
מסתם להגיד שלום.

871
00:35:34,650 --> 00:35:38,680
לכן, בתוכניות שכתבנו עד כה יש ראשי.

872
00:35:38,680 --> 00:35:40,890
זה בדיוק הדבר שברירת מחדל בעיטות מחוץ הכל.

873
00:35:40,890 --> 00:35:43,340
אבל יש תפקידים אחרים שם בחוץ, כמו גם, ו

874
00:35:43,340 --> 00:35:45,890
stdio.h הוא הדבר שאותו ראה בראש שלנו

875
00:35:45,890 --> 00:35:48,480
קובץ לפני, וזה מה שנקרא ספרייה הסטנדרטית.

876
00:35:48,480 --> 00:35:51,300
בתוך הספרייה הסטנדרטית היא חבורה שלמה של פונקציות

877
00:35:51,300 --> 00:35:53,850
שמישהו אחר כתב, ואנחנו יכולים להתחיל באמצעות אלה

878
00:35:53,850 --> 00:35:55,050
פונקציות לכתוב יותר

879
00:35:55,050 --> 00:35:56,760
תוכניות מעניינות את עצמנו.

880
00:35:56,760 --> 00:35:58,370
>> אז תן לי לחזור למכשיר.

881
00:35:58,370 --> 00:35:59,820
אני הולך לסגור את חלון מסוף זה.

882
00:35:59,820 --> 00:36:02,630
אני הולך לסגור את הדברים שכתבנו קודם לכן, ופשוט ללכת

883
00:36:02,630 --> 00:36:07,350
לhello.c, ושם לב עכשיו שאני יכול לעשות את הדברים הבאים.

884
00:36:07,350 --> 00:36:09,730
שלום העולם הוא לא כל כך מעניין, שהייתי רוצה

885
00:36:09,730 --> 00:36:11,770
אישית התכנית הזאת לעצמי.

886
00:36:11,770 --> 00:36:13,440
אז במקום לומר עולם, אני הולך

887
00:36:13,440 --> 00:36:14,830
קדימה ואומרים -

888
00:36:14,830 --> 00:36:16,880
אני יכול להקליד דוד - אבל זה באמת סוג של

889
00:36:16,880 --> 00:36:18,050
ביסוד.

890
00:36:18,050 --> 00:36:19,970
אבל בואו ננסה את רעיון מציין מיקום זה.

891
00:36:19,970 --> 00:36:24,460
יזכיר כי ב-C, ולא בprintf, היו לנו אלה

892
00:36:24,460 --> 00:36:28,110
מצייני מיקום, ויש יותר מסתם ד%.

893
00:36:28,110 --> 00:36:31,150
אז% ד היה, לבדוק את השפיות מהירה.

894
00:36:31,150 --> 00:36:32,310
אוקיי, מספר עשרוני, זהו זה.

895
00:36:32,310 --> 00:36:33,860
ספרות אחרי נקודה עשרונית, זה הכול.

896
00:36:33,860 --> 00:36:37,755
אז ג%, כפי שאנו נתקלים, הולך להיות אופי.

897
00:36:37,755 --> 00:36:40,530
שים את דמות כאן, מכתב דרך z,

898
00:36:40,530 --> 00:36:41,600
או סימן פיסוק.

899
00:36:41,600 --> 00:36:45,590
מישהו תו בודד,% f, יודע משפות אחרות?

900
00:36:45,590 --> 00:36:47,020
אז ערך נקודה צפה.

901
00:36:47,020 --> 00:36:47,880
מספר אמיתי.

902
00:36:47,880 --> 00:36:51,550
אז לא מספר עשרוני - זה הוא למעשה מספר אמיתי עם

903
00:36:51,550 --> 00:36:54,130
נקודה עשרונית, וחלק מספר הספרות לשמאל

904
00:36:54,130 --> 00:36:55,520
וזכותו שלו.

905
00:36:55,520 --> 00:36:58,060
% s, מייתר.

906
00:36:58,060 --> 00:36:59,530
שבו אנחנו הולכים לראות לעתים קרובות למדי.

907
00:36:59,530 --> 00:37:02,140
מחרוזת, שוב, היא רק מילה, ביטוי, רצף של

908
00:37:02,140 --> 00:37:03,330
תווים בודדים.

909
00:37:03,330 --> 00:37:06,730
ולבסוף, LLD?

910
00:37:06,730 --> 00:37:08,210
אז זה יותר ממקרה פינה.

911
00:37:08,210 --> 00:37:09,850
ארוך, ארוך עשרוני.

912
00:37:09,850 --> 00:37:12,035
אז אם אתה רוצה לא רק מספר שהוא גדול, שזה

913
00:37:12,035 --> 00:37:14,160
רוצה מספר גדול יותר, אתה הולך צריך לציין ל

914
00:37:14,160 --> 00:37:16,400
המחשב שהוא בגודל מסוים.

915
00:37:16,400 --> 00:37:17,610
>> אז בואו לצבוט זה קצת.

916
00:37:17,610 --> 00:37:20,610
במקום קוד קשה רק בדוד, תן לי קצת

917
00:37:20,610 --> 00:37:22,460
דינמי אומרים% s.

918
00:37:22,460 --> 00:37:25,790
אז שם% s כאן, שהוא מציין מיקום עבור מחרוזת.

919
00:37:25,790 --> 00:37:30,500
אז תן לי לעשות פסיק, ולאחר מכן "דוד" כאן.

920
00:37:30,500 --> 00:37:32,770
עכשיו זה לא כל כך מעניין מבחינה אינטלקטואלית,

921
00:37:32,770 --> 00:37:35,060
בגלל כל מה שעשיתי עכשיו הוא באמת ליצור יותר עבודה בשביל

922
00:37:35,060 --> 00:37:35,790
המחשב.

923
00:37:35,790 --> 00:37:39,660
במקום להגיד למחשב לעשות את זה בבת אחת, אני עכשיו

924
00:37:39,660 --> 00:37:43,760
אמר לעשות את זה ולהכניס מחרוזת כאן סופו של דבר, פסיק,

925
00:37:43,760 --> 00:37:44,950
כאן היא מחרוזת ש.

926
00:37:44,950 --> 00:37:47,220
אז זה לא שיפור טוב יותר, אבל זה לפחות

927
00:37:47,220 --> 00:37:49,010
צעד לקראת תכנית מעניינת יותר.

928
00:37:49,010 --> 00:37:51,240
כי עכשיו, תן לי ללכת קדימה ולעשות חלון זה קטן

929
00:37:51,240 --> 00:37:56,850
גדול יותר, תן לי להמשיך ולרוץ לעשות שלום.

930
00:37:56,850 --> 00:38:01,340
ועכשיו,. / A.out לא עובד, למה?

931
00:38:03,880 --> 00:38:05,570
בסדר, עכשיו זה נקרא שלום.

932
00:38:05,570 --> 00:38:09,400
אז שוב לעשות, וגם עם צלצול-O, שם

933
00:38:09,400 --> 00:38:11,120
תכנית להיות משהו יותר מעניין.

934
00:38:11,120 --> 00:38:13,060
וזהו: עכשיו זה אומר שלום דוד.

935
00:38:13,060 --> 00:38:14,590
>> בסדר, עדיין תכנית מטופשת.

936
00:38:14,590 --> 00:38:18,070
אז עכשיו בואו באמת נחזור לכאן ולהציג את הרעיון

937
00:38:18,070 --> 00:38:18,810
של משתנה.

938
00:38:18,810 --> 00:38:21,600
האם לא יהיה זה נחמד אם אני יכול להצהיר על משתנה

939
00:38:21,600 --> 00:38:23,150
הסוג שלו היא מחרוזת?

940
00:38:23,150 --> 00:38:26,720
והערך של המשתנה מגיע דווקא מהמשתמש

941
00:38:26,720 --> 00:38:27,810
או את עוצמה.

942
00:38:27,810 --> 00:38:30,240
אז באופן שרירותי, אני הולך לקרוא למשתנה שלי, שהיא

943
00:38:30,240 --> 00:38:32,410
פשוט כנס משותף כאשר יש לך משתנה אחד בשם

944
00:38:32,410 --> 00:38:33,250
המחרוזת.

945
00:38:33,250 --> 00:38:35,670
אני הולך לעשות את סימן שוויון, ואז אני הולך לקרוא

946
00:38:35,670 --> 00:38:38,030
פונקציה שנקראת GetString.

947
00:38:38,030 --> 00:38:40,830
אז GetString זה לא משהו שמגיע מובנה בתוך ג זה

948
00:38:40,830 --> 00:38:43,330
פונקציה שצוות CS50 כתב, באמת רק בשביל

949
00:38:43,330 --> 00:38:45,670
אלה הזוג הראשון של שבועות, כדי לפשט את התהליך של

950
00:38:45,670 --> 00:38:49,450
מקבל קלט ממשתמש וצובר קלט משתמש בצורה

951
00:38:49,450 --> 00:38:51,960
של מחרוזות או מספרים, וכאלה.

952
00:38:51,960 --> 00:38:55,520
אז GetString הוא כמו printf, אבל ברור שלא

953
00:38:55,520 --> 00:38:58,700
להדפיס זה הולך לעשות את מה שהשם שלה אומר, מקבל מחרוזת.

954
00:38:58,700 --> 00:39:00,970
אבל להשתמש GetString, אנחנו הולכים צריכים לעשות שינוי

955
00:39:00,970 --> 00:39:03,180
כאן, מעבר לזה.

956
00:39:03,180 --> 00:39:07,170
אז באופן אינטואיטיבי, תכנית זו, בתקווה, הוא הולכת איכשהו

957
00:39:07,170 --> 00:39:09,700
מקבל מחרוזת מהמשתמש, ואז מה זה הולך לעשות

958
00:39:09,700 --> 00:39:11,460
עם מחרוזת, בשם של?

959
00:39:15,060 --> 00:39:16,470
זה רק הולך להדפיס אותו, נכון?

960
00:39:16,470 --> 00:39:18,870
עדיין לא תכנית מגרה כי כל מה שקורה

961
00:39:18,870 --> 00:39:22,160
לעשות הוא תקע שבערך לתוך בי% s

962
00:39:22,160 --> 00:39:23,750
אומר שהוא צריך ללכת.

963
00:39:23,750 --> 00:39:25,290
>> אז בוא לפחות לראות את זה בפעולה.

964
00:39:25,290 --> 00:39:27,040
בואו להציל אותי ולהקטין את התצוגה.

965
00:39:27,040 --> 00:39:30,280
עכשיו בחלון המסוף, פה למטה, פרוסה הקטנה של אחד,

966
00:39:30,280 --> 00:39:32,760
תן לי שוב לעשות לעשות שלום.

967
00:39:32,760 --> 00:39:35,160
אוקיי, ואה, לעזאזל, יש לי חבורה שלמה של טעויות.

968
00:39:35,160 --> 00:39:38,020
בואו לגלול אותי, ואנחנו רואים אותנו ראשון -

969
00:39:38,020 --> 00:39:40,430
אז בוא באמת לעשות את זה בחלון גדול עוד יותר, כך שאתה

970
00:39:40,430 --> 00:39:42,110
יכול לראות איך פשלתי -

971
00:39:42,110 --> 00:39:44,460
עד לשלום.

972
00:39:44,460 --> 00:39:46,540
אוקיי, זה אסון, נכון?

973
00:39:46,540 --> 00:39:48,740
כתבתי שלוש שורות של קוד, ו

974
00:39:48,740 --> 00:39:50,070
זה נתן לי 12 שגיאות.

975
00:39:50,070 --> 00:39:51,980
אז למה זה?

976
00:39:51,980 --> 00:39:55,720
אז למרבה המזל, לעתים קרובות כשאתה רואה הרבה, הרבה שגיאות

977
00:39:55,720 --> 00:39:57,730
יורק החוצה בבת אחת, זה באמת רק בגלל שיש לך

978
00:39:57,730 --> 00:39:59,760
מבולבל המחשב עד כאן.

979
00:39:59,760 --> 00:40:02,330
והוא נשאר מבולבל עד שזה יגיע לכאן.

980
00:40:02,330 --> 00:40:04,400
וכך זה רק מתחיל למעוד, וכושל, ו

981
00:40:04,400 --> 00:40:07,310
לירוק מפחיד יותר מדווקא חל.

982
00:40:07,310 --> 00:40:10,120
אז באופן כללי, תמיד להתחיל עם העליון.

983
00:40:10,120 --> 00:40:13,320
>> אז רוב למשל מאוד העליון של אדום,

984
00:40:13,320 --> 00:40:14,740
הודעת שגיאה היא זו.

985
00:40:14,740 --> 00:40:17,750
שימוש במחרוזת זיהוי לא מוצהרת, לא אני

986
00:40:17,750 --> 00:40:19,160
מתכוון סטנדרטי ב?

987
00:40:19,160 --> 00:40:19,900
אני לא עשיתי זאת.

988
00:40:19,900 --> 00:40:24,180
התכוונתי מחרוזת, אבל זה בגלל שגם מילת המחרוזת

989
00:40:24,180 --> 00:40:26,020
שאני שומר את השימוש מילולי למעשה

990
00:40:26,020 --> 00:40:27,240
לא קיים ב-C גם.

991
00:40:27,240 --> 00:40:29,470
זה משהו שאנו נשתמש רק בשבוע הראשון או שתיים

992
00:40:29,470 --> 00:40:34,500
כאן, אבל זה קיים בקובץ בשם cs50.h.

993
00:40:34,500 --> 00:40:37,110
אז לעת עתה, יודע שיש ספרייה אחרת זה כי

994
00:40:37,110 --> 00:40:39,330
צוות כתב, כך שזה נכתב בתקופה מאוחרת יותר מאשר

995
00:40:39,330 --> 00:40:40,510
stdio.h.

996
00:40:40,510 --> 00:40:45,020
אבל בתוך cs50.h הוא הגדרה, מילה נרדפת של

997
00:40:45,020 --> 00:40:48,310
מינים, שיוצרים מילה במחרוזת זו.

998
00:40:48,310 --> 00:40:50,890
>> אז עכשיו תן לי לחזור לחלון המסוף שלי.

999
00:40:50,890 --> 00:40:53,200
אני הולך לנקות את כל הבלגן הזה על ידי Ctrl-L. עכשיו פשוט

1000
00:40:53,200 --> 00:40:55,700
למחוק הכל נקי, ואני מתכוון להמשיך ולעשות

1001
00:40:55,700 --> 00:40:57,860
הלו שוב, לחץ על Enter.

1002
00:40:57,860 --> 00:40:59,440
אז מה קרה עכשיו?

1003
00:40:59,440 --> 00:41:01,150
עכשיו כל השגיאות האלה הלכו משם.

1004
00:41:01,150 --> 00:41:02,230
אז מה באמת עשיתי?

1005
00:41:02,230 --> 00:41:05,920
פשוט אני כבר למדתי את המחשב שמחרוזת קיימת, וזה

1006
00:41:05,920 --> 00:41:07,890
שבקובץ שנקרא cs50.h.

1007
00:41:07,890 --> 00:41:10,930
אז להפסיק להתלונן, כי עכשיו אתה יודע איפה למצוא את

1008
00:41:10,930 --> 00:41:13,220
ההצהרה כי הפונקציה של כביכול.

1009
00:41:13,220 --> 00:41:15,200
איפה זה קיים בעולם.

1010
00:41:15,200 --> 00:41:18,820
>> אז עכשיו אני הולך קדימה ולרוץ שלום.

1011
00:41:18,820 --> 00:41:22,300
נראה לי ללולאה אינסופית, שום דבר לא קורה.

1012
00:41:25,530 --> 00:41:26,870
אז אני צריך להקליד משהו כאן, נכון.

1013
00:41:26,870 --> 00:41:29,650
שורת הקוד הראשונה בתכנית שלי הייתה GetString.

1014
00:41:29,650 --> 00:41:31,750
אז זה ממש מחכה לי כדי לקבל מחרוזת.

1015
00:41:31,750 --> 00:41:33,680
אז במובן הזה, כן, זה הוא לולאה אינסופית.

1016
00:41:33,680 --> 00:41:36,520
כנראה בGetString היא התנהגות ברירת מחדל שאנו

1017
00:41:36,520 --> 00:41:37,510
כתב - צוות -

1018
00:41:37,510 --> 00:41:39,550
שפשוט אומר לחכות ולחכות ולחכות ולחכות ולחכות,

1019
00:41:39,550 --> 00:41:42,550
עד שהמשתמש נותן לך על ידי הקלדת מחרוזת משהו פנימה

1020
00:41:42,550 --> 00:41:46,000
אז תן לי ללכת קדימה וסוג ב D-v-- i-D, Enter.

1021
00:41:46,000 --> 00:41:47,420
וזה מה שיש, שלום דוד.

1022
00:41:47,420 --> 00:41:50,430
>> עכשיו האם זה נראה כאילו זה רק מעשה?

1023
00:41:50,430 --> 00:41:52,810
תן לי ללכת קדימה והקלד בטומי.

1024
00:41:52,810 --> 00:41:54,740
הזן, בסדר, נראה שזה עובד.

1025
00:41:54,740 --> 00:41:59,130
עבודות עבור רוב, עבודות לZamyla, עובדות - בסדר.

1026
00:41:59,130 --> 00:42:01,000
אז זה הולך לעבודה, סביר להניח.

1027
00:42:01,000 --> 00:42:05,030
אז זה צריך להדפיס את כל מה שאנחנו בעצם נותנים לו,

1028
00:42:05,030 --> 00:42:07,830
ואנחנו יכולים להיות קצת קשים כאן.

1029
00:42:07,830 --> 00:42:12,130
בואו נראה אם ​​אנחנו עושים משהו כמו שלום.

1030
00:42:12,130 --> 00:42:18,000
יכול ללכת לכאן, בואו נראים, להעתיק, להדביק.

1031
00:42:18,000 --> 00:42:19,950
אני לא הולך להיות מסוגל להדביק את זה כאן פעמים רבות.

1032
00:42:19,950 --> 00:42:24,410
דבק, בסדר, Shift + Ctrl + V. אז מה יכול

1033
00:42:24,410 --> 00:42:26,970
קורה שרע כאן?

1034
00:42:26,970 --> 00:42:27,770
>> אוקיי, אז, segfaults.

1035
00:42:27,770 --> 00:42:29,710
אז כמה מכם עם רקע קודם ישמח לדעת כי

1036
00:42:29,710 --> 00:42:32,710
בדרך כלל, נותן מחשבים המון כניסות כשהם

1037
00:42:32,710 --> 00:42:36,140
כנראה לא נועד לקבל שמות ארוכים כמו זה - רעים

1038
00:42:36,140 --> 00:42:36,740
לדברים לקרות.

1039
00:42:36,740 --> 00:42:39,230
אכן, בעולם של האינטרנט, גם זה קורה לא מעט,

1040
00:42:39,230 --> 00:42:41,000
לפיו כאשר אתה מעצב אתר, כשאתה

1041
00:42:41,000 --> 00:42:43,850
העיצוב פייסבוק, יש לך לקבל החלטות שרירותיות עד

1042
00:42:43,850 --> 00:42:45,370
קדמי, כמו כמה זמן יהיה של מישהו

1043
00:42:45,370 --> 00:42:46,360
פייסבוק שם המשתמש יהיה?

1044
00:42:46,360 --> 00:42:48,050
או כמה זמן יהיה שמו הפרטי של מישהו להיות?

1045
00:42:48,050 --> 00:42:50,110
כמה זמן את מספר הטלפון של מישהו יהיה וכדומה.

1046
00:42:50,110 --> 00:42:53,580
ואם מתכנתים עושים הנחות רעות, תוכניות לשבור

1047
00:42:53,580 --> 00:42:56,640
מפני שאתה מנסה לתת להם יותר תפוקה, יותר קלט

1048
00:42:56,640 --> 00:42:58,330
לייתר דיוק, ממה שהם צריכים זיכרון.

1049
00:42:58,330 --> 00:43:01,860
או הזיכרון RAM שהוקצה עבורו, ולכן אם עכשיו אני על Enter,

1050
00:43:01,860 --> 00:43:04,640
תכנית שעבדה בפועל, מכיוון שהיינו בספרייה

1051
00:43:04,640 --> 00:43:06,790
ואנחנו בכלל צפינו מקרה הספציפי הזה.

1052
00:43:06,790 --> 00:43:10,900
אבל אין ספק שהסמסטר הזה, תוכל לכתוב אחד לפחות

1053
00:43:10,900 --> 00:43:13,280
תכנית שאומרת את המילים הללו.

1054
00:43:13,280 --> 00:43:16,520
זכור את זה שבועות מהיום, אולי ימים מעכשיו.

1055
00:43:16,520 --> 00:43:18,760
אשמת פילוח היא דבר רע.

1056
00:43:18,760 --> 00:43:21,920
זה יתייחס ליעשה משהו שהמחשב

1057
00:43:21,920 --> 00:43:23,310
לא ציפה.

1058
00:43:23,310 --> 00:43:25,810
ובמקרה כזה, אתה, המתכנת, לא ציפתה.

1059
00:43:25,810 --> 00:43:27,720
הרבה כמו מה זה ערימה של גרביים, הייתה שונה

1060
00:43:27,720 --> 00:43:29,520
מקרים פינתיים היינו יכולים נתקלו.

1061
00:43:29,520 --> 00:43:32,340
כמו כן בתוכניות אם אתה לא צופה כמה זמן הוא

1062
00:43:32,340 --> 00:43:33,310
השם של מישהו הולך להיות.

1063
00:43:33,310 --> 00:43:35,890
או מה אם יש לי משתמש זדוני, ואת השם שלו או שלה הוא

1064
00:43:35,890 --> 00:43:37,230
למעשה די קצר, אבל הם רק מנסים

1065
00:43:37,230 --> 00:43:37,960
להתעסק איתי?

1066
00:43:37,960 --> 00:43:40,490
מה הולך להיות ההתנהגות של התכנית שלי?

1067
00:43:40,490 --> 00:43:43,930
ובכן, במקרה זה, משהו באמת עשוי לקרוס.

1068
00:43:43,930 --> 00:43:44,750
>> אז בואו לעשות את זה.

1069
00:43:44,750 --> 00:43:46,860
ב 90 דקות, זה המון זמן

1070
00:43:46,860 --> 00:43:47,780
לעשות מדעי מחשב.

1071
00:43:47,780 --> 00:43:49,550
למה שלא להיכנס להרגל של לקחת חמש דקות

1072
00:43:49,550 --> 00:43:51,520
לשבור כאן, וכשנחזור, אנחנו לצלול לתוך חלק

1073
00:43:51,520 --> 00:43:53,430
תוכניות מורכבות ומשכנעות יותר?

1074
00:43:53,430 --> 00:43:54,680
חמש דקות.

1075
00:43:56,910 --> 00:43:58,160
>> בסדר.

1076
00:44:01,138 --> 00:44:02,780
אז תגובה אחת מהירה.

1077
00:44:02,780 --> 00:44:05,590
נאמרתי לי שלמרות שזה היה על המסך לפני, מה

1078
00:44:05,590 --> 00:44:08,880
יצא לי מהפה היה cs50.net/rsvp.

1079
00:44:08,880 --> 00:44:11,670
זה נכון. cs50.net/lunch.

1080
00:44:11,670 --> 00:44:16,030
אז עכשיו אתה יכול לנסות RSVPing לזה ב/ ארוחת צהריים.

1081
00:44:16,030 --> 00:44:16,980
אבל בואו נעשה את זה עכשיו.

1082
00:44:16,980 --> 00:44:20,150
אז זה היה סופר מהיר, סופר חדש להרבה אנשים.

1083
00:44:20,150 --> 00:44:21,560
כובע ישן לאנשים מסוימים.

1084
00:44:21,560 --> 00:44:24,930
אז בואו אחורה לרגע, ולראות איך הגעתי ל

1085
00:44:24,930 --> 00:44:29,350
פלט זה שלום עולם רק לפני רגע.

1086
00:44:29,350 --> 00:44:31,780
>> אז קודם כל, יש מכשיר CS50 זה.

1087
00:44:31,780 --> 00:44:34,270
שוב, חלק מהתוכנה, בעיה להגדיר 1 עומד לספר

1088
00:44:34,270 --> 00:44:36,610
לך איך להוריד אותו, שבו כדי להוריד אותו, מה ללחוץ

1089
00:44:36,610 --> 00:44:37,430
וכן הלאה.

1090
00:44:37,430 --> 00:44:39,670
ואז ברגע שאתה פעלת בהתאם להוראות אלה, תוכל

1091
00:44:39,670 --> 00:44:42,840
כדי למקסם את החלון שלך, ו-Mac או במחשב האישי שלך ייראה

1092
00:44:42,840 --> 00:44:43,910
משהו קטן כזה.

1093
00:44:43,910 --> 00:44:47,170
רקע שחור, בתיקייה ראשית בחלק העליון שבו כל

1094
00:44:47,170 --> 00:44:49,850
הקבצים שלך ללכת, פח אשפה בפינה השמאלית העליונה,

1095
00:44:49,850 --> 00:44:51,130
תפריט בתחתית.

1096
00:44:51,130 --> 00:44:54,010
אז שוב, די דומה ברוח ל-Mac OS או Windows,

1097
00:44:54,010 --> 00:44:56,040
למרות שזה קורה להיות לינוקס.

1098
00:44:56,040 --> 00:44:58,120
אז מה אנחנו עושים הבאים?

1099
00:44:58,120 --> 00:44:59,580
ובכן, התחלנו לכתוב תוכניות.

1100
00:44:59,580 --> 00:45:02,260
וזוכרים משבוע שעבר שכל מה שנדרש לכתוב

1101
00:45:02,260 --> 00:45:04,970
תכנית היא עורך טקסט פשוט,

1102
00:45:04,970 --> 00:45:06,550
כמו פנקס רשימות או TextEdit.

1103
00:45:06,550 --> 00:45:08,360
למען אמת, אתה יכול גם להשתמש ב-Word של מיקרוסופט.

1104
00:45:08,360 --> 00:45:11,170
אבל סופו של דבר דברים רעים יקרו, כי זה מאוד

1105
00:45:11,170 --> 00:45:13,930
פתרון מגושם לכתיבת תכנית, בתוספת המדבר

1106
00:45:13,930 --> 00:45:15,400
לשמור אותו בפורמט השגוי.

1107
00:45:15,400 --> 00:45:18,150
אבל זה רק בעורך טקסט, במעבד תמלילים, הוא כל מה ש

1108
00:45:18,150 --> 00:45:19,390
צורך לכתוב את תכנית.

1109
00:45:19,390 --> 00:45:23,420
>> אז בCS50 המכשיר, אנחנו יכולים לעשות את זה בדרך פשוטה אחת.

1110
00:45:23,420 --> 00:45:25,580
אנחנו יכולים פשוט ללחוץ על סמל זה בצד שמאל למטה.

1111
00:45:25,580 --> 00:45:28,790
ושוב, בעיה להגדיר 1 יהיה לייעץ לך על כך, והנה -

1112
00:45:28,790 --> 00:45:31,210
אתה מקבל ממשק השחור ולבן הזה שבו אנחנו יכולים להתחיל

1113
00:45:31,210 --> 00:45:32,160
כתיבת קוד.

1114
00:45:32,160 --> 00:45:34,960
אז בואו נתחיל לכתוב תכנית סופר פשוטה שוב.

1115
00:45:34,960 --> 00:45:38,890
אני מתכוון ללכת לקובץ, שמור, ואני הולך לקרוא

1116
00:45:38,890 --> 00:45:42,870
זה, יניח, hello2.c.

1117
00:45:42,870 --> 00:45:45,410
ואני רק אומר לו על ידי לחיצה על jharvard, לשים אותו

1118
00:45:45,410 --> 00:45:46,750
בספרייה הביתית שלו, אני לא ממש אכפת

1119
00:45:46,750 --> 00:45:47,980
שם זה הולך.

1120
00:45:47,980 --> 00:45:49,090
ואז שמור.

1121
00:45:49,090 --> 00:45:50,880
ועכשיו אני יכול להתחיל לכתוב את התכנית שלי.

1122
00:45:50,880 --> 00:45:53,560
ואני זוכר מקודם שאני צריך לכתוב int

1123
00:45:53,560 --> 00:45:55,400
עיקרי (void).

1124
00:45:55,400 --> 00:45:57,000
קרב על שמאלי עליון.

1125
00:45:57,000 --> 00:46:02,670
ואז אני רוצה לומר printf, קח שניים.

1126
00:46:02,670 --> 00:46:05,690
ועכשיו ציטוט שורה חדש, קרוב, קרוב

1127
00:46:05,690 --> 00:46:07,820
סוגריים, פסיק.

1128
00:46:07,820 --> 00:46:10,560
ואז אני יורד כאן לחלון מסופי זה

1129
00:46:10,560 --> 00:46:12,840
מוטבע בgedit, רק מטעמי נוחות.

1130
00:46:12,840 --> 00:46:15,200
ואני מתכוון להמשיך ולכתוב לעשות שלום, אך לא

1131
00:46:15,200 --> 00:46:17,500
שלום לבד, hello2.

1132
00:46:17,500 --> 00:46:20,490
>> אז הקובץ שלי נקרא hello2.c. הקובץ שלי ולכן

1133
00:46:20,490 --> 00:46:23,510
צריך להיקרא hello2, במקרה זה.

1134
00:46:23,510 --> 00:46:26,490
לעזאזל, מה אני עושה לא בסדר?

1135
00:46:26,490 --> 00:46:29,490
בסדר, אז ברור שהשמיט קו, אם אתה זוכר מה

1136
00:46:29,490 --> 00:46:31,020
תוכניות קודמות להיראות.

1137
00:46:31,020 --> 00:46:32,480
אבל בואו נראה אם ​​אנחנו לא יכולים להקניט זה לגזרים.

1138
00:46:32,480 --> 00:46:35,310
למרבה הצער, רוב האנשים שכותבים את התוכניות שבי

1139
00:46:35,310 --> 00:46:38,820
אנחנו כותבים תוכניות לא לפשט את הדברים כל כך טובה.

1140
00:46:38,820 --> 00:46:41,520
אז יש לנו לסוג של רפרף על מה שלא עושה די

1141
00:46:41,520 --> 00:46:44,050
לחוש כאן ולראות אם אנחנו יכולים להבין מה לא בסדר.

1142
00:46:44,050 --> 00:46:46,700
השורה הראשונה שם אומר בעקיפין הכרזת C

1143
00:46:46,700 --> 00:46:49,310
פונקצית printf עם הסוג int ספרייה.

1144
00:46:49,310 --> 00:46:51,210
בסדר, הבנתי חלק מזה.

1145
00:46:51,210 --> 00:46:54,570
אבל נראה שזה רומז לעובדה שנהגתי printf

1146
00:46:54,570 --> 00:46:55,700
בסדר, איכשהו.

1147
00:46:55,700 --> 00:46:56,930
ומה תחושה הוא שגוי זה?

1148
00:46:56,930 --> 00:46:59,970
אני פשוט לא למדתי את המחשב שהוא בקובץ

1149
00:46:59,970 --> 00:47:01,420
קרא stdio.h.

1150
00:47:01,420 --> 00:47:04,120
עכשיו יש לי רק לשנן עכשיו שprintf הוא

1151
00:47:04,120 --> 00:47:06,540
בstdio.h, ואכן יהיה אחר

1152
00:47:06,540 --> 00:47:08,900
פונקציות באותו קובץ שנתרגל אליהם.

1153
00:47:08,900 --> 00:47:12,490
>> אז עכשיו תן לי ללכת קדימה ופגע Ctrl-L שלרק לנקות

1154
00:47:12,490 --> 00:47:16,050
משם, שידור חוזר להפוך hello2, וזהו.

1155
00:47:16,050 --> 00:47:19,490
ופקודה שוב, מורכבת יותר ממה שאנחנו נסביר ל

1156
00:47:19,490 --> 00:47:20,520
המטרות של היום.

1157
00:47:20,520 --> 00:47:23,570
אבל זה לא להפעיל צלצול, והצלצול לוקח קוד מקור ו

1158
00:47:23,570 --> 00:47:24,870
יורק את 0s ו 1s.

1159
00:47:24,870 --> 00:47:28,610
ואלה 0s ו 1s במקרה זה נקראים מה?

1160
00:47:28,610 --> 00:47:29,470
אוקיי, מתנגד קוד.

1161
00:47:29,470 --> 00:47:32,210
ואת הקובץ שהם בנקראים, כך,

1162
00:47:32,210 --> 00:47:33,820
hello2, במקרה זה.

1163
00:47:33,820 --> 00:47:37,040
מאחר שקובץ הטקסט שלי היה hello2.c, Enter.

1164
00:47:37,040 --> 00:47:39,820
ועכשיו יש לי לקחת את שתי נקודתי קריאה, קריאה

1165
00:47:39,820 --> 00:47:41,880
נקודה, סימן קריא.

1166
00:47:41,880 --> 00:47:45,430
בסדר, אז יש לנו את היכולת לקבל מחרוזות עכשיו,

1167
00:47:45,430 --> 00:47:46,280
כנראה.

1168
00:47:46,280 --> 00:47:48,190
ובכן, מה עוד אנחנו יכולים לקבל ממשתמשים?

1169
00:47:48,190 --> 00:47:51,010
>> ובכן בCS50 הספרייה, יש פונקציות נוספות ה

1170
00:47:51,010 --> 00:47:53,300
הולכים לפשט את חיינו בימים הראשונים האלה.

1171
00:47:53,300 --> 00:47:56,350
Getchar, GetDouble, GetFloat, GetInt,

1172
00:47:56,350 --> 00:47:57,290
GetLongLong, GetString.

1173
00:47:57,290 --> 00:47:59,550
ובכן, בואו לתלוש מעל הקל ביותר של אלה ראשונים.

1174
00:47:59,550 --> 00:48:01,430
GetString ממש עושה את זה.

1175
00:48:01,430 --> 00:48:04,210
זה פשוט יושב שם, מחכה למשתמש להקליד משהו ב,

1176
00:48:04,210 --> 00:48:07,170
וברגע שאני מקליד משהו ובמקיש על Enter, זה

1177
00:48:07,170 --> 00:48:08,860
עושה משהו עם ערך זה.

1178
00:48:08,860 --> 00:48:11,700
אז בואו נחזור לדוגמה שכדי לראות בדיוק מה

1179
00:48:11,700 --> 00:48:12,950
GetString עושה.

1180
00:48:12,950 --> 00:48:17,445
תן לי ללכת קדימה ולפתוח בgedit, hello.c, ולהיזכר

1181
00:48:17,445 --> 00:48:20,590
כי ממש לפני ההפסקה, זה המקום שבו הפסקנו.

1182
00:48:20,590 --> 00:48:23,240
>> אז בואו עכשיו להקניט זה לגזרים בפירוט רב יותר.

1183
00:48:23,240 --> 00:48:27,190
אז ב 6 בשורה, יש שני דברים

1184
00:48:27,190 --> 00:48:28,450
קורה באותו הרגע.

1185
00:48:28,450 --> 00:48:32,630
סימן השוויון הוא הפרדת המחצית ראשונה ומחצית שנייה.

1186
00:48:32,630 --> 00:48:34,670
אז בצד השמאל של סימן השוויון, אנחנו

1187
00:48:34,670 --> 00:48:35,580
אומר מחרוזת s.

1188
00:48:35,580 --> 00:48:37,580
ואז, רק המונחים של ההדיוטות, מה הוא מחרוזת של

1189
00:48:37,580 --> 00:48:41,040
עושה, אתה חושב?

1190
00:48:41,040 --> 00:48:42,990
זה יוצר את מה?

1191
00:48:42,990 --> 00:48:44,930
אז זה יוצר מחרוזת בשם זה.

1192
00:48:44,930 --> 00:48:46,370
אז מה זה באמת אומר?

1193
00:48:46,370 --> 00:48:51,540
טוב, זה להזמין מקום למחרוזת בשם זה.

1194
00:48:51,540 --> 00:48:52,490
זה לא לגמרי נכון.

1195
00:48:52,490 --> 00:48:53,120
מה זה עושה?

1196
00:48:53,120 --> 00:48:55,400
מחשבים ובכן, כפי שאתה יודע, יש כוננים קשיחים; זה מקום שבי

1197
00:48:55,400 --> 00:48:56,300
הקבצים שלך מאוחסנים.

1198
00:48:56,300 --> 00:48:59,100
מחשבים יש זכרון RAM, וזה מקום שבי תוכניות נטענות

1199
00:48:59,100 --> 00:49:00,240
זמן שהן פועלות.

1200
00:49:00,240 --> 00:49:02,470
לכן, כאשר אתה לוחץ פעמים על סמל ו-Microsoft Word פותח

1201
00:49:02,470 --> 00:49:06,380
עד, Microsoft Word פועל, כביכול, בזכרון RAM, שהוא

1202
00:49:06,380 --> 00:49:08,160
חלק האלקטרוני של המחשב.

1203
00:49:08,160 --> 00:49:10,660
לא, חלק הפיזי המכאני שהוא מסתובב, בי

1204
00:49:10,660 --> 00:49:12,640
נתונים מאוחסנים בדרך כלל לטווח ארוך.

1205
00:49:12,640 --> 00:49:15,810
אז מחרוזת של די הרבה אומר לי את המחשב

1206
00:49:15,810 --> 00:49:18,150
מספיק RAM כדי להתאים מחרוזת.

1207
00:49:18,150 --> 00:49:20,450
עכשיו זה קצת פשטני, כי

1208
00:49:20,450 --> 00:49:22,300
כמה גדול המחרוזת הוא הולך להיות?

1209
00:49:22,300 --> 00:49:24,410
ובכן אנחנו באמת לא יודעים עדיין, ולכן בשבועות הקרובים

1210
00:49:24,410 --> 00:49:27,290
אנחנו בעצם נוכל למשוך בחזרה את השכבה שהיא מחרוזת ו

1211
00:49:27,290 --> 00:49:28,510
אנחנו נגיד לך מה שהוא באמת.

1212
00:49:28,510 --> 00:49:31,050
מייתרים, לעת עתה, הוא רק פישוט נחמד של עולמנו.

1213
00:49:31,050 --> 00:49:35,700
אבל מחרוזת s מצהירה מחרוזת בשם של, לעת עתה.

1214
00:49:35,700 --> 00:49:36,520
מצהיר מחרוזת.

1215
00:49:36,520 --> 00:49:39,310
זה שומר קצת מקום בזכרון RAM עבור מחרוזת המשתמש הוא

1216
00:49:39,310 --> 00:49:40,150
על להקליד.

1217
00:49:40,150 --> 00:49:41,840
>> עכשיו בואו נסתכל בצד ימין של סימן השוויון.

1218
00:49:41,840 --> 00:49:44,110
אז זה אומר GetString ().

1219
00:49:44,110 --> 00:49:45,070
ושפיות קצת לבדוק.

1220
00:49:45,070 --> 00:49:47,940
העובדה שאין שום דבר בתוך הסוגריים

1221
00:49:47,940 --> 00:49:50,810
מרמז על מה GetString?

1222
00:49:50,810 --> 00:49:52,180
זה לוקח אין ויכוחים.

1223
00:49:52,180 --> 00:49:55,290
כלומר, אתה לא יכול להשפיע על ההתנהגות שלו בכל דרך.

1224
00:49:55,290 --> 00:49:58,940
בכל פעם שאתה משתמש בו, הוא יקבל מחרוזת וזהו זה.

1225
00:49:58,940 --> 00:50:02,210
לעומת זאת, printf, בתקווה ההתנהגות שלה עושה

1226
00:50:02,210 --> 00:50:03,010
לשנות בכל פעם.

1227
00:50:03,010 --> 00:50:05,230
אחרת, זה תפקיד די חסר תועלת אם הדפסה

1228
00:50:05,230 --> 00:50:06,480
היא עושה את אותו דבר.

1229
00:50:06,480 --> 00:50:07,970
אם זה תמיד מדפיס דוד או משהו

1230
00:50:07,970 --> 00:50:09,500
השרירותי כל הזמן.

1231
00:50:09,500 --> 00:50:11,540
אז printf הגיוני יש ויכוח.

1232
00:50:11,540 --> 00:50:14,240
GetString לא ממש צריך את טיעון, כי רציתי

1233
00:50:14,240 --> 00:50:16,700
כדי לקבל מחרוזת מהמשתמש וזה המשתמש שקורה

1234
00:50:16,700 --> 00:50:19,580
כדי לספק את הדינאמיות בהקלדה באותיות שונות

1235
00:50:19,580 --> 00:50:20,850
כל פעם במקלדת.

1236
00:50:20,850 --> 00:50:23,140
>> אז מה עושה GetString סופו של דבר?

1237
00:50:23,140 --> 00:50:25,080
תחשוב על זה כקופסה השחורה הקטנה הזה.

1238
00:50:25,080 --> 00:50:29,340
קופסה שחורה וזה לוקח לא קלט, אבל כשאתה דופק על

1239
00:50:29,340 --> 00:50:33,240
זה, זה יורק את מחרוזת שהמשתמש הקליד פנימה

1240
00:50:33,240 --> 00:50:36,660
והעובדה שיש סימן שוויון יש משמעות לקחת

1241
00:50:36,660 --> 00:50:39,890
מה לירוק על ימין ולאחסן אותו בתוך

1242
00:50:39,890 --> 00:50:41,390
מה בצד השמאל.

1243
00:50:41,390 --> 00:50:43,470
אז סימן שווה כאן, זה ממש לא אומר

1244
00:50:43,470 --> 00:50:46,490
שוויון, זה לא אומר שמשימה טכנית.

1245
00:50:46,490 --> 00:50:49,330
קח את הערך בצד ימין, ולשים אותו ב

1246
00:50:49,330 --> 00:50:51,050
משתנה בצד השמאל.

1247
00:50:51,050 --> 00:50:52,820
כך שכל מה שקורה שיש.

1248
00:50:52,820 --> 00:50:55,640
>> עכשיו בקו 7, אנחנו קוראים printf.

1249
00:50:55,640 --> 00:50:58,170
אז printf תקווה הוא מקבל קצת משעמם עד עכשיו.

1250
00:50:58,170 --> 00:50:59,530
אז להדפיס מחרוזת מעוצבת.

1251
00:50:59,530 --> 00:51:00,440
מה חוט?

1252
00:51:00,440 --> 00:51:05,460
להדפיס, "h-E-l-l-o,% s

1253
00:51:05,460 --> 00:51:07,840
! \ N ".

1254
00:51:07,840 --> 00:51:10,470
בסדר, אז מה אני רוצה תוסף עבור% s?

1255
00:51:10,470 --> 00:51:12,960
פשוטו כמשמעו, כל מה שמאוחסן בים.

1256
00:51:12,960 --> 00:51:15,570
אז במקרה הזה סימון, קצת שפיות כמה טיעונים, עושים

1257
00:51:15,570 --> 00:51:16,820
printf לקחת?

1258
00:51:19,860 --> 00:51:21,110
אוקיי, שמעתי את אחד.

1259
00:51:23,840 --> 00:51:26,330
שמעתי את אחד שוב.

1260
00:51:26,330 --> 00:51:27,730
שניים שמעו שניים.

1261
00:51:27,730 --> 00:51:29,920
ומה בנוגע לשלוש?

1262
00:51:29,920 --> 00:51:30,450
אוקיי, שלוש?

1263
00:51:30,450 --> 00:51:30,930
מצוין.

1264
00:51:30,930 --> 00:51:33,170
שלוש תשובות אפשריות, רק אחת מהן נכונה.

1265
00:51:33,170 --> 00:51:36,390
אז טיעונים שוב להשפיע על ההתנהגות של פונקציה.

1266
00:51:36,390 --> 00:51:39,380
בעבר, printf לא לקחת את הטיעון אחד בלבד.

1267
00:51:39,380 --> 00:51:42,260
"שלום העולם" היה ויכוח אחד.

1268
00:51:42,260 --> 00:51:45,190
עם זאת, כעת, שים לב איפה פסיק זה.

1269
00:51:45,190 --> 00:51:49,600
פסיק זה מחוץ לציטוט / סוף הציטוט, מה שאומר

1270
00:51:49,600 --> 00:51:52,170
היי printf, הנה מגיע טיעון שני.

1271
00:51:52,170 --> 00:51:54,240
>> אז פסיקים ברוב שפות תכנות

1272
00:51:54,240 --> 00:51:57,300
ויכוחים מרובים נפרדים.

1273
00:51:57,300 --> 00:51:59,600
אז התשובה כאן היא בהחלט לא אחד, כי

1274
00:51:59,600 --> 00:52:00,390
יש פסיק זה.

1275
00:52:00,390 --> 00:52:03,680
אז מינימאלי, printf הוא כנראה לוקח שניים

1276
00:52:03,680 --> 00:52:04,940
טיעונים הפעם.

1277
00:52:04,940 --> 00:52:07,050
אבל את ההזדמנות לשאלה מה טריק כאן היא

1278
00:52:07,050 --> 00:52:07,990
על הפסיק הזה?

1279
00:52:07,990 --> 00:52:11,260
האם זה מרמז על כך שיש בעצם שלוש טענות?

1280
00:52:11,260 --> 00:52:13,820
זה, זה, זה ו.

1281
00:52:13,820 --> 00:52:18,820
אז לא, בגלל הפסיק שנמצא בתוך המרכאות, אשר

1282
00:52:18,820 --> 00:52:20,890
כלומר, זה באמת רק אסתטי של שפה אנגלית.

1283
00:52:20,890 --> 00:52:23,180
אין לזה שום קשר למספר

1284
00:52:23,180 --> 00:52:24,890
טיעונים בתכנית זו.

1285
00:52:24,890 --> 00:52:27,670
אז פסיק זה הוא מחוץ למרכאות הכפולות.

1286
00:52:27,670 --> 00:52:28,850
ואז להחזיר 0.

1287
00:52:28,850 --> 00:52:30,980
רק מיון עבור עכשיו בואו ניקח את זה של באמונה ל

1288
00:52:30,980 --> 00:52:34,460
כיום, ורק יודע שכאשר פונקציות נעשות ביצוע

1289
00:52:34,460 --> 00:52:37,950
שורות של קוד, הם בדרך כלל צריכים להחזיר ערך כלשהו.

1290
00:52:37,950 --> 00:52:42,010
במקרה זה, רק בגלל שעיקרי חייב להחזיר int,

1291
00:52:42,010 --> 00:52:44,320
זה בדיוק כמו השפה C עובד.

1292
00:52:44,320 --> 00:52:47,040
>> לכן, מכיוון ששום דבר לא השתבש, מרגיש כמו התכנית של זה

1293
00:52:47,040 --> 00:52:49,960
בסדר, אני מקודד פשוט קשה בתמורה 0.

1294
00:52:49,960 --> 00:52:52,980
אבל בניגוד לכך, ואני הולך לכתוב את זה בקוד פסאודו

1295
00:52:52,980 --> 00:52:55,020
עכשיו, ממש כמו יוסף עשה כשעשינו את הגרב

1296
00:52:55,020 --> 00:52:56,220
למשל בשבוע שעבר.

1297
00:52:56,220 --> 00:53:00,440
אם משהו ישתבש - זה לא קוד עצמו - הלך

1298
00:53:00,440 --> 00:53:06,570
לא בסדר, ואז לחזור, יניח, 1.

1299
00:53:06,570 --> 00:53:08,770
אחר יחזירו 0.

1300
00:53:08,770 --> 00:53:10,070
אז זה המקום שאנחנו הולכים עם זה.

1301
00:53:10,070 --> 00:53:12,090
זה לא קוד C בפועל, רק pseudocode.

1302
00:53:12,090 --> 00:53:14,010
אבל עד כדי כך שאולי תחזרו

1303
00:53:14,010 --> 00:53:15,580
ערכים אפשריים שונים.

1304
00:53:15,580 --> 00:53:19,520
אבל נכון לעכשיו אני רק הולך קדימה ולהחזיר 0.

1305
00:53:19,520 --> 00:53:24,410
בסדר, כל שאלות עד כה בתחביר, פונקציונלי,

1306
00:53:24,410 --> 00:53:25,000
או אוהבים?

1307
00:53:25,000 --> 00:53:26,280
כן, מאחור.

1308
00:53:26,280 --> 00:53:27,530
>> קהל: [לא ברור]

1309
00:53:30,510 --> 00:53:32,210
הדוד Malan: האם אתה יכול לדבר קצת יותר חזק?

1310
00:53:32,210 --> 00:53:34,325
מדוע 0 תמורה לתכנית זו, ו?

1311
00:53:34,325 --> 00:53:35,575
קהל: [לא ברור]

1312
00:53:39,910 --> 00:53:43,450
הדוד Malan: אה, זה בגלל שנהייתי עצלנית, מצטער.

1313
00:53:43,450 --> 00:53:48,290
אין תגובה אקדמית טובה, להחזיר 0.

1314
00:53:48,290 --> 00:53:52,690
אני יכול להציל את מין זה, באומרו הטכני C, אם עיקרי

1315
00:53:52,690 --> 00:53:55,900
לא במפורש להחזיר ערך, 0 יוחזרו

1316
00:53:55,900 --> 00:53:57,730
באופן אוטומטי עבורך.

1317
00:53:57,730 --> 00:54:00,290
וזה נכון, אני לא רק לטשטש את העקבות.

1318
00:54:00,290 --> 00:54:03,270
אבל, הייתי צריך לעשות את זה ככה.

1319
00:54:03,270 --> 00:54:05,250
לא takeaway מעניין מאשר שמלבד הטעות שלי.

1320
00:54:05,250 --> 00:54:06,170
כן?

1321
00:54:06,170 --> 00:54:08,470
>> קהל: לרוב בעת ההקלדה בחלל, זה אומר שאתה

1322
00:54:08,470 --> 00:54:10,770
לא מחזיר משהו.

1323
00:54:10,770 --> 00:54:11,420
הדוד Malan: נכון.

1324
00:54:11,420 --> 00:54:15,800
אם במקום זאת, עליך לציין לפני שם של פונקציה, עבור

1325
00:54:15,800 --> 00:54:18,590
למשל כאן, הריק, אז הפונקציה

1326
00:54:18,590 --> 00:54:20,480
לא מחזיר שום דבר.

1327
00:54:20,480 --> 00:54:25,210
ולכן אני פשוט אומר, שיבה או לא כלום,

1328
00:54:25,210 --> 00:54:26,730
ושיהיה עקבי.

1329
00:54:26,730 --> 00:54:27,750
ואנחנו נחזור לזה.

1330
00:54:27,750 --> 00:54:31,030
ורק לידיעתך, אחד מהתופס עם הלמידה

1331
00:54:31,030 --> 00:54:33,450
תכנות בעולם שיש לו מאה ספרים ו

1332
00:54:33,450 --> 00:54:36,180
מאה אתרי אינטרנט שם בחוץ, הם שיהיה תמיד

1333
00:54:36,180 --> 00:54:38,220
לראות תחביר שונה בספרים שונים

1334
00:54:38,220 --> 00:54:40,220
על ידי אנשים שונים.

1335
00:54:40,220 --> 00:54:42,100
מבין אנו נעשינו כמיטב יכולתנו בסעיפים והרצאות להיות

1336
00:54:42,100 --> 00:54:42,960
עקבי.

1337
00:54:42,960 --> 00:54:46,660
אבל לפעמים אתה תראה תחביר סותר.

1338
00:54:46,660 --> 00:54:48,540
אז בכל פעם בספק, פשוט לשאול.

1339
00:54:48,540 --> 00:54:51,100
ובכלל, אנחנו נדאג בהרצאות ובקטעים שיש

1340
00:54:51,100 --> 00:54:53,710
כמעט תמיד להציג את זה בדרך הנכונה.

1341
00:54:53,710 --> 00:54:56,070
ואני אומר כמעט תמיד, כי דוגמה טובה.

1342
00:54:56,070 --> 00:54:56,860
שאלות אחרות?

1343
00:54:56,860 --> 00:55:01,590
>> קהל: האם% s קיימת מחוץ למכשיר?

1344
00:55:01,590 --> 00:55:03,710
הדוד Malan: האם קיימת% s החיצונית של המכשיר?

1345
00:55:03,710 --> 00:55:04,180
כן.

1346
00:55:04,180 --> 00:55:07,760
אז% s יש לעשות עם ג עובדה שאנחנו משתמשים בו ב

1347
00:55:07,760 --> 00:55:10,290
מכשיר מיסוד יש מה לעשות עם

1348
00:55:10,290 --> 00:55:12,080
תכונות של השפה שאנו משתמשים.

1349
00:55:12,080 --> 00:55:15,990
ואכן, בשבוע שעבר כאשר השתמשנו Mac שלי, כתב

1350
00:55:15,990 --> 00:55:17,160
קוד C ב-Mac שלי.

1351
00:55:17,160 --> 00:55:20,020
הייתי יכול להשתמש ב-Mac של% שלי, ואתה יכול להשתמש בו על

1352
00:55:20,020 --> 00:55:22,400
מחשב Windows שלך, אם אתה מתקין מהדר, כמו

1353
00:55:22,400 --> 00:55:24,070
של Visual Studio של מיקרוסופט.

1354
00:55:24,070 --> 00:55:24,990
אז% s.

1355
00:55:24,990 --> 00:55:27,860
כל מה שאנחנו עושים בתוך של חלון זה היום יש

1356
00:55:27,860 --> 00:55:31,140
לעשות עם ג והיסוד ולא כלום עם

1357
00:55:31,140 --> 00:55:33,450
מערכת הפעלה בשאלה.

1358
00:55:33,450 --> 00:55:35,900
לעומת זאת, חלון המסוף השחור ולבן - כש

1359
00:55:35,900 --> 00:55:40,160
אני מקליד דברים כמו ls, וrm ו cd -

1360
00:55:40,160 --> 00:55:42,020
שיש לעשות עם מערכת ההפעלה ו

1361
00:55:42,020 --> 00:55:43,562
ניווט בסביבה.

1362
00:55:43,562 --> 00:55:44,546
כן.

1363
00:55:44,546 --> 00:55:46,520
קהל: אני מתכוון לספרייה, CS50 הספרייה.

1364
00:55:46,520 --> 00:55:49,960
הדוד Malan: אוקיי, אז אם אתה מתכוון למחרוזת של מילות המפתח, ה

1365
00:55:49,960 --> 00:55:52,460
קיים רק בCS50 הספרייה, נכון.

1366
00:55:52,460 --> 00:55:55,350
זה לא מקיים ב-C עצמו, ואכן בזוג

1367
00:55:55,350 --> 00:55:58,220
שבועות אנו לזרוק ספריית CS50 ולהתחיל

1368
00:55:58,220 --> 00:56:02,290
עושים דברים מהתחלה את עצמנו, אם אפשר לומר כך.

1369
00:56:02,290 --> 00:56:02,940
שאלות אחרות?

1370
00:56:02,940 --> 00:56:04,577
כן.

1371
00:56:04,577 --> 00:56:05,827
>> קהל: [לא ברור]

1372
00:56:09,470 --> 00:56:10,160
הדוד Malan: שאלה טובה.

1373
00:56:10,160 --> 00:56:11,720
האם מקרה הפקודות רגישות?

1374
00:56:11,720 --> 00:56:13,710
ותן לי לעשות כאן הבחנה.

1375
00:56:13,710 --> 00:56:15,840
אז פקודות הן בדרך כלל דברים שאנחנו כותבים ב

1376
00:56:15,840 --> 00:56:17,940
חלק תחתון של החלון, בחלון המסוף.

1377
00:56:17,940 --> 00:56:21,770
כל דבר עד כאן יהיה הצהרות או קוד C.

1378
00:56:21,770 --> 00:56:24,490
אבל בשני המקרים, התשובה היא אותו הדבר, כן.

1379
00:56:24,490 --> 00:56:27,800
שתי הסביבות הללו, קוד C בראש ו

1380
00:56:27,800 --> 00:56:29,910
שורת פקודה של מערכת הפעלה ב

1381
00:56:29,910 --> 00:56:31,440
תחתון, הוא עניין רגיש.

1382
00:56:31,440 --> 00:56:33,830
אז אתה חייב לנצל GetString עם ההון G,

1383
00:56:33,830 --> 00:56:37,050
ההון ס אתה חייב לכתוב printf בכל האותיות קטנות.

1384
00:56:37,050 --> 00:56:39,520
עליך להקליד ls בכל האותיות קטנות.

1385
00:56:39,520 --> 00:56:43,260
אז כמעט בכל סיטואצית סמסטר, במקרה זה יובא בחשבון,

1386
00:56:43,260 --> 00:56:44,820
למעשה, עניין.

1387
00:56:44,820 --> 00:56:46,148
כן.

1388
00:56:46,148 --> 00:56:47,398
>> קהל: [לא ברור]

1389
00:56:54,770 --> 00:56:56,480
הדוד Malan: אה, אז בסדר, מה אם היה לנו קובץ

1390
00:56:56,480 --> 00:56:57,840
קרא hello.d.

1391
00:56:57,840 --> 00:57:00,090
אז מתברר D היא שפת תכנות.

1392
00:57:00,090 --> 00:57:02,790
וכך, במקרים מסוימים, נוכל בעצם לכתוב בתכנית

1393
00:57:02,790 --> 00:57:06,190
קובץ ושהרכיב שבאופנה.

1394
00:57:06,190 --> 00:57:09,090
אנחנו יכולים, ובעצם, תשובה הקצרה היא, אני לא יודע.

1395
00:57:09,090 --> 00:57:10,440
אז אנחנו הולכים לעשות את זה.

1396
00:57:10,440 --> 00:57:13,040
תן לי ללכת קדימה וליצור קובץ חדש.

1397
00:57:13,040 --> 00:57:15,580
והספין כאן, בכנות באופן כללי, הוא בכל פעם לכל ספק

1398
00:57:15,580 --> 00:57:18,130
בסמסטר הזה, ויש לך מכשיר או המחשב שלך

1399
00:57:18,130 --> 00:57:20,030
לפתוח, קדימה ולנסות משהו.

1400
00:57:20,030 --> 00:57:23,740
אז אני הולך להציל את קובץ שנקרא hello.d.

1401
00:57:23,740 --> 00:57:25,010
שמור את זה.

1402
00:57:25,010 --> 00:57:29,070
ואני הולך לרוץ לעשות שלום Enter.

1403
00:57:29,070 --> 00:57:31,660
זה נראה להסיק שג היה סביר יותר

1404
00:57:31,660 --> 00:57:35,920
מ ד, במקרה זה.

1405
00:57:35,920 --> 00:57:38,046
שאלות אחרות.

1406
00:57:38,046 --> 00:57:40,456
כן.

1407
00:57:40,456 --> 00:57:41,706
>> קהל: [לא ברור]

1408
00:57:48,170 --> 00:57:49,837
הדוד Malan: אוקיי, יגיד את זה עוד פעם.

1409
00:57:49,837 --> 00:57:51,087
קהל: [לא ברור]

1410
00:58:04,250 --> 00:58:05,780
הדוד Malan: איך היית הולך על אבחון זה או

1411
00:58:05,780 --> 00:58:06,380
פתרון זה?

1412
00:58:06,380 --> 00:58:08,800
כל כך סביר, כי רוב הם שפות שונות,

1413
00:58:08,800 --> 00:58:10,280
סביר להניח שהיית מקבל לחלוטין

1414
00:58:10,280 --> 00:58:11,580
תכנית אחרת outputted.

1415
00:58:11,580 --> 00:58:14,140
היית מקבל הודעות שגיאה שונות לחלוטין.

1416
00:58:14,140 --> 00:58:16,750
וגם רק במונחים של עיצוב, זה יהיה ללא ספק להיות

1417
00:58:16,750 --> 00:58:19,140
החלטת תכנון לקויה צריכות הייתה לכתוב שתי שונים

1418
00:58:19,140 --> 00:58:21,510
שפות עם קבצים בשמות זהים כמעט, ב

1419
00:58:21,510 --> 00:58:23,000
אותו מדריך המדויק, תוך שימוש

1420
00:58:23,000 --> 00:58:24,550
כלי אוטומטי כמו לעשות.

1421
00:58:24,550 --> 00:58:27,750
אז אני יכול גם לדחוף חוזר ואומר ב15 שנים עושים את זה,

1422
00:58:27,750 --> 00:58:29,190
אף פעם לא עשה את הטעות הזאת.

1423
00:58:29,190 --> 00:58:30,030
יכול לקרות.

1424
00:58:30,030 --> 00:58:31,190
אבל יש רק שונה, אני חושב,

1425
00:58:31,190 --> 00:58:33,180
הגנות לוגיסטיות במקום.

1426
00:58:33,180 --> 00:58:35,440
בנוסף הודעות השגיאה שתבואנה בעיקבותיה, שהייתן

1427
00:58:35,440 --> 00:58:37,260
סופו של דבר לחשוף את מה שהוא הנושא.

1428
00:58:37,260 --> 00:58:39,120
אבל מקרה פינה אפשרי.

1429
00:58:39,120 --> 00:58:41,730
>> בסדר, אז בואו להציג רק כמה אחרים

1430
00:58:41,730 --> 00:58:45,600
תכונות כאן עכשיו, כדי שנוכל להתחיל לבנות את ליותר

1431
00:58:45,600 --> 00:58:47,140
ותכנית מורכבת יותר.

1432
00:58:47,140 --> 00:58:49,000
אז קודם כל, מתמטיקה.

1433
00:58:49,000 --> 00:58:51,520
אז דוגמאות מתמטיקה הן רק סוג של קל בשבוע הראשון.

1434
00:58:51,520 --> 00:58:53,560
זה לא אומר שכל תכנות הוא כ

1435
00:58:53,560 --> 00:58:54,390
מתמטיקה.

1436
00:58:54,390 --> 00:58:57,890
אין ספק, להבנת תכונות שונות של

1437
00:58:57,890 --> 00:58:59,610
מתמטיקה, אלגברה בפרט, היא

1438
00:58:59,610 --> 00:59:00,330
די רלוונטי כאן.

1439
00:59:00,330 --> 00:59:03,010
בכיתות גבוהות יותר ברמת CS, אלגברה ליניארית,

1440
00:59:03,010 --> 00:59:03,920
תחשיב, וכמו.

1441
00:59:03,920 --> 00:59:06,500
אבל מבין שרוב מה שנעשינו בסמסטר הזה לא מפחית

1442
00:59:06,500 --> 00:59:09,230
למתמטיקה, ובוודאי שלא לחשבון, כשלעצמה, אבל באמת

1443
00:59:09,230 --> 00:59:11,570
רק היגיון וחשיבה זהירה.

1444
00:59:11,570 --> 00:59:14,310
וכן את הקשר הזה שיש לו מדעי מחשב ארוך,

1445
00:59:14,310 --> 00:59:16,570
במיוחד ברמת בית הספר התיכון, במתמטיקה, הוא

1446
00:59:16,570 --> 00:59:17,370
קצת מטעה.

1447
00:59:17,370 --> 00:59:20,090
מכיוון שברוב התוכניות שאנחנו כותבים, באמת, הם

1448
00:59:20,090 --> 00:59:23,290
סוג של רמה גבוהה יותר והתמקדות בפתרון בעיות ש,

1449
00:59:23,290 --> 00:59:26,410
בטוח, אולי להשתמש בחלק חיבור, חיסור, ושונה

1450
00:59:26,410 --> 00:59:28,650
נוסחות מתמטיות או כדומה,

1451
00:59:28,650 --> 00:59:30,860
אבל בסופו של היום, זה על חשיבה ולא

1452
00:59:30,860 --> 00:59:33,240
רק יישום מה שאולי עשה על כמו TI

1453
00:59:33,240 --> 00:59:35,050
מחשבון בבית הספר תיכון.

1454
00:59:35,050 --> 00:59:38,410
>> אז עם זה אמר, בוא עכשיו יעשה משהו עם אלה

1455
00:59:38,410 --> 00:59:40,980
אופרטורים מתמטיים שכן קיימים, כך שאנו יכולים להכשיל

1456
00:59:40,980 --> 00:59:43,950
על כמה היבטים הבסיסיים של תכנות, או ב

1457
00:59:43,950 --> 00:59:48,930
במקרה זה ג אז יש, כCS50 הספרייה הציעה,

1458
00:59:48,930 --> 00:59:51,520
והיום אנחנו משתמשים רק GetString - וברגע

1459
00:59:51,520 --> 00:59:52,940
אולי תפקיד אחד אחר -

1460
00:59:52,940 --> 00:59:55,380
אבל יש סוגי נתונים שונים במחשב.

1461
00:59:55,380 --> 00:59:58,550
בסופו של היום, מחשבים יודעים רק 0s ו 1s.

1462
00:59:58,550 --> 01:00:01,880
אבל זוכר ששבוע שעבר דברנו על המערכת הבינארית

1463
01:00:01,880 --> 01:00:05,000
בייצוג מספרים, כמו המספר 0, ו 1, ו 2,

1464
01:00:05,000 --> 01:00:07,480
כל הדרך בעד 8, כמו בווידאו של נייט.

1465
01:00:07,480 --> 01:00:08,840
ואז אנחנו יכולים לסמוך הרבה יותר גבוהים כפי שאנו

1466
01:00:08,840 --> 01:00:10,000
עשה על במה כאן.

1467
01:00:10,000 --> 01:00:15,660
אבל אם אתה רוצה לייצג לא רק מספרים, אלא מכתבים,

1468
01:00:15,660 --> 01:00:18,240
אנחנו, בני האדם, צריכים לבוא עם קצת שרירותי

1469
01:00:18,240 --> 01:00:21,180
מוסכם, שלפיו אם בסופו של היום את כל המחשב שלי

1470
01:00:21,180 --> 01:00:24,260
כבר היא היכולת להביע 0s ו 1s, גם אנחנו היינו טובים יותר

1471
01:00:24,260 --> 01:00:27,990
להתחיל תקנון דפוסים של 0s ו 1s שמייצגים

1472
01:00:27,990 --> 01:00:28,800
דברים שונים.

1473
01:00:28,800 --> 01:00:32,370
דפוס של 0s ו 1s שמייצג את האות.

1474
01:00:32,370 --> 01:00:34,840
דפוסים של 0s ו 1s המייצגים את אות Z.

1475
01:00:34,840 --> 01:00:37,600
דפוסים של 0s ו 1s המייצגים את הצבע הכחול, או

1476
01:00:37,600 --> 01:00:38,600
אדום, או כמו.

1477
01:00:38,600 --> 01:00:42,360
אנחנו צריכים להשתמש בכל אלה 0s ו 1s לבטא את עצם ב

1478
01:00:42,360 --> 01:00:45,140
הקשרים שונים, בדרכים שונות שאינן

1479
01:00:45,140 --> 01:00:46,470
בהכרח מספרי.

1480
01:00:46,470 --> 01:00:51,150
>> אז במונחים של ייצוג, C יש סוגי נתונים שונים,

1481
01:00:51,150 --> 01:00:52,550
וראינו אחד מהם עד כה.

1482
01:00:52,550 --> 01:00:54,940
ראינו int, והודעה על מה שלא מופיע על המסך

1483
01:00:54,940 --> 01:00:56,140
עכשיו היא מחרוזת.

1484
01:00:56,140 --> 01:00:58,550
מחרוזת אינה, למעשה, קיימת בג שוב, זה

1485
01:00:58,550 --> 01:01:00,610
פישוט אנו מגישים ל1

1486
01:01:00,610 --> 01:01:01,570
כמה שבועות.

1487
01:01:01,570 --> 01:01:03,770
Char הוא אופי אישי.

1488
01:01:03,770 --> 01:01:07,050
ציפה היא מספר אמיתי, עם נקודה ומספרים לעשרוניים

1489
01:01:07,050 --> 01:01:09,066
שמאל וימין שלו.

1490
01:01:09,066 --> 01:01:16,040
כפול הוא מה, לבעלי רקע חזרה מוקדם?

1491
01:01:16,040 --> 01:01:19,720
אז כפול הוא כפול משהו.

1492
01:01:19,720 --> 01:01:21,240
מוסיף כמות כפול של דיוק.

1493
01:01:21,240 --> 01:01:22,440
אז מה זה אומר?

1494
01:01:22,440 --> 01:01:26,090
אז בכל אחד מהמקרים הללו, בעולם יש סוג של טופל

1495
01:01:26,090 --> 01:01:27,960
כמה חתיכות משמשים כדי לייצג

1496
01:01:27,960 --> 01:01:29,160
כל אחד מהדברים האלה.

1497
01:01:29,160 --> 01:01:31,590
אז אם ראית וידאו ASCII של נייט כבר לחלק

1498
01:01:31,590 --> 01:01:36,170
של pset 0, או בהמשך השבוע אתה, אתה בטח יודע

1499
01:01:36,170 --> 01:01:37,450
שASCII -

1500
01:01:37,450 --> 01:01:38,610
ייצוגי דמויות -

1501
01:01:38,610 --> 01:01:40,670
להשתמש בכמה חתיכות?

1502
01:01:40,670 --> 01:01:43,410
ואולי אפילו אתם זוכרים מההדגמה שלנו בשבוע שעבר באופן

1503
01:01:43,410 --> 01:01:45,500
הרבה אנשים היו על במה.

1504
01:01:45,500 --> 01:01:46,840
אז 7 או 8, בדרך כלל.

1505
01:01:46,840 --> 01:01:49,230
אז בדרך כלל 8, ויש משהו שנקרא כמו הוארך

1506
01:01:49,230 --> 01:01:51,240
ASCII שמשתמש בכל 8 הביטים, במקום 7.

1507
01:01:51,240 --> 01:01:54,710
אבל באופן כללי, אנחנו מדברים בחזקים של 2, ולכן במקרה זה, 8.

1508
01:01:54,710 --> 01:01:58,900
אז דמות בשפת תכנות היא בדרך כלל 8 סיביות.

1509
01:01:58,900 --> 01:02:02,550
אז int הוא בדרך כלל 32 סיביים.

1510
01:02:02,550 --> 01:02:04,810
מצוף הוא בדרך כלל 32 סיביים.

1511
01:02:04,810 --> 01:02:08,060
כפול הוא בדרך כלל 64 סיביים.

1512
01:02:08,060 --> 01:02:08,870
ומה זה אומר?

1513
01:02:08,870 --> 01:02:11,500
זה אומר שאתה יכול לייצג מספרים גדולים יותר, או במקרה

1514
01:02:11,500 --> 01:02:15,490
מספרים אמיתיים, אתה יכול לקבל הרבה יותר מספרים אחרי

1515
01:02:15,490 --> 01:02:16,240
מקום עשרוני.

1516
01:02:16,240 --> 01:02:18,980
הרבה יותר דיוק, במקרה זה.

1517
01:02:18,980 --> 01:02:21,780
עכשיו זמן ארוך נקרא על שמו, למרבה הצער.

1518
01:02:21,780 --> 01:02:24,340
אז יש int שהוא 32 סיביים.

1519
01:02:24,340 --> 01:02:29,800
יש זמן שהוא, לא, 32 סיביים.

1520
01:02:29,800 --> 01:02:32,610
וארוך ארוך שהוא 64 סיביים.

1521
01:02:32,610 --> 01:02:34,830
עם זאת חלק מאלה רגישים להיקשר, היא תלויה

1522
01:02:34,830 --> 01:02:36,190
איזה סוג של מחשב יש לך.

1523
01:02:36,190 --> 01:02:40,510
אז באופן כללי, אנו נציין בשיעורי בית או בחידון כש

1524
01:02:40,510 --> 01:02:41,180
זה באמת חשוב.

1525
01:02:41,180 --> 01:02:43,080
אבל הנקודה היא שיש כל אלה שונים

1526
01:02:43,080 --> 01:02:44,250
ייצוגים כאן.

1527
01:02:44,250 --> 01:02:45,950
>> אז בואו באמת לצלול לתוך תכנית.

1528
01:02:45,950 --> 01:02:48,300
במקום לכתוב את זה מהתחלה, תן לי ללכת קדימה

1529
01:02:48,300 --> 01:02:50,940
ולפתוח מקוד המקור של היום - כל אשר הוא

1530
01:02:50,940 --> 01:02:54,980
באינטרנט - אם אתה רוצה להתעסק באינטרנט, או תשואה על

1531
01:02:54,980 --> 01:02:57,120
יום רביעי, עם המכשיר במחשב שלך, הוראות

1532
01:02:57,120 --> 01:02:59,160
שליחבר בעמוד הבית של הקורס.

1533
01:02:59,160 --> 01:03:00,830
הנה תכנית סופר פשוטה.

1534
01:03:00,830 --> 01:03:02,520
אבל יש לה משהו חדש קטן בראש ש

1535
01:03:02,520 --> 01:03:03,650
לא הייתה לנו בעבר.

1536
01:03:03,650 --> 01:03:05,800
המון קווים כחולים של טקסט.

1537
01:03:05,800 --> 01:03:08,410
אז הקווים הכחולים האלה מייצגים הערות.

1538
01:03:08,410 --> 01:03:10,620
אז זה די שימושי בתכנית כדי להיות מסוגל לכתוב

1539
01:03:10,620 --> 01:03:13,160
כמה הערות לעצמך, או לעמיתים לעבודה, או חברים, או

1540
01:03:13,160 --> 01:03:15,700
עמיתי הוראה, מסוג לתאר את מה שקורה ב

1541
01:03:15,700 --> 01:03:18,500
קובץ זה, אבל אין לי מה לעשות עם קוד C עצמו.

1542
01:03:18,500 --> 01:03:20,860
אין מה לעשות עם התכנית פונקציונלית, זה רק

1543
01:03:20,860 --> 01:03:21,760
אסתטיקה.

1544
01:03:21,760 --> 01:03:24,580
אז כמו שאתה עושה את זה ב C הוא שאתה בדרך כלל מתחיל

1545
01:03:24,580 --> 01:03:29,860
הערות עם / *, ואתה בסופו ההערות שלך עם

1546
01:03:29,860 --> 01:03:31,270
* /.

1547
01:03:31,270 --> 01:03:34,140
אם אתה באמת אנאלי ואוהב לצייר ומיון של תמונות,

1548
01:03:34,140 --> 01:03:35,870
אז אתה רוצה לשים המון כוכבים, היית יכול

1549
01:03:35,870 --> 01:03:36,970
קופסה קטנה כמו זה.

1550
01:03:36,970 --> 01:03:37,990
אבל זה בכלל לא משנה.

1551
01:03:37,990 --> 01:03:40,230
הדבר היחיד שחשובים הוא ראשון

1552
01:03:40,230 --> 01:03:41,620
ואחרון.

1553
01:03:41,620 --> 01:03:43,820
זה מה שנקרא תגובה מרובה שורות.

1554
01:03:43,820 --> 01:03:46,610
וזה רק מוסכמה אנושית לעתים קרובות לעשות את הכוכבים והתיבה

1555
01:03:46,610 --> 01:03:48,420
דברים בסוג הזה, אם יש לך הרבה זמן פנוי.

1556
01:03:48,420 --> 01:03:51,550
>> אז אחרי שכתבת בהערות מסוימות, בדרך כלל, באים

1557
01:03:51,550 --> 01:03:53,160
האומץ בפועל של התכנית.

1558
01:03:53,160 --> 01:03:55,630
הנה המוכר שלנו # כולל <stdio.h>.

1559
01:03:55,630 --> 01:04:00,410
ולא מהיר, זה נחוץ או לא נחוץ?

1560
01:04:00,410 --> 01:04:02,860
קהל: צורך.

1561
01:04:02,860 --> 01:04:04,390
הדוד Malan: אז זה ממש לא הכרחי.

1562
01:04:04,390 --> 01:04:07,070
אז מדוע, אם כי, הוא שזה לא הכרחי?

1563
01:04:07,070 --> 01:04:08,170
כך שאין printf.

1564
01:04:08,170 --> 01:04:08,510
ואכן.

1565
01:04:08,510 --> 01:04:10,470
כל מה שאנחנו עושים בתכנית זו היא מתמטיקה.

1566
01:04:10,470 --> 01:04:11,640
אז אני באמת יכול למחוק את זה.

1567
01:04:11,640 --> 01:04:14,330
אז אתה לא תמיד צריך לכלול כל דבר ב

1568
01:04:14,330 --> 01:04:15,420
החלק העליון של תכנית.

1569
01:04:15,420 --> 01:04:17,020
>> אז בואו נפשט את זה קצת.

1570
01:04:17,020 --> 01:04:18,650
ועכשיו שים לב למה התכנית הזו עושה.

1571
01:04:18,650 --> 01:04:19,920
לא הרבה של עניין.

1572
01:04:19,920 --> 01:04:21,410
int x = 1.

1573
01:04:21,410 --> 01:04:22,550
ובכן, מה זה עושה?

1574
01:04:22,550 --> 01:04:25,130
ובכן, תחשוב על מודל מנטלי מקודם.

1575
01:04:25,130 --> 01:04:27,500
צד השמאל של ביטוי זה עושה מה?

1576
01:04:31,440 --> 01:04:32,830
יצירת מרחב למספר שלם.

1577
01:04:32,830 --> 01:04:33,930
אז כמה מקום?

1578
01:04:33,930 --> 01:04:36,980
ובכן, אנחנו יודעים במקרה עכשיו שזה 32 סיבי.

1579
01:04:36,980 --> 01:04:40,070
בעבר, הייתה מחרוזת טכנית 32 סיביות, אבל יותר

1580
01:04:40,070 --> 01:04:40,950
על כך שבעתיד.

1581
01:04:40,950 --> 01:04:42,240
אבל int הוא 32 סיביים.

1582
01:04:42,240 --> 01:04:45,590
לכן הביטוי הזה כאן מהשמאל, int x רק אומר היי

1583
01:04:45,590 --> 01:04:48,490
מערכת הפעלה, תן לי 32 ביטים של זכרון RAM -

1584
01:04:48,490 --> 01:04:50,450
הידוע גם 4 בתים של זכרון RAM -

1585
01:04:50,450 --> 01:04:53,930
כך שאני יכול לשים את המספר שלם שבחלל.

1586
01:04:53,930 --> 01:04:55,330
מה עשית שלם שאתה רוצה לשים?

1587
01:04:55,330 --> 01:04:56,640
ובכן, רק המספר 1.

1588
01:04:56,640 --> 01:04:59,530
int y מקבל 2, עושה בדיוק את אותו דבר למרות

1589
01:04:59,530 --> 01:05:02,160
המספר גדול, במונחים של גודלו.

1590
01:05:02,160 --> 01:05:04,790
המספר עצמו הוא עדיין רק 32 חתיכות.

1591
01:05:04,790 --> 01:05:06,520
זה פשוט הדפוס של ביטים שונים כדי

1592
01:05:06,520 --> 01:05:08,260
לייצג 1 מול 2.

1593
01:05:08,260 --> 01:05:11,980
int z עכשיו אומר לי עוד 32 חתיכות, קורא לזה z, ולשים

1594
01:05:11,980 --> 01:05:14,210
סיכום של 1 ו 2 לשם.

1595
01:05:14,210 --> 01:05:18,050
כך שעכשיו יש להניח z לאחסון הערך 3,

1596
01:05:18,050 --> 01:05:19,360
ולאחר מכן להחזיר 0.

1597
01:05:19,360 --> 01:05:23,020
>> עכשיו תכנית זו, הוא עושה משהו מעניין?

1598
01:05:23,020 --> 01:05:26,170
אז זה בעצם לא עושה שום דבר מעניין, בכל

1599
01:05:26,170 --> 01:05:28,450
תחושה, כי למה? זה עושה קצת מתמטיקה.

1600
01:05:28,450 --> 01:05:30,590
אבל זה לא חוזר תשובה, נכון.

1601
01:05:30,590 --> 01:05:31,790
זה חוזר 0.

1602
01:05:31,790 --> 01:05:33,440
זה לא מדפיס את התשובה.

1603
01:05:33,440 --> 01:05:35,760
אז התכנית הזאת היא יסוד חסרת ערך, כפי שהוא

1604
01:05:35,760 --> 01:05:36,350
עומד עכשיו.

1605
01:05:36,350 --> 01:05:37,220
זה עושה קצת עבודה.

1606
01:05:37,220 --> 01:05:39,530
זה הולך לקחת קצת מספר השניות, או מייקרו, כדי

1607
01:05:39,530 --> 01:05:41,510
לרוץ, אבל זה לא ממש עושה משהו

1608
01:05:41,510 --> 01:05:42,770
שימושי לאדם.

1609
01:05:42,770 --> 01:05:46,810
>> אז בואו ממש עכשיו לפתוח math2, שם עכשיו אני ממש

1610
01:05:46,810 --> 01:05:48,250
להדפיס את התוצאה.

1611
01:05:48,250 --> 01:05:51,260
אז גם את זה ניתן להסיק מהדוגמות הקודמות שלנו.

1612
01:05:51,260 --> 01:05:54,320
אם אני רוצה לעשות קצת מתמטיקה פשוטה, int x = 1, y

1613
01:05:54,320 --> 01:05:56,820
= 2. z הוא 1 ועוד 2 עכשיו.

1614
01:05:56,820 --> 01:05:59,240
מה זה הולך להדפיס ברור?

1615
01:05:59,240 --> 01:06:00,120
רק 3.

1616
01:06:00,120 --> 01:06:01,590
אז שפיות מהירה לבדוק.

1617
01:06:01,590 --> 01:06:03,830
בואו להעביר אותי לספרייה זו.

1618
01:06:03,830 --> 01:06:06,480
אז cd source1m.

1619
01:06:06,480 --> 01:06:09,370
תן לי ללכת קדימה ולעשות הקלד math2.

1620
01:06:09,370 --> 01:06:11,510
אין הודעות שגיאה יצאו, אז תן לי לרוץ -

1621
01:06:11,510 --> 01:06:14,800
לא a.out-תן לי לרוץ math2. Enter.

1622
01:06:14,800 --> 01:06:16,750
ואכן, אותו הדפיס 3.

1623
01:06:16,750 --> 01:06:18,460
ובכן, הבה נסתכל על וריאציה של זה.

1624
01:06:18,460 --> 01:06:23,870
בmath3.c, עכשיו יש לנו דוגמה זו כאן.

1625
01:06:23,870 --> 01:06:26,540
>> אז די מעניין של אדם זה.

1626
01:06:26,540 --> 01:06:32,000
אז בספר הזה, תשובה הוא הולך לקבל 1 חלקי 10,

1627
01:06:32,000 --> 01:06:33,910
ושימו לב שהכרזתי עליו כמצוף.

1628
01:06:33,910 --> 01:06:35,200
למה אני רוצה שזה יהיה מצוף?

1629
01:06:35,200 --> 01:06:36,110
טוב, זה חלק קטן.

1630
01:06:36,110 --> 01:06:37,140
זה הולך להיות מספר אמיתי.

1631
01:06:37,140 --> 01:06:40,970
אז זה הולך להיות 0.1, בתקווה - 10%, במקרה זה.

1632
01:06:40,970 --> 01:06:42,610
ומה אז אני רוצה להדפיס?

1633
01:06:42,610 --> 01:06:43,440
ובכן, זו תשובה.

1634
01:06:43,440 --> 01:06:44,760
ובכן, בואו להקניט אלה מלבד ראשונים.

1635
01:06:44,760 --> 01:06:47,020
אז בצד השמאלי, מצהיר

1636
01:06:47,020 --> 01:06:49,410
לצוף, קוראים לזה תשובה.

1637
01:06:49,410 --> 01:06:52,280
בצד ימין, אל 1 מחולק 10 ולשים את זה

1638
01:06:52,280 --> 01:06:54,370
לענות בתוך משתנה.

1639
01:06:54,370 --> 01:06:56,410
עכשיו, הקו הזה נראה קצת יותר מסתורי.

1640
01:06:56,410 --> 01:06:59,440
אבל שם לב שחלק ממאפיינים מוכרים. % פירושו כאן מגיע

1641
01:06:59,440 --> 01:07:00,490
מציין מיקום.

1642
01:07:00,490 --> 01:07:03,230
f אומר הנה ערך נקודה צפה, רק אמיתי

1643
01:07:03,230 --> 01:07:05,490
מספר, משהו עם נקודה עשרונית.

1644
01:07:05,490 --> 01:07:07,330
0.2 מה זה אומר?

1645
01:07:07,330 --> 01:07:10,740
מישהו יודע מניסיון קודם?

1646
01:07:10,740 --> 01:07:12,010
שני מקומות אחרי נקודה עשרוניים.

1647
01:07:12,010 --> 01:07:14,050
אז לא ראיתי את זה בעבר, אבל זה רק דרך

1648
01:07:14,050 --> 01:07:16,360
פעילות גופנית יותר שליטה קצת יותר וprintf

1649
01:07:16,360 --> 01:07:20,840
פתגם אל תשאיר לי 30 נקודות לאחר הנקודה העשרונית,

1650
01:07:20,840 --> 01:07:22,490
במקום לתת לי רק 2.

1651
01:07:22,490 --> 01:07:23,960
>> ואז בואו נלך קדימה ולהפעיל את זה.

1652
01:07:23,960 --> 01:07:30,160
אז להפוך את המתמטיקה 3, ועכשיו תן לי לרוץ במתמטיקה 3, Enter.

1653
01:07:30,160 --> 01:07:34,630
וזה לא בסדר.

1654
01:07:34,630 --> 01:07:37,390
נדמו לי שנתקלנו בבאג האמיתי הראשון שלנו.

1655
01:07:37,390 --> 01:07:39,400
טוב, אולי אני פשוט לא מחפש מספיק קרוב.

1656
01:07:39,400 --> 01:07:41,960
אז בואו תעלו אותי לכאן, ותן לי לשים 20 עשרוניים

1657
01:07:41,960 --> 01:07:43,300
מקומות בזה משהו.

1658
01:07:43,300 --> 01:07:47,950
ותנו לי לקמפל את זה, יגרום math3, לרוץ.

1659
01:07:47,950 --> 01:07:50,960
די בטוח 1 חלקים 10 היא לא 0.

1660
01:07:50,960 --> 01:07:54,270
אז מה קורה פה?

1661
01:07:54,270 --> 01:07:56,740
ובכן בסדר, אז למעשה אין לו מה לעשות עם זה.

1662
01:07:56,740 --> 01:07:57,600
זו מחשבה טובה.

1663
01:07:57,600 --> 01:07:59,140
זה באמת רק צירוף מקרים

1664
01:07:59,140 --> 01:08:00,220
שאנחנו עושים את זה.

1665
01:08:00,220 --> 01:08:02,010
אבל רק כדי להוכיח שזה לא זה, אני

1666
01:08:02,010 --> 01:08:03,160
להחזיר משהו אקראי.

1667
01:08:03,160 --> 01:08:05,160
אל תעשה את זה בבית, כי זה פשוט לא נכון.

1668
01:08:05,160 --> 01:08:08,000
אבל להפוך את math3, תן לי לרוץ אותו.

1669
01:08:08,000 --> 01:08:10,690
אז יש מה לעשות עם מה שאני חוזר, צריך רק לעשות

1670
01:08:10,690 --> 01:08:11,940
עם מה שאני מדפיס.

1671
01:08:11,940 --> 01:08:14,150
אבל שמעתי אותו כאן למטה.

1672
01:08:14,150 --> 01:08:15,270
מה?

1673
01:08:15,270 --> 01:08:17,524
קהל: אז אנחנו צריכים לכתוב את המספרים ב

1674
01:08:17,524 --> 01:08:19,680
חטיבה כ--

1675
01:08:19,680 --> 01:08:20,319
>> הדוד Malan: אוקיי טוב.

1676
01:08:20,319 --> 01:08:22,810
אז אנחנו צריכים לכתוב את המספרים המשתתפים ב

1677
01:08:22,810 --> 01:08:25,979
חלוקה כאן כנקודה צפה מעריכה את עצמם.

1678
01:08:25,979 --> 01:08:29,359
אז הבעיה כאן היא כמו קודם: C, כמו בהרבה

1679
01:08:29,359 --> 01:08:31,819
שפות, יש סוגי נתונים שונים.

1680
01:08:31,819 --> 01:08:34,600
וסוגי נתונים אלה, למשל, הם אלה כאן.

1681
01:08:34,600 --> 01:08:37,430
ואת סוגי הנתונים בשאלה כאן, כשאני סוג 1 ואז

1682
01:08:37,430 --> 01:08:40,870
סוג 10, הם כנראה סוגי נתונים מה?

1683
01:08:40,870 --> 01:08:42,170
אז זה כנראה int, נכון?

1684
01:08:42,170 --> 01:08:44,149
זה בהחלט לא לצוף כי אין עשרוני

1685
01:08:44,149 --> 01:08:45,460
נקודה או משהו כזה.

1686
01:08:45,460 --> 01:08:48,270
אז באמת, יש לי int מחולק int.

1687
01:08:48,270 --> 01:08:52,160
>> אז מה המעניין במתמטיקה ובמחשב הוא ש

1688
01:08:52,160 --> 01:08:54,840
אם אתה עושה את החלוקה באמצעות מספרים שלמים -

1689
01:08:54,840 --> 01:08:57,310
1 מחולק 10, כן עומד על 0.1.

1690
01:08:57,310 --> 01:09:01,420
עם זאת, כאשר אתה חלוקת מספר שלם במספר שלם,

1691
01:09:01,420 --> 01:09:06,859
תשובה יש גם להיות שלם רק בגלל, לעת עתה.

1692
01:09:06,859 --> 01:09:08,630
ומה ההשלכות אם כך?

1693
01:09:08,630 --> 01:09:13,640
ובכן, אם התשובה היא 1 חלקים 10 שווים 0.1, מה

1694
01:09:13,640 --> 01:09:15,680
המחשב הולך לעשות הוא אין לי מושג איך

1695
01:09:15,680 --> 01:09:19,270
מייצג 0.1, כי זה ערך נקודה צפה, לא

1696
01:09:19,270 --> 01:09:21,910
שלם; זה הולך לכרות את הכל אחרי

1697
01:09:21,910 --> 01:09:27,470
נקודה עשרונית ורק להראות לך את ה 0 בהתחלה.

1698
01:09:27,470 --> 01:09:29,540
ועובדה שזה מדפיס כנקודה צפה

1699
01:09:29,540 --> 01:09:31,200
ערך, זה רק עניין אסתטי.

1700
01:09:31,200 --> 01:09:34,279
זה בגלל שאני מכריח את המחשב כדי להדפיס זה כ

1701
01:09:34,279 --> 01:09:35,229
צף ערך נקודה.

1702
01:09:35,229 --> 01:09:37,720
ואכן אני כבר הכרזתי עליו כמצוף, אבל המתמטיקה היא

1703
01:09:37,720 --> 01:09:39,010
קורה כאן.

1704
01:09:39,010 --> 01:09:41,859
>> אז תן לי לתקן את זה ממש בדרך זו די קלה.

1705
01:09:41,859 --> 01:09:45,250
למה שלא פשוט לעשות 10.0 ו 1.0, למרות

1706
01:09:45,250 --> 01:09:47,609
מבחינה טכנית אני יכול לברוח עם רק עושה אחד מאלה.

1707
01:09:47,609 --> 01:09:50,630
עכשיו תן לי ללכת קדימה ולעשות math3.

1708
01:09:50,630 --> 01:09:56,350
תן לי ללכת קדימה וכעת להפעיל math3, Enter.

1709
01:09:56,350 --> 01:09:57,500
ועכשיו, אוי ויי.

1710
01:09:57,500 --> 01:10:00,050
עכשיו יש לנו בעיה חדשה לגמרי.

1711
01:10:00,050 --> 01:10:05,600
אז טוב יותר, נכון, אנחנו קרובים יותר ל -0.1, אבל מה שברור הוא

1712
01:10:05,600 --> 01:10:06,240
כאן לא בסדר?

1713
01:10:06,240 --> 01:10:08,260
אם אנחנו כבר שוכבים לך במשך שנים, נכון?

1714
01:10:08,260 --> 01:10:13,660
חלק 1 ב 10 הוא למעשה לא ממש 0.1, אז מה

1715
01:10:13,660 --> 01:10:14,700
באמת קורה כאן?

1716
01:10:14,700 --> 01:10:16,420
ובכן אתה יכול סוג של היגיון בתוך זה בהיגיון.

1717
01:10:16,420 --> 01:10:19,200
אם מחשב יש כמות מוגבלת של זכרון RAM כדי להתחיל רק

1718
01:10:19,200 --> 01:10:23,530
עם, ואכן מחשב רק באמצעות 32 סיביים עבור

1719
01:10:23,530 --> 01:10:26,200
צפתי ערך נקודה, זה הגיוני שעם

1720
01:10:26,200 --> 01:10:29,870
מספר סופי של ביטים, 32 במקרה הזה, כן, אתה יכול

1721
01:10:29,870 --> 01:10:31,050
מייצג הרבה דברים.

1722
01:10:31,050 --> 01:10:33,220
זה באמת הוא 4000000000 ערכים שונים יכולים להיות

1723
01:10:33,220 --> 01:10:38,040
מיוצג עם 32 סיביים, 2 עד 32, אבל זה עדיין סופי.

1724
01:10:38,040 --> 01:10:40,730
אז הבעיה היא שיש מספר אינסופי של אמת

1725
01:10:40,730 --> 01:10:41,370
מספרים, נכון.

1726
01:10:41,370 --> 01:10:43,560
אם תיתן לי מספר אמיתי, אני תמיד יכול למצוא לך אחד

1727
01:10:43,560 --> 01:10:46,080
מעט יותר גדול, קצת פחות, רק על ידי tweaking

1728
01:10:46,080 --> 01:10:47,970
מספרים שאחרי הנקודה העשרונית.

1729
01:10:47,970 --> 01:10:50,870
אז אם אין לך מספר אינסופי של ביטים, אתה

1730
01:10:50,870 --> 01:10:52,940
אולי לא יכול לייצג אינסופי

1731
01:10:52,940 --> 01:10:54,800
מספר של מספרים ממשיים.

1732
01:10:54,800 --> 01:10:58,090
>> אז יש חוסר הדיוק הזה טבוע במחשבים, ו

1733
01:10:58,090 --> 01:11:00,930
זה מקבל מעד על כל הזמן, אפילו בפשוט של

1734
01:11:00,930 --> 01:11:02,260
תוכניות כמו זו.

1735
01:11:02,260 --> 01:11:05,640
אבל גם בכמה בעיות, כמו גם בעולם אמיתיות מאוד.

1736
01:11:05,640 --> 01:11:07,790
למעשה, בואו ניקח רגע רק כדי להעיף מבט על

1737
01:11:07,790 --> 01:11:09,530
משהו שבאמת קרה במציאות.

1738
01:11:09,530 --> 01:11:11,620
אנחנו נסתכל רק הזוג הראשון של דקות, ולאחר מכן

1739
01:11:11,620 --> 01:11:13,270
אנו לכתוב באינטרנט הקישור.

1740
01:11:13,270 --> 01:11:16,700
אבל זה מעיד על בדיוק מה שיכול להשתבש, די

1741
01:11:16,700 --> 01:11:19,680
בכנות, באופן מאוד טרגי שבו הדברים האלה הם לא

1742
01:11:19,680 --> 01:11:23,870
מוערך או רק אנחנו, בני האדם עושה טעויות כשמדובר

1743
01:11:23,870 --> 01:11:26,792
אלו סוגים של פרטי יישום של מחשבים מודרניים.

1744
01:11:26,792 --> 01:11:27,284
>> [משחק וידאו]

1745
01:11:27,284 --> 01:11:30,730
-כעת אנו חוזרים לאסונות הנדסיים על פלאים מודרניים.

1746
01:11:30,730 --> 01:11:32,200
מחשבים.

1747
01:11:32,200 --> 01:11:34,920
כולנו כבר למד לקבל את הבעיות לעתים קרובות המתסכלות

1748
01:11:34,920 --> 01:11:36,750
שילכו איתם.

1749
01:11:36,750 --> 01:11:40,690
באגים, וירוסים ותקלות תוכנה הם מחירים קטנים ל

1750
01:11:40,690 --> 01:11:42,550
לשלם עבור הנוחות.

1751
01:11:42,550 --> 01:11:45,170
אבל בצבא גבוה טק ומהירות גבוה וחלל

1752
01:11:45,170 --> 01:11:48,450
תיכנות יישומים, הבעיה הקטנה ביותר יכולה להיות

1753
01:11:48,450 --> 01:11:52,220
מוגדל לאסון.

1754
01:11:52,220 --> 01:11:56,780
ב -4 ביונים 1996, מדענים מוכנים לשיגור מאויש

1755
01:11:56,780 --> 01:11:58,430
5 רקטות אריאן.

1756
01:11:58,430 --> 01:12:00,750
הוא נשא לווינים מדעיים שנועדו

1757
01:12:00,750 --> 01:12:03,580
לקבוע בדיוק איך השדה המגנטי של כדור הארץ

1758
01:12:03,580 --> 01:12:06,900
אינטראקציה עם רוחות סולריות.

1759
01:12:06,900 --> 01:12:10,330
הרקטה נבנתה עבור סוכנות החלל האירופית ו

1760
01:12:10,330 --> 01:12:13,450
המריא מהמתקן שלה בחוף הצרפתי גיאנה.

1761
01:12:13,450 --> 01:12:16,970
>> -בערך כ 37 שניות לתוך הטיסה, הם 1

1762
01:12:16,970 --> 01:12:19,700
משהו שם לב שהשתבש, כי החרירים היו

1763
01:12:19,700 --> 01:12:21,590
מסתובב בצורה שהם ממש לא צריכים.

1764
01:12:21,590 --> 01:12:25,020
כ 40 שניות לטיסה, ברור שהרכב

1765
01:12:25,020 --> 01:12:27,340
היה בצרות, וזה כשהם עשו את ההחלטה

1766
01:12:27,340 --> 01:12:28,136
להרוס אותו.

1767
01:12:28,136 --> 01:12:31,450
קצין בטיחות באומץ אדיר לחץ

1768
01:12:31,450 --> 01:12:34,160
כפתור, התפוצץ הרקטה לפני זה יכול להיות

1769
01:12:34,160 --> 01:12:37,470
סכנה לביטחון ציבור.

1770
01:12:37,470 --> 01:12:40,750
>> -זו הייתה הפלגת הבכורה של אריאן 5, ו

1771
01:12:40,750 --> 01:12:43,990
חורבן התרחש בגלל הפגם המוטבע ב

1772
01:12:43,990 --> 01:12:45,480
תוכנה של הרקטות.

1773
01:12:45,480 --> 01:12:47,660
>> -הבעיה באריאן הייתה שלא הייתה מספר ש

1774
01:12:47,660 --> 01:12:51,245
דורש 64 סיביים כדי לבטא והם רצו להמיר אותו

1775
01:12:51,245 --> 01:12:53,010
למספר 16 ביט.

1776
01:12:53,010 --> 01:12:54,900
הם הניחו שהמספר לא היה

1777
01:12:54,900 --> 01:12:56,280
הולך להיות מאוד גדול,

1778
01:12:56,280 --> 01:12:59,920
שרוב הספרות אלה במספר 64 הביט היה 0s.

1779
01:12:59,920 --> 01:13:01,860
הם טעו.

1780
01:13:01,860 --> 01:13:04,550
>> -חוסר היכולת של תוכנה מי שיקבל את

1781
01:13:04,550 --> 01:13:07,730
סוג של מספר שנוצר על ידי אחר היה בשורש

1782
01:13:07,730 --> 01:13:08,930
הכישלון.

1783
01:13:08,930 --> 01:13:11,490
פיתוח תוכנה הפך להיות חלק מאוד יקר של

1784
01:13:11,490 --> 01:13:13,280
טכנולוגיה חדשה.

1785
01:13:13,280 --> 01:13:16,530
4 רקטות אריאן היו מוצלחות מאוד.

1786
01:13:16,530 --> 01:13:19,100
כל כך הרבה מתוכנות שנוצרו לזה היה גם בעבר

1787
01:13:19,100 --> 01:13:21,050
באריאן 5.

1788
01:13:21,050 --> 01:13:25,530
>> -הבעיה הבסיסית הייתה שאריאן 5 היה מהיר יותר,

1789
01:13:25,530 --> 01:13:27,280
האיץ מהר יותר.

1790
01:13:27,280 --> 01:13:30,590
והתוכנה לא היוותה בשביל זה.

1791
01:13:30,590 --> 01:13:33,060
>> -ההרס של הרקטות היה כספי עצום

1792
01:13:33,060 --> 01:13:37,670
אסון, והכל בשל שגיאת תוכנת דקה.

1793
01:13:37,670 --> 01:13:40,750
אבל זו לא הייתה הפעם הראשונה שהיו בעיות המרת הנתונים

1794
01:13:40,750 --> 01:13:43,680
הטריד טכנולוגיית טילים מודרנית.

1795
01:13:43,680 --> 01:13:44,390
>> הדוד Malan: נשאיר את זה ככה.

1796
01:13:44,390 --> 01:13:46,870
אבל זו היא עדות לעד כמה ישים אפילו חלק מ

1797
01:13:46,870 --> 01:13:48,750
פרטים אלה ברמה הנמוכים ביותר שאנחנו כבר החלנו

1798
01:13:48,750 --> 01:13:50,040
לחקור היום.

1799
01:13:50,040 --> 01:13:52,510
אז גם כמו שאתה מקבל קצת לא מרוכז אולי על ידי כמה

1800
01:13:52,510 --> 01:13:55,240
התחביר וarcaneness כאן, מבינים שמעל

1801
01:13:55,240 --> 01:13:57,690
נהיה ממוקד רק בטווח איך זה ישים הוא

1802
01:13:57,690 --> 01:13:59,530
עולמות הרבה מעבר CS.

1803
01:13:59,530 --> 01:14:00,780
אנחנו רואים אותך ביום רביעי.