1
00:00:00,000 --> 00:00:11,280

2
00:00:11,280 --> 00:00:13,650
>> רמקול 1: בסדר.

3
00:00:13,650 --> 00:00:14,390
ברוך שובך.

4
00:00:14,390 --> 00:00:19,260
זהו שבוע שני CS50, ויש לנו
עד כה השתמשתי בפונקציות אבל

5
00:00:19,260 --> 00:00:20,830
במידה רבה, לקח אותם כמובן מאליו.

6
00:00:20,830 --> 00:00:23,430
אנחנו השתמשנו בו יש printf
תופעת לוואי של הדפסה

7
00:00:23,430 --> 00:00:24,110
דברים המופיעים על המסך.

8
00:00:24,110 --> 00:00:25,790
אנחנו השתמשנו לקבל-int, לקבל לצוף.

9
00:00:25,790 --> 00:00:29,230
>> אבל מה אם אתה באמת רוצה ליצור
פונקציות משלך, כחלק

10
00:00:29,230 --> 00:00:31,740
ייתכן שכבר החלו
לעשות בשביל סט בעיה אחת, אם כי

11
00:00:31,740 --> 00:00:33,140
לא נדרש להקפיד?

12
00:00:33,140 --> 00:00:37,150
ובכן, בואו נלך קדימה ולבקר שוב כי
בעיה של רק לשאול את המשתמש עבור

13
00:00:37,150 --> 00:00:40,660
השם וההדפסה שלהם על משהו
מסך, אבל מנסה גורם קצת

14
00:00:40,660 --> 00:00:44,000
המכנה המשותף של שיש לנו
ראה בקוד שלנו עד כה.

15
00:00:44,000 --> 00:00:45,120
זאת על ידי כך אני מתכוון שלאחר מכן.

16
00:00:45,120 --> 00:00:47,315
>> אני הולך להמשיך וליצור
תכנית חדשה, פשוט להתקשר

17
00:00:47,315 --> 00:00:49,320
זה hello.c כרגיל.

18
00:00:49,320 --> 00:00:53,730
אני הולך קדימה ולתת לעצמי
כולל io.h הסטנדרטי בחלקו העליון.

19
00:00:53,730 --> 00:00:57,040
אני הולך גם לתת לעצמי
מנע ספריית CS50 כך

20
00:00:57,040 --> 00:00:59,080
אני לא צועק על ידי המהדר.

21
00:00:59,080 --> 00:01:02,400
ועכשיו אני הולך קדימה
ולהכריז int, ראשי, הריק.

22
00:01:02,400 --> 00:01:09,020
>> ולאחר מכן בפה, זה מקום שבו אני רוצה
כדי להתחיל להעביר למיקור חוץ פונקציונליות

23
00:01:09,020 --> 00:01:12,090
איזה תפקיד אחר שאני בעצמי
הולך לכתוב אבל זה לא

24
00:01:12,090 --> 00:01:13,820
קיימים כיום.

25
00:01:13,820 --> 00:01:19,210
לדוגמה, נניח שאני רוצה
לכתוב פונקציה שמאפשרת לי

26
00:01:19,210 --> 00:01:23,830
להדפיס את שלום, פסיק, ו
לאחר מכן שמו של משתמש מסוים.

27
00:01:23,830 --> 00:01:29,010
במקום להמשיך לעשות printf
הלו,,% s לא יהיה זה נחמד אם

28
00:01:29,010 --> 00:01:33,380
היו רק פונקציה הנקראת
לא printf אבל שם הדפסה?

29
00:01:33,380 --> 00:01:36,600
>> אז במילים אחרות, אני רוצה להיות מסוגל
לכתוב תכנית שעושה קצת

30
00:01:36,600 --> 00:01:37,710
משהו כזה.

31
00:01:37,710 --> 00:01:42,070
ראשית, אני הולך לומר printf שלך
שם, ובכך גרם למשתמש

32
00:01:42,070 --> 00:01:46,150
תן לי את השם שלו או שלה, ולאחר מכן אני
הולכים להשתמש במחרוזת ים המוכר ל

33
00:01:46,150 --> 00:01:47,290
להכריז על מחרוזת.

34
00:01:47,290 --> 00:01:50,420
תן לי משתנה מסוג מחרוזת,
קורא לזה ים, וחנות שב

35
00:01:50,420 --> 00:01:52,120
לגרום לקורא לקבל את המחרוזת.

36
00:01:52,120 --> 00:01:56,060
אבל עכשיו בשבועות האחרונים, שיהיה לי
קצת עייפה עשה שלום,% s / n.

37
00:01:56,060 --> 00:01:58,630

38
00:01:58,630 --> 00:02:02,570
>> ובמילים אחרות, אנחנו כבר ראינו את זה
דוגמא חבורה של פעמים, וזה

39
00:02:02,570 --> 00:02:05,280
דוגמה טריוויאלית בגלל שיש רק אחד
שורת קוד כך שזה ממש לא

40
00:02:05,280 --> 00:02:06,860
עניין גדול כדי לשמור על הקלדה שוב.

41
00:02:06,860 --> 00:02:09,990
אבל נניח שהקו הזה של קוד
למעשה היו הופך לנטל, ו

42
00:02:09,990 --> 00:02:12,900
זה לא שורה אחת של קוד אבל זה 10
שורות קוד כמה שבועות עכשיו,

43
00:02:12,900 --> 00:02:15,190
ואתה רק מקבל עייף
של העתקה והדבקה או

44
00:02:15,190 --> 00:02:17,180
הקלדה מחדש באותו קוד.

45
00:02:17,180 --> 00:02:22,100
האם לא יהיה זה נחמד במקום לעשות
printf שלום,%, S וכן הלאה

46
00:02:22,100 --> 00:02:26,500
האם לא יהיה זה נחמד אם היו רק
פונקציה שנקראת שם שההדפסה

47
00:02:26,500 --> 00:02:27,560
לוקח טיעון -

48
00:02:27,560 --> 00:02:29,120
במילים אחרות, זה לוקח קלט -

49
00:02:29,120 --> 00:02:30,620
ולאחר מכן פסיק.

50
00:02:30,620 --> 00:02:33,240
אז פונקציה ש, לא הייתה זה
יהיה נחמד אם זה היה קיים?

51
00:02:33,240 --> 00:02:36,690
ואז לא הייתי צריך לדאוג
מה הוא printf, מה% כל ים ו

52
00:02:36,690 --> 00:02:39,400
המורכבויות האלה, כי הם
לא כל כך מעניינת.

53
00:02:39,400 --> 00:02:40,570
הם שימושיים.

54
00:02:40,570 --> 00:02:44,700
>> אז שם הדפסה, למרבה הצער, לא היה
המציא איזה לפני 40 שנה פלוס.

55
00:02:44,700 --> 00:02:45,980
אף אחד לא חשב לכתוב אותו.

56
00:02:45,980 --> 00:02:48,300
אבל זה היופי של בעל
שפת תכנות, בדיוק כמו ב

57
00:02:48,300 --> 00:02:52,930
שריטה באפשרותך להגדיר בלוקים מותאמים אישית, כך
ב-C, ורוב כל שפה, אתה יכול

58
00:02:52,930 --> 00:02:57,260
מגדיר את הפונקציונליות שלך, יכול
אתה מגדיר את פונקציות משלך.

59
00:02:57,260 --> 00:03:01,710
אז למרות שאנחנו מקבלים עיקרי על ידי
באופן אוטומטי ללא תשלום, אנחנו יכולים להצהיר

60
00:03:01,710 --> 00:03:02,730
הפונקציות שלנו.

61
00:03:02,730 --> 00:03:05,670
>> אז אני הולך לעשות קצת מקום עד כאן
למעלה, ואני הולך להכריז עליי

62
00:03:05,670 --> 00:03:08,210
פונקציה שלו שהולכת להיראות
קצת מוזר בהתחלה, אבל אנחנו נבוא

63
00:03:08,210 --> 00:03:09,400
בחזרה לכל כך הרבה זמן לפני.

64
00:03:09,400 --> 00:03:12,310
אני הולך לומר חלל, ובכך
המציין פונקציה זו עושה

65
00:03:12,310 --> 00:03:16,040
משהו, יש לו תופעת לוואי, אבל זה
לא מחזיר לי משהו ב

66
00:03:16,040 --> 00:03:18,810
אותו אופן שמקבל int או
מקבל מחרוזת עצמה עושה.

67
00:03:18,810 --> 00:03:22,450
ואני הולך לתת לי פונקציה זו
שמו של שם דפוס, ואני הולך

68
00:03:22,450 --> 00:03:26,470
לציין שהבחור הזה הולך לקחת
מחרוזת, ואני הולך לקרוא לזה

69
00:03:26,470 --> 00:03:27,600
שם מחרוזת.

70
00:03:27,600 --> 00:03:32,100
אני יכול לקרוא לזה מה שאני רוצה, אבל אני
רוצה הקוד שלי יהיה תיעוד עצמי.

71
00:03:32,100 --> 00:03:34,770
במילים אחרות, אם אחד מכם היית
לפתוח קובץ זה ולקרוא אותו, אתה יכול

72
00:03:34,770 --> 00:03:39,020
סוג של להסיק משמו של ש
קלט איזה תפקיד הוא אמור לשחק.

73
00:03:39,020 --> 00:03:42,270
>> ועכשיו מתחת לזה, אני הולך לפתוח
מתולתל סד וסד סגור מתולתל,

74
00:03:42,270 --> 00:03:47,140
ואז שם לב שאחרי אותו
דפוס על קווי ארבעה עד שבע כ

75
00:03:47,140 --> 00:03:51,622
אני עוקב אחרי במשך שבוע בתוספת טוב
עכשיו בין, יניח, קווים ותשעה

76
00:03:51,622 --> 00:03:53,400
14 המרכיבים עיקרי.

77
00:03:53,400 --> 00:03:56,160
במילים אחרות, להדפיס את השם
היא פונקציה אחרת.

78
00:03:56,160 --> 00:03:58,990
כעת, המהדר לא הולך לדעת
לקרוא את הדבר הזה באופן אוטומטי

79
00:03:58,990 --> 00:04:02,670
כי אני ממש ממש המצאתי את זה,
אבל זה עדיין יודע לקרוא עיקרי

80
00:04:02,670 --> 00:04:08,710
באופן אוטומטי, ולאחר מכן כמובן ב
קו 13, אני קורא לפונקציה שלי.

81
00:04:08,710 --> 00:04:12,805
ומכיוון שאני כבר הצהיר כי פונקציה
על קו ארבעה לפני ראשי,

82
00:04:12,805 --> 00:04:16,579
זה הולך ללמד את המהדר
מה ציטוט, סוף ציטוט ", שם הדפסה"

83
00:04:16,579 --> 00:04:18,140
אומר ומה היא צריכה לעשות.

84
00:04:18,140 --> 00:04:22,700
אז אני נותן לו סוג של מנהג חדש
לחסום בהקשר של, יניח, שריטה.

85
00:04:22,700 --> 00:04:27,240
>> אז הנה, אני יכול לשים את זה נפוץ מאוד
או תבנית חוזרת של קוד אני שומר

86
00:04:27,240 --> 00:04:32,300
כתיבה בכיתה, printf
-% S שלום,% s / n ",

87
00:04:32,300 --> 00:04:36,720

88
00:04:36,720 --> 00:04:37,590
מה שאני רוצה לשים כאן?

89
00:04:37,590 --> 00:04:39,200
S?

90
00:04:39,200 --> 00:04:41,420
אז אני רוצה לשים את השם בהקשר זה.

91
00:04:41,420 --> 00:04:43,440
אז שם לב קצת הדיכוטומיה כאן.

92
00:04:43,440 --> 00:04:47,680
כי אני מכריז הפונקציה שלי
ויש לי במידה מסוימת נקרא באופן שרירותי

93
00:04:47,680 --> 00:04:50,880
שמו להדפיס, וכי יש לי
צוין בסוגריים שזה

94
00:04:50,880 --> 00:04:55,035
הפונקציה לוקחת טיעון אחד, הסוג של
אשר היא מחרוזת - כך שזה מילה

95
00:04:55,035 --> 00:05:00,010
או ביטוי או משהו כזה - ו
אני קורא בשם טיעון זה, כי

96
00:05:00,010 --> 00:05:04,770
הפירוש משתנה רק שהוא ב
היקפו, אם אפשר לומר כך, הוא שם.

97
00:05:04,770 --> 00:05:07,780
>> S קיים רק בין מה ששתי
סוגריים מסולסלים, כמובן?

98
00:05:07,780 --> 00:05:12,990
ובכן באמת, בדיוק כמו קו 10 דרך
14, אז בדיוק כמו ביום שני לא יכול להשתמש

99
00:05:12,990 --> 00:05:17,650
S, אך מה אני יכול לעשות הוא לעבור
S לשם הדפסה.

100
00:05:17,650 --> 00:05:21,030
שם להדפיס פשוט קורה כל כך לתת לו
כינוי, שם נרדף, כינוי,

101
00:05:21,030 --> 00:05:24,400
קורא לזה שם, ועכשיו
השימוש בו בתחום הזה.

102
00:05:24,400 --> 00:05:26,840
אז עכשיו תן לי לשמור את זה, להקטין את התצוגה.

103
00:05:26,840 --> 00:05:31,250
>> תן לי להמשיך ולעשות שלום.

104
00:05:31,250 --> 00:05:32,400
נראה טוב.

105
00:05:32,400 --> 00:05:36,110
לא לירוק את כל שגיאות.
. / שלום על Enter.

106
00:05:36,110 --> 00:05:37,020
מה השם שלי?

107
00:05:37,020 --> 00:05:38,060
דוד.

108
00:05:38,060 --> 00:05:39,270
שלום ודוד.

109
00:05:39,270 --> 00:05:41,820
אז לא כל כך מרגש,
אבל רק לחשוב עכשיו.

110
00:05:41,820 --> 00:05:44,310
כעת יש לך אותו מרכיב
כפי שעשינו בהתחלה כדי

111
00:05:44,310 --> 00:05:45,420
להפוך את הפונקציות שלנו.

112
00:05:45,420 --> 00:05:46,770
>> אבל יש קצת תפסתי אותך.

113
00:05:46,770 --> 00:05:50,620
נניח שאני באמת לא חשבתי
זו דרך ואני ממש בלי

114
00:05:50,620 --> 00:05:54,250
באמת חשבתי על זה כתב
שפונקציה כאן למטה.

115
00:05:54,250 --> 00:05:55,420
מרגיש סבירים בהחלט.

116
00:05:55,420 --> 00:05:58,440
בגרד אין מושג
של מיקום בתסריטים שלך.

117
00:05:58,440 --> 00:06:00,670
אתה יכול לשים את אחד כאן, אחד כאן,
אחד עד כאן, וזה עלול להתחיל

118
00:06:00,670 --> 00:06:03,310
להסתכל קצת מבולגן אם לא
להניח אותה החוצה בצורה מסודרת, אבל זה לא עושה

119
00:06:03,310 --> 00:06:05,910
משנה איפה פיזית את התסריטים
היו על המסך.

120
00:06:05,910 --> 00:06:09,660
לצערנו ב-C - וזאת, בניגוד
שפות כמו ג'אווה ופייתון

121
00:06:09,660 --> 00:06:13,600
ואחרים שאתה עשוי להיות מוכר
עם - למרבה הצער ב-C, כדי עושה

122
00:06:13,600 --> 00:06:15,830
משנה כי מה לצפות
הולך לקרות עכשיו.

123
00:06:15,830 --> 00:06:19,010
>> פונקצית ברירת המחדל שקורה
לביצוע הוא, כמובן, עיקרי.

124
00:06:19,010 --> 00:06:22,290
העיקרי היא הולך לקרוא שם על ההדפסה
קו שמונה, אך למרבה הצער,

125
00:06:22,290 --> 00:06:26,660
מהדר אפילו לא יודע את השם של ההדפסה ש
קיים עד שהוא מגיע לקו 11,

126
00:06:26,660 --> 00:06:28,520
שלמרבה הצער היא
הולך להיות מאוחר מדי.

127
00:06:28,520 --> 00:06:30,660
אז בואו נעשה לעשות שלום.

128
00:06:30,660 --> 00:06:32,950
ועכשיו, שתי שגיאות הארורות שנוצרו.

129
00:06:32,950 --> 00:06:36,050
אז עכשיו בואו לגלול עד מאוד
ראשון, כפי שאנו תמיד צריכים לעשות, ו

130
00:06:36,050 --> 00:06:39,560
שם לב שהוא צועק עליי,
"הצהרה המרומזת של פונקציה

131
00:06:39,560 --> 00:06:40,540
להדפיס את השם ".

132
00:06:40,540 --> 00:06:43,860
>> אז ראינו את ההודעה לפני,
הצהרה המרומזת של תפקוד.

133
00:06:43,860 --> 00:06:48,080
כאשר יש לנו לראות סוג כזה של שגיאה?

134
00:06:48,080 --> 00:06:49,180
כשלא כלל את ספרייה.

135
00:06:49,180 --> 00:06:53,470
אם שכחתי cs50.h ואני אקבל
צעק על למקבל מחרוזת או לקבל int.

136
00:06:53,470 --> 00:06:56,880
אבל במקרה הזה, פונקציה זו הדפסה
שם לא נמצא בספרייה, נכון?

137
00:06:56,880 --> 00:07:00,230
זה ממש בקובץ זה, ולכן
מה באמת הבעיה?

138
00:07:00,230 --> 00:07:04,660
>> ובכן למרבה הצער ב-C, זה לוקח לך
כך, פשוטו כמשמעו, שאם אתה מאוד

139
00:07:04,660 --> 00:07:08,640
רוצה פונקציה שנקראת שם להדפסה
קיים, אתה גם צריך ליישם

140
00:07:08,640 --> 00:07:11,940
הפונקציה שבחלקו העליון שלך
קוד כך שיהיה נגיש להורדה

141
00:07:11,940 --> 00:07:15,070
פונקציות, אבל בכנות, שהופך להיות
מרושל במהירות רבה.

142
00:07:15,070 --> 00:07:18,160
אישית, אני אוהב לשים ראשי ראשון
כי אז זה מאוד ברור מה זה

143
00:07:18,160 --> 00:07:19,890
תכנית עושה במבט הראשון.

144
00:07:19,890 --> 00:07:23,290
ובנוסף, אתה יכול להיכנס לפינה מוזרה
מקרים שבם אם x רוצה להתקשר

145
00:07:23,290 --> 00:07:27,530
Y אבל Y יכול לקרוא X, אתה פשוט
מבחינה פיזית לא ממש יכול לשים אחד

146
00:07:27,530 --> 00:07:28,540
מעל השני.

147
00:07:28,540 --> 00:07:31,230
>> אבל מתברר בC, אנחנו יכולים
לפתור את זה פשוט מאוד.

148
00:07:31,230 --> 00:07:34,010
אני הולך לשים קצת שטח
עד כאן, ואני רק הולך

149
00:07:34,010 --> 00:07:38,170
מנע, אם כי במידה מסוימת
מיותר, הולך ללמד

150
00:07:38,170 --> 00:07:42,320
מהדר כי קיימת פונקציה
קראתי בשם הדפסה, זה לוקח מחרוזת,

151
00:07:42,320 --> 00:07:46,330
ואני הולך לקרוא
זה שם פסיק.

152
00:07:46,330 --> 00:07:50,220
>> אז זה עכשיו בקו ארבעה, שבו אנו
לא ראה בעבר, היא הצהרה

153
00:07:50,220 --> 00:07:53,940
משם הדפסת פונקציה, אבל זה רק
הבטחה שפונקציה זו

154
00:07:53,940 --> 00:07:56,620
סופו של דבר להיות מוגדר, סופו של דבר
להיות מיושם.

155
00:07:56,620 --> 00:08:00,180
זה עכשיו אני יכול להשאיר אותו לבד, כי
עכשיו זה הוא ההגדרה,

156
00:08:00,180 --> 00:08:04,090
יישום, סוג של המייל האחרון
מיישום זה

157
00:08:04,090 --> 00:08:05,130
פונקציה מסוימת.

158
00:08:05,130 --> 00:08:08,450
אז בכנות שזה טיפשי, זה מעצבן,
אבל זו הדרך C הוא, וזה

159
00:08:08,450 --> 00:08:12,050
כי זה לוקח אותך, פשוטו כמשמעו, מאוד
וכפי שמחשב צריך כנות,

160
00:08:12,050 --> 00:08:16,020
רק שבדיוק את מה שאתה אומר לו
לעשות, ועל כך שההזמנה היא חשובה.

161
00:08:16,020 --> 00:08:18,940
>> אז לזכור את זה שוב ושוב, כדי להתחיל
שים לב להישנות של דפוסים.

162
00:08:18,940 --> 00:08:21,850
רוב הסיכויים שירצה, אם יש לך לא
כבר, מתחילים להיתקל בהודעות

163
00:08:21,850 --> 00:08:24,700
ככה שבמבט הראשון נראה
סתום לחלוטין, אבל אם אתה מתחיל

164
00:08:24,700 --> 00:08:29,000
כדי לחפש מילות מפתח אלו כמו
"הכרזה משתמעת", אזכור שמו של

165
00:08:29,000 --> 00:08:32,380
פונקציה במקרה זה - ולמען האמת, אתה
לפעמים אפילו מקבל קצת ירוק

166
00:08:32,380 --> 00:08:35,010
סמל גזר שאומר לך איפה
הבעיה היא כנראה -

167
00:08:35,010 --> 00:08:40,980
אתה יכול להתחיל לעבוד בדרך שלך דרך
עדיין הודעות שגיאה בלתי נראות.

168
00:08:40,980 --> 00:08:45,860
כל שאלות על הכתיבה שלך
תפקוד שלו בדרך זו?

169
00:08:45,860 --> 00:08:47,540
>> בואו נעשה משהו שהוא
קצת יותר משכנע.

170
00:08:47,540 --> 00:08:51,760
ולא רק לעשות משהו שיש לו
תופעת לוואי של הדפסה, תן לי ללכת

171
00:08:51,760 --> 00:08:55,340
קדימה ולשמור את הקובץ חדש ואנו יהיו
קורא positive.c זה, למרות שזה

172
00:08:55,340 --> 00:08:57,600
הולך להיות קצת שונים
לעומת פעם שעברה.

173
00:08:57,600 --> 00:09:01,910
והפעם, אני רוצה לשוב וליישם
דוגמא positive.C האחרון של הזמן, אשר

174
00:09:01,910 --> 00:09:04,430
היא לאלץ את המשתמש לתת
שלי מספר שלם חיובי.

175
00:09:04,430 --> 00:09:07,280
אבל אני הייתי צריך להשתמש לקבל הפעם האחרונה int.

176
00:09:07,280 --> 00:09:10,780
האם לא יהיה זה יכול להיות נחמד אם היה
פונקציה שנקראת לקבל int החיובי

177
00:09:10,780 --> 00:09:13,610
שאני יכול פשוט למיקור חוץ את זה
פיסת פונקציונליות?

178
00:09:13,610 --> 00:09:16,480
אז ההבדל כאן הוא שאנחנו יהיו
ליישם מקבל int החיובי, אבל בניגוד

179
00:09:16,480 --> 00:09:20,330
שם הדפסה שהייתה תופעת לוואי - זה
לא החזיר לי משהו כמו

180
00:09:20,330 --> 00:09:21,710
מספר או מחרוזת -

181
00:09:21,710 --> 00:09:25,510
מקבל int חיובי, כמובן, הולך
תחזור, בתקווה, int חיובי.

182
00:09:25,510 --> 00:09:26,170
>> אז בואו לעשות את זה.

183
00:09:26,170 --> 00:09:30,840
כולל cs50.h, כלול הסטנדרטי io.h.

184
00:09:30,840 --> 00:09:33,520
Int החלל ראשי.

185
00:09:33,520 --> 00:09:42,160
ועכשיו לכאן, אני הולך קדימה
ותניחו int, קורא לזה n, שווה

186
00:09:42,160 --> 00:09:44,270
לקבל int החיובי.

187
00:09:44,270 --> 00:09:49,080
ובדיוק כמו לקבל int כבר קיים
משום שצוות כתב אותו, אני הולך

188
00:09:49,080 --> 00:09:53,950
להניח לרגע שיקבל
int החיובי קיים, ועכשיו אני הולך

189
00:09:53,950 --> 00:09:57,730
ללכת קדימה ואומר printf,
תודה על% i / n ", n.

190
00:09:57,730 --> 00:10:02,940

191
00:10:02,940 --> 00:10:07,770
>> אז עכשיו אם אני לקמפל תכנית זו, מה
הולך לקרות במסוף שלי

192
00:10:07,770 --> 00:10:09,075
חלון בחלק התחתון של המסך?

193
00:10:09,075 --> 00:10:11,580

194
00:10:11,580 --> 00:10:13,900
אני הולך כנראה לקבל את זה
אותה שגיאה כמו קודם.

195
00:10:13,900 --> 00:10:14,570
אז בואו ננסה את זה.

196
00:10:14,570 --> 00:10:16,450
הפוך חיובי.

197
00:10:16,450 --> 00:10:19,900
ושוב, הצהרה המרומזת
של פונקציה, מקבל int החיובי.

198
00:10:19,900 --> 00:10:21,970
אז אנחנו יכולים לפתור את זה ב
כמה דרכים.

199
00:10:21,970 --> 00:10:27,310
אני הולך לשמור את זה פשוט ופשוט
לשים את ההצהרה שלי כאן ולקבל

200
00:10:27,310 --> 00:10:28,120
int החיובי.

201
00:10:28,120 --> 00:10:29,720
אני צריך את החתימה של מה שנקרא.

202
00:10:29,720 --> 00:10:32,410
החתימה מתייחסת רק
לאסתטיקה של

203
00:10:32,410 --> 00:10:34,090
השורה הראשונה של התכנית.

204
00:10:34,090 --> 00:10:37,420
אז מה צריך לקבל חיובי
int תמורה?

205
00:10:37,420 --> 00:10:37,970
>> אז int.

206
00:10:37,970 --> 00:10:41,540
אני מתכוון באופן אידיאלי, זה יחזור
משהו כמו int החיובי, אבל זה

207
00:10:41,540 --> 00:10:42,160
לא קיימת.

208
00:10:42,160 --> 00:10:45,280
אנחנו כבר לא ראינו כי בין הנתונים שלנו
סוגים, ולכן אנחנו צריכים להתמודד עם

209
00:10:45,280 --> 00:10:47,170
עובדה שיש לנו מעט מאוד
סוגי נתונים כדי לעבוד איתו.

210
00:10:47,170 --> 00:10:50,360
אבל אנחנו יכולים להחזיר int ופשוט
מקווה שזה יהיה חיובי.

211
00:10:50,360 --> 00:10:52,690
זה הולך להיקרא
לקבל int החיובי.

212
00:10:52,690 --> 00:10:55,122
>> ועכשיו מה דעתך על טענותיו?

213
00:10:55,122 --> 00:10:56,440
האם זה ייקח כל קלט?

214
00:10:56,440 --> 00:10:58,280
האם זה צריך כל קלט?

215
00:10:58,280 --> 00:11:00,900
אז זה לא צריך לדעת
בכל דבר מראש.

216
00:11:00,900 --> 00:11:03,220
קבל מחרוזת לא, לקבל int לא.

217
00:11:03,220 --> 00:11:06,430
Printf עושה - זה צריך להיות חלק
קלט עבר לתוך זה - ושם הדפסה

218
00:11:06,430 --> 00:11:09,020
צריך קצת קלט, אבל מקבל
int החיובי לא עושה.

219
00:11:09,020 --> 00:11:11,530
אז אני הולך באופן מפורש
תגיד את חלל מהדר.

220
00:11:11,530 --> 00:11:13,470
הריק הוא היעדר כל דבר אחר.

221
00:11:13,470 --> 00:11:17,990
כך ששום דבר אמצעי הריק הולך בפנים
בסוגריים האלה, פסיק.

222
00:11:17,990 --> 00:11:20,840
>> ועכשיו בחלק התחתון של התיק שלי - ו
סוג שוב, אני פשוט להיות של אנאלי

223
00:11:20,840 --> 00:11:23,640
כאן לשים ראשי בחלק העליון, אשר
היא פרקטיקה טובה, כי בדרך זו,

224
00:11:23,640 --> 00:11:26,220
בכל עת שאתה או מישהו אחר
פותח את הקובץ,

225
00:11:26,220 --> 00:11:27,400
פונקציונלי הוא ממש שם.

226
00:11:27,400 --> 00:11:29,660
אתה יכול לצלול מריבוע אחד.

227
00:11:29,660 --> 00:11:34,190
אז עכשיו אני הולך לשכפל את זה,
לקבל חלל int חיובי, אבל אני לא

228
00:11:34,190 --> 00:11:35,430
הולך להכות פסיק עכשיו.

229
00:11:35,430 --> 00:11:38,280
אני הולך לפתוח סוגריים מסולסלים,
ועכשיו אני צריך ללוות

230
00:11:38,280 --> 00:11:39,700
כמה רעיונות מיום שני.

231
00:11:39,700 --> 00:11:44,450
>> אז כפי שאתם זוכרים, שעשינו משהו
רוצים לעשות את הדברים הבאים תוך

232
00:11:44,450 --> 00:11:45,830
משהו היה נכון.

233
00:11:45,830 --> 00:11:46,630
ומה עשיתי?

234
00:11:46,630 --> 00:11:51,540
אני עשיתי משהו כמו לתת לי
שלי מספר חיובי,

235
00:11:51,540 --> 00:11:52,430
קצת מהיר.

236
00:11:52,430 --> 00:11:53,540
אני יכול להשתמש בכל מילים שאני רוצה.

237
00:11:53,540 --> 00:11:54,960
ואז השתמשתי במה?

238
00:11:54,960 --> 00:11:59,530
Int n שווה לקבל int,
אין טענות אליו.

239
00:11:59,530 --> 00:12:00,550
>> ותבחין בהבדל.

240
00:12:00,550 --> 00:12:04,680
כשאתה קורא לפונקציה, בעת שימוש
פונקציה, אתה לא לשים בחלל הריק.

241
00:12:04,680 --> 00:12:08,570
אתה רק עושה את זה כאשר הכריז
פונקציה, מלמד מה מהדר

242
00:12:08,570 --> 00:12:09,780
הוא צריך לצפות.

243
00:12:09,780 --> 00:12:11,650
אז אתה לא צריך לשים
יש לבטל את עצמך.

244
00:12:11,650 --> 00:12:12,940
>> ועכשיו מה המצב שלי?

245
00:12:12,940 --> 00:12:19,670
ובכן, n הוא לא שווה לחיובי,
אבל זה רק פסאודו קוד.

246
00:12:19,670 --> 00:12:22,530
אז איך אני יכול להביע את זה יותר נקי?

247
00:12:22,530 --> 00:12:24,090
אז פחות או שווה לאפס.

248
00:12:24,090 --> 00:12:26,250
אז שוב, שים לב שאתה יכול לעשות
פחות או שווה ל.

249
00:12:26,250 --> 00:12:28,100
למרות שזה שתיים נפרדים
סמלים, אתה יכול לעשות את זה על

250
00:12:28,100 --> 00:12:29,350
המקלדת שלך ככזה.

251
00:12:29,350 --> 00:12:33,950
>> אבל עדיין יש באג ש
גם אני פשלה בפעם האחרונה.

252
00:12:33,950 --> 00:12:36,950
אני חייב להצהיר -

253
00:12:36,950 --> 00:12:37,460
בדיוק.

254
00:12:37,460 --> 00:12:39,640
אני חייב להצהיר n מחוץ
של הלולאה.

255
00:12:39,640 --> 00:12:44,180
אז אני צריך לשים את n עד כאן, ואני לא
רוצה לחזור ולהכריז עליו בפה

256
00:12:44,180 --> 00:12:46,480
שמא אני מקבל את משתנה חדש.

257
00:12:46,480 --> 00:12:48,860
אני רק רוצה להקצות ערך לכאן.

258
00:12:48,860 --> 00:12:54,320
>> ועכשיו אני לא עשיתי די לכאן.

259
00:12:54,320 --> 00:12:57,290
תנו לי להתקדם בעצמי
ולהעמיד פן שאני עושה.

260
00:12:57,290 --> 00:13:01,220
הפוך חיובי, ועכשיו
יש שגיאה חדשה.

261
00:13:01,220 --> 00:13:04,550
שליטה מגיעה לסוף
פונקציה שאינה מבוטלת.

262
00:13:04,550 --> 00:13:07,760
אז הודעת שגיאה חדשה, אבל אם אתה מסוג
של להקניט בנפרד כל אחת מהמילים, זה

263
00:13:07,760 --> 00:13:09,620
כנראה מרמז על מה לא בסדר.

264
00:13:09,620 --> 00:13:11,240
>> לשלוט בו.

265
00:13:11,240 --> 00:13:14,250
שליטה רק אומרת לצו
פעילות בתכנית.

266
00:13:14,250 --> 00:13:16,510
המחשב הוא בשליטה ו
משהו השתבש.

267
00:13:16,510 --> 00:13:18,510
אז הוא מגיע לסוף
פונקציה שאינה מבוטלת.

268
00:13:18,510 --> 00:13:21,760
איזה תפקיד זה ככל הנראה
בהתייחסו ל?

269
00:13:21,760 --> 00:13:24,790
מה היא פונקציה שאינן מבוטל?

270
00:13:24,790 --> 00:13:27,400
אז קצת לקבל int החיובי, ו
מבלבל בכך שכן,

271
00:13:27,400 --> 00:13:29,010
זה סוג של החלל.

272
00:13:29,010 --> 00:13:33,070
יש לו מפרט של החלל עבורה
טיעונים, אבל התפוקה שלה עומדת

273
00:13:33,070 --> 00:13:34,540
להיות מהסוג n.

274
00:13:34,540 --> 00:13:37,260
אז המילה בצד השמאל היא
מה שנקרא סוג תמורה.

275
00:13:37,260 --> 00:13:40,320
המילה בצד הפנימי כאן היא
אפס או יותר את הטיעונים

276
00:13:40,320 --> 00:13:41,970
שפונקציה לוקחת.

277
00:13:41,970 --> 00:13:44,060
>> אז מה אני צריך לעשות?

278
00:13:44,060 --> 00:13:47,650
בשלב זה בקוד שלי, קו 21 שבו
הפקודה מהבהבת כרגע היא, אני

279
00:13:47,650 --> 00:13:51,430
יש לי חיובי int בתוך
של משתנה בשם n.

280
00:13:51,430 --> 00:13:55,200
כיצד אני יכול להחזיר אותו לדף הראשי?

281
00:13:55,200 --> 00:13:55,960
פשוטו כמשמעו.

282
00:13:55,960 --> 00:13:59,320
לחזור פסיק n.

283
00:13:59,320 --> 00:14:04,090
>> אז חזר פיסת בדיוק כמו קולטון
נייר עם תשובה אליי על ידי הטלת

284
00:14:04,090 --> 00:14:07,020
פיסת נייר בשחור הקטנה
תיבה על השולחן, לעשות את זה ב

285
00:14:07,020 --> 00:14:10,100
קוד, אתה ממש פשוט לכתוב, לחזור
n, וזה כאילו היו קולטון

286
00:14:10,100 --> 00:14:12,140
הושיט לי משהו פיזי בחזרה.

287
00:14:12,140 --> 00:14:15,870
במקרה זה, מה שקורה הוא לקבל
int החיובי הולך יד בחזרה

288
00:14:15,870 --> 00:14:19,220
מה יש להניח חיובי
שלם למי?

289
00:14:19,220 --> 00:14:21,380
איפה ערך שסופו של דבר?

290
00:14:21,380 --> 00:14:29,080
כי בסופו של משתנה זה, N, ו
לאחר מכן אנו ממשיכים עם קו תשע.

291
00:14:29,080 --> 00:14:31,920
>> אז במילים אחרות, לפי סדר
פעולות, תכנית זו מתחילה

292
00:14:31,920 --> 00:14:34,430
ביצוע, והמהדר מבין,
אה, אתה רוצה את הספרייה?

293
00:14:34,430 --> 00:14:36,310
תן לי ללכת לתפוס כל מה שיש בפנים.

294
00:14:36,310 --> 00:14:37,750
אה, אתה רוצה ספריית IO הסטנדרטית?

295
00:14:37,750 --> 00:14:39,660
תן לי ללכת לתפוס כל מה שיש בפנים.

296
00:14:39,660 --> 00:14:44,510
מה אומר לעצמו מהדר
כאשר הוא יגיע ארבעה קו?

297
00:14:44,510 --> 00:14:47,980
אה, אתה הבטחת ליישם
פונקציה שנקראת לקבל חיובי, אבל

298
00:14:47,980 --> 00:14:50,820
אנחנו נחזור לזה בהמשך,
משהו בכיוון הזה.

299
00:14:50,820 --> 00:14:53,450
>> החלל עיקרי int רק אומר שהנה
את האומץ של התכנית שלי.

300
00:14:53,450 --> 00:14:54,990
קו שבעה הוא רק סד מתולתל.

301
00:14:54,990 --> 00:14:59,540
קו שמונה אומר בצד השמאל, לתת
לי 32 סיביות למספר שלם, קורא לזה n.

302
00:14:59,540 --> 00:15:02,160
בצד ימין, זה
אומר לקבל int החיובי.

303
00:15:02,160 --> 00:15:07,120
עכשיו בואו להשהות שסיפור כי עכשיו
אני לא להמשיך לנוע למטה הסמן שלי.

304
00:15:07,120 --> 00:15:11,720
הסמן שלי עכשיו יורד פה כי
עכשיו לקבל int החיובי מבצע.

305
00:15:11,720 --> 00:15:13,100
Int n הוא הכריז.

306
00:15:13,100 --> 00:15:14,040
בצע את הפעולות הבאות.

307
00:15:14,040 --> 00:15:16,090
Printf נותן לי מספר שלם חיובי.

308
00:15:16,090 --> 00:15:19,740
>> קבל int מהמשתמש, לאחסן אותו בn,
ואולי לעשות את זה שוב ושוב.

309
00:15:19,740 --> 00:15:23,010
לולאה זה אומר שהקוד הזה עלול
לבצע למעלה ולמטה כמו זה שוב

310
00:15:23,010 --> 00:15:25,810
ושוב, אבל כאשר המשתמש סוף סוף
משתף פעולה ונותן לי חיובי

311
00:15:25,810 --> 00:15:31,750
int, אני מכה קו 21, בשלב שבי
מספר הוא החזיר, ואשר אחד

312
00:15:31,750 --> 00:15:34,280
אני צריך להדגיש עכשיו?

313
00:15:34,280 --> 00:15:35,070
תשע.

314
00:15:35,070 --> 00:15:39,010
שליטה, כביכול, חוזרת
בשורה תשע.

315
00:15:39,010 --> 00:15:40,650
זו השורה שעכשיו בתשלום.

316
00:15:40,650 --> 00:15:43,250
>> אז זה מה שקורה בכל
הפעם מתחת למכסת המנוע, אבל

317
00:15:43,250 --> 00:15:46,480
כאשר יש לנו להשתמש בפונקציות כמו printf
או אפילו לקבל מחרוזת שמישהו אחר

318
00:15:46,480 --> 00:15:50,600
כתב לך, השליטה הייתה להיות הושיטה
שורת הקוד של אותו למישהו אחר

319
00:15:50,600 --> 00:15:51,290
בשורה אחרת השורה.

320
00:15:51,290 --> 00:15:53,770
זה פשוט לא היינו יכולים לראות את זה ואנחנו
לא ממש יכול לתאר אותו בזה

321
00:15:53,770 --> 00:15:57,620
התכנית בגלל שזה בחלק אחר
קובץ על הכונן הקשיח

322
00:15:57,620 --> 00:16:00,000
ללא ידיעתנו.

323
00:16:00,000 --> 00:16:02,100
אז בואו באמת לקמפל
ולהפעיל את זה עכשיו.

324
00:16:02,100 --> 00:16:03,890
>> הפוך חיובי.

325
00:16:03,890 --> 00:16:05,260
לקמפל, זה התקדמות.

326
00:16:05,260 --> 00:16:06,650
. / חיובי.

327
00:16:06,650 --> 00:16:08,020
תן לי את מספר שלם חיובי.

328
00:16:08,020 --> 00:16:08,800
בואו להיות קשה.

329
00:16:08,800 --> 00:16:10,430
1 שלילי.

330
00:16:10,430 --> 00:16:11,360
אפס.

331
00:16:11,360 --> 00:16:13,370
בואו ניתן לו 50.

332
00:16:13,370 --> 00:16:18,100
תודה על 50, וכן בקרה
עכשיו חזר.

333
00:16:18,100 --> 00:16:21,750
על כל שאלה, ולאחר מכן, ביום זה?

334
00:16:21,750 --> 00:16:23,180
כן?

335
00:16:23,180 --> 00:16:25,630
>> [לא ברור].

336
00:16:25,630 --> 00:16:26,130
>> אומר שוב.

337
00:16:26,130 --> 00:16:27,860
אה, שאלה טובה.

338
00:16:27,860 --> 00:16:31,100
אז אולי שמתם לב כי במקביל כאן
אני סוג של חיתוך בפינה.

339
00:16:31,100 --> 00:16:35,420
בקו 12, שאני אומר, לקבל int החיובי
מחזיר int, אלא על ידי אותו

340
00:16:35,420 --> 00:16:39,660
היגיון, זה עומד כיום על דעת כי ב
קו שש, אני אומר שתשואות עיקריות

341
00:16:39,660 --> 00:16:44,040
int, אבל מה שיש לנו לעולם לא
היה בכל התוכניות שלנו?

342
00:16:44,040 --> 00:16:46,470
אף פעם לא היו לנו אזכור של
מילת מפתח שיבה זו.

343
00:16:46,470 --> 00:16:49,970
>> אז מתברר כי ב-C, לפחות
הגרסה של זה שבו אנו משתמשים

344
00:16:49,970 --> 00:16:55,750
עשיתי בשנת 1999, מבחינה טכנית, זה
קורה לך באופן אוטומטי.

345
00:16:55,750 --> 00:16:59,300
בכל פעם שאתה מיישם את תכנית ואתה
ליישם פונקציה הנקראת ראשי,

346
00:16:59,300 --> 00:17:04,230
שהפונקציה תחזיר אפס על ידי
כברירת מחדל, אם אתה לא אומר אחרת,

347
00:17:04,230 --> 00:17:05,849
ואפס הוא רק מוסכמה.

348
00:17:05,849 --> 00:17:09,430
העולם מחזיר אפס ובכך
המציין כי הכל טוב,

349
00:17:09,430 --> 00:17:13,040
יעילות והשאיר אותנו עם ארבעה מליארד
דברים אפשריים שיכול ללכת

350
00:17:13,040 --> 00:17:17,530
לא נכון כך שאם אנחנו חוזרים אחד, כי
אולי מסמן קוד שפירוש זה

351
00:17:17,530 --> 00:17:18,310
דבר לא השתבש.

352
00:17:18,310 --> 00:17:20,589
אנחנו יכולים להחזיר שתיים, מה שאומר
דבר שני זה השתבש.

353
00:17:20,589 --> 00:17:23,440
אנחנו יכולים להחזיר את ארבעה מליארד, אשר
פירוש דבר שני זה השתבש.

354
00:17:23,440 --> 00:17:27,170
>> ואם עכשיו אתה חושב על עצמך
PC או Mac, אתם אולי זוכרים כי

355
00:17:27,170 --> 00:17:29,610
לפעמים אתה מקבל הודעות שגיאה מסתוריות
מתוכנה שאתה

356
00:17:29,610 --> 00:17:32,650
משתמש, ולפעמים יש לו אדם
תיאור ידידותי, אבל יש

357
00:17:32,650 --> 00:17:35,265
לעתים קרובות קוד או מספר
על המסך?

358
00:17:35,265 --> 00:17:37,800
אם זה לא מגיע למוח,
רק לפקוח עין על זה.

359
00:17:37,800 --> 00:17:40,790
זה בדרך כלל מה אלה
קודים מתייחסים.

360
00:17:40,790 --> 00:17:44,200
הם כלולים ב-Microsoft Word ו
תוכניות אחרות, כך שאם אתה קובץ

361
00:17:44,200 --> 00:17:48,850
דיווח באג עם החברה, אתה יכול
אומר להם, הו, יש לי מספר שגיאת 45.

362
00:17:48,850 --> 00:17:51,750
וחלק אחורי מתכנת בחברה
יכול להסתכל למעלה, כי בו או שלה

363
00:17:51,750 --> 00:17:54,940
קוד ואומרים, אה, זה בגלל שאני עשיתי
הבאג הזה ובגלל זה המשתמש

364
00:17:54,940 --> 00:17:56,240
קיבל הודעה זו.

365
00:17:56,240 --> 00:17:59,490
>> אבל בכנות, זה רק קצת
מסיח את הדעת וקצת משעמם

366
00:17:59,490 --> 00:18:02,130
להסיק כי, לפחות עלינו
כמה תוכניות הראשונות, ולכן יש לנו

367
00:18:02,130 --> 00:18:02,970
כבר השמטתו.

368
00:18:02,970 --> 00:18:07,450
אבל כל הזמן הזה בכל אחד משלך
פונקציות העיקרית יש לו בסתר זה

369
00:18:07,450 --> 00:18:11,600
קו נוסף באופן אוטומטי עבורך על ידי
מהדר, רק על ידי אמנה ל

370
00:18:11,600 --> 00:18:13,172
לחסוך לך קצת זמן.

371
00:18:13,172 --> 00:18:14,620
>> [לא ברור].

372
00:18:14,620 --> 00:18:16,250
>> אתה לא צריך לכלול אותו בראשי.

373
00:18:16,250 --> 00:18:16,700
זה בסדר.

374
00:18:16,700 --> 00:18:20,260
אתה צריך לכלול אותו אם היית
יישום פונקציה כזאת.

375
00:18:20,260 --> 00:18:22,850
אחרת שטוח הפונקציה
את לא יעבוד.

376
00:18:22,850 --> 00:18:24,480
אבל בראשי, זה לא הכרחי.

377
00:18:24,480 --> 00:18:28,450
בשבוע או שבועות, נתחיל לקבל
להרגל שברגע שאנחנו רוצים להתחיל

378
00:18:28,450 --> 00:18:29,690
מסמנים שגיאות.

379
00:18:29,690 --> 00:18:32,550
באמת שאלה טובה.

380
00:18:32,550 --> 00:18:36,880
>> הפסקה מילולית כל כך מהר להזכיר כי
ביום שישי הקרוב, אנחנו לא אוכלים צהריים

381
00:18:36,880 --> 00:18:39,980
כשלעצמו, אבל יהיו לנו ארוחת ערב עם
חלק מהתלמידים ואנשי צוות.

382
00:18:39,980 --> 00:18:42,940
אם ברצונך להצטרף אלינו, מרגיש
חופשי ללכת לcs50.net/rsvp.

383
00:18:42,940 --> 00:18:45,030
06:00 יום שישי הקרוב.

384
00:18:45,030 --> 00:18:47,990
שטח הוא, כמו תמיד, מוגבל, אבל אנחנו
להמשיך לעשות את אלה בכמעט

385
00:18:47,990 --> 00:18:51,420
בסיס שבועי אם החלל
נגמר השבוע.

386
00:18:51,420 --> 00:18:56,160
>> אז הסחרור המסוכן שהפסקנו על
יום שני היה שמייתרים יכולים למעשה

387
00:18:56,160 --> 00:19:00,520
להיות צמוד אליו, שרק אומר לך
יכול לקבל בתו הראשון,

388
00:19:00,520 --> 00:19:03,770
דמות שנייה, הדמות השלישית
וכן הלאה, כי אתה יכול

389
00:19:03,770 --> 00:19:07,860
יעילות חושב על מחרוזת, כמו
שלום, כמו להיות במקרה זה חמישה

390
00:19:07,860 --> 00:19:09,670
אותיות בתוך קופסאות.

391
00:19:09,670 --> 00:19:13,370
ואתה יכול לקבל בכל אחד מאלה
תיבות עם מה שעשה לנו תחביר

392
00:19:13,370 --> 00:19:15,230
להציג ביום שני?

393
00:19:15,230 --> 00:19:16,760
אלה סוגריים מרובעים
במקלדת.

394
00:19:16,760 --> 00:19:18,980
שנועד רק לעבור למיקום אפס.

395
00:19:18,980 --> 00:19:22,840
>> אנחנו מתחילים לספור על אפס, כך סוגר
אפס מסמל שעות, סוגר אחד

396
00:19:22,840 --> 00:19:25,170
מסמל דואר, וכן הלאה.

397
00:19:25,170 --> 00:19:28,490
ולכן כל הזמן שבו אנחנו כבר
באמצעות המיתרים והקלדת "שלום"

398
00:19:28,490 --> 00:19:31,250
ו" עולם ", ועל דברים אחרים
המסך, זה היה מאוחסן

399
00:19:31,250 --> 00:19:32,820
בתיבות מהסוג הזה.

400
00:19:32,820 --> 00:19:33,370
ותיקח ניחוש.

401
00:19:33,370 --> 00:19:37,470
מה משמעות של כל תיבה מייצגת פיזית
חלק פנימי של המחשב שלך?

402
00:19:37,470 --> 00:19:38,250
>> [לא ברור].

403
00:19:38,250 --> 00:19:39,150
>> סליחה?

404
00:19:39,150 --> 00:19:39,580
>> תווים.

405
00:19:39,580 --> 00:19:44,760
>> אז אופי, בוודאי במקרה
של מחרוזות, ואופי הוא פשוט

406
00:19:44,760 --> 00:19:46,800
שמונה סיביות או בית אחד.

407
00:19:46,800 --> 00:19:49,550
אז אתה כנראה לפחות במעורפל
מכיר את העובדה ש

408
00:19:49,550 --> 00:19:50,500
יש בזכרון מחשב.

409
00:19:50,500 --> 00:19:52,110
יש לו שני סוגים של זיכרון לפחות.

410
00:19:52,110 --> 00:19:54,810
אחד מהם הוא הדיסק הקשיח שבו אתה שומר
דברים באופן קבוע, וזה

411
00:19:54,810 --> 00:19:57,400
גדול בדרך כלל, כך שאתה יכול להיות סרטים
ומוסיקה וכן הלאה.

412
00:19:57,400 --> 00:20:04,010
>> אז יש לך סוג אחר של זיכרון
נקרא זיכרון RAM, R--M, גישה אקראית

413
00:20:04,010 --> 00:20:07,510
זיכרון, וזה הסוג של זיכרון
המשמש כאשר המחשב שלך הוא

414
00:20:07,510 --> 00:20:11,520
פועל, אבל אם אתה מאבד את כוח שלך או
מת סוללה, מה שמאוחסן

415
00:20:11,520 --> 00:20:15,300
בזכרון RAM נעלם אם אתה מאבד את כוח
לגמרי כי זה לא

416
00:20:15,300 --> 00:20:16,060
מתמשך.

417
00:20:16,060 --> 00:20:19,120
אתה בדרך כלל יש, בימים אלה,
הופעה שלו, שתי הופעות, אולי יותר.

418
00:20:19,120 --> 00:20:23,490
והיתרון של זיכרון RAM הוא שזה הרבה יותר
הרבה, הרבה יותר מהר מאשר דיסקים קשיחים

419
00:20:23,490 --> 00:20:27,390
או מצב מוצק גם מניע בימים אלה,
אבל זה בדרך כלל יקר יותר ולכן

420
00:20:27,390 --> 00:20:28,480
יש לך פחות מזה.

421
00:20:28,480 --> 00:20:32,400
>> אז השיחה של היום באמת מתייחסת
ל-RAM, זה סוג של זיכרון ש

422
00:20:32,400 --> 00:20:35,270
קיים רק בזמן שיש כוח
שמוזן לתוך המחשב שלך.

423
00:20:35,270 --> 00:20:40,530
לכן, כאשר אתה מקליד בH-E-L-L-O, Enter ב
המקלדת, H עומדת באחד

424
00:20:40,530 --> 00:20:44,550
בייט של זיכרון RAM, E הולכת ב
בתים נוספים של זיכרון RAM, וכך גם

425
00:20:44,550 --> 00:20:45,800
שאר המילה.

426
00:20:45,800 --> 00:20:49,010
אז זוכר מה היינו יכול
לעשות פעם האחרונה היה זה.

427
00:20:49,010 --> 00:20:53,940
תן לי ללכת קדימה ולפתוח את הקובץ
כי אנחנו נקראים string.c, ולהיזכר

428
00:20:53,940 --> 00:20:56,860
כי זה נראה קצת
משהו כזה.

429
00:20:56,860 --> 00:20:59,860
תן לי בעצם לחזור ולשנות
זה בדיוק מה שזה נראה,

430
00:20:59,860 --> 00:21:02,654
מחרוזת באורך של שעות.

431
00:21:02,654 --> 00:21:04,560
>> אז להסתכל על התכנית כאן.

432
00:21:04,560 --> 00:21:08,530
אנו כוללים ספריית CS50 כך
שאנחנו יכולים להשתמש מקבלים מחרוזת.

433
00:21:08,530 --> 00:21:11,400
אנו כוללים io.h הסטנדרטי
כדי שנוכל להשתמש בprintf.

434
00:21:11,400 --> 00:21:13,580
מדוע אנו כוללים string.h?

435
00:21:13,580 --> 00:21:16,980
זה היה חדש ביום שני.

436
00:21:16,980 --> 00:21:18,230
אז אנחנו רוצים אורך מחרוזת.

437
00:21:18,230 --> 00:21:19,090
Str leng.

438
00:21:19,090 --> 00:21:21,470
אנשים החליטו לפני שנים,
בואו פשוט להיות תמציתי.

439
00:21:21,470 --> 00:21:24,290
במקום לקרוא לזה "אורך מחרוזת,"
בואו נקראים לזה "רח נג" ולתת לי

440
00:21:24,290 --> 00:21:28,540
דמות עולם שבחוץ, ואז זה
מה שאנחנו מקבלים גישה לעם string.h.

441
00:21:28,540 --> 00:21:29,390
>> זה מוכר.

442
00:21:29,390 --> 00:21:30,320
זה מוכר.

443
00:21:30,320 --> 00:21:31,450
זה מוכר.

444
00:21:31,450 --> 00:21:32,370
זה קצת חדש.

445
00:21:32,370 --> 00:21:35,420
בקו 22 - ואנחנו נחזור
לזה, אך לעת עתה יודע -

446
00:21:35,420 --> 00:21:37,880
והיית יודע שזה רק מפני שיש
קראו את התיעוד או אם

447
00:21:37,880 --> 00:21:39,010
אתה יודע כבר C -

448
00:21:39,010 --> 00:21:41,510
מקבל מחרוזת לפעמים יכולה לפשל.

449
00:21:41,510 --> 00:21:45,130
אם המשתמש הוא באמת יריב או
לא משתף פעולה, והוא או היא פשוט

450
00:21:45,130 --> 00:21:49,450
לא יקליד דבר במקלדת או
סוגים כל כך הרבה במקלדת ש

451
00:21:49,450 --> 00:21:53,760
זה מציף את הזיכרון של המחשב,
בתאוריה, מקבל מחרוזת יכולה לחזור

452
00:21:53,760 --> 00:21:56,270
משהו אחר מאשר
מחרוזת של תווים.

453
00:21:56,270 --> 00:22:01,930
זה יכול להחזיר ערך מיוחד הנקרא
NULL בכל הכובעים, N-U-L-L, וזה

454
00:22:01,930 --> 00:22:03,390
רק מה שנקרא ערך זקיף.

455
00:22:03,390 --> 00:22:08,010
זה ערך מיוחד שמסמל
משהו רע שקרה במקרה זה.

456
00:22:08,010 --> 00:22:10,520
זהו העדר חוט.

457
00:22:10,520 --> 00:22:16,190
>> אז אני בודק null לכך שפשוט,
עוד סיפור קצר, וstr leng

458
00:22:16,190 --> 00:22:20,230
פונקציות אחרות שמגיעות עם C, אם
הם מצפים מחרוזת אבל אתה עובר אותם

459
00:22:20,230 --> 00:22:23,630
העדרו של מיתר, אם אתה עובר
שלהם null, המחשב או התכנית

460
00:22:23,630 --> 00:22:25,000
יהיה פשוט יתרסק על הסף.

461
00:22:25,000 --> 00:22:25,610
זה יהיה תלוי באוויר.

462
00:22:25,610 --> 00:22:27,250
זה יהיה לזרוק את הודעת שגיאה כלשהי.

463
00:22:27,250 --> 00:22:28,690
דברים רעים לא יקרה.

464
00:22:28,690 --> 00:22:31,130
גם אם זאת היא עדיין
לא מוגדר היטב -

465
00:22:31,130 --> 00:22:33,730
זה יהיה הגיוני יותר בשבוע או
שתיים - בקו 22, זה רק

466
00:22:33,730 --> 00:22:38,790
דוגמה לבדיקת שגיאות הגנה עצמית
רק במקרה אחד מתוך זמן

467
00:22:38,790 --> 00:22:42,040
מיליון משהו משתבש, ב
לפחות התכנית שלי לא תתרסק.

468
00:22:42,040 --> 00:22:45,960
>> אז אם זה לא עושה שווה משהו רע,
יש לי את זה ללולאה, וזה היה

469
00:22:45,960 --> 00:22:47,710
שבו היו לנו אחרים
יצירה חדשה של תחביר.

470
00:22:47,710 --> 00:22:51,580
יש לי ללולאה מiterating
אפס ועד לאורכו של ים.

471
00:22:51,580 --> 00:22:56,140
והנה, הייתי להדפיס את ים
סוגר לי, אבל למה אני משתמש% ג כל

472
00:22:56,140 --> 00:23:00,770
פתאום במקום% s אפילו
למרות שהים הוא מחרוזת?

473
00:23:00,770 --> 00:23:02,110
זה אופי, נכון?

474
00:23:02,110 --> 00:23:06,560
S הוא מחרוזת, אבל סוגר של משהו,
סוגר שלי שבו אני הוא אפס

475
00:23:06,560 --> 00:23:10,380
או אחד או שתיים, זה פרט
תו במחרוזת, וכן עבור

476
00:23:10,380 --> 00:23:14,970
ש, printf צריך להיות הודיע ​​כי
זה אכן אופי לצפות.

477
00:23:14,970 --> 00:23:18,096
>> ולאחר מכן זוכר, מה שעשה את זה
תכנית לעשות בעצם?

478
00:23:18,096 --> 00:23:19,848
>> הדפיס את זה בטורים.

479
00:23:19,848 --> 00:23:21,120
>> כן, בדיוק.

480
00:23:21,120 --> 00:23:24,990
זה פשוט הדפיס את המילה שאני מקליד ב
טור, תו אחד בכל שורה.

481
00:23:24,990 --> 00:23:26,190
אז בואו תראה את זה שוב.

482
00:23:26,190 --> 00:23:27,810
אז להפוך את המחרוזת.

483
00:23:27,810 --> 00:23:30,200
מלוקט על אישור. . / מחרוזת.

484
00:23:30,200 --> 00:23:35,560
תן לי להקליד בH-E-L-L-O, Enter, ו
אכן אני מקבל את זה, אחד בכל שורה.

485
00:23:35,560 --> 00:23:37,280
>> אז תן לי לעשות אופטימיזציה אחד כאן.

486
00:23:37,280 --> 00:23:40,240
אם אתה חושב על זה, במיוחד אם
אתה כבר מתוכנת בעבר, יש

487
00:23:40,240 --> 00:23:43,340
ניתן לטעון חוסר יעילות בקו 24.

488
00:23:43,340 --> 00:23:46,160
במילים אחרות, זה לא בהכרח
העיצוב הטוב ביותר.

489
00:23:46,160 --> 00:23:50,200
פשוט, לפחות ברגע שאתה
זוכר מה הוא str leng, אבל זה

490
00:23:50,200 --> 00:23:52,640
עושה משהו טיפשי שעלול להיות.

491
00:23:52,640 --> 00:23:54,863
מה זה יכול להיות?

492
00:23:54,863 --> 00:23:56,280
>> [לא ברור].

493
00:23:56,280 --> 00:23:56,800
>> בדיוק.

494
00:23:56,800 --> 00:24:00,340
זה בדיקה לאורכו של ים
בכל פעם שלמרות

495
00:24:00,340 --> 00:24:02,980
H-E-L-L-O הוא הולך תמיד
להיות חמישה תווים.

496
00:24:02,980 --> 00:24:05,490
בכל פעם שדרך לולאה זו,
חמישה לא משתנים.

497
00:24:05,490 --> 00:24:08,750
יכול להיות שאני להגדיל כולי, אבל מה
הוא אורכו של ים על כל

498
00:24:08,750 --> 00:24:09,690
איטרציה של לולאה זה?

499
00:24:09,690 --> 00:24:15,810
זה חמש, זה חמש, זה חמש, ו
עדיין אני בכל זאת שואל את זה

500
00:24:15,810 --> 00:24:18,320
שאלה שוב ושוב ושוב.

501
00:24:18,320 --> 00:24:20,750
עכשיו בכנות, המחשב הוא כל כך מחורבן
מהר, שאף אחד לא ישים לב אל

502
00:24:20,750 --> 00:24:23,780
הבדל במקרה זה, אבל סוגים אלה
של החלטות עיצוב עניות יכול

503
00:24:23,780 --> 00:24:28,330
מתחיל להוסיף את עצמו אם מהדר
לא לנסות לתקן את זה בשבילך אשר

504
00:24:28,330 --> 00:24:30,630
זה בדרך כלל לא, ב
לפחות במכשיר.

505
00:24:30,630 --> 00:24:31,540
>> אז אני הולך לעשות את זה.

506
00:24:31,540 --> 00:24:34,580
אני הולך להוסיף פסיק אחרי
המשתנה הראשון שלי, אני.

507
00:24:34,580 --> 00:24:37,310
אני הולך לתת לעצמי עוד
משתנה, קורא לזה N, רק על ידי

508
00:24:37,310 --> 00:24:41,330
כנס למספרים, ולאחר מכן אני
הולך להקצות n את הערך של מחרוזת

509
00:24:41,330 --> 00:24:42,530
אורכו של ים.

510
00:24:42,530 --> 00:24:46,060
ואז אני הולך לשנות
המצב שלי להיות מה?

511
00:24:46,060 --> 00:24:51,960
אני הולך לשנות את המצב שלי
לזמן שאני פחות מ n.

512
00:24:51,960 --> 00:24:55,700
>> אז עכשיו, כמה פעמים אני
בדיקת אורכו של ים?

513
00:24:55,700 --> 00:25:00,110
פעם אחת, אבל זה בסדר כדי לבדוק שאני נגד
n שוב ושוב כי עכשיו אלו

514
00:25:00,110 --> 00:25:03,170
ערכים לא ממש משתנים.

515
00:25:03,170 --> 00:25:06,020
עכשיו לעכשיו, רק יודע שכל פעם שאתה
לקרוא לפונקציה, יש קצת

516
00:25:06,020 --> 00:25:09,930
מעלינו, לא מספיק כדי להרתיע אותך
באמת אי פעם שימוש בפונקציות, אבל

517
00:25:09,930 --> 00:25:12,750
בוודאי כאשר יש שורת קוד
אוהב את זה - ואת הקווים יקבלו

518
00:25:12,750 --> 00:25:15,490
יותר מעניין לפני זמן רב - שבו
יש הזדמנות לחשוב, אם אני

519
00:25:15,490 --> 00:25:18,320
הקלד את הקוד הזה, כמה
פעמים יהיה זה ביצוע?

520
00:25:18,320 --> 00:25:20,950
אתה מתחיל לראות לאורך הזמן
ביצועים של התוכניות שלך יכולים

521
00:25:20,950 --> 00:25:21,660
אכן תשתנה.

522
00:25:21,660 --> 00:25:24,110
>> למעשה, אחד של הבעיה קובע שיש לנו
נעשה בשנים האחרונות כולל

523
00:25:24,110 --> 00:25:27,600
יישום, כפי שאתם אולי זוכרים מ
בשבוע שאפס, בודק איות, אבל

524
00:25:27,600 --> 00:25:31,380
בודק איות שנועדו לתמוך
מילון של 150,000 בתוספת

525
00:25:31,380 --> 00:25:32,860
מילים שאנחנו נותנים לך חבר 'ה.

526
00:25:32,860 --> 00:25:37,100
היית צריך לכתוב קוד שנטען
את המילים האלה לזיכרון RAM, כך לתוך

527
00:25:37,100 --> 00:25:40,700
תיבות כמו שראינו על מסך רגע
לפני, ומהר אז כמו שאתה

528
00:25:40,700 --> 00:25:43,740
יכול, אתה צריך להיות מסוגל לענות על
שאלה של הצורה, היא מילה זו

529
00:25:43,740 --> 00:25:44,280
שגוי?

530
00:25:44,280 --> 00:25:45,420
האם מילה זו שגויה?

531
00:25:45,420 --> 00:25:46,770
האם מילה זו שגויה?

532
00:25:46,770 --> 00:25:49,525
>> ובמשהו כזה מה שיש לנו
נעשה בשנים האחרונות הוא הפך אותו ל,

533
00:25:49,525 --> 00:25:53,500
אם כי בopt-in בסיס אופציונלי,
תחרות של מיני, לפיה

534
00:25:53,500 --> 00:25:59,470
תלמידים המשתמשים בזכרון RAM ופחות פחות
זמן, מחזורי CPU פחות, בסופו של

535
00:25:59,470 --> 00:26:02,640
מבעבע לראש קטן
לוח מנהיג או דירוג שאנחנו שמים על

536
00:26:02,640 --> 00:26:04,770
בדף הבית של הקורס כפי שיש לנו
נעשה בשנים האחרונות.

537
00:26:04,770 --> 00:26:08,100
אז שוב, לחלוטין לא חובה, אבל זה
מדבר אל הזדמנויות העיצוב

538
00:26:08,100 --> 00:26:11,250
שהם קדימה ברגע שאנחנו מתחילים
בנייה על גבי כמה מאלה

539
00:26:11,250 --> 00:26:14,010
אבני בניין בסיסי.

540
00:26:14,010 --> 00:26:16,780
>> אז תן לי לחזור לתרשים זה ל
רק לרגע ולחשוף קצת

541
00:26:16,780 --> 00:26:17,610
עוד משהו.

542
00:26:17,610 --> 00:26:21,400
זו אכן היא מחרוזת, ואנחנו כבר לקחנו
יתרון של כמה ספריות,

543
00:26:21,400 --> 00:26:25,150
io.h הסטנדרטי שיש -

544
00:26:25,150 --> 00:26:26,110
>> Printf.

545
00:26:26,110 --> 00:26:27,860
>> Printf, בין השאר.

546
00:26:27,860 --> 00:26:31,540
cs50.h, אשר מקבל int ולקבל מחרוזת
וכן הלאה, string.h, אשר

547
00:26:31,540 --> 00:26:32,570
היה לי str leng.

548
00:26:32,570 --> 00:26:34,800
אבל מתברר שיש עוד.

549
00:26:34,800 --> 00:26:38,540
למען האמת, יש המון המון כותרת
קבצים שמצהירים פונקציות

550
00:26:38,540 --> 00:26:43,320
לספריות, אבל ctype.h זה
באמת הולך להיות קצת

551
00:26:43,320 --> 00:26:46,900
יתרון משום שאני הולך
להמשיך וליישם אחד

552
00:26:46,900 --> 00:26:48,120
תכנית אחרת כאן.

553
00:26:48,120 --> 00:26:52,420
>> תן לי ללכת קדימה ולפתוח משהו
אני כתבתי מראש הנקרא

554
00:26:52,420 --> 00:26:55,750
capitalize.c, ובואו ניקח
תסתכל על איך זה עובד.

555
00:26:55,750 --> 00:27:00,340
שימו לב שאני משתמש בגרסה זו
שלו, שלושה קבצים מוכרים.

556
00:27:00,340 --> 00:27:04,110
שים לב שבשורה 18, אני
מקבל שורה של טקסט.

557
00:27:04,110 --> 00:27:07,660
הודעה בקו 21, בטענה שאני
את הקוד הבא הוא הולך

558
00:27:07,660 --> 00:27:12,170
לנצל ים, מה שמשתמש הקליד
ב, ואיך אני עושה את זה?

559
00:27:12,170 --> 00:27:13,300
ובכן, אני לוקח את -

560
00:27:13,300 --> 00:27:14,750
לקח מהפעם האחרונה -

561
00:27:14,750 --> 00:27:18,370
אני מכריז שאני וn וiterating
על התווים במחרוזת.

562
00:27:18,370 --> 00:27:22,720
ואז מה הוא בלוק של זה
קוד בקו 24 עד 27

563
00:27:22,720 --> 00:27:24,550
עושה במונחים של ההדיוט?

564
00:27:24,550 --> 00:27:27,766

565
00:27:27,766 --> 00:27:29,730
>> אותיות קטנות מכתב בחזרה.

566
00:27:29,730 --> 00:27:30,430
>> בדיוק.

567
00:27:30,430 --> 00:27:35,920
אם סוגר שלי - כך שאם i-ה
דמותו של ים, שהוא ספציפי

568
00:27:35,920 --> 00:27:40,220
char במחרוזת, הוא גדול יותר מאשר
או שווה לאותיות קטנות ו--

569
00:27:40,220 --> 00:27:42,670
זוכר שאמפרסנד כפול
מסמן ו--

570
00:27:42,670 --> 00:27:46,810
ואת אותה הדמות, של סוגר אני, היא
קטן או שווה לאותיות קטנות z,

571
00:27:46,810 --> 00:27:50,600
זה אומר שזה או B או C או
נקודה, נקודה, נקודה, או Z, שפירושו

572
00:27:50,600 --> 00:27:51,340
זה אותיות קטנות.

573
00:27:51,340 --> 00:27:52,900
מה אני רוצה לעשות במקרה זה?

574
00:27:52,900 --> 00:27:55,010
ובכן, אני יכול לעשות את זה במידה מסוימת
מסתוריות, אבל

575
00:27:55,010 --> 00:27:56,160
בואו להקניט את זה לגזרים.

576
00:27:56,160 --> 00:28:00,210
>> אני הולך להתקשר printf, מדפיס% ג
כי אני רוצה להדפיס מחדש את זה

577
00:28:00,210 --> 00:28:01,580
דמות על המסך.

578
00:28:01,580 --> 00:28:06,650
אז אני הולך לקחת את זה שאני סוגר,
דמות i-th בים, ולאחר מכן מדוע

579
00:28:06,650 --> 00:28:12,330
אני עושה את זה טריק קטן כאן,
אותיות קטנות הון מינוס?

580
00:28:12,330 --> 00:28:16,352
מה שהולך לתת לי
לי, באופן כללי?

581
00:28:16,352 --> 00:28:18,600
>> [לא ברור].

582
00:28:18,600 --> 00:28:19,390
>> בדיוק.

583
00:28:19,390 --> 00:28:20,860
אני לא ממש זוכר -

584
00:28:20,860 --> 00:28:24,390
זה היה 65 להון א 'אני לא ממש
זוכר מה אותיות קטנות היא,

585
00:28:24,390 --> 00:28:25,540
אבל לא משנה.

586
00:28:25,540 --> 00:28:26,580
המחשב יודע.

587
00:28:26,580 --> 00:28:30,380
אז באומרו, אותיות קטנות מינוס
הון, זה מוזר להיות

588
00:28:30,380 --> 00:28:33,530
הפחתת char אחד למשנו, אבל
מה הם תווים מתחת למכסת המנוע?

589
00:28:33,530 --> 00:28:34,520
הם פשוט מספרים.

590
00:28:34,520 --> 00:28:36,980
אז כל מה שהמספרים האלה הם,
לתת למחשב לזכור את זה

591
00:28:36,980 --> 00:28:38,240
ולא לי האדם.

592
00:28:38,240 --> 00:28:41,710
>> אז אותיות קטנות הון מינוס הוא
הולך לתת לי את הבדל.

593
00:28:41,710 --> 00:28:45,370
זה קורה להיות 32, וזה יהיה
במקרה של ב אותיות קטנות ובירה ב '

594
00:28:45,370 --> 00:28:45,930
וכן הלאה.

595
00:28:45,930 --> 00:28:47,710
הוא נשאר עקבי, תודה לאל.

596
00:28:47,710 --> 00:28:51,930
אז אני בעצם אומר, לקחת את
אותיות קטנות מכתב, לחסר את זה

597
00:28:51,930 --> 00:28:55,340
הבדל סטנדרטי, וכי
סוגר שאני בעצם s שינויים מ

598
00:28:55,340 --> 00:28:59,400
אותיות קטנות, כמובן, באותיות גדולות,
בלי באמת שיש לי לחשוב

599
00:28:59,400 --> 00:29:03,040
על או זוכרים, מה היו אלה
מספרים שדיברנו עליו, כאשר שמונה

600
00:29:03,040 --> 00:29:04,800
מתנדבים עלו על במה?

601
00:29:04,800 --> 00:29:08,800
עכשיו בינתיים, באחר, אם זה לא
אות קטנה, כפי שנקבע

602
00:29:08,800 --> 00:29:10,400
על ידי קו 24, רק להדפיס אותו.

603
00:29:10,400 --> 00:29:12,590
אני רק רוצה לגעת
דמויות שהיו

604
00:29:12,590 --> 00:29:14,410
למעשה מקור אותיות קטנות.

605
00:29:14,410 --> 00:29:15,150
>> אז בואו יראו את זה.

606
00:29:15,150 --> 00:29:17,400
הפוך לנצל.

607
00:29:17,400 --> 00:29:18,470
מלוקט, על אישור.

608
00:29:18,470 --> 00:29:19,730
. / לנצל.

609
00:29:19,730 --> 00:29:23,530
ותנו לי להקליד בH-E-L-L-O
באותיות קטנות, Enter.

610
00:29:23,530 --> 00:29:26,370
ושים לב שהיא מומרת
לאותיות רישיות.

611
00:29:26,370 --> 00:29:27,940
תנו לי לעשות את זה שוב עם
מילה אחרת.

612
00:29:27,940 --> 00:29:32,720
מה דעתך על D--V-I-D עם הראשון D
מהוון כשמו הוא בדרך כלל?

613
00:29:32,720 --> 00:29:33,560
Enter.

614
00:29:33,560 --> 00:29:34,870
שים לב שזה עדיין נכון.

615
00:29:34,870 --> 00:29:40,250
זה פשוט שoutputted ראשון ללא שינוי D
דרך שלבנות אחר.

616
00:29:40,250 --> 00:29:42,170
>> ולכן יש לזכור, אם כן,
כמה דברים כאן.

617
00:29:42,170 --> 00:29:45,060
אחד, אם תרצה אי פעם לבדוק את שני
תנאים בפעם אחת, שאתה יכול ואותם

618
00:29:45,060 --> 00:29:46,500
ביחד כמו שאנחנו חזו.

619
00:29:46,500 --> 00:29:49,900
אתה יכול להשוות את דמויות בדרך זו
ולטפל ביעילות בדמויות כמו

620
00:29:49,900 --> 00:29:53,050
מספרים, אבל בכנות, זה כל כך מחורבן
אף פעם לא נסתר אני הולך לזכור

621
00:29:53,050 --> 00:29:56,510
איך לבוא עם זה מהתחלה
ללא חשיבה דרכו די

622
00:29:56,510 --> 00:29:57,140
קצת זמן.

623
00:29:57,140 --> 00:30:00,590
>> האם לא יהיה זה יכול להיות נחמד אם מישהו
שם כתב את פונקציה שנקראת הוא

624
00:30:00,590 --> 00:30:05,390
תחתון שיכל לענות לי נכון או
שקר, הדמות הזאת היא אותיות קטנות?

625
00:30:05,390 --> 00:30:09,350
ובכן שמחתי, מי שכתב
ctype.h עשה בדיוק את זה.

626
00:30:09,350 --> 00:30:15,540
עזוב אותי לכאן ולהוסיף ctype לג
סוגים, ועכשיו תן לי ללכת לכאן ו

627
00:30:15,540 --> 00:30:18,820
לשכתב את הקו הזה באופן הבא.

628
00:30:18,820 --> 00:30:27,510
>> אז אם זה נקרא נמוך יותר, אני טוען, S
סוגרי, אז אני הולך למחוק

629
00:30:27,510 --> 00:30:29,400
שתי שורות אלה לחלוטין.

630
00:30:29,400 --> 00:30:32,570
אז עכשיו מישהו אחר, אני מקווה, כתבתי
פונקציה שנקראת היא נמוכה יותר, וזה

631
00:30:32,570 --> 00:30:36,250
מתברר שהם עשו והם הכריזו
זה חלק פנימי של ctype.h.

632
00:30:36,250 --> 00:30:39,480
ועכשיו אני הולך לעזוב את הקו 27
לבד, אני הולך לעזוב את הקו 31

633
00:30:39,480 --> 00:30:41,890
לבד, אבל שים לב כמה הרבה יש לי
הידק את הקוד שלי.

634
00:30:41,890 --> 00:30:42,690
עכשיו זה נקי יותר.

635
00:30:42,690 --> 00:30:47,250
זה פחות קשה להסתכל דרך
כי עכשיו את הפונקציה, יתר על כן, היא

636
00:30:47,250 --> 00:30:50,080
כך שם זה פשוט להפליא
עושה מה שהוא אומר.

637
00:30:50,080 --> 00:30:51,520
>> אז עכשיו אני הולך לשמור את זה.

638
00:30:51,520 --> 00:30:52,930
אני הולך להקטין את התצוגה.

639
00:30:52,930 --> 00:30:56,650
ובדיוק כמו בגרד יכול להיות לך
Booleans, ערכים בוליאניים נכונים או

640
00:30:56,650 --> 00:31:01,530
שקר, זה בדיוק מה שהוא
להפחית ביעילות תשואות.

641
00:31:01,530 --> 00:31:02,960
תן לי הידור מחדש.

642
00:31:02,960 --> 00:31:04,500
תן לי להפעיל מחדש.

643
00:31:04,500 --> 00:31:07,350
ועכשיו בואו ננסה את זה שוב,
H-E-L-L-O, Enter.

644
00:31:07,350 --> 00:31:07,970
זה די טוב.

645
00:31:07,970 --> 00:31:10,150
ולנסות את זה שוב, לוודא שאני
לא ידפוק משהו.

646
00:31:10,150 --> 00:31:11,670
שמהוון גם כן.

647
00:31:11,670 --> 00:31:14,190
>> אבל זה לא מספיק טוב, כי
דבר שני שאני אף פעם לא הולך

648
00:31:14,190 --> 00:31:19,090
זוכר, אלא אם כן אני עובד דרכו באמת
בזהירות על, יניח, הוא נייר

649
00:31:19,090 --> 00:31:19,920
הקו הארור הזה.

650
00:31:19,920 --> 00:31:23,450
האם לא יהיה זה נחמד אם היו
פונקציה שנקראת לעליונים?

651
00:31:23,450 --> 00:31:26,930
ובכן מסתבר שיש
הוא בctype.h גם כן.

652
00:31:26,930 --> 00:31:30,150
אני הולך קדימה, הקלד -

653
00:31:30,150 --> 00:31:31,340
תנו לי להביא את זה קו אחורי.

654
00:31:31,340 --> 00:31:36,430
במקום זה כאן, תן לי ללכת קדימה
ואומר, להחליף את ג%

655
00:31:36,430 --> 00:31:42,110
תוצאה של קריאה לפונקציה זו כדי
עליון בדמותו של ה-i-ים.

656
00:31:42,110 --> 00:31:45,430
ועכשיו שם לב שזה מתחיל
קצת מאוזנת.

657
00:31:45,430 --> 00:31:48,870
אני חייב לעקוב אחר כמה
סוגריים שנפתחתי ונסגר.

658
00:31:48,870 --> 00:31:50,050
>> אז עכשיו זה אפילו נקי יותר.

659
00:31:50,050 --> 00:31:53,460
עכשיו תכנית זו משתפרת ו
טוב יותר נועד לטעון כי זה

660
00:31:53,460 --> 00:31:56,450
הרבה, הרבה יותר קריא, אבל
זה לא בוא נתקן.

661
00:31:56,450 --> 00:31:57,600
הפוך לנצל.

662
00:31:57,600 --> 00:31:58,930
. / לנצל.

663
00:31:58,930 --> 00:32:03,220
H-E-L-L-O. בואו להפעיל אותו שוב,
D--V-I-D. אוקיי, אז אנחנו עדיין ב

664
00:32:03,220 --> 00:32:04,250
די צורה טובה.

665
00:32:04,250 --> 00:32:06,030
>> אבל עכשיו לעליון.

666
00:32:06,030 --> 00:32:09,720
אני מציע שיש עוד אחד
עידון שאנחנו יכולים לעשות שיהיה

667
00:32:09,720 --> 00:32:12,820
ממש נחמד, כי באמת יכול להדק
את הקוד הזה ובאמת לתת לנו חמש

668
00:32:12,820 --> 00:32:15,150
מתוך חמישה לעיצוב, למשל.

669
00:32:15,150 --> 00:32:16,510
מה יהיה נחמד להיפטר?

670
00:32:16,510 --> 00:32:20,770
ובכן, תראה כמה ארור ארוך בלוק של זה
קוד הוא רק כדי לעשות משהו פשוט.

671
00:32:20,770 --> 00:32:23,850
>> עכשיו כצד, כמו שיש לך
ראה בסופר הסעיף הזה בעבר

672
00:32:23,850 --> 00:32:27,570
בסוף השבוע, אתה לא צריך להקפיד
סוגריים מסולסלים, כאשר יש לך רק אחד

673
00:32:27,570 --> 00:32:32,180
שורת קוד, למרות שאנחנו הצענו
שמירה על אותם כך שהוא עושה הרבה

674
00:32:32,180 --> 00:32:36,190
יותר ברור, כמו בצורת U של Scratch
בלוקים, מה שבפנים של הסניף.

675
00:32:36,190 --> 00:32:40,170
אבל לא זה יהיה נחמד אם לעליון,
כאשר נתון הקלט שלה, הפך אותו ל

676
00:32:40,170 --> 00:32:44,730
אותיות גדולות אם זה לא, ומה יהיה
יהיה נפלא במקרה ההפוך, אם

677
00:32:44,730 --> 00:32:47,210
זה כבר אות גדול?

678
00:32:47,210 --> 00:32:49,620
רק להעביר אותו דרך
ולהשאיר אותו לבד.

679
00:32:49,620 --> 00:32:50,660
>> אז אולי הוא עושה את זה.

680
00:32:50,660 --> 00:32:52,990
אני יכול לנסות ורק מקווה
שזה, אבל תן לי

681
00:32:52,990 --> 00:32:54,450
להציג דבר אחד.

682
00:32:54,450 --> 00:32:57,440
במקום להשתמש מובנה במסוף זה
חלון כאן למטה, זוכר כי

683
00:32:57,440 --> 00:33:01,130
סמל שחור מרובע זה נותן לך
חלון מסוף גדול יותר שאני יכול מלא

684
00:33:01,130 --> 00:33:02,260
מסך אם אני רוצה?

685
00:33:02,260 --> 00:33:05,820
אז מתברר שהם סוג של מוזר
בשם, אבל יש את הדברים האלה שנקראים

686
00:33:05,820 --> 00:33:10,970
דפי man, דפים ידניים, גבר בקיצור,
ואני יכול לגשת אליהם על ידי

687
00:33:10,970 --> 00:33:14,515
הקלדת אדם -

688
00:33:14,515 --> 00:33:15,570
מה שאני רוצה להקליד?

689
00:33:15,570 --> 00:33:17,830
אדם העליון.

690
00:33:17,830 --> 00:33:21,090
>> ועכשיו שם לב אם קיים
לתפקד בתוך המחשב, ב

691
00:33:21,090 --> 00:33:23,970
מקרה זה מכשיר, שהוא רק
מערכת ההפעלה לינוקס, שזה הולך

692
00:33:23,970 --> 00:33:27,920
לתת לי סט סתום במקצת של
תפוקה, אבל לך תמצא לאורך זמן, כי

693
00:33:27,920 --> 00:33:31,720
זה תמיד מעוצב פחות או יותר
אותו כדי שתתחיל להתרגל לזה.

694
00:33:31,720 --> 00:33:35,130
שימו לב שבחלק העליון לעליון, ו
ככל הנראה הוא אותו התיעוד

695
00:33:35,130 --> 00:33:35,680
ללהנמיך.

696
00:33:35,680 --> 00:33:38,740
מי שכתב אותו היה חיתוך חלק
פינות ולשים את הכל בעמוד אחד.

697
00:33:38,740 --> 00:33:40,720
המטרה 'את הדברים האלה ב
חיים הוא להמיר

698
00:33:40,720 --> 00:33:42,780
מכתב לעליון או אותיות קטנות.

699
00:33:42,780 --> 00:33:46,290
>> שים לב כי על פי תקציר, דף האדם
הוא מלמד אותי את מה שיש לי קובץ

700
00:33:46,290 --> 00:33:48,130
לכלול להשתמש בדבר הזה.

701
00:33:48,130 --> 00:33:51,320
זה נותן לי את חתימות לאלה
פונקציות, שניהם, ואפילו

702
00:33:51,320 --> 00:33:53,510
למרות שכרגע אנחנו רק
אכפת אחד.

703
00:33:53,510 --> 00:33:54,730
הנה עכשיו תיאור.

704
00:33:54,730 --> 00:33:58,800
לעליונים ממיר את האות
ג לאותיות גדולים, אם אפשר.

705
00:33:58,800 --> 00:34:02,280
>> ובכל זאת לא כל כך מאלף, אבל תן לי
נראה כעת תחת ערך החזרה, הדבר

706
00:34:02,280 --> 00:34:03,520
מה שהחזיר.

707
00:34:03,520 --> 00:34:08,600
אז הוא הערך המוחזר של
מכתב או ג יומר אם

708
00:34:08,600 --> 00:34:09,870
המרה לא הייתה אפשרית.

709
00:34:09,870 --> 00:34:11,202
מהו ג?

710
00:34:11,202 --> 00:34:12,560
>> הדמות המקורית.

711
00:34:12,560 --> 00:34:15,370
>> אופי המקורי ואנחנו יודעים
כי על ידי, שוב הולך, עד

712
00:34:15,370 --> 00:34:19,179
תקציר, ומי שכתב את זה
פונקציה פשוט החליטה שהקלט

713
00:34:19,179 --> 00:34:22,909
לעליון ותחתון הוא רק כדי
באופן שרירותי הולך להיקרא ג.

714
00:34:22,909 --> 00:34:24,909
הם יכלו לקרוא לזה משהו ביותר
הם רוצים, אבל הם שמרו את זה

715
00:34:24,909 --> 00:34:26,270
פשוט כמו ג.

716
00:34:26,270 --> 00:34:27,880
אז אני כבר התייעצתי דף האדם.

717
00:34:27,880 --> 00:34:31,870
משפט זה מרגיע אותי שאם
זה לא אות קטנה, זה

718
00:34:31,870 --> 00:34:34,969
הולך רק כדי להחזיר לי את C, שהוא
מושלם, מה שאומר שאני יכול להיפטר

719
00:34:34,969 --> 00:34:36,199
המצב אחר שלי.

720
00:34:36,199 --> 00:34:39,679
>> אז תן לי לחזור לgedit, ו
עכשיו תן לי רק לעשות את זה.

721
00:34:39,679 --> 00:34:41,960
אני הולך להעתיק הצהרת printf שלי.

722
00:34:41,960 --> 00:34:45,969
אני הולך קדימה, וממש בתוך
להדפסת לולאה שיצאה, ולקבל

723
00:34:45,969 --> 00:34:48,760
להיפטר מכל זה עכשיו אם מבנה.

724
00:34:48,760 --> 00:34:51,860
היה רעיון לא רע, וזה היה מאוד
נכון ועולה בקנה אחד עם הרבה

725
00:34:51,860 --> 00:34:54,100
כל מה שהטפנו,
אבל פשוט אין צורך.

726
00:34:54,100 --> 00:34:57,070
ברגע שאתה מבין כמה ספרייה
פונקציה קיימת שמישהו אחר

727
00:34:57,070 --> 00:35:01,340
כתב, או אולי אתה כתב במקום אחר ב
את הקובץ, אתה יכול להשתמש בו ובאמת

728
00:35:01,340 --> 00:35:02,690
להתחיל להדק את הקוד.

729
00:35:02,690 --> 00:35:06,080
>> וכשאני אומר את דברים כמו סגנון טוב,
העובדה שהאדם הזה שנקרא

730
00:35:06,080 --> 00:35:11,490
תפעל לעליון, או בעבר הוא
נמוך להפליא שימושי כי

731
00:35:11,490 --> 00:35:12,900
הם מאוד תיאורי.

732
00:35:12,900 --> 00:35:16,120
לא היית רוצה לקרוא לפונקציות שלך
X ו-Y ו-Z, שיש לי

733
00:35:16,120 --> 00:35:19,620
הרבה, הרבה פחות משמעות.

734
00:35:19,620 --> 00:35:25,160
כל שאלות על סדרה ש
שיפורים?

735
00:35:25,160 --> 00:35:28,010
>> אז די לומר אחד
מזנונים הוא אפילו כבעיה שלך

736
00:35:28,010 --> 00:35:30,960
סט - אולי בעיה סט אחד, אבל
בהחלט P להגדיר שתיים והלאה, אפילו

737
00:35:30,960 --> 00:35:34,380
כשהם לא בהכרח נכונים
אומר שהם פשוט מושלמים

738
00:35:34,380 --> 00:35:36,155
עדיין או במיוחד מעוצב היטב.

739
00:35:36,155 --> 00:35:38,420
זה ציר האחר
להתחיל לחשוב על.

740
00:35:38,420 --> 00:35:41,730
אז זה היה בתוך מחרוזת שלך
הזיכרון של המחשב, אבל אם יש לך

741
00:35:41,730 --> 00:35:46,180
חבורה שלמה של דמויות כמו H-E-L-L-O
חלק פנימי של זיכרון RAM, ומניח

742
00:35:46,180 --> 00:35:51,330
כי אתה בתכנית שלך קורא את המחרוזת
מספר פעמים כזה שאתה

743
00:35:51,330 --> 00:35:54,200
קורא לקבל מחרוזת פעם אחת, אז אתה
קוראים לקבל מחרוזת שוב.

744
00:35:54,200 --> 00:35:55,880
ובכן, מה הולך
יקרה לאורך זמן?

745
00:35:55,880 --> 00:35:59,170
>> במילים אחרות, אם יש לך שורה של
קוד, גם אם מחוץ להקשרו, כמו

746
00:35:59,170 --> 00:36:02,120
מחרוזת של מקבל -

747
00:36:02,120 --> 00:36:02,960
בואו נעשינו את זה.

748
00:36:02,960 --> 00:36:05,270
שם המיתרים שווים מקבלים מחרוזת.

749
00:36:05,270 --> 00:36:08,590
אז נניח שהשורה של קוד נועדה
לשאול את המשתמש שלו או את שמה.

750
00:36:08,590 --> 00:36:14,580
השורה הבאה של קוד זה נועדה כדי לשאול
למשתמש שלו או של בית הספר שלה, ו

751
00:36:14,580 --> 00:36:15,920
הקו הזה הבא, וכן הלאה.

752
00:36:15,920 --> 00:36:18,150
נניח שאנחנו חוזרים ושואלים
המשתמש אחר ול

753
00:36:18,150 --> 00:36:19,750
מחרוזת עוד אחד ועוד.

754
00:36:19,750 --> 00:36:22,390
הם הולכים להישאר בזיכרון
באותו הזמן.

755
00:36:22,390 --> 00:36:24,280
אחד לא הולך להרביץ את השני.

756
00:36:24,280 --> 00:36:26,420
בית הספר הוא לא יחליף את השני.

757
00:36:26,420 --> 00:36:28,520
אבל לאן כולם
בסופו של זיכרון?

758
00:36:28,520 --> 00:36:32,030
>> ובכן, אם אנחנו מתחילים לצייר על המסך,
שבו אנו יכולים להשתמש בדבר הזה

759
00:36:32,030 --> 00:36:35,800
כאן כמו לוח וגיר, אם זה שחור
מלבן מייצג המחשב שלי

760
00:36:35,800 --> 00:36:39,800
זיכרון, אני הולך להתחיל באופן שרירותי
חילק אותו לריבועים קטנים,

761
00:36:39,800 --> 00:36:42,120
כל אחד מהם מייצג
ייט אחד של זיכרון.

762
00:36:42,120 --> 00:36:46,560
למען האמת, אם יש לך ג'יגה של זיכרון RAM
בימים אלה, יש לך מיליארדי בתים

763
00:36:46,560 --> 00:36:49,540
זיכרון במחשב שלך, אז
מיליארדים של ריבועים אלה.

764
00:36:49,540 --> 00:36:52,110
אז די אם נאמרתי, זה
הוא לא באמת בקנה המידה.

765
00:36:52,110 --> 00:36:58,250
>> אבל אנחנו יכולים לשמור על ציור כל אלה
ברור שלא בקנה מידת ריבועים, וזה

766
00:36:58,250 --> 00:37:01,260
ביחד מייצג
הזיכרון של המחשב שלי.

767
00:37:01,260 --> 00:37:03,136
עכשיו אנחנו רק נעשה נקודה, נקודה, נקודה.

768
00:37:03,136 --> 00:37:06,260
אז במילים אחרות, כשאני עכשיו תבקש
משתמש עם מחרוזת להגיע ללתת לי

769
00:37:06,260 --> 00:37:07,350
מחרוזת, מה קורה?

770
00:37:07,350 --> 00:37:14,270
אם המשתמש מקליד ב" שלום, "כי בסופו
בH-E-L-L-O. אבל נניח

771
00:37:14,270 --> 00:37:15,720
משתמש אז בסוגים -

772
00:37:15,720 --> 00:37:17,250
למעשה, אני לא הייתי צריך לעשות
שלום בגלל שאנו מבקשים

773
00:37:17,250 --> 00:37:18,330
אותם לשמות שלהם.

774
00:37:18,330 --> 00:37:20,580
אז בואו נחזור אם אני יכול לעשות את זה.

775
00:37:20,580 --> 00:37:26,130
>> אז אם אני בסוג D--V-I-D לשם שלי,
אבל לזכור כי בשורה השנייה של

776
00:37:26,130 --> 00:37:29,220
קוד שיקבל מחרוזת שוב
כדי לקבל את הספר שלהם.

777
00:37:29,220 --> 00:37:32,090
איפה מילה שהמשתמש
סוגים בהולכים הבא?

778
00:37:32,090 --> 00:37:38,290
טוב, אולי זה הולך להיכנס
H--R-V--R-D. אז למרות שיש לי

779
00:37:38,290 --> 00:37:41,560
נמשך זה כשתי שורות, זה רק
חבורה שלמה של בתים בך

780
00:37:41,560 --> 00:37:42,710
זיכרון RAM של המחשב.

781
00:37:42,710 --> 00:37:46,560
יש בעיה עכשיו, כי עכשיו אם אני
שימוש בזיכרון RAM בזה סביר מאוד

782
00:37:46,560 --> 00:37:49,910
אבל סוג של דרך תמימה, מה אתה יכול
לא להבחין ככל הנראה?

783
00:37:49,910 --> 00:37:52,640

784
00:37:52,640 --> 00:37:54,680
איפה אחד מתחיל ואיפה
אחד מסתיים, נכון?

785
00:37:54,680 --> 00:37:55,860
הוא סוג של טשטוש יחד.

786
00:37:55,860 --> 00:37:57,920
>> אז מתברר המחשב
לא לעשות את זה.

787
00:37:57,920 --> 00:38:04,720
תנו לי בעצם לגלול אחורה בזמן
כמה תווים, ובמקום הרווארד

788
00:38:04,720 --> 00:38:09,570
הולך מייד אחרי שמו של המשתמש,
המשתמש מקבל למעשה, מאחורי

789
00:38:09,570 --> 00:38:12,000
הקלעים, אופי מיוחד
הוכנס על ידי

790
00:38:12,000 --> 00:38:13,885
מחשב בשבילו או שלה.

791
00:38:13,885 --> 00:38:19,470
/ 0, הידוע גם בתו הריק
מעצבן בשם N-U-L, לא

792
00:38:19,470 --> 00:38:22,190
N-U-L-L, אבל אתה כותב את זה כ/ 0.

793
00:38:22,190 --> 00:38:27,130
זה פשוט כל הביטים אפס הוא סמן ב
בין המילה הראשונה ש של המשתמש

794
00:38:27,130 --> 00:38:28,290
הקליד והשני.

795
00:38:28,290 --> 00:38:33,020
>> אז הרווארד מסתיימת ממש עכשיו את
כרצף של תווים

796
00:38:33,020 --> 00:38:36,110
ועוד אחד / 0.

797
00:38:36,110 --> 00:38:41,690
אז במילים אחרות, על ידי בעל אלה
ערכי סנטינל, שמונה אפס רציף

798
00:38:41,690 --> 00:38:45,220
ביטים, עכשיו אתה יכול להתחיל להבחין
תו אחד למשנהו.

799
00:38:45,220 --> 00:38:49,720
אז כל הזמן הזה מה שהיה "שלום" הוא
בעצם "שלום" עם / 0, ו

800
00:38:49,720 --> 00:38:53,580
בינתיים, מאוד ייתכן שגם
להיות די קצת יותר זיכרון RAM

801
00:38:53,580 --> 00:38:56,400
חלק פנימי של המחשב.

802
00:38:56,400 --> 00:38:57,810
>> תן לי לעשות דבר אחד עכשיו.

803
00:38:57,810 --> 00:39:01,800
מתברר שכל ריבועים אלה
אנחנו כבר ציור, הם, כן,

804
00:39:01,800 --> 00:39:06,140
מחרוזות, אבל באופן כללי יותר,
הדברים האלה הם מערכים.

805
00:39:06,140 --> 00:39:10,590
מערך הוא רק נתח של זיכרון
זה גב אל גב אל גב אל גב,

806
00:39:10,590 --> 00:39:15,130
ואתה משתמש בדרך כלל מערך בדרך
של סימון סוגר המרובע הזה.

807
00:39:15,130 --> 00:39:18,210
אז אנחנו הולכים לראות אותם לא מעט
לאורך זמן, אבל תן לי ללכת קדימה

808
00:39:18,210 --> 00:39:21,160
להיפתח, בואו נקראים לזה המון זמן.

809
00:39:21,160 --> 00:39:23,920
ושים לב למה שאנחנו יכולים לעשות עם
אלה קטנים אותם טריקים,

810
00:39:23,920 --> 00:39:25,750
קצת יותר תחביר כאן.

811
00:39:25,750 --> 00:39:29,270
>> אז בקו 17 של תכנית זו -
בעצם, תן לי להפעיל את התכנית ראשונה

812
00:39:29,270 --> 00:39:30,770
כדי שנוכל לראות מה הדבר הזה עושה.

813
00:39:30,770 --> 00:39:33,530
תנו לי להתקשר להפוך לגילים
לקמפל תכנית זו.

814
00:39:33,530 --> 00:39:34,950
גילים /..

815
00:39:34,950 --> 00:39:36,480
כמה אנשים בחדר?

816
00:39:36,480 --> 00:39:38,020
קוראים לזה שלוש.

817
00:39:38,020 --> 00:39:39,575
גילה של האדם הראשון?

818
00:39:39,575 --> 00:39:42,710
18, 19, ו -20.

819
00:39:42,710 --> 00:39:46,770
ועכשיו קצת מגוחך, אני פשוט
עשה תכנית שגילים אלו

820
00:39:46,770 --> 00:39:47,740
שלושה אנשים.

821
00:39:47,740 --> 00:39:50,390
>> אז יש באופן ברור הזדמנות
לקצת חשבון כיף כאן.

822
00:39:50,390 --> 00:39:51,560
למרבה המזל, המתמטיקה היא נכונה.

823
00:39:51,560 --> 00:39:54,720
18 הלכו ל19, 19 הלכו
עד 20 וכן הלאה.

824
00:39:54,720 --> 00:39:58,510
אבל מה שבאמת אמור להיות
המחשה כאן הוא איך אנחנו אחסון

825
00:39:58,510 --> 00:40:00,190
הגילים של אותם שלושה אנשים.

826
00:40:00,190 --> 00:40:02,370
תנו לי להתקרב במה
קורה כאן.

827
00:40:02,370 --> 00:40:06,240
>> אז קודם כל, כמה השורות הראשונות אלה צריכים
מקבל די מוכר.

828
00:40:06,240 --> 00:40:08,770
אני רק להציג הודעה למשתמש עבור
מספר האנשים בחדר.

829
00:40:08,770 --> 00:40:11,490
אז אני משתמש לקבל int ולעשות בזמן כדי
לעשות את זה שוב ושוב ושוב.

830
00:40:11,490 --> 00:40:15,780
ראינו את תבנית שלפני, אבל
קו 27 הוא חדש ולמעשה די

831
00:40:15,780 --> 00:40:18,160
שימושי, ויהפוך
יותר ויותר שימושי.

832
00:40:18,160 --> 00:40:21,620
שים לב כי מה שונה בקו 27
זה שאני מופיע להיות הכרזה

833
00:40:21,620 --> 00:40:23,960
int גילים שם, אבל חכה.

834
00:40:23,960 --> 00:40:27,140
זה לא רק גילים int.

835
00:40:27,140 --> 00:40:30,130
יש סוגריים המרובעים האלה,
בתוכה הוא n.

836
00:40:30,130 --> 00:40:35,150
>> אז n סוגר בהקשר זה, לא
בתוך הצהרת printf כאן, אבל

837
00:40:35,150 --> 00:40:44,370
בקו בלעדי זה 27, הקו הזה הוא
אמר, תן לי n ints, כל אחד מהם

838
00:40:44,370 --> 00:40:46,080
הוא מסוג int.

839
00:40:46,080 --> 00:40:49,870
אז זה דלי, כביכול, של,
במקרה הזה, שלושה שלמים חזרה ל

840
00:40:49,870 --> 00:40:52,770
גב אל גב, כך שאני ביעילות
יש שלוש משתנה.

841
00:40:52,770 --> 00:40:54,890
האלטרנטיבה, להיות
ברור, יהיה זו.

842
00:40:54,890 --> 00:40:57,400
>> אם אני רוצה של התלמיד הראשון
גיל, אני יכול לעשות את זה.

843
00:40:57,400 --> 00:40:59,520
אם אני רוצה של התלמיד השני
גיל אני יכול לעשות את זה.

844
00:40:59,520 --> 00:41:01,860
אם אני רוצה של התלמיד השלישי
גיל, אני יכול לעשות את זה.

845
00:41:01,860 --> 00:41:04,320
וחס וחליל שאנחנו צריכים כולם
גיל בחדר הזה -

846
00:41:04,320 --> 00:41:07,670
אני מתכוון, זה לעזאזל של הרבה של עותק,
להדביק שוב ושוב ושוב.

847
00:41:07,670 --> 00:41:10,870
ועוד פעם אחת אני לקמפל תכנית זו,
אם תלמיד אחר נכנס מעל החוצה

848
00:41:10,870 --> 00:41:14,200
מהדלת הזאת, עכשיו את המספר שלי
של משתנים אינו נכונה.

849
00:41:14,200 --> 00:41:17,450
>> אז מה שיפה הוא שמערך
ברגע שאתה מתחיל להרגיש את עצמך

850
00:41:17,450 --> 00:41:20,190
העתקה והדבקה, סיכויים הם שזה
לא הגישה הטובה ביותר.

851
00:41:20,190 --> 00:41:22,240
מערך הוא דינמי שעלול להיות.

852
00:41:22,240 --> 00:41:24,610
אני לא יודע בכמה אנשים מראש
הולכים להיות בחדר,

853
00:41:24,610 --> 00:41:28,670
אבל אני יודע שאני צריך n שלהם, ואני יהיה
להבין n בבוא העת.

854
00:41:28,670 --> 00:41:35,500
קו זה של קוד עכשיו אומר, תן לי
נתח של זיכרון שנראה כך

855
00:41:35,500 --> 00:41:40,380
שבו מספר התיבות על המסך
הוא תלוי לחלוטין בn כי

856
00:41:40,380 --> 00:41:42,010
משתמש הקליד פנימה

857
00:41:42,010 --> 00:41:44,850
>> אז עכשיו את שארית של תכנית זו היא
בעצם די דומה למה שאנו

858
00:41:44,850 --> 00:41:46,860
פשוט עשיתי עם דמויות.

859
00:41:46,860 --> 00:41:49,970
שימו לב שיש לי ללולאה
מתחיל בקו 30.

860
00:41:49,970 --> 00:41:54,920
אז מייד אחרי שאני מקבל את המערך, אני
לחזר מY שווה אפס בעד n.

861
00:41:54,920 --> 00:41:58,890
אני רק צריך מאלף printf זה
הודעה רק אומרת, תן לי הגיל

862
00:41:58,890 --> 00:42:03,690
של אדם #% i, כך מספר אחד,
מספר שתיים, מספר שלוש.

863
00:42:03,690 --> 00:42:04,730
ולמה אני עושה את זה?

864
00:42:04,730 --> 00:42:08,870
למען האמת, בני אדם מעדיפים לספור מאחד
בעד ואילו מדעני מחשב,

865
00:42:08,870 --> 00:42:09,620
אפס על למעלה.

866
00:42:09,620 --> 00:42:11,700
מדעני מחשב לא הולכים
להשתמש בתכנית מסוג זה, כך שאנחנו

867
00:42:11,700 --> 00:42:13,990
הולך רק כדי להתחיל לספור
באחד כמו אנשים נורמלים.

868
00:42:13,990 --> 00:42:17,630
>> ועכשיו בקו 33, תבחין במקצת
פיסה אחרת של תחביר.

869
00:42:17,630 --> 00:42:23,710
גיל ה-i במשתנה שמהסוג
מערך הוא הולך לקבל int.

870
00:42:23,710 --> 00:42:25,770
ועכשיו סוף סוף, זה רק
חשבון כאן למטה.

871
00:42:25,770 --> 00:42:29,200
החלטתי בלולאה נפרדת לתבוע
כמה זמן עובר, ועכשיו בזה

872
00:42:29,200 --> 00:42:31,400
לולאה נפרדת, שורות אלה לבצע.

873
00:42:31,400 --> 00:42:35,810
>> שנה מיום, אדם שאני יהיה אני
שנים, אבל שם לב שזה לא

874
00:42:35,810 --> 00:42:36,500
משתנה לי.

875
00:42:36,500 --> 00:42:38,390
זהו עכשיו אני% עבור int.

876
00:42:38,390 --> 00:42:43,210
והודעה כמציין המיקום הראשון, אני
התוספת שבתוספת 1, ולכן אנו סופרים כמו

877
00:42:43,210 --> 00:42:44,250
אדם נורמלי.

878
00:42:44,250 --> 00:42:49,190
ולאחר מכן לשווי של גילם, ל
אני בן, אני לוקח את סוגר גילים

879
00:42:49,190 --> 00:42:52,980
אני - ולמה אני עושה ועוד אחד כאן?

880
00:42:52,980 --> 00:42:53,760
הם פשוט הזדקנו.

881
00:42:53,760 --> 00:42:55,030
זו הבחירה שלי המטופשת של תוכניות.

882
00:42:55,030 --> 00:42:56,810
הם רק בני שנה אחת.

883
00:42:56,810 --> 00:42:59,770
אני יכול להקליד כל מספר ש
למעשה אני רוצה שם.

884
00:42:59,770 --> 00:43:02,430
>> אז מה בעצם כל
רלוונטיות כאן?

885
00:43:02,430 --> 00:43:07,610
ובכן, הרשה לי בעצם לגלול אחורה
כאן ומצייר תמונה

886
00:43:07,610 --> 00:43:10,830
של מה שלפנינו.

887
00:43:10,830 --> 00:43:15,720
מה יהיה לנו לעשות עם הבא שלנו
סט שתי בעיה הוא מתעסק ב

888
00:43:15,720 --> 00:43:17,070
עולם של הצפנה.

889
00:43:17,070 --> 00:43:22,500
אז זה הוא מחרוזת של תווים, ולכן
רצף של תווים מרובים, ומה

890
00:43:22,500 --> 00:43:23,750
זה אומר?

891
00:43:23,750 --> 00:43:28,530

892
00:43:28,530 --> 00:43:30,600
זה לא בגרסה המקוונת
של השקופיות.

893
00:43:30,600 --> 00:43:35,880
>> אז אני טוען שזה שווה את זה,
פרסומת טיפשית משנים רבות

894
00:43:35,880 --> 00:43:39,950
לפני שבאמת עשוי להיזכר
אחד ממקורותיו.

895
00:43:39,950 --> 00:43:42,740
אז זו דוגמה להצפנה
או הצפנה.

896
00:43:42,740 --> 00:43:46,150
מסתבר שאם אתה רוצה
בעצם לשלוח מידע או לשתף

897
00:43:46,150 --> 00:43:49,310
מידע עם מישהו באופן מאובטח,
כמו הודעה כזאת, אתה יכול

898
00:43:49,310 --> 00:43:50,500
לטרוף את המכתבים.

899
00:43:50,500 --> 00:43:53,170
אבל בדרך כלל, המילים הן
לא מקושקשת באופן אקראי.

900
00:43:53,170 --> 00:43:56,365
הם permuted בדרך כלשהי או השתנו
בדרך כלשהי, כך ש-- אופס.

901
00:43:56,365 --> 00:43:59,040
זה ספוילר כיף לפעם הבאה.

902
00:43:59,040 --> 00:44:04,390
>> אז אתה יכול למפות את מה שהוא ככל הנראה
O להודעה ב 'שקווים עד

903
00:44:04,390 --> 00:44:05,420
מבחינת שווי.

904
00:44:05,420 --> 00:44:07,960
ככל הנראה R הופך דואר.

905
00:44:07,960 --> 00:44:14,000
ככל הנראה, ה-F-H-E-R הופך S-U-R-E. כך
מתברר שיש מיפוי, ובשינה

906
00:44:14,000 --> 00:44:18,720
מקרה זה יש די טיפשי
מיפוי אם מישהו הבין את זה?

907
00:44:18,720 --> 00:44:21,440
זה משהו שנקרא
רוט 13, סובב 13.

908
00:44:21,440 --> 00:44:24,760
זה הטיפשי ביותר של הצפנה
מנגנונים כי זה ממש פשוט

909
00:44:24,760 --> 00:44:29,160
מוסיף 13 לכל אחד מהמכתבים,
טיפשים במובן זה שאם אתה רק

910
00:44:29,160 --> 00:44:31,890
יש קצת זמן פנוי על ידי שלך
ועיפרון, או שאתה פשוט חושב שזה

911
00:44:31,890 --> 00:44:35,260
דרך בראש שלך, אתה יכול לנסות
כל תוספות האפשריות - אחד, שתיים,

912
00:44:35,260 --> 00:44:38,470
שלוש, נקודה, נקודה, נקודה, 25 רק
לסובב את כל האותיות, ו

913
00:44:38,470 --> 00:44:40,860
סופו של דבר, יהיה עליך להבין
מה היא הודעה זו.

914
00:44:40,860 --> 00:44:43,700
אז אם אתה עשית משהו כזה ב
בית הספר יסודי להעברת מסרים שלך

915
00:44:43,700 --> 00:44:46,830
חברו הטוב ביותר, אם בבית הספר היסודי שלך
מורה פשוט לקרוא

916
00:44:46,830 --> 00:44:50,320
הודעה וזרוע אילץ את הפתרון,
יש לך אולי קיבל

917
00:44:50,320 --> 00:44:52,550
תשובה על ידי זה.

918
00:44:52,550 --> 00:44:54,970
>> עכשיו כמובן, בעולם האמיתי,
ההצפנה היא מתוחכמת יותר.

919
00:44:54,970 --> 00:45:00,120
זהו קטע טקסט מ
מערכת מחשב שיש לו שמות משתמש ו

920
00:45:00,120 --> 00:45:03,630
סיסמאות, כפי שכמעט כולנו עושות, ו
זה מה שאולי את הסיסמה שלך

921
00:45:03,630 --> 00:45:07,260
נראה אם ​​מאוחסן בך קשה
אבל לנהוג בצורה מוצפנת.

922
00:45:07,260 --> 00:45:11,050
זה לא רק סיבוב של מכתבים,
הוא B ו-B הוא C. זה הוא

923
00:45:11,050 --> 00:45:15,620
הרבה יותר מתוחכם, אבל הוא משתמש
מה שידוע בדרך כלל כמפתח סודי

924
00:45:15,620 --> 00:45:16,690
הצפנה.

925
00:45:16,690 --> 00:45:20,210
התמונה הזאת אומרת לי הבאה
סיפור עם כמה סמלים.

926
00:45:20,210 --> 00:45:22,250
>> בצד השמאל, יש לנו מה
אנחנו קוראים לטקסט רגיל.

927
00:45:22,250 --> 00:45:25,420
בעולם של קריפטוגרפיה, רגיל
טקסט הוא רק ההודעה המקורית

928
00:45:25,420 --> 00:45:29,050
נכתב באנגלית או בצרפתית
או בכל שפה שהיא.

929
00:45:29,050 --> 00:45:32,405
אם ברצונך להצפין אותו, נצטרך לעבור
זה ציורי דרך מנעול, ולכן

930
00:45:32,405 --> 00:45:35,580
סוג מסוים של של אלגוריתם, תפקיד כלשהו
או תכנית שמישהו כתב

931
00:45:35,580 --> 00:45:39,880
כי טורף בתקווה האותיות
יותר מאשר רק אופן מורכב והוסיף 13

932
00:45:39,880 --> 00:45:40,980
לכל אחד מהם.

933
00:45:40,980 --> 00:45:43,780
>> מה לך לצאת מזה בתהליך
המרכז שם נקרא cyphertext.

934
00:45:43,780 --> 00:45:44,850
אז סוג של מילה סקסית.

935
00:45:44,850 --> 00:45:47,630
זה רק אומר שזה מוצפן
גרסה של הטקסט רגיל.

936
00:45:47,630 --> 00:45:52,570
ורק אם יש לך אותו סוד,
13 או מינוס 13, אתה מסוגל

937
00:45:52,570 --> 00:45:54,970
לפענח מסר כזה.

938
00:45:54,970 --> 00:45:57,770
>> אז בבעיה להגדיר שתי, בין הדברים
תעשה אם בהאקר

939
00:45:57,770 --> 00:46:01,860
מהדורה, תצטרך לכתוב קוד כדי
לפצח סיסמאות האלה, להבין

940
00:46:01,860 --> 00:46:05,170
מה שהם היו ואיך הם היו
מוצפן, למרות שאנחנו עושים לך קצת

941
00:46:05,170 --> 00:46:06,460
של הדרכה לאורך הדרך.

942
00:46:06,460 --> 00:46:09,320
במהדורה רגילה, אנחנו מציגים
כמה צפנים, הצפנה

943
00:46:09,320 --> 00:46:12,400
מנגנונים, אחד בשם קיסר, אחד
קראתי Vigenere, שעדיין

944
00:46:12,400 --> 00:46:16,100
צופן סיבוב שבו הופך
משהו ', ב' הופך להיות משהו, אבל

945
00:46:16,100 --> 00:46:18,820
אתה צריך לעשות את זה באמצעות תכנות
כי יש אכן יהיה סוד

946
00:46:18,820 --> 00:46:22,840
מפתח המעורב שהוא בדרך כלל מספר
או מילת מפתח שרק

947
00:46:22,840 --> 00:46:26,420
שולח והנמען של אלה
מסרים צריכים להבין.

948
00:46:26,420 --> 00:46:28,660
>> עכשיו, יש לזה ממש גלגולים
בעולם האמיתי.

949
00:46:28,660 --> 00:46:32,910
זו, למשל, היא יתום קטן
הטבעת של אנני סוד מפענח, ואתה

950
00:46:32,910 --> 00:46:35,180
למעשה אלה יכולים ליישם
צופן סיבוב -

951
00:46:35,180 --> 00:46:37,930
הופך למשהו ', ב' הופך להיות
משהו - עם כמה גלגלים,

952
00:46:37,930 --> 00:46:40,840
אחד בחוץ, אחד בפנים
כך שאם אתה מסובב את הגלגל או

953
00:46:40,840 --> 00:46:44,170
הטבעת, למעשה אתה יכול להסתדר בשורה
אותיות עם אותיות שונות,

954
00:46:44,170 --> 00:46:45,430
מקבל קוד סודי.

955
00:46:45,430 --> 00:46:48,110
וכך, כסחרור מסוכן להיום,
מה חשבתי שאני רוצה לעשות הוא קצת

956
00:46:48,110 --> 00:46:52,170
נסיגה שאם אתה מדליק את טלוויזיה
ב -24 בדצמבר, אתה יכול לצפות

957
00:46:52,170 --> 00:46:55,390
עד זרא לסרט
24 שעות ברציפות.

958
00:46:55,390 --> 00:47:06,030
אבל היום, אני אפתח את זה כאן
ולתת לנו רק שתי דקות

959
00:47:06,030 --> 00:47:13,493
סיפור חג המולד פדגוגי רלוונטי
עם בחור קטן בשם ראלפי.

960
00:47:13,493 --> 00:47:14,400
>> [השמעת וידאו]

961
00:47:14,400 --> 00:47:17,420
>> -אם זה ידוע לכל ומשונים ש
ראלף פארקר מתמנה בזאת

962
00:47:17,420 --> 00:47:20,650
חבר של היתומה הקטנה אנני הסוד
המעגל והוא זכאי לכל

963
00:47:20,650 --> 00:47:23,460
הכיבודים וההטבות
התרחשות שהוכנסו בו.

964
00:47:23,460 --> 00:47:25,990
>> על החתום,, יתומה הקטנה אנני.

965
00:47:25,990 --> 00:47:30,100
תשובה, פייר אנדרה בדיו.

966
00:47:30,100 --> 00:47:34,270
כיבודים והטבות שכבר
בגיל תשע.

967
00:47:34,270 --> 00:47:39,440
>> [צועק ברדיו]

968
00:47:39,440 --> 00:47:40,770
>> יאללה, בואו נגמור עם זה.

969
00:47:40,770 --> 00:47:44,965
אני לא צריך את כל זה על ג'אז
מבריחים ופירטים.

970
00:47:44,965 --> 00:47:48,270
>> תקשיב, מחר בלילה ל
הרפתקה מסכמת של שחור

971
00:47:48,270 --> 00:47:49,650
ספינת פירטים.

972
00:47:49,650 --> 00:47:53,320
עכשיו, הגיע זמן לסוד של אנני
מסר בשבילך חברים

973
00:47:53,320 --> 00:47:55,720
המעגל הסודי.

974
00:47:55,720 --> 00:47:56,580
זכור, ילדים.

975
00:47:56,580 --> 00:48:01,720
רק חברי המעגל הסודי של אנני
יכול לפענח המסר הסודי של אנני.

976
00:48:01,720 --> 00:48:05,872
זכרו, אנני היא תלוי בך.

977
00:48:05,872 --> 00:48:08,670
הגדרה שלך לסיכות B2.

978
00:48:08,670 --> 00:48:11,000
כאן הוא המסר.

979
00:48:11,000 --> 00:48:12,335
12, 11, 2 -

980
00:48:12,335 --> 00:48:14,670
>> -אני בפגישה החשאית הראשונה שלי.

981
00:48:14,670 --> 00:48:19,720
>> -25, 14, 11, 18, 16 -

982
00:48:19,720 --> 00:48:21,650
>> פייר היה נהדר בקול ערב.

983
00:48:21,650 --> 00:48:24,830
אני יכול לספר לי ההודעה של הלילה כי
היה באמת חשוב.

984
00:48:24,830 --> 00:48:26,400
>> -3, 25.

985
00:48:26,400 --> 00:48:28,540
זה מסר מאנני את עצמה.

986
00:48:28,540 --> 00:48:30,086
זכור, לא לספר לאף אחד.

987
00:48:30,086 --> 00:48:34,370

988
00:48:34,370 --> 00:48:38,710
>> -90 שניות מאוחר יותר, אני בחדר רק
בבית שבו ילד בן תשע

989
00:48:38,710 --> 00:48:42,668
יכל לשבת בפרטיות ובפענוח.

990
00:48:42,668 --> 00:48:47,628
אהה, הלכתי ב 'למשנהו.

991
00:48:47,628 --> 00:48:53,060
א 'המילה הראשונה היא "להיות". ס
זה היה קרוב יותר קל עכשיו.

992
00:48:53,060 --> 00:48:54,980
ע '25.

993
00:48:54,980 --> 00:48:55,940
זה ר '

994
00:48:55,940 --> 00:48:56,900
>> -יאללה, ראלפי.

995
00:48:56,900 --> 00:48:57,860
אני חייב ללכת.

996
00:48:57,860 --> 00:48:59,780
>> -אני אהיה ישר, אמא.

997
00:48:59,780 --> 00:49:01,030
בחיי.

998
00:49:01,030 --> 00:49:04,300

999
00:49:04,300 --> 00:49:08,220
>> -T. O. הקפד.

1000
00:49:08,220 --> 00:49:09,500
הקפד מה?

1001
00:49:09,500 --> 00:49:11,660
מה הייתה יתומה קטנה
אנני מנסה לומר?

1002
00:49:11,660 --> 00:49:12,844
הקפד מה?

1003
00:49:12,844 --> 00:49:14,732
>> -ראלפי, רנדי יש לי ללכת.

1004
00:49:14,732 --> 00:49:16,148
האם תוכל בבקשה לצאת?

1005
00:49:16,148 --> 00:49:17,092
>> -בסדר, אמא.

1006
00:49:17,092 --> 00:49:18,510
אני מייד החוצה.

1007
00:49:18,510 --> 00:49:20,270
>> -אני מתקרב לעכשיו.

1008
00:49:20,270 --> 00:49:21,823
המתח היה נורא.

1009
00:49:21,823 --> 00:49:23,045
מה זה היה?

1010
00:49:23,045 --> 00:49:26,510
גורלו של כדור הארץ עלולה
תלוי ועומד.

1011
00:49:26,510 --> 00:49:28,985
>> -ראלפי, Go חייב של רנדי.

1012
00:49:28,985 --> 00:49:32,680
>> -אני אהיה זכות לצאת ל
בוכה בקול רם.

1013
00:49:32,680 --> 00:49:33,956
>> -כמעט שם.

1014
00:49:33,956 --> 00:49:35,140
האצבעות שלי עפו.

1015
00:49:35,140 --> 00:49:36,880
המוח שלי היה מלכודת פלדה.

1016
00:49:36,880 --> 00:49:38,010
כל נקבובית רטט.

1017
00:49:38,010 --> 00:49:39,878
זה היה כמעט ברור.

1018
00:49:39,878 --> 00:49:43,210
כן, כן, כן, כן, כן.

1019
00:49:43,210 --> 00:49:49,030
>> -הקפד לשתות השוקו שלך.

1020
00:49:49,030 --> 00:49:50,280
שוקו?

1021
00:49:50,280 --> 00:49:53,980

1022
00:49:53,980 --> 00:49:55,230
מסחרי עלוב?

1023
00:49:55,230 --> 00:49:58,572

1024
00:49:58,572 --> 00:50:00,694
בן זונה.

1025
00:50:00,694 --> 00:50:01,900
>> [השמעת וידאו הסוף]

1026
00:50:01,900 --> 00:50:04,260
>> 1 דובר: זה CS50, וכי
יוגדר בעיה שנייה.

1027
00:50:04,260 --> 00:50:06,305
להתראות בשבוע הבא.

1028
00:50:06,305 --> 00:50:08,800
>> רמקול 2: בסמוך
CS50, זה קורה.

1029
00:50:08,800 --> 00:50:11,060
>> רמקול 1: אז נושא אחד יש לנו לא
הביט בו עד כה

1030
00:50:11,060 --> 00:50:12,220
זה של מצביעי פונקציות.

1031
00:50:12,220 --> 00:50:14,540
עכשיו, מצביע לפונקציה הוא רק
הכתובת של ציבור

1032
00:50:14,540 --> 00:50:17,000
פונקציה, אבל הרבה יותר כמו -

1033
00:50:17,000 --> 00:50:18,250
בנו של -

1034
00:50:18,250 --> 00:50:19,670