1
00:00:00,000 --> 00:00:06,030
>> [השמעת מוסיקה]

2
00:00:06,030 --> 00:00:08,390
>> דאג LLOYD: מצביעים, אנחנו כאן.

3
00:00:08,390 --> 00:00:11,080
זה כנראה הולך ל
להיות הנושא הקשה ביותר

4
00:00:11,080 --> 00:00:12,840
שאנחנו מדברים על בCS50.

5
00:00:12,840 --> 00:00:15,060
ואם יצאת לך לקרוא
שום דבר על מצביעים

6
00:00:15,060 --> 00:00:19,080
לפני שאתה עלול להיות קצת
מפחיד להיכנס לווידאו הזה.

7
00:00:19,080 --> 00:00:21,260
זה נכון המצביעים
אל תאפשר לך את היכולת

8
00:00:21,260 --> 00:00:23,740
לפשל אולי
די קשה כשאתה

9
00:00:23,740 --> 00:00:27,450
עבודה עם משתנים, ונתונים,
וגורם לתכנית שלך לקרוס.

10
00:00:27,450 --> 00:00:30,490
אבל הם ממש ממש שימושיים
והם מאפשרים לנו דרך גדולה באמת

11
00:00:30,490 --> 00:00:33,340
להעביר נתונים הלוך ו
שוב בין פונקציות,

12
00:00:33,340 --> 00:00:35,490
שאנחנו בדרך אחרת לא יכולים לעשות.

13
00:00:35,490 --> 00:00:37,750
>> ואז מה שאנחנו באמת
רוצה לעשות כאן היא רכבת

14
00:00:37,750 --> 00:00:41,060
ליש לך משמעת מצביע טובה, כל כך
שאתה יכול להשתמש במצביעים ביעילות

15
00:00:41,060 --> 00:00:43,850
כדי להפוך את התוכניות שלך, כי הרבה יותר טובים.

16
00:00:43,850 --> 00:00:48,220
כפי שאמרתי מצביעים לתת השונים
דרך להעביר נתונים בין פונקציות.

17
00:00:48,220 --> 00:00:50,270
עכשיו, אם אתה זוכר מ
וידאו קודם לכן, כאשר

18
00:00:50,270 --> 00:00:53,720
אנחנו מדברים על
היקף משתנה, שציינתי

19
00:00:53,720 --> 00:01:00,610
כי כל הנתונים שאנו עוברים בין
פונקציות בC מועברת על ידי ערך.

20
00:01:00,610 --> 00:01:03,070
ואולי אני לא השתמשתי שב
טווח, מה שהתכוונתי שם

21
00:01:03,070 --> 00:01:07,170
היה שאנו מעבירים עותקים של נתונים.

22
00:01:07,170 --> 00:01:12,252
כאשר אנו עוברים משתנים לפונקציה,
אנחנו לא ממש עוברים משתנים

23
00:01:12,252 --> 00:01:13,210
לפונקציה, נכון?

24
00:01:13,210 --> 00:01:17,670
אנחנו עוברים עותק של
נתונים שלפונקציה.

25
00:01:17,670 --> 00:01:20,760
הפונקציה עושה מה שהוא יהיה
והיא מחשבת כמה ערך,

26
00:01:20,760 --> 00:01:23,180
ואולי אנו משתמשים ערך ש
כאשר הוא נותן אותו בחזרה.

27
00:01:23,180 --> 00:01:26,700
>> היה חריג אחד ל
כלל זה של העברה לפי ערך,

28
00:01:26,700 --> 00:01:31,210
ואנחנו נחזור למה ש
קצת מאוחר יותר בסרט הזה.

29
00:01:31,210 --> 00:01:34,880
אם אנחנו משתמשים במצביעים במקום
שימוש במשתנים,

30
00:01:34,880 --> 00:01:38,180
או במקום להשתמש במשתנים
בעצמם או העתקים של המשתנים,

31
00:01:38,180 --> 00:01:43,790
עכשיו אנחנו יכולים להעביר את המשתנים סביב
בין פונקציות בצורה שונה.

32
00:01:43,790 --> 00:01:46,550
משמעות דבר היא שאם אנחנו עושים
שינוי בתפקוד אחד,

33
00:01:46,550 --> 00:01:49,827
שינוי זה בעצם לקחת
אפקט בתפקיד שונה.

34
00:01:49,827 --> 00:01:52,160
שוב, זה משהו ש
לא יכולתי לעשות בעבר,

35
00:01:52,160 --> 00:01:56,979
ואם אי פעם ניסו להחליף
ערך של שני משתנים בפונקציה,

36
00:01:56,979 --> 00:01:59,270
שמת לב לבעיה זו
סוג של זחילה, נכון?

37
00:01:59,270 --> 00:02:04,340
>> אם אנחנו רוצים להחליף X ו- Y, ואנחנו
להעביר אותם לפונקציה שנקראת החלפה,

38
00:02:04,340 --> 00:02:08,680
בתוך הפונקציה להחליף
משתנים לעשות ערכי חליפין.

39
00:02:08,680 --> 00:02:12,600
אחד הופך לשתיים, שני הופכים
אחד, אבל אנחנו לא ממש

40
00:02:12,600 --> 00:02:16,890
לשנות משהו במקור
פונקציה, במתקשר.

41
00:02:16,890 --> 00:02:19,550
כי אנחנו לא יכולים, אנחנו רק
עבודה עם עותקים שלהם.

42
00:02:19,550 --> 00:02:24,760
עם מצביעים אם כי, אנחנו יכולים
למעשה עובר X ​​ו- Y לפונקציה.

43
00:02:24,760 --> 00:02:26,960
פונקציה שיכולה לעשות
משהו איתם.

44
00:02:26,960 --> 00:02:29,250
וערכי משתנים אלה
באמת יכול לשנות.

45
00:02:29,250 --> 00:02:33,710
אז זה די שינוי ב
היכולת שלנו לעבוד עם נתונים.

46
00:02:33,710 --> 00:02:36,100
>> לפני שנצלול ל
מצביעים, אני חושב שזה שווה

47
00:02:36,100 --> 00:02:38,580
לוקח לכמה דקות
לחזור ליסודות כאן.

48
00:02:38,580 --> 00:02:41,000
ויש להסתכל על איך
עבודות זיכרון מחשב

49
00:02:41,000 --> 00:02:45,340
משום ששני נושאים אלה הולכים
להיות בעצם די קשורים.

50
00:02:45,340 --> 00:02:48,480
כפי שאתה בוודאי יודע,
על מערכת המחשב שלך

51
00:02:48,480 --> 00:02:51,310
יש לך כונן קשיח או
אולי כונן מצב מוצק,

52
00:02:51,310 --> 00:02:54,430
איזה מיקום אחסון קבצים.

53
00:02:54,430 --> 00:02:57,950
זה בדרך כלל אי ​​שם ב
שכונה של 250 ג'יגה-בתים

54
00:02:57,950 --> 00:02:59,810
לאולי כמה טרה עכשיו.

55
00:02:59,810 --> 00:03:02,270
וזה שבו כולכם
קבצי סופו של דבר לחיות,

56
00:03:02,270 --> 00:03:04,870
גם כאשר המחשב סגור
את, אתה יכול להפעיל אותו מחדש

57
00:03:04,870 --> 00:03:09,190
ואתה תמצא את הקבצים שלך נמצאים שם
שוב כאשר אתה לאתחל את המערכת.

58
00:03:09,190 --> 00:03:14,820
אבל כונני דיסקים, כמו כונן דיסק קשיח,
HDD, או כונן מצב מוצק, SSD,

59
00:03:14,820 --> 00:03:16,050
הם שטח אחסון פשוט.

60
00:03:16,050 --> 00:03:20,400
>> אנחנו לא באמת יכולים לעשות משהו עם
נתונים שנמצאים בדיסק קשיח,

61
00:03:20,400 --> 00:03:22,080
או בכונן מצב מוצק.

62
00:03:22,080 --> 00:03:24,950
כדי לשנות בפועל
נתונים או להזיז אותו מסביב,

63
00:03:24,950 --> 00:03:28,800
אנחנו צריכים להעביר אותה ל
זיכרון RAM, זיכרון גישה אקראי.

64
00:03:28,800 --> 00:03:31,170
עכשיו RAM, יש לך הרבה
פחות במחשב שלך.

65
00:03:31,170 --> 00:03:34,185
ייתכן שיש לך אי שם ב
שכונה של 512 מגה בייט

66
00:03:34,185 --> 00:03:38,850
אם יש לך מחשב ישן יותר,
לאולי שתיים, ארבעה, שמונה, 16,

67
00:03:38,850 --> 00:03:41,820
אולי אפילו קצת
יותר, ג 'ייגה של זיכרון RAM.

68
00:03:41,820 --> 00:03:46,390
אז זה הרבה יותר קטן, אבל זה
שבו כל הנתונים ההפכפכים קיים.

69
00:03:46,390 --> 00:03:48,270
זה שבו אנחנו יכולים לשנות דברים.

70
00:03:48,270 --> 00:03:53,350
אבל כאשר אנחנו לכבות את המחשב שלנו,
כל הנתונים בזכרון RAM נהרס.

71
00:03:53,350 --> 00:03:57,150
>> אז בגלל זה אנחנו צריכים דיסק קשיח
למיקום קבוע יותר מזה,

72
00:03:57,150 --> 00:03:59,720
כך שזה היה exists-
להיות ממש רע אם בכל פעם ש

73
00:03:59,720 --> 00:04:03,310
הפכתי את המחשב שלנו, כל
קובץ במערכת שלנו נמחק.

74
00:04:03,310 --> 00:04:05,600
אז אנחנו עובדים בתוך של זיכרון RAM.

75
00:04:05,600 --> 00:04:09,210
ובכל פעם שאנחנו מדברים
זיכרון, פחות או יותר, בCS50,

76
00:04:09,210 --> 00:04:15,080
על זיכרון RAM, דיסק קשיח לא שאנחנו מדברים.

77
00:04:15,080 --> 00:04:18,657
>> לכן, כאשר אנחנו עוברים דברים בזיכרון,
זה לוקח כמות מסוימת של שטח.

78
00:04:18,657 --> 00:04:20,740
כל סוגי הנתונים ש
אנחנו עובדים עם

79
00:04:20,740 --> 00:04:23,480
תופס שונה
כמויות של שטח בזכרון RAM.

80
00:04:23,480 --> 00:04:27,600
אז בכל פעם שאתה יוצר מספר שלם
ארבעה בתים משתנים, של זיכרון

81
00:04:27,600 --> 00:04:30,750
הם מניחים בצד בזכרון RAM, כך ש
יכול לעבוד עם מספר שלם ש.

82
00:04:30,750 --> 00:04:34,260
אתה יכול להכריז על המספר השלם,
לשנות אותו, להקצות אותו

83
00:04:34,260 --> 00:04:36,700
לערך 10 מוגדל
על ידי אחד, כן הלאה וכן הלאה.

84
00:04:36,700 --> 00:04:39,440
כל מה שצריך לקרות ב
זיכרון RAM, ואתה מקבל ארבעה בתים

85
00:04:39,440 --> 00:04:42,550
לעבוד עם כל
מספר שלם שאתה יוצר.

86
00:04:42,550 --> 00:04:45,410
>> כל דמותך
ליצור מקבל בית אחד.

87
00:04:45,410 --> 00:04:48,160
זה בדיוק כמה מקום הוא
צריך לאחסן אופי.

88
00:04:48,160 --> 00:04:51,310
כל לצוף, אמיתי
מספר, מקבל ארבעה בתים

89
00:04:51,310 --> 00:04:53,390
אלא אם כן זה כפול
נקודה צפה דיוק

90
00:04:53,390 --> 00:04:56,510
מספר, שמאפשר לך
יש ספרות מדויקת יותר או יותר

91
00:04:56,510 --> 00:04:59,300
לאחר הנקודה העשרונית
מבלי לאבד דיוק,

92
00:04:59,300 --> 00:05:01,820
אשר תופסים שמונה בתים של זיכרון.

93
00:05:01,820 --> 00:05:06,730
מתגעגע ארוך, מספרים שלמים גדולים באמת,
גם לקחת שמונה בתים של זיכרון.

94
00:05:06,730 --> 00:05:09,000
כמה בתים של זיכרון
אל מיתרים תופסים?

95
00:05:09,000 --> 00:05:12,990
ובכן בואו לשים סיכה בשאלה ש
לעת עתה, אבל אנחנו נחזור אליו.

96
00:05:12,990 --> 00:05:17,350
>> אז בחזרה לרעיון הזה של זיכרון כ
מערך גדול של תאים בייט בגודל.

97
00:05:17,350 --> 00:05:20,871
זה באמת כל זה הוא, זה
רק מערך של תאים ענק,

98
00:05:20,871 --> 00:05:23,370
בדיוק כמו כל מערך אחר ש
אתה מכיר ותראה,

99
00:05:23,370 --> 00:05:26,430
מלבד כל אלמנט הוא רחב בית אחד.

100
00:05:26,430 --> 00:05:30,030
ובדיוק כמו מערך,
יש כל אלמנט כתובת.

101
00:05:30,030 --> 00:05:32,120
כל אלמנט של מערך
יש מדד, ואנחנו

102
00:05:32,120 --> 00:05:36,302
ניתן להשתמש במדד שיעשה מה שנקרא
גישה אקראית במערך.

103
00:05:36,302 --> 00:05:38,510
אנחנו לא צריכים להתחיל ב
תחילת המערך,

104
00:05:38,510 --> 00:05:40,569
לחזר דרך כל
אלמנט יחיד שלה,

105
00:05:40,569 --> 00:05:41,860
כדי למצוא את מה שאנחנו מחפשים.

106
00:05:41,860 --> 00:05:45,790
אנחנו רק יכולים לומר, אני רוצה להגיע ל
אלמנט ה -15 או ה -100 האלמנט.

107
00:05:45,790 --> 00:05:49,930
ואתה יכול פשוט לעבור במספר ש
ולקבל את הערך שאתה מחפש.

108
00:05:49,930 --> 00:05:54,460
>> באופן דומה בכל מיקום
בזיכרון יש כתובת.

109
00:05:54,460 --> 00:05:57,320
אז אולי הזיכרון שלך
נראה משהו כזה.

110
00:05:57,320 --> 00:06:01,420
הנה נתח קטן מאוד של
זיכרון, זה 20 בתים של זיכרון.

111
00:06:01,420 --> 00:06:04,060
20 הבתים הראשונים בגללי
כתובות שם בתחתית

112
00:06:04,060 --> 00:06:08,890
הם 0, 1, 2, 3, וכך
בכל הדרך עד 19.

113
00:06:08,890 --> 00:06:13,190
וכאשר אני מצהיר משתנים ו
כאשר אני מתחיל לעבוד איתם,

114
00:06:13,190 --> 00:06:15,470
מערכת הולכת להגדיר
בצד קצת מקום לי

115
00:06:15,470 --> 00:06:17,595
בזיכרון כדי שזה יעבוד
עם המשתנים שלי.

116
00:06:17,595 --> 00:06:21,610
אז אני יכול להגיד, char ג שווה הון
ח ומה הולך לקרות?

117
00:06:21,610 --> 00:06:23,880
ובכן המערכת הולכת
להפריש עבורי בית אחד.

118
00:06:23,880 --> 00:06:27,870
במקרה זה בחר מספר הבתים
ארבעה, בייט בכתובת ארבע,

119
00:06:27,870 --> 00:06:31,310
וזה הולך לאחסון
H מכתב הון שביש לי.

120
00:06:31,310 --> 00:06:34,350
אם אני אומר אז מהירות int
מגבלה שווה 65, שזה

121
00:06:34,350 --> 00:06:36,806
הולך להפריש ארבעה
בתים של זיכרון בשבילי.

122
00:06:36,806 --> 00:06:39,180
וזה הולך לטיפול אלה
ארבעה בתים כיחידה אחת

123
00:06:39,180 --> 00:06:41,305
כי מה שאנחנו עובדים
עם הוא מספר שלם כאן.

124
00:06:41,305 --> 00:06:44,350
וזה הולך לאחסון 65 שם.

125
00:06:44,350 --> 00:06:47,000
>> עכשיו אני כבר סוג של
אומר לך קצת שקר,

126
00:06:47,000 --> 00:06:50,150
נכון, כי אנחנו יודעים ש
מחשבים לעבוד בינארי.

127
00:06:50,150 --> 00:06:53,100
הם לא מבינים
בהכרח מה הוא H הון

128
00:06:53,100 --> 00:06:57,110
או מה הוא 65, הם רק
מבין בינארי, אפסים ואחדים.

129
00:06:57,110 --> 00:06:59,000
ומה כל כך למעשה
אנחנו אחסון שם

130
00:06:59,000 --> 00:07:03,450
אינו האות H והמספר 65,
אלא ייצוגי ינארי

131
00:07:03,450 --> 00:07:06,980
כל אלה, אשר נראים
משהו קטן כמו זה.

132
00:07:06,980 --> 00:07:10,360
ובפרט ב
הקשר של המשתנה השלם,

133
00:07:10,360 --> 00:07:13,559
זה לא הולך רק כדי לירוק אותו ל,
זה לא הולך להתייחס אליו כאחד ארבעה

134
00:07:13,559 --> 00:07:15,350
נתח בתים בהכרח,
זה באמת קורה

135
00:07:15,350 --> 00:07:19,570
להתייחס אליו כארבעה אחד נתחי בתים,
אשר עשוי להיראות משהו כזה.

136
00:07:19,570 --> 00:07:22,424
וגם זה לא
לגמרי נכון או,

137
00:07:22,424 --> 00:07:24,840
בגלל משהו שנקרא
סדר בתים, שאנחנו לא

138
00:07:24,840 --> 00:07:26,965
הולך להיכנס עכשיו, אבל
אם אתה סקרן לגבי,

139
00:07:26,965 --> 00:07:29,030
אתה יכול לקרוא על קטן
וסדר בתים גדולים.

140
00:07:29,030 --> 00:07:31,640
אבל למען טענה זו,
למען וידאו זה,

141
00:07:31,640 --> 00:07:34,860
בואו פשוט להניח שהוא, ב
למעשה, איך מספר 65 הייתם

142
00:07:34,860 --> 00:07:36,970
להיות מיוצג ב
זיכרון בכל מערכת,

143
00:07:36,970 --> 00:07:38,850
למרות שזה לא לגמרי נכון.

144
00:07:38,850 --> 00:07:41,700
>> אבל בואו למעשה רק לקבל
להיפטר מכל ינארי לחלוטין,

145
00:07:41,700 --> 00:07:44,460
וחושב רק על כH
ו -65, זה הרבה יותר קל

146
00:07:44,460 --> 00:07:47,900
לחשוב על זה כמו
כי כאדם.

147
00:07:47,900 --> 00:07:51,420
בסדר, אז זה גם נראה אולי
המערכת קטנה אקראית שI've-

148
00:07:51,420 --> 00:07:55,130
לא נתן לי בתים 5, 6, 7,
ו -8 לאחסון השלם.

149
00:07:55,130 --> 00:07:58,580
יש סיבה לכך, גם, ש
אנו לא תקבלו לעכשיו, אבל יספיקו

150
00:07:58,580 --> 00:08:00,496
זה אומר שמה
מחשב עושה כאן

151
00:08:00,496 --> 00:08:02,810
כנראה מהלך טוב בחלקו.

152
00:08:02,810 --> 00:08:06,020
לא לתת לי זיכרון זה
בהכרח גב אל גב.

153
00:08:06,020 --> 00:08:10,490
למרות שזה הולך לעשות את זה עכשיו
אם אני רוצה לקבל מחרוזת אחרת,

154
00:08:10,490 --> 00:08:13,080
בשם משפחה, ואני רוצה
לשים לויד שם.

155
00:08:13,080 --> 00:08:18,360
אני הולך צריך להתאים אחד
אופי, כל אות של זה

156
00:08:18,360 --> 00:08:21,330
הולך לדרוש אחד
דמות, בית אחד של זיכרון.

157
00:08:21,330 --> 00:08:26,230
אז אם אני יכול לשים לויד למערך שלי
ככה אני די טוב ללכת, נכון?

158
00:08:26,230 --> 00:08:28,870
מה חסר?

159
00:08:28,870 --> 00:08:31,840
>> זכור כי כל מחרוזת אנחנו עובדים
עם בC מסתיים בקו נטוי אפס,

160
00:08:31,840 --> 00:08:33,339
ואנחנו לא יכולים להשמיט את זה כאן, או.

161
00:08:33,339 --> 00:08:36,090
אנחנו צריכים להפריש בית אחד
זיכרון להחזיק שכדי ש

162
00:08:36,090 --> 00:08:39,130
יודע מתי המחרוזת שלנו הסתיימה.

163
00:08:39,130 --> 00:08:41,049
אז שוב הסדר זה
של הדברים בדרך

164
00:08:41,049 --> 00:08:42,799
מופיע בעצמת זיכרון
להיות קצת אקראי,

165
00:08:42,799 --> 00:08:44,870
אבל זה באמת הוא איך
רוב המערכות מתוכננות.

166
00:08:44,870 --> 00:08:48,330
בשורה אותם בכפולות
ארבעה, מסיבות שוב

167
00:08:48,330 --> 00:08:50,080
כי אנחנו לא צריכים
להיכנס עכשיו.

168
00:08:50,080 --> 00:08:53,060
אבל זה, כך די אם נאמר ש
לאחר שלוש שורות של קוד אלה,

169
00:08:53,060 --> 00:08:54,810
זה מה שעשוי להיראות כמו זיכרון.

170
00:08:54,810 --> 00:08:58,930
אם אני צריך מיקומי זיכרון
4, 8, ו -12 להחזיק את הנתונים שלי,

171
00:08:58,930 --> 00:09:01,100
זה מה שהזיכרון שלי עשוי להיראות.

172
00:09:01,100 --> 00:09:04,062
>> ופשוט להיות במיוחד
קפדן כאן, כאשר

173
00:09:04,062 --> 00:09:06,020
על זיכרון אנחנו מדברים
כתובות אנחנו בדרך כלל

174
00:09:06,020 --> 00:09:08,390
לעשות זאת באמצעות סימונים הקסדצימלי.

175
00:09:08,390 --> 00:09:12,030
אז למה אנחנו לא להמיר את כל אלה
מעשרוני לסימון הקסדצימלי

176
00:09:12,030 --> 00:09:15,010
רק בגלל שזה בדרך כלל
איך אנחנו מתייחסים לזיכרון.

177
00:09:15,010 --> 00:09:17,880
אז במקום להיות 0 ב
19, מה שיש לנו הוא אפס

178
00:09:17,880 --> 00:09:20,340
x אפס אפס דרך x1 שלוש.

179
00:09:20,340 --> 00:09:23,790
אלה הם 20 הבתים של זיכרון ש
יש להם או שאנחנו מסתכלים על בתמונה זו

180
00:09:23,790 --> 00:09:25,540
ממש כאן.

181
00:09:25,540 --> 00:09:29,310
>> אז כל מה שנאמר, בואו
להתרחק מזיכרון לשנייה

182
00:09:29,310 --> 00:09:30,490
ובחזרה למצביעים.

183
00:09:30,490 --> 00:09:32,420
כאן הוא החשוב ביותר
מה שצריך לזכור

184
00:09:32,420 --> 00:09:34,070
כפי שאנו מתחילים לעבוד עם מצביעים.

185
00:09:34,070 --> 00:09:36,314
מצביע הוא דבר
יותר מ כתובת.

186
00:09:36,314 --> 00:09:38,230
אני אגיד את זה שוב, כי
זה כל כך חשוב,

187
00:09:38,230 --> 00:09:42,730
מצביע הוא דבר
יותר מ כתובת.

188
00:09:42,730 --> 00:09:47,760
מצביעים הם כתובות אתרים ל
בזיכרון שבו משתנה לחיות.

189
00:09:47,760 --> 00:09:52,590
בידיעה שהוא הופך להיות תקווה
קצת יותר קלים לעבוד איתם.

190
00:09:52,590 --> 00:09:54,550
דבר נוסף שאני אוהב
לעשות הוא להיות סוג

191
00:09:54,550 --> 00:09:58,510
של התרשימים חזותי המייצג את מה ש
קורה עם קווים שונים של קוד.

192
00:09:58,510 --> 00:10:00,660
ואנחנו נעשה את זה כמה
פעמים במצביעים,

193
00:10:00,660 --> 00:10:03,354
וכאשר אנחנו מדברים על דינמיים
הקצאת זיכרון, כמו גם.

194
00:10:03,354 --> 00:10:06,020
כי אני חושב שדיאגרמות אלה
יכול להיות מועיל במיוחד.

195
00:10:06,020 --> 00:10:09,540
>> אז אם אני אומר לדוגמא, k int
בקוד שלי, מה קורה?

196
00:10:09,540 --> 00:10:12,524
ובכן מה בעצם קורה הוא
אני מקבל זיכרון להפריש עבורי,

197
00:10:12,524 --> 00:10:14,690
אבל אני אפילו לא רוצה
אחשוב על זה ככה, אני

198
00:10:14,690 --> 00:10:16,300
רוצה לחשוב על זה כמו קופסא.

199
00:10:16,300 --> 00:10:20,090
יש לי קופסה וזה
ירוק בצבע, כי אני

200
00:10:20,090 --> 00:10:21,750
יכול לשים את המספרים השלמים בקופסות ירוקות.

201
00:10:21,750 --> 00:10:23,666
אם זה היה אני דמות
אולי יש לי קופסא כחולה.

202
00:10:23,666 --> 00:10:27,290
אבל אני תמיד אומר, אם אני יוצר
תיבה שיכול להכיל מספרים שלמים

203
00:10:27,290 --> 00:10:28,950
התיבה שהיא בצבע ירוקה.

204
00:10:28,950 --> 00:10:33,020
ואני לוקח את סמן קבע
ואני כותב k בצד שלו.

205
00:10:33,020 --> 00:10:37,590
אז יש לי תיבה שנקראת K,
שאליו אני יכול לשים את מספרים שלמים.

206
00:10:37,590 --> 00:10:41,070
לכן, כאשר אני אומר יא int, זה
מה שקורה בראש שלי.

207
00:10:41,070 --> 00:10:43,140
אם אני אומר k שווה חמש, מה אני עושה?

208
00:10:43,140 --> 00:10:45,110
ובכן, אני שם את חמש
בתיבה, תקין.

209
00:10:45,110 --> 00:10:48,670
זה די פשוט, אם
אני אומר יא int, ליצור תיבה שנקראת k.

210
00:10:48,670 --> 00:10:52,040
אם אני אומר k שווה 5,
לשים חמש לתוך התיבה.

211
00:10:52,040 --> 00:10:53,865
אני מקווה שזה לא יותר מדי של קפיצה.

212
00:10:53,865 --> 00:10:55,990
הנה שבו דברים הולכים
קצת מעניין, אם כי.

213
00:10:55,990 --> 00:11:02,590
אם אני אומר * int PK, גם אפילו אם אני לא
יודע מה זה אומר בהכרח,

214
00:11:02,590 --> 00:11:06,150
זה ברור שיש לי משהו
לעשות עם שלם.

215
00:11:06,150 --> 00:11:08,211
אז אני הולך לצבוע
תיבה זו ירוקה-איש,

216
00:11:08,211 --> 00:11:10,210
אני יודע שיש לו משהו
לעשות עם שלם,

217
00:11:10,210 --> 00:11:13,400
אבל זה לא שלם עצמו,
כי זה כוכב int.

218
00:11:13,400 --> 00:11:15,390
יש משהו מעט
שונה על זה.

219
00:11:15,390 --> 00:11:17,620
כל כך מעורב של מספר שלם,
אבל חוץ מזה

220
00:11:17,620 --> 00:11:19,830
לא שונה מדי מ
מה אנחנו מדברים.

221
00:11:19,830 --> 00:11:24,240
זה תיבה, שלה יש תווית,
זה לובש PK תווית,

222
00:11:24,240 --> 00:11:27,280
וזה מסוגל להחזיק
כוכבי int, מה הם אותם.

223
00:11:27,280 --> 00:11:29,894
יש להם משהו לעשות
עם מספרים שלמים, ברור.

224
00:11:29,894 --> 00:11:31,060
הנה השורה האחרונה אף.

225
00:11:31,060 --> 00:11:37,650
אם אני אומר PK = & K, וואו,
מה בדיוק קרה, נכון?

226
00:11:37,650 --> 00:11:41,820
אז מספר אקראי זה, לכאורה אקראי
מספר, מקבל נזרק לתוך התיבה שם.

227
00:11:41,820 --> 00:11:44,930
כל מה שהוא, הוא PK
מקבל את הכתובת של k.

228
00:11:44,930 --> 00:11:52,867
אז אני דבקתי בו k מתגורר בזיכרון,
הכתובת שלו, את הכתובת של בתיו.

229
00:11:52,867 --> 00:11:55,200
כל מה שאני עושה הוא שאני אומר
ערך זה מה שאני הולך

230
00:11:55,200 --> 00:11:59,430
לשים בתוך PK נקרא התיבה שלי.

231
00:11:59,430 --> 00:12:02,080
ומכיוון שהדברים האלה הם
מצביעים, וכי מחפשים

232
00:12:02,080 --> 00:12:04,955
במחרוזת כמו אפס x
שמונה אפס ג שבע ארבעה שמונה

233
00:12:04,955 --> 00:12:07,790
שני אפס הוא כנראה
לא מאוד משמעותי.

234
00:12:07,790 --> 00:12:12,390
כאשר אנחנו בדרך כלל לדמיין מצביעים,
אנחנו באמת עושים זאת כמצביעים.

235
00:12:12,390 --> 00:12:17,000
PK נותן לנו המידע
אנחנו צריכים למצוא k בזיכרון.

236
00:12:17,000 --> 00:12:19,120
אז בעצם PK יש חץ בזה.

237
00:12:19,120 --> 00:12:21,670
ואם אנחנו הולכים לאורך
של חץ ש, לדמיין

238
00:12:21,670 --> 00:12:25,280
זה משהו שאתה יכול ללכת על, אם
ללכת לאורכו של החץ,

239
00:12:25,280 --> 00:12:29,490
בקצה קצו של החץ ש, אנחנו
יהיה למצוא את המיקום בזיכרון

240
00:12:29,490 --> 00:12:31,390
כאשר k מתגורר.

241
00:12:31,390 --> 00:12:34,360
וזה באמת חשוב
כי ברגע שאנחנו יודעים איפה גר k,

242
00:12:34,360 --> 00:12:37,870
אנחנו יכולים להתחיל לעבוד עם הנתונים
בתוך שמיקום הזיכרון.

243
00:12:37,870 --> 00:12:40,780
למרות שאנחנו מקבלים קטנטן
נשכתי יקדים את המאוחר לעת עתה.

244
00:12:40,780 --> 00:12:42,240
>> אז מה הוא מצביע?

245
00:12:42,240 --> 00:12:45,590
מצביע הוא פריט מידע ש
ערך הוא כתובת זיכרון.

246
00:12:45,590 --> 00:12:49,740
זה היה כי אפס x שמונה אפס דברים
קורה, שהיה כתובת זיכרון.

247
00:12:49,740 --> 00:12:52,060
זה היה מיקום בזיכרון.

248
00:12:52,060 --> 00:12:55,080
והסוג של מצביע
מתאר את הסוג

249
00:12:55,080 --> 00:12:56,930
הנתונים תמצאו ב
שכתובת הזיכרון.

250
00:12:56,930 --> 00:12:58,810
אז יש את זכות חלק כוכב int.

251
00:12:58,810 --> 00:13:03,690
אם אני עוקב אחרי חץ זה, זה
הולך להוביל אותי למקום.

252
00:13:03,690 --> 00:13:06,980
ומיקום ש, מה ש
ימצא שם בדוגמא שלי,

253
00:13:06,980 --> 00:13:08,240
היא תיבה בצבע ירוקה.

254
00:13:08,240 --> 00:13:12,650
זה מספר שלם, זה מה שאני
ימצא אם אני הולך לכתובת זו.

255
00:13:12,650 --> 00:13:14,830
סוג נתונים של
מצביע מתאר את מה ש

256
00:13:14,830 --> 00:13:17,936
תוכל למצוא שבכתובת הזיכרון.

257
00:13:17,936 --> 00:13:19,560
אז הנה הדבר ממש מגניב אף.

258
00:13:19,560 --> 00:13:25,090
מצביעים יאפשר לנו לעבור
משתנים בין פונקציות.

259
00:13:25,090 --> 00:13:28,520
ובעצם להעביר משתנה
ולא יעבור עותקים שלהם.

260
00:13:28,520 --> 00:13:32,879
כי אם אנחנו יודעים בדיוק איפה
בזיכרון כדי למצוא משתנים,

261
00:13:32,879 --> 00:13:35,670
אנחנו לא צריכים ליצור עותק של
זה, אנחנו יכולים פשוט ללכת למקום ש

262
00:13:35,670 --> 00:13:37,844
ולעבוד עם משתנה ש.

263
00:13:37,844 --> 00:13:40,260
אז במצביעי מהות מין
של לעשות סביבת מחשב

264
00:13:40,260 --> 00:13:42,360
הרבה יותר כמו בעולם האמיתי, נכון.

265
00:13:42,360 --> 00:13:44,640
>> אז הנה אנלוגיה.

266
00:13:44,640 --> 00:13:48,080
בואו נגיד שיש לי מחברת,
נכון, והוא מלא בהערות.

267
00:13:48,080 --> 00:13:50,230
ואני רוצה שתעדכן אותו.

268
00:13:50,230 --> 00:13:53,960
אתה הוא פונקציה ש
הערות עדכונים, תקין.

269
00:13:53,960 --> 00:13:56,390
בדרך בה אנו כבר
עובד כל כך הרבה, מה ש

270
00:13:56,390 --> 00:14:02,370
קורה הוא שאתה תיקח את המחברת שלי,
אתה תלך לעותק החנות,

271
00:14:02,370 --> 00:14:06,410
תוכל לעשות עותק Xerox של
כל דף של המחברת.

272
00:14:06,410 --> 00:14:09,790
אתה משאיר את המחברת שלי בחזרה
על השולחן שלי כשתסיים,

273
00:14:09,790 --> 00:14:14,600
אתה תלך ולחצות את דברים בי
מחברת שאינן מעודכנים או לא נכון,

274
00:14:14,600 --> 00:14:19,280
ואז אתה עובר בחזרה ל
שלי הערימה של דפי Xerox

275
00:14:19,280 --> 00:14:22,850
כי הוא העתק מדויק של המחברת שלי עם
השינויים שביצעתם אליו.

276
00:14:22,850 --> 00:14:27,040
ובשלב זה, זה תלוי בי כ
הפונקציה הקוראת, כמתקשר,

277
00:14:27,040 --> 00:14:30,582
למחליט לקחת את ההערות שלך ו
לשלב אותם בחזרה למחשב הנייד שלי.

278
00:14:30,582 --> 00:14:32,540
אז יש הרבה שלבים
מעורב כאן, נכון.

279
00:14:32,540 --> 00:14:34,850
כמו האם זה לא יהיה טוב יותר
אם אני רק אומר, היי, אתה יכול

280
00:14:34,850 --> 00:14:38,370
לעדכן את המחברת שלי ל
שלי, למסור לך את המחברת שלי,

281
00:14:38,370 --> 00:14:40,440
ואתה לוקח את הדברים ו
פשוטו כמשמעו לעבור אותם

282
00:14:40,440 --> 00:14:42,810
ולעדכן את הרשימות שלי במחברת שלי.

283
00:14:42,810 --> 00:14:45,140
ולאחר מכן לתת לי את המחברת שלי בחזרה.

284
00:14:45,140 --> 00:14:47,320
זה סוג של מה ש
מצביעים יאפשר לנו לעשות,

285
00:14:47,320 --> 00:14:51,320
הם עושים סביבה זו הרבה
יותר כמו איך אנחנו פועלים במציאות.

286
00:14:51,320 --> 00:14:54,640
>> בסדר אז זה מה ש
מצביע, בואו נדבר

287
00:14:54,640 --> 00:14:58,040
על איך מצביעי העבודה ב- C, ו
איך אנחנו יכולים להתחיל לעבוד איתם.

288
00:14:58,040 --> 00:15:02,550
אז יש מצביע פשוט מאוד
ב- C נקרא מצביע null.

289
00:15:02,550 --> 00:15:04,830
נקודות מצביע null לשום דבר.

290
00:15:04,830 --> 00:15:08,310
זה כנראה נראה כמו זה
בעצם לא דבר שימושי מאוד,

291
00:15:08,310 --> 00:15:10,500
אבל כפי שנראה
מעט מאוחר יותר, העובדה

292
00:15:10,500 --> 00:15:15,410
שמצביע null הזה קיים
ממש ממש יכול להיות שימושי.

293
00:15:15,410 --> 00:15:19,090
ובכל פעם שאתה יוצר מצביע, ו
לא תגדיר-אמצעי הערך שלה

294
00:15:19,090 --> 00:15:21,060
דוגמא של הגדרה
מייד הערך שלה

295
00:15:21,060 --> 00:15:25,401
תהיה זוג שקופיות גב
שבו אמרתי PK שווה & K,

296
00:15:25,401 --> 00:15:28,740
PK מקבל את כתובתו של k, כ
אנחנו תראו מה זה אומר,

297
00:15:28,740 --> 00:15:32,990
אנו רואים כיצד קוד שshortly-
אם לא נקבעו הערך שלה למשהו

298
00:15:32,990 --> 00:15:35,380
משמעות מיידית,
אתה תמיד צריך

299
00:15:35,380 --> 00:15:37,480
להגדיר את המצביע להצביע על null.

300
00:15:37,480 --> 00:15:40,260
אתה צריך להגדיר את זה כדי להצביע על שום דבר.

301
00:15:40,260 --> 00:15:43,614
>> זה שונה מאוד מ
רק עוזב את הערך כפי שהוא

302
00:15:43,614 --> 00:15:45,530
ולאחר מכן הכריז
מצביע ורק בהנחה

303
00:15:45,530 --> 00:15:48,042
זה null כי זה רק לעתים נדירות אמיתיים.

304
00:15:48,042 --> 00:15:50,000
אז אתה צריך תמיד להגדיר
הערך של מצביע

305
00:15:50,000 --> 00:15:55,690
לnull אם לא יגדיר הערך שלה
למשהו משמעותי באופן מיידי.

306
00:15:55,690 --> 00:15:59,090
אתה יכול לבדוק אם הערך של מצביע
בטל באמצעות מפעיל השוויון

307
00:15:59,090 --> 00:16:05,450
(==), בדיוק כמוך להשוות כל מספר שלם
ערכים או ערכי אופי שימוש (==)

308
00:16:05,450 --> 00:16:06,320
גם כן.

309
00:16:06,320 --> 00:16:10,994
זה סוג מיוחד של קבוע
ערך שאתה יכול להשתמש בו כדי לבדוק.

310
00:16:10,994 --> 00:16:13,160
אז זה היה מאוד פשוט
מצביע, מצביע null.

311
00:16:13,160 --> 00:16:15,320
דרך נוספת ליצירה
מצביע הוא לחלץ

312
00:16:15,320 --> 00:16:18,240
הכתובת של משתנה
שכבר יצר,

313
00:16:18,240 --> 00:16:22,330
ואתה עושה את זה באמצעות ו
חילוץ כתובת מפעיל.

314
00:16:22,330 --> 00:16:26,720
שכבר ראו בעבר
בדוגמא התרשים הראשונה שהראיתי.

315
00:16:26,720 --> 00:16:31,450
אז אם x הוא משתנה שיש לנו
כבר יצר של מספר שלם סוג,

316
00:16:31,450 --> 00:16:35,110
אז & x הוא מצביע למספר שלם.

317
00:16:35,110 --> 00:16:39,810
וx היא- זוכר, והוא הולך לחלץ
הכתובת של הדבר בצד הימין.

318
00:16:39,810 --> 00:16:45,350
ומאחר שמצביע הוא רק כתובת,
מ & x הוא מצביע למספר שלם

319
00:16:45,350 --> 00:16:48,560
ערך שהמקום שבו בחיי x הזיכרון.

320
00:16:48,560 --> 00:16:50,460
זה הכתובת של x.

321
00:16:50,460 --> 00:16:53,296
אז & x הוא הכתובת של x.

322
00:16:53,296 --> 00:16:55,670
בואו ניקח את זה צעד אחד
יותר ולהתחבר למשהו

323
00:16:55,670 --> 00:16:58,380
רמזתי בוידאו לפני.

324
00:16:58,380 --> 00:17:06,730
אם עיבוד הוא מערך של זוגות, ואז
וסוגר מרובע עיבוד הוא אני מצביע

325
00:17:06,730 --> 00:17:08,109
לכפול.

326
00:17:08,109 --> 00:17:08,970
אוקיי.

327
00:17:08,970 --> 00:17:12,160
ARR הסוגר מרובע אני, אם
עיבוד הוא מערך של זוגות,

328
00:17:12,160 --> 00:17:19,069
אז ARR הסוגר מרובע הוא אני
אלמנט i-ה ממערך ש,

329
00:17:19,069 --> 00:17:29,270
ו& ARR הסוגר מרובע הוא לי איפה ב
זיכרון אלמנט i-ה של עיבוד קיים.

330
00:17:29,270 --> 00:17:31,790
>> אז מה המשמעות כאן?

331
00:17:31,790 --> 00:17:34,570
שם מערכים, המשמעות
של כל הדבר הזה,

332
00:17:34,570 --> 00:17:39,290
הוא שהשם של מערך הוא
למעשה עצמו מצביע.

333
00:17:39,290 --> 00:17:41,170
אתה כבר עובד
עם מצביעים לכל אורך הדרך

334
00:17:41,170 --> 00:17:45,290
בכל פעם שהשתמשת במערך.

335
00:17:45,290 --> 00:17:49,090
זכור מהדוגמא
בהיקף משתנה,

336
00:17:49,090 --> 00:17:53,420
לקראת סוף הסרטון אני מציג
דוגמא שבה יש לנו פונקציה

337
00:17:53,420 --> 00:17:56,890
int הסט התקשר ו
פונקציה שנקראת מערך קבוצה.

338
00:17:56,890 --> 00:18:00,490
והאתגר שלך כדי לקבוע
אם לא, או מה

339
00:18:00,490 --> 00:18:03,220
ערכים שאנו הדפסנו
סוף הפונקציה,

340
00:18:03,220 --> 00:18:05,960
בסוף התכנית הראשית.

341
00:18:05,960 --> 00:18:08,740
>> אם אתה זוכר מדוגמא ש
או אם אתה כבר צפה בסרטון,

342
00:18:08,740 --> 00:18:13,080
אתה יודע שכאשר ך- הקריאה ל
int סט ביעילות לא עושה כלום.

343
00:18:13,080 --> 00:18:16,390
אבל השיחה להגדיר מערך עושה.

344
00:18:16,390 --> 00:18:19,280
ואני סוג של לא הקדשתי זמן למה
זה היה המקרה באותו הזמן.

345
00:18:19,280 --> 00:18:22,363
אני רק אמרתי, גם זה מערך, זה
מיוחד, אתה יודע, יש סיבה.

346
00:18:22,363 --> 00:18:25,020
הסיבה לכך היא שמערך של
שם הוא באמת רק מצביע,

347
00:18:25,020 --> 00:18:28,740
ויש את זה מיוחד
תחביר הסוגר מרובע ש

348
00:18:28,740 --> 00:18:30,510
לעשות דברים הרבה יותר נחמדים לעבוד איתו.

349
00:18:30,510 --> 00:18:34,410
והם עושים את הרעיון של
מצביע הרבה פחות מאיים,

350
00:18:34,410 --> 00:18:36,800
וזו הסיבה שהם סוג
הציג בדרך זו.

351
00:18:36,800 --> 00:18:38,600
אבל באמת מערכים הם רק מצביעים.

352
00:18:38,600 --> 00:18:41,580
ולכן כאשר אנו
עשה שינוי למערך,

353
00:18:41,580 --> 00:18:44,880
כשעברנו מערך כפרמטר
לפונקציה או כטיעון

354
00:18:44,880 --> 00:18:50,110
לפונקציה, את התוכן של המערך
למעשה השתנה בשני callee

355
00:18:50,110 --> 00:18:51,160
ובמתקשר.

356
00:18:51,160 --> 00:18:55,846
אשר לכל סוג של אחרים
משתנה שראינו לא היה המקרה.

357
00:18:55,846 --> 00:18:58,970
אז זה רק משהו כדי לשמור על ב
אכפת כשאתה עובד עם מצביעים,

358
00:18:58,970 --> 00:19:01,610
הוא ששמו של
מערך למעשה מצביע

359
00:19:01,610 --> 00:19:04,750
לאלמנט הראשון של מערך זה.

360
00:19:04,750 --> 00:19:08,930
>> אוקי אז עכשיו יש לנו את כל אלה
עובדות, בואו נמשיך, נכון.

361
00:19:08,930 --> 00:19:11,370
למה אכפת לנו
שבו משהו חי.

362
00:19:11,370 --> 00:19:14,120
ובכן כמו שאמרתי, זה די
שימושי לדעת איפה משהו חי

363
00:19:14,120 --> 00:19:17,240
כך שאתה יכול ללכת לשם ולשנות אותו.

364
00:19:17,240 --> 00:19:19,390
לעבוד עם זה ולמעשה
יש דבר ש

365
00:19:19,390 --> 00:19:23,710
רוצה לעשות לזה השפעה לקחת משתנה,
ולא ייכנס לתוקף בכמה עותק שלו.

366
00:19:23,710 --> 00:19:26,150
זה נקרא ביטול הפניה.

367
00:19:26,150 --> 00:19:28,690
אנחנו הולכים להתייחסות ו
נשנינו את הערך שם.

368
00:19:28,690 --> 00:19:32,660
אז אם יש לנו מצביע וזה נקרא
מחשב, וזה מצביע על אופי,

369
00:19:32,660 --> 00:19:40,610
אז אנחנו יכולים לומר למחשב PC * ו* הוא
שמו של מה שאנחנו תמצאו אם נלך

370
00:19:40,610 --> 00:19:42,910
למחשב הכתובת.

371
00:19:42,910 --> 00:19:47,860
מה שאנחנו תמצאו שם הוא דמות ו
* מחשב הוא איך אנחנו מתייחסים לנתונים שב

372
00:19:47,860 --> 00:19:48,880
מיקום.

373
00:19:48,880 --> 00:19:54,150
אז אנחנו יכולים לומר משהו כמו
* מחשב = D או משהו כזה,

374
00:19:54,150 --> 00:19:59,280
וזה אומר שכל מה ש
היה במחשב כתובת זיכרון,

375
00:19:59,280 --> 00:20:07,040
כל מה שהייתה בעבר הדמות
יש, עכשיו הוא D, אם אנחנו אומרים * מחשב = D.

376
00:20:07,040 --> 00:20:10,090
>> אז הנה זה באו שוב עם
כמה דברים ג מוזרים, נכון.

377
00:20:10,090 --> 00:20:14,560
אז שראינו * בעבר כ
איכשהו חלק מסוג הנתונים,

378
00:20:14,560 --> 00:20:17,160
ועכשיו הוא נמצא בשימוש ב
הקשר מעט שונה

379
00:20:17,160 --> 00:20:19,605
כדי לגשת לנתונים במיקום.

380
00:20:19,605 --> 00:20:22,480
אני יודע שזה קצת מבלבל ו
זה בעצם חלק מכל זה

381
00:20:22,480 --> 00:20:25,740
כמו, למה יש לי מצביעי מיתולוגיה זו
סביבם כמו להיות כל כך מורכב,

382
00:20:25,740 --> 00:20:28,250
הוא סוג של בעיה תחביר, בכנות.

383
00:20:28,250 --> 00:20:31,810
אבל * משמש בשני ההקשרים,
הן כחלק משמו של הסוג,

384
00:20:31,810 --> 00:20:34,100
ואנו רואים מעט
משהו מאוחר יותר אחר, גם.

385
00:20:34,100 --> 00:20:36,490
ועכשיו הוא
מפעיל dereference.

386
00:20:36,490 --> 00:20:38,760
אז זה הולך להתייחסות,
זה ניגש לנתונים

387
00:20:38,760 --> 00:20:43,000
במיקום של המצביע, ו
מאפשר לך לשנות אותו כרצונו.

388
00:20:43,000 --> 00:20:45,900
>> עכשיו זה דומה מאוד ל
ביקור השכן שלך, נכון.

389
00:20:45,900 --> 00:20:48,710
אם אתה יודע מה שלך
השכן מתגורר, אתה

390
00:20:48,710 --> 00:20:50,730
לא להסתובב עם השכן שלך.

391
00:20:50,730 --> 00:20:53,510
אתה יודע שאתה יקרה ל
יודע איפה הם גרים,

392
00:20:53,510 --> 00:20:56,870
אבל זה לא אומר שעל ידי
כוח שיש ידיעה ש

393
00:20:56,870 --> 00:20:59,170
אתה נמצא באינטראקציה איתם.

394
00:20:59,170 --> 00:21:01,920
אם אתה רוצה לתקשר איתם,
אתה צריך ללכת לבית שלהם,

395
00:21:01,920 --> 00:21:03,760
אתה צריך ללכת למקום שבו הם חיים.

396
00:21:03,760 --> 00:21:07,440
וברגע שאתה עושה את זה,
אז אתה יכול לקיים אינטראקציה

397
00:21:07,440 --> 00:21:09,420
עם אותם בדיוק כמו שהיית רוצה.

398
00:21:09,420 --> 00:21:12,730
ובאופן דומה עם משתנים,
אתה צריך ללכת לכתובת שלהם

399
00:21:12,730 --> 00:21:15,320
אם אתה רוצה לתקשר אותם,
אתה לא יכול פשוט יודע את הכתובת.

400
00:21:15,320 --> 00:21:21,495
והדרך שאתה הולך לכתובת היא
לשימוש *, מפעיל dereference.

401
00:21:21,495 --> 00:21:23,620
מה אתה חושב שקורה
אם ננסה וdereference

402
00:21:23,620 --> 00:21:25,260
מצביע שערכו הוא null?

403
00:21:25,260 --> 00:21:28,470
נזכיר כי null
המצביע מצביע על שום דבר.

404
00:21:28,470 --> 00:21:34,110
אז אם אתה מנסה וdereference
שום דבר או ללכת לשום כתובת,

405
00:21:34,110 --> 00:21:36,800
מה אתה חושב שקורה?

406
00:21:36,800 --> 00:21:39,630
פילוח גם אם ניחשת
אשמה, אתה רוצה להיות צודק.

407
00:21:39,630 --> 00:21:41,390
אם תנסה וdereference
מצביע null,

408
00:21:41,390 --> 00:21:43,140
אתה סובל פילוח
דופי. אבל חכה,

409
00:21:43,140 --> 00:21:45,820
לא אני אומר לך, ש
אם אתה לא הולך

410
00:21:45,820 --> 00:21:49,220
כדי להגדיר הערך שלך שלך
מצביע למשהו משמעותי,

411
00:21:49,220 --> 00:21:51,000
אתה צריך להגדיר לnull?

412
00:21:51,000 --> 00:21:55,290
אני עשיתי ולמעשה הפילוח
אשמה היא סוג של התנהגות טובה.

413
00:21:55,290 --> 00:21:58,680
>> האם אי פעם הכריז על משתנה ו
לא הוקצה הערך שלה באופן מיידי?

414
00:21:58,680 --> 00:22:02,680
אז אתה פשוט אומר int x; אתה לא
למעשה להקצות אותו לשום דבר

415
00:22:02,680 --> 00:22:05,340
ואז בשלב מאוחר יותר בקוד שלך,
אתה מדפיס את הערך של x,

416
00:22:05,340 --> 00:22:07,650
יש עדיין לא
שהוקצה אותו לשום דבר.

417
00:22:07,650 --> 00:22:10,370
לעתים קרובות תקבל
אפס, אבל לפעמים אתה

418
00:22:10,370 --> 00:22:15,000
אולי תקבל קצת מספרים אקראיים, ו
אין לך מושג מהאיפה זה בא.

419
00:22:15,000 --> 00:22:16,750
כמו כן יכול דברים
יקרה עם מצביעים.

420
00:22:16,750 --> 00:22:20,110
כאשר אתה מצהיר על מצביע
int * PK למשל,

421
00:22:20,110 --> 00:22:23,490
ואתה לא להקצות אותו ערך,
אתה מקבל ארבעה בתים לזיכרון.

422
00:22:23,490 --> 00:22:25,950
לא משנה מה ארבעה בתים של
יכול זיכרון המערכת

423
00:22:25,950 --> 00:22:28,970
למצוא, כי יש כמה ערך משמעותי.

424
00:22:28,970 --> 00:22:31,760
ואולי היה
משהו כבר שם ש

425
00:22:31,760 --> 00:22:34,190
הוא כבר לא היה צריך על ידי אחר
פונקציה, כל כך פשוט שיש לך

426
00:22:34,190 --> 00:22:35,900
כל הנתונים היה שם.

427
00:22:35,900 --> 00:22:40,570
>> מה אם אתה ניסית לעשות dereference
כמה כתובת שלא- היו

428
00:22:40,570 --> 00:22:43,410
כבר בתים ומידע ב
שם, זה עכשיו במצביע שלך.

429
00:22:43,410 --> 00:22:47,470
אם תנסה וdereference מצביע ש,
ייתכן שאתה מתעסק עם כמה זיכרון

430
00:22:47,470 --> 00:22:49,390
שלא התכוון
להתעסק עם כל זה.

431
00:22:49,390 --> 00:22:51,639
ולמעשה אתה יכול לעשות
משהו ממש הרסני,

432
00:22:51,639 --> 00:22:54,880
כמו לשבור תכנית אחרת,
או לשבור את פונקציה אחרת,

433
00:22:54,880 --> 00:22:58,289
או לעשות משהו זדוני ש
אתה לא מתכוון לעשות בכל.

434
00:22:58,289 --> 00:23:00,080
ואז זה למה זה
למעשה רעיון טוב

435
00:23:00,080 --> 00:23:04,030
להגדיר מצביעים שלך לnull אם אתה
לא להגדיר אותם למשהו משמעותי.

436
00:23:04,030 --> 00:23:06,760
זה כנראה טוב יותר ב
סופו של היום לתכנית שלך

437
00:23:06,760 --> 00:23:09,840
לקרוס אז לזה לעשות
משהו שמפשל

438
00:23:09,840 --> 00:23:12,400
תכנית אחרת או פונקציה אחרת.

439
00:23:12,400 --> 00:23:15,207
התנהגות זו כנראה גם
פחות אידיאלי מאשר רק מתרסק.

440
00:23:15,207 --> 00:23:17,040
ואז זה למה זה
למעשה הרגל טוב

441
00:23:17,040 --> 00:23:20,920
להיכנס להגדרת המצביעים שלך
לnull אם אתה לא להגדיר אותם

442
00:23:20,920 --> 00:23:24,540
לערך משמעותי
מייד, ערך שאתה יודע

443
00:23:24,540 --> 00:23:27,260
ושאתה יכול בבטחה dereference.

444
00:23:27,260 --> 00:23:32,240
>> אז בואו נחזור עכשיו ותסתכל
בתחביר הכולל של המצב.

445
00:23:32,240 --> 00:23:37,400
אם אני אומר int p * ;, מה יש לי רק לעשות?

446
00:23:37,400 --> 00:23:38,530
מה שעשיתי הוא זה.

447
00:23:38,530 --> 00:23:43,290
אני יודע את הערך של p הוא כתובת
כי כל המצביעים הם רק

448
00:23:43,290 --> 00:23:44,660
כתובות.

449
00:23:44,660 --> 00:23:47,750
אני יכול p dereference
באמצעות המפעיל *.

450
00:23:47,750 --> 00:23:51,250
בהקשר זה כאן, ממש ב
עליון זוכר * הוא חלק מהסוג.

451
00:23:51,250 --> 00:23:53,510
Int * הוא סוג נתונים.

452
00:23:53,510 --> 00:23:56,150
אבל אני יכול dereference
p באמצעות המפעיל *,

453
00:23:56,150 --> 00:24:01,897
ואם אני עושה זאת, אם אני הולך לכתובת זו,
מה אני תמצא בכתובת ש?

454
00:24:01,897 --> 00:24:02,855
אני תמצא את מספר שלם.

455
00:24:02,855 --> 00:24:05,910
אז * int p הוא בעצם
אומר, עמ 'הוא כתובת.

456
00:24:05,910 --> 00:24:09,500
אני יכול dereference p ואם
אני עושה, אני תמצא את מספר שלם

457
00:24:09,500 --> 00:24:11,920
באותו מיקום בזיכרון.

458
00:24:11,920 --> 00:24:14,260
>> אישור אז אמרתי היה עוד
דבר מעצבן עם כוכבים

459
00:24:14,260 --> 00:24:17,060
וכאן המקום שבו ש
דבר מעצבן עם כוכבים הוא.

460
00:24:17,060 --> 00:24:21,640
האם אי פעם ניסינו להכריז
משתנים מרובים מאותו הסוג

461
00:24:21,640 --> 00:24:24,409
על אותו הקו של קוד?

462
00:24:24,409 --> 00:24:27,700
אז לרגע, להעמיד פנים שהשורה,
הקוד אני באמת צריך שם בירוק

463
00:24:27,700 --> 00:24:29,366
הוא לא שם וזה רק אומר x int, y, z ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
מה שהיה עושה הוא בעצם ליצור
שלושה משתנים שלמים בשבילך,

466
00:24:34,550 --> 00:24:36,930
אחד x נקרא, אחד בשם
y, ואחד בשם Z.

467
00:24:36,930 --> 00:24:41,510
זוהי דרך לעשות את זה בלי
יש לפצל על שלושה קווים.

468
00:24:41,510 --> 00:24:43,890
>> כאן המקום לקבל כוכבים
מעצבן שוב אם כי,

469
00:24:43,890 --> 00:24:49,200
כי * הוא למעשה חלק
שני שם הסוג והחלק

470
00:24:49,200 --> 00:24:50,320
של השם המשתנה.

471
00:24:50,320 --> 00:24:56,430
ולכן אם אני אומר * int px, py, PZ, מה ש
למעשה מקבלים הוא מצביע למספר שלם

472
00:24:56,430 --> 00:25:01,650
נקרא px ושני מספרים שלמים, py וPZ.

473
00:25:01,650 --> 00:25:04,950
וזה כנראה לא מה ש
אנחנו רוצים, זה לא טוב.

474
00:25:04,950 --> 00:25:09,290
>> אז אם אני רוצה ליצור מצביעים מרובים
על אותו הקו, מאותו הסוג,

475
00:25:09,290 --> 00:25:12,140
וכוכבים, מה שבאמת צריך
לעשות הוא לומר * int הרשות הפלסטינית, * PB, * מחשב.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
עכשיו שרק אמר ש
ואומר לך את זה עכשיו,

478
00:25:20,300 --> 00:25:22,170
אתה כנראה לא תעשה את זה.

479
00:25:22,170 --> 00:25:25,170
וזה כנראה דבר טוב באמת,
כי בטעות אתה עלול

480
00:25:25,170 --> 00:25:26,544
להשמיט כוכב, משהו כזה.

481
00:25:26,544 --> 00:25:29,290
זה כנראה הכי טוב אולי להכריז
מצביעים על קווים בודדים,

482
00:25:29,290 --> 00:25:31,373
אבל זה רק עוד אחד
תחביר המעצבן

483
00:25:31,373 --> 00:25:35,310
דברים עם כוכבים שמרכיבים
מצביעים כל כך קשה לעבוד איתו.

484
00:25:35,310 --> 00:25:39,480
כי זה פשוט תחבירי זה
בלגן אתה צריך לעבוד דרך.

485
00:25:39,480 --> 00:25:41,600
בעזרת תרגול שהיא עושה
באמת יהפוך לטבע שני.

486
00:25:41,600 --> 00:25:45,410
אני עדיין עושה טעויות עם זה עדיין
לאחר תכנות במשך 10 שנים,

487
00:25:45,410 --> 00:25:49,630
אז אל תכעס אם קורה משהו
לך, שזה די נפוץ בכנות.

488
00:25:49,630 --> 00:25:52,850
זה באמת סוג של
פגם של התחביר.

489
00:25:52,850 --> 00:25:54,900
>> אישור אז אני סוג של הבטחתי
שהיינו לבקר

490
00:25:54,900 --> 00:25:59,370
המושג עד כמה גדול הוא מחרוזת.

491
00:25:59,370 --> 00:26:02,750
ובכן, אם אמרתי לך ש
מחרוזת, יש לנו באמת סוג של

492
00:26:02,750 --> 00:26:04,140
משקר לך כל הזמן.

493
00:26:04,140 --> 00:26:06,181
אין סוג נתונים הנקראים
מחרוזת, ולמעשה אני

494
00:26:06,181 --> 00:26:09,730
הזכיר את זה באחד משלנו
קטעי וידאו מוקדמים על סוגי נתונים,

495
00:26:09,730 --> 00:26:13,820
המחרוזת שהייתה סוג הנתונים ש
נוצר עבורך בCS50.h.

496
00:26:13,820 --> 00:26:17,050
אתה צריך include #
CS50.h כדי להשתמש בו.

497
00:26:17,050 --> 00:26:19,250
>> ובכן המחרוזת היא באמת רק
כינוי למשהו

498
00:26:19,250 --> 00:26:23,600
נקרא char *,
מצביע לאופי.

499
00:26:23,600 --> 00:26:26,010
ובכן מצביעים, כזכור,
רק מטפל.

500
00:26:26,010 --> 00:26:28,780
אז מה הוא הגודל
בבתים של מחרוזת?

501
00:26:28,780 --> 00:26:29,796
ובכן זה ארבעה או שמונה.

502
00:26:29,796 --> 00:26:32,170
והסיבה שאני אומר ארבעה או
שמונה הוא משום שהיא למעשה

503
00:26:32,170 --> 00:26:36,730
תלוי במערכת, אם אתה משתמש ב
IDE CS50, char * הוא בגודל של char

504
00:26:36,730 --> 00:26:39,340
* הוא שמונה, זה מערכת של 64 סיביות.

505
00:26:39,340 --> 00:26:43,850
כל כתובת בזיכרון היא ארוכה 64 סיביות.

506
00:26:43,850 --> 00:26:48,270
אם אתה משתמש במכשיר CS50
או באמצעות כל מחשב 32 סיביות,

507
00:26:48,270 --> 00:26:51,640
ושמעת שטווח של 32 סיביות
מכונה, מה היא מכונה 32 ביט?

508
00:26:51,640 --> 00:26:56,090
ובכן זה רק אומר שכל
כתובת בזיכרון היא ארוכה 32 סיביות.

509
00:26:56,090 --> 00:26:59,140
וכך 32 סיביות הוא ארבעה בתים.

510
00:26:59,140 --> 00:27:02,710
אז * char הוא ארבעה או שמונה
ביטים בהתאם למערכת שלך.

511
00:27:02,710 --> 00:27:06,100
ואכן כל סוגי הנתונים,
ומצביע לכל נתוני

512
00:27:06,100 --> 00:27:12,030
הקלד, שכן כל המצביעים הם רק
כתובות, ארבעה או שמונה בתים.

513
00:27:12,030 --> 00:27:14,030
אז בואו לבקר זה
התרשים ובואו נסיים

514
00:27:14,030 --> 00:27:18,130
בסרטון זה עם קצת פעילות גופנית כאן.

515
00:27:18,130 --> 00:27:21,600
אז הנה התרשים שעזבנו את עם
בתחילת הווידאו מאוד.

516
00:27:21,600 --> 00:27:23,110
אז מה קורה עכשיו אם אני אומר * PK = 35?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
אז מה זה אומר כשאני אומר, * PK = 35?

519
00:27:30,530 --> 00:27:32,420
קח שני.

520
00:27:32,420 --> 00:27:34,990
* PK.

521
00:27:34,990 --> 00:27:39,890
בהקשר כאן, * הוא
מפעיל dereference.

522
00:27:39,890 --> 00:27:42,110
לכן, כאשר dereference
משמש מפעיל,

523
00:27:42,110 --> 00:27:48,520
אנחנו הולכים לכתובת הצביעה
על ידי PK, ואנחנו נשנה את מה שאנו מוצאים.

524
00:27:48,520 --> 00:27:55,270
אז * PK = 35 ביעילות
עושה את זה לתמונה.

525
00:27:55,270 --> 00:27:58,110
אז זה בעצם מבחינה תחבירית
זהה לשל שאמר k = 35.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> עוד אחד.

528
00:28:01,930 --> 00:28:05,510
אם אני אומר מ 'int, אני יוצר
משתנה חדש בשם מ '.

529
00:28:05,510 --> 00:28:08,260
תיבה חדשה, זה קופסא ירוקה כי
זה הולך להחזיק מספר שלם,

530
00:28:08,260 --> 00:28:09,840
וזה שכותרתו מ '.

531
00:28:09,840 --> 00:28:14,960
אם אני אומר מ '= 4, שמתי
מספר שלם לתוך התיבה ש.

532
00:28:14,960 --> 00:28:20,290
אם נניח PK = & M, איך עושה
שינוי תרשים זה?

533
00:28:20,290 --> 00:28:28,760
PK = & M, אתה זוכר מה
ומפעיל עושה או נקרא?

534
00:28:28,760 --> 00:28:34,430
זכור כי וכמה שם משתנה
הוא הכתובת של שם משתנה.

535
00:28:34,430 --> 00:28:38,740
אז מה שאנחנו אומרים הוא
PK מקבל את הכתובת של מטר.

536
00:28:38,740 --> 00:28:42,010
וכך ביעילות מה שקורה
תרשים הוא שPK נקודות כבר לא

537
00:28:42,010 --> 00:28:46,420
לk, אבל נקודות למ '.

538
00:28:46,420 --> 00:28:48,470
>> שוב מצביעים מאוד
מסובך לעבוד עם

539
00:28:48,470 --> 00:28:50,620
והם לוקחים הרבה
בפועל, אלא משום ש

540
00:28:50,620 --> 00:28:54,150
היכולת שלהם כדי לאפשר לך
להעביר נתונים בין פונקציות

541
00:28:54,150 --> 00:28:56,945
ובעצם יש לי אלה
שינויים ייכנסו לתוקף,

542
00:28:56,945 --> 00:28:58,820
מקבל את הראש סביב
באמת חשוב.

543
00:28:58,820 --> 00:29:02,590
זה כנראה המסובך ביותר
נושא שאנו דנים בCS50,

544
00:29:02,590 --> 00:29:05,910
אבל זה הערך ש
תקבל משימוש במצביעים

545
00:29:05,910 --> 00:29:09,200
עולה בהרבה על הסיבוכים
שמגיע מלימודם.

546
00:29:09,200 --> 00:29:12,690
אז אני מאחל לך את הטוב שב
מזל ללמוד על מצביעים.

547
00:29:12,690 --> 00:29:15,760
אני דאג לויד, זה CS50.

548
00:29:15,760 --> 00:29:17,447