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

2
00:00:11,320 --> 00:00:13,260
>> דוד Malan: שלום, ו
ברוך שובך לCS50.

3
00:00:13,260 --> 00:00:14,860
אז זהו סוף השבוע ארבעה.

4
00:00:14,860 --> 00:00:16,680
רק אחד הודעה ראשונה.

5
00:00:16,680 --> 00:00:19,600
אז מה שנקרא החמישי יום שני הוא
מתקרב ליום השנייה הקרוב.

6
00:00:19,600 --> 00:00:22,800
זו ההזדמנות לשנות מ
SAT / UNSAT לכיתת מכתב, או מ

7
00:00:22,800 --> 00:00:24,130
מכתב כיתה SAT / UNSAT.

8
00:00:24,130 --> 00:00:27,130
מעצבן, כי תהליך דורש
חתימה, כי אתה צריך למלא

9
00:00:27,130 --> 00:00:28,770
את אחת מהצורות להוסיף / טיפה הוורודות האלה.

10
00:00:28,770 --> 00:00:31,680
>> כי מבחינה טכנית, SAT / UNSAT
גרסה וגרסת כיתה המכתב

11
00:00:31,680 --> 00:00:33,320
יש מק"טים שונים.

12
00:00:33,320 --> 00:00:34,240
אבל לא עניין גדול.

13
00:00:34,240 --> 00:00:36,620
פשוט לבוא אליי או לRob
או ללורן בכל נקודה.

14
00:00:36,620 --> 00:00:39,550
או שלח לנו דוא"ל אם אין לך את הסוג
ניירת שאתה צריך היום, ואנחנו

15
00:00:39,550 --> 00:00:43,410
יהיה בטוח שתעזרו לך לקחת
טיפול שלפני יום שני.

16
00:00:43,410 --> 00:00:45,780
>> בסדר, אז היום -

17
00:00:45,780 --> 00:00:47,630
למעשה, יש קצת הד.

18
00:00:47,630 --> 00:00:51,070
אנחנו יכולים למתן אותי קצת?

19
00:00:51,070 --> 00:00:51,730
אישור.

20
00:00:51,730 --> 00:00:54,850
אז היום, אנחנו מציגים את נושא
ידוע כמצביעים.

21
00:00:54,850 --> 00:00:57,770
ואני מודה שזו אחת
נושאים מורכבים יותר שאנו נוטים

22
00:00:57,770 --> 00:01:00,960
לכסות במעמד הזה, או בעצם כל
קורס מבוא המשתמש ג

23
00:01:00,960 --> 00:01:05,510
>> אבל תסמוך על המילה שלי בשביל זה, במיוחד
אם המוח שלך מרגיש קצת יותר מכופף

24
00:01:05,510 --> 00:01:07,100
היום ובשבועות הבאים.

25
00:01:07,100 --> 00:01:10,340
זה לא נציג שלך מקבל
יותר גרוע בזה זה רק אומר ש

26
00:01:10,340 --> 00:01:13,360
זה נושא מתוחכם במיוחד
שאני מבטיח, כמה שבועות

27
00:01:13,360 --> 00:01:17,610
לכן, ייראה כל מדי בולט
פשוט במבט לאחור.

28
00:01:17,610 --> 00:01:18,720
>> אני עדיין זוכר עד עצם היום הזה.

29
00:01:18,720 --> 00:01:22,190
אני ישבתי באולם אוכל אליוט,
ישב ליד TF Nishat מהטה,

30
00:01:22,190 --> 00:01:24,070
מי שהיה תושב אליוט הבית.

31
00:01:24,070 --> 00:01:26,340
ומשום מה, זה
נושא פשוט לוחץ.

32
00:01:26,340 --> 00:01:29,430
וזה אומר שגם אני נאבקתי
עם זה לכמות מסוימת של זמן, אבל אני

33
00:01:29,430 --> 00:01:33,610
יעשה כמיטב יכולתי לסייע להימנע מכל כגון
מאבק עם נושא שסופו של דבר

34
00:01:33,610 --> 00:01:34,580
הוא די חזק.

35
00:01:34,580 --> 00:01:37,350
>> למעשה, אחד הנושאים נדון
בשבועות הבאים הוא כי

36
00:01:37,350 --> 00:01:41,130
של ביטחון, ואיך אתה יכול באמת
לנצל את המכונות בדרכים

37
00:01:41,130 --> 00:01:42,320
שלא התכוונו אליו.

38
00:01:42,320 --> 00:01:45,850
וexploitations אלה הם בדרך כלל
התוצאה של חרקים, טעויות שאנחנו

39
00:01:45,850 --> 00:01:49,740
אנשים עושים בכך שלא הבין חלק
של היישום הבסיסי

40
00:01:49,740 --> 00:01:52,250
פרטים באמצעות תוכניות שהם עשו.

41
00:01:52,250 --> 00:01:55,410
>> עכשיו כדי להפוך את זה נראה כל המשתמש יותר
ידידותי, חשבתי שאני רוצה לשחק 10

42
00:01:55,410 --> 00:01:59,680
תצוגה מקדימה שנייה של אולפן קטן
דמות בשם בינקי שהובא ל

43
00:01:59,680 --> 00:02:03,020
חיים על ידי חבר שלנו בסטנפורד,
פרופסור ניק Parlante.

44
00:02:03,020 --> 00:02:06,753
אז הרשה לי לתת לך את זה
טיזר של בינקי כאן.

45
00:02:06,753 --> 00:02:09,520
>> [השמעת וידאו]

46
00:02:09,520 --> 00:02:10,380
>> -היי, בינקי.

47
00:02:10,380 --> 00:02:11,050
להתעורר.

48
00:02:11,050 --> 00:02:13,610
זה זמן בשביל כיף מצביע.

49
00:02:13,610 --> 00:02:14,741
>> , מה זה?

50
00:02:14,741 --> 00:02:16,440
למד על מצביעים?

51
00:02:16,440 --> 00:02:17,928
אה, יופי.

52
00:02:17,928 --> 00:02:18,920
>> [השמעת וידאו הסוף]

53
00:02:18,920 --> 00:02:20,670
>> מלאן דוד: זה הוא סטנפורד
מדעי מחשב.

54
00:02:20,670 --> 00:02:23,194
אז עוד על כך לבוא.

55
00:02:23,194 --> 00:02:24,930
>> [מחיאות כפות]

56
00:02:24,930 --> 00:02:26,660
>> דוד Malan: מצטער, ניק.

57
00:02:26,660 --> 00:02:30,680
>> אז זוכר שהפעם האחרונה שנסתיימו ביום
סחרור מסוכן באמת זה מרגש

58
00:02:30,680 --> 00:02:32,960
לפי פונקציה זו
פשוט לא עבד.

59
00:02:32,960 --> 00:02:34,960
לפחות באופן אינטואיטיבי, זה הרגיש
כמו שזה צריך לעבוד.

60
00:02:34,960 --> 00:02:37,600
פשוט להחליף את הערכים
של שני מספרים שלמים.

61
00:02:37,600 --> 00:02:40,915
אבל זוכר שכאשר אנו הדפסנו
ערכים מקוריים בראשי, ואחד

62
00:02:40,915 --> 00:02:44,210
שתיים, הם עדיין הייתם אחד ו
שתיים ולא שתיים ואחד.

63
00:02:44,210 --> 00:02:46,070
>> אז תן לי בעצם לעבור
מעל למכשיר.

64
00:02:46,070 --> 00:02:50,180
ואני כתבתי קצת קוד של שלד ב
לקדם כאן, שבו אני טוען שX

65
00:02:50,180 --> 00:02:52,500
יהיה 1, y יהיה 2.

66
00:02:52,500 --> 00:02:54,810
אני מכן להדפיס את שניהם
ערכים עם F ההדפסה.

67
00:02:54,810 --> 00:02:57,540
>> אז אני טוען כאן כי
אנחנו הולכים להחליף אותם.

68
00:02:57,540 --> 00:03:00,800
עזבתי את מקום ריק כאן בשבילנו
מלא היום ברגע.

69
00:03:00,800 --> 00:03:03,380
לאחר מכן, אני הולך לטעון כי
שני משתנים כבר החליפו.

70
00:03:03,380 --> 00:03:04,770
ואז אני הולך להדפיס
אותם שוב.

71
00:03:04,770 --> 00:03:07,090
וכך אני מקווה, אני צריך לראות 1, 2.

72
00:03:07,090 --> 00:03:07,380
2, 1.

73
00:03:07,380 --> 00:03:09,830
זה פשוט הסופר
מטרה עכשיו.

74
00:03:09,830 --> 00:03:12,430
>> אז איך אנחנו הולכים על החלפה
שני משתנים?

75
00:03:12,430 --> 00:03:17,220
ובכן, אם אני מציע כאן שהכוסות הללו
עשוי לייצג בזכרון מחשב.

76
00:03:17,220 --> 00:03:19,070
זה כמה נגיסות, זה
הוא עוד כמה נגיסות.

77
00:03:19,070 --> 00:03:23,260
אפשר שיש לנו מתנדבים לבוא בעד ו
לערבב אותנו כמה משקאות, אם מוכר?

78
00:03:23,260 --> 00:03:23,920
בואו נעלה.

79
00:03:23,920 --> 00:03:24,815
מה שמך?

80
00:03:24,815 --> 00:03:25,260
>> JESS: ג'ס.

81
00:03:25,260 --> 00:03:25,690
>> דוד Malan: ג'ס?

82
00:03:25,690 --> 00:03:26,540
בואו למעלה, ג'ס.

83
00:03:26,540 --> 00:03:29,180
אם לא אכפת לך, אנחנו צריכים לשים את
זכוכית גוגל עליך כדי שנוכל

84
00:03:29,180 --> 00:03:30,430
להנציח את זה.

85
00:03:30,430 --> 00:03:32,800

86
00:03:32,800 --> 00:03:34,670
אוקיי, זכוכית.

87
00:03:34,670 --> 00:03:37,250
להקליט וידאו.

88
00:03:37,250 --> 00:03:43,103
ובסדר, אנחנו טוב
ללכת עם ג'ס כאן.

89
00:03:43,103 --> 00:03:43,810
בסדר.

90
00:03:43,810 --> 00:03:45,120
נע מאוד.

91
00:03:45,120 --> 00:03:47,720
>> אז מה אני רוצה שאתם עושים כאן -
אם אתה יכול, די מהר -

92
00:03:47,720 --> 00:03:51,040
פשוט שופך לנו חצי כוס התפוזים
מיץ וחצי כוס חלב,

93
00:03:51,040 --> 00:03:55,710
מייצג למעשה את המספרים 1
בכוס אחת ו -2 בגביע האחר.

94
00:03:55,710 --> 00:04:01,380

95
00:04:01,380 --> 00:04:02,630
>> זה הולך להיות סרט טוב.

96
00:04:02,630 --> 00:04:04,910

97
00:04:04,910 --> 00:04:05,860
>> JESS: מצטער.

98
00:04:05,860 --> 00:04:06,330
>> מלאן דוד: לא, לא.

99
00:04:06,330 --> 00:04:08,703
זה בסדר.

100
00:04:08,703 --> 00:04:10,120
נחמד.

101
00:04:10,120 --> 00:04:12,950
בסדר, אז יש לנו ארבעה בתים
שווה של מיץ תפוזים.

102
00:04:12,950 --> 00:04:14,460
אנחנו קראנו לזה את הערך 1.

103
00:04:14,460 --> 00:04:16,579
עכשיו ארבעה בתים אחרים שווים של חלב.

104
00:04:16,579 --> 00:04:18,519
האם לקרוא לו ערך 2.

105
00:04:18,519 --> 00:04:20,440
אז X ו-Y, בהתאמה.

106
00:04:20,440 --> 00:04:23,450
>> בסדר, אז עכשיו אם את המשימה בהישג יד -
בשבילך, ג'ס, מול כל

107
00:04:23,450 --> 00:04:24,270
מהכיתה שלך -

108
00:04:24,270 --> 00:04:28,510
הוא להחליף את ערכי X ו-Y, כגון
כי אנחנו רוצים את מיץ התפוזים ב

109
00:04:28,510 --> 00:04:32,070
כוס השנייה ואת החלב בכוס הזאת, איך
אולי אתה - לפני שאתה בעצם עושה

110
00:04:32,070 --> 00:04:34,020
זה - ללכת על עושה את זה?

111
00:04:34,020 --> 00:04:35,220
>> מניח את הדעת, חכם החלטה.

112
00:04:35,220 --> 00:04:36,340
אז אתה צריך קצת יותר זיכרון.

113
00:04:36,340 --> 00:04:38,190
אז בואו נקצה זמני
גביע, אם תרצה.

114
00:04:38,190 --> 00:04:40,540
ועכשיו להמשיך להחליף X ו-Y.

115
00:04:40,540 --> 00:04:52,950

116
00:04:52,950 --> 00:04:53,530
>> מצוין.

117
00:04:53,530 --> 00:04:54,420
אז עשה טוב מאוד.

118
00:04:54,420 --> 00:04:55,670
תודה רבה לך, ג'ס.

119
00:04:55,670 --> 00:04:59,520

120
00:04:59,520 --> 00:05:00,020
הנה בבקשה.

121
00:05:00,020 --> 00:05:01,950
מזכרת קטנה.

122
00:05:01,950 --> 00:05:04,350
>> אוקיי, אז כמובן, רעיון פשוט סופר.

123
00:05:04,350 --> 00:05:07,500
אינטואיטיבי לחלוטין שאנחנו צריכים קצת
שטח אחסון נוסף - בצורה זו,

124
00:05:07,500 --> 00:05:09,750
כוס - אם אנחנו באמת רוצים
להחליף את שני המשתנים הללו.

125
00:05:09,750 --> 00:05:11,110
אז בואו לעשות בדיוק את זה.

126
00:05:11,110 --> 00:05:14,330
עד כאן בין שבו אני טוען שאני
הולך לעשות קצת החלפה, אני יהיה

127
00:05:14,330 --> 00:05:15,720
קדימה ולהכריז זמני.

128
00:05:15,720 --> 00:05:17,980
ואני מגדיר את זה שווה, יניח, x.

129
00:05:17,980 --> 00:05:21,110
>> ואז אני הולך לשנות את הערך של
X בדיוק כמו ג'ס עשה כאן עם

130
00:05:21,110 --> 00:05:23,200
חלב ומיץ תפוזים
להיות שווה ל-Y.

131
00:05:23,200 --> 00:05:27,460
ואני הולך לשנות את y להיות שווה
כדי לא X, כי עכשיו אנחנו יהיו

132
00:05:27,460 --> 00:05:29,530
תקוע במעגל, אלא זמני.

133
00:05:29,530 --> 00:05:33,170
איפה אני באופן זמני - או היכן ג'ס
באופן זמני את מיץ התפוזים

134
00:05:33,170 --> 00:05:35,460
לפני שמחץ
כוס עם החלב.

135
00:05:35,460 --> 00:05:37,250
>> אז תן לי ללכת קדימה ולעשות את זה עכשיו.

136
00:05:37,250 --> 00:05:39,210
זה נקרא noswap.c.

137
00:05:39,210 --> 00:05:41,190
ועכשיו תן לי לרוץ ללא החלפה.

138
00:05:41,190 --> 00:05:43,910
ואכן אני רואה, אם אני מרחיב
חלון קצת, כי

139
00:05:43,910 --> 00:05:45,160
X הוא 1, y הוא 2.

140
00:05:45,160 --> 00:05:47,230
ואז X הוא 2, y הוא 1.

141
00:05:47,230 --> 00:05:51,910
>> אבל תזכור כי ביום שני שעשינו דברים
קצת אחר שבו אני

142
00:05:51,910 --> 00:05:56,760
במקום ליישם פונקציה עוזרת,
אם תרצה, שהיה למעשה מבוטל.

143
00:05:56,760 --> 00:05:58,010
אני קראתי לה להחליף.

144
00:05:58,010 --> 00:06:01,600
אני נתתי לו שני פרמטרים, ואני קראתי
שלהם וקראתי להם ב.

145
00:06:01,600 --> 00:06:04,380
>> בכנות, אני יכול לקרוא להם X ו-Y.

146
00:06:04,380 --> 00:06:06,040
אין שום דבר שמונע
אותי מלעשות את זה.

147
00:06:06,040 --> 00:06:08,140
אבל אני טוען שזה אז
קצת מעורפל.

148
00:06:08,140 --> 00:06:11,910
בגלל החזרה ליום השני שאנחנו
טען כי פרמטרים אלה היו

149
00:06:11,910 --> 00:06:13,650
עותקים של הערכים עברו פנימה

150
00:06:13,650 --> 00:06:15,640
אז זה פשוט מתעסק עימך
מוח, אני חושב, אם אתה משתמש

151
00:06:15,640 --> 00:06:17,370
בדיוק באותם משתנה.

152
00:06:17,370 --> 00:06:20,150
>> אז אני במקום אתקשר אליהם
ו-B, רק בשביל בהירות.

153
00:06:20,150 --> 00:06:21,840
אבל אנחנו יכולים לקרוא להם ביותר
כל דבר שאנחנו רוצים.

154
00:06:21,840 --> 00:06:26,280
ואני מתכוון להעתיק ולהדביק
ביעילות את הקוד הזה מלמעלה

155
00:06:26,280 --> 00:06:27,170
למטה לתוך כאן.

156
00:06:27,170 --> 00:06:29,110
כי אני פשוט ראיתי שזה עובד.

157
00:06:29,110 --> 00:06:30,790
אז זה בצורה די טובה.

158
00:06:30,790 --> 00:06:37,390
ואני תשנה X שלי, שלי X
ל, y שלי ל-B ו-y שלי ל-B.

159
00:06:37,390 --> 00:06:39,130
>> אז במילים אחרות, בדיוק באותו היגיון.

160
00:06:39,130 --> 00:06:40,850
בדיוק את אותו הדבר שעשתה ג'ס.

161
00:06:40,850 --> 00:06:44,350
ואז הדבר היחיד שאני צריך לעשות את
כאן, כמובן, עכשיו זה לעורר

162
00:06:44,350 --> 00:06:45,990
פונקציה, או להתקשר בפונקציה זו.

163
00:06:45,990 --> 00:06:50,430
אז אני אקרא בפונקציה זו עם שתיים
תשומות, X ו-Y, ולהיט 'שמור'.

164
00:06:50,430 --> 00:06:52,300
>> בסדר, כל כך בסיסי
את אותו הדבר.

165
00:06:52,300 --> 00:06:55,570
למעשה, אני כנראה כבר עשיתי את התכנית
שלא לצורך על ידי קומפלקס

166
00:06:55,570 --> 00:07:00,820
כתיבת פונקציה שרק לוקח
כשש שורות של קוד ואילו אני

167
00:07:00,820 --> 00:07:02,970
בעבר היה מיושם
בדיוק את זה בשלוש.

168
00:07:02,970 --> 00:07:06,230
>> אז תן לי ללכת קדימה עכשיו ולעצב מחדש
זה, לא עושה שום החלפה.

169
00:07:06,230 --> 00:07:07,920
בסדר, אני דפוק כאן.

170
00:07:07,920 --> 00:07:11,290
זו צריכה להיות שגיאה שתוכל
רואה יותר ויותר בכינוי שלך

171
00:07:11,290 --> 00:07:12,380
תוכניות מורכבות יותר ויותר.

172
00:07:12,380 --> 00:07:13,470
אבל יש תיקון קל.

173
00:07:13,470 --> 00:07:15,650
תן לי לגלול חזרה לכאן.

174
00:07:15,650 --> 00:07:18,190
>> ומה השגיאה הראשונה שאני רואה?

175
00:07:18,190 --> 00:07:19,520
הצהרה המרומזת.

176
00:07:19,520 --> 00:07:21,466
מה זה מצביע בדרך כלל?

177
00:07:21,466 --> 00:07:22,830
אה, שכחתי את האבטיפוס.

178
00:07:22,830 --> 00:07:26,900
שכחתי ללמד את המהדר שהחלפה
הולך להתקיים למרות שהוא

179
00:07:26,900 --> 00:07:28,920
לא קיימת ממש בהתחלה
של התכנית.

180
00:07:28,920 --> 00:07:35,780
אז אני פשוט הולך להגיד חלל, החלפה,
int, int b, פסיק.

181
00:07:35,780 --> 00:07:37,280
>> אז אני לא הולך לreimplement את זה.

182
00:07:37,280 --> 00:07:39,140
אבל עכשיו זה תואם את מה שכאן למטה.

183
00:07:39,140 --> 00:07:42,530
ושים לב, העדר פסיק
כאן, שאין צורך בי

184
00:07:42,530 --> 00:07:43,200
יישום.

185
00:07:43,200 --> 00:07:46,010
>> אז תן לי לסדר את זה, לא עושה שום החלפה.

186
00:07:46,010 --> 00:07:46,910
מצב הרבה יותר טוב.

187
00:07:46,910 --> 00:07:48,130
הפעלה לא החלפה.

188
00:07:48,130 --> 00:07:48,740
ולעזאזל.

189
00:07:48,740 --> 00:07:51,650
עכשיו אנחנו שוב איפה שהיינו ביום שני,
שבו הדבר לא להחליף.

190
00:07:51,650 --> 00:07:55,410
>> ומהו ההסבר הסביר אינטואיטיבית
למה זה המקרה?

191
00:07:55,410 --> 00:07:56,380
כן?

192
00:07:56,380 --> 00:07:57,630
>> תלמיד: [לא ברור].

193
00:07:57,630 --> 00:08:04,140

194
00:08:04,140 --> 00:08:05,230
>> דוד Malan: בדיוק.

195
00:08:05,230 --> 00:08:07,330
אז A ו-B הם עותקים של X ו-Y.

196
00:08:07,330 --> 00:08:10,680
ולמעשה, בכל זמן שהיית
קורא לפונקציה שעד כה

197
00:08:10,680 --> 00:08:12,540
עובר משתנים כמו ints -

198
00:08:12,540 --> 00:08:14,470
בדיוק כמו החלפה מצפה כאן -

199
00:08:14,470 --> 00:08:16,270
אתם כבר עוברים בעותקים.

200
00:08:16,270 --> 00:08:19,150
>> עכשיו זה אומר שזה לוקח קצת
של זמן, שבריר שני, עבור

201
00:08:19,150 --> 00:08:23,270
מחשב כדי להעתיק את הקטעים מאחד
משתנה לפיסות אחרת.

202
00:08:23,270 --> 00:08:24,610
אבל זה לא כזה ביג דיל.

203
00:08:24,610 --> 00:08:25,920
אבל הם בכל זאת העתקה.

204
00:08:25,920 --> 00:08:30,020
>> וכך עכשיו, בהקשר של עסקת ההחלף,
אני למעשה בהצלחה

205
00:08:30,020 --> 00:08:31,180
שינוי A ו-B.

206
00:08:31,180 --> 00:08:33,000
למעשה, בואו נעשה מהיר
שפיות לבדוק.

207
00:08:33,000 --> 00:08:36,830
F ההדפסה הוא% אני, שורה חדשה.

208
00:08:36,830 --> 00:08:38,770
והתקע בואו ב.

209
00:08:38,770 --> 00:08:41,830
עכשיו בואו נעשה את אותו דבר עם b.

210
00:08:41,830 --> 00:08:43,640
ובואו נעשה את אותו דבר כאן.

211
00:08:43,640 --> 00:08:47,260
>> ועכשיו, תן לי להעתיק את אותם קווים
שוב בחלק התחתון של הפונקציה

212
00:08:47,260 --> 00:08:51,250
אחרי שלוש השורות שלי מעניין
היה יכול להיות מוצא להורג, ו

213
00:08:51,250 --> 00:08:53,270
להדפיס ושוב ב.

214
00:08:53,270 --> 00:08:56,030
אז עכשיו בואו נעשה את זה, לא עושה שום החלפה.

215
00:08:56,030 --> 00:08:58,430
תן לי לעשות את חלון המסוף
קצת יותר גבוה, כך שאנו יכולים לראות

216
00:08:58,430 --> 00:08:59,520
יותר מזה בבת אחת.

217
00:08:59,520 --> 00:09:00,860
>> ולהפעיל שום החלפה.

218
00:09:00,860 --> 00:09:04,000
X הוא 1, y הוא 2. הוא 1, B הוא 2.

219
00:09:04,000 --> 00:09:06,070
ואז, הוא 2, B הוא 1.

220
00:09:06,070 --> 00:09:09,390
אז הוא פועל, בדיוק כמו ג'ס
עשה כאן בפנים של החלפה.

221
00:09:09,390 --> 00:09:13,090
אבל כמובן, זה שאין לו השפעה
על המשתנים העיקריים ב.

222
00:09:13,090 --> 00:09:15,360
>> אז ראינו את טריק לפיו אנו
אפשר לתקן את זה, נכון?

223
00:09:15,360 --> 00:09:19,560
כאשר אתה מתמודד עם זה בטווחים
בעיה, אתה יכול פשוט להפוך את הדוגית וX

224
00:09:19,560 --> 00:09:22,400
ו-y איזה סוג של משתנים במקום?

225
00:09:22,400 --> 00:09:23,390
>> אתה יכול להפוך אותם לעולמי.

226
00:09:23,390 --> 00:09:27,560
שימו אותם בחלקו העליון של הקובץ
כפי שעשינו, אפילו במשחק של 15.

227
00:09:27,560 --> 00:09:28,890
אנו משתמשים במשתנה גלובלית.

228
00:09:28,890 --> 00:09:32,420
אבל בהקשר של המשחק 15,
זה הגיוני שיהיה לי גלובלי

229
00:09:32,420 --> 00:09:37,170
משתנה המייצגת את המועצה, כי
מכלול 15.c הוא כל

230
00:09:37,170 --> 00:09:38,650
על יישום את המשחק הזה.

231
00:09:38,650 --> 00:09:41,470
זה מה שהקובץ קיים לעשות.

232
00:09:41,470 --> 00:09:44,170
>> אבל במקרה הזה כאן, אני
קורא החלפת פונקציה.

233
00:09:44,170 --> 00:09:45,380
אני רוצה להחליף את שני משתנים.

234
00:09:45,380 --> 00:09:48,950
וזה צריך להתחיל להרגיש פשוט מרושל
אם הפתרון לכולנו

235
00:09:48,950 --> 00:09:51,300
בעיות כאשר אנחנו נתקלים בהיקף
בעיות היא לעשות את זה בעולם.

236
00:09:51,300 --> 00:09:54,730
כי מהר מאוד התכנית שלנו היא
הולך להיות די בלגן.

237
00:09:54,730 --> 00:09:57,760
ואנחנו עשינו את זה מאוד במשורה
כתוצאה מכך ב15.c.

238
00:09:57,760 --> 00:10:00,470
>> אבל מתברר שיש
דרך טובה יותר לגמרי.

239
00:10:00,470 --> 00:10:05,600
תן לי בעצם לחזור ולמחוק את
להדפיס F של, רק כדי לפשט את הקוד הזה.

240
00:10:05,600 --> 00:10:09,160
ותרשו לי להציע כי
זו, אכן, היא רעה.

241
00:10:09,160 --> 00:10:15,990
אבל אם אני במקום להוסיף כמה כוכביות
וכוכבים, אני יכול במקום להפוך את זה

242
00:10:15,990 --> 00:10:18,670
פונקציה לאחד זה
מבצעי בפועל.

243
00:10:18,670 --> 00:10:25,020
>> אז תן לי לחזור לכאן ולהודות לומר
כוכביות היא תמיד קשה,

244
00:10:25,020 --> 00:10:26,170
אז אני אגיד את הכוכבים.

245
00:10:26,170 --> 00:10:27,660
אני רק אודה לזה.

246
00:10:27,660 --> 00:10:28,190
בסדר.

247
00:10:28,190 --> 00:10:30,190
ועכשיו, מה אני הולך
לעשות במקום?

248
00:10:30,190 --> 00:10:34,130
>> אז קודם כל, אני הולך כדי לציין
כי במקום עובר לתוך int

249
00:10:34,130 --> 00:10:37,980
פונקצית swap, אני במקום
מהולך להגיד כוכב int.

250
00:10:37,980 --> 00:10:39,170
עכשיו, מה עושה הכוכב עולה?

251
00:10:39,170 --> 00:10:41,970
זה רעיון ששל מצביע כי
בינקי, דמות האולפן, הייתה

252
00:10:41,970 --> 00:10:43,465
בהתייחסו לרגע לפני.

253
00:10:43,465 --> 00:10:47,610
>> אז אם אנחנו אומרים כוכב int, את המשמעות של
זה עכשיו הוא שהוא לא הולך להיות

254
00:10:47,610 --> 00:10:49,110
עבר על ידי הערך שלו.

255
00:10:49,110 --> 00:10:50,350
זה לא הולך להיות מועתק פנימה

256
00:10:50,350 --> 00:10:54,700
במקום זאת, את הכתובת שלו
הולך להיות מועבר פנימה

257
00:10:54,700 --> 00:10:57,840
>> אז זוכר שבתוך המחשב שלך
היא חבורה שלמה של זיכרון, אחרת

258
00:10:57,840 --> 00:10:58,760
ידוע כזכרון RAM.

259
00:10:58,760 --> 00:11:00,520
וזכרון RAM שהוא רק
חבורה שלמה של בתים.

260
00:11:00,520 --> 00:11:03,320
אז אם יש לך MAC או למחשב
שתי ג'יגה, יש לך 2

261
00:11:03,320 --> 00:11:05,760
מליארד בייטים של זיכרון.

262
00:11:05,760 --> 00:11:08,440
>> עכשיו בואו רק נניח שרק כדי
לשמור על דברים נחמדים ומסודרים, אנחנו

263
00:11:08,440 --> 00:11:09,450
להקצות כתובת -

264
00:11:09,450 --> 00:11:10,170
מספר -

265
00:11:10,170 --> 00:11:12,270
לכל בייט של זיכרון RAM במחשב שלך.

266
00:11:12,270 --> 00:11:15,410
הבתים הראשון של 2 אלה
מיליארדים הוא מספר באפס.

267
00:11:15,410 --> 00:11:18,572
הקטע הבא הוא מספר הבתים מספר אחד,
שתיים, כל הדרך למעלה, נקודת נקודה

268
00:11:18,572 --> 00:11:20,530
נקודה, לכ -2 מליארד דולרים.

269
00:11:20,530 --> 00:11:23,640
>> אז אתה יכול כמה מהבתים
זיכרון במחשב שלך.

270
00:11:23,640 --> 00:11:26,460
אז בואו נניח שזה מה
אנו מתכוונים בכתובת.

271
00:11:26,460 --> 00:11:31,360
אז כשאני רואה כוכב int, מה קורה
כדי להיות מועבר להחלפה כרגע הוא

272
00:11:31,360 --> 00:11:32,830
כתובת של.

273
00:11:32,830 --> 00:11:37,150
לא את הערך שלו, אבל מהו דואר
כתובת היא, אם אפשר לומר כך -

274
00:11:37,150 --> 00:11:38,810
מיקומו בזכרון RAM.

275
00:11:38,810 --> 00:11:41,250
>> ובאופן דומה עבור b, אני הולך
לומר את אותו דבר.

276
00:11:41,250 --> 00:11:42,720
Int, כוכב, ב.

277
00:11:42,720 --> 00:11:46,350
במאמר מוסגר, מבחינה טכנית כוכבים
יכל ללכת במקומות אחרים.

278
00:11:46,350 --> 00:11:50,140
אבל אנחנו סטנדרטיזציה על הכוכב להיות
ממש בסמוך לסוג הנתונים.

279
00:11:50,140 --> 00:11:54,080
>> אז להחליף חתימה עכשיו אומרת, תן לי
הכתובת של int, ושיחה

280
00:11:54,080 --> 00:11:55,400
כי כתובת.

281
00:11:55,400 --> 00:11:58,690
ותן לי כתובת אחרת של
int ולקרוא ב כתובת זו.

282
00:11:58,690 --> 00:12:01,120
>> אבל עכשיו הקוד שלי כאן חייב להשתנות.

283
00:12:01,120 --> 00:12:03,470
כי אם אני מצהיר טמפ int -

284
00:12:03,470 --> 00:12:05,580
שהוא עדיין מסוג int -

285
00:12:05,580 --> 00:12:08,700
אבל אני מאחסן בזה,
איזה סוג של ערך?

286
00:12:08,700 --> 00:12:12,870
כדי להיות ברור, אני מניח עם
הקוד כפי שנכתב ממש עכשיו?

287
00:12:12,870 --> 00:12:14,360
>> אני שם את המיקום ב.

288
00:12:14,360 --> 00:12:16,500
אבל לא אכפת לי
מיקום עכשיו, נכון?

289
00:12:16,500 --> 00:12:21,940
טמפ 'קיים רק הגביע השלישי "ג'ס
קיים, לאיזו מטרה?

290
00:12:21,940 --> 00:12:23,090
כדי לאחסן את ערך.

291
00:12:23,090 --> 00:12:24,830
חלב או מיץ תפוזים.

292
00:12:24,830 --> 00:12:28,520
לא ממש לאחסן את הכתובת של
אף אחד מהדברים האלה, שמרגיש

293
00:12:28,520 --> 00:12:31,200
קצת שטותי בזה אמיתי
הקשר עולם בכל מקרה.

294
00:12:31,200 --> 00:12:34,990
>> אז באמת, מה שאני רוצה לשים בטמפ
לא את הכתובת של, אבל

295
00:12:34,990 --> 00:12:36,180
תוכן.

296
00:12:36,180 --> 00:12:41,930
אז אם הוא מספר כמו 123, זו היא
הבתים של זיכרון 123 שרק

297
00:12:41,930 --> 00:12:45,090
קורה להיות כובש, כי הערך
בקורה להיות כובש.

298
00:12:45,090 --> 00:12:49,040
>> אם אני רוצה ללכת לכתובת ש,
אני צריך להגיד את הכוכב.

299
00:12:49,040 --> 00:12:52,610
בדומה לכך, אם הייתי משנה את מה
בכתובת, אני משנה

300
00:12:52,610 --> 00:12:53,570
זה כדי להתחיל.

301
00:12:53,570 --> 00:12:58,185
אם אני רוצה לאחסן במה ב
מיקום עם מה במיקום

302
00:12:58,185 --> 00:13:02,180
ב-B, B כוכב כוכב.

303
00:13:02,180 --> 00:13:05,340
>> אז בקיצור, גם אם זה לא די
שוקע בעדיין - ואני לא הייתי מצפה

304
00:13:05,340 --> 00:13:06,560
כי זה היית כל כך מהר -

305
00:13:06,560 --> 00:13:11,100
להבין שכל מה שאני עושה הוא קידומת
כוכבים אלה למשתנים שלי,

306
00:13:11,100 --> 00:13:13,350
אומרים שאין לתפוס את הערכים.

307
00:13:13,350 --> 00:13:14,520
אין לשנות את הערכים.

308
00:13:14,520 --> 00:13:17,600
אלא, הולכים לכתובות אלה
ולקבל את התמורה.

309
00:13:17,600 --> 00:13:21,430
מעבר לכתובת ושינוי ש
הערך שם.

310
00:13:21,430 --> 00:13:25,500
>> אז עכשיו תן לי לגלול חזרה לפסגה,
רק כדי לתקן את הקו הזה כאן, כדי

311
00:13:25,500 --> 00:13:27,690
לשנות את אב הטיפוס כדי להתאים.

312
00:13:27,690 --> 00:13:30,280
אבל עכשיו אני צריך לעשות עוד דבר אחד.

313
00:13:30,280 --> 00:13:35,500
באופן אינטואיטיבי, אם אני כבר שיניתי את הסוגים
טיעונים של החלפה שהוא מצפה,

314
00:13:35,500 --> 00:13:37,245
מה עוד אני צריך לעשות כדי
שינוי בקוד שלי?

315
00:13:37,245 --> 00:13:39,750

316
00:13:39,750 --> 00:13:40,840
>> כאשר אני קורא ההחלף.

317
00:13:40,840 --> 00:13:43,340
כי כרגע, מה אני
אני עובר להחליף עדיין?

318
00:13:43,340 --> 00:13:47,450
X הערך והערך של y, או
חלב ומיץ התפוזים.

319
00:13:47,450 --> 00:13:48,510
אבל אני לא רוצה לעשות את זה.

320
00:13:48,510 --> 00:13:51,060
אני רוצה להעביר במקום במה?

321
00:13:51,060 --> 00:13:53,050
המיקום של X ו
המיקום של y.

322
00:13:53,050 --> 00:13:55,300
מה הן כתובות הדואר שלהם,
אם אפשר לומר כך.

323
00:13:55,300 --> 00:13:57,600
>> אז כדי לעשות את זה, יש אמפרסנד.

324
00:13:57,600 --> 00:13:59,260
סוג של אמפרסנד נשמע כמו כתובת.

325
00:13:59,260 --> 00:14:03,240
כך n, אמפרסנד, הכתובת
של x, ואת הכתובת של y.

326
00:14:03,240 --> 00:14:06,790
אז זה מכוון שאנו משתמשים
אמפרסנד כאשר הקריאה לפונקציה,

327
00:14:06,790 --> 00:14:10,230
וכוכבים כשהכריזו ומתי
יישום הפונקציה.

328
00:14:10,230 --> 00:14:14,220
>> ורק לחשוב על אמפרסנד כ
כתובת של מפעיל, וכוכב כמו

329
00:14:14,220 --> 00:14:15,490
ללכת לשם מפעיל -

330
00:14:15,490 --> 00:14:18,640
או, יותר נכון,
מפעיל dereference.

331
00:14:18,640 --> 00:14:23,480
אז זה המון מילים רק כדי
אומרים את זה עכשיו, בתקווה, ההחלפה הולכת

332
00:14:23,480 --> 00:14:24,440
כדי להיות נכון.

333
00:14:24,440 --> 00:14:26,550
>> תן לי להמשיך ולעשות -

334
00:14:26,550 --> 00:14:30,940
בואו באמת לשנות את שם הקובץ, פן
תכנית זו עדיין להיקרא לא החלפה.

335
00:14:30,940 --> 00:14:33,240
אני טוען שאנחנו קוראים לזה swap.c עכשיו.

336
00:14:33,240 --> 00:14:35,670
אז לעשות, להחליף.

337
00:14:35,670 --> 00:14:37,520
נקודה, לוכסן, להחליף.

338
00:14:37,520 --> 00:14:40,210
>> ועכשיו אכן, x הוא 1, y הוא 2.

339
00:14:40,210 --> 00:14:44,040
ואז, הוא x 2, y הוא אחד.

340
00:14:44,040 --> 00:14:46,500
ובכן בואו תראו אם אנחנו לא יכולים לעשות את זה
קצת אחר על מה זה

341
00:14:46,500 --> 00:14:47,180
קורה כאן.

342
00:14:47,180 --> 00:14:51,250
ראשית, הרשו לי להתמקד עלינו
ציור מסך כאן.

343
00:14:51,250 --> 00:14:54,160
ותרשו לי להציע לרגע - ו
בכל פעם שאני מצייר כאן יהיה שיקוף

344
00:14:54,160 --> 00:14:58,660
עד לשם עכשיו - תנו לי להציע כי
הנה חבורה שלמה של זיכרון, או

345
00:14:58,660 --> 00:15:00,540
זיכרון RAM, חלק פנימי של המחשב שלי.

346
00:15:00,540 --> 00:15:04,140
>> וזה יהיה מספר ביס,
נניח, 1.

347
00:15:04,140 --> 00:15:05,720
זה יהיה בתים מספר 2.

348
00:15:05,720 --> 00:15:08,220
ואני אעשה את כל חבורה יותר, ו
לאחר מכן חבורה של נקודות נקודת נקודה כדי

349
00:15:08,220 --> 00:15:10,880
מצביע על כך שיש 2 מליארד
מהדברים האלה.

350
00:15:10,880 --> 00:15:13,520
4, 5, וכן הלאה.

351
00:15:13,520 --> 00:15:17,055
>> אז יש חמשת הבתים הראשונים
מהזיכרון של המחשב שלי.

352
00:15:17,055 --> 00:15:17,560
בסדר?

353
00:15:17,560 --> 00:15:19,060
מעטים מאוד מתוך 2 מליארד דולרים.

354
00:15:19,060 --> 00:15:21,120
אבל עכשיו אני הולך להציע
את הדברים הבאים.

355
00:15:21,120 --> 00:15:27,490
אני הולך להציע כי X הולך
לאחסן את המספר 1, והוא הולך y

356
00:15:27,490 --> 00:15:29,690
כדי לאחסן את המספר 2.

357
00:15:29,690 --> 00:15:35,000
ותנו לי ללכת קדימה עכשיו ומייצג
ערכים אלה באופן הבא.

358
00:15:35,000 --> 00:15:41,510
>> בואו לעשות את זה באופן הבא.

359
00:15:41,510 --> 00:15:42,870
תן לי רק שני אחת.

360
00:15:42,870 --> 00:15:44,150
שנייה אחת.

361
00:15:44,150 --> 00:15:45,680
אישור.

362
00:15:45,680 --> 00:15:47,560
אני רוצה לעשות את זה קצת -

363
00:15:47,560 --> 00:15:50,440
בואו נעשינו את זה שוב.

364
00:15:50,440 --> 00:15:53,250
אחרת אני הולך ולשימוש
אותם מספרים, שלא בכוונה,

365
00:15:53,250 --> 00:15:54,230
מספר רב של פעמים.

366
00:15:54,230 --> 00:15:57,320
>> אז פשוט כל כך שיש לנו מספרים שונים
לדבר עליו, בואו נקראים לזה בתים

367
00:15:57,320 --> 00:16:03,391
מספר 123, 124, 125, 126,
ונקודת נקודת נקודה.

368
00:16:03,391 --> 00:16:08,400
ותנו לי טוען עכשיו שאני הולך
לשים את ערך 1 כאן, ואת הערך 2

369
00:16:08,400 --> 00:16:11,990
כאן, הידוע גם בX ו-Y.

370
00:16:11,990 --> 00:16:15,300
אז זה פשוט כל כך קורה כי
זה הוא x, y זה.

371
00:16:15,300 --> 00:16:18,180
>> ורק על ידי כמה סיכוי אקראי,
מחשב, מערכת ההפעלה,

372
00:16:18,180 --> 00:16:21,890
קרה לשים X במיקום
מספר 123.

373
00:16:21,890 --> 00:16:25,590
ו-y בסופו במיקום 124 -

374
00:16:25,590 --> 00:16:26,330
לעזאזל.

375
00:16:26,330 --> 00:16:28,700
אני הייתי אמור לתקן את זה.

376
00:16:28,700 --> 00:16:34,040
אה גבר, האם אני באמת רוצה לעשות את זה?

377
00:16:34,040 --> 00:16:37,340
כן, אני רוצה לתקן את זה ו
ב נכון על זה היום.

378
00:16:37,340 --> 00:16:39,950
מצטער, חדש בזה.

379
00:16:39,950 --> 00:16:45,020
>> 127, 131, ואני לא רוצה שזה יהיה
מורכב, אבל למה שאני משנה

380
00:16:45,020 --> 00:16:46,340
מספרים שם?

381
00:16:46,340 --> 00:16:48,360
כי אני רוצה את ints ל
למעשה יהיה ארבעה בתים.

382
00:16:48,360 --> 00:16:49,810
אז בואו להיות סופר אנאלי על זה.

383
00:16:49,810 --> 00:16:53,800
כך שאם קורה 1 יש לטפל
123, 2 הולכים להיות בכתובת

384
00:16:53,800 --> 00:16:55,730
127 בגלל שזה רק 4 פרידות משם.

385
00:16:55,730 --> 00:16:56,210
זה הכול.

386
00:16:56,210 --> 00:16:58,640
ואנו לשכוח את כל
כתובות אחרות בעולם.

387
00:16:58,640 --> 00:17:03,320
>> אז x הוא במיקום 123,
y הוא במיקום 127.

388
00:17:03,320 --> 00:17:05,770
ועכשיו, מה לעשות אני ממש
רוצה לעשות?

389
00:17:05,770 --> 00:17:10,099
כאשר אני קורא להחליף עכשיו, מה
בעצם קורה פה?

390
00:17:10,099 --> 00:17:14,920
ובכן, כאשר אני קורא להחלפה, אני מעביר ב
הכתובת של X ואת הכתובת של y.

391
00:17:14,920 --> 00:17:18,540
כך למשל, אם שני חלקים אלה
נייר עכשיו מייצגים את שני

392
00:17:18,540 --> 00:17:23,510
טיעונים וB להחליף, מה אני
הולך לכתוב על הראשונה שבן,

393
00:17:23,510 --> 00:17:27,720
שאני הולך להתקשר מתייחס כאל?

394
00:17:27,720 --> 00:17:30,610
>> בדיוק, 123.

395
00:17:30,610 --> 00:17:31,905
אז זה שאני טוען הוא.

396
00:17:31,905 --> 00:17:32,955
זהו הפרמטר.

397
00:17:32,955 --> 00:17:35,856
אני מכניס את הכתובת של x לשם.

398
00:17:35,856 --> 00:17:38,152
>> מה זה?

399
00:17:38,152 --> 00:17:40,890
>> מה זה?

400
00:17:40,890 --> 00:17:41,190
>> לא, לא.

401
00:17:41,190 --> 00:17:41,720
זה בסדר.

402
00:17:41,720 --> 00:17:42,570
עדיין טוב, עדיין טוב.

403
00:17:42,570 --> 00:17:43,530
אז זהו.

404
00:17:43,530 --> 00:17:46,240
ועכשיו בקטע השני של נייר,
זה הולך להיות ב ', ומה אני

405
00:17:46,240 --> 00:17:49,010
הולך לכתוב על
הנייר הזה?

406
00:17:49,010 --> 00:17:50,080
127.

407
00:17:50,080 --> 00:17:53,720
>> אז דבר היחיד שהשתנה מאז
המאלף הקודם שלנו של הסיפור הזה הוא,

408
00:17:53,720 --> 00:17:58,590
ולא, פשוטו כמשמעו, 1 ו -2, אני
הולך לעבור ב123 ו -127.

409
00:17:58,590 --> 00:18:02,130
ועכשיו אני הולך לשים אותם בתוך
של תיבה זו, בסדר?

410
00:18:02,130 --> 00:18:04,640
כך שהקופסה שחורה מייצגת כיום
פונקצית swap.

411
00:18:04,640 --> 00:18:07,230
>> בינתיים, בואו עכשיו יש לי של מישהו
מיישם את פונקצית swap.

412
00:18:07,230 --> 00:18:09,090
האם מישהו כאן למעלה
רוצה להתנדב?

413
00:18:09,090 --> 00:18:09,560
בואו נעלה.

414
00:18:09,560 --> 00:18:11,080
מה שמך?

415
00:18:11,080 --> 00:18:11,460
צ'רלי.

416
00:18:11,460 --> 00:18:12,080
בסדר, צ'רלי.

417
00:18:12,080 --> 00:18:14,810
בואו נעלה.

418
00:18:14,810 --> 00:18:17,310
>> אז צ'ארלי הולך לשחק
תפקידה של הקופסה השחורה שלנו.

419
00:18:17,310 --> 00:18:21,460
וצ'רלי, מה שהייתי רוצה שתעשה
כעת הוא ליישם את ההחלפה באופן כזה

420
00:18:21,460 --> 00:18:25,320
כי, בהתחשב בשתי הכתובות האלה,
אתה בעצם הולך

421
00:18:25,320 --> 00:18:26,330
כדי לשנות את הערכים.

422
00:18:26,330 --> 00:18:28,290
ואני אלחש לך באוזן
כיצד להפעיל את טלוויזיה כאן.

423
00:18:28,290 --> 00:18:29,930
>> אז קדימה, ואתה את הקופסה השחורה.

424
00:18:29,930 --> 00:18:30,920
להגיע לשם.

425
00:18:30,920 --> 00:18:34,054
מה ערכים שאתה רואה ל, ו
מה ערכים שאתה רואה לב?

426
00:18:34,054 --> 00:18:36,740
>> צ'ארלי: הוא 123 ו-B הוא 127.

427
00:18:36,740 --> 00:18:37,530
>> דוד Malan: בסדר, בדיוק.

428
00:18:37,530 --> 00:18:38,940
עכשיו יש להשהות לרגע.

429
00:18:38,940 --> 00:18:41,680
הדבר הראשון שאתה הולך לעשות עכשיו,
על פי הקוד - אשר

430
00:18:41,680 --> 00:18:43,220
אני עכשיו אצטרך להרים על המסך -

431
00:18:43,220 --> 00:18:46,750
הולך להיות להקצות קטנה
קצת זיכרון בשם זמני.

432
00:18:46,750 --> 00:18:48,850
אז אני הולך קדימה
לתת לך את הזיכרון.

433
00:18:48,850 --> 00:18:52,210
>> אז זה הולך להיות משתנה שלישי
שיש לך נגיש ל

434
00:18:52,210 --> 00:18:54,080
אתה נקרא זמני.

435
00:18:54,080 --> 00:18:57,120
ומה אתה הולך לכתוב
על פיסת נייר הזמנית?

436
00:18:57,120 --> 00:19:02,524

437
00:19:02,524 --> 00:19:03,470
>> צ'ארלי: מצביעים, נכון?

438
00:19:03,470 --> 00:19:04,790
>> דוד Malan: בסדר, גם לא
דווקא מצביעים.

439
00:19:04,790 --> 00:19:07,230
אז שורת קוד שיש לי
מודגש בצד ימין,

440
00:19:07,230 --> 00:19:07,900
בואו נתחיל שם.

441
00:19:07,900 --> 00:19:08,890
זה אומר כוכב.

442
00:19:08,890 --> 00:19:11,670
אז שומר כעת
מספר 123.

443
00:19:11,670 --> 00:19:16,660
ורק באופן אינטואיטיבי, מה
לא כוכב 123 אומר?

444
00:19:16,660 --> 00:19:21,630
>> אבל באופן ספציפי, אם הוא
123, כוכב מה זה אומר?

445
00:19:21,630 --> 00:19:22,560
הערך.

446
00:19:22,560 --> 00:19:24,580
או יותר כבדרך אגב, ללכת לשם.

447
00:19:24,580 --> 00:19:28,620
אז הרשה לי להציע את זה, מחזיק ב
היד שלך, קדימה ולטפל בזה

448
00:19:28,620 --> 00:19:29,430
כאילו זה מפה.

449
00:19:29,430 --> 00:19:32,940
וללכת על עצמך למחשב של
זיכרון, ולמצוא לנו מה היא

450
00:19:32,940 --> 00:19:36,520
במיקום 123.

451
00:19:36,520 --> 00:19:37,720
בדיוק.

452
00:19:37,720 --> 00:19:41,100
>> כך אנו רואים במיקום 123
מה, ברור?

453
00:19:41,100 --> 00:19:44,240
אוקיי, עכשיו, אז מה ערכך
הולך להכניס זמני?

454
00:19:44,240 --> 00:19:44,750
בדיוק.

455
00:19:44,750 --> 00:19:45,600
אז קדימה, לעשות את זה.

456
00:19:45,600 --> 00:19:51,280
ולכתוב את המספר 1 בפיסה
נייר שכרגע זה שכותרתו זמנית.

457
00:19:51,280 --> 00:19:53,540
>> ועכשיו השלב הבא ש
אתה הולך ליישם

458
00:19:53,540 --> 00:19:54,310
הולך להיות מה.

459
00:19:54,310 --> 00:19:57,820
ובכן, בצד של הזכות
השורה הבאה של קוד היא כוכב ב. ב ', של

460
00:19:57,820 --> 00:19:59,260
כמובן, מאחסן את כתובת.

461
00:19:59,260 --> 00:20:02,270
כי כתובות 127.

462
00:20:02,270 --> 00:20:06,620
כוכב B מתכוון למה, כבדרך אגב מדבר?

463
00:20:06,620 --> 00:20:08,700
>> עבור למיקום זה.

464
00:20:08,700 --> 00:20:14,988
אז קדימה, תמצא אותנו מה
במיקום 127.

465
00:20:14,988 --> 00:20:15,480
אישור.

466
00:20:15,480 --> 00:20:19,170
כמובן, במיקום 127,
עדיין הערך 2.

467
00:20:19,170 --> 00:20:24,060
אז מה אתה הולך עכשיו בחנות
כל מה שהוא במיקום ב?

468
00:20:24,060 --> 00:20:26,860
אז כוכבים אמצעי ללכת למיקום.

469
00:20:26,860 --> 00:20:29,770
מהו המיקום?

470
00:20:29,770 --> 00:20:30,430
>> בדיוק.

471
00:20:30,430 --> 00:20:34,190
אז עכשיו, אם אתה רוצה לשנות
מה במיקום זה -

472
00:20:34,190 --> 00:20:36,470
אני אלך קדימה ולרוץ
המחק נמצא כאן.

473
00:20:36,470 --> 00:20:37,760
ועכשיו החזיר אותו על המברשת.

474
00:20:37,760 --> 00:20:42,190
מה מספר שאתה הולך לכתוב
שבתיבה הריקה עכשיו?

475
00:20:42,190 --> 00:20:42,850
>> בדיוק.

476
00:20:42,850 --> 00:20:46,470
אז הקו הזה של קוד, כדי שיהיה ברור - תן
שלי להשהות את מה שעושה צ'רלי ו

477
00:20:46,470 --> 00:20:51,730
תציין כאן, מה שהוא עשה הוא פשוט
לכתוב שלתיבה במיקום 123

478
00:20:51,730 --> 00:20:55,150
הערך שהיה בעבר ב-B.

479
00:20:55,150 --> 00:20:59,140
ולכן אנחנו עכשיו כבר מיושמים אכן
קו שני זה של קוד.

480
00:20:59,140 --> 00:21:01,920
>> עכשיו למרבה הצער, יש
עדיין שורה אחת שנותרה.

481
00:21:01,920 --> 00:21:04,900
עכשיו מה שנמצא בטמפ ', פשוטו כמשמעו?

482
00:21:04,900 --> 00:21:06,200
זה ללא ספק מספר אחד.

483
00:21:06,200 --> 00:21:07,020
זה לא כתובת.

484
00:21:07,020 --> 00:21:09,380
זה רק מספר, סוג של
משתנה משבוע אחד.

485
00:21:09,380 --> 00:21:13,520
>> ועכשיו כשאתה אומר הכוכב B, שפירושו
ללכת לב הכתובת, שהוא של

486
00:21:13,520 --> 00:21:15,090
כמובן כאן.

487
00:21:15,090 --> 00:21:16,020
אז ברגע שאתה מגיע לשם -

488
00:21:16,020 --> 00:21:18,320
אני אלך קדימה ולמחוק את מה בעצם
שם - ומה אתה

489
00:21:18,320 --> 00:21:20,820
הולך לכתוב עכשיו ב127 מיקום?

490
00:21:20,820 --> 00:21:22,010
>> צ'ארלי: בטמפ ', שהוא אחד.

491
00:21:22,010 --> 00:21:23,430
>> דוד Malan: טמפ ', שהוא אחד.

492
00:21:23,430 --> 00:21:25,670
ומה קורה לטמפ 'בסופו של הדבר?

493
00:21:25,670 --> 00:21:26,600
ובכן, אנחנו לא באמת יודעים.

494
00:21:26,600 --> 00:21:27,420
אנחנו לא ממש אכפת לי.

495
00:21:27,420 --> 00:21:31,090
בכל פעם שיש לנו מיושמת פונקציה
עד כה, כל משתנים מקומיים שיש לך

496
00:21:31,090 --> 00:21:31,890
אכן מקומי.

497
00:21:31,890 --> 00:21:33,060
והם פשוט נעלמים.

498
00:21:33,060 --> 00:21:35,040
הם נתבעו על ידי ההפעלה
מערכת סופו של דבר.

499
00:21:35,040 --> 00:21:39,800
>> אז העובדה שעדיין יש לו זמני
ערך 1 הוא סוג של היסוד

500
00:21:39,800 --> 00:21:41,150
לא מעניין לנו.

501
00:21:41,150 --> 00:21:43,100
בסדר, אז מחיאות כפות
אם היינו יכול לצ'רלי.

502
00:21:43,100 --> 00:21:46,400
עשה טוב מאוד.

503
00:21:46,400 --> 00:21:51,520
>> בסדר, אז מה עוד עושה
זה אומר שאנחנו יכולים לעשות?

504
00:21:51,520 --> 00:21:54,400
אז מתברר שאנחנו כבר
לספר כמה שקרים לבנים

505
00:21:54,400 --> 00:21:55,540
די הרבה זמן.

506
00:21:55,540 --> 00:21:59,990
ואכן, מתברר כי מחרוזת,
כל הזמן הזה, הוא לא באמת

507
00:21:59,990 --> 00:22:02,190
רצף של תווים כשלעצמה.

508
00:22:02,190 --> 00:22:03,980
זה סוג של שהוא באופן אינטואיטיבי.

509
00:22:03,980 --> 00:22:08,270
>> אבל מבחינה טכנית, היא מחרוזת
סוג הנתונים שאנו הכריזו פנימיים של

510
00:22:08,270 --> 00:22:12,170
ספריית CS50 כדי לפשט את העולם
בשבועות הראשונים של כיתה.

511
00:22:12,170 --> 00:22:20,130
מה באמת היא מחרוזת היא הכתובת
של דמות במקום כלשהו בזכרון RAM.

512
00:22:20,130 --> 00:22:25,530
מחרוזת היא באמת מספר, כמו 123
או 127, זה קורה לתיחום

513
00:22:25,530 --> 00:22:28,420
שבו מתחילה במחרוזת
זכרון המחשב שלך.

514
00:22:28,420 --> 00:22:31,870
>> אבל זה לא מייצג
מחרוזת, כשלעצמה, את עצמו.

515
00:22:31,870 --> 00:22:33,460
ואנחנו יכולים לראות את זה באופן הבא.

516
00:22:33,460 --> 00:22:35,980
תן לי ללכת קדימה ולפתוח את
איזה קוד זה בקרב

517
00:22:35,980 --> 00:22:38,340
דוגמאות קוד המקור של היום.

518
00:22:38,340 --> 00:22:42,225
ואני הולך קדימה, לפתוח
עד, נניח, להשוות-0.c.

519
00:22:42,225 --> 00:22:44,830

520
00:22:44,830 --> 00:22:48,790
זוהי תכנית מרכבה, כי הוא הולך
לייעשה באופן הבא.

521
00:22:48,790 --> 00:22:49,040
>> ראשון.

522
00:22:49,040 --> 00:22:50,420
אני הולך להגיד משהו.

523
00:22:50,420 --> 00:22:52,660
ואז אני הולך קדימה,
מקבל מחרוזת מהמשתמש

524
00:22:52,660 --> 00:22:53,750
שבשורה הבאה.

525
00:22:53,750 --> 00:22:55,370
ואז אני הולך להגיד את זה שוב.

526
00:22:55,370 --> 00:22:57,540
ואז אני הולך לקבל עוד
מחרוזת מהמשתמש.

527
00:22:57,540 --> 00:23:00,390
>> ושים לב, אני מראה אחד
מחרוזות במשתנה בשם S, ו

528
00:23:00,390 --> 00:23:03,040
נוסף של מחרוזות אלה
במשתנה בשם t.

529
00:23:03,040 --> 00:23:07,480
ועכשיו אני הולך לתבוע, מאוד
סביר, שאם זה לא שווה שווה,

530
00:23:07,480 --> 00:23:08,940
המיתרים הם אותו הדבר.

531
00:23:08,940 --> 00:23:09,970
אתה מקליד את אותו דבר.

532
00:23:09,970 --> 00:23:11,830
אחר, בחוטים הם
לא אותו הדבר.

533
00:23:11,830 --> 00:23:15,440
>> אחרי הכל, אם אנחנו שני קלט ints, שתי
תווים, שני מצופים, שני זוגות, כל אחד

534
00:23:15,440 --> 00:23:18,400
את סוגי הנתונים שדברנו על
עד כה להשוות אותם -

535
00:23:18,400 --> 00:23:22,070
זוכרים שעשינו מאוד ברור לפני כמה זמן
כי אתה לא עושה את זה, כי

536
00:23:22,070 --> 00:23:25,840
סימן שוויון יחיד הוא כמובן
אופרטור ההשמה.

537
00:23:25,840 --> 00:23:26,820
כך שיהיה באג.

538
00:23:26,820 --> 00:23:29,260
>> אנו משתמשים בסימן השוויון שווה,
שאכן משווה

539
00:23:29,260 --> 00:23:31,050
דברים לשוויון אמיתי.

540
00:23:31,050 --> 00:23:32,275
אבל אני טוען שזה הוא מרכבה.

541
00:23:32,275 --> 00:23:37,400
אם אני הולך קדימה ולהפוך להשוות לאפס,
ולאחר מכן נקודת לוכסן אין להשוות לאפס.

542
00:23:37,400 --> 00:23:39,700
ואני מקליד ב, בואו נגיד, הלו.

543
00:23:39,700 --> 00:23:41,590
ואז בואו להגיד שלום שוב.

544
00:23:41,590 --> 00:23:46,040
פשוטו כמשמעו, את אותו דבר, מחשב
תביעות הקלדתי את הדברים שונים.

545
00:23:46,040 --> 00:23:47,640
>> עכשיו אולי אני רק הוקלדתי בטעות משהו.

546
00:23:47,640 --> 00:23:49,910
אני הקלד את השם שלי הפעם.

547
00:23:49,910 --> 00:23:52,580
אני אומר, הלו.

548
00:23:52,580 --> 00:23:54,770
שלום.

549
00:23:54,770 --> 00:23:57,360
זה שונה בכל פעם.

550
00:23:57,360 --> 00:23:58,430
>> ובכן, מדוע זה כך?

551
00:23:58,430 --> 00:24:00,140
מה באמת קורה
מתחת למכסת המנוע?

552
00:24:00,140 --> 00:24:03,270
ובכן, מה באמת קורה מתחת
מכסה המנוע הוא מחרוזת אז

553
00:24:03,270 --> 00:24:07,410
אני הקלדתי שבפעם הראשונה למשל
שלום היא המילה, כמובן.

554
00:24:07,410 --> 00:24:11,660
אבל אם אנחנו מייצגים את זה מתחת
מכסה המנוע, זוכר כי

555
00:24:11,660 --> 00:24:13,470
מחרוזת היא במערך.

556
00:24:13,470 --> 00:24:15,040
ואנחנו כבר אמרו כל כך הרבה בעבר.

557
00:24:15,040 --> 00:24:20,200
>> אז אם אני מצייר כמו שמערך הזה, אני
הולך לייצג משהו די

558
00:24:20,200 --> 00:24:23,030
בדומה למה שעשינו לפני רגע.

559
00:24:23,030 --> 00:24:25,390
ויש באמת משהו
מדי מיוחד כאן,.

560
00:24:25,390 --> 00:24:28,090
מה אנו קובעים שעל
סופו של כל מחרוזת?

561
00:24:28,090 --> 00:24:30,760
כן, אפס הקו הנטוי הזה, שהוא
רק דרך לייצג,

562
00:24:30,760 --> 00:24:33,610
פשוטו כמשמעו, 00000000.

563
00:24:33,610 --> 00:24:35,680
שמונה 0 ביטים ברציפות.

564
00:24:35,680 --> 00:24:37,610
>> אני לא יודע, בכנות,
מה אחרי זה.

565
00:24:37,610 --> 00:24:40,090
זה פשוט יותר זיכרון RAM חבורה
חלק פנימי של המחשב שלי.

566
00:24:40,090 --> 00:24:40,970
אבל זה מערך.

567
00:24:40,970 --> 00:24:42,260
דיברנו על מערכים בעבר.

568
00:24:42,260 --> 00:24:45,010
ואנחנו בדרך כלל מדברים על מערכים
כמיקום אפס,

569
00:24:45,010 --> 00:24:46,580
אז אחת, ואז שתיים.

570
00:24:46,580 --> 00:24:47,950
אבל זה רק מטעמי נוחות.

571
00:24:47,950 --> 00:24:49,380
וזה יחסי לחלוטין.

572
00:24:49,380 --> 00:24:53,010
>> כאשר אתה בעצם מקבל מזיכרון
מחשב, שזה כמובן כל

573
00:24:53,010 --> 00:24:55,450
2 מיליארדים כמה בתים מוזרים, באופן פוטנציאלי.

574
00:24:55,450 --> 00:24:59,100
אז באמת מתחת למכסת המנוע,
כל הזמן הזה, כן.

575
00:24:59,100 --> 00:25:01,670
זה עשוי להיות טוב מאוד אפס סוגר.

576
00:25:01,670 --> 00:25:04,780
אבל אם אתה חופר עמוק יותר מתחת
את מכסה המנוע, זה ממש

577
00:25:04,780 --> 00:25:07,000
לטפל במספר 123.

578
00:25:07,000 --> 00:25:09,150
זוהי כתובת 124.

579
00:25:09,150 --> 00:25:11,040
זוהי כתובת 125.

580
00:25:11,040 --> 00:25:12,540
>> ואני לא אפשל הפעם.

581
00:25:12,540 --> 00:25:15,840
אלה הם כיום אחד בתים
מלבד מה סיבה?

582
00:25:15,840 --> 00:25:17,930
מה גודלו של char?

583
00:25:17,930 --> 00:25:19,170
Char הוא רק בית אחד.

584
00:25:19,170 --> 00:25:20,570
Int הוא בדרך כלל ארבעה בתים.

585
00:25:20,570 --> 00:25:24,850
אז בגלל זה אני עשיתי את זה 123,
127, 131 וכן הלאה.

586
00:25:24,850 --> 00:25:27,560
עכשיו אני יכול לשמור את המתמטיקה פשוטה
ופשוט לעשות 1 ועוד.

587
00:25:27,560 --> 00:25:30,510
וזה עכשיו מה באמת קורה
על מתחת למכסת המנוע.

588
00:25:30,510 --> 00:25:37,760
>> לכן, כאשר אתה מצהיר משהו כזה,
מחרוזת של, זה בעצם -

589
00:25:37,760 --> 00:25:39,170
מתברר -

590
00:25:39,170 --> 00:25:41,190
כוכב char.

591
00:25:41,190 --> 00:25:44,640
כוכב, כמובן, משמעות הדבר היא
כתובת, מצביע aka.

592
00:25:44,640 --> 00:25:46,200
אז זה הכתובת של משהו.

593
00:25:46,200 --> 00:25:47,510
מהו אותו את הכתובת של?

594
00:25:47,510 --> 00:25:47,760
>> ובכן -

595
00:25:47,760 --> 00:25:51,680
אני יחיד שיכול לראות את הטוב
נקודה חשובה שאני עושה, או חושב

596
00:25:51,680 --> 00:25:52,560
אני עושה.

597
00:25:52,560 --> 00:25:55,270
אז מחרוזת -

598
00:25:55,270 --> 00:25:57,180
הדבר העצוב הוא שיש לי מסך
ממש שם איפה אני

599
00:25:57,180 --> 00:25:58,100
יכל לראות את זה.

600
00:25:58,100 --> 00:26:00,990
>> בסדר, אז מחרוזת של מה
אני הצהיר בעבר.

601
00:26:00,990 --> 00:26:04,600
אבל מתברר, הודות למעט
קסם בספרייה CS50, כל זה

602
00:26:04,600 --> 00:26:08,780
יש מחרוזת זמן, פשוטו כמשמעו,
היה כוכב char.

603
00:26:08,780 --> 00:26:11,310
הכוכבים אומר שוב
מצביע או כתובת.

604
00:26:11,310 --> 00:26:14,180
עובדה שזה איגוף
המילה char אומר שזה

605
00:26:14,180 --> 00:26:15,970
כתובת של אופי.

606
00:26:15,970 --> 00:26:23,100
>> אז אם תקבל מחרוזת נקראת, ואני מקליד
בH-E-L-L-O, מציע כעת את מה שיקבל

607
00:26:23,100 --> 00:26:27,330
מחרוזת, פשוטו כמשמעו, הייתה חוזר כל
הפעם, למרות שיש לנו ולא

608
00:26:27,330 --> 00:26:29,980
פשטני בעולם?

609
00:26:29,980 --> 00:26:33,310
מה בעצם מקבל מחרוזת
תחזור כערך ההחזרה שלה?

610
00:26:33,310 --> 00:26:35,830

611
00:26:35,830 --> 00:26:38,720
>> 123 במקרה זה, למשל.

612
00:26:38,720 --> 00:26:42,630
אנחנו כבר אמרו בעבר כי תקבלו מחרוזת
פשוט מחזירה מחרוזת, רצף של

613
00:26:42,630 --> 00:26:43,300
תווים.

614
00:26:43,300 --> 00:26:44,790
אבל זה קצת שקר לבן.

615
00:26:44,790 --> 00:26:48,010
הדרך לקבל מחרוזת באמת עובדת
מתחת למכסת המנוע הוא שהוא מקבל

616
00:26:48,010 --> 00:26:48,930
מחרוזת מהמשתמש.

617
00:26:48,930 --> 00:26:51,530
זה שומט את התווים
הוא או הוא בסוגי זיכרון.

618
00:26:51,530 --> 00:26:54,680
זה מעמיד אותך בסופו של הדבר אפס קו נטוי
של אלה רצף של תווים.

619
00:26:54,680 --> 00:26:57,310
>> אבל אז מה מקבל מחרוזת
פשוטו כמשמעו לחזור?

620
00:26:57,310 --> 00:27:02,710
זה ממש מחזיר את הכתובת של
הבתים הראשונים בזכרון ה-RAM

621
00:27:02,710 --> 00:27:04,130
זה משמש לכוח זה.

622
00:27:04,130 --> 00:27:07,500
ומתברר, כי רק על ידי החזרת
כתובת יחידה של

623
00:27:07,500 --> 00:27:12,120
התו הראשון במחרוזת, כלומר
מספיק למציאת מכלול

624
00:27:12,120 --> 00:27:12,630
המחרוזת.

625
00:27:12,630 --> 00:27:16,930
>> במילים אחרות, לקבל את המחרוזת אין
כדי לחזור ו123 124 ו 125.

626
00:27:16,930 --> 00:27:19,950
זה לא חייב לתת לי עוד
רשימה של כל הבתים ש

627
00:27:19,950 --> 00:27:20,740
המחרוזת שלי משתמשת בו.

628
00:27:20,740 --> 00:27:22,670
בגלל אחד, הם כולם הגב אל הגב.

629
00:27:22,670 --> 00:27:28,160
ושתיים, המבוסס על הכתובת הראשונה, אני
ניתן להבין איפה המחרוזת מסתיימת.

630
00:27:28,160 --> 00:27:29,910
איך?

631
00:27:29,910 --> 00:27:33,490
>> אופי null המיוחד,
קו נטוי אפס בסוף.

632
00:27:33,490 --> 00:27:35,430
אז במילים אחרות, אם
אתה עובר בסביבה -

633
00:27:35,430 --> 00:27:36,530
חלק פנימי של משתנים -

634
00:27:36,530 --> 00:27:41,300
הכתובת של char, ואתה מניח
כי בסוף כל מחרוזת, כל

635
00:27:41,300 --> 00:27:45,040
רצף של תווים כפי שאנו בני האדם
חושב על המיתרים, אם אתה מניח כי

636
00:27:45,040 --> 00:27:48,600
בסוף כל מחרוזת כזו יש
אפס קו נטוי הפוך, אתה זהב.

637
00:27:48,600 --> 00:27:52,430
כי אתה תמיד יכול למצוא
קצה חוט.

638
00:27:52,430 --> 00:27:54,870
>> עכשיו מה באמת קורה אז
בתכנית זו?

639
00:27:54,870 --> 00:27:59,990
מדוע תכנית זו,
להשוות-0.c, עגלה?

640
00:27:59,990 --> 00:28:01,690
מה הוא בעצם השוואה?

641
00:28:01,690 --> 00:28:02,420
כן?

642
00:28:02,420 --> 00:28:05,000
>> תלמיד: [לא ברור].

643
00:28:05,000 --> 00:28:05,730
>> דוד Malan: בדיוק.

644
00:28:05,730 --> 00:28:08,350
זה השוואת בין המקומות
של המיתרים.

645
00:28:08,350 --> 00:28:12,420
אז אם המשתמש הקליד בשלום פעם אחת,
כפי שאני עשיתי, זיכרון עלול בסופו

646
00:28:12,420 --> 00:28:13,430
נראה כמו זה.

647
00:28:13,430 --> 00:28:18,210
אם המשתמש אז בסוגים שלום שוב,
אבל על ידי קורא מקבל מחרוזת שוב, הוא ג

648
00:28:18,210 --> 00:28:21,800
לא חכם במיוחד, אלא אם אתה מלמד
זה להיות חכם על ידי כתיבת קוד.

649
00:28:21,800 --> 00:28:22,430
>> ג -

650
00:28:22,430 --> 00:28:23,860
ומחשבים באופן כללי -

651
00:28:23,860 --> 00:28:27,370
אם תקליד שוב שלום במילה,
אתה יודע מה אתה הולך לקבל.

652
00:28:27,370 --> 00:28:31,480
אתה פשוט הולך לקבל מערך שני
של זיכרון שכן, קורה להיות

653
00:28:31,480 --> 00:28:35,510
אחסון H-E-L-L-O וכן הלאה.

654
00:28:35,510 --> 00:28:38,240
>> זה הולך להיראות אותו הדבר ל
שלנו, בני אדם, אך הכתובת

655
00:28:38,240 --> 00:28:39,460
לא יכול להיות 123.

656
00:28:39,460 --> 00:28:42,470
זה יכול לקרות, כי רק כך
יש מערכת הפעלה מסוימת זמינה

657
00:28:42,470 --> 00:28:45,430
שטח למשל במיקום -

658
00:28:45,430 --> 00:28:49,820
בואו נגיד משהו שרירותי,
כזה הוא מיקום 200.

659
00:28:49,820 --> 00:28:51,620
ואת זה הוא מיקום 201.

660
00:28:51,620 --> 00:28:53,060
ואת זה הוא מיקום 202.

661
00:28:53,060 --> 00:28:55,730
אין לנו מושג איפה זה
הולך להיות בזיכרון.

662
00:28:55,730 --> 00:28:59,110
>> אבל מה זה אומר זה מה שהוא
הולך להיות מאוחסן בסופו של דבר זה?

663
00:28:59,110 --> 00:29:00,750
מספר 123.

664
00:29:00,750 --> 00:29:04,860
מה הולך להיות מאוחסן בT,
בדוגמה שרירותית זו?

665
00:29:04,860 --> 00:29:06,300
מספר 200.

666
00:29:06,300 --> 00:29:11,410
וכל זה אומר שלאחר מכן הוא ללא ספק,
123 לא שווה 200.

667
00:29:11,410 --> 00:29:14,940
וכך זה אם מצב לא
מוערך נכון.

668
00:29:14,940 --> 00:29:18,430
בגלל מחרוזת גט באמצעות אחרת
נתחי זיכרון בכל פעם.

669
00:29:18,430 --> 00:29:20,360
>> עכשיו אנחנו יכולים לראות את זה שוב
בדוגמה נוספת.

670
00:29:20,360 --> 00:29:23,764
תן לי ללכת קדימה ולפתוח את העותק-0.c.

671
00:29:23,764 --> 00:29:28,770
אני טוען שדוגמה זו הולכת
מנסה - אבל לא מצליח - להעתיק שתי מחרוזות

672
00:29:28,770 --> 00:29:29,910
כדלקמן.

673
00:29:29,910 --> 00:29:31,730
>> אני הולך להגיד משהו
למשתמש.

674
00:29:31,730 --> 00:29:34,490
אז אני הולך לקבל
מחרוזת וקורא לזה ש.

675
00:29:34,490 --> 00:29:36,400
ועכשיו, אני עושה את הבדיקה הזאת כאן.

676
00:29:36,400 --> 00:29:37,990
הזכרנו אחורה בזמן הזה.

677
00:29:37,990 --> 00:29:42,490
אבל כאשר עלול לקבל אפס תשואת מחרוזת,
תו מיוחד אחר, או מיוחד

678
00:29:42,490 --> 00:29:45,050
הסמל נניח.

679
00:29:45,050 --> 00:29:45,900
אם זה מתוך זיכרון.

680
00:29:45,900 --> 00:29:48,970
>> לדוגמה, אם המשתמש הוא באמת
להיות קשה וסוגים זוועתיים

681
00:29:48,970 --> 00:29:51,220
מספר התווים ב
מקלדת ולהיטים Enter.

682
00:29:51,220 --> 00:29:54,580
אם מספר תווים שפשוט לא יכול
תתאים בזכרון RAM לכל מה משוגע

683
00:29:54,580 --> 00:29:57,820
סיבה, אולי גם לקבל מחרוזת
טוב מאוד תחזיר null.

684
00:29:57,820 --> 00:30:01,080
>> או אם התכנית שלך עצמו הוא עושה הרבה
של דברים אחרים ויש רק

685
00:30:01,080 --> 00:30:03,790
לא מספיק זיכרון עבור מחרוזת גט
כדי להצליח, זה עלול בסופו

686
00:30:03,790 --> 00:30:05,240
עד חוזר ריקה.

687
00:30:05,240 --> 00:30:07,160
אבל בואו נהיה מדויק יותר
על מה זה.

688
00:30:07,160 --> 00:30:10,280
מהו הסוג של נתונים של ממש?

689
00:30:10,280 --> 00:30:11,610
כוכב צ'אר.

690
00:30:11,610 --> 00:30:14,560
>> אז מתברר עכשיו אנחנו יכולים לקלף
לגבות את שכבה ריקה.

691
00:30:14,560 --> 00:30:17,500
מתברר, null הוא - כן, ברור
סמל מיוחד.

692
00:30:17,500 --> 00:30:19,190
אבל מה זה באמת?

693
00:30:19,190 --> 00:30:25,220
באמת, null הוא רק סמל שאנחנו
בני אדם משתמשים כדי לייצג אפס גם כן.

694
00:30:25,220 --> 00:30:29,010
>> אז המחברים של C, והמחשבים
באופן כללי יותר, החליט לפני שנים

695
00:30:29,010 --> 00:30:30,010
כי, אתם יודעים מה.

696
00:30:30,010 --> 00:30:34,850
למה שלא להבטיח שאף משתמש
הנתונים הוא אי פעם, אף פעם, אף פעם

697
00:30:34,850 --> 00:30:36,730
מאוחסן באפס שלום?

698
00:30:36,730 --> 00:30:39,610
למעשה, אפילו בדוגמא השרירותית שלי
בעבר, אני לא התחלתי את המספור

699
00:30:39,610 --> 00:30:40,390
בתים באפס.

700
00:30:40,390 --> 00:30:41,540
התחלתי בשעה אחת.

701
00:30:41,540 --> 00:30:44,950
כי ידעתי שאנשים בעולם
החליט להזמין אפס

702
00:30:44,950 --> 00:30:47,970
בתים בזכרון RAM של מישהו כמו
משהו מיוחד.

703
00:30:47,970 --> 00:30:52,020
>> להיות הסיבה לכך, בכל עת שתרצה
סימן שמשהו השתבש

704
00:30:52,020 --> 00:30:55,960
בנוגע לכתובות, חזר לך
null - הידוע גם אפס -

705
00:30:55,960 --> 00:30:59,410
וכי אתה יודע שאין שום
נתונים חוקיים בכתובת אפס, באופן ברור

706
00:30:59,410 --> 00:31:00,400
זה אומר שגיאה.

707
00:31:00,400 --> 00:31:04,080
וזו הסיבה שאנו, על ידי אמנה, לבדוק
לבטלה ולחזור משהו

708
00:31:04,080 --> 00:31:06,260
כמו אחד במקרים אלה.

709
00:31:06,260 --> 00:31:09,300
>> אז אם אנחנו לגלול למטה עכשיו, זה רק
אז איזה בדיקת שגיאות, רק במקרה

710
00:31:09,300 --> 00:31:10,610
משהו השתבש עם [? ערבות?]

711
00:31:10,610 --> 00:31:13,470
לגמרי וסיימתי את התכנית
על ידי חזרה מוקדם.

712
00:31:13,470 --> 00:31:19,030
קו זה יכול עכשיו להיות משוכתב
כמו זה, שפירושו מה?

713
00:31:19,030 --> 00:31:23,155
בצד השמאל, תן לי עוד
מצביע לתו, וקורא לזה לא.

714
00:31:23,155 --> 00:31:26,935
מה אני אחסון פנימי של T, המבוסס
בשורה אחת של הקוד הזה?

715
00:31:26,935 --> 00:31:30,950

716
00:31:30,950 --> 00:31:32,170
>> אני אחסון מיקום.

717
00:31:32,170 --> 00:31:34,742
באופן ספציפי את המיקום
שהיה בים.

718
00:31:34,742 --> 00:31:39,000
אז אם המשתמש הקליד בשלום, ו
כי שלום הראשון שקורה בסופו של

719
00:31:39,000 --> 00:31:42,567
כאן, ולאחר מכן את המספר 123 היא
אחזור מלקבל

720
00:31:42,567 --> 00:31:43,810
מחרוזת ולהיות מאוחסן -

721
00:31:43,810 --> 00:31:44,780
כמו שאמרנו קודם -

722
00:31:44,780 --> 00:31:45,440
בים.

723
00:31:45,440 --> 00:31:50,560
>> כשאני מצהיר עכשיו מצביע אחר
לא להשחיר וקוראים לזה, מהו מספר

724
00:31:50,560 --> 00:31:53,940
פשוטו כמשמעו, הולך בסופו של דבר
לא על פי הסיפור?

725
00:31:53,940 --> 00:31:55,420
אז 123.

726
00:31:55,420 --> 00:32:00,310
>> אז מבחינה טכנית עכשיו גם ים ו
לא מצביעים על מדויק

727
00:32:00,310 --> 00:32:02,410
אותם גושים של זיכרון.

728
00:32:02,410 --> 00:32:06,140
אז שים לב למה שאני הולך לעשות עכשיו כדי
להוכיח כי תכנית זו היא מרכבה.

729
00:32:06,140 --> 00:32:08,820
>> ראשית אני הולך לתבוע, עם
F הדפסה, ניצול

730
00:32:08,820 --> 00:32:10,080
העותק של המחרוזת.

731
00:32:10,080 --> 00:32:11,660
ואז אני הולך לעשות קצת
בדיקת שגיאות.

732
00:32:11,660 --> 00:32:12,160
אני הולך כדי לוודא.

733
00:32:12,160 --> 00:32:16,710
בואו נוודא שלא נמצא במחרוזת
לפחות גדול מאפס באורך,

734
00:32:16,710 --> 00:32:19,190
כך שיש איזו דמות שיש
כדי לנצל באמת.

735
00:32:19,190 --> 00:32:22,840
>> ואז אתה יכול להיזכר בזה
מדוגמאות קודמות.

736
00:32:22,840 --> 00:32:25,630
2 עליון - שהוא ב
קובץ ctype.h.

737
00:32:25,630 --> 00:32:30,800
T סוגר אפס נותן לי אפס
דמותו של לא המחרוזת.

738
00:32:30,800 --> 00:32:34,360
ו2 העליונות של אותו ערך, של
כמובן, ממיר אותו לאותיות גדולות.

739
00:32:34,360 --> 00:32:38,230
>> אז באופן אינטואיטיבי, זה מודגש קו
של קוד הוא ניצול הראשון

740
00:32:38,230 --> 00:32:40,250
מכתב לא.

741
00:32:40,250 --> 00:32:44,485
אבל זה לא ניצול, באופן אינטואיטיבי,
האות הראשונה בים.

742
00:32:44,485 --> 00:32:48,130
אבל אם אתה חושב קדימה, מה אני
עומד לראות כאשר אני מפעיל את התכנית

743
00:32:48,130 --> 00:32:54,220
ולהדפיס את שניהם המקורי,
ים, והעותק מה שנקרא, לא?

744
00:32:54,220 --> 00:32:55,350
>> הם באמת הולכים להיות אותו הדבר.

745
00:32:55,350 --> 00:32:56,600
ולמה הם הולכים להיות אותו הדבר?

746
00:32:56,600 --> 00:32:58,970

747
00:32:58,970 --> 00:33:01,020
הם גם מצביעים על
בדיוק אותו הדבר.

748
00:33:01,020 --> 00:33:01,610
אז בואו לעשות את זה.

749
00:33:01,610 --> 00:33:03,160
>> הפוך אפס עותק.

750
00:33:03,160 --> 00:33:04,070
זה הידור אישור.

751
00:33:04,070 --> 00:33:06,500
תן לי להפעיל את העותק אפס.

752
00:33:06,500 --> 00:33:10,110
תן לי להקליד משהו כמו שלום ב
כל אותיות קטנות ולאחר מכן על Enter.

753
00:33:10,110 --> 00:33:16,520
והיא טוענת שהן של מקורית
והעותק הם אכן זהה.

754
00:33:16,520 --> 00:33:17,920
>> אז מה באמת קרה כאן?

755
00:33:17,920 --> 00:33:20,100
תן לי לצייר מחדש את התמונה הזאת רק
לספר את הסיפור ב

756
00:33:20,100 --> 00:33:21,340
דרך שונה במקצת.

757
00:33:21,340 --> 00:33:26,060
מה באמת קורה מתחת
מכסה המנוע, כאשר אני מצהיר משהו כמו

758
00:33:26,060 --> 00:33:30,410
התחלה של char, או מחרוזת של,
אני מקבל מצביע -

759
00:33:30,410 --> 00:33:33,090
אשר קורה להיות ארבעה בתים
במכשיר CS50

760
00:33:33,090 --> 00:33:34,410
ובהרבה מחשבים.

761
00:33:34,410 --> 00:33:36,008
ואני הולך לקרוא לים זה.

762
00:33:36,008 --> 00:33:39,810
ואת זה יש כרגע
ערך כלשהו לא ידוע.

763
00:33:39,810 --> 00:33:43,900
>> כאשר אתה מצהיר על משתנה, אלא אם כן אתה
את עצמך את ערך שם, ה

764
00:33:43,900 --> 00:33:44,570
יודע מה יש שם.

765
00:33:44,570 --> 00:33:48,110
זה יכול להיות רצף אקראי כמה
פיסות מביצוע הקודם.

766
00:33:48,110 --> 00:33:52,490
לכן, כאשר אני, בשורת הקוד שלי מקבל
מחרוזת ולאחר מכן לאחסן את התשואה

767
00:33:52,490 --> 00:33:54,800
ערך בים מקבל מחרוזת איכשהו -

768
00:33:54,800 --> 00:33:58,520
וסופו של דבר אנו יהיו לקלף איך להגיע
עבודות מחרוזת, איכשהו מקצה

769
00:33:58,520 --> 00:34:00,480
מערך שכנראה נראה
קצת כמו זה.

770
00:34:00,480 --> 00:34:05,390
H-E-L-L-O, קו נטוי אפס.

771
00:34:05,390 --> 00:34:09,510
>> בואו נניח שזה הוא כתובת
רק 123 עקביות ראשונה.

772
00:34:09,510 --> 00:34:13,000
אז לקבל את מחרוזת תשואות, ב
קו מודגש שם, זה מחזיר את

773
00:34:13,000 --> 00:34:15,000
מספר שאמרנו, 123.

774
00:34:15,000 --> 00:34:17,420
אז מה באמת עובר בתוך ים כאן?

775
00:34:17,420 --> 00:34:26,590
>> ובכן, מה באמת קורה
בתוך שעות היא 123.

776
00:34:26,590 --> 00:34:29,250
אבל בכנות, אני קצת מקבל
מבולבל מכל הכתובות האלה,

777
00:34:29,250 --> 00:34:30,320
כל מספרים השרירותיים אלה.

778
00:34:30,320 --> 00:34:32,290
123, 124, 127.

779
00:34:32,290 --> 00:34:34,570
אז בואו באמת לפשט
העולם קצת.

780
00:34:34,570 --> 00:34:38,800
>> כאשר אנו מדברים על מצביעים, בכנות, ל
שלנו, בני אדם, מי לעזאזל אכפת איפה

781
00:34:38,800 --> 00:34:39,870
דברים הם בזיכרון?

782
00:34:39,870 --> 00:34:41,080
זה שרירותי לחלוטין.

783
00:34:41,080 --> 00:34:43,370
זה הולך להיות תלוי באופן
הרבה רם המשתמש.

784
00:34:43,370 --> 00:34:46,590
זה הולך להיות תלוי בכאשר ביום
אתה מפעיל את התכנית, אולי, ו

785
00:34:46,590 --> 00:34:48,250
מה קלט המשתמש נותן לך.

786
00:34:48,250 --> 00:34:50,060
אנחנו להתעכב על פרטים לא חשובים.

787
00:34:50,060 --> 00:34:54,230
>> אז בואו משם מופשט ואומרים את זה,
כשאתה מפעיל את שורת קוד כזה,

788
00:34:54,230 --> 00:34:57,320
char כוכב ים יקבל את התמורה
ערך של מחרוזת גט.

789
00:34:57,320 --> 00:35:02,720
למה שלא במקום רק לצייר את מה שאנחנו
להמשיך לקרוא מצביע כאילו זה

790
00:35:02,720 --> 00:35:04,140
מצביע על משהו?

791
00:35:04,140 --> 00:35:07,000
אז אני טוען שעכשיו זה עד
יש מצביע -

792
00:35:07,000 --> 00:35:08,480
מתחת למכסת המנוע זה כתובת.

793
00:35:08,480 --> 00:35:11,330
אבל זה רק מצביע על
הבית הראשון ב

794
00:35:11,330 --> 00:35:12,780
מחרוזת שהוחזרה.

795
00:35:12,780 --> 00:35:16,710
>> אם אני עכשיו אחזור לקוד כאן,
מה קורה בתחום הזה?

796
00:35:16,710 --> 00:35:20,020
ובכן, בשורה מודגשת זה עכשיו,
אני מכריז כנראה אחר

797
00:35:20,020 --> 00:35:21,070
משתנה בשם t.

798
00:35:21,070 --> 00:35:25,700
אבל זה גם מצביע, אז אני הולך
לצייר אותו כ, בתאוריה, המדויק

799
00:35:25,700 --> 00:35:26,710
אותה תיבת גודל.

800
00:35:26,710 --> 00:35:28,160
ואני הולך לקרוא לזה לא.

801
00:35:28,160 --> 00:35:33,500
>> ועכשיו אם נחזור לקוד שוב,
כשאני של החנות בתוך t,

802
00:35:33,500 --> 00:35:36,920
מה אני טכני
לשים את החלק פנימי של t?

803
00:35:36,920 --> 00:35:39,350
גם מבחינה טכנית, זה
היה מספר 123.

804
00:35:39,350 --> 00:35:42,270
אז באמת שאני צריך לכתוב
מספר 123 שם.

805
00:35:42,270 --> 00:35:43,900
אבל בואו ניקח את זה ברמה גבוהה יותר.

806
00:35:43,900 --> 00:35:48,090
לא, אם זה רק מצביע,
באופן אינטואיטיבי, הוא בדיוק את זה.

807
00:35:48,090 --> 00:35:49,800
זה כל מה שזה להיות
מאוחסן שם.

808
00:35:49,800 --> 00:35:54,970
>> אז עכשיו בשורות המעניינות האחרונות
של קוד, כשאני באמת ללכת על

809
00:35:54,970 --> 00:36:00,680
ניצול האופי אפס
בT, מה קורה?

810
00:36:00,680 --> 00:36:06,310
ובכן, לא אפס סוגר מצביע כעת
למה אופי, אני מניח?

811
00:36:06,310 --> 00:36:07,460
>> זה מצביע על שעות.

812
00:36:07,460 --> 00:36:08,870
כי לא סוגר אפס -

813
00:36:08,870 --> 00:36:12,490
זוכר, זה תחביר ישן. לא סוגר
אפס רק אומר שאם לא הוא מחרוזת, לא

814
00:36:12,490 --> 00:36:15,590
סוגר אפס פירושו מקבל אפס
דמות בכוח זה.

815
00:36:15,590 --> 00:36:18,650
אז מה זה באמת אומר
זה ללכת למערך זה -

816
00:36:18,650 --> 00:36:21,520
וכן, זה יכול להיות 123,
זה יכול להיות 124.

817
00:36:21,520 --> 00:36:22,790
אבל זה הכול יחסי, זכור.

818
00:36:22,790 --> 00:36:25,640
בכל פעם שמדבר על מערך, שיש לנו
היתרון של מדבר על

819
00:36:25,640 --> 00:36:27,000
מדדים יחסיים.

820
00:36:27,000 --> 00:36:31,120
>> ואז עכשיו אנחנו יכולים רק להניח
אפס כי לא סוגר הוא שעות.

821
00:36:31,120 --> 00:36:35,090
אז אם אני קורא 2 עליון עליו, מה זה
באמת עושה הוא ניצול

822
00:36:35,090 --> 00:36:38,290
שעות אותיות קטנות לאותיות הגדולות ח
אבל כמובן, מה היא שעות?

823
00:36:38,290 --> 00:36:41,010
זה מצביע לאותה המחרוזת המעצבן הזה.

824
00:36:41,010 --> 00:36:44,200
>> אז זה כל מה שהיה קורה
בקוד זה עד כה.

825
00:36:44,200 --> 00:36:45,960
אז מה אז המשמעות?

826
00:36:45,960 --> 00:36:48,300
איך אפשר לתקן את שתי הבעיות האלה?

827
00:36:48,300 --> 00:36:50,870
איך אפשר להשוות מחרוזות בפועל?

828
00:36:50,870 --> 00:36:53,720
>> גם באופן אינטואיטיבי, איך היית
אתה הולך על השוואת שתי

829
00:36:53,720 --> 00:36:55,090
מחרוזות לשוויון אמיתי?

830
00:36:55,090 --> 00:36:58,920

831
00:36:58,920 --> 00:37:00,750
>> מה זה אומר אם שני
המיתרים שווים?

832
00:37:00,750 --> 00:37:04,330
ברור שלא, כי הכתובות שלהם הן
שווה בזיכרון, כי זה נמוך

833
00:37:04,330 --> 00:37:06,590
יישום רמת פירוט.

834
00:37:06,590 --> 00:37:08,360
כל הדמויות הן אותו הדבר.

835
00:37:08,360 --> 00:37:12,810
אז הרשה לי להציע, והרשה לי להציג
בגרסה אחת של compare.c

836
00:37:12,810 --> 00:37:14,970
כאן, כדי להשוות-1.c.

837
00:37:14,970 --> 00:37:19,590
>> הרשו לי להציע שאנחנו עדיין מקבלים
מצביע הנקרא ים, וחנות בה

838
00:37:19,590 --> 00:37:20,610
להחזיר ערך של מחרוזת גט.

839
00:37:20,610 --> 00:37:21,750
בואו נעשה את אותו דבר עם לא.

840
00:37:21,750 --> 00:37:23,230
אז אף אחד מהקוד הוא שונה.

841
00:37:23,230 --> 00:37:25,420
אני הולך להוסיף קצת
עוד בדיקת שגיאות עכשיו.

842
00:37:25,420 --> 00:37:29,390
אז עכשיו שאנחנו סוג של פילינג גב
זה שכבות של מה בCS50 מחרוזת

843
00:37:29,390 --> 00:37:33,520
היא למעשה, אנחנו צריכים להיות יותר אנאליים
לגבי לוודא שאנחנו לא נתעלל

844
00:37:33,520 --> 00:37:35,330
ערכים לא חוקיים כמו null.

845
00:37:35,330 --> 00:37:36,440
>> אז אני פשוט הולך לבדוק.

846
00:37:36,440 --> 00:37:41,490
אם זה לא עושה null שווה ולא לא עושה
null שווה, זה אומר שאנחנו בסדר.

847
00:37:41,490 --> 00:37:44,460
קבל מחרוזת לא לפשל מקבלת
אחת מהמחרוזות האלה.

848
00:37:44,460 --> 00:37:51,270
ואתה אולי יכול לנחש עכשיו, מה
אין STR CMP לעשות מן הסתם?

849
00:37:51,270 --> 00:37:52,000
מחרוזת להשוות.

850
00:37:52,000 --> 00:37:55,470
>> אז אם יש לך תכנית ב-Java לפני,
זה כמו בשיטת שווים ב

851
00:37:55,470 --> 00:37:56,490
כיתת מחרוזת.

852
00:37:56,490 --> 00:37:57,890
אבל לאלה מכם שיש לי לא
לתכנת לפני,

853
00:37:57,890 --> 00:37:59,320
זה רק פונקצית ג.

854
00:37:59,320 --> 00:38:02,180
זה קורה לבוא
קובץ שנקרא string.h.

855
00:38:02,180 --> 00:38:03,830
זה מקום שבו הוא הכריז.

856
00:38:03,830 --> 00:38:05,110
>> ולהשוות את המחרוזת -

857
00:38:05,110 --> 00:38:07,530
אני בעצם שוכח השימוש בו,
אבל יעזוב את זה.

858
00:38:07,530 --> 00:38:10,470
נזכיר כי אנחנו יכולים לעשות
גבר, מערבבים להשוות.

859
00:38:10,470 --> 00:38:12,590
וזה הולך להעלות את
מדריך למתכנתי לינוקס.

860
00:38:12,590 --> 00:38:14,060
וזה, למען האמת, לא ברור מספיק.

861
00:38:14,060 --> 00:38:15,270
אבל אני יכול לראות כאן ש, כן.

862
00:38:15,270 --> 00:38:17,570
אני חייב לכלול string.h.

863
00:38:17,570 --> 00:38:20,590
>> וזה אומר כאן תחת תיאור "
פונקציה להשוות מחרוזת משווה

864
00:38:20,590 --> 00:38:24,560
שתי המחרוזות S1 ו S2. "וS1
וS2 הם ככל הנראה שתיים

865
00:38:24,560 --> 00:38:26,120
טיעונים עברו פנימה

866
00:38:26,120 --> 00:38:28,650
אני לא ממש זוכר מה
const הוא, אבל עכשיו שם לב -

867
00:38:28,650 --> 00:38:31,480
ואולי ראה את זה כבר כש
שיש לך להשתמש בדפים אם אתה הגבר

868
00:38:31,480 --> 00:38:32,390
יש את כל זה -

869
00:38:32,390 --> 00:38:36,220
שהכוכבים הוא רק שם נרדף char
עם מחרוזת.

870
00:38:36,220 --> 00:38:40,440
>> אז הוא משווה את שתי המחרוזות, S1 ו
S2, והיא מחזירה מספר שלם פחות

871
00:38:40,440 --> 00:38:44,930
או שווה או גדול מאפס
אם S1 נמצא, בהתאמה, כדי להיות

872
00:38:44,930 --> 00:38:47,450
פחות מ, או להתאים, או
להיות גדול מ S2.

873
00:38:47,450 --> 00:38:51,220
זה פשוט דרך מורכבת מאוד לומר
שהמחרוזת להשוות תשואות

874
00:38:51,220 --> 00:38:55,760
אפס אם שתי מחרוזות הן באופן אינטואיטיבי
זהים, תווים

875
00:38:55,760 --> 00:38:57,120
תו לתו.

876
00:38:57,120 --> 00:38:59,970
>> זה מחזיר מספר שלילי אם
ים, לפי סדר אלפביתי, אמור

877
00:38:59,970 --> 00:39:01,010
לבוא לפני לא.

878
00:39:01,010 --> 00:39:05,300
או מחזיר מספר חיובי אם
ים אמור לבוא אחרי לא

879
00:39:05,300 --> 00:39:06,170
לפי סדר אלפביתי.

880
00:39:06,170 --> 00:39:08,360
אז עם פונקציה פשוטה זו, יכולה
אתה, למשל, למיין

881
00:39:08,360 --> 00:39:09,770
חבורה שלמה של מילים?

882
00:39:09,770 --> 00:39:13,984
>> אז בגרסה חדשה זו, אני הולך
ללכת קדימה ולעשות compare1.

883
00:39:13,984 --> 00:39:15,750
נקודת לוכסן להשוות אחד.

884
00:39:15,750 --> 00:39:18,030
אני אקליד בשלום בכל המקרה נמוך יותר.

885
00:39:18,030 --> 00:39:20,300
אני הולך להקליד בשלום
בכל אותיות קטנות שוב.

886
00:39:20,300 --> 00:39:23,340
ותודה לאל עכשיו הוא מבין
אני הקלדתי את אותו דבר.

887
00:39:23,340 --> 00:39:27,520
>> בינתיים, אם אני מקליד בשלום בתחתון
מקרה ושלום במקרה העליון ו

888
00:39:27,520 --> 00:39:29,710
להשוות אותם, אני הקלדתי
דברים שונים.

889
00:39:29,710 --> 00:39:32,530
כי לא רק את הכתובות
שונה, אבל אנחנו משווים

890
00:39:32,530 --> 00:39:35,350
דמויות שונות שוב ושוב.

891
00:39:35,350 --> 00:39:37,320
>> ובכן בואו נלך ולתקן אחד
בעיה אחרת עכשיו.

892
00:39:37,320 --> 00:39:41,590
בואו לפתוח את הגרסה אחת שלי
עותק, שעכשיו מטפל

893
00:39:41,590 --> 00:39:42,900
סוגיה זו כדלקמן.

894
00:39:42,900 --> 00:39:45,650
וזה אחד הולך להיראות
קצת יותר מורכב.

895
00:39:45,650 --> 00:39:49,320
אבל אם אתה חושב על מה שאנחנו בעיה
צריך לפתור, אני מקווה שזה יהיה

896
00:39:49,320 --> 00:39:51,870
לנקות ברגע עכשיו.

897
00:39:51,870 --> 00:39:57,280
>> אז השורה ראשונה זה, char התחלה לא, ב
המונחים של הדיוט מישהו יכול להציע

898
00:39:57,280 --> 00:39:59,450
מה הקו הזה כאן אומר?

899
00:39:59,450 --> 00:40:01,050
תו לא כוכב, מה זה עושה?

900
00:40:01,050 --> 00:40:06,660

901
00:40:06,660 --> 00:40:07,210
>> טוב.

902
00:40:07,210 --> 00:40:09,500
ליצור מצביע לחלק
מקום בזיכרון.

903
00:40:09,500 --> 00:40:10,930
והרשו לי לחדד את זה קצת.

904
00:40:10,930 --> 00:40:17,180
מצהיר על משתנה שיאחסן
כתובת של איזה דמות בזיכרון, רק

905
00:40:17,180 --> 00:40:18,480
כדי להיות קצת יותר ראוי.

906
00:40:18,480 --> 00:40:21,210
>> אוקיי, אז עכשיו בצד ימין, יש לי
מעולם לא ראה את אחת מהפונקציות הללו

907
00:40:21,210 --> 00:40:22,660
בעבר, malloc.

908
00:40:22,660 --> 00:40:26,980
אבל מה שאולי אומר?

909
00:40:26,980 --> 00:40:28,050
הקצאת הזיכרון.

910
00:40:28,050 --> 00:40:29,410
הקצאת זיכרון.

911
00:40:29,410 --> 00:40:33,050
>> אז מתברר, עד עכשיו, אנחנו
לא באמת הייתה לי דרך רב עוצמה של

912
00:40:33,050 --> 00:40:36,210
שואל את מערכת ההפעלה,
תן לי קצת את זיכרון.

913
00:40:36,210 --> 00:40:39,980
במקום זאת, עכשיו יש לנו פונקציה שנקראת
malloc שעושה בדיוק את זה.

914
00:40:39,980 --> 00:40:42,960
למרות שזה קצת
הסחת דעת עכשיו, שים לב כי ב

915
00:40:42,960 --> 00:40:46,200
בין שני הסוגריים הוא
פשוט הולך להיות מספר.

916
00:40:46,200 --> 00:40:48,510
איפה אני כבר הקלדתי בשאלה
סימנים יכולים להיות מספר.

917
00:40:48,510 --> 00:40:51,020
>> ומספר זה אומר,
תן לי 10 בתים.

918
00:40:51,020 --> 00:40:52,320
תן לי 20 בתים.

919
00:40:52,320 --> 00:40:53,820
תן לי 100 בתים.

920
00:40:53,820 --> 00:40:56,500
וmalloc יעשה כמיטב יכולתה
תשאל את מערכת ההפעלה -

921
00:40:56,500 --> 00:40:57,630
לינוקס, במקרה זה -

922
00:40:57,630 --> 00:40:59,630
היי, הם 100 בתיהם
של זיכרון RAM הפנוי?

923
00:40:59,630 --> 00:41:04,320
אם כן, תחזור הבתים האלה לי על ידי
חוזר שהכתובת של

924
00:41:04,320 --> 00:41:06,610
אלה בתים, אולי?

925
00:41:06,610 --> 00:41:07,610
הראשון אחד.

926
00:41:07,610 --> 00:41:10,460
>> אז גם כאן - ואת זה הוא דומיננטי
ב-C, בכל פעם שאתה

927
00:41:10,460 --> 00:41:11,680
התמודדות עם כתובות?

928
00:41:11,680 --> 00:41:15,830
אתה כמעט תמיד מתעסק עם
הכתובת ראשונה מסוגו, לא משנה כמה גדול

929
00:41:15,830 --> 00:41:19,490
נתח של זיכרון שאתה להיות
החזיר, אם אפשר לומר כך.

930
00:41:19,490 --> 00:41:20,880
>> אז בואו לצלול כאן.

931
00:41:20,880 --> 00:41:23,940
אני מנסה להקצות כמה
בתים רבים, בדיוק?

932
00:41:23,940 --> 00:41:24,080
כן.

933
00:41:24,080 --> 00:41:26,090
מחרוזת באורך של שעות - בואו
לעשות דוגמה קונקרטית.

934
00:41:26,090 --> 00:41:30,700
אם ים הוא שלום, H-E-L-L-O, מה
מחרוזת באורך של שעות, ברור?

935
00:41:30,700 --> 00:41:32,010
אז זה חמש.

936
00:41:32,010 --> 00:41:34,590
אבל אני עושה את 1 בתוספת על זה, למה?

937
00:41:34,590 --> 00:41:37,700
למה אני רוצה שישה בתים
במקום חמש?

938
00:41:37,700 --> 00:41:38,790
אופי null.

939
00:41:38,790 --> 00:41:41,210
>> אני לא רוצה לעזוב את זה
אופי null מיוחד.

940
00:41:41,210 --> 00:41:45,160
כי אם אני עושה עותק של שלום ו
פשוט לעשות את H-E-L-L-O, אבל אני לא שמתי את

941
00:41:45,160 --> 00:41:50,160
שאופי מיוחד, המחשב
ייתכן שאין לי, במקרה, קו נטוי

942
00:41:50,160 --> 00:41:51,730
לאפס שם בשבילי.

943
00:41:51,730 --> 00:41:55,570
ולכן אם אני מנסה להבין
אורכו של ההעתק, אני עשוי לחשוב כי

944
00:41:55,570 --> 00:41:59,360
זה עוד 20 תווים, או מיליון
תווים אם אני פשוט אף פעם לא יקרה

945
00:41:59,360 --> 00:42:01,050
לרמה של אפס קו נטוי.

946
00:42:01,050 --> 00:42:05,780
>> אז אנחנו צריכים שישה בתים כדי לאחסן
H-E-L-L-O, קו נטוי אפס.

947
00:42:05,780 --> 00:42:07,870
ואז זה פשוט
להיות סופר אנאלי.

948
00:42:07,870 --> 00:42:10,700
נניח שאני לא זוכר מה
גודלו של char הוא.

949
00:42:10,700 --> 00:42:12,020
אנחנו כל זמן אומרים שזה אחד בתים.

950
00:42:12,020 --> 00:42:12,860
וזה בדרך כלל.

951
00:42:12,860 --> 00:42:15,425
בתאוריה, זה יכול להיות משהו
שונה, במקינטוש או אחרים

952
00:42:15,425 --> 00:42:16,250
מחשב שונה.

953
00:42:16,250 --> 00:42:19,650
>> אז מסתבר שיש זה למפעיל
קרא sizeof שאם אתה עובר אותו

954
00:42:19,650 --> 00:42:22,680
שמו של סוג נתוני - כמו
char או int, או לצוף -

955
00:42:22,680 --> 00:42:26,930
הוא יגיד לך, באופן דינמי, כמה
הבתים char תופס על זה

956
00:42:26,930 --> 00:42:28,090
מחשב מסוים.

957
00:42:28,090 --> 00:42:31,360
>> אז זה רק בצורה יעילה
כמו לומר 1 פעמים או

958
00:42:31,360 --> 00:42:32,440
פעמים שום דבר בכלל.

959
00:42:32,440 --> 00:42:36,340
אבל אני עושה את זה רק כדי להיות סופר אנאלי,
כי רק במקרה char שונה

960
00:42:36,340 --> 00:42:40,610
במחשב שלך לעומת שלי, בדרך זו
המתמטיקה הוא תמיד הולכת לבדוק.

961
00:42:40,610 --> 00:42:43,720
>> לבסוף, כאן למטה אני בודק לריק,
וזה תמיד טוב להתאמן - שוב,

962
00:42:43,720 --> 00:42:44,920
כל זמן יש לנו עסק עם מצביעים.

963
00:42:44,920 --> 00:42:47,520
אם malloc לא היה מסוגל לתת לי
לי שש פרידות - וזה

964
00:42:47,520 --> 00:42:49,210
לא סביר, אבל רק במקרה -

965
00:42:49,210 --> 00:42:50,730
להחזיר אחת באופן מיידי.

966
00:42:50,730 --> 00:42:53,290
ועכשיו, קדימה, ולהעתיק
המחרוזת כדלקמן.

967
00:42:53,290 --> 00:42:57,240
ואת זה הוא תחביר מוכר,
אם כי בתפקיד אחר.

968
00:42:57,240 --> 00:43:01,210
>> אני הולך קדימה, לקבל את המחרוזת
אורכו של ים ולאחסן אותו בn.

969
00:43:01,210 --> 00:43:06,620
אז אני הולך כדי לעבור מאני שווה
אפס עד וכולל n,

970
00:43:06,620 --> 00:43:08,410
גדול או שווה ל.

971
00:43:08,410 --> 00:43:13,540
כך שעל כל איטרציה, שמתי
תו ה-i של S ב- i

972
00:43:13,540 --> 00:43:15,380
דמותו של t.

973
00:43:15,380 --> 00:43:18,190
>> אז מה באמת קורה מתחת
מכסה המנוע כאן?

974
00:43:18,190 --> 00:43:22,140
ובכן, אם זה, למשל, הוא ים -

975
00:43:22,140 --> 00:43:26,400
ואני הקלדתי את מילת H-E-L-L-O
ויש אפס קו נטוי.

976
00:43:26,400 --> 00:43:29,020
ושוב, זה של ההצבעה כאן.

977
00:43:29,020 --> 00:43:30,830
והנה עכשיו הוא לא.

978
00:43:30,830 --> 00:43:34,860
>> ואת זה הוא מצביע כעת ל
עותק של זיכרון, נכון?

979
00:43:34,860 --> 00:43:37,340
Malloc נתן לי כל
נתח של זיכרון.

980
00:43:37,340 --> 00:43:41,440
אני לא יודע בתחילה מה
באף אחד מהמקומות האלה.

981
00:43:41,440 --> 00:43:44,340
אז אני הולך לחשוב על אלה כ
חבורה שלמה של סימני שאלה.

982
00:43:44,340 --> 00:43:50,190
>> אבל ברגע שאני מתחיל מאפס לולאה
על דרך באורך של S, T

983
00:43:50,190 --> 00:43:52,790
סוגר אפס ולא 1 סוגר -

984
00:43:52,790 --> 00:43:55,080
ואני אשים את זה עכשיו
על תקורה -

985
00:43:55,080 --> 00:44:04,190
לא סוגר אפס ואפס של סוגר מתכוונים
שאני הולך להיות העתקה

986
00:44:04,190 --> 00:44:09,875
שעות iteratively כאן, E-L-L-O.
בנוסף, בגלל שעשיתי בתוספת

987
00:44:09,875 --> 00:44:12,370
1, קו נטוי אפס.

988
00:44:12,370 --> 00:44:19,060
>> אז עכשיו במקרה של להשוות-1.c,
בסופו של הדבר, אם אני מדפיס את

989
00:44:19,060 --> 00:44:24,760
היוון לא, אנחנו צריכים
רואה שהים הוא ללא שינוי.

990
00:44:24,760 --> 00:44:26,090
תן לי ללכת קדימה ולעשות את זה עכשיו.

991
00:44:26,090 --> 00:44:28,630
אז להפוך את COPY1.

992
00:44:28,630 --> 00:44:30,860
נקודת הלוכסן COPY1.

993
00:44:30,860 --> 00:44:33,670
אני הולך להקליד בשלום, על Enter.

994
00:44:33,670 --> 00:44:37,430
ועכשיו שם לב, רק העותק
כבר באותיות גדולות.

995
00:44:37,430 --> 00:44:40,890
כי אני באמת צריך שתיים
נתחי הזיכרון.

996
00:44:40,890 --> 00:44:44,390
>> למרבה הצער, אתה יכול לעשות כמה יפה
דברים רעים ודי מסוכנים כאן.

997
00:44:44,390 --> 00:44:49,290
תן לי למשוך את דוגמה כאן עכשיו,
זה נותן לנו דוגמה לכמה

998
00:44:49,290 --> 00:44:51,540
קווים שונים.

999
00:44:51,540 --> 00:44:56,040
אז רק באופן אינטואיטיבי כאן, השורה הראשונה
של קוד, int x הכוכב, מכריז

1000
00:44:56,040 --> 00:44:57,340
משתנה בשם x.

1001
00:44:57,340 --> 00:44:58,810
ומה סוג הנתונים
של משתנה זה?

1002
00:44:58,810 --> 00:45:01,820

1003
00:45:01,820 --> 00:45:04,290
מה סוג הנתונים של משתנה זה?

1004
00:45:04,290 --> 00:45:06,980
זה לא היה הסחרור המסוכן.

1005
00:45:06,980 --> 00:45:08,350
>> סוג הנתונים הוא כוכב int.

1006
00:45:08,350 --> 00:45:12,600
אז מה זה אומר? X יהיה
לאחסן את הכתובת של int.

1007
00:45:12,600 --> 00:45:13,520
פשוט עד כדי כך.

1008
00:45:13,520 --> 00:45:16,220
Y הולך לאחסון
כתובת של int.

1009
00:45:16,220 --> 00:45:18,390
מהי השורה השלישית
של קוד עושה שם?

1010
00:45:18,390 --> 00:45:21,850
זה הקצאה כמה
בתים, ככל הנראה?

1011
00:45:21,850 --> 00:45:22,350
ארבע.

1012
00:45:22,350 --> 00:45:25,460
בשל גודלו של int הוא
בדרך כלל ארבעה, malloc של ארבעה נותן לי

1013
00:45:25,460 --> 00:45:29,950
לי את כתובתו של נתח של
זיכרון, הראשון מבתיהם הוא

1014
00:45:29,950 --> 00:45:32,110
מאוחסן כעת בx.

1015
00:45:32,110 --> 00:45:34,410
>> עכשיו אנחנו עוברים קטן במהירות.

1016
00:45:34,410 --> 00:45:35,760
כוכב X מה זה אומר?

1017
00:45:35,760 --> 00:45:38,480

1018
00:45:38,480 --> 00:45:42,590
זה אומר ללכת לכתובת ש
ולשים את מה שיש מספר?

1019
00:45:42,590 --> 00:45:43,870
לשים את המספר 42 שם.

1020
00:45:43,870 --> 00:45:47,590
כוכב Y אומר ללכת למה בy
ולשים את המספר 13 שם.

1021
00:45:47,590 --> 00:45:48,600
>> אבל חכה רגע.

1022
00:45:48,600 --> 00:45:51,640
מהו בY ברגע?

1023
00:45:51,640 --> 00:45:54,950
מה הוא כתובת Y אחסון?

1024
00:45:54,950 --> 00:45:55,770
אנחנו לא יודעים, נכון?

1025
00:45:55,770 --> 00:45:59,230
אנחנו מעולם לא להשתמש פעם אחת את המשימה
מפעיל מעורב y.

1026
00:45:59,230 --> 00:46:03,370
אז y כהכריז על הקו השני של
קוד הוא רק חלק ערך אשפה, גדול

1027
00:46:03,370 --> 00:46:04,760
סימן שאלה אם אפשר לומר כך.

1028
00:46:04,760 --> 00:46:07,230
הוא היה יכול להצביע באופן אקראי
לכל דבר בזיכרון, אשר

1029
00:46:07,230 --> 00:46:08,340
הוא בדרך כלל רע.

1030
00:46:08,340 --> 00:46:13,540
>> אז ברגע שפגענו בקו שיש,
כוכב Y שווה 13, משהו רע,

1031
00:46:13,540 --> 00:46:17,220
משהו רע מאוד עומד
לקרות לינקי.

1032
00:46:17,220 --> 00:46:25,810
אז בואו נראה מה קורה בסופו של
קורה לינקי כאן ברגע זה

1033
00:46:25,810 --> 00:46:26,200
או כך לפחות נראה.

1034
00:46:26,200 --> 00:46:26,490
>> [השמעת וידאו]

1035
00:46:26,490 --> 00:46:26,745
>> -היי, בינקי.

1036
00:46:26,745 --> 00:46:27,000
להתעורר.

1037
00:46:27,000 --> 00:46:29,296
זה זמן בשביל כיף מצביע.

1038
00:46:29,296 --> 00:46:30,680
>> , מה זה?

1039
00:46:30,680 --> 00:46:31,980
למד על מצביעים?

1040
00:46:31,980 --> 00:46:34,010
אה, יופי.

1041
00:46:34,010 --> 00:46:37,220
>> -ובכן, כדי להתחיל בעבודה, אני מניח שאנחנו
הולך צריך כמה עצות.

1042
00:46:37,220 --> 00:46:37,930
>> -אישור.

1043
00:46:37,930 --> 00:46:41,650
קוד זה מקצה שני מצביעים
אשר יכול להצביע על מספרים שלמים.

1044
00:46:41,650 --> 00:46:43,760
>> -OK, טוב, אני רואה את שני מצביעים.

1045
00:46:43,760 --> 00:46:45,850
אבל נראה שהם לא להיות
הצבעה לכל דבר.

1046
00:46:45,850 --> 00:46:46,490
>> -נכון.

1047
00:46:46,490 --> 00:46:48,630
בתחילה, מצביעים לא
להצביע על כל דבר.

1048
00:46:48,630 --> 00:46:51,700
את הדברים שהם יצביעו לנקראים
pointees, ומקים אותם הוא

1049
00:46:51,700 --> 00:46:52,850
צעד נפרד.

1050
00:46:52,850 --> 00:46:53,740
>> -אה, נכון, נכון.

1051
00:46:53,740 --> 00:46:54,500
ידעתי את זה.

1052
00:46:54,500 --> 00:46:56,270
את pointees הם נפרדים.

1053
00:46:56,270 --> 00:46:58,553
אז איך אתה להקצות pointee?

1054
00:46:58,553 --> 00:46:59,480
>> -אישור.

1055
00:46:59,480 --> 00:47:03,707
ובכן, את הקוד הזה מקצה מספרים שלמים חדשים
pointee, וחלק זה מגדיר X

1056
00:47:03,707 --> 00:47:05,520
כדי להצביע על זה.

1057
00:47:05,520 --> 00:47:06,760
>> -היי, זה נראה טוב יותר.

1058
00:47:06,760 --> 00:47:08,520
אז להפוך אותו לעשות משהו.

1059
00:47:08,520 --> 00:47:09,530
>> -אישור.

1060
00:47:09,530 --> 00:47:14,110
אני dereference x המצביע לאחסון
המספר 42 לpointee שלה.

1061
00:47:14,110 --> 00:47:17,660
על הטריק הזה, ואני צריך את הקסם שלי
שרביט של ביטול הפניה.

1062
00:47:17,660 --> 00:47:20,695
>> -שרביט הקסם של ביטול הפניה למבנה?

1063
00:47:20,695 --> 00:47:22,632
אה, זה נהדר.

1064
00:47:22,632 --> 00:47:24,620
>> -זה מה שנראה כמו קוד.

1065
00:47:24,620 --> 00:47:27,526
אני רק להגדיר את המספר, ו--

1066
00:47:27,526 --> 00:47:28,250
>> -היי, תראה.

1067
00:47:28,250 --> 00:47:29,680
שם זה הולך.

1068
00:47:29,680 --> 00:47:34,520
אז עושה dereference על X כדלקמן
החץ לגשת pointee שלה.

1069
00:47:34,520 --> 00:47:36,690
במקרה זה, כדי לאחסן 42 שם.

1070
00:47:36,690 --> 00:47:40,890
היי, נסה להשתמש בו כדי לאחסן את המספר
13 דרך המצביע האחר, y.

1071
00:47:40,890 --> 00:47:42,125
>> -אישור.

1072
00:47:42,125 --> 00:47:46,810
אני פשוט אלך לכאן ולy
לקבל את המספר 13 להגדיר.

1073
00:47:46,810 --> 00:47:50,890
ואז לקחת את השרביט של
ביטול הפניה למבנה ורק -

1074
00:47:50,890 --> 00:47:52,430
וואו!

1075
00:47:52,430 --> 00:47:53,030
>> -הו, היי.

1076
00:47:53,030 --> 00:47:54,610
זה לא עבד.

1077
00:47:54,610 --> 00:47:58,200
תגידו, בינקי, אני לא חושב
ביטול הפניה למבנה Y הוא רעיון טוב,

1078
00:47:58,200 --> 00:48:01,370
בגלל הגדרת pointee
הוא צעד נפרד.

1079
00:48:01,370 --> 00:48:03,460
ואני לא חושב שאי פעם עשינו את זה.

1080
00:48:03,460 --> 00:48:03,810
>> -הממ.

1081
00:48:03,810 --> 00:48:05,160
נקודה טובה.

1082
00:48:05,160 --> 00:48:07,410
>> 'כן, אנחנו מוקצים y המצביע.

1083
00:48:07,410 --> 00:48:10,045
אבל אנחנו אף פעם לא להגדיר אותו
להצביע על pointee.

1084
00:48:10,045 --> 00:48:10,490
>> -הממ.

1085
00:48:10,490 --> 00:48:12,170
דתי מאוד.

1086
00:48:12,170 --> 00:48:13,790
>> היי-, שאתה מחפש
טוב שיש, בינקי.

1087
00:48:13,790 --> 00:48:16,920
האם אתה יכול לתקן אותו כך שנקודות y
לאותו pointee כX?

1088
00:48:16,920 --> 00:48:17,810
>> -בטח.

1089
00:48:17,810 --> 00:48:20,300
אני אשתמש בשרביט הקסמים שלי
מצביע משימה.

1090
00:48:20,300 --> 00:48:22,240
>> -האם זה הולך להיות
בעיה כמו בעבר?

1091
00:48:22,240 --> 00:48:22,665
>> -No.

1092
00:48:22,665 --> 00:48:24,300
זה לא לגעת בpointees.

1093
00:48:24,300 --> 00:48:27,880
זה פשוט משנה את מצביע אחד שיצביע
לאותו דבר כמו אחר.

1094
00:48:27,880 --> 00:48:28,970
>> -אה, אני מבין.

1095
00:48:28,970 --> 00:48:31,730
עכשיו נקודות y לאותו המקום כמו x.

1096
00:48:31,730 --> 00:48:32,450
אז תחכה.

1097
00:48:32,450 --> 00:48:33,490
עכשיו Y הוא קבוע.

1098
00:48:33,490 --> 00:48:34,630
יש לו pointee.

1099
00:48:34,630 --> 00:48:36,520
אז אתה יכול לנסות את השרביט
של ביטול הפניה למבנה שוב

1100
00:48:36,520 --> 00:48:39,200
לשלוח 13 נגמר.

1101
00:48:39,200 --> 00:48:39,840
>> -אישור.

1102
00:48:39,840 --> 00:48:41,570
הנה זה בא.

1103
00:48:41,570 --> 00:48:42,870
>> -היי, תראה את זה.

1104
00:48:42,870 --> 00:48:44,320
ביטול הפניה למבנה החברה עובד על y.

1105
00:48:44,320 --> 00:48:47,020
ומכיוון שאת המצביעים משתפים
שpointee אחד, הם

1106
00:48:47,020 --> 00:48:48,585
שניהם רואים 13.

1107
00:48:48,585 --> 00:48:49,040
>> -כן.

1108
00:48:49,040 --> 00:48:49,670
שיתוף.

1109
00:48:49,670 --> 00:48:50,380
לא משנה מה.

1110
00:48:50,380 --> 00:48:52,290
אז אנחנו הולכים להחליף מקומות עם החברה?

1111
00:48:52,290 --> 00:48:52,970
>> -הו, תראה.

1112
00:48:52,970 --> 00:48:54,150
נגמר לנו זמן.

1113
00:48:54,150 --> 00:48:55,200
>> -אבל -

1114
00:48:55,200 --> 00:48:57,060
>> רק תזכרו-שלוש
כללי מצביע.

1115
00:48:57,060 --> 00:49:00,100
מספר אחד, את המבנה הבסיסי
הוא שיש לך מצביע.

1116
00:49:00,100 --> 00:49:02,170
והוא מצביע על לpointee.

1117
00:49:02,170 --> 00:49:04,160
אבל המצביע וpointee
הם נפרדים.

1118
00:49:04,160 --> 00:49:06,460
והטעות הנפוצה היא
להגדיר את מצביע, אלא

1119
00:49:06,460 --> 00:49:08,540
תשכח ניתנה pointee.

1120
00:49:08,540 --> 00:49:12,460
>> מספר שתיים, ביטול הפנית המצביע מתחילה
במצביע ועוקב

1121
00:49:12,460 --> 00:49:14,570
חץ מעל לגשת pointee שלה.

1122
00:49:14,570 --> 00:49:18,640
כפי שכולנו יודעים, זה עובד רק אם יש
הוא pointee, שחוזר ל

1123
00:49:18,640 --> 00:49:19,790
כלל מספר אחת.

1124
00:49:19,790 --> 00:49:23,670
>> מספר שלוש, הקצאת מצביע לוקח
מצביע אחד ושינויים בו כדי להצביע על

1125
00:49:23,670 --> 00:49:25,850
אותו pointee כמצביע אחר.

1126
00:49:25,850 --> 00:49:27,840
אז אחרי המשימה,
שני המצביעים יהיו

1127
00:49:27,840 --> 00:49:29,430
להצביע לאותו pointee.

1128
00:49:29,430 --> 00:49:31,600
לפעמים זה נקרא שיתוף.

1129
00:49:31,600 --> 00:49:33,430
וזה כל מה שיש בו, באמת.

1130
00:49:33,430 --> 00:49:33,840
ביי ביי עכשיו.

1131
00:49:33,840 --> 00:49:34,300
>> [השמעת וידאו הסוף]

1132
00:49:34,300 --> 00:49:36,940
>> דוד Malan: אז עוד על מצביעים,
נוסף על השבוע הבא בינקי.

1133
00:49:36,940 --> 00:49:38,190
נתראה ביום שני.

1134
00:49:38,190 --> 00:49:42,187