1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [שבוע 6]

2
00:00:02,000 --> 00:00:04,000
[הדוד י מלאן] [אוניברסיטת הרווארד]

3
00:00:04,000 --> 00:00:08,000
[זה CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> זה CS50, וזו היא ההתחלה של שבוע 6,

5
00:00:12,000 --> 00:00:16,000
אז כמה כלים חדשים זמינים כעת כדי שתוכל לנצל,

6
00:00:16,000 --> 00:00:19,000
הראשון שבם נקרא CS50 סגנון.

7
00:00:19,000 --> 00:00:22,000
רוב הסיכויים הם, אם אתה אוהב אותי או כל החברים להוראה,

8
00:00:22,000 --> 00:00:26,000
אתה בטח כבר ראית את תכנית שסגנונו נראה משהו קטן כזה.

9
00:00:26,000 --> 00:00:30,000
אולי אתה מתחיל לחתוך כמה פינות בשעתי הלילה מאוחרות, או שתתמודד עם זה בהמשך,

10
00:00:30,000 --> 00:00:32,000
ולאחר מכן TF או CA בא בשעתי עבודה.

11
00:00:32,000 --> 00:00:34,000
אז זה קשה לנו לקרוא.

12
00:00:34,000 --> 00:00:38,000
ובכן, את הקוד הזה הוא נכון מבחינה תחבירית, וזה יהיה לקמפל, וזה יהיה ממש לרוץ.

13
00:00:38,000 --> 00:00:40,000
אבל זה בהחלט לא 5 לסגנון.

14
00:00:40,000 --> 00:00:45,000
>> אבל עכשיו, אם אנחנו הולכים לספרייה זו כאן

15
00:00:45,000 --> 00:00:48,000
ושים לב שיש לי conditions2.c-

16
00:00:48,000 --> 00:00:55,000
ואני מפעיל את הפקודה הזו החדשה, style50, על conditions2.c קובץ זה, זן,

17
00:00:55,000 --> 00:00:57,000
שם לב שהוא הודיע ​​לי שזה כבר מסוגנן.

18
00:00:57,000 --> 00:01:00,000
Gedit לב שהקובץ השתנה בדיסק,

19
00:01:00,000 --> 00:01:08,000
ואם אני לוחץ על לטעון מחדש, כל הבעיות שלך נמצאות כעת באופן אוטומטי.

20
00:01:08,000 --> 00:01:15,000
[מחיאות כפות]

21
00:01:15,000 --> 00:01:17,000
זה אחד מהדברים שעשינו בסוף השבוע הזה.

22
00:01:17,000 --> 00:01:20,000
להבין שזה לא מושלם, מפני שיש קוד

23
00:01:20,000 --> 00:01:23,000
כי זה פשוט לא יהיה מסוגל לסגנן בצורה מושלמת,

24
00:01:23,000 --> 00:01:26,000
אבל מבין שזה כרגע כלי שאתה יכול לנצל את היתרון של

25
00:01:26,000 --> 00:01:33,000
אם רק לחלק מלסדר את הפלטה מונח יותר errantly המסולסלת וכדומה.

26
00:01:33,000 --> 00:01:36,000
>> אבל יותר משכנע כרגע הוא CS50 הגעה.

27
00:01:36,000 --> 00:01:39,000
עם CS50 צק, למעשה אתה יכול לבצע את בדיקות תקינות אותן

28
00:01:39,000 --> 00:01:42,000
בקוד שלך שבחורי ההוראה מסוגלים.

29
00:01:42,000 --> 00:01:44,000
זה שירות של שורת פקודה שמגיע כעת במכשיר

30
00:01:44,000 --> 00:01:46,000
ברגע שאתה עושה update50 לפי

31
00:01:46,000 --> 00:01:49,000
pset 4 מפרטים, ואתה משתמשים בו למעשה כזה.

32
00:01:49,000 --> 00:01:51,000
אתה מפעיל את check50 הפקודה.

33
00:01:51,000 --> 00:01:56,000
ואז אתה עובר בארגומנט שורת פקודה, או באופן כללי יותר הידוע כמתג או דגל.

34
00:01:56,000 --> 00:01:58,000
באופן כללי, דברים שיש לי מקפים נקראים מתג

35
00:01:58,000 --> 00:02:02,000
לתכנית שורת פקודה, מה שמציין ג

36
00:02:02,000 --> 00:02:04,000
את הבדיקות שברצונך להפעיל.

37
00:02:04,000 --> 00:02:07,000
>> הבדיקות שברצונך להפעיל מזוהות באופן ייחודי על ידי מחרוזת זו,

38
00:02:07,000 --> 00:02:10,000
2012/pset4/resize.

39
00:02:10,000 --> 00:02:13,000
במילים אחרות, זה פשוט מחרוזת שרירותית, אך ייחודית

40
00:02:13,000 --> 00:02:18,000
שאנו משתמשים כדי לזהות בדיקות תקינות של 4 pset.

41
00:02:18,000 --> 00:02:21,000
ואז אתה מציין רשימה מופרדת שטח של קבצים שאתה רוצה להעלות

42
00:02:21,000 --> 00:02:24,000
לCS50 הגעה לניתוח.

43
00:02:24,000 --> 00:02:29,000
לדוגמה, אם אני הולך לפתרון שלי כאן לresize.c-

44
00:02:29,000 --> 00:02:31,000
תן לי לפתוח את חלון מסוף גדול יותר,

45
00:02:31,000 --> 00:02:42,000
ואני ממשיך ולהפעיל אניח check50-ג 2012/pset4/resize,

46
00:02:42,000 --> 00:02:46,000
ואז אני הולך קדימה ולציין את שמות הקבצים,

47
00:02:46,000 --> 00:02:49,000
resize.c, ולאחר מכן על Enter, הוא דוחס,

48
00:02:49,000 --> 00:02:53,000
הוא מאפשר להעלות, הוא בודק, ואני פשוט לא הצלחתי חבורה שלמה של בדיקות.

49
00:02:53,000 --> 00:02:59,000
אחד באדום בפינה שמאלית עליונה אומר שresize.c וbmp קיים.

50
00:02:59,000 --> 00:03:01,000
זה היה המבחן. זו השאלה ששאלה.

51
00:03:01,000 --> 00:03:04,000
וזה עצוב, משום שהתשובה הייתה כוזבת.

52
00:03:04,000 --> 00:03:08,000
הטקסט הלבן מתחתיו אומר bmp.h צפוי להתקיים, וזה פשוט אשמתי.

53
00:03:08,000 --> 00:03:11,000
שכחתי להעלות אותה, ולכן אני צריך להעלות את שני קבצים,

54
00:03:11,000 --> 00:03:14,000
resize.c וbmp.h.

55
00:03:14,000 --> 00:03:17,000
אבל עכשיו שם לב כל בדיקות האחרות הנם בצבע צהוב בגלל שהם לא לרוץ,

56
00:03:17,000 --> 00:03:21,000
ואז פרצוף המחייך הוא אנכי כי הוא שמח ולא עצוב,

57
00:03:21,000 --> 00:03:25,000
אבל יש לנו לתקן בעיה שבאדום לפני בדיקות אחרות אלה תפעלנה.

58
00:03:25,000 --> 00:03:27,000
>> תן לי לתקן את זה.

59
00:03:27,000 --> 00:03:30,000
בואו להגדיל אותי וזה שידור חוזר, הפעם עם bmp.h גם

60
00:03:30,000 --> 00:03:34,000
בשורת הפקודה, זן, ועכשיו אם הכל ילך כשורה,

61
00:03:34,000 --> 00:03:38,000
זה הולך לבדוק ולאחר מכן להחזיר תוצאה, יחזיק אותך הנשימה

62
00:03:38,000 --> 00:03:42,000
כל ירוק, מה שאומר שאני עושה ממש טוב על pset 4 עד כה.

63
00:03:42,000 --> 00:03:44,000
אתה יכול לראות ולהסיק מטקסט התיאורים כאן

64
00:03:44,000 --> 00:03:47,000
בדיוק מה שזה בדקנו.

65
00:03:47,000 --> 00:03:49,000
בדקנו תחילה את הקבצים קיימים?

66
00:03:49,000 --> 00:03:51,000
אז בדקנו עושה לקמפל resize.c?

67
00:03:51,000 --> 00:03:58,000
אז בדקנו זה לא ישנה את גודל 1x1 BMP פיקסל כאשר n, גורם שינוי הגודל, הוא 1.

68
00:03:58,000 --> 00:04:01,000
עכשיו, אם אין לך מושג מה n הוא, אתה ברגע שאתה לצלול לתוך pset 4,

69
00:04:01,000 --> 00:04:04,000
אבל זה פשוט הוא שפיות לבדוק כדי לוודא שאתה לא שינוי גודל

70
00:04:04,000 --> 00:04:08,000
תמונה בכלל אם גורם שינוי הגודל הוא 1.

71
00:04:08,000 --> 00:04:14,000
אם, לעומת זאת, זה משנה את גודל 1x1 פיקסל לפיקסל BMP 1x1 ל2x2 כראוי

72
00:04:14,000 --> 00:04:19,000
כאשר n הוא 2, אז באופן דומה, שלי יוצר בהתאם.

73
00:04:19,000 --> 00:04:22,000
>> בקיצור, זה נועד לאחד, לקחת את מעברי האצבעות

74
00:04:22,000 --> 00:04:25,000
מחוץ למשוואה נכונה לפני שתגיש pset.

75
00:04:25,000 --> 00:04:28,000
אתה תדע בדיוק מה TF בקרוב יודע

76
00:04:28,000 --> 00:04:30,000
כשאתה הולך על הגשת חלק מהתבניות הבעייתיות אלה,

77
00:04:30,000 --> 00:04:34,000
וגם המוטיבציה הפדגוגית היא באמת לשים

78
00:04:34,000 --> 00:04:37,000
ההזדמנות מולך, כך שכאשר אתה יודע מראש

79
00:04:37,000 --> 00:04:39,000
שיש באגים בקוד שלך ובדיקות שאינם בעברו,

80
00:04:39,000 --> 00:04:43,000
אתה יכול לשים בזמן יעיל יותר מראש כדי לפתור את הבעיות האלה

81
00:04:43,000 --> 00:04:45,000
ולא לאבד נקודות, לקבל משוב מTF שלך,

82
00:04:45,000 --> 00:04:48,000
ואז תלכו, "אהה," כמו שהיה צריך לדעת את זה.

83
00:04:48,000 --> 00:04:50,000
עכשיו לפחות יש כלי שיעזרו לך למצוא את זה.

84
00:04:50,000 --> 00:04:52,000
זה לא הולך להצביע היכן הבאג הוא, אבל הוא יגיד לך

85
00:04:52,000 --> 00:04:54,000
מה הוא סימפטומים שלה.

86
00:04:54,000 --> 00:04:57,000
>> עכשיו מבין את הבדיקות אינן בהכרח ממצות.

87
00:04:57,000 --> 00:04:59,000
רק בגלל שאתה מקבל מסך מלא בפרצופי סמיילי ירוקים

88
00:04:59,000 --> 00:05:02,000
לא אומר שהקוד שלך הוא מושלם, אבל זה אומר

89
00:05:02,000 --> 00:05:06,000
שזה עבר בדיקות מסוימות שנקבעו על ידי המפרט.

90
00:05:06,000 --> 00:05:08,000
לפעמים אנחנו לא נשחרר צקים.

91
00:05:08,000 --> 00:05:10,000
לדוגמה, מי עשה, אחד מההיבטים של pset 4,

92
00:05:10,000 --> 00:05:15,000
הוא סוג של אכזבה אם אנחנו נותנים לך

93
00:05:15,000 --> 00:05:18,000
התשובה לשאלה מה זה, ויש מספר דרכים כדי לחשוף

94
00:05:18,000 --> 00:05:21,000
שהאדם נמצא ברעש האדום.

95
00:05:21,000 --> 00:05:24,000
המפרט תמיד לציין בעתיד ל5 ואילך pset

96
00:05:24,000 --> 00:05:26,000
מה בודק קיימת בשבילך.

97
00:05:26,000 --> 00:05:28,000
תוכל להבחין שיש URL הלבנה הזה בתחתית.

98
00:05:28,000 --> 00:05:30,000
לעת עתה, זה רק פלט אבחון.

99
00:05:30,000 --> 00:05:33,000
אם אתה מבקר את כתובת אתר, תקבל חבורה שלמה של הודעות מטורפות, מסתוריות

100
00:05:33,000 --> 00:05:36,000
ואתה מוזמן לראות דרכו, אבל זה בעיקר לצוות

101
00:05:36,000 --> 00:05:41,000
כדי שנוכל לאבחן וניפוי באגים בcheck50 עצמו.

102
00:05:41,000 --> 00:05:46,000
>> בלי שהיות, הבה נעבור למקום שבו הפסיק.

103
00:05:46,000 --> 00:05:48,000
CS50 ספרייה לקחנו כמובן מאליו במשך כמה שבועות,

104
00:05:48,000 --> 00:05:52,000
אבל אז בשבוע שעבר, התחילו לקלף אחת מהשכבות שלו.

105
00:05:52,000 --> 00:05:55,000
התחלנו לשים בצד מחרוזת לטובת מה במקום?

106
00:05:55,000 --> 00:05:57,000
[סטודנטים] צ'אר.

107
00:05:57,000 --> 00:05:59,000
* Char, אשר כבר דמות * כל הזמן הזה,

108
00:05:59,000 --> 00:06:03,000
אבל עכשיו אין לנו להעמיד פן שזה סוג מחרוזת נתונים בפועל.

109
00:06:03,000 --> 00:06:06,000
במקום זאת, הוא הייתה מילה נרדפת של מיני לדמות *,

110
00:06:06,000 --> 00:06:09,000
ומחרוזת היא רצף של תווים,

111
00:06:09,000 --> 00:06:14,000
אז מדוע זה הגיוני לייצג מחרוזות כchar * s?

112
00:06:14,000 --> 00:06:20,000
מה * char כן מייצג בהקשר של תפיסה זו של מחרוזת?

113
00:06:20,000 --> 00:06:23,000
כן. >> [סטודנטים] התו הראשון.

114
00:06:23,000 --> 00:06:25,000
טוב, התו הראשון, אבל לא ממש את התו הראשון.

115
00:06:25,000 --> 00:06:27,000
זהו אופן ש[ סטודנטים] כתובת.

116
00:06:27,000 --> 00:06:29,000
טוב, את הכתובת של התו הראשון.

117
00:06:29,000 --> 00:06:33,000
כל מה שהכרחי כדי לייצג מחרוזת בזיכרון של מחשב

118
00:06:33,000 --> 00:06:36,000
רק הכתובת הייחודית של הבתים הראשונים שלה.

119
00:06:36,000 --> 00:06:38,000
אתה אפילו לא צריך לדעת כמה זמן זה הוא

120
00:06:38,000 --> 00:06:42,000
כי איך אפשר להבין את זה באופן דינמי?

121
00:06:42,000 --> 00:06:44,000
[סטודנטים] אורך מחרוזת.

122
00:06:44,000 --> 00:06:48,000
אתה יכול לקרוא לאורך מחרוזת, מצוין, אבל איך זה עובד אורך מחרוזת?

123
00:06:48,000 --> 00:06:50,000
מה זה עושה? כן.

124
00:06:50,000 --> 00:06:52,000
[סטודנטים] תמשיך ללכת עד שתקבל את תו null.

125
00:06:52,000 --> 00:06:54,000
כן, בדיוק, זה פשוט סובב עם ללולאה, ואילו לולאה,

126
00:06:54,000 --> 00:06:57,000
מה * עד הסוף, והסוף מיוצג

127
00:06:57,000 --> 00:07:01,000
על ידי \ 0, דמות שנקראת NUL, NUL,

128
00:07:01,000 --> 00:07:05,000
לא להתבלבל עם אפס, אשר הוא מצביע,

129
00:07:05,000 --> 00:07:07,000
שעלה בשיחה שוב היום.

130
00:07:07,000 --> 00:07:11,000
>> אנחנו קלפנו שכבת GetInt, ואז לקחנו להסתכל GetString,

131
00:07:11,000 --> 00:07:14,000
וזוכר ששתי פונקציות אלה, או באמת,

132
00:07:14,000 --> 00:07:18,000
GetString, היה משתמש בפונקציה מסוימת

133
00:07:18,000 --> 00:07:21,000
למעשה לנתח, כלומר, לקרוא או לנתח, הקלט של המשתמש.

134
00:07:21,000 --> 00:07:25,000
וכי מה היה תפקידו החדש?

135
00:07:25,000 --> 00:07:27,000
Scanf או sscanf. זה באמת מגיע בכמה טעמים שונים.

136
00:07:27,000 --> 00:07:31,000
יש scanf, יש sscanf, יש fscanf.

137
00:07:31,000 --> 00:07:35,000
לעת עתה, אם כי, בואו נתמקד באחד מודגם בקלות הרבה ביותר,

138
00:07:35,000 --> 00:07:38,000
ותנו לי ללכת קדימה ולפתוח במכשיר

139
00:07:38,000 --> 00:07:41,000
קובץ כזה, scanf1.c.

140
00:07:41,000 --> 00:07:43,000
זוהי תכנית סופר פשוטה,

141
00:07:43,000 --> 00:07:46,000
אבל שעושה משהו שאנחנו אף פעם לא עשינו

142
00:07:46,000 --> 00:07:48,000
ללא עזרה של CS50 הספרייה.

143
00:07:48,000 --> 00:07:51,000
זה מקבל int ממשתמש. איך זה עובד?

144
00:07:51,000 --> 00:07:53,000
ובכן, ב 16 יש קו,

145
00:07:53,000 --> 00:07:56,000
שם לב שאנו מצהירים x נקרא int, ובשלב זה בסיפור,

146
00:07:56,000 --> 00:07:58,000
מהו הערך של x?

147
00:07:58,000 --> 00:08:00,000
[תגובת תלמיד לא נשמעה]

148
00:08:00,000 --> 00:08:02,000
[דוד מ '] נכון, מי יודע, איזה ערך זבל פוטנציאלי, ולכן ב17, אנחנו פשוט לספר את המשתמש

149
00:08:02,000 --> 00:08:06,000
תן לי מספר, בבקשה, וצעד 18 הוא מקום שבו מתחיל להיות מעניין.

150
00:08:06,000 --> 00:08:11,000
Scanf נראה ללוות רעיון מprintf בכך שהוא משתמש בפורמט הקודים האלה במרכאות.

151
00:08:11,000 --> 00:08:13,000
ד% הוא כמובן מספר עשרוני.

152
00:08:13,000 --> 00:08:21,000
אבל למה אני עובר ב& x במקום רק X?

153
00:08:21,000 --> 00:08:24,000
הראשון הוא נכון. כן.

154
00:08:24,000 --> 00:08:26,000
[תגובת תלמיד לא נשמעה]

155
00:08:26,000 --> 00:08:31,000
בדיוק, אם המטרה של התכנית הזו, כמו GetInt הפונקציה עצם,

156
00:08:31,000 --> 00:08:34,000
הוא להגיע int מהמשתמש אני יכול להעביר פונקציות

157
00:08:34,000 --> 00:08:38,000
כל המשתנים שאני רוצה, אבל אם אני לא אעבור אותם על ידי התייחסות

158
00:08:38,000 --> 00:08:41,000
או על ידי כתובת או על ידי מצביע, כל המילה נרדפת למטרות של היום,

159
00:08:41,000 --> 00:08:46,000
אז פונקציה שאין לו יכולת לשנות את התוכן של אותו משתנה.

160
00:08:46,000 --> 00:08:49,000
זה היה עובר בעותק בדיוק כמו את גרסת המרכבה של החלפה

161
00:08:49,000 --> 00:08:51,000
שאנחנו מדברים עליו כבר כמה פעמים.

162
00:08:51,000 --> 00:08:54,000
>> אבל במקום זה, על ידי עושה & x, אני ממש עובר במה?

163
00:08:54,000 --> 00:08:57,000
[סטודנטים] הכתובת. >> הכתובת של x.

164
00:08:57,000 --> 00:09:01,000
זה כמו ציור מפה לפונקציה שנקראת scanf ואומר כאן,

165
00:09:01,000 --> 00:09:04,000
אלה הם כיוונים לנתח של זיכרון במחשב

166
00:09:04,000 --> 00:09:07,000
כי אתה יכול ללכת לאחסן חלק שלם פנימה

167
00:09:07,000 --> 00:09:10,000
על מנת sscanf לעכשיו לעשות את זה

168
00:09:10,000 --> 00:09:13,000
מה מפעיל, מה קטע של תחביר זה הולך צריך להשתמש

169
00:09:13,000 --> 00:09:19,000
למרות שאנחנו לא יכולים לראות את זה בגלל שמישהו אחר כתב בפונקציה זו?

170
00:09:19,000 --> 00:09:21,000
במילים אחרות - מה זה?

171
00:09:21,000 --> 00:09:23,000
[סטודנטים] X לקרוא.

172
00:09:23,000 --> 00:09:27,000
יש הולך להיות קצת קריאה, אבל רק בנוגע לx כאן.

173
00:09:27,000 --> 00:09:30,000
אם scanf המועברת כתובת של x,

174
00:09:30,000 --> 00:09:35,000
מבחינה תחבירית, מה שמפעיל חייב להתקיים במקום כלשהו

175
00:09:35,000 --> 00:09:38,000
בתוך היישום של scanf כך שscanf

176
00:09:38,000 --> 00:09:42,000
בעצם יכול לכתוב את המספר 2 לאותה כתובת?

177
00:09:42,000 --> 00:09:44,000
כן, אז *.

178
00:09:44,000 --> 00:09:47,000
תזכיר כי * הוא מפעיל dereference שלנו, שבעצם אומר ללכת לשם.

179
00:09:47,000 --> 00:09:50,000
>> לאחר שנמסרת כתובת, כמו במקרה כאן,

180
00:09:50,000 --> 00:09:53,000
scanf הוא כנראה, אם אנחנו באמת הסתכלנו סביב מקורו הקוד

181
00:09:53,000 --> 00:09:59,000
עושה * x או שווה הערך בעצם ללכת לכתובת ולשים קצת ערך שם.

182
00:09:59,000 --> 00:10:02,000
עכשיו, כמו לכמה scanf מקבל קלט מהמקלדת,

183
00:10:02,000 --> 00:10:04,000
אנחנו מניפים את ידינו להווה.

184
00:10:04,000 --> 00:10:07,000
רק להניח כי מערכת ההפעלה מאפשרת sscanf לדבר

185
00:10:07,000 --> 00:10:11,000
למקלדת של המשתמש, אך בשלב זה עכשיו בקו 19,

186
00:10:11,000 --> 00:10:14,000
כאשר אנו פשוט להדפיס את x, נראה שזה המקרה

187
00:10:14,000 --> 00:10:17,000
שscanf יש לשים int ב x.

188
00:10:17,000 --> 00:10:19,000
זה בדיוק איך scanf עובד, ולהיזכר בשבוע שעבר

189
00:10:19,000 --> 00:10:25,000
זה בדיוק מה שGetString וGetInt ומשפחתה האחרת של פונקציות

190
00:10:25,000 --> 00:10:28,000
סופו של דבר עובד, אם כי עם שונות קלות כמו sscanf,

191
00:10:28,000 --> 00:10:31,000
מה שאומר לסרוק מחרוזת במקום מקלדת.

192
00:10:31,000 --> 00:10:33,000
אבל בואו נסתכל על שונות קטנות של זה.

193
00:10:33,000 --> 00:10:37,000
בscanf2, אני ממש דפוק.

194
00:10:37,000 --> 00:10:42,000
מה לא בסדר ואני להסתיר את ההערה שמסבירה עד כמה-

195
00:10:42,000 --> 00:10:47,000
מה לא בסדר עם תכנית זו, גרסה 2?

196
00:10:47,000 --> 00:10:55,000
להיות טכני ככל האפשר שלב זה.

197
00:10:55,000 --> 00:10:57,000
זה נראה די טוב.

198
00:10:57,000 --> 00:11:03,000
זה מסוכסך יפה, אבל-

199
00:11:03,000 --> 00:11:07,000
בסדר, מה איתי בואו לגזום אותו לשאלות קצרות יותר?

200
00:11:07,000 --> 00:11:17,000
קו 16. מה הקו 16 עושה באנגלית מדויקת אך טכנית?

201
00:11:17,000 --> 00:11:20,000
מקבל קצת מביך. כן, מיכאל.

202
00:11:20,000 --> 00:11:25,000
[סטודנטים] זה מצביע על המכתב הראשון בשרשרת.

203
00:11:25,000 --> 00:11:27,000
>> אוקיי, קרוב. בואו לצבוט לי שקצת.

204
00:11:27,000 --> 00:11:33,000
מצביע על המכתב הראשון בשרשרת, אתה מצהיר חיץ משתנה בשם

205
00:11:33,000 --> 00:11:36,000
שיצביע לכתובת הראשונה בשרשרת,

206
00:11:36,000 --> 00:11:39,000
או לייתר דיוק, שיצביע באופן ספציפי יותר לchar.

207
00:11:39,000 --> 00:11:42,000
שים לב, זה לא ממש מצביע בשום מקום כי אין אופרטור השמה.

208
00:11:42,000 --> 00:11:46,000
אין שום סימן שווה, כך שכל מה שאנחנו עושים הוא הקצאת החיץ שנקרא משתנה.

209
00:11:46,000 --> 00:11:49,000
זה קורה להיות 32 ביטים כי זה מצביע,

210
00:11:49,000 --> 00:11:52,000
ואת התוכן של חיץ ככל הנראה סופו של דבר

211
00:11:52,000 --> 00:11:57,000
יכיל כתובת של char, אך לעת עתה, מה חיץ להכיל?

212
00:11:57,000 --> 00:11:59,000
רק חלק מזויף, מי יודע, איזה ערך זבל,

213
00:11:59,000 --> 00:12:03,000
מכיוון שלא אותחלנו במפורש, ולכן אנחנו לא צריכים להניח שום דבר.

214
00:12:03,000 --> 00:12:06,000
אוקיי, אז עכשיו קו 17 הוא 'מה קו 17 לעשות?

215
00:12:06,000 --> 00:12:08,000
אולי זה יהיה לחמם את זה.

216
00:12:08,000 --> 00:12:10,000
היא מדפיסה מחרוזת, נכון?

217
00:12:10,000 --> 00:12:12,000
היא מדפיסה מחרוזת בבקשה.

218
00:12:12,000 --> 00:12:15,000
>> קו 18 הוא סוג של מכיר כעת בכך שרק עכשיו ראו את שונות של זה

219
00:12:15,000 --> 00:12:18,000
אבל עם קוד פורמט שונה, ולכן בקו 18,

220
00:12:18,000 --> 00:12:23,000
אנחנו מספרים scanf כאן היא הכתובת של נתח של זיכרון.

221
00:12:23,000 --> 00:12:27,000
אני רוצה שתצלצל במחרוזת, כפי שנרמז על ידי% s,

222
00:12:27,000 --> 00:12:32,000
אבל הבעיה היא שאנחנו לא עשינו כמה דברים כאן.

223
00:12:32,000 --> 00:12:35,000
מה אחת הבעיות?

224
00:12:35,000 --> 00:12:38,000
[סטודנטים] הוא מנסה dereference מצביע null.

225
00:12:38,000 --> 00:12:41,000
טובים, מצביעי null או סתם שאינו ידועים.

226
00:12:41,000 --> 00:12:45,000
אתה מוסר scanf כתובת, אבל אתה פשוט אמרת לפני רגע

227
00:12:45,000 --> 00:12:49,000
כתובת זו שהיא חלק ערך זבל בגלל שאנחנו לא ממש להקצות אותו לשום דבר,

228
00:12:49,000 --> 00:12:53,000
ואז אתה אומר לי scanf ביעילות הולך לשים מחרוזת כאן,

229
00:12:53,000 --> 00:12:56,000
אבל אנחנו לא יודעים איפה הוא עדיין כאן,

230
00:12:56,000 --> 00:12:59,000
אז אנחנו לא באמת נוקצה זיכרון לחיץ.

231
00:12:59,000 --> 00:13:03,000
יתר על כן, מה שאתה גם אפילו לא אומר לי scanf?

232
00:13:03,000 --> 00:13:06,000
תניח שזה היה נתח של זיכרון, וזה לא היה ערך זבל,

233
00:13:06,000 --> 00:13:09,000
אבל אתה עדיין לא אומר לי scanf משהו חשוב.

234
00:13:09,000 --> 00:13:12,000
[סטודנטים] איפה שזה באמת הוא, האמפרסנד.

235
00:13:12,000 --> 00:13:15,000
אמפרסנד, כך שבמקרה זה, זה בסדר.

236
00:13:15,000 --> 00:13:18,000
בגלל חיץ כבר הוכרז כמצביע

237
00:13:18,000 --> 00:13:22,000
עם החתיכה * בתחביר, אנחנו לא צריכים להשתמש אמפרסנד

238
00:13:22,000 --> 00:13:25,000
כי זה כבר כתובת, אבל אני חושב ששמעתי את זה כאן.

239
00:13:25,000 --> 00:13:27,000
[סטודנטים] איזה גודל הוא?

240
00:13:27,000 --> 00:13:29,000
טוב, אנחנו לא אומרים לscanf כמה גדול חיץ זה,

241
00:13:29,000 --> 00:13:32,000
מה שאומר שגם אם המאגר היה מצביע,

242
00:13:32,000 --> 00:13:35,000
אנחנו אומרים scanf, לשים מחרוזת כאן,

243
00:13:35,000 --> 00:13:38,000
אבל כאן יכול להיות 2 בתים, זה יכול להיות 10 בתים, זה יכול להיות מגה.

244
00:13:38,000 --> 00:13:41,000
Scanf אין לו מושג, ובגלל זה הוא נתח של זיכרון

245
00:13:41,000 --> 00:13:43,000
ככל הנראה, זה לא מחרוזת עדיין.

246
00:13:43,000 --> 00:13:48,000
זה רק מחרוזת ברגע שאתה כותב תווים ו\ 0 עד שהנתח של זיכרון.

247
00:13:48,000 --> 00:13:51,000
עכשיו זה רק חלק הנתח של זיכרון.

248
00:13:51,000 --> 00:13:55,000
Scanf לא יודע מתי להפסיק לכתוב לכתובת זו.

249
00:13:55,000 --> 00:13:59,000
>> אם אתה זוכר כמה דוגמאות בעבר שבו אני הוקלדתי באופן אקראי על המקלדת

250
00:13:59,000 --> 00:14:03,000
מנסה לעלות על גדות מאגר, ודברנו ביום שישי בדיוק על זה.

251
00:14:03,000 --> 00:14:07,000
אם יריב איכשהו מזריק לתוך התכנית שלך מילה הרבה יותר גדולה

252
00:14:07,000 --> 00:14:10,000
או משפט או ביטוי אז אתה מצפה שתוכל לכבוש

253
00:14:10,000 --> 00:14:13,000
נתח של זיכרון, אשר יכולה להביא לתוצאות רעות,

254
00:14:13,000 --> 00:14:15,000
כמו לקחת על כל התכנית עוצמה.

255
00:14:15,000 --> 00:14:17,000
אנחנו צריכים לתקן את זה איכשהו.

256
00:14:17,000 --> 00:14:20,000
בואו להגדיל אותי ולהיכנס לגרסה 3 של תכנית זו.

257
00:14:20,000 --> 00:14:22,000
זה קצת יותר טוב.

258
00:14:22,000 --> 00:14:24,000
בגרסה זו, יבחין בהבדל.

259
00:14:24,000 --> 00:14:27,000
בקו 16, אני מצהיר שוב חיץ משתנה בשם,

260
00:14:27,000 --> 00:14:29,000
אבל מה זה עכשיו?

261
00:14:29,000 --> 00:14:33,000
זה מערך של 16 תווים.

262
00:14:33,000 --> 00:14:36,000
זה טוב, כי זה אומר שעכשיו אני יכול לספר לי scanf

263
00:14:36,000 --> 00:14:39,000
כאן הוא נתח ממשי של זיכרון.

264
00:14:39,000 --> 00:14:42,000
אתה כמעט יכול לחשוב על מערכים כמצביעים עכשיו,

265
00:14:42,000 --> 00:14:44,000
למרות שהם לא ממש שווים.

266
00:14:44,000 --> 00:14:47,000
הם מתנהגים באופן שונה בהקשרים שונים.

267
00:14:47,000 --> 00:14:50,000
אבל זה בהחלט המקרה שחיץ הוא התייחסות

268
00:14:50,000 --> 00:14:53,000
16 תווים רציפים משום שזה מה שמערך הוא

269
00:14:53,000 --> 00:14:55,000
וכבר כמה שבועות עכשיו.

270
00:14:55,000 --> 00:14:59,000
>> הנה, אני אומר לי scanf הנה נתח של זיכרון.

271
00:14:59,000 --> 00:15:01,000
הפעם, זה בעצם נתח של זיכרון,

272
00:15:01,000 --> 00:15:07,000
אבל למה היא תכנית זו עדיין ניצול?

273
00:15:07,000 --> 00:15:11,000
מה לא בסדר עדיין?

274
00:15:11,000 --> 00:15:14,000
אני כבר אמרתי לי 16 בתים אבל-

275
00:15:14,000 --> 00:15:16,000
[סטודנטים] מה אם הם מקלידים יותר מ 16?

276
00:15:16,000 --> 00:15:20,000
בדיוק, מה אם המשתמש מקליד ב 17 תווים או תווים 1700?

277
00:15:20,000 --> 00:15:23,000
למעשה, בואו נראה אם ​​אנחנו לא יכולים למעוד על הטעות הזאת עכשיו.

278
00:15:23,000 --> 00:15:25,000
זה יותר טוב, אבל לא מושלם.

279
00:15:25,000 --> 00:15:28,000
תן לי ללכת קדימה ולרוץ לעשות scanf3 לקמפל תכנית זו.

280
00:15:28,000 --> 00:15:34,000
תן לי לרוץ scanf3, מחרוזת בבקשה: הלו, ונראים שאנחנו לא בסדר.

281
00:15:34,000 --> 00:15:37,000
תן לי לנסות קצת יותר ארוך אחד, שלום לך.

282
00:15:37,000 --> 00:15:42,000
אוקיי, בואו נעשה שלום יש מה שלומך היום, Enter.

283
00:15:42,000 --> 00:15:54,000
מקבל סוג של מזל, בואו נגיד שלום לשם השלום.

284
00:15:54,000 --> 00:15:56,000
לעזאזל.

285
00:15:56,000 --> 00:16:03,000
אוקיי, אז היינו לנו מזל. בואו נראה אם ​​אנחנו לא יכולים לתקן את זה.

286
00:16:03,000 --> 00:16:06,000
לא, זה לא הולך לתת לי להעתיק.

287
00:16:06,000 --> 00:16:09,000
בואו ננסה את זה שוב.

288
00:16:09,000 --> 00:16:12,000
בסדר, בכוננות.

289
00:16:12,000 --> 00:16:20,000
נצטרך לראות כמה זמן אני יכול להעמיד פן כדי להתמקד ועדיין עושה את זה.

290
00:16:20,000 --> 00:16:23,000
לעזאזל. זה לא מתאים, למעשה.

291
00:16:23,000 --> 00:16:26,000
הנה.

292
00:16:26,000 --> 00:16:30,000
נקודה שהועלה.

293
00:16:30,000 --> 00:16:34,000
>> זה, למרות שזה מביך גם הוא, הוא גם אחד ממקורות הבלבול גדול

294
00:16:34,000 --> 00:16:38,000
בעת כתיבת תוכניות שיש לי באגים כי הם באים לידי הביטוי

295
00:16:38,000 --> 00:16:40,000
רק פעם בכמה זמן לפעמים.

296
00:16:40,000 --> 00:16:43,000
המציאות היא שגם אם הקוד שלך הוא שבור לחלוטין,

297
00:16:43,000 --> 00:16:46,000
זה יכול להיות שבור לחלוטין רק פעם אחת בזמן

298
00:16:46,000 --> 00:16:49,000
כי לפעמים, בעצם מה שקורה הוא שמקצה מערכת ההפעלה

299
00:16:49,000 --> 00:16:52,000
יותר זיכרון קטן ממה שאתה באמת צריך סיבה כלשהי,

300
00:16:52,000 --> 00:16:57,000
ואז אף אחד אחר לא משתמש בזיכרון מייד אחרי הנתח של 16 תווים שלך,

301
00:16:57,000 --> 00:17:01,000
כך שאם אתה הולך ל17, 18, 19, מה, זה לא כזה ביג דיל.

302
00:17:01,000 --> 00:17:04,000
עכשיו, מחשב, גם אם זה לא לקרוס בשלב זה,

303
00:17:04,000 --> 00:17:09,000
סופו של דבר עשוי להשתמש במספר בתי 17 או 18 או 19 למשהו אחר,

304
00:17:09,000 --> 00:17:14,000
הבמצביעים הנתונים שלך שאתה מכניס לשם, אם כי ארוך מדי,

305
00:17:14,000 --> 00:17:18,000
הוא הולך לקבל מוחלף פוטנציאלי על ידי כמה תפקיד אחר.

306
00:17:18,000 --> 00:17:21,000
זה לא בהכרח הולך להישאר שלם,

307
00:17:21,000 --> 00:17:23,000
אבל זה לא בהכרח יגרום אשמת צינוק.

308
00:17:23,000 --> 00:17:26,000
אבל במקרה הזה, אני סוף הסוף ספקתי מספיק תווים

309
00:17:26,000 --> 00:17:29,000
כי אני למעשה חרגתי קטע של זיכרון שלי, ובום,

310
00:17:29,000 --> 00:17:33,000
מערכת ההפעלה אמרה, "סליחה, זה לא, אשמת פילוח טובה."

311
00:17:33,000 --> 00:17:38,000
>> ובואו נראים אם עכשיו מה שנשאר כאן בספרייה שלי,

312
00:17:38,000 --> 00:17:40,000
שם לב שיש לי את הקובץ הזה לכאן, ליבה.

313
00:17:40,000 --> 00:17:42,000
שים לב שזה נקרא מזבלת ליבה שוב.

314
00:17:42,000 --> 00:17:46,000
זה בעצם קובץ שמכיל את התוכן של הזיכרון של התכנית שלך

315
00:17:46,000 --> 00:17:48,000
בנקודה שבה התרסק,

316
00:17:48,000 --> 00:17:51,000
ורק כדי לנסות דוגמה קטנה כאן נתנו לי ללכת לכאן

317
00:17:51,000 --> 00:17:57,000
ולהפעיל gdb על scanf3 ולאחר מכן ציין טענה שלישית נקראת ליבה,

318
00:17:57,000 --> 00:18:01,000
ושים לב כאן שאם אני מציג את הקוד,

319
00:18:01,000 --> 00:18:06,000
שנוכל כרגיל עם gdb להתחיל ללכת בתכנית זו,

320
00:18:06,000 --> 00:18:10,000
ואני יכול להפעיל אותו וברגע שאני מכה-כמו עם פקודת הצעד בgdb-

321
00:18:10,000 --> 00:18:13,000
ברגע שפגעתי בקו פוטנציאל המרכבה לאחר הקלדת מחרוזת עצומה,

322
00:18:13,000 --> 00:18:16,000
אני אהיה מסוגל למעשה לזהות אותו כאן.

323
00:18:16,000 --> 00:18:19,000
עוד על כך, אם כי, בסעיף במונחים של מצבורי ליבה

324
00:18:19,000 --> 00:18:22,000
ואוהבים, כך שאתה ממש יכול לחטט בתוך מזבלת הליבה

325
00:18:22,000 --> 00:18:27,000
ולראות באיזה שורת התכנית אכזבה אותך.

326
00:18:27,000 --> 00:18:32,000
כל שאלות אז על מצביעים ועל כתובות?

327
00:18:32,000 --> 00:18:36,000
כי היום ב, אנחנו הולכים להתחיל לקחת כמובן מאליו שהדברים האלה קיימים

328
00:18:36,000 --> 00:18:40,000
ואנחנו יודעים בדיוק מה הם.

329
00:18:40,000 --> 00:18:42,000
כן.

330
00:18:42,000 --> 00:18:46,000
>> [סטודנטים] איך זה שאתה לא צריך לשים את אמפרסנד ליד החלקי

331
00:18:46,000 --> 00:18:48,000
שאלה טובה.

332
00:18:48,000 --> 00:18:51,000
איך זה שאני לא צריך לשים אמפרסנד הבא למערך התווים כפי שעשיתי בעבר

333
00:18:51,000 --> 00:18:53,000
ברוב הדוגמות שלנו?

334
00:18:53,000 --> 00:18:55,000
התשובה הקצרה היא מערכים הם קצת מיוחדים.

335
00:18:55,000 --> 00:18:59,000
אתה כמעט יכול לחשוב חיץ כמו להיות ממש כתובת,

336
00:18:59,000 --> 00:19:03,000
וזה פשוט כל כך קורה להיות המקרה שתיווי סוגר המרובע

337
00:19:03,000 --> 00:19:06,000
היא נוחות, כך שנוכל להיכנס למסגרת 0, 1 משען

338
00:19:06,000 --> 00:19:10,000
סוגר 2, מבלי להשתמש בסימון *.

339
00:19:10,000 --> 00:19:13,000
זה קצת שקר לבן כי מערכים ומצביעים

340
00:19:13,000 --> 00:19:17,000
הם, למעשה, קצת שונים, אבל הם יכולים לעתים קרובות אך לא תמיד ניתן להשתמש לסירוגין.

341
00:19:17,000 --> 00:19:21,000
בקיצור, כאשר פונקציה מצפה מצביעה לנתח של זיכרון,

342
00:19:21,000 --> 00:19:24,000
אתה יכול להעביר אותו כתובת שהוחזרה ע"י malloc,

343
00:19:24,000 --> 00:19:29,000
ואנו רואים malloc שוב לפני זמן, או שאתה יכול להעביר אותו את שמו של מערך.

344
00:19:29,000 --> 00:19:32,000
אתה לא צריך לעשות אמפרסנד עם מערכים כי הם כבר

345
00:19:32,000 --> 00:19:34,000
בעצם רוצים כתובות.

346
00:19:34,000 --> 00:19:36,000
זה יוצא מן הכלל.

347
00:19:36,000 --> 00:19:39,000
הסוגריים המרובעים הופכים אותם מיוחדים.

348
00:19:39,000 --> 00:19:41,000
>> האם אתה יכול לשים את האמפרסנד הבא למאגר?

349
00:19:41,000 --> 00:19:43,000
לא במקרה זה.

350
00:19:43,000 --> 00:19:46,000
זה לא יעבוד כי, שוב, במקרה של הפינה הזאת

351
00:19:46,000 --> 00:19:49,000
שם מערכים הם לא ממש ממש כתובות.

352
00:19:49,000 --> 00:19:54,000
אבל אולי אנחנו נחזור לזה לפני זמן רב עם דוגמאות אחרות.

353
00:19:54,000 --> 00:19:56,000
בואו ננסה לפתור את הבעיה פה.

354
00:19:56,000 --> 00:20:00,000
יש לנו מבנה נתונים שכבר משתמשים מזה זמן מה הידוע כמערך.

355
00:20:00,000 --> 00:20:02,000
מקרה לדוגמה, זה מה שעשו זה עתה.

356
00:20:02,000 --> 00:20:04,000
אבל יש כמה מערכים upsides וחסרונות.

357
00:20:04,000 --> 00:20:06,000
מערכים הם הסיבה נחמדה?

358
00:20:06,000 --> 00:20:11,000
מה זה דבר אחד שאתה אוהב, במידה שתרצה מערכים-על מערכים?

359
00:20:11,000 --> 00:20:13,000
מה נוח עליהם? מה מושך?

360
00:20:13,000 --> 00:20:18,000
למה אנחנו מציגים אותם במקום הראשון?

361
00:20:18,000 --> 00:20:20,000
כן.

362
00:20:20,000 --> 00:20:27,000
[סטודנטים] הם יכולים לאחסן כמויות גדולות של נתונים, ואתה לא צריך להשתמש בכל דבר.

363
00:20:27,000 --> 00:20:29,000
אתה יכול להשתמש בסעיף.

364
00:20:29,000 --> 00:20:32,000
הטוב, עם מערך שיכול לאחסן כמויות גדולות של נתונים,

365
00:20:32,000 --> 00:20:35,000
ואתה לא בהכרח צריך להשתמש בכולו, כך שאתה יכול overallocate,

366
00:20:35,000 --> 00:20:39,000
שעשוי להיות נוח אם אתה לא יודע מראש כמה ממשהו לצפות.

367
00:20:39,000 --> 00:20:41,000
>> GetString היא דוגמה מושלמת.

368
00:20:41,000 --> 00:20:44,000
GetString, שנכתב על ידי בנו, אין לו מושג כמה תווים לצפות,

369
00:20:44,000 --> 00:20:48,000
לכן העובדה שאנחנו יכולים להקצות נתחי זיכרון רציף היא טובה.

370
00:20:48,000 --> 00:20:51,000
מערכים גם לפתור בעיה שראינו לפני כמה שבועות

371
00:20:51,000 --> 00:20:54,000
שם הקוד שלך מתחיל לרדת ברמה למשהו תוכנן בצורה גרועה מאוד.

372
00:20:54,000 --> 00:20:57,000
זוכר שיצרתי מבנה סטודנט בשם דוד,

373
00:20:57,000 --> 00:21:00,000
ולאחר מכן שלמרות שהיה למעשה אלטרנטיבה,,

374
00:21:00,000 --> 00:21:04,000
שיש שם משתנה בשם ומשתנים נוספים שנקרא, אני חושב, הבית,

375
00:21:04,000 --> 00:21:08,000
ועוד משתנים הנקרא תעודת זהות, כי בסיפור הזה אז אני רוצה להציג משהו אחר

376
00:21:08,000 --> 00:21:11,000
רוצה רוב לתכנית, אז אני החלטתי לחכות רגע,

377
00:21:11,000 --> 00:21:13,000
אני צריך לשנות את השם משתנה אלה.

378
00:21:13,000 --> 00:21:16,000
בואו נקראים name1, ID1, house1.

379
00:21:16,000 --> 00:21:20,000
בואו לקרוא רוב של name2, house2, ID2.

380
00:21:20,000 --> 00:21:22,000
אבל אז רגע, מה עם טומי?

381
00:21:22,000 --> 00:21:24,000
ואז היו לנו עוד שלושה משתנים.

382
00:21:24,000 --> 00:21:27,000
אנחנו הצגנו מישהו אחר, ארבעה סטים של משתנים.

383
00:21:27,000 --> 00:21:30,000
העולם התחיל להיות מלוכלך מהר מאוד,

384
00:21:30,000 --> 00:21:33,000
כך הצגנו structs, ומה משכנע על struct?

385
00:21:33,000 --> 00:21:39,000
מה struct C לא ייתן לך לעשות?

386
00:21:39,000 --> 00:21:42,000
זה ממש מוזר היום.

387
00:21:42,000 --> 00:21:44,000
מה? >> [תגובת תלמיד לא נשמעה]

388
00:21:44,000 --> 00:21:47,000
כן, באופן ספציפי, typedef מאפשר לך ליצור סוג נתונים חדש,

389
00:21:47,000 --> 00:21:51,000
וstruct, מילת מפתח struct, מאפשר לך לתמצת

390
00:21:51,000 --> 00:21:54,000
יצירות הקשורות מושגית של נתונים יחד

391
00:21:54,000 --> 00:21:56,000
ולאחר מכן קורא להם משהו כמו סטודנט.

392
00:21:56,000 --> 00:21:58,000
>> זה היה טוב, כי עכשיו אנחנו יכולים מודל

393
00:21:58,000 --> 00:22:03,000
מין הרבה יותר מבחינה רעיונית העקבי הרעיון של תלמיד במשתנה

394
00:22:03,000 --> 00:22:07,000
ולא באופן שרירותי שיש אחד למחרוזת, אחד לזיהוי, וכן הלאה.

395
00:22:07,000 --> 00:22:10,000
מערכים הם נחמדים, כי הם מאפשרים לנו להתחיל לנקות את הקוד שלנו.

396
00:22:10,000 --> 00:22:13,000
אבל מה הוא חסרון כרגע של מערך?

397
00:22:13,000 --> 00:22:15,000
מה אתה לא יכול לעשות? כן.

398
00:22:15,000 --> 00:22:17,000
[סטודנטים] אתה צריך לדעת כמה הוא גדול.

399
00:22:17,000 --> 00:22:19,000
אתה צריך לדעת כמה הוא גדול, כך שזה סוג של כאב.

400
00:22:19,000 --> 00:22:21,000
עם ניסיון בתכנות מוקדם אלה מכם שיודעים בהרבה שפות,

401
00:22:21,000 --> 00:22:24,000
כמו Java, אתה יכול לשאול את נתח של זיכרון, ובמיוחד מערך,

402
00:22:24,000 --> 00:22:28,000
כמה אתה גדול, עם אורך, רכוש, אם אפשר לומר כך, וזה ממש נוח.

403
00:22:28,000 --> 00:22:32,000
ב-C, אתה אפילו לא יכול לקרוא strlen על מערך גנרי

404
00:22:32,000 --> 00:22:35,000
בגלל strlen, כמשמעות המילה היא רק עבור מחרוזות,

405
00:22:35,000 --> 00:22:39,000
ואתה יכול להבין את האורך של מחרוזת בגלל המוסכמות האנושיות הזה

406
00:22:39,000 --> 00:22:43,000
שיש \ 0, אך מערך, יותר הגנרי, הוא פשוט גוש של זיכרון.

407
00:22:43,000 --> 00:22:46,000
אם זה מערך של ints, שם לא הולך להיות דמות מיוחדת

408
00:22:46,000 --> 00:22:48,000
בסוף מחכה לך.

409
00:22:48,000 --> 00:22:50,000
צריך לזכור את האורך של מערך.

410
00:22:50,000 --> 00:22:54,000
חסרון נוסף של מערך הרים את ראשה בGetString עצמו.

411
00:22:54,000 --> 00:22:59,000
מה חסרון נוסף של מערך?

412
00:22:59,000 --> 00:23:01,000
אדונים, רק אתה ואני היום.

413
00:23:01,000 --> 00:23:04,000
[תגובת תלמיד לא נשמעה] >> זה מה?

414
00:23:04,000 --> 00:23:06,000
זה הכריז במחסנית.

415
00:23:06,000 --> 00:23:09,000
אוקיי, הכריז על הערימה. למה אתה לא אוהב את זה?

416
00:23:09,000 --> 00:23:13,000
[סטודנטים] כי היא מקבלת בשימוש חוזר.

417
00:23:13,000 --> 00:23:15,000
זה נעשה שימוש חוזר.

418
00:23:15,000 --> 00:23:18,000
אוקיי, אם אתה משתמש במערך כדי להקצות זיכרון,

419
00:23:18,000 --> 00:23:21,000
אתה לא יכול, למשל, להחזיר אותו כי זה בערימה.

420
00:23:21,000 --> 00:23:23,000
אוקיי, זה חסרון.

421
00:23:23,000 --> 00:23:25,000
ומה דעתך על אחד אחר עם מערך?

422
00:23:25,000 --> 00:23:28,000
ברגע שאתה מקצה לו, את הסוג של נדפק אם אתה צריך יותר מקום

423
00:23:28,000 --> 00:23:30,000
מהמערך שיש.

424
00:23:30,000 --> 00:23:34,000
>> אחר כך הציגו, כזכור, malloc, שנתן לנו את היכולת הדינמית להקצאת זיכרון.

425
00:23:34,000 --> 00:23:37,000
אבל מה אם תנסה עולם אחר לגמרי?

426
00:23:37,000 --> 00:23:40,000
מה אם אנחנו רוצים לפתור כמה הבעיות האלה

427
00:23:40,000 --> 00:23:45,000
לכן אנחנו במקום-העט נרדמו כאן

428
00:23:45,000 --> 00:23:51,000
מה אם אנחנו רוצים בעצם במקום ליצור עולם זה כבר לא ככה?

429
00:23:51,000 --> 00:23:56,000
זה מערך, וכמובן, זה סוג של מתדרדר ברגע שפגענו בסופו של המערך,

430
00:23:56,000 --> 00:24:00,000
ועכשיו אני כבר לא צריך מקום למספר שלם אחר או דמות אחרת.

431
00:24:00,000 --> 00:24:03,000
מה אם אנחנו סוג של פעולת מנע אומרים כן, למה אנחנו לא להירגע

432
00:24:03,000 --> 00:24:07,000
דרישה זו שכל הגושים האלה של זיכרון יהיו רציפים גב אל גב,

433
00:24:07,000 --> 00:24:10,000
ומדוע לא, כאשר אני צריך int או char,

434
00:24:10,000 --> 00:24:12,000
רק תן לי מקום לאחד מהם?

435
00:24:12,000 --> 00:24:14,000
וכשאני זקוק לעוד, תן לי מקום אחר,

436
00:24:14,000 --> 00:24:16,000
וכשאני זקוק לעוד, תן לי מקום אחר.

437
00:24:16,000 --> 00:24:19,000
היתרון שלה הוא שאם מישהו אחר

438
00:24:19,000 --> 00:24:21,000
לוקח את הזיכרון לכאן, לא ביג דיל.

439
00:24:21,000 --> 00:24:25,000
אני אקח נתח הנוסף של זיכרון כאן ואז זה אחד.

440
00:24:25,000 --> 00:24:28,000
>> עכשיו, המלכוד היחיד כאן הוא שזה כמעט מרגיש כאילו יש לי

441
00:24:28,000 --> 00:24:30,000
חבורה שלמה של משתנים שונים.

442
00:24:30,000 --> 00:24:33,000
זה מרגיש כמו חמישה משתנים שונים באופן פוטנציאלי.

443
00:24:33,000 --> 00:24:36,000
אבל מה אם אנחנו לגנוב רעיון ממייתרים

444
00:24:36,000 --> 00:24:41,000
לפיו אנו איכשהו לקשר את הדברים האלה יחד מושגית, ומה אם עשיתי את זה?

445
00:24:41,000 --> 00:24:44,000
זה החץ שלי נמשך בצורה גרועה מאוד.

446
00:24:44,000 --> 00:24:46,000
אבל תניח שכל אחד מהגושים האלה של זיכרון

447
00:24:46,000 --> 00:24:52,000
הצבעתי אחרים, והבחור הזה, שאין לו אח או אחות לזכותו,

448
00:24:52,000 --> 00:24:54,000
אין חץ כזה.

449
00:24:54,000 --> 00:24:56,000
זה למעשה מה שנקרא רשימה מקושרת.

450
00:24:56,000 --> 00:25:00,000
זהו מבנה נתונים חדשים המאפשר לנו להקצות נתח של זיכרון,

451
00:25:00,000 --> 00:25:03,000
אז עוד אחת, ועוד אחת, ועוד אחת, בכל פעם שאנחנו רוצים

452
00:25:03,000 --> 00:25:07,000
במהלך תכנית, ואנחנו זוכרים שהם כולם איכשהו קשורים

453
00:25:07,000 --> 00:25:11,000
פשוטו כמשמעו, על ידי שרשור אותם יחד, ואנחנו עשינו את זה כאן באופן ציורי חץ.

454
00:25:11,000 --> 00:25:15,000
אבל בקוד, מה יהיה המנגנון שדרכו אתה יכול איכשהו להתחבר,

455
00:25:15,000 --> 00:25:20,000
כמעט כמו שריטה, חתיכה אחת לחתיכה אחרת?

456
00:25:20,000 --> 00:25:22,000
אנחנו יכולים להשתמש במצביע, נכון?

457
00:25:22,000 --> 00:25:25,000
כי באמת שהחץ שהולך מהמשבצת השמאלית העליונה,

458
00:25:25,000 --> 00:25:31,000
הבחור הזה כאן לזה, יכול להכיל בתוך כיכר זו

459
00:25:31,000 --> 00:25:34,000
לא רק כמה ints, לא סתם char, אבל מה אם אני הוקציתי בפועל

460
00:25:34,000 --> 00:25:37,000
תוספת שטח קטן, כך שעכשיו,

461
00:25:37,000 --> 00:25:41,000
כל אחד מהגושים של זיכרון שלי, למרות שזה יעלה לי,

462
00:25:41,000 --> 00:25:45,000
עכשיו נראה קצת יותר מלבני שבו אחת מהחתיכות של זיכרון

463
00:25:45,000 --> 00:25:47,000
משמש למספר, כמו המספר 1,

464
00:25:47,000 --> 00:25:50,000
ואז אם הבחור הזה מאחסן את המספר 2,

465
00:25:50,000 --> 00:25:52,000
נתח שני זה של זיכרון משמש לחץ

466
00:25:52,000 --> 00:25:54,000
או יותר קונקרטי, מצביע.

467
00:25:54,000 --> 00:25:59,000
ונניח שאני מאחסן את המספר 3 לכאן בזמן שאני משתמש בזה כדי להצביע על הבחור הזה,

468
00:25:59,000 --> 00:26:02,000
ועכשיו הבחור הזה, יניח שאני רוצה שלושה חלקים כאלה של זיכרון בלבד.

469
00:26:02,000 --> 00:26:05,000
אני לצייר קו באמצעות ש, המציין null.

470
00:26:05,000 --> 00:26:07,000
אין שום דמות נוספת.

471
00:26:07,000 --> 00:26:10,000
>> ואכן, זה איך אנחנו יכולים ללכת על יישום

472
00:26:10,000 --> 00:26:12,000
משהו שנקרא רשימה מקושרת.

473
00:26:12,000 --> 00:26:18,000
רשימה מקושרת היא מבנה נתונים חדש, וזה קרש קפיצה לכיוון

474
00:26:18,000 --> 00:26:21,000
מבני נתונים הרבה יותר מהודרים שמתחילים לפתור את הבעיות

475
00:26:21,000 --> 00:26:23,000
על פי הקווים של בעיות מסוג פייסבוק ובעיות גוגל מסוג

476
00:26:23,000 --> 00:26:26,000
שם יש לך ערכות נתונים עצומות, וזה כבר לא חותך אותו

477
00:26:26,000 --> 00:26:29,000
כדי לאחסן כל הדבר בסמיכות ולהשתמש במשהו כמו חיפוש ליניארי

478
00:26:29,000 --> 00:26:31,000
או אפילו משהו כמו חיפוש בינארי.

479
00:26:31,000 --> 00:26:33,000
אתה רוצה פעמים רצופות אפילו טובות יותר.

480
00:26:33,000 --> 00:26:37,000
למעשה, אחד מהגביעים הקדושים נדברנו על המשך שבוע או הבא

481
00:26:37,000 --> 00:26:41,000
הוא אלגוריתם שזמן ריצה הוא קבוע.

482
00:26:41,000 --> 00:26:44,000
במילים אחרות, זה תמיד לוקח את אותה כמות של זמן לא משנה

483
00:26:44,000 --> 00:26:47,000
כמה גדול הוא הקלט, וזה אכן יהיה משכנע,

484
00:26:47,000 --> 00:26:49,000
אפילו יותר מאשר משהו לוגריתמים.

485
00:26:49,000 --> 00:26:51,000
מה זה על המסך כאן?

486
00:26:51,000 --> 00:26:55,000
כל אחד מהמלבנים הוא בדיוק מה שאני רק משכתי ביד.

487
00:26:55,000 --> 00:26:59,000
אבל הדבר כל הדרך בצד השמאל הוא משתנה מיוחד.

488
00:26:59,000 --> 00:27:02,000
זה הולך להיות מצביע בודד בגלל זה תפס אותך

489
00:27:02,000 --> 00:27:04,000
עם רשימה מקושרת, כמו הדברים האלה נקראים,

490
00:27:04,000 --> 00:27:09,000
הוא שיש לך לתלות על קצה אחד של הרשימה המקושרת.

491
00:27:09,000 --> 00:27:13,000
>> בדיוק כמו עם מחרוזת, אתה צריך לדעת את הכתובת של הדמות הראשונה.

492
00:27:13,000 --> 00:27:15,000
עסקה זהה לרשימות מקושרות.

493
00:27:15,000 --> 00:27:19,000
אתה צריך לדעת את הכתובת של הגוש הראשון של זיכרון

494
00:27:19,000 --> 00:27:25,000
כי משם, אתה יכול להגיע לכל אחד אחר.

495
00:27:25,000 --> 00:27:27,000
חסרון.

496
00:27:27,000 --> 00:27:30,000
מה מחיר שאנחנו משלמים על זה שיש צדדי באופן דינמי

497
00:27:30,000 --> 00:27:34,000
מבנה נתונים גדול למדי, שאם אי פעם נצטרך יותר זיכרון, בסדר,

498
00:27:34,000 --> 00:27:37,000
רק להקצות יותר חתיכה אחת ולהסיק ממצביע

499
00:27:37,000 --> 00:27:39,000
הישן לזנב החדש של הרשימה?

500
00:27:39,000 --> 00:27:41,000
כן.

501
00:27:41,000 --> 00:27:43,000
[סטודנטים] זה לוקח בערך כפליים חלל.

502
00:27:43,000 --> 00:27:45,000
זה לוקח פי שניים משטח, כך שזה בהחלט חסרון, ואנחנו ראינו את זה

503
00:27:45,000 --> 00:27:48,000
איזון בין לפני הזמן ובמרחב וגמישות

504
00:27:48,000 --> 00:27:51,000
שם עד עכשיו, אנחנו לא צריכים 32 סיביים לכל אחד מהמספרים האלה.

505
00:27:51,000 --> 00:27:57,000
אנחנו באמת צריכים 64, 32 למספר 32 ולמצביע.

506
00:27:57,000 --> 00:27:59,000
אבל היי, יש לי 2 ג'יגה בייט של זכרון RAM.

507
00:27:59,000 --> 00:28:02,000
הוספת 32 ביטים עוד כאן וכאן לא נראית כל כך גדולה של עסקה.

508
00:28:02,000 --> 00:28:05,000
אבל עבור ערכות נתונים גדולות, זה בהחלט מוסיף עד ממש כפליים.

509
00:28:05,000 --> 00:28:09,000
מה חסרון נוסף עכשיו, או מה תכונה שאנחנו מוותרים,

510
00:28:09,000 --> 00:28:12,000
אם אנחנו מייצגים רשימות של דברים עם רשימה מקושרת ולא במערך?

511
00:28:12,000 --> 00:28:14,000
[סטודנטים] אתה לא יכול לעבור אותו לאחור.

512
00:28:14,000 --> 00:28:16,000
אתה לא יכול לעבור אותו לאחור, כך שאת די דפוקה אם אתה הולך

513
00:28:16,000 --> 00:28:19,000
משמאל לימין באמצעות לולאה או ללולאה בזמן

514
00:28:19,000 --> 00:28:21,000
ואז אתה מבין, "הו, אני רוצה לחזור לתחילת הרשימה."

515
00:28:21,000 --> 00:28:26,000
אתה לא יכול כי המצביעים האלה ללכת רק משמאל לימין כחצים מצביעים.

516
00:28:26,000 --> 00:28:29,000
>> עכשיו, אתה יכול לזכור את ההתחלה של הרשימה במשתנה אחרת,

517
00:28:29,000 --> 00:28:31,000
אבל זה מורכבות לזכור.

518
00:28:31,000 --> 00:28:35,000
מערך, לא משנה כמה רחוק אתה הולך, אתה תמיד יכול לעשות מינוס, מינוס, מינוס, מינוס

519
00:28:35,000 --> 00:28:37,000
ולחזור ממנו באת.

520
00:28:37,000 --> 00:28:40,000
מה חסרון נוסף כאן? כן.

521
00:28:40,000 --> 00:28:43,000
[שאלת תלמיד לא נשמעה]

522
00:28:43,000 --> 00:28:47,000
אתה יכול, כך שלמעשה רק הצעת מבנה נתונים הנקרא רשימה מקושרת כפליים,

523
00:28:47,000 --> 00:28:50,000
ואכן, היית מוסיף מצביע נוסף לכל אחד מהמלבנים האלה

524
00:28:50,000 --> 00:28:53,000
שהולך לכיוון השני, היתרון שלה

525
00:28:53,000 --> 00:28:55,000
עכשיו אתה יכול לעבור קדימה ואחורה,

526
00:28:55,000 --> 00:28:59,000
החסרון שלו שעכשיו אתה משתמש בשלוש פעמים כזיכרון רב כפי שנהגנו

527
00:28:59,000 --> 00:29:04,000
וגם להוסיף מורכבות במונחים של הקוד שצריך לכתוב כדי לעשות את זה נכון.

528
00:29:04,000 --> 00:29:08,000
אבל כל אלה הם אולי פשרות סבירות מאוד, אם ההיפוך הוא חשוב יותר.

529
00:29:08,000 --> 00:29:10,000
כן.

530
00:29:10,000 --> 00:29:12,000
[סטודנטים] אתה גם לא יכול לקבל את רשימה מקושרת 2D.

531
00:29:12,000 --> 00:29:16,000
טוב, אתה לא באמת יכול להיות רשימה מקושרת 2D.

532
00:29:16,000 --> 00:29:18,000
אתה יכול. זה לא כמעט קל כמו מערך.

533
00:29:18,000 --> 00:29:21,000
כמו מערך, אתה עושה סוגר פתוח, סוגר סגור, סוגר פתוח, סגור סוגריים,

534
00:29:21,000 --> 00:29:23,000
ואתה מקבל איזה מבנה 2-ממדי.

535
00:29:23,000 --> 00:29:26,000
אתה יכול ליישם את רשימה מקושרת 2-ממדית

536
00:29:26,000 --> 00:29:29,000
אם אתה עושה את התוספת כפי שהצעה, מצביע שלישי לכל אחד מהדברים האלה,

537
00:29:29,000 --> 00:29:34,000
ואם אתה חושב על רשימה נוספת מתקרב אליך בסגנון 3D

538
00:29:34,000 --> 00:29:40,000
מהמסך לכולנו, וזה רק שרשרת אחרת מסוג כלשהו.

539
00:29:40,000 --> 00:29:45,000
אנחנו יכולים לעשות את זה, אבל זה לא פשוט כמו הקלדת סוגר פתוח, סוגר מרובע. כן.

540
00:29:45,000 --> 00:29:48,000
[שאלת תלמיד לא נשמעה]

541
00:29:48,000 --> 00:29:50,000
טוב, אז זה תמרוץ אמיתי.

542
00:29:50,000 --> 00:29:54,000
>> אלגוריתמים אלה שאנחנו כבר ערגנו נגמרנו, כמו אוי, חיפוש בינארי,

543
00:29:54,000 --> 00:29:57,000
אתה יכול לחפש במערך של מספרים על הלוח

544
00:29:57,000 --> 00:30:01,000
או ספר טלפונים הרבה יותר מהר אם אתה משתמש פרד ומשול

545
00:30:01,000 --> 00:30:05,000
ואלגוריתם חיפוש הבינארי, אך חיפוש הבינארי נדרש שתי הנחות.

546
00:30:05,000 --> 00:30:09,000
אחד, שהנתונים היו ממוינים.

547
00:30:09,000 --> 00:30:11,000
כעת, אנו יכולים להניח שנשמור את זה ממוין,

548
00:30:11,000 --> 00:30:14,000
אז אולי זה לא עניין, אבל חיפוש בינארי גם להניח

549
00:30:14,000 --> 00:30:18,000
שהיה לך גישה אקראית לרשימת מספרים,

550
00:30:18,000 --> 00:30:21,000
ומערך מאפשר לך לקבל גישה אקראית, ועל ידי גישה אקראית,

551
00:30:21,000 --> 00:30:24,000
אני מתכוון שאם אתה נתון מערך, כמה זמן לוקח לך

552
00:30:24,000 --> 00:30:26,000
כדי להגיע למדרגת 0?

553
00:30:26,000 --> 00:30:29,000
פעולה אחת, אתה פשוט להשתמש [0] ואתה צודק שיש.

554
00:30:29,000 --> 00:30:33,000
כמה צעדים נדרש כדי להגיע למיקום 10?

555
00:30:33,000 --> 00:30:36,000
צעד אחד, אתה פשוט הולך ל[ 10] ואתה שם.

556
00:30:36,000 --> 00:30:40,000
לעומת זאת, איך אתה מקבל למספר השלם 10 ברשימה מקושרת?

557
00:30:40,000 --> 00:30:42,000
אתה צריך להתחיל בהתחלה כי אתה רק לזכור

558
00:30:42,000 --> 00:30:45,000
תחילת רשימה מקושרת, בדיוק כמו מחרוזת שזכרה

559
00:30:45,000 --> 00:30:48,000
לפי הכתובת של char הראשון שלה, ולגלות כי int 10

560
00:30:48,000 --> 00:30:53,000
או שהדמות 10 במחרוזת, אתה צריך לחפש את הדבר הארור.

561
00:30:53,000 --> 00:30:55,000
>> שוב, אנחנו לא פתרון כל הבעיות שלנו.

562
00:30:55,000 --> 00:31:00,000
אנחנו מציגים חדשים, אבל זה באמת תלוי במה שאתה מנסה לתכנן ל.

563
00:31:00,000 --> 00:31:04,000
במונחים של יישום זה, אנחנו יכולים ללוות מרעיון שמבנה התלמיד.

564
00:31:04,000 --> 00:31:07,000
התחביר מאוד דומה, אלא שעכשיו, הרעיון הוא קצת יותר מופשט

565
00:31:07,000 --> 00:31:09,000
מבית ושם ותעודת זהות.

566
00:31:09,000 --> 00:31:13,000
אבל אני מציע שיהיה לנו מבנה נתונים ב-C

567
00:31:13,000 --> 00:31:17,000
שנקרא צומת, כמילה האחרונה בשקופית מרמזת,

568
00:31:17,000 --> 00:31:21,000
בתוך צומת, וצומת היא רק מכל הגנרית במדעי מחשב.

569
00:31:21,000 --> 00:31:25,000
בדרך כלל זה נמשך כעיגול או ריבוע או מלבן כפי שעשינו.

570
00:31:25,000 --> 00:31:27,000
ובמבנה נתונים זה, יש לנו int, n,

571
00:31:27,000 --> 00:31:29,000
אז זה המספר שאני רוצה לאחסן.

572
00:31:29,000 --> 00:31:36,000
אבל מה הוא הקו הזה השני, struct * צומת הבאה?

573
00:31:36,000 --> 00:31:40,000
למה זה נכון, או מה תפקיד הדבר הזה,

574
00:31:40,000 --> 00:31:42,000
למרות שזה לא ברור מספיק במבט הראשון?

575
00:31:42,000 --> 00:31:44,000
כן.

576
00:31:44,000 --> 00:31:46,000
[תגובת תלמיד לא נשמעה]

577
00:31:46,000 --> 00:31:50,000
בדיוק, ולכן הסוג * של שלל שזה מצביע מסוג כלשהו.

578
00:31:50,000 --> 00:31:53,000
שמו של מצביע זה הוא שרירותי הבא,

579
00:31:53,000 --> 00:32:00,000
אבל אנחנו יכולים לקרוא לה שום דבר שאנחנו רוצים, אבל מה זה נקודת מצביע זה?

580
00:32:00,000 --> 00:32:03,000
[סטודנטים] צומת נוספת. >> בדיוק, הוא מצביע על צומת כזו אחרת.

581
00:32:03,000 --> 00:32:05,000
>> עכשיו, זה סוג של סקרנות של ג

582
00:32:05,000 --> 00:32:09,000
תזכיר כי C נקראת על ידי ראש מהדר תחתון, משמאל לימין,

583
00:32:09,000 --> 00:32:13,000
מה שאומר שאם-הזה הוא קצת שונה ממה שעשינו עם התלמידים.

584
00:32:13,000 --> 00:32:16,000
כשהגדרנו סטודנט, אנחנו בעצם לא הכנסנו מילה שם.

585
00:32:16,000 --> 00:32:18,000
זה פשוט אמר typedef.

586
00:32:18,000 --> 00:32:20,000
ואז היה לנו זהות, שם int מחרוזת, מחרוזת בית,

587
00:32:20,000 --> 00:32:23,000
ואז תלמיד בתחתית struct.

588
00:32:23,000 --> 00:32:26,000
הצהרה זו היא קצת שונה, כי,

589
00:32:26,000 --> 00:32:28,000
שוב, מהדר C הוא קצת טמבל.

590
00:32:28,000 --> 00:32:30,000
זה רק הולך לקרוא מלמעלה למטה,

591
00:32:30,000 --> 00:32:33,000
כך שאם הוא מגיע לקו 2 כאן

592
00:32:33,000 --> 00:32:37,000
שם הבא הוכרזו והוא רואה, הו, הנה משתנה בשם הבא.

593
00:32:37,000 --> 00:32:39,000
זה מצביע לצומת struct.

594
00:32:39,000 --> 00:32:42,000
המהדר הוא תקלוט מה היא צומת struct?

595
00:32:42,000 --> 00:32:44,000
אני מעולם לא שמעתי על הדבר הזה,

596
00:32:44,000 --> 00:32:47,000
משום שמילת הצומת לא ייתכן אחרת תופיע

597
00:32:47,000 --> 00:32:49,000
עד תחתית, עד שזה יתירות.

598
00:32:49,000 --> 00:32:53,000
יש לך לומר צומת struct כאן, אשר תוכל לקצר בהמשך

599
00:32:53,000 --> 00:32:56,000
הודות לtypedef כאן למטה, אבל זה בגלל

600
00:32:56,000 --> 00:33:02,000
אנו התייחסות למבנה עצמו פנימי של המבנה.

601
00:33:02,000 --> 00:33:05,000
זה תפס אותך אחד שם.

602
00:33:05,000 --> 00:33:07,000
>> כמה בעיות מעניינות הולכות להתעורר.

603
00:33:07,000 --> 00:33:09,000
יש לנו רשימה של מספרים. איך להכניס לתוכו?

604
00:33:09,000 --> 00:33:11,000
איך לחפש אותו? איך למחוק ממנו?

605
00:33:11,000 --> 00:33:13,000
במיוחד עכשיו שיש לנו לנהל את כל מצביעים אלה.

606
00:33:13,000 --> 00:33:15,000
חשבו שהמצביעים היו סוג של כיפוף המוח

607
00:33:15,000 --> 00:33:17,000
כאשר יש לך אחד מהם רק מנסה לקרוא int אליו.

608
00:33:17,000 --> 00:33:20,000
עכשיו יש לנו לתפעל השווה של כל הרשימה.

609
00:33:20,000 --> 00:33:22,000
למה שלא תיקחו ההפסקה שלנו 5-הדקה פה, ואז תביאו את

610
00:33:22,000 --> 00:33:34,000
כמה אנשים על במה כדי לעשות בדיוק את זה.

611
00:33:34,000 --> 00:33:36,000
>> C היא הרבה יותר כיף כשזה ימומש.

612
00:33:36,000 --> 00:33:39,000
מי ממש רוצה להיות ראשון?

613
00:33:39,000 --> 00:33:41,000
אוקיי, בואו ניכנס. אתה ראשון.

614
00:33:41,000 --> 00:33:44,000
מי רוצה להיות 9? אוקיי, 9.

615
00:33:44,000 --> 00:33:46,000
מה דעתך על 9? 17?

616
00:33:46,000 --> 00:33:51,000
קליקה קטנה כאן. 22 ו 26 שבשורה ראשונה.

617
00:33:51,000 --> 00:33:53,000
ואז מה עם מישהו שם שמכוון אליי.

618
00:33:53,000 --> 00:33:57,000
אתה 34. אוקיי, בן 34, יעלה למעלה.

619
00:33:57,000 --> 00:33:59,000
הראשון היא שם. אוקיי, כל ארבעה החבר 'ה.

620
00:33:59,000 --> 00:34:01,000
ומי שלא אומרים ל9?

621
00:34:01,000 --> 00:34:04,000
מי הם 9?

622
00:34:04,000 --> 00:34:07,000
מי שבאמת רוצה להיות 9? בסדר, בואו, יהיו 9.

623
00:34:07,000 --> 00:34:10,000
הנה אנחנו מתחילים.

624
00:34:10,000 --> 00:34:13,000
34, שנפגוש אותך שם.

625
00:34:13,000 --> 00:34:17,000
החלק הראשון הוא להפוך את עצמכם להיראות ככה.

626
00:34:17,000 --> 00:34:21,000
26, 22, 17, טובים.

627
00:34:21,000 --> 00:34:25,000
אם אתה יכול לעמוד בצד, כי אנחנו הולכים malloc ברגע.

628
00:34:25,000 --> 00:34:29,000
>> טוב, טוב.

629
00:34:29,000 --> 00:34:32,000
אוקיי, מצוין, אז בואו נשאל כמה שאלות כאן.

630
00:34:32,000 --> 00:34:34,000
ובעצם, מה השם שלך? >> אניטה.

631
00:34:34,000 --> 00:34:37,000
אניטה, בסדר, לא תבואו לכאן.

632
00:34:37,000 --> 00:34:41,000
אניטה הולכת לעזור לנו סוג של לפתור שאלה אחת פשוטה למדי בתחילה,

633
00:34:41,000 --> 00:34:44,000
אשר הוא איך אתה מוצא אם ערך הוא ברשימה?

634
00:34:44,000 --> 00:34:48,000
עכשיו, שים לב שראשון, שמיוצג כאן על ידי לוקאס,

635
00:34:48,000 --> 00:34:52,000
הוא קצת שונה, וכן פיסת נייר שלו היא מכוון הצידה

636
00:34:52,000 --> 00:34:55,000
כי זה לא ממש גבוה כמו ולא תופס כמו חתיכות רבות,

637
00:34:55,000 --> 00:34:58,000
למרות שמבחינה טכנית יש לו את אותו הגודל של נייר פשוט הסתובב.

638
00:34:58,000 --> 00:35:01,000
אבל הוא קצת שונה בכך שהוא רק 32 ביטים למצביע,

639
00:35:01,000 --> 00:35:05,000
וכל החבר 'ה האלה הם 64 סיביים, שמחצית מהם הוא המספר, שמחציתן היא מצביע.

640
00:35:05,000 --> 00:35:08,000
אבל המצביע אינו מתואר, כך שאם אתם יכולים קצת מגושמים

641
00:35:08,000 --> 00:35:12,000
להשתמש ביד השמאל כדי להצביע על האדם שיושב לידך.

642
00:35:12,000 --> 00:35:14,000
ואתה מספר 34. מה שמך?

643
00:35:14,000 --> 00:35:16,000
ארי.

644
00:35:16,000 --> 00:35:19,000
ארי, אז למעשה, להחזיק את הנייר ביד ימין, ויד שמאל יורדת ישר.

645
00:35:19,000 --> 00:35:21,000
אתה מייצג אפס בצד השמאל.

646
00:35:21,000 --> 00:35:24,000
>> עכשיו התמונה האנושית שלנו היא מאוד עקבית.

647
00:35:24,000 --> 00:35:26,000
זהו למעשה כמה מצביעי עבודה.

648
00:35:26,000 --> 00:35:29,000
ואם אתה יכול לכווץ קצת בדרך זו ולכן אני לא בדרך שלך.

649
00:35:29,000 --> 00:35:34,000
אניטה כאן, תמצא לי את המספר 22,

650
00:35:34,000 --> 00:35:40,000
אבל תניח אילוץ של בני אדם לא מחזיקים את פיסות נייר,

651
00:35:40,000 --> 00:35:43,000
אבל זו רשימה, ויש לך רק לוקאס מלכתחילה

652
00:35:43,000 --> 00:35:46,000
משום שהוא, פשוטו כמשמעו, את המצביע הראשון.

653
00:35:46,000 --> 00:35:51,000
תניח שאתה בעצמך הוא מצביע, ואז יש לך את היכולת להצביע על משהו יותר מדי.

654
00:35:51,000 --> 00:35:56,000
למה שלא תתחיל בהצבעה על לוקאס בדיוק מה הוא מצביע?

655
00:35:56,000 --> 00:35:58,000
טוב, ולתת לחוקקי את זה כאן.

656
00:35:58,000 --> 00:36:04,000
רק לצורך הדיון, בואו תמשכו אותי דף ריק כאן.

657
00:36:04,000 --> 00:36:06,000
איך מאיית את השם שלך? >> אניטה.

658
00:36:06,000 --> 00:36:08,000
אוקיי, אניטה.

659
00:36:08,000 --> 00:36:18,000
נניח צומת * אניטה = לוקאס.

660
00:36:18,000 --> 00:36:22,000
ובכן, אנחנו לא צריכים לקרוא לך לוקאס. אנחנו צריכים לקרוא לך ראשונים.

661
00:36:22,000 --> 00:36:25,000
למה זה בעצם עולה בקנה אחד עם מציאות כאן?

662
00:36:25,000 --> 00:36:27,000
אחד, ראשון שכבר קיים.

663
00:36:27,000 --> 00:36:30,000
הראשון הוקצה כנראה איפשהו כאן למעלה.

664
00:36:30,000 --> 00:36:35,000
* הצומת ראשונה, וזה הוקצה רשימה איכשהו.

665
00:36:35,000 --> 00:36:37,000
אני לא יודע איך זה קרה. זה קרה לפני השיעור התחיל.

666
00:36:37,000 --> 00:36:40,000
רשימה מקושרת זה של בני אדם נוצרה.

667
00:36:40,000 --> 00:36:44,000
ועכשיו, בשלב זה בסיפור, כל זה הולך בפייסבוק ככל הנראה מאוחר יותר

668
00:36:44,000 --> 00:36:49,000
בנקודה זו בסיפור, אניטה אותחלה להיות שווה לראשון,

669
00:36:49,000 --> 00:36:51,000
מה שלא אומר שנקודתי אניטה בלוקאס.

670
00:36:51,000 --> 00:36:53,000
במקום זאת, היא מצביעה על מה שהוא מצביע על

671
00:36:53,000 --> 00:36:57,000
בגלל אותה כתובת שיש בפנים של 32 הסיביים של לוקאס - 1, 2, 3 -

672
00:36:57,000 --> 00:37:01,000
עכשיו גם חלק פנימי של 32 הסיביים של אניטה - 1, 2, 3.

673
00:37:01,000 --> 00:37:05,000
>> עכשיו למצוא 22. איך היית הולך על עושה את זה?

674
00:37:05,000 --> 00:37:07,000
מה זה נקודה? >> לכל דבר.

675
00:37:07,000 --> 00:37:11,000
להצביע על מה, אז קדימה, ולפעול את זה כמיטב היכולת לכאן.

676
00:37:11,000 --> 00:37:15,000
טוב, טוב, ועכשיו אתה מצביע, מה שמך עם 22?

677
00:37:15,000 --> 00:37:18,000
רמון. >> רמון, אז רמון הוא מחזיק עד 22.

678
00:37:18,000 --> 00:37:20,000
עכשיו יש לך לעשות בדיקה.

679
00:37:20,000 --> 00:37:24,000
האם רמון == 22, ואם כן, למשל, אנחנו יכולים לחזור אמיתיים.

680
00:37:24,000 --> 00:37:26,000
תן לי, בעוד החבר 'ה האלה עומדים כאן מעט מגושם-

681
00:37:26,000 --> 00:37:32,000
תן לי לעשות משהו במהירות כמו bool למצוא.

682
00:37:32,000 --> 00:37:37,000
אני הולך קדימה, ואומר (צומת * רשימה, int n).

683
00:37:37,000 --> 00:37:39,000
אני כבר חוזר איתכם. אני רק צריך לכתוב קצת קוד.

684
00:37:39,000 --> 00:37:45,000
ועכשיו אני הולך ללכת ולעשות, צומת * אניטה = רשימה זו.

685
00:37:45,000 --> 00:37:51,000
ואני הולך קדימה, ואומר אילו (אניטה! = NULL).

686
00:37:51,000 --> 00:37:57,000
>> המטאפורה כאן היא מקבלת קצת מתוחה, אבל בזמן (אניטה! = NULL), מה שאני רוצה לעשות?

687
00:37:57,000 --> 00:38:03,000
אני זקוק לדרך ההתייחסות

688
00:38:03,000 --> 00:38:05,000
השלם שאניטה היא מצביעה.

689
00:38:05,000 --> 00:38:08,000
בעבר, כאשר היו לנו מבנים, שצומת היא,

690
00:38:08,000 --> 00:38:11,000
השתמשנו בסימון הנקודה, ואנחנו היו אומרים משהו כמו

691
00:38:11,000 --> 00:38:15,000
anita.n, אבל הבעיה כאן היא שאניטה היא לא struct כשלעצמה.

692
00:38:15,000 --> 00:38:17,000
מה הוא?

693
00:38:17,000 --> 00:38:21,000
היא מצביעה, אז באמת, אם אנחנו רוצים להשתמש בנקודה זו סימון-

694
00:38:21,000 --> 00:38:23,000
וזה הולך להיראות בכוונה לא ברור מספיק,

695
00:38:23,000 --> 00:38:28,000
אנחנו צריכים לעשות משהו כמו ללכת יד השמאל של אניטה מה הוא מצביע

696
00:38:28,000 --> 00:38:31,000
ולאחר מכן לקבל את השדה שנקרא n.

697
00:38:31,000 --> 00:38:35,000
אניטה היא מצביע, אבל מה היא * אניטה?

698
00:38:35,000 --> 00:38:38,000
מה אתה מוצא כשאתה הולך למה שאניטה היא מצביעה?

699
00:38:38,000 --> 00:38:42,000
Struct, צומת וצומת, כזכור, יש שדה שנקרא n

700
00:38:42,000 --> 00:38:47,000
משום שהוא, כזכור, 2 תחומים אלה, הבאים וn,

701
00:38:47,000 --> 00:38:50,000
שראינו לפני רגע ממש כאן.

702
00:38:50,000 --> 00:38:53,000
>> למעשה לחקות זה בקוד,

703
00:38:53,000 --> 00:39:02,000
אנחנו יכולים לעשות את זה ואומרים שאם ((* anita). n == n), n שאני מחפש.

704
00:39:02,000 --> 00:39:04,000
שים לב כי הפונקציה עברה במספר שאכפת לי.

705
00:39:04,000 --> 00:39:10,000
אז אני יכול ללכת ולעשות משהו כמו תשואה אמיתית.

706
00:39:10,000 --> 00:39:12,000
אחר, אם זה לא מקרה, מה שאני רוצה לעשות?

707
00:39:12,000 --> 00:39:19,000
כיצד ניתן לתרגם לקוד מה אניטה עשתה זאת באופן אינטואיטיבי על ידי הליכה ברשימה?

708
00:39:19,000 --> 00:39:26,000
מה אני צריך לעשות כאן כדי לדמות אניטה צעד שלשמאל, צעד שלשמאל?

709
00:39:26,000 --> 00:39:28,000
[תגובת תלמיד לא נשמע] >> מה זה?

710
00:39:28,000 --> 00:39:30,000
[תגובת תלמיד לא נשמעה]

711
00:39:30,000 --> 00:39:34,000
טוב, רעיון לא רע, אבל בעבר, כשעשינו את זה, עשה אניטה + +

712
00:39:34,000 --> 00:39:37,000
משום שהייתי מוסיף מספר 1 לאניטה,

713
00:39:37,000 --> 00:39:40,000
אשר בדרך כלל מצביע על האדם הבא, כמו רמון,

714
00:39:40,000 --> 00:39:44,000
או האדם שיושב לידו, או לידו אדם לאורך הקו.

715
00:39:44,000 --> 00:39:49,000
אבל זה לא ממש טוב כאן משום מה הדבר הזה נראה כמו בזיכרון?

716
00:39:49,000 --> 00:39:54,000
לא זה. אנחנו צריכים לבטל את זה.

717
00:39:54,000 --> 00:40:00,000
זה נראה כאילו זה בזיכרון, ולמרות שאני נמשך 1 ו 2 ו 3 קרוב אחד לשני,

718
00:40:00,000 --> 00:40:03,000
אם אנחנו באמת לדמות הזאת-אתם יכולים, ועדיין מצביעים על אותם האנשים,

719
00:40:03,000 --> 00:40:07,000
כמה מכם יכול לקחת צעד אחורה אקראי, כמה מכם צעד קדימה אקראי?

720
00:40:07,000 --> 00:40:10,000
>> הבלגן הזה הוא עדיין רשימה מקושרת,

721
00:40:10,000 --> 00:40:13,000
אבל החבר 'ה האלה יכול להיות בכל מקום בזיכרון,

722
00:40:13,000 --> 00:40:15,000
כך אניטה + + היא לא הולכת לעבודה למה?

723
00:40:15,000 --> 00:40:19,000
מה במיקום אניטה + +?

724
00:40:19,000 --> 00:40:21,000
מי יודע.

725
00:40:21,000 --> 00:40:24,000
זה ערך אחר שפשוט כל כך קורה שחוצץ

726
00:40:24,000 --> 00:40:28,000
בין כל צומת הללו על ידי סיכוי כי אנחנו לא משתמשים במערך.

727
00:40:28,000 --> 00:40:30,000
אנחנו הקצינו כל אחד מצומת הללו בנפרד.

728
00:40:30,000 --> 00:40:32,000
אוקיי, אם אתם יכולים לנקות את עצמכם בחזרה למעלה.

729
00:40:32,000 --> 00:40:37,000
הרשו לי להציע שבמקום אניטה אניטה + +, במקום לעשות אנחנו מקבלים-

730
00:40:37,000 --> 00:40:42,000
טוב, למה שלא נלך לכל מה שאניטה היא מצביעה ולאחר מכן לעשות. הבא?

731
00:40:42,000 --> 00:40:45,000
במילים אחרות, אנחנו הולכים לרמון, שמחזיק במספר 22,

732
00:40:45,000 --> 00:40:51,000
ולאחר מכן. הבא הוא כאילו אניטה הייתי מעתיקה מצביעה בידו השמאלי.

733
00:40:51,000 --> 00:40:54,000
אבל היא לא רצתה ללכת רחוק יותר מרמון כי מצאו 22.

734
00:40:54,000 --> 00:40:56,000
אבל זה יהיה הרעיון. עכשיו, זה בלגן נורא ואיום.

735
00:40:56,000 --> 00:40:59,000
בכנות, אף אחד לא זוכר את תחביר זה, וכך לשמחתי,

736
00:40:59,000 --> 00:41:04,000
זה בעצם קצת מכוון-הו, אתה לא ממש רואה את מה שכתבתי.

737
00:41:04,000 --> 00:41:08,000
זה יהיה משכנע יותר אם אתה יכול. וואלה!

738
00:41:08,000 --> 00:41:10,000
>> מאחורי הקלעים, הייתי לפתור את הבעיה בדרך זו.

739
00:41:10,000 --> 00:41:14,000
אניטה, לקחת צעד לשמאל,

740
00:41:14,000 --> 00:41:18,000
ראשון, אנחנו הולכים לכתובת שאניטה היא מצביעה

741
00:41:18,000 --> 00:41:23,000
ושם היא תמצא את n, שאנו פשוט בדקנו לשם השוואה, לא רק

742
00:41:23,000 --> 00:41:25,000
אבל אתה גם מוצא בא - במקרה זה,

743
00:41:25,000 --> 00:41:28,000
יד השמאל של רמון מצביעה לצומת הבאה ברשימה.

744
00:41:28,000 --> 00:41:32,000
אבל זה בלגן הנורא והאיום שאליו התייחסתי קודם לכן,

745
00:41:32,000 --> 00:41:34,000
אבל מסתבר C מאפשרת לנו לפשט את זה.

746
00:41:34,000 --> 00:41:40,000
במקום כתיבה (* anita), אנחנו יכולים פשוט במקום לכתוב אניטה-> n,

747
00:41:40,000 --> 00:41:45,000
וזה בדיוק אותו דבר פונקציונלי, אבל זה הרבה יותר אינטואיטיבי,

748
00:41:45,000 --> 00:41:48,000
וזה הרבה יותר בקנה אחד עם התמונה שאנו מציירים

749
00:41:48,000 --> 00:41:50,000
כל הזמן הזה באמצעות חיצים.

750
00:41:50,000 --> 00:41:57,000
>> לבסוף, מה שאנחנו צריכים לעשות בסוף התכנית זו?

751
00:41:57,000 --> 00:42:00,000
יש שורה אחת של קוד שנותר.

752
00:42:00,000 --> 00:42:02,000
להחזיר את מה?

753
00:42:02,000 --> 00:42:05,000
שקר, כי אם לעבור את כל אילו לולאה

754
00:42:05,000 --> 00:42:10,000
ואניטה היא, למעשה, ריק, זה אומר שהיא הלכה כל הדרך עד סוף הרשימה

755
00:42:10,000 --> 00:42:12,000
מקום שהיא הצביעה ב- מה השם שלך שוב?

756
00:42:12,000 --> 00:42:15,000
יד ארי. >> של ארי השמאל, שהיא אפס.

757
00:42:15,000 --> 00:42:18,000
אניטה היא עכשיו ריקה, ואני מבין שאתה רק עומד כאן במבוכה בלימבו

758
00:42:18,000 --> 00:42:21,000
מכיוון שאני עומד על את מונולוג כאן,

759
00:42:21,000 --> 00:42:23,000
אבל אנחנו ערב אותך שוב ברגע.

760
00:42:23,000 --> 00:42:27,000
אניטה היא ריקה בשלב זה בסיפור, ולכן בעוד הלולאה מסתיימת,

761
00:42:27,000 --> 00:42:30,000
ויש לנו לחזור כוזב כי אם היא עשתה את כל הדרך למצביע null של ארי

762
00:42:30,000 --> 00:42:34,000
אז לא היה מספר שהיא חפשה ברשימה.

763
00:42:34,000 --> 00:42:39,000
אנו יכולים לנקות את זה יותר מדי, אבל זה יישום די טוב אז

764
00:42:39,000 --> 00:42:43,000
של פונקצית חצייה, למצוא את הפונקציה לרשימה מקושרת.

765
00:42:43,000 --> 00:42:48,000
זה עדיין חיפוש ליניארי, אבל זה לא פשוט כמו + + מצביע

766
00:42:48,000 --> 00:42:52,000
או + + משתנה i כי עכשיו אנחנו לא יכולים לנחש

767
00:42:52,000 --> 00:42:54,000
כאשר כל אחת מצומת האלה הם בזיכרון.

768
00:42:54,000 --> 00:42:57,000
יש לנו, פשוטו כמשמעו, כדי לעקוב אחרי השובל של פירורי לחם או, לייתר דיוק,

769
00:42:57,000 --> 00:43:00,000
מצביעים, להגיע מצומת אחד למשנו.

770
00:43:00,000 --> 00:43:02,000
>> עכשיו בואו ננסה עוד אחד. אניטה, אתה רוצה לחזור לכאן?

771
00:43:02,000 --> 00:43:06,000
למה שלא להמשיך ולהקצות אדם אחר אחד מהקהל?

772
00:43:06,000 --> 00:43:08,000
Malloc-מה השם שלך? >> רבקה.

773
00:43:08,000 --> 00:43:10,000
רבקה. רבקה כבר malloced מהקהל,

774
00:43:10,000 --> 00:43:13,000
והיא כעת אחסון המספר 55.

775
00:43:13,000 --> 00:43:17,000
והמטרה בהישג יד כרגע היא לאניטה להכניס

776
00:43:17,000 --> 00:43:22,000
רבקה לרשימה המקושרת כאן במקום הראוי לו.

777
00:43:22,000 --> 00:43:24,000
בואו הנה לרגע.

778
00:43:24,000 --> 00:43:28,000
אני עשיתי משהו כזה.

779
00:43:28,000 --> 00:43:32,000
עשיתי * צומת. ואיך קורא לך שוב?

780
00:43:32,000 --> 00:43:34,000
רבקה. >> רבקה, בסדר.

781
00:43:34,000 --> 00:43:41,000
רבקה מקבלת malloc (sizeof (צומת)).

782
00:43:41,000 --> 00:43:44,000
בדיוק כמו שאנו הקצינו דברים כמו סטודנטים ומה לא בעבר,

783
00:43:44,000 --> 00:43:46,000
אנחנו צריכים את הגודל של הצומת, כך שעכשיו רבקה

784
00:43:46,000 --> 00:43:49,000
הוא מצביע על מה?

785
00:43:49,000 --> 00:43:52,000
רבקה יש שני תחומים בתוכה, אחד מהם הם 55.

786
00:43:52,000 --> 00:43:55,000
בואו נעשה מה, רבקה-> = 55.

787
00:43:55,000 --> 00:44:00,000
אבל אז רבקה-> הבא צריך להיות-כמו עכשיו, ידה היא סוג של מי יודע?

788
00:44:00,000 --> 00:44:03,000
זה מצביע על איזה ערך זבל, אז למה לא למען הסדר טוב

789
00:44:03,000 --> 00:44:07,000
אנחנו לפחות עושים זאת כדי שיד שמאל היא עכשיו בצד שלה.

790
00:44:07,000 --> 00:44:09,000
עכשיו אניטה, קח אותו מכאן.

791
00:44:09,000 --> 00:44:11,000
יש לך רבקה שהוקצתה.

792
00:44:11,000 --> 00:44:20,000
קדימה ולמצוא בו אנחנו צריכים לשים את רבקה.

793
00:44:20,000 --> 00:44:25,000
טוב, טוב מאוד.

794
00:44:25,000 --> 00:44:28,000
אוקיי, טוב, ועכשיו אנחנו צריכים אותך כדי לספק קצת כיוון,

795
00:44:28,000 --> 00:44:30,000
כך שהגעת לארי.

796
00:44:30,000 --> 00:44:33,000
בידו השמאלי הוא אפס, אבל רבקה שייכת בבירור לימין,

797
00:44:33,000 --> 00:44:36,000
אז איך אנחנו צריכים לשנות את הרשימה מקושרת זה

798
00:44:36,000 --> 00:44:38,000
כדי להכניס את רבקה למקום המתאים?

799
00:44:38,000 --> 00:44:42,000
אם אתה ממש יכולת להזיז את הידות השמאליות של אנשים מסביב לפי צורך,

800
00:44:42,000 --> 00:44:48,000
אנחנו נסדר את הבעיה בדרך זו.

801
00:44:48,000 --> 00:44:52,000
אוקיי, טוב, ובינתיים, יד השמאל של רבקה היא עכשיו על הצד שלה.

802
00:44:52,000 --> 00:44:54,000
>> זה היה קל מדי.

803
00:44:54,000 --> 00:44:57,000
בואו ננסה הקצאה-אנחנו כבר כמעט סיימנו, 20.

804
00:44:57,000 --> 00:44:59,000
אוקיי, בואו ניכנס.

805
00:44:59,000 --> 00:45:04,000
20 הוקצו, אז תן לי ללכת קדימה ואומרים שוב כאן

806
00:45:04,000 --> 00:45:07,000
פשוט עשינו סעד * צומת.

807
00:45:07,000 --> 00:45:11,000
יש לנו malloc (sizeof (צומת)).

808
00:45:11,000 --> 00:45:16,000
אז אנחנו עושים אותו התחביר המדויק כפי שעשינו קודם ל20,

809
00:45:16,000 --> 00:45:20,000
ואני אעשה = NULL הבא, ועכשיו זה תלוי בי אניטה

810
00:45:20,000 --> 00:45:23,000
כדי להכניס אותך לרשימה המקושרת, אם אתה יכול לשחק באותו תפקיד בדיוק.

811
00:45:23,000 --> 00:45:30,000
ביצוע.

812
00:45:30,000 --> 00:45:32,000
בסדר, טוב.

813
00:45:32,000 --> 00:45:38,000
עכשיו תחשוב היטב לפני שתתחיל להזיז את הידות שמאליות בסביבה.

814
00:45:38,000 --> 00:45:46,000
אתה ללא ספק קבלת את התפקיד המביך ביותר כיום.

815
00:45:46,000 --> 00:45:59,000
ידו של מי צריך להיות הראשון שזז?

816
00:45:59,000 --> 00:46:02,000
אוקיי, הרגע, אני שומע כמה לא של.

817
00:46:02,000 --> 00:46:07,000
אם כמה אנשים בנימוס ברצון לעזור לפתור מצב מביך כאן.

818
00:46:07,000 --> 00:46:11,000
יד שמאל שצריך להיות מעודכנת, אולי לראשונה? כן.

819
00:46:11,000 --> 00:46:13,000
[סטודנטים] סעד של.

820
00:46:13,000 --> 00:46:15,000
אוקיי, סעד של, למה, בעצם?

821
00:46:15,000 --> 00:46:17,000
[תגובת תלמיד לא נשמעה]

822
00:46:17,000 --> 00:46:19,000
טוב, כי אם תעברו, מה שמך? >> מרשל.

823
00:46:19,000 --> 00:46:22,000
מרשל, שאם תזיז את ידו הראשונה למטה לnull,

824
00:46:22,000 --> 00:46:25,000
עכשיו יש לנו ארבעה אנשים, פשוטו כמשמעו, התייתמו ברשימה זו

825
00:46:25,000 --> 00:46:29,000
כי הוא היה הדבר היחיד שמצביע על רמון וכולם לשמאל,

826
00:46:29,000 --> 00:46:31,000
כך מעדכן כי המצביע ראשון היה רע.

827
00:46:31,000 --> 00:46:33,000
הבה תתיר את זה.

828
00:46:33,000 --> 00:46:37,000
טוב, ועכשיו קדימה ולהזיז את יד השמאל המתאימה מצביעה על רמון.

829
00:46:37,000 --> 00:46:39,000
זה מרגיש קצת מיותר.

830
00:46:39,000 --> 00:46:41,000
עכשיו יש שני אנשים מצביעים על רמון, אבל זה בסדר

831
00:46:41,000 --> 00:46:43,000
כי עכשיו איך עוד אנחנו לעדכן את הרשימה?

832
00:46:43,000 --> 00:46:48,000
מה מצד שני יש לעבור?

833
00:46:48,000 --> 00:46:53,000
מצוין, עכשיו יש לנו אבדתי כל זיכרון?

834
00:46:53,000 --> 00:46:57,000
לא, כל כך טוב, בואו נראה אם ​​אנחנו לא יכולים לעבור את זה פעם נוספת.

835
00:46:57,000 --> 00:47:00,000
>> Mallocing הפעם האחרונה, מספר 5.

836
00:47:00,000 --> 00:47:04,000
כל הדרך חזרה ב, בואי למטה.

837
00:47:04,000 --> 00:47:08,000
זה מאוד מרגש.

838
00:47:08,000 --> 00:47:15,000
[מחיאות כפות]

839
00:47:15,000 --> 00:47:17,000
מה שמך? >> רון.

840
00:47:17,000 --> 00:47:19,000
רון, בסדר, אתה malloced כמספר 5.

841
00:47:19,000 --> 00:47:23,000
שמנו רק להורג קוד זה כמעט זהה לאלה

842
00:47:23,000 --> 00:47:26,000
רק עם שם אחרים.

843
00:47:26,000 --> 00:47:28,000
מצוין.

844
00:47:28,000 --> 00:47:38,000
עכשיו, אניטה, מזל טוב החדרת מספר 5 ברשימה עכשיו.

845
00:47:38,000 --> 00:47:43,000
טוב, ו?

846
00:47:43,000 --> 00:47:47,000
מצוין, אז זה באמת שלישי של שלושה מקרים בסך הכל.

847
00:47:47,000 --> 00:47:49,000
הייתי צריכים קודם מישהו בסוף, רבקה.

848
00:47:49,000 --> 00:47:51,000
אז היה לנו מישהו באמצע.

849
00:47:51,000 --> 00:47:53,000
עכשיו יש לנו מישהו בהתחלה, ובדוגמה זו,

850
00:47:53,000 --> 00:47:56,000
עכשיו היו לנו לעדכן את לוקאס בפעם הראשונה

851
00:47:56,000 --> 00:48:00,000
משום שהמרכיב הראשון ברשימה עכשיו יש להצביע על צומת חדשה,

852
00:48:00,000 --> 00:48:03,000
אשר, בתורו, מצביע על מספר הצומת 9.

853
00:48:03,000 --> 00:48:06,000
>> זו הייתה הפגנה עצומה מביכה, אני בטוח,

854
00:48:06,000 --> 00:48:08,000
אז מחיאות כפות לחבר 'ה האלה אם אתה יכול.

855
00:48:08,000 --> 00:48:11,000
יפה עשה.

856
00:48:11,000 --> 00:48:17,000
זה הכל. אתה יכול לשמור על הכלים שלך של נייר כזיכרון קטן.

857
00:48:17,000 --> 00:48:22,000
מתברר שעושה את זה בקוד

858
00:48:22,000 --> 00:48:26,000
הוא לא ממש פשוט כמו רק להזיז את הידות סביב

859
00:48:26,000 --> 00:48:28,000
ומצביעים מצביעים בדברים שונים.

860
00:48:28,000 --> 00:48:31,000
אבל מבין שכאשר מגיע זמן ליישם משהו כמו

861
00:48:31,000 --> 00:48:34,000
רשימה מקושרת או גרסה שלו אם להתמקד באמת

862
00:48:34,000 --> 00:48:38,000
יסודות בסיסיים אלו, בעיות בגודל נגיסה שיש לי כדי להבין,

863
00:48:38,000 --> 00:48:43,000
זה זה יד או יד זה, מבין כי מה שהיא בדרך אחרת תכנית מורכבת למדי

864
00:48:43,000 --> 00:48:47,000
יכול, למעשה, להיות מופחת לאבני בניין פשוטים למדי כמו זה.

865
00:48:47,000 --> 00:48:51,000
>> בואו ניקח את הדברים בכיוון יותר מתוחכם עדיין.

866
00:48:51,000 --> 00:48:53,000
עכשיו יש לנו את הרעיון של הרשימה המקושרת.

867
00:48:53,000 --> 00:48:57,000
שיש לנו תודה גם להצעה לחזור לשם, רשימה מקושרת כפליים,

868
00:48:57,000 --> 00:49:01,000
שנראה כמעט אותו הדבר, אבל עכשיו יש לנו שני מצביעים בתוך struct

869
00:49:01,000 --> 00:49:05,000
במקום אחד, ואנחנו יכולים כנראה קוראים למצביעים הללו קודמים והבאים

870
00:49:05,000 --> 00:49:08,000
או שמאלה או ימינה, אבל אנחנו כן, למעשה, צריכים שניים מהם.

871
00:49:08,000 --> 00:49:10,000
הקוד יהיה קצת יותר מעורב.

872
00:49:10,000 --> 00:49:12,000
אניטה הייתי צריכה לעשות את עבודה יותר כאן על הבמה.

873
00:49:12,000 --> 00:49:15,000
אבל אנחנו בהחלט יכולים ליישם סוג זה של מבנה.

874
00:49:15,000 --> 00:49:19,000
במונחים של זמן ריצה, אם כי, מה יהיה זמן הריצה

875
00:49:19,000 --> 00:49:24,000
לאניטה למצוא מספר n ברשימה מקושרת עכשיו?

876
00:49:24,000 --> 00:49:27,000
עדיין גדול O של n, כך שזה לא טוב יותר מחיפוש לינארי.

877
00:49:27,000 --> 00:49:29,000
אנחנו לא יכולים לעשות חיפוש בינארי, אם כי, שוב.

878
00:49:29,000 --> 00:49:34,000
מדוע זה כך? אתה לא יכול לקפוץ.

879
00:49:34,000 --> 00:49:36,000
למרות שברורים שאנחנו נראה את כל בני האדם על הבמה,

880
00:49:36,000 --> 00:49:39,000
ואניטה יכלה eyeballed ואמרה, "הנה באמצע הרשימה,"

881
00:49:39,000 --> 00:49:42,000
היא לא יודעת שאם היא הייתה תכנית המחשב

882
00:49:42,000 --> 00:49:47,000
כי הדבר היחיד שהיא צריכה להיצמד לתחילת התרחיש

883
00:49:47,000 --> 00:49:50,000
היה לוקאס, שהיה המצביע הראשון.

884
00:49:50,000 --> 00:49:53,000
היא הייתה בהכרח צריכה לעקוב אחרי הקישורים האלה,

885
00:49:53,000 --> 00:49:56,000
סופר את דרכה עד שמצאתי בערך באמצע,

886
00:49:56,000 --> 00:49:58,000
וגם אז, היא לא הולכת ליודעת מתי היא הגיעה לאמצע

887
00:49:58,000 --> 00:50:01,000
אלא אם כן היא הולכת כל הדרך עד הסוף כדי להבין כמה יש,

888
00:50:01,000 --> 00:50:05,000
אז נסוג, וגם זה יהיה קשה, אלא אם כן היה לך

889
00:50:05,000 --> 00:50:07,000
רשימה מקושרת כפליים מסוג כלשהו.

890
00:50:07,000 --> 00:50:10,000
>> לפתור כמה בעיות היום, אבל מציג לאחרים.

891
00:50:10,000 --> 00:50:12,000
מה לגבי מבנה נתונים אחר לגמרי?

892
00:50:12,000 --> 00:50:15,000
זהו תצלום של את המגשים במאת'ר הבית,

893
00:50:15,000 --> 00:50:19,000
ובמקרה הזה, יש לנו מבנה נתונים שגם סוג של כבר מדבר עליו.

894
00:50:19,000 --> 00:50:22,000
דברנו על ערימה בהקשר של זיכרון,

895
00:50:22,000 --> 00:50:26,000
וזה סוג של המקום נקרא על שם בכוונה, כי מחסנית במונחים של זיכרון

896
00:50:26,000 --> 00:50:31,000
הוא למעשה מבנה נתונים שיש יותר ויותר דברים, שכבות על גבי זה.

897
00:50:31,000 --> 00:50:35,000
אבל מה שמעניין לגבי מחסנית, כפי שקורה במציאות,

898
00:50:35,000 --> 00:50:38,000
הוא שזה סוג מיוחד של מבנה נתונים.

899
00:50:38,000 --> 00:50:42,000
זה מבנה נתונים לפי הרכיב הראשון ב

900
00:50:42,000 --> 00:50:46,000
הוא האלמנט האחרון החוצה.

901
00:50:46,000 --> 00:50:50,000
אם אתה המגש הראשון ששם על המחסנית,

902
00:50:50,000 --> 00:50:53,000
אתה הולך להיות לצערי המגש האחרון שצריך לקחת את הערימה,

903
00:50:53,000 --> 00:50:55,000
וזה לא בהכרח דבר טוב.

904
00:50:55,000 --> 00:50:58,000
לעומת זאת, אתה יכול לחשוב על זה בכיוון הפוך,

905
00:50:58,000 --> 00:51:02,000
האחרון בהוא יוצא הראשון.

906
00:51:02,000 --> 00:51:05,000
>> עכשיו, אל תרחישים כל עולים על דעת שיש בו מחסנית

907
00:51:05,000 --> 00:51:08,000
מבנה הנתונים שבו יש לך נכס ש

908
00:51:08,000 --> 00:51:13,000
בפעם האחרונה, יוצא ראשון, הוא למעשה משכנע?

909
00:51:13,000 --> 00:51:16,000
האם זה דבר טוב? האם זה דבר רע?

910
00:51:16,000 --> 00:51:19,000
זה בהחלט דבר רע אם את המגשים לא היה כולם זהה

911
00:51:19,000 --> 00:51:21,000
וכולן בצבעים השונים המיוחדים או מה לא,

912
00:51:21,000 --> 00:51:24,000
ואת הצבע שאתה רוצה זה כל הדרך בתחתית.

913
00:51:24,000 --> 00:51:26,000
כמובן, אתה לא יכול לקבל את זה ללא מאמץ גדול.

914
00:51:26,000 --> 00:51:28,000
אתה צריך להתחיל מלמעלה, והמשך הלאה בדרך שלך.

915
00:51:28,000 --> 00:51:31,000
בדומה לכך, מה אם אתה היית אחד מן הנערים הללו המאוורר

916
00:51:31,000 --> 00:51:34,000
שמחכה כל הלילה מנסה להשיג אייפון וקווים עד

917
00:51:34,000 --> 00:51:36,000
במקום כזה?

918
00:51:36,000 --> 00:51:40,000
האם לא יהיה זה נחמד אם החנות של אפל

919
00:51:40,000 --> 00:51:42,000
היה מבנה נתוני מחסנית?

920
00:51:42,000 --> 00:51:44,000
Yay? ניי?

921
00:51:44,000 --> 00:51:47,000
זה טוב רק לאנשים שמופיעים ברגע האחרון האפשרי

922
00:51:47,000 --> 00:51:50,000
ולאחר מכן לקבל קטף את התור.

923
00:51:50,000 --> 00:51:52,000
ואכן, העובדה שהייתי כל כך נוטה לומר תור

924
00:51:52,000 --> 00:51:56,000
הוא למעשה בקנה אחד עם מה שהיינו קורא לזה סוג של מבנה נתונים,

925
00:51:56,000 --> 00:51:59,000
אחד במציאות שבה סדר כן משנה,

926
00:51:59,000 --> 00:52:02,000
ואתה רוצה את הראשון בלהיות ראשון שיצא

927
00:52:02,000 --> 00:52:04,000
אם רק לשם הגינות אנושית.

928
00:52:04,000 --> 00:52:07,000
אנחנו בדרך כלל נתקשר כי מבנה נתוני תור.

929
00:52:07,000 --> 00:52:11,000
>> מתברר מלבד רשימות מקושרות, אנו יכולים להתחיל להשתמש ברעיונות בסיסיים באותם

930
00:52:11,000 --> 00:52:15,000
ולהתחיל ליצור סוגים חדשים ושונים של פתרונות לבעיות.

931
00:52:15,000 --> 00:52:19,000
לדוגמה, במקרה של מחסנית, אנחנו יכולים לייצג מחסנית

932
00:52:19,000 --> 00:52:22,000
שימוש במבנה נתונים כזה, אני הייתי מציע.

933
00:52:22,000 --> 00:52:26,000
במקרה זה, שהכרזתי זה עתה struct, ואני כבר אמרתי פנימי של מבנה זה

934
00:52:26,000 --> 00:52:30,000
הוא מערך של מספרים ולאחר מכן גודל משתנה בשם,

935
00:52:30,000 --> 00:52:33,000
ואני הולך לקרוא לזה דבר ערימה.

936
00:52:33,000 --> 00:52:35,000
עכשיו, למה זה באמת עובד?

937
00:52:35,000 --> 00:52:43,000
במקרה של מחסנית, אני יכול לצייר ביעילות זה על המסך כמו מערך.

938
00:52:43,000 --> 00:52:47,000
הנה הערימה שלי. אלה הם המספרים שלי.

939
00:52:47,000 --> 00:52:50,000
ואנו לצייר אותם כמו זה, זה, זה, זה, זה.

940
00:52:50,000 --> 00:52:53,000
ואז יש לי כמה חבר נתונים אחרים כאן,

941
00:52:53,000 --> 00:52:58,000
אשר נקרא גודל, אז זה גודל, וזה מספרים,

942
00:52:58,000 --> 00:53:02,000
וביחד, כל האייפד כאן מייצג מבנה ערימה אחת.

943
00:53:02,000 --> 00:53:07,000
עכשיו, כברירת מחדל, גודל שכנראה חייב להיות מאותחל ל 0,

944
00:53:07,000 --> 00:53:11,000
ומה שבפנים במערך של מספרים ראשוניים

945
00:53:11,000 --> 00:53:14,000
כשאני להקצות מערך ראשון?

946
00:53:14,000 --> 00:53:16,000
זבל. מי יודע? וזה לא ממש משנה.

947
00:53:16,000 --> 00:53:20,000
זה לא משנה אם זה הוא 1, 2, 3, 4, 5, לחלוטין באופן אקראי

948
00:53:20,000 --> 00:53:25,000
על ידי מזל רע המאוחסנים במבנה שלי כי כל עוד אני יודע שהגודל של המחסנית

949
00:53:25,000 --> 00:53:29,000
הוא 0, ואז אני יודע תכנות, לא מסתכל על אף אחד מהאלמנטים במערך.

950
00:53:29,000 --> 00:53:31,000
זה לא משנה מה יש שם.

951
00:53:31,000 --> 00:53:34,000
אל תסתכל עליהם, כפי שיהיה המשמעות של גודל של 0.

952
00:53:34,000 --> 00:53:38,000
>> אבל יניח שעכשיו אני הולך קדימה ולהכניס משהו לתוך המחסנית.

953
00:53:38,000 --> 00:53:42,000
אני רוצה להכניס את המספר 5, אז שמתי מספר 5 כאן,

954
00:53:42,000 --> 00:53:45,000
ואז מה ישים כאן למטה?

955
00:53:45,000 --> 00:53:48,000
עכשיו אני ממש לא הנחתי 1 עבור הגודל,

956
00:53:48,000 --> 00:53:50,000
ועכשיו היא בגודל הערימה 1.

957
00:53:50,000 --> 00:53:53,000
מה אם אני הולך קדימה ולהכניס את המספר, יניח, ליד 7?

958
00:53:53,000 --> 00:53:57,000
אז זה מתעדכן ל 2, ואז אנחנו נעשה 9,

959
00:53:57,000 --> 00:54:02,000
ואז זה מתעדכן ל 3.

960
00:54:02,000 --> 00:54:05,000
אבל התכונה המעניינת עכשיו ערימה של זה היא כי

961
00:54:05,000 --> 00:54:09,000
אני אמור להסיר את האלמנט שאם אני רוצה לקפוץ

962
00:54:09,000 --> 00:54:12,000
משהו מהערימה, כביכול?

963
00:54:12,000 --> 00:54:14,000
9 יהיו הדבר הראשון ללכת.

964
00:54:14,000 --> 00:54:18,000
איך התמונה צריכה להשתנות אם אני רוצה לפוצץ את אלמנט המחסנית,

965
00:54:18,000 --> 00:54:20,000
הרבה אוהב את מגש למאת'ר?

966
00:54:20,000 --> 00:54:22,000
כן. >> [סטודנטים] גודל מוגדר 2.

967
00:54:22,000 --> 00:54:27,000
בדיוק, כל מה שאני עושה הוא להגדיר גודל 2, ומה עליי לעשות עם המערך?

968
00:54:27,000 --> 00:54:29,000
אני לא צריך לעשות שום דבר.

969
00:54:29,000 --> 00:54:32,000
אני יכול, רק כדי להיות אנאלי, לשים 0 שם או -1 או משהו שיעיד

970
00:54:32,000 --> 00:54:34,000
כי זה לא ערך חוקי, אבל זה לא משנה כי

971
00:54:34,000 --> 00:54:37,000
אני יכול להקליט מחוץ למערך עצמו כמה זמן הוא

972
00:54:37,000 --> 00:54:41,000
כך שאני יודע שמסתכל רק על שני המרכיבים הראשונים במערך הזה.

973
00:54:41,000 --> 00:54:47,000
עכשיו, אם אני הולך ולהוסיף את המספר 8 למערך זה, איך לשנות את התמונה הבאה?

974
00:54:47,000 --> 00:54:50,000
זה הופך להיות 8, וזה הופך להיות 3.

975
00:54:50,000 --> 00:54:52,000
אני חותך כמה פינות כאן.

976
00:54:52,000 --> 00:54:56,000
עכשיו יש לנו 5, 7, 8, ואנחנו שוב לגודל של 3.

977
00:54:56,000 --> 00:54:58,000
זה די פשוט לביצוע,

978
00:54:58,000 --> 00:55:06,000
אבל כאשר אנחנו הולכים להתחרט על החלטת העיצוב הזה?

979
00:55:06,000 --> 00:55:09,000
כאשר הדברים מתחילים ללכת מאוד מאוד לא בסדר? כן.

980
00:55:09,000 --> 00:55:11,000
[תגובת תלמיד לא נשמעה]

981
00:55:11,000 --> 00:55:13,000
כשאתה רוצה לחזור ולקבל את האלמנט הראשון שהכנסת פנימה

982
00:55:13,000 --> 00:55:18,000
>> מתברר כאן למרות שמחסנית היא מערך מתחת למכסת המנוע,

983
00:55:18,000 --> 00:55:21,000
מבני נתונים אלה התחלנו לדבר על גם ידועים בדרך כלל

984
00:55:21,000 --> 00:55:25,000
מבני נתונים מופשטים לפי איך הם יישמו

985
00:55:25,000 --> 00:55:27,000
הוא לגמרי ממין העניין.

986
00:55:27,000 --> 00:55:31,000
מבנה נתונים כמו ערימה אמור להוסיף תמיכה

987
00:55:31,000 --> 00:55:35,000
פעולות כמו לדחוף, אשר דוחף את מגש על המחסנית,

988
00:55:35,000 --> 00:55:39,000
ופופ, אשר מסיר אלמנט מהמחסנית, וזהו זה.

989
00:55:39,000 --> 00:55:43,000
אם היו לך להוריד קוד של מישהו אחר שכבר מיושם

990
00:55:43,000 --> 00:55:46,000
הדבר הזה שנקרא מחסנית, האדם שהייתי כותב

991
00:55:46,000 --> 00:55:49,000
רק שתי פונקציות עבורך, לדחוף ופופ, שכל מטרתו בחיים

992
00:55:49,000 --> 00:55:51,000
יהיה לעשות בדיוק את זה.

993
00:55:51,000 --> 00:55:54,000
אתה או או לה שיישמת את התכנית ש

994
00:55:54,000 --> 00:55:58,000
היה כל אחד כדי להחליט כיצד ליישם

995
00:55:58,000 --> 00:56:00,000
את הסמנטיקה של דחיפות וצצים מתחת למכסת המנוע

996
00:56:00,000 --> 00:56:03,000
או הפונקציונלי של דחיפה ומכניס.

997
00:56:03,000 --> 00:56:07,000
ויש לי החלטה קצת קצרה רואי כאן

998
00:56:07,000 --> 00:56:10,000
על ידי יישום הערימה שלי עם מבנה זה נתונים פשוט למה?

999
00:56:10,000 --> 00:56:12,000
כאשר עושה הפסקת מבנה נתונים זה?

1000
00:56:12,000 --> 00:56:18,000
באיזה שלב שאני צריך להחזיר שגיאה כאשר המשתמש קורא דחיפה, למשל?

1001
00:56:18,000 --> 00:56:20,000
[סטודנטים] אם אין יותר מקום.

1002
00:56:20,000 --> 00:56:23,000
בדיוק, אם אין יותר מקום, אם חרגתי מקיבולת,

1003
00:56:23,000 --> 00:56:27,000
שהוא כל הכמוסות כי זה עולה כי זה סוג של קבוע הגלובלי.

1004
00:56:27,000 --> 00:56:30,000
טוב, אז אני פשוט הולך לחייב לומר, "מצטער, אני לא יכול לדחוף ערך אחר

1005
00:56:30,000 --> 00:56:32,000
על המחסנית, "הרבה כמו במאת'ר.

1006
00:56:32,000 --> 00:56:36,000
>> בשלב מסוים, הם הולכים להכות את החלק העליון של שהארון הקטן.

1007
00:56:36,000 --> 00:56:39,000
אין יותר מקום או קיבולת בערימה, ובשלב זה יש איזה סוג של טעות.

1008
00:56:39,000 --> 00:56:42,000
הם צריכים לשים את הרכיב במקום אחר, את המגש למקום אחר,

1009
00:56:42,000 --> 00:56:44,000
או בכלל לא קיים.

1010
00:56:44,000 --> 00:56:47,000
עכשיו, עם תור, היינו יכול ליישם את זה קצת אחר.

1011
00:56:47,000 --> 00:56:50,000
תור הוא קצת שונה בכך שמתחת למכסת המנוע, זה יכול להיות מיושם

1012
00:56:50,000 --> 00:56:54,000
כמערך, אבל למה, במקרה זה, אני מציע

1013
00:56:54,000 --> 00:56:59,000
גם יש אלמנט ראש המייצג את ראש הרשימה,

1014
00:56:59,000 --> 00:57:06,000
מול הרשימה, האדם הראשון בתור בחנות של אפל, בנוסף לגודל?

1015
00:57:06,000 --> 00:57:14,000
מדוע אני זקוק לחתיכה נוספת של נתונים לכאן?

1016
00:57:14,000 --> 00:57:16,000
לחשוב ולהיזכר מה הוא מספרים

1017
00:57:16,000 --> 00:57:18,000
אם אני ארשום אותו באופן בא.

1018
00:57:18,000 --> 00:57:21,000
תניח שזה עכשיו תור במקום מחסנית,

1019
00:57:21,000 --> 00:57:24,000
ההבדל הוא, בדיוק כמו בחנות תור אפל הוא הוגן.

1020
00:57:24,000 --> 00:57:27,000
האדם הראשון בשורה בתחילת הרשימה, המספר 5 במקרה זה,

1021
00:57:27,000 --> 00:57:30,000
הוא או היא עומד זכות להיכנס לחנות ראשונה.

1022
00:57:30,000 --> 00:57:32,000
בואו לעשות את זה.

1023
00:57:32,000 --> 00:57:35,000
תניח שזה המצב של התור שלי ברגע זה בזמן, ועכשיו החנות של אפל

1024
00:57:35,000 --> 00:57:39,000
נפתח והאדם הראשון, מספר 5, מובל אל תוך החנות.

1025
00:57:39,000 --> 00:57:43,000
איך אני משנה את התמונה שיש לי עכשיו דה בתור האדם הראשון

1026
00:57:43,000 --> 00:57:47,000
בחזית של הקו?

1027
00:57:47,000 --> 00:57:50,000
מה זה? >> [סטודנטים] שינוי התור.

1028
00:57:50,000 --> 00:57:52,000
שינוי בראש, ולכן 5 נעלמים.

1029
00:57:52,000 --> 00:57:56,000
במציאות, זה כאילו, איך הכי טוב לעשות זאת?

1030
00:57:56,000 --> 00:58:00,000
במציאות, זה כאילו שהבחור הזה נעלם.

1031
00:58:00,000 --> 00:58:03,000
מה מספר 7 היה עושה בחנות בפועל?

1032
00:58:03,000 --> 00:58:05,000
הם היו לוקחים צעד גדול קדימה.

1033
00:58:05,000 --> 00:58:08,000
>> אבל מה שאנחנו באים להעריך כשזה מגיע למערכים

1034
00:58:08,000 --> 00:58:10,000
והזיז דברים?

1035
00:58:10,000 --> 00:58:12,000
זה סוג של בזבוז הזמן שלך, נכון?

1036
00:58:12,000 --> 00:58:16,000
למה אתה צריך להיות כל כך אנאלי כמו שיש לאדם הראשון

1037
00:58:16,000 --> 00:58:21,000
בתחילתו של הקו באופן פיזי תחילת הנתח של זיכרון?

1038
00:58:21,000 --> 00:58:23,000
זה מיותר לחלוטין. למה?

1039
00:58:23,000 --> 00:58:26,000
מה יכול אני רק זוכר במקום? >> [תגובת תלמיד לא נשמעה]

1040
00:58:26,000 --> 00:58:30,000
בדיוק, אני יכול רק לזכור בראש חבר נתונים נוסף זה

1041
00:58:30,000 --> 00:58:34,000
שעכשיו ראש הרשימה הוא כבר לא 0, שבו היה לפני רגע.

1042
00:58:34,000 --> 00:58:39,000
עכשיו זה באמת המספר 1. בדרך זו, אני מקבל אופטימיזציה קלה.

1043
00:58:39,000 --> 00:58:44,000
רק משום שאני דה בתור מישהו מקו בתחילת התור בחנות של אפל

1044
00:58:44,000 --> 00:58:47,000
לא אומר שכל אחד צריך לעבור, שהיזכרות היא פעולה ליניארית.

1045
00:58:47,000 --> 00:58:50,000
אני יכול לבלות במקום זמן קבוע היחיד

1046
00:58:50,000 --> 00:58:53,000
ולהשיג תגובה הרבה יותר מהר אז.

1047
00:58:53,000 --> 00:58:56,000
אבל את המחיר אני משלם הוא מה שירוויח ביצועים נוספים

1048
00:58:56,000 --> 00:58:58,000
ושלא יצטרך לעבור את כולם?

1049
00:58:58,000 --> 00:59:01,000
כן. >> [תגובת תלמיד לא נשמעה]

1050
00:59:01,000 --> 00:59:04,000
יכול להוסיף עוד אנשים, טוב, בעיה שהיא אורתוגונלי

1051
00:59:04,000 --> 00:59:07,000
לעובדה שאנחנו לא מעבירים אנשים מסביב.

1052
00:59:07,000 --> 00:59:11,000
זה עדיין מערך, כך שאם אנחנו מעבירים את כולם או לא

1053
00:59:11,000 --> 00:59:13,000
אה, אני מבין מה שאתה אומר, בסדר.

1054
00:59:13,000 --> 00:59:16,000
למעשה, אני מסכים עם מה שאתה אומר שבזה כמעט כאילו

1055
00:59:16,000 --> 00:59:19,000
עכשיו אנחנו לא הולכים להשתמש תחילת מערך זה יותר

1056
00:59:19,000 --> 00:59:22,000
כי אם אני מסיר 5, אז אני מסיר 7.

1057
00:59:22,000 --> 00:59:24,000
אבל אני הבאתי את אנשים יחידים לצד ימין.

1058
00:59:24,000 --> 00:59:28,000
>> זה מרגיש כאילו אני מבזבז את החלל, וסופו של דבר התור שלי מתפורר לשום דבר,

1059
00:59:28,000 --> 00:59:31,000
אז אנחנו פשוט יכולים להיות אנשי מעטפת,

1060
00:59:31,000 --> 00:59:35,000
ואנחנו יכולים לחשוב על מערך זה ממש כמו איזה סוג של מבנה עגול,

1061
00:59:35,000 --> 00:59:38,000
אבל אנחנו משתמשים במה אופרטור לעשות את זה סוג של מעטפת?

1062
00:59:38,000 --> 00:59:40,000
[תגובת תלמיד לא נשמעה] >> מפעיל מודולו.

1063
00:59:40,000 --> 00:59:43,000
זה יהיה קצת מעצבן לחשוב על איך עושה את המעטפת,

1064
00:59:43,000 --> 00:59:46,000
אבל אנחנו יכולים לעשות את זה, ואנחנו יכולים להתחיל לשים את אנשים במה שהייתה אמור להיות בחזית של הקו,

1065
00:59:46,000 --> 00:59:52,000
אבל אנחנו זוכרים רק עם משתנים בראש זה שראש בפועל של הקו באמת.

1066
00:59:52,000 --> 00:59:57,000
מה אם, במקום זאת, המטרה שלנו בסופו, אם כי,

1067
00:59:57,000 --> 01:00:00,000
היה לחפש את המספרים, כמו שעשינו כאן על במה עם אניטה,

1068
01:00:00,000 --> 01:00:02,000
אבל אנחנו באמת רוצים את הטוב ביותר מכל העולמים האלה?

1069
01:00:02,000 --> 01:00:05,000
אנחנו רוצים יותר תחכום מערך מאפשר

1070
01:00:05,000 --> 01:00:09,000
כי אנחנו רוצים את היכולת לגדול באופן דינמי את מבנה הנתונים.

1071
01:00:09,000 --> 01:00:12,000
אבל אנחנו לא רוצים צריכים לפנות למשהו שאנחנו הצבענו

1072
01:00:12,000 --> 01:00:15,000
בהרצאה הראשונה לא היה אלגוריתם אופטימלי,

1073
01:00:15,000 --> 01:00:17,000
זה של חיפוש לינארי.

1074
01:00:17,000 --> 01:00:21,000
מסתבר שאתה יכול, למעשה, להשיג

1075
01:00:21,000 --> 01:00:24,000
או לפחות קרוב לזמן קבוע, לפיו מישהו כמו אניטה,

1076
01:00:24,000 --> 01:00:27,000
אם היא מגדירה את מבנה הנתונים שלה לא להיות רשימה מקושרת,

1077
01:00:27,000 --> 01:00:30,000
לא להיות ערימה, לא להיות תור, יכול, למעשה,

1078
01:00:30,000 --> 01:00:33,000
לבוא עם מבנה נתונים המאפשר לה לבדוק את הדברים,

1079
01:00:33,000 --> 01:00:37,000
גם מילים, ולא רק מספרים, במה שאנחנו קוראים לזמן קבוע.

1080
01:00:37,000 --> 01:00:40,000
>> ואכן, במבט קדימה, אחד מpsets בכיתה זו היא כמעט תמיד

1081
01:00:40,000 --> 01:00:43,000
ביצוע בדיקת איות, לפיו

1082
01:00:43,000 --> 01:00:46,000
אנחנו נותנים לך שוב כמה מילים באנגלית 150.000 והמטרה היא

1083
01:00:46,000 --> 01:00:51,000
אלה לטעון לזיכרון ומהירות להיות מסוגל לענות על שאלות בטופס

1084
01:00:51,000 --> 01:00:54,000
היא מילה זו מאויתת בצורה נכונה?

1085
01:00:54,000 --> 01:00:58,000
וזה באמת היה שואב אם היית צריך לחזר דרך כל 150.000 המילים לענות על זה.

1086
01:00:58,000 --> 01:01:02,000
אבל, למעשה, נראה שאנחנו יכולים לעשות את זה בזמן מאוד, מאוד מהיר.

1087
01:01:02,000 --> 01:01:06,000
וזה הולך לערב משהו יישום נקרא שולחן חשיש,

1088
01:01:06,000 --> 01:01:09,000
ואף על פי שבמבט הראשון הדבר הזה שנקרא שולחן חשיש הולך

1089
01:01:09,000 --> 01:01:12,000
תנו לנו להשיג זמני התגובה המהירים אלה סופר,

1090
01:01:12,000 --> 01:01:18,000
מתברר שיש למעשה בעיה.

1091
01:01:18,000 --> 01:01:23,000
כשזה מגיע זמן ליישם הדבר הזה שנקרא, שוב, אני עושה את זה שוב.

1092
01:01:23,000 --> 01:01:25,000
אני היחיד כאן.

1093
01:01:25,000 --> 01:01:28,000
כשזה מגיע זמן ליישום הדבר הזה שנקרא שולחן חשיש,

1094
01:01:28,000 --> 01:01:30,000
אנחנו הולכים לעשות כדי להפוך את החלטה.

1095
01:01:30,000 --> 01:01:32,000
כמה גדול צריך להיות הדבר הזה בעצם?

1096
01:01:32,000 --> 01:01:36,000
כאשר אנו מתחילים מספרי החדרה לתוך שולחן חשיש וזה,

1097
01:01:36,000 --> 01:01:38,000
איך אנחנו הולכים לאחסן אותם באופן כזה

1098
01:01:38,000 --> 01:01:42,000
שאנחנו יכולים לקבל אותם בחזרה החוצה מהר ככל שיש לנו אותם?

1099
01:01:42,000 --> 01:01:45,000
אבל אנחנו רואים לפני זמן רב ששאלה זו של

1100
01:01:45,000 --> 01:01:48,000
מתי יום ההולדת של כולם היא בכיתה יהיה די רלוונטי.

1101
01:01:48,000 --> 01:01:51,000
מתברר כי בחדר הזה, יש לנו כמה מאה אנשים,

1102
01:01:51,000 --> 01:01:56,000
כך הסיכויים ששנינו יש לו יום ההולדת היא כנראה די גבוהה.

1103
01:01:56,000 --> 01:01:58,000
מה אם היו רק 40 מאיתנו בחדר הזה?

1104
01:01:58,000 --> 01:02:02,000
מה הסיכויים של שני אנשים שיש אותו יום הולדת?

1105
01:02:02,000 --> 01:02:04,000
[סטודנטים] מעל 50%.

1106
01:02:04,000 --> 01:02:06,000
כן, מעל 50%. למעשה, אני אפילו הבאתי תרשים.

1107
01:02:06,000 --> 01:02:08,000
מתברר, וזה באמת רק תצוגה מקדימה להתגנב-

1108
01:02:08,000 --> 01:02:12,000
אם יש רק 58 מאיתנו בחדר הזה, את ההסתברות של 2 מתוכנו

1109
01:02:12,000 --> 01:02:16,000
נתקל באותה יום ההולדת הוא עצום גבוה, כמעט 100%,

1110
01:02:16,000 --> 01:02:20,000
וזה הולך לגרום לכל חבורה של כאב בשבילנו ביום רביעי.

1111
01:02:20,000 --> 01:02:24,000
>> עם זאת אמרה, בואו לדחות כאן. ניראה אותך ביום רביעי.

1112
01:02:24,000 --> 01:02:28,000
[מחיאות כפות]

1113
01:02:28,000 --> 01:02:30,000
[CS50.TV]