1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [ביקורת] [חידון 0]

2
00:00:03,000 --> 00:00:05,000
>> [לקסי רוס, טומי MacWilliam, לוקאס פרייטס, יוסף אונג] [אוניברסיטת הרווארד]

3
00:00:05,000 --> 00:00:08,000
>> [זה CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> היי, כולם.

5
00:00:10,000 --> 00:00:15,000
ברוכים באים לפגישת הביקורת לחידון 0, שמתקיים ביום רביעי הקרוב.

6
00:00:15,000 --> 00:00:19,000
מה אנחנו הולכים לעשות הלילה, אני עם 3 TFS אחר,

7
00:00:19,000 --> 00:00:24,000
ויחד אנחנו הולכים לעבור סקירה של מה שעשינו בקורס עד כה.

8
00:00:24,000 --> 00:00:27,000
זה לא הולך להיות 100% מקיפים, אבל זה אמור לתת לך רעיון טוב יותר

9
00:00:27,000 --> 00:00:31,000
ממה שכבר יש לך את מה שאתה עדיין צריך ללמוד לפני יום רביעי.

10
00:00:31,000 --> 00:00:34,000
ואל תהסס להרים את היד שלך עם שאלות כמו שאנחנו הולכים יחד,

11
00:00:34,000 --> 00:00:38,000
אך יש לזכור שגם תהיה לנו קצת זמן בסוף

12
00:00:38,000 --> 00:00:41,000
אם אנחנו מקבלים דרך עם כמה דקות לחילוף לעשות שאלות כלליות,

13
00:00:41,000 --> 00:00:47,000
כל כך לזכור את זה, ולכן אנחנו מתכוונים להתחיל בתחילת שבוע עם 0.

14
00:00:47,000 --> 00:00:50,000
>> [חידון 0 סקירה!] [חלק 0] [לקסי רוס] אבל לפני שאנחנו עושים את זה בואו נדבר על

15
00:00:50,000 --> 00:00:53,000
הלוגיסטיקה של החידון.

16
00:00:53,000 --> 00:00:55,000
>> [לוגיסטיקה] [החידון מתקיים ביום רביעי 10/10 במקום הרצאה]

17
00:00:55,000 --> 00:00:57,000
>> [(ראה http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf לפרטים נוספים)] זה על יום רביעי 10 באוקטובר.

18
00:00:57,000 --> 00:01:00,000
>> זה ביום רביעי, ואם אתה רוצה ללכת לכתובת אתר זו כאן,

19
00:01:00,000 --> 00:01:03,000
שהוא גם נגיש מCS50.net-שם של קישור אליו,

20
00:01:03,000 --> 00:01:06,000
אתה יכול לראות פרטים על לאן ללכת מבוסס על

21
00:01:06,000 --> 00:01:10,000
השם שלך האחרון או השתייכות בית הספר כמו גם

22
00:01:10,000 --> 00:01:14,000
היא מספרת על מה בדיוק את החידון ויכסה את סוגי שאלות שאתה הולך לקבל.

23
00:01:14,000 --> 00:01:19,000
זכור כי אתה גם תהיה לך הזדמנות לעיין בחידון בסעיף,

24
00:01:19,000 --> 00:01:21,000
כך TFS שלך צריך ללכת על כמה בעיות בפועל,

25
00:01:21,000 --> 00:01:29,000
וזה עוד הזדמנות טובה לראות בו אתה עדיין צריך ללמוד עד לחידון.

26
00:01:29,000 --> 00:01:32,000
בואו נתחיל בהתחלה עם Bytes 'n' Bits.

27
00:01:32,000 --> 00:01:35,000
זכור קצת הוא רק 0 או 1,

28
00:01:35,000 --> 00:01:38,000
ובתים הם אוסף של 8 הביטים האלה.

29
00:01:38,000 --> 00:01:42,000
בואו נסתכל על זה אוסף של ביטים ממש כאן.

30
00:01:42,000 --> 00:01:44,000
אנחנו צריכים להיות מסוגלים להבין כמה ביטים יש.

31
00:01:44,000 --> 00:01:48,000
איפה אנחנו סופרים יש רק 8 מתוכם, 8 0 או 1 יחידות.

32
00:01:48,000 --> 00:01:51,000
וכיוון שיש 8 ביטים, זה בית 1,

33
00:01:51,000 --> 00:01:53,000
ובואו להמיר אותו להקסדצימלי.

34
00:01:53,000 --> 00:01:58,000
הקסאדצימלי הוא 16 בסיס, וזה די קל להמיר

35
00:01:58,000 --> 00:02:01,000
מספר בינארי, וזה מה שהוא, למספר בקסדצימלי.

36
00:02:01,000 --> 00:02:04,000
כל מה שאנחנו עושים הוא שאנחנו מסתכלים על קבוצות של 4,

37
00:02:04,000 --> 00:02:07,000
ולהמיר אותם לספרה ההקסדצימלי המתאימה.

38
00:02:07,000 --> 00:02:11,000
אנחנו מתחילים עם הקבוצה הימנית ביותר מתוך 4, אז 0011.

39
00:02:11,000 --> 00:02:16,000
זה הולך להיות אחד 1 ו 1 2, אז ביחד זה עושה 3.

40
00:02:16,000 --> 00:02:19,000
ואז בואו נסתכל על הבלוק השני של 4.

41
00:02:19,000 --> 00:02:24,000
1101. זה הולך להיות אחד 1, אחד 4, ואחד 8.

42
00:02:24,000 --> 00:02:28,000
ביחד זה הולך להיות 13, מה שהופך את ד

43
00:02:28,000 --> 00:02:32,000
ואנו זוכרים שבהקסדצימלי אנחנו לא הולכים רק 0 עד 9.

44
00:02:32,000 --> 00:02:36,000
אנחנו הולכים 0 עד F, אז אחרי 9, 10, מקביל,

45
00:02:36,000 --> 00:02:40,000
11 ל-B, וכולי כאשר F הוא 15.

46
00:02:40,000 --> 00:02:44,000
הנה הם 13 D,

47
00:02:44,000 --> 00:02:49,000
כך כדי להמיר אותו למספר עשרוני כל מה שאנחנו עושים זה בעצם

48
00:02:49,000 --> 00:02:52,000
להתייחס לכל עמדת כוח של 2.

49
00:02:52,000 --> 00:02:58,000
זה אחד 1, 1 2, אפס 4s, 8s אפס, אחד 16, וכולי,

50
00:02:58,000 --> 00:03:03,000
וזה קצת קשה לחשב בראש שלך, אבל אם נלך לשקופית הבאה

51
00:03:03,000 --> 00:03:05,000
אנו יכולים לראות את התשובה לכך.

52
00:03:05,000 --> 00:03:09,000
>> בעיקרו של דבר אנחנו הולכים מול זכות חזרה לשמאל,

53
00:03:09,000 --> 00:03:14,000
ואנחנו הכפלה כל ספרה על ידי הכח המקביל של 2.

54
00:03:14,000 --> 00:03:19,000
ותזכור, להקסדצימלי נסמן את המספרים האלה עם 0x בהתחלה

55
00:03:19,000 --> 00:03:23,000
ולכן אנחנו לא לבלבל אותו עם מספר עשרוני.

56
00:03:23,000 --> 00:03:29,000
ולהמשיך הלאה, זה טבלת ASCII,

57
00:03:29,000 --> 00:03:35,000
ומה אנו משתמשים לASCII הוא למפות מתווים לערכים מספריים.

58
00:03:35,000 --> 00:03:39,000
זכור בpset קריפטוגרפיה עשינו שימוש נרחב בטבלת ASCII

59
00:03:39,000 --> 00:03:43,000
כדי להשתמש בשיטות שונות של הצפנה,

60
00:03:43,000 --> 00:03:47,000
קיסר וצופן Vigenère, להמיר אותיות שונות

61
00:03:47,000 --> 00:03:52,000
במחרוזת לפי המפתח הנתון על ידי המשתמש.

62
00:03:52,000 --> 00:03:56,000
בואו נסתכל קצת מתמטיקת ASCII.

63
00:03:56,000 --> 00:04:02,000
כאשר מסתכלים על 'P' + 1, בצורת דמות שתהיה ש,

64
00:04:02,000 --> 00:04:07,000
ולזכור ש'5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
ואיך בדיוק הייתי לנו להמיר בין 2 הצורות האלה?

66
00:04:10,000 --> 00:04:13,000
למען האמת היא לא קשה מדי.

67
00:04:13,000 --> 00:04:16,000
על מנת לקבל 5 נתעלמנו '0 '

68
00:04:16,000 --> 00:04:20,000
משום שיש 5 מקומות בין '0 'ו'5'.

69
00:04:20,000 --> 00:04:23,000
כדי ללכת בדרך האחרת רק תוסיפי 0,

70
00:04:23,000 --> 00:04:25,000
אז זה כמו סוג של חשבון רגיל.

71
00:04:25,000 --> 00:04:29,000
רק תזכור שכאשר משהו יש ציטוטים סביבו זה אופי

72
00:04:29,000 --> 00:04:37,000
ובכך מתאים לערך בטבלת ASCII.

73
00:04:37,000 --> 00:04:40,000
עובר לנושאי מדע כלליים יותר של מחשב.

74
00:04:40,000 --> 00:04:43,000
למדנו מה הוא אלגוריתם וכיצד אנו משתמשים בתכנות

75
00:04:43,000 --> 00:04:45,000
ליישם אלגוריתמים.

76
00:04:45,000 --> 00:04:48,000
כמה דוגמאות של אלגוריתמים הן משהו ממש פשוט כמו

77
00:04:48,000 --> 00:04:51,000
בודק אם מספר הוא גם או מוזר.

78
00:04:51,000 --> 00:04:54,000
בשביל זה אנחנו זוכרים mod המספר ב 2 ובדקו אם התוצאה היא 0.

79
00:04:54,000 --> 00:04:57,000
אם כך, זה אפילו. אם לא, זה מוזר.

80
00:04:57,000 --> 00:04:59,000
וזה דוגמה של אלגוריתם באמת בסיסי.

81
00:04:59,000 --> 00:05:02,000
>> קצת יותר מעורב 1 הוא חיפוש בינארי,

82
00:05:02,000 --> 00:05:05,000
שנלך מעל מאוחר יותר בפגישת הביקורת.

83
00:05:05,000 --> 00:05:09,000
ותכנות הוא המונח שאנו משתמשים ללקיחת אלגוריתם

84
00:05:09,000 --> 00:05:15,000
וממיר אותו לקוד שהמחשב יכול לקרוא.

85
00:05:15,000 --> 00:05:20,000
2 דוגמאות של תכנות היא גרד,

86
00:05:20,000 --> 00:05:22,000
וזה מה שעשינו בשבוע 0.

87
00:05:22,000 --> 00:05:25,000
למרות שאנחנו לא באמת הקלידו את הקוד שזה דרך של יישום

88
00:05:25,000 --> 00:05:29,000
אלגוריתם זה, המדפיס את המספרים 1-10,

89
00:05:29,000 --> 00:05:32,000
וכאן אנחנו עושים את אותו הדבר בשפת תכנות C.

90
00:05:32,000 --> 00:05:41,000
אלה הם פונקציונליים שווים, רק שנכתב בשפות או תחביר שונות.

91
00:05:41,000 --> 00:05:44,000
אז למדנו על ביטויי וליאניות,

92
00:05:44,000 --> 00:05:48,000
ובוליאני הוא ערך זה אמת או שקר,

93
00:05:48,000 --> 00:05:51,000
וביטויים כאן לעתים קרובות וליאניות

94
00:05:51,000 --> 00:05:55,000
להיכנס פנימה של תנאים, כך שאם (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
טוב, אנחנו כבר להגדיר x = 5, ולכן מצב שהוא הולך להערכה אמיתית.

96
00:06:00,000 --> 00:06:03,000
ואם זה נכון, מה שקוד הוא מתחת למצב

97
00:06:03,000 --> 00:06:08,000
הולך להיות מוערך על ידי המחשב, ולכן המחרוזת כי הוא הולך להיות מודפס

98
00:06:08,000 --> 00:06:12,000
לפלט סטנדרטי, ותנאי הטווח

99
00:06:12,000 --> 00:06:16,000
מתייחס לכל מה שבתוך הסוגריים של אם ההצהרה.

100
00:06:16,000 --> 00:06:20,000
זכור את כל המפעילים.

101
00:06:20,000 --> 00:06:26,000
זכור && של זה ו| | כאשר אנחנו מנסים לשלב 2 או יותר תנאים,

102
00:06:26,000 --> 00:06:30,000
== לא = כדי לבדוק אם 2 דברים שווים.

103
00:06:30,000 --> 00:06:36,000
זכור כי = הוא למשימה ואילו == הוא מפעיל וליאני.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ ולאחר מכן 2 הסופיים הם ברורים מאליו.

105
00:06:41,000 --> 00:06:45,000
סקירה כללית של היגיון בוליאני כאן.

106
00:06:45,000 --> 00:06:48,000
וביטויי וליאניות חשובים גם בלולאות,

107
00:06:48,000 --> 00:06:50,000
שנלך על עכשיו.

108
00:06:50,000 --> 00:06:56,000
למדנו בערך 3 סוגים של לולאות עד כה בCS50, ל, הזמן, ולעשות בזמן.

109
00:06:56,000 --> 00:06:59,000
וזה חשוב שידע שלמרות לרוב מטרות

110
00:06:59,000 --> 00:07:02,000
אנחנו יכולים להשתמש בכל סוג של לולאה בדרך

111
00:07:02,000 --> 00:07:06,000
ישנם סוגים מסוימים של מטרות או דפוסים נפוצים

112
00:07:06,000 --> 00:07:09,000
בתכנות שדווקא קורא לאחת מהלולאות האלה

113
00:07:09,000 --> 00:07:13,000
זה עושה את זה יעיל או אלגנטי שיצפין אותה בדרך זו ביותר.

114
00:07:13,000 --> 00:07:18,000
בואו נלך על מה שכל אחד מהלולאות הללו נוטה לשמש בתדירות הגבוהה ביותר.

115
00:07:18,000 --> 00:07:21,000
>> בלולאה אנחנו בדרך כלל כבר יודעים כמה פעמים אנחנו רוצים לחזר.

116
00:07:21,000 --> 00:07:24,000
זה מה שאנחנו מכניסים למצב.

117
00:07:24,000 --> 00:07:28,000
ל, i = 0, i <10, למשל.

118
00:07:28,000 --> 00:07:31,000
אנחנו כבר יודעים שאנחנו רוצים לעשות משהו 10 פעמים.

119
00:07:31,000 --> 00:07:34,000
עכשיו, ללולאה בזמן, בדרך כלל אנחנו לא בהכרח

120
00:07:34,000 --> 00:07:36,000
יודע כמה פעמים אנחנו רוצים הלולאה לרוץ.

121
00:07:36,000 --> 00:07:39,000
אבל אנחנו יודעים איזה תנאים שאנחנו רוצים שהוא

122
00:07:39,000 --> 00:07:41,000
תמיד להיות נכון או תמיד יהיה שקר.

123
00:07:41,000 --> 00:07:44,000
לדוגמה, בזמן מוגדר.

124
00:07:44,000 --> 00:07:46,000
בואו נגיד שזה משתנה בוליאני.

125
00:07:46,000 --> 00:07:48,000
למרות שזה נכון שאנחנו רוצים את הקוד כדי להעריך,

126
00:07:48,000 --> 00:07:52,000
כך קצת יותר להרחבה, קצת כללי יותר מקטן ללולאה,

127
00:07:52,000 --> 00:07:55,000
אבל כל ללולאה ניתן גם להמיר ללולאה בזמן.

128
00:07:55,000 --> 00:08:00,000
לבסוף, לעשות בזמן לולאות, שעשוי להיות הקשה ביותר להבנה באופן מיידי,

129
00:08:00,000 --> 00:08:04,000
משמש לעתים קרובות כאשר אנו רוצים להעריך את הקוד ראשון

130
00:08:04,000 --> 00:08:06,000
לפני הפעם הראשונה שאנחנו בודקים את מצבו.

131
00:08:06,000 --> 00:08:09,000
שימוש נפוץ ליעשה תוך לולאה

132
00:08:09,000 --> 00:08:12,000
כאשר אתה רוצה לקבל קלט משתמש, ואתה יודע שאתה רוצה לשאול את המשתמש

133
00:08:12,000 --> 00:08:15,000
עבור קלט לפחות פעם אחת, אבל אם הם לא נותנים לך קלט טוב תיכף ומייד

134
00:08:15,000 --> 00:08:18,000
אתה רוצה להמשיך לשאול אותם עד שהם נותנים לך קלט הטוב.

135
00:08:18,000 --> 00:08:21,000
זה השימוש הנפוץ ביותר שלי בזמן לולאה,

136
00:08:21,000 --> 00:08:23,000
ובואו נסתכל על המבנה בפועל של לולאות אלו.

137
00:08:23,000 --> 00:08:27,000
הם בדרך כלל תמיד נוטים ללכת בעקבות דפוסים אלה.

138
00:08:27,000 --> 00:08:30,000
>> בלולאה בתוכך יש 3 מרכיבים:

139
00:08:30,000 --> 00:08:35,000
אתחול, בדרך כלל משהו כמו אני int = 0 שבו אני הוא הדלפק,

140
00:08:35,000 --> 00:08:40,000
מצב, שבו אנו רוצים לומר להפעיל את זה ללולאה כל עוד התנאי הזה תקף,

141
00:08:40,000 --> 00:08:44,000
כמו i <10, ולבסוף, עדכון, וככה אנחנו להגדיל

142
00:08:44,000 --> 00:08:47,000
משתנה דלפק בכל נקודה בלולאה.

143
00:08:47,000 --> 00:08:50,000
דבר שכיח לראות יש רק אני + +,

144
00:08:50,000 --> 00:08:52,000
כלומר להגדיל לי עד ליום 1 בכל פעם.

145
00:08:52,000 --> 00:08:55,000
אתה יכול גם לעשות משהו כמו i + = 2,

146
00:08:55,000 --> 00:08:58,000
כלומר להוסיף 2 ל i כל פעם שאתה עובר את הלולאה.

147
00:08:58,000 --> 00:09:03,000
ואז לעשות את זה פשוט מתייחס לכל קוד שבעצם פועל כחלק מהלולאה.

148
00:09:03,000 --> 00:09:09,000
וללולאה בזמן, הפעם אנחנו באמת צריכים אתחול מחוץ למעגל,

149
00:09:09,000 --> 00:09:12,000
כך לדוגמה, אניח שאנחנו מנסים לעשות את אותו הסוג של לולאה כמו שתארתי.

150
00:09:12,000 --> 00:09:16,000
היינו אומרים אני int = 0 לפני הלולאה מתחיל.

151
00:09:16,000 --> 00:09:20,000
ואז תוכל לומר לי תוך <10 לעשות את זה,

152
00:09:20,000 --> 00:09:22,000
כך באותו הבלוק של קוד כמו קודם,

153
00:09:22,000 --> 00:09:26,000
והפעם עדכון חלק של הקוד, לדוגמה, אני + +,

154
00:09:26,000 --> 00:09:29,000
בעצם הולך בתוך הלולאה.

155
00:09:29,000 --> 00:09:33,000
ולבסוף, ללעשות בזמן, זה דומה ללולאה בזמן,

156
00:09:33,000 --> 00:09:36,000
אבל אנחנו צריכים לזכור שהקוד יהיה להעריך פעם אחת

157
00:09:36,000 --> 00:09:40,000
לפני המצב מסומן, כך שזה עושה הרבה יותר מובן

158
00:09:40,000 --> 00:09:44,000
אם אתה מסתכל עליו בצו של מלמעלה למטה.

159
00:09:44,000 --> 00:09:49,000
בלעשות בעוד לולאת הקוד מעריך עוד לפני שאתה מסתכל על המצב בזמן,

160
00:09:49,000 --> 00:09:55,000
בעוד לולאה בזמן, הוא בודק ראשון.

161
00:09:55,000 --> 00:09:59,000
דוחות ומשתנה.

162
00:09:59,000 --> 00:10:04,000
כאשר אנו רוצים ליצור משתנה חדשים שאנו ראשונים רוצים לאתחל אותו.

163
00:10:04,000 --> 00:10:07,000
>> לדוגמה, בר int מאתחל את הסרגל משתנה,

164
00:10:07,000 --> 00:10:10,000
אבל זה לא נותן לו ערך, אז מה היא שוויו של הבר עכשיו?

165
00:10:10,000 --> 00:10:12,000
אנחנו לא יודעים.

166
00:10:12,000 --> 00:10:14,000
זה יכול להיות איזה שהוא ערך זבל שאוחסן קודם לכן בזיכרון שם,

167
00:10:14,000 --> 00:10:16,000
ואנחנו לא רוצים להשתמש במשתנה ש

168
00:10:16,000 --> 00:10:19,000
עד שלמעשה לתת לו ערך,

169
00:10:19,000 --> 00:10:21,000
כך אנו מצהירים את זה כאן.

170
00:10:21,000 --> 00:10:24,000
אז לאתחל אותו להיות 42 להלן.

171
00:10:24,000 --> 00:10:28,000
עכשיו, כמובן, אנחנו יודעים שזה יכול להיעשות בשורה אחת, int הבר = 42.

172
00:10:28,000 --> 00:10:30,000
אבל רק שיהיה ברורים את השלבים המרובים שהם קורים,

173
00:10:30,000 --> 00:10:34,000
ההצהרה והאתחול קורות בנפרד כאן.

174
00:10:34,000 --> 00:10:38,000
זה קורה בשלב אחד, והבא, ובאז int = בר + 1,

175
00:10:38,000 --> 00:10:44,000
הצהרה זו להלן, שבאז במרווחים, ולכן בסופו של קטע הקוד הזה

176
00:10:44,000 --> 00:10:48,000
אם היינו מדפיס את ערכו של באז זה יהיה 44

177
00:10:48,000 --> 00:10:52,000
משום שאנו מצהירים ולאתחל אותו להיות ברים> 1,

178
00:10:52,000 --> 00:10:58,000
ואז להגדיל אותו עוד פעם אחת עם + +.

179
00:10:58,000 --> 00:11:02,000
ניגשנו לרגע היפה הזה, אבל זה טוב שיש בכלל

180
00:11:02,000 --> 00:11:04,000
הבנה של מה הם נושאים ואירועים.

181
00:11:04,000 --> 00:11:06,000
אנחנו בעיקר עשינו את זה בהתחלה,

182
00:11:06,000 --> 00:11:09,000
כך שאתה יכול לחשוב על נושאים כרצפים מרובים של קוד

183
00:11:09,000 --> 00:11:11,000
פועל באותו הזמן.

184
00:11:11,000 --> 00:11:14,000
בפועל, זה כנראה לא פועל באותו הזמן,

185
00:11:14,000 --> 00:11:17,000
אבל כאילו בצורה מופשטת אנחנו יכולים לחשוב עליו בדרך זו.

186
00:11:17,000 --> 00:11:20,000
>> בלגרד, למשל, היו לנו את השדונים המרובים.

187
00:11:20,000 --> 00:11:22,000
זה יכול להיות ביצוע קוד שונה באותו הזמן.

188
00:11:22,000 --> 00:11:26,000
אחד יכול להיות הליכה ואילו השני אומר משהו

189
00:11:26,000 --> 00:11:29,000
בחלק אחר של המסך.

190
00:11:29,000 --> 00:11:34,000
אירועים הם דרך נוספת להפריד את ההיגיון

191
00:11:34,000 --> 00:11:37,000
בין מרכיבים שונים של הקוד שלך,

192
00:11:37,000 --> 00:11:40,000
ובסריטות שהיינו מסוגל לדמות אירועים באמצעות שידור,

193
00:11:40,000 --> 00:11:43,000
וזה בעצם כשאני מקבל, לא כשאני שומע,

194
00:11:43,000 --> 00:11:47,000
אבל בעיקרו של דבר דרך להעברת מידע

195
00:11:47,000 --> 00:11:49,000
מספרייט אחד למשנו.

196
00:11:49,000 --> 00:11:52,000
לדוגמה, ייתכן שתרצה להעביר את המשחק,

197
00:11:52,000 --> 00:11:56,000
וכאשר ספרייט אחר מקבל משחק נגמר,

198
00:11:56,000 --> 00:11:58,000
הוא מגיב בדרך מסוימת.

199
00:11:58,000 --> 00:12:03,000
זה מודל חשוב להבין לתכנות.

200
00:12:03,000 --> 00:12:07,000
רק לעבור על השבוע הבסיסי 0, מה שאנחנו כבר דברנו על כך הרבה,

201
00:12:07,000 --> 00:12:10,000
בואו נסתכל על תכנית C פשוטה זו.

202
00:12:10,000 --> 00:12:14,000
הטקסט עשוי להיות קצת קטן מכאן, אבל אני אלך על זה ממש מהר.

203
00:12:14,000 --> 00:12:20,000
אנו כוללים את 2 קבצי כותרת בחלק העליון, וcs50.h stdio.h.

204
00:12:20,000 --> 00:12:23,000
אז אנחנו מגדירים את גבול נקרא מתמיד להיות 100.

205
00:12:23,000 --> 00:12:26,000
אז אנחנו מיישמים הפונקציה העיקרית שלנו.

206
00:12:26,000 --> 00:12:29,000
מכיוון שאנחנו לא משתמשים בטיעוני שורת פקודה כאן אנחנו צריכים לשים את הריק

207
00:12:29,000 --> 00:12:32,000
כנימוקים עיקריים.

208
00:12:32,000 --> 00:12:38,000
אנו רואים int לעיל ראשי. זה סוג התמורה, ומכאן להחזיר 0 בתחתית.

209
00:12:38,000 --> 00:12:41,000
ואנחנו משתמשים בפונקצית ספריית CS50 לקבל int

210
00:12:41,000 --> 00:12:45,000
לשאול את המשתמש עבור קלט, ואנחנו מאחסנים אותו במשתנה זה x,

211
00:12:45,000 --> 00:12:51,000
כך אנו מצהירים מעל x, ואנחנו לאתחל אותו עם x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> לאחר מכן, אנו בודקים אם המשתמש נתן לנו קלט טוב.

213
00:12:53,000 --> 00:12:59,000
אם זה LIMIT ≥ אנחנו רוצים להחזיר קוד שגיאה של 1 ולהדפיס הודעת שגיאה.

214
00:12:59,000 --> 00:13:02,000
ולבסוף, אם קלט המשתמש נתן לנו טוב

215
00:13:02,000 --> 00:13:08,000
אנחנו הולכים ליישב את המספר ולהדפיס את התוצאה.

216
00:13:08,000 --> 00:13:11,000
רק כדי לוודא שכל מי בית הלהיט

217
00:13:11,000 --> 00:13:17,000
אתה יכול לראות את התוויות של חלקים שונים של הקוד כאן.

218
00:13:17,000 --> 00:13:19,000
הזכרתי קבצים קבועים, של כותרות.

219
00:13:19,000 --> 00:13:21,000
אה, int x. ודא שיש לזכור שזה משתנה מקומי.

220
00:13:21,000 --> 00:13:24,000
זאת, בניגודו ממשתנה גלובלי, שנדברנו על

221
00:13:24,000 --> 00:13:27,000
מעט מאוחר יותר בישיבת הביקורת,

222
00:13:27,000 --> 00:13:30,000
ואנחנו קוראים את פונקצית ספריית printf,

223
00:13:30,000 --> 00:13:34,000
כך שאם לא הייתי כלול בקובץ הכותרת stdio.h

224
00:13:34,000 --> 00:13:37,000
לא הייתי מסוגל לקרוא printf.

225
00:13:37,000 --> 00:13:42,000
ואני מאמין שהחץ שנותק, כאן הוא הצביע על ד%,

226
00:13:42,000 --> 00:13:45,000
אשר היא מחרוזת עיצוב בprintf.

227
00:13:45,000 --> 00:13:52,000
זה אומר להדפיס את משתנה זה כמספר, ד%.

228
00:13:52,000 --> 00:13:58,000
וזה אותו שבוע ל0.

229
00:13:58,000 --> 00:14:06,000
עכשיו לוקאס הולך להמשיך.

230
00:14:06,000 --> 00:14:08,000
היי, חבר 'ה. השם שלי הוא לוקאס.

231
00:14:08,000 --> 00:14:10,000
אני בכיתת י 'בבית הטוב ביותר בקמפוס, מאת'ר,

232
00:14:10,000 --> 00:14:14,000
ואני הולך לדבר קצת על שבוע 1 ו 2.1.

233
00:14:14,000 --> 00:14:16,000
[1 שבוע ו -2.1!] [לוקאס פרייטס]

234
00:14:16,000 --> 00:14:19,000
כקסי אמר, כשהתחלנו לתרגם את הקוד שלך מהתחלה כדי C

235
00:14:19,000 --> 00:14:23,000
אחד הדברים שאנו הבחנו הוא שאתה לא יכול פשוט

236
00:14:23,000 --> 00:14:26,000
לכתוב את הקוד שלך ולהפעיל אותו באמצעות דגל ירוק יותר.

237
00:14:26,000 --> 00:14:30,000
למעשה, אתה צריך להשתמש בכמה צעדים כדי להפוך את תכנית C

238
00:14:30,000 --> 00:14:33,000
להפוך קובץ הפעלה.

239
00:14:33,000 --> 00:14:36,000
בעיקרון מה שאתה עושה כשאתה כותב תכנית הוא כי

240
00:14:36,000 --> 00:14:40,000
אתה מתרגם את הרעיון שלך לשפה שמהדר יכול להבין,

241
00:14:40,000 --> 00:14:44,000
לכן כאשר אתה כותב תכנית ב-C

242
00:14:44,000 --> 00:14:47,000
מה שאתה עושה הוא בעצם כותב משהו שהמהדר שלך לא יבין,

243
00:14:47,000 --> 00:14:50,000
ואז המהדר הולך לתרגם קוד ש

244
00:14:50,000 --> 00:14:53,000
למשהו שהמחשב שלך יבין.

245
00:14:53,000 --> 00:14:55,000
>> והעניין הוא, המחשב שלך הוא בעצם מאוד מטומטם.

246
00:14:55,000 --> 00:14:57,000
המחשב שלך יכול להבין 0s ו 1s בלבד,

247
00:14:57,000 --> 00:15:01,000
כך למעשה במחשבים הראשונים שהאנשים בדרך כלל לתכנת

248
00:15:01,000 --> 00:15:04,000
באמצעות 0s ו 1s, אבל לא יותר, תודה לאל.

249
00:15:04,000 --> 00:15:07,000
אנחנו לא צריכים לשנן את הרצפים ל0s ו 1s

250
00:15:07,000 --> 00:15:10,000
עבור ללולאה או ללולאה בזמן וכן הלאה.

251
00:15:10,000 --> 00:15:13,000
זו הסיבה שיש לנו במהדר.

252
00:15:13,000 --> 00:15:17,000
מה מהדר עושה זה בעצם מתרגם את קוד C,

253
00:15:17,000 --> 00:15:21,000
במקרה שלנו, לשפה שהמחשב יבין,

254
00:15:21,000 --> 00:15:25,000
המהווה את קוד האובייקט, ומהדר שאנחנו משתמשים

255
00:15:25,000 --> 00:15:30,000
נקרא להרעיש, ואז זה בעצם הסמל לצלצול.

256
00:15:30,000 --> 00:15:33,000
כאשר יש לך תכנית שלך, אתה צריך לעשות 2 דברים.

257
00:15:33,000 --> 00:15:37,000
ראשית, אתה צריך לקמפל את התכנית שלך, ואז אתה הולך להפעיל את התכנית שלך.

258
00:15:37,000 --> 00:15:41,000
כדי להדר את התכנית שלך יש לך הרבה אפשרויות לעשות זאת.

259
00:15:41,000 --> 00:15:44,000
הראשון הוא לעשות program.c צלצול

260
00:15:44,000 --> 00:15:47,000
בתכנית שבה הוא השם של התכנית שלך.

261
00:15:47,000 --> 00:15:51,000
במקרה זה אתה יכול לראות שהם רק אומרים "היי, לקמפל את התכנית שלי".

262
00:15:51,000 --> 00:15:56,000
אתה לא אומר "אני רוצה את השם הזה לתכנית שלי" או משהו כזה.

263
00:15:56,000 --> 00:15:58,000
>> האפשרות השנייה היא לתת שם לתכנית שלך.

264
00:15:58,000 --> 00:16:02,000
אתה יכול להגיד צלצול-O ולאחר מכן את השם שאתה רוצה

265
00:16:02,000 --> 00:16:06,000
קובץ ההפעלה שייקרא וכאז program.c.

266
00:16:06,000 --> 00:16:11,000
ואתה יכול גם לעשות להפוך את התכנית, ורואה איך ב2 המקרים הראשונים

267
00:16:11,000 --> 00:16:15,000
אני שם. ג, ובשלישי יש לי תוכניות בלבד?

268
00:16:15,000 --> 00:16:18,000
כן, אתה באמת לא צריך לשים. ג כאשר אתה משתמש לעשות.

269
00:16:18,000 --> 00:16:22,000
אחרת המהדר הוא בעצם הולך לצעוק עליך.

270
00:16:22,000 --> 00:16:24,000
וגם, אני לא יודע אם אתם זוכרים,

271
00:16:24,000 --> 00:16:29,000
אבל הרבה פעמים אנחנו משמשים-lcs50 גם או lm.

272
00:16:29,000 --> 00:16:31,000
זה נקרא קישור.

273
00:16:31,000 --> 00:16:35,000
זה פשוט אומר למהדר שתוכל להשתמש בספריות האלה כאן,

274
00:16:35,000 --> 00:16:39,000
כך שאם ברצונך להשתמש cs50.h אתה בעצם צריך להקליד

275
00:16:39,000 --> 00:16:43,000
צלצול program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
אם אתה לא עושה את זה, המהדר לא הולך לדעת

277
00:16:45,000 --> 00:16:50,000
שאתה משתמש בפונקציות האלה בcs50.h.

278
00:16:50,000 --> 00:16:52,000
וכאשר ברצונך להפעיל את התכנית שלך יש לך 2 אפשרויות.

279
00:16:52,000 --> 00:16:57,000
אם עשית program.c צלצול שלא לתת שם לתכנית שלך.

280
00:16:57,000 --> 00:17:01,000
אתה צריך להפעיל אותו באמצעות. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out הוא שם סטנדרטי שנותן צלצול התכנית שלך אם אתה לא נותן לו שם.

282
00:17:06,000 --> 00:17:11,000
אחרת אתה הולך לעשות. / תכנית אם נתת שם לתכנית שלך,

283
00:17:11,000 --> 00:17:15,000
וגם אם אתה עושה התכנית עשה שם שתכנית הוא הולך לקבל

284
00:17:15,000 --> 00:17:23,000
כבר הולך לתכנת אותו שם כמו קובץ c.

285
00:17:23,000 --> 00:17:26,000
ואז דברו על סוגי נתונים ונתונים.

286
00:17:26,000 --> 00:17:31,000
>> בעיקרון סוגי נתונים הם אותו דבר כמו קופסות קטנות שהם משתמשים

287
00:17:31,000 --> 00:17:35,000
לאחסון ערכים, ולכן סוגי נתונים הם למעשה בדיוק כמו פוקימונים.

288
00:17:35,000 --> 00:17:39,000
הם באים בכל הגדלים וסוגים.

289
00:17:39,000 --> 00:17:43,000
אני לא יודע אם אנלוגיה זה הגיוני.

290
00:17:43,000 --> 00:17:46,000
גודל הנתונים בפועל תלוי בארכיטקטורת המחשב.

291
00:17:46,000 --> 00:17:49,000
כל גדלי הנתונים שאני הולך להראות כאן

292
00:17:49,000 --> 00:17:53,000
הם למעשה למכונה 32-bit, שהוא במקרה של המכשיר שלנו,

293
00:17:53,000 --> 00:17:56,000
אבל אם אתה בעצם קידוד Mac או בWindows שלך גם

294
00:17:56,000 --> 00:17:59,000
כנראה שאתה הולך יש לי מכונית 64-bit,

295
00:17:59,000 --> 00:18:03,000
כך זוכר שגדלי הנתונים שאני הולך להראות כאן

296
00:18:03,000 --> 00:18:06,000
הם למכונת 32-bit.

297
00:18:06,000 --> 00:18:08,000
הראשונה שראינו הייתה int,

298
00:18:08,000 --> 00:18:10,000
וזה די פשוט.

299
00:18:10,000 --> 00:18:13,000
אתה משתמש int כדי לאחסן מספר שלם.

300
00:18:13,000 --> 00:18:16,000
ראו גם את הדמות, char.

301
00:18:16,000 --> 00:18:20,000
אם אתה רוצה להשתמש באות או סימן קטן אתה כנראה הולך להשתמש char.

302
00:18:20,000 --> 00:18:26,000
דמות יש בית 1, כלומר 8 ביטים, כמו לקסי אמר.

303
00:18:26,000 --> 00:18:31,000
בעיקרון יש לנו טבלת ASCII שיש 256

304
00:18:31,000 --> 00:18:34,000
שילובים אפשריים של 0s ו 1s,

305
00:18:34,000 --> 00:18:37,000
ולאחר מכן בעת ​​הקלדת char זה הולך לתרגם

306
00:18:37,000 --> 00:18:44,000
הדמות שהתשומות לך מספר שיש לך בטבלת ASCII, כמו לקסי אמרה.

307
00:18:44,000 --> 00:18:48,000
יש לנו גם לצוף, בו אנו משתמשים כדי לאחסן מספרים עשרוניים.

308
00:18:48,000 --> 00:18:53,000
אם אתה רוצה לבחור 3.14, לדוגמה, אתה הולך להשתמש במצוף

309
00:18:53,000 --> 00:18:55,000
או כפול שיש לו יותר דיוק.

310
00:18:55,000 --> 00:18:57,000
לצוף יש 4 בתים.

311
00:18:57,000 --> 00:19:01,000
כפול יש 8 בתים, אז ההבדל היחיד הוא הדיוק.

312
00:19:01,000 --> 00:19:04,000
יש לנו גם ארוך המשמש למספרים שלמים,

313
00:19:04,000 --> 00:19:09,000
ואתה יכול לראות במכונה 32-bit int ועוד יש לו גודל,

314
00:19:09,000 --> 00:19:13,000
אז זה לא ממש הגיוני להשתמש בזמן במכונה 32-bit.

315
00:19:13,000 --> 00:19:17,000
>> אבל אם אתה משתמש במחשב Mac ו 64-bit, ממש ארוך יש גודל 8,

316
00:19:17,000 --> 00:19:19,000
כך שזה באמת תלוי באדריכלות.

317
00:19:19,000 --> 00:19:22,000
למכונת 32-bit זה לא הגיוני להשתמש בזמן באמת.

318
00:19:22,000 --> 00:19:25,000
ואז עוד ארוך, לעומת זאת, יש 8 בתים,

319
00:19:25,000 --> 00:19:30,000
אז זה מאוד טוב אם אתה רוצה להיות יותר שלם.

320
00:19:30,000 --> 00:19:34,000
ולבסוף, יש לנו חוט, שהוא בעצם * char,

321
00:19:34,000 --> 00:19:37,000
שהוא מצביע לchar.

322
00:19:37,000 --> 00:19:40,000
זה קל מאוד לחשוב שהגודל של המחרוזת הוא הולך להיות כמו

323
00:19:40,000 --> 00:19:42,000
מספר התווים שיש לך שם,

324
00:19:42,000 --> 00:19:45,000
אבל בעצם * char עצמו

325
00:19:45,000 --> 00:19:49,000
יש את הגודל של מצביע char, שזה 4 בתים.

326
00:19:49,000 --> 00:19:52,000
הגודל של * char הוא 4 בתים.

327
00:19:52,000 --> 00:19:56,000
זה לא משנה אם יש לך מילה קטנה או מכתב או משהו.

328
00:19:56,000 --> 00:19:58,000
זה הולך להיות 4 בתים.

329
00:19:58,000 --> 00:20:01,000
למדו גם קצת על ליהוק,

330
00:20:01,000 --> 00:20:04,000
אז כפי שאתם יכולים לראות, אם יש לך, למשל, תכנית שאומרת

331
00:20:04,000 --> 00:20:08,000
int x = 3 ואז printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
אתם יודעים מה זה הולך להדפסה על מסך?

333
00:20:12,000 --> 00:20:14,000
>> מישהו? >> [סטודנטים] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, כן.

335
00:20:16,000 --> 00:20:20,000
כאשר אתה עושה 3/2 זה הולך לקבל 1.5,

336
00:20:20,000 --> 00:20:24,000
אבל מכיוון שאתה משתמש במספר שלם זה הולך להתעלם מהחלק העשרוני,

337
00:20:24,000 --> 00:20:26,000
ואתה הולך להיות 1.

338
00:20:26,000 --> 00:20:29,000
אם אתה לא רוצה שזה יקרה מה שאתה יכול לעשות, למשל,

339
00:20:29,000 --> 00:20:33,000
הוא מצהיר לצוף y = x.

340
00:20:33,000 --> 00:20:40,000
אז X שהיו בעבר 3 עכשיו הולך להיות 3.000 בy.

341
00:20:40,000 --> 00:20:44,000
ואז אתה יכול להדפיס את y / 2.

342
00:20:44,000 --> 00:20:50,000
למעשה, אני צריך 2. לשם.

343
00:20:50,000 --> 00:20:55,000
זה הולך לעשות 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
ואתה הולך לקבל 1.5.

345
00:20:58,000 --> 00:21:06,000
ויש לנו .2 f זה רק כדי לבקש 2 יחידות עשרוניות בחלק העשרוני.

346
00:21:06,000 --> 00:21:12,000
אם יש לך .3 f זה הולך לי 1.500 בפועל.

347
00:21:12,000 --> 00:21:16,000
אם זה 2 שזה הולך להיות 1.50.

348
00:21:16,000 --> 00:21:18,000
יש לנו גם המקרה הזה כאן.

349
00:21:18,000 --> 00:21:22,000
אם אתה עושה את המצוף X = 3.14 ואז אתה x printf

350
00:21:22,000 --> 00:21:24,000
אתה הולך לקבל 3.14.

351
00:21:24,000 --> 00:21:29,000
ואם אתה עושה x = int של x,

352
00:21:29,000 --> 00:21:34,000
מה שאומר שטיפול x כint ואתה מדפיס x עכשיו

353
00:21:34,000 --> 00:21:36,000
אתה הולך להיות 3.00.

354
00:21:36,000 --> 00:21:38,000
האם זה הגיוני?

355
00:21:38,000 --> 00:21:41,000
בגלל שאתה בטיפול 1 x כמספר שלם, אז אתה מתעלם מהחלק העשרוני,

356
00:21:41,000 --> 00:21:45,000
ואז אתה מדפיס x.

357
00:21:45,000 --> 00:21:47,000
ולבסוף, אתה יכול גם לעשות את זה,

358
00:21:47,000 --> 00:21:52,000
int x = 65, ואז אתה מצהיר char c = x,

359
00:21:52,000 --> 00:21:56,000
ואז אם אתה מדפיס ג אתה בעצם הולך לקבל

360
00:21:56,000 --> 00:21:59,000
, אז בעצם מה שאתה עושה כאן

361
00:21:59,000 --> 00:22:02,000
הוא לתרגם את המספר השלם לתוך הדמות,

362
00:22:02,000 --> 00:22:05,000
בדיוק כמו טבלת ASCII עושה.

363
00:22:05,000 --> 00:22:08,000
דברו גם על מפעילי מתמטיקה.

364
00:22:08,000 --> 00:22:14,000
רובם הם די פשוטים, ולכן +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
וגם דברנו על mod, המהווה את שארית חלוקה של 2 מספרים.

366
00:22:20,000 --> 00:22:23,000
אם יש לך 10% 3, למשל,

367
00:22:23,000 --> 00:22:27,000
זה אומר לחלק את 10 על ידי 3, ומה היא השארית?

368
00:22:27,000 --> 00:22:30,000
זה הולך להיות 1, כך שזה באמת מאוד שימושי להרבה מהתוכניות.

369
00:22:30,000 --> 00:22:38,000
לVigenère וקיסר אני די בטוח שכולכם השתמשתי mod.

370
00:22:38,000 --> 00:22:43,000
על מפעילי מתמטיקה, להיות זהיר מאוד כאשר שילוב * ו /.

371
00:22:43,000 --> 00:22:48,000
>> לדוגמה, אם אתה עושה (3/2) * 2 מה אתה הולך לקבל?

372
00:22:48,000 --> 00:22:50,000
[סטודנטים] 2.

373
00:22:50,000 --> 00:22:54,000
כן, 2, כי 3/2 הולך להיות 1.5,

374
00:22:54,000 --> 00:22:57,000
אבל מכיוון שאתה עושה פעילות בין 2 מספרים שלמים

375
00:22:57,000 --> 00:22:59,000
אתה בעצם רק הולך לשקול 1,

376
00:22:59,000 --> 00:23:03,000
ואז * 1 2 הולך להיות 2, ולכן להיות מאוד, מאוד זהיר

377
00:23:03,000 --> 00:23:07,000
כאשר עושים חשבון עם מספרים שלמים בגלל

378
00:23:07,000 --> 00:23:12,000
אתה יכול לקבל כי 2 = 3, במקרה זה.

379
00:23:12,000 --> 00:23:14,000
וגם להיות מאוד זהיר לגבי קדימות.

380
00:23:14,000 --> 00:23:21,000
אתה צריך בדרך כלל להשתמש בסוגריים כדי להיות בטוח שאתה יודע מה אתה עושה.

381
00:23:21,000 --> 00:23:27,000
החלק מקיצורי הדרך שימושיים, כמובן, אחת הם i + + או i + = 1

382
00:23:27,000 --> 00:23:30,000
או שימוש = +.

383
00:23:30,000 --> 00:23:34,000
זה אותו הדבר כמו לעשות i = i + 1.

384
00:23:34,000 --> 00:23:39,000
אתה גם יכול לעשות לי - או שאני - = 1,

385
00:23:39,000 --> 00:23:42,000
שזה אותו דבר כמוני = אני -1,

386
00:23:42,000 --> 00:23:46,000
אתם משהו משתמשים הרבה בלולאות, לפחות.

387
00:23:46,000 --> 00:23:52,000
כמו כן, עבור *, אם אתה משתמש * = ואם אתה עושה, למשל,

388
00:23:52,000 --> 00:23:57,000
i * = 2 הם אותו הדבר כמו לומר אני = i * 2,

389
00:23:57,000 --> 00:23:59,000
ואותו דבר לחלוקה.

390
00:23:59,000 --> 00:24:08,000
אם אתה עושה לי / = 2 זה אותו הדבר כמו i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> עכשיו על פונקציות.

392
00:24:10,000 --> 00:24:13,000
אתם למדתם שפונקציות הן אסטרטגיה טובה מאוד לשמירת קוד

393
00:24:13,000 --> 00:24:16,000
בזמן שאתה מתכנת, כך שאם אתה רוצה לבצע את אותה המשימה

394
00:24:16,000 --> 00:24:20,000
בקוד שוב ושוב, כנראה שאתה רוצה להשתמש בפונקציה

395
00:24:20,000 --> 00:24:25,000
רק כדי שלא יצטרך להעתיק ולהדביק את הקוד שוב ושוב.

396
00:24:25,000 --> 00:24:28,000
למעשה, היא פונקציה עיקרית, וכשאני מראה אותך את התבנית של פונקציה

397
00:24:28,000 --> 00:24:32,000
אתה הולך לראות את זה שהוא די ברור.

398
00:24:32,000 --> 00:24:35,000
אנחנו גם להשתמש בפונקציות מספריות מסוימות,

399
00:24:35,000 --> 00:24:39,000
לדוגמה, printf, GetIn, שהוא מספריית CS50,

400
00:24:39,000 --> 00:24:43,000
ופונקציות נוספות כמו toupper.

401
00:24:43,000 --> 00:24:46,000
כל הפונקציות הללו הם למעשה מיושמים בספריות אחרות,

402
00:24:46,000 --> 00:24:49,000
וכאשר אתה שם את הקבצים האלה לקשור בתחילת התכנית שלך

403
00:24:49,000 --> 00:24:53,000
שאתה אומר אתה יכול בבקשה לתת לי את הקוד לפונקציות אלה

404
00:24:53,000 --> 00:24:57,000
אז אני לא אצטרך ליישם אותם בעצמי?

405
00:24:57,000 --> 00:25:00,000
ואתה יכול גם לכתוב פונקציות משלך, כך שכאשר אתה מתחיל בתכנות

406
00:25:00,000 --> 00:25:04,000
אתה מבין שאין לי ספריות את כל הפונקציות שאתה צריך.

407
00:25:04,000 --> 00:25:10,000
לpset האחרון, למשל, שכתבנו לצייר, צעקות, ובדיקה,

408
00:25:10,000 --> 00:25:13,000
וזה מאוד מאוד חשוב להיות מסוגל לכתוב פונקציות

409
00:25:13,000 --> 00:25:17,000
משום שהם שימושיים, ואנחנו משתמשים בם כל הזמן בתכנות,

410
00:25:17,000 --> 00:25:19,000
וזה חוסך הרבה קוד.

411
00:25:19,000 --> 00:25:21,000
הפורמט של פונקציה הוא זה אחד.

412
00:25:21,000 --> 00:25:24,000
יש לנו סוג החזרה בהתחלה. מהו סוג התמורה?

413
00:25:24,000 --> 00:25:27,000
זה רק כאשר התפקוד שלך הולך לחזור.

414
00:25:27,000 --> 00:25:29,000
אם יש לך פונקציה, למשל, עצרת,

415
00:25:29,000 --> 00:25:31,000
כי הוא הולך לחישוב עצרת של מספר שלם,

416
00:25:31,000 --> 00:25:34,000
כנראה שזה הולך לחזור גם שלם.

417
00:25:34,000 --> 00:25:37,000
אז סוג ההחזרה הולך להיות int.

418
00:25:37,000 --> 00:25:41,000
Printf למעשה יש חלל סוג החזרה

419
00:25:41,000 --> 00:25:43,000
כי אתה לא חוזר שום דבר.

420
00:25:43,000 --> 00:25:45,000
אתה פשוט להדפיס דברים על המסך

421
00:25:45,000 --> 00:25:48,000
והפסקת התפקוד לאחר מכן.

422
00:25:48,000 --> 00:25:51,000
אז יש לך את השם של הפונקציה שאתה יכול לבחור.

423
00:25:51,000 --> 00:25:55,000
אתה צריך להיות קצת הגיוני, כמו לא בוחר שם כמו xyz

424
00:25:55,000 --> 00:25:58,000
או כמו x2f.

425
00:25:58,000 --> 00:26:02,000
אנסה להמציא שם זה הגיוני.

426
00:26:02,000 --> 00:26:04,000
>> לדוגמה, אם זה עצרת, אומרים עצרת.

427
00:26:04,000 --> 00:26:08,000
אם זה פונקציה שהוא הולך לצייר משהו, שם זה לצייר.

428
00:26:08,000 --> 00:26:11,000
ואז יש לנו את הפרמטרים, שנקראים גם טיעונים,

429
00:26:11,000 --> 00:26:14,000
שהם כמו את המשאבים שהפונקציה שלך צריכה

430
00:26:14,000 --> 00:26:17,000
מהקוד שלך כדי לבצע את המשימה שלו.

431
00:26:17,000 --> 00:26:20,000
אם ברצונך לחשב את העצרת של מספר

432
00:26:20,000 --> 00:26:23,000
כנראה אתה צריך לעבור מספר לחשב עצרת.

433
00:26:23,000 --> 00:26:27,000
אחת הטענות שאתה הולך להיות הוא המספר עצמו.

434
00:26:27,000 --> 00:26:31,000
ואז זה הולך לעשות משהו ולהחזיר את הערך בסוף

435
00:26:31,000 --> 00:26:35,000
אלא אם כן זה פונקציה מבוטלת.

436
00:26:35,000 --> 00:26:37,000
בואו לראות דוגמה.

437
00:26:37,000 --> 00:26:40,000
אם אני רוצה לכתוב פונקציה שמסכמת את כל המספרים במערך של מספרים שלמים,

438
00:26:40,000 --> 00:26:43,000
קודם כל, סוג ההחזרה הולך להיות int

439
00:26:43,000 --> 00:26:46,000
כי יש לי מערך של מספרים שלמים.

440
00:26:46,000 --> 00:26:51,000
ואז אני הולך להיות שם פונקציה כמו sumArray,

441
00:26:51,000 --> 00:26:54,000
ואז זה הולך לקחת את המערך עצמו, לnums int,

442
00:26:54,000 --> 00:26:58,000
ואז האורך של המערך ולכן אני יודע כמה מספרים יש לי לסכם.

443
00:26:58,000 --> 00:27:02,000
ואז אני צריך לאתחל סכום משתנה נקרא, למשל, ל0,

444
00:27:02,000 --> 00:27:08,000
ובכל פעם שאני רואה אלמנט במערך שאני צריך להוסיף אותו לסכום, אז עשיתי ללולאה.

445
00:27:08,000 --> 00:27:15,000
בדיוק כמו לקסי אמר, אתה עושה אני int = 0, i <אורך ואני + +.

446
00:27:15,000 --> 00:27:20,000
ועבור כל רכיב במערך שעשיתי סכום + = nums [i],

447
00:27:20,000 --> 00:27:24,000
ואז החזרתי את הסכום, כך שזה מאוד פשוט, וזה חוסך הרבה קוד

448
00:27:24,000 --> 00:27:28,000
אם אתה משתמש בפונקציה זו הרבה פעמים.

449
00:27:28,000 --> 00:27:32,000
אז לקחנו מבט בתנאים.

450
00:27:32,000 --> 00:27:38,000
יש לנו אם, אחר, ואם אחר.

451
00:27:38,000 --> 00:27:42,000
בואו נראה מה היא ההבדל בין אלה.

452
00:27:42,000 --> 00:27:45,000
תסתכל על 2 קודים אלה. מה ההבדל ביניהם?

453
00:27:45,000 --> 00:27:49,000
1 הראשון, בעצם את הקודים רוצה שתגידו

454
00:27:49,000 --> 00:27:51,000
אם מספר הוא +, -, או 0.

455
00:27:51,000 --> 00:27:55,000
הראשונה אומרת שאם זה> 0 אז זה חיובי.

456
00:27:55,000 --> 00:28:00,000
אם זה = ל 0 אז זה 0, ואם זה <0 אז זה שלילי.

457
00:28:00,000 --> 00:28:04,000
>> והשני עושה אם, אם אחר, אחר.

458
00:28:04,000 --> 00:28:07,000
ההבדל בין השניים הוא שזה דווקא הולך

459
00:28:07,000 --> 00:28:13,000
לבדוק אם> 0, <0 או 0 = שלוש פעמים,

460
00:28:13,000 --> 00:28:17,000
כך שאם יש לך את המספר 2, למשל, זה הולך לבוא לכאן ולומר

461
00:28:17,000 --> 00:28:21,000
אם (x> 0), וזה הולך לומר כן, ולכן אני מדפיס חיובי.

462
00:28:21,000 --> 00:28:25,000
אבל למרות שאני יודע שזה> 0 וזה לא הולך להיות 0 או <0

463
00:28:25,000 --> 00:28:29,000
אני עדיין הולך לעשות את זה הוא 0, הוא אותו <0,

464
00:28:29,000 --> 00:28:33,000
אז בעצם אני הולך בתוך של אילו שלא היה לי ל

465
00:28:33,000 --> 00:28:38,000
כי אני כבר יודע שזה לא הולך כדי לספק את כל התנאים הללו.

466
00:28:38,000 --> 00:28:41,000
אני יכול להשתמש אם, אם אחר, אחר אמירה.

467
00:28:41,000 --> 00:28:45,000
זה בעצם אומר שאם x = 0 אני מדפיס חיובי.

468
00:28:45,000 --> 00:28:48,000
אם זה לא, אני הולך לבדוק את זה גם.

469
00:28:48,000 --> 00:28:51,000
אם זה לא 2 אני הולך לעשות את זה.

470
00:28:51,000 --> 00:28:54,000
בעיקרון, אם היה לי x = 2 היית אומר

471
00:28:54,000 --> 00:28:57,000
אם (x> 0), כן, אז להדפיס את זה.

472
00:28:57,000 --> 00:29:00,000
עכשיו שאני יודע שזה> 0 וכי הוא מרוצה הראשון אם

473
00:29:00,000 --> 00:29:02,000
אני אפילו לא מתכוון לרוץ את הקוד הזה.

474
00:29:02,000 --> 00:29:09,000
הקוד רץ מהר יותר, למעשה, 3 פעמים מהר יותר אם אתה משתמש בזה.

475
00:29:09,000 --> 00:29:11,000
למדו גם על ואו.

476
00:29:11,000 --> 00:29:15,000
אני לא הולך לעבור את זה, כי לקסי כבר דבר עליהם.

477
00:29:15,000 --> 00:29:17,000
זה רק את && ו | | מפעיל.

478
00:29:17,000 --> 00:29:21,000
>> הדבר היחיד שאני יכול לומר הוא להיות זהיר כאשר יש לך 3 תנאים.

479
00:29:21,000 --> 00:29:24,000
השתמש בסוגריים כי זה מאוד מבלבל כאשר יש לך מצב

480
00:29:24,000 --> 00:29:27,000
ועוד אחת או אחד את השני.

481
00:29:27,000 --> 00:29:30,000
השתמש בסוגריים רק כדי להיות בטוח שהתנאים שלך הגיוניים

482
00:29:30,000 --> 00:29:34,000
כי במקרה כזה, לדוגמה, אתה יכול לדמיין את זה

483
00:29:34,000 --> 00:29:38,000
זה יכול להיות התנאי הראשון ואחד או אחר

484
00:29:38,000 --> 00:29:41,000
או את 2 תנאים בשילוב וב

485
00:29:41,000 --> 00:29:45,000
או השלישי, כל כך פשוט להיות זהיר.

486
00:29:45,000 --> 00:29:48,000
ולבסוף, דבר על מתגים.

487
00:29:48,000 --> 00:29:53,000
בורר הוא מאוד שימושי כאשר יש לך משתנה.

488
00:29:53,000 --> 00:29:55,000
בואו נגיד שיש לך משתנה כמו n

489
00:29:55,000 --> 00:29:59,000
שיכול להיות 0, 1 או 2, ועבור כל אחד ממקרים אלה

490
00:29:59,000 --> 00:30:01,000
אתה הולך לבצע משימה.

491
00:30:01,000 --> 00:30:04,000
אתה יכול להגיד לעבור משתנה, והוא מציין כי

492
00:30:04,000 --> 00:30:08,000
אז הערך הוא כמו value1 אני הולך לעשות את זה,

493
00:30:08,000 --> 00:30:12,000
ואז אני שובר, מה שאומר שאני לא הולך להסתכל על כל אחד מהמקרים האחרים

494
00:30:12,000 --> 00:30:15,000
כי אנחנו כבר מרוצים מקרה ש

495
00:30:15,000 --> 00:30:20,000
ולאחר מכן value2 וכן הלאה, ואני גם יכול לקבל מתג ברירת מחדל.

496
00:30:20,000 --> 00:30:24,000
זאת אומרת שאם זה לא מספק את כל אחד מהמקרים שהיו לי

497
00:30:24,000 --> 00:30:29,000
שאני הולך לעשות משהו אחר, אבל זה לא חובה.

498
00:30:29,000 --> 00:30:36,000
זה כל מה שבשבילי. עכשיו בואו יש טומי.

499
00:30:36,000 --> 00:30:41,000
בסדר, זה הולך להיות שבוע 3-ish.

500
00:30:41,000 --> 00:30:45,000
אלה הם חלק מהנושאים שאנו תהיו כיסוי, אנוסים, היקפו, מערכיו, וכולי.

501
00:30:45,000 --> 00:30:49,000
רק כמה מילים על אנוסים. אנחנו לא הולכים לתקוע את זה הביתה.

502
00:30:49,000 --> 00:30:52,000
>> אנחנו עשינו את זה בpset 2, אבל לחידון לוודא שאתה יודע את ההבדל

503
00:30:52,000 --> 00:30:54,000
בין קיסר הצופן וצופן Vigenère,

504
00:30:54,000 --> 00:30:57,000
איך שני אלה צפני העבודה ומה שהיא רוצה להצפין

505
00:30:57,000 --> 00:30:59,000
וטקסט לפענח באמצעות 2 צפנים אלה.

506
00:30:59,000 --> 00:31:03,000
זכור, קיסר הצופן פשוט מסתובב כל תו, באותו הסכום,

507
00:31:03,000 --> 00:31:06,000
וודא שאתה mod במספר האותיות באלף הבית.

508
00:31:06,000 --> 00:31:09,000
וצופן Vigenère, לעומת זאת, מסתובב כל תו

509
00:31:09,000 --> 00:31:12,000
בסכום שונה, אז במקום לומר

510
00:31:12,000 --> 00:31:15,000
כל סיבוב אופי של 3 Vigenère יהיה לסובב כל תו

511
00:31:15,000 --> 00:31:17,000
בסכום שונה בהתאם למילות מפתח מסוים

512
00:31:17,000 --> 00:31:20,000
שבו כל אות במילת המפתח מייצגת שונה במידה מסוימת

513
00:31:20,000 --> 00:31:26,000
כדי לסובב את הטקסט הברור על ידי.

514
00:31:26,000 --> 00:31:28,000
בואו נדבר קודם כל על היקף משתנה.

515
00:31:28,000 --> 00:31:30,000
ישנם 2 סוגים שונים של משתנים.

516
00:31:30,000 --> 00:31:33,000
יש לנו משתנים מקומיים, ואלה הולכים להיות מוגדרים

517
00:31:33,000 --> 00:31:36,000
מחוץ לראשי או מחוץ לכל פונקציה או בלוק,

518
00:31:36,000 --> 00:31:39,000
ואלה יהיו נגישים בכל מקום בתכנית שלך.

519
00:31:39,000 --> 00:31:41,000
אם יש לך פונקציה והפונקציה היא שבלולאה בזמן

520
00:31:41,000 --> 00:31:44,000
המשתנה הגלובלי הגדול נגיש בכל מקום.

521
00:31:44,000 --> 00:31:48,000
משתנה מקומי, לעומת זאת, הוא scoped למקום שבו הוא מוגדר.

522
00:31:48,000 --> 00:31:53,000
>> אם יש לך פונקציה כאן, למשל, יש לנו גרם פונקציה זו,

523
00:31:53,000 --> 00:31:56,000
ובתוך הגר יש כאן משתנה בשם y,

524
00:31:56,000 --> 00:31:58,000
וזה אומר שזה משתנה מקומי.

525
00:31:58,000 --> 00:32:00,000
למרות שמשתנה זה נקרא y

526
00:32:00,000 --> 00:32:03,000
ומשתנה זה נקרא Y 2 הפונקציות האלה

527
00:32:03,000 --> 00:32:06,000
אין לי מושג מה המשתנים המקומיים של זה הם.

528
00:32:06,000 --> 00:32:10,000
מצד השני, עד כאן אנחנו אומרים int x = 5,

529
00:32:10,000 --> 00:32:12,000
וזה הוא מחוץ לתחום של כל אירוע.

530
00:32:12,000 --> 00:32:16,000
זה מחוץ לתחום עיקרי, ולכן זה משתנה גלובלי.

531
00:32:16,000 --> 00:32:20,000
זה אומר שבתוך של 2 פונקציות אלה כשאני אומר x - או x + +

532
00:32:20,000 --> 00:32:26,000
אני ניגש לאותו x לפי y זה y וזה הוא משתנים שונים.

533
00:32:26,000 --> 00:32:30,000
זה הבדל בין משתנה הגלובלי ומשתנה מקומיים.

534
00:32:30,000 --> 00:32:33,000
מבחינת עיצוב הוא מודאג, לפעמים זה כנראה רעיון טוב יותר

535
00:32:33,000 --> 00:32:37,000
כדי לשמור על משתנים מקומיים בכל פעם שאתה אולי יכול

536
00:32:37,000 --> 00:32:39,000
מאז שיש לו חבורה של משתנים הגלובליים יכולה להיות ממש מבלבלת.

537
00:32:39,000 --> 00:32:42,000
אם יש לך חבורה של פונקציות כל שינוי אותו הדבר

538
00:32:42,000 --> 00:32:45,000
אתם עלולים לשכוח מה אם פונקציה זו משנה את הטעות הזו גלובלית,

539
00:32:45,000 --> 00:32:47,000
והפונקציה שנייה לא יודעת על זה,

540
00:32:47,000 --> 00:32:50,000
והוא מגיע די מבלבל כמו שאתה מקבל יותר קוד.

541
00:32:50,000 --> 00:32:53,000
שמירה על משתנים מקומיים בכל פעם שאתה אולי יכול

542
00:32:53,000 --> 00:32:56,000
עיצוב הוא פשוט טוב.

543
00:32:56,000 --> 00:33:00,000
מערכים, יש לזכור, הם פשוט רשימות של אלמנטים מאותו הסוג.

544
00:33:00,000 --> 00:33:04,000
בתוך CI לא יכול יש לי רשימה כמו 1, 2.0, שלום.

545
00:33:04,000 --> 00:33:06,000
אנחנו פשוט לא יכולים לעשות את זה.

546
00:33:06,000 --> 00:33:11,000
>> כאשר אנו מצהירים במערך C כל האלמנטים צריכים להיות מאותו הסוג.

547
00:33:11,000 --> 00:33:14,000
כאן יש לי מערך של 3 מספרים שלמים.

548
00:33:14,000 --> 00:33:18,000
כאן יש לי אורך של המערך, אבל אם אני רק מצהיר על זה בתחביר זה

549
00:33:18,000 --> 00:33:21,000
שבו אני מציין מה כל הרכיבים הם מבחינה טכנית אני לא צריך את זה 3.

550
00:33:21,000 --> 00:33:25,000
המהדר הוא חכם מספיק כדי להבין עד כמה גדול המערך צריך להיות.

551
00:33:25,000 --> 00:33:28,000
עכשיו כשאני רוצה לקבל או להגדיר את ערכו של מערך

552
00:33:28,000 --> 00:33:30,000
זה התחביר כדי לעשות את זה.

553
00:33:30,000 --> 00:33:33,000
זה יהיה למעשה לשנות את האלמנט השני של המערך, כי, כזכור,

554
00:33:33,000 --> 00:33:36,000
המספור מתחיל מ 0, לא ב1.

555
00:33:36,000 --> 00:33:42,000
אם אני רוצה לקרוא ערך שאני יכול לומר משהו כמו int x = מערך [1].

556
00:33:42,000 --> 00:33:44,000
או אם אני רוצה לקבוע ערך זה, כמו שאני עושה כאן,

557
00:33:44,000 --> 00:33:47,000
אני יכול לומר מערך [1] = 4.

558
00:33:47,000 --> 00:33:50,000
זה זמן גישה לאלמנטים במדדם

559
00:33:50,000 --> 00:33:52,000
או העמדה או איפה הם נמצאים במערך שלהם,

560
00:33:52,000 --> 00:33:57,000
והרישום שמתחיל ב 0.

561
00:33:57,000 --> 00:34:00,000
אנחנו יכולים גם מערכים של מערכים,

562
00:34:00,000 --> 00:34:03,000
וזה נקרא מערך רב ממדי.

563
00:34:03,000 --> 00:34:05,000
כאשר יש לנו מערך רב ממדי

564
00:34:05,000 --> 00:34:07,000
זה אומר שאנחנו יכולים להיות משהו כמו שורות ועמודות,

565
00:34:07,000 --> 00:34:11,000
וזו רק דרך אחת לדמיין את זה או לחשוב על זה.

566
00:34:11,000 --> 00:34:14,000
כאשר יש לי מערך רב ממדי שאומר שאני הולך למתחיל להזדקק

567
00:34:14,000 --> 00:34:17,000
מדד יותר מ 1, כי אם יש לי רשת

568
00:34:17,000 --> 00:34:19,000
לומר את מה שאתה בשורה פשוט לא נותן לנו מספר.

569
00:34:19,000 --> 00:34:22,000
זה באמת פשוט הולך לתת לנו רשימה של מספרים.

570
00:34:22,000 --> 00:34:25,000
בואו נגיד שיש לי מערך זה כאן.

571
00:34:25,000 --> 00:34:30,000
יש לי מערך נקרא רשת, ואני אומר 2 שורות ועמודות 3 של זה,

572
00:34:30,000 --> 00:34:32,000
ואז זה הוא דרך אחת לדמיין את זה.

573
00:34:32,000 --> 00:34:37,000
כשאני אומר שאני רוצה לקבל את האלמנט ב[ 1] [2]

574
00:34:37,000 --> 00:34:41,000
זה אומר שבגלל שמדוברות בשורות ראשונות ואז עמודות

575
00:34:41,000 --> 00:34:44,000
אני הולך לקפוץ לשורת 1 מאז שאמרתי 1.

576
00:34:44,000 --> 00:34:49,000
>> ואז אני הולך לבוא לכאן לעמודה 2, ואני הולך לקבל את הערך 6.

577
00:34:49,000 --> 00:34:51,000
הפוך תחושה?

578
00:34:51,000 --> 00:34:55,000
מערכים רבים ממדיים, יש לזכור, הם מבחינה טכנית פשוט מערך של מערכים.

579
00:34:55,000 --> 00:34:57,000
יכול להיות לנו מערכים של מערכים של מערכים.

580
00:34:57,000 --> 00:35:00,000
אנחנו יכולים להמשיך, אבל באמת דרך אחת לחשוב על

581
00:35:00,000 --> 00:35:03,000
איך זה שהניח על השולחן ומה שקורה הוא לדמיין אותו

582
00:35:03,000 --> 00:35:09,000
ברשת כזאת.

583
00:35:09,000 --> 00:35:12,000
כאשר אנו עוברים מערכים לפונקציות, הם הולכים להתנהג

584
00:35:12,000 --> 00:35:16,000
קצת שונה מכאשר אנו עוברים משתנים רגילים לפונקציות

585
00:35:16,000 --> 00:35:18,000
כמו עובר int או לצוף.

586
00:35:18,000 --> 00:35:21,000
כאשר אנו עוברים בint או char או כל נתונים אחרים אלה סוגים

587
00:35:21,000 --> 00:35:24,000
אנחנו פשוט לקחנו להסתכל אם הפונקציה משנה

588
00:35:24,000 --> 00:35:28,000
הערך של אותו משתנה שהשינוי לא הולך להפיץ את

589
00:35:28,000 --> 00:35:32,000
לפונקציה הקוראת.

590
00:35:32,000 --> 00:35:35,000
עם מערך, מצד השני, זה לא יקרה.

591
00:35:35,000 --> 00:35:39,000
אם אני עובר במערך לפונקציה מסוימת והפונקציה שמשנה חלק מהרכיבים,

592
00:35:39,000 --> 00:35:43,000
כשאני חוזר לפונקציה שקראה לה

593
00:35:43,000 --> 00:35:47,000
המערך שלי עכשיו הוא הולך להיות שונה, ואת אוצר מילים של

594
00:35:47,000 --> 00:35:50,000
מערכים הוא מועברים על ידי הפניה, כפי שנראים בהמשך.

595
00:35:50,000 --> 00:35:53,000
זה קשור לאופן עבודה של מצביעים, בי סוגי הנתונים בסיסיים אלה,

596
00:35:53,000 --> 00:35:55,000
מצד השני, מועברים על ידי ערך.

597
00:35:55,000 --> 00:35:59,000
>> אנחנו יכולים לחשוב על זה כיצירת עותק של משתנה מסוים ולאחר מכן עובר בהעתקה.

598
00:35:59,000 --> 00:36:01,000
זה לא משנה מה אנחנו עושים עם זה משתנה.

599
00:36:01,000 --> 00:36:06,000
הפונקציה קוראה לא תהיה מודעת לכך שזה היה שונה.

600
00:36:06,000 --> 00:36:10,000
מערכים הם רק קצת שונה בעניין זה.

601
00:36:10,000 --> 00:36:13,000
לדוגמה, כפי שראינו כרגע, עיקרי הוא פשוט פונקציה

602
00:36:13,000 --> 00:36:15,000
זה יכול לקחת ב2 טיעונים.

603
00:36:15,000 --> 00:36:20,000
הטענה הראשונה לתפקידו העיקרי היא argc, או במספר הטיעונים,

604
00:36:20,000 --> 00:36:23,000
והטענה השנייה נקראת argv,

605
00:36:23,000 --> 00:36:27,000
ואלה הם ערכים האמיתיים של טענות אלה.

606
00:36:27,000 --> 00:36:30,000
בואו נגיד שיש לי תכנית בשם this.c,

607
00:36:30,000 --> 00:36:34,000
ואני אומר לעשות את זה, ואני מתכוון להפעיל את זה בשורת הפקודה.

608
00:36:34,000 --> 00:36:38,000
עכשיו לעבור בטיעונים מסוימים לתכנית שלי בשם הזה,

609
00:36:38,000 --> 00:36:42,000
אני יכול לומר משהו כמו. / זה cs 50.

610
00:36:42,000 --> 00:36:45,000
זה מה שאנו מדמיינים דוד לעשות בכל יום במסוף.

611
00:36:45,000 --> 00:36:48,000
אבל עכשיו בתוך הפונקציה העיקרית של תכנית

612
00:36:48,000 --> 00:36:52,000
יש ערכים אלה, ולכן argc הוא 4.

613
00:36:52,000 --> 00:36:56,000
זה יכול להיות קצת מבלבל, כי באמת שאנחנו רק עוברים בהוא cs 50.

614
00:36:56,000 --> 00:36:58,000
זה רק 3.

615
00:36:58,000 --> 00:37:02,000
אך יש לזכור כי המרכיב הראשון של argv או הטענה הראשונה

616
00:37:02,000 --> 00:37:05,000
הוא שמה של הפונקציה עצם.

617
00:37:05,000 --> 00:37:07,190
אז זה אומר שיש לנו 4 דברים כאן,

618
00:37:07,190 --> 00:37:10,530
והאלמנט הראשון הולך להיות. זה /.

619
00:37:10,530 --> 00:37:12,970
וזה יהיה מיוצג כמחרוזת.

620
00:37:12,970 --> 00:37:18,590
אז האלמנטים שנותרו הם מה שהקלדנו באחרי השם של התכנית.

621
00:37:18,590 --> 00:37:22,720
אז רק כהערת אגב, כפי שבוודאי ראינו בpset 2,

622
00:37:22,720 --> 00:37:28,780
זוכר שהמחרוזת של 50 ≠ 50 מספר השלמים.

623
00:37:28,780 --> 00:37:32,520
אז אנחנו לא יכולים להגיד משהו כמו, 'int x = 3 argv.'

624
00:37:32,520 --> 00:37:36,470
>> זה פשוט לא הולך לעשות את התחושה, כי זו מחרוזת, וזה מספר שלם.

625
00:37:36,470 --> 00:37:38,510
אז אם אתם רוצים להמיר בין 2, תזכרו, אנחנו הולכים

626
00:37:38,510 --> 00:37:40,810
יש פונקצית הקסם הזה שנקרא atoi.

627
00:37:40,810 --> 00:37:46,270
שלוקח מחרוזת ומחזיר את המספר השלם מיוצג בתוכה מחרוזת.

628
00:37:46,270 --> 00:37:48,360
אז זה קל לעשות טעות בחידון,

629
00:37:48,360 --> 00:37:51,590
רק מחשבה שזה יהיה באופן אוטומטי את הסוג הנכון.

630
00:37:51,590 --> 00:37:53,860
אבל רק יודע שתמיד יהיו אלה מחרוזות

631
00:37:53,860 --> 00:38:00,920
גם אם המחרוזת מכילה מספר שלם או תו או מצוף בלבד.

632
00:38:00,920 --> 00:38:03,380
אז עכשיו בואו נדבר על זמן ריצה.

633
00:38:03,380 --> 00:38:06,700
כאשר יש לנו את כל אלגוריתמים אלה שעושים את כל הדברים מטורפים האלה,

634
00:38:06,700 --> 00:38:11,580
זה הופך להיות ממש שימושי לשאול את השאלה, "כמה זמן הם לוקחים?"

635
00:38:11,580 --> 00:38:15,500
אנחנו מייצגים את זה עם משהו שנקרא סימון אסימפטוטי.

636
00:38:15,500 --> 00:38:18,430
אז זה אומר ש-- טוב, בואו נגיד שאנו נותנים האלגוריתם שלנו

637
00:38:18,430 --> 00:38:20,840
קצת קלט ממש, ממש, ממש גדול.

638
00:38:20,840 --> 00:38:23,840
ברצוננו לשאול את השאלה, "כמה זמן זה ייקח לנו?

639
00:38:23,840 --> 00:38:26,370
כמה צעדים ייקח האלגוריתם שלנו לרוץ

640
00:38:26,370 --> 00:38:29,980
כפונקציה של גודל הקלט? "

641
00:38:29,980 --> 00:38:33,080
אז הדרך הראשונה שאנו יכולים לתאר את זמן ריצה היא עם גדול O.

642
00:38:33,080 --> 00:38:35,380
וזה זמן הריצה הגרועה ביותר שלנו.

643
00:38:35,380 --> 00:38:38,590
אז אם אנחנו רוצים למיין מערך, ואנחנו נותנים לאלגוריתם שלנו מערך

644
00:38:38,590 --> 00:38:41,000
זה בסדר יורד כאשר זה צריך להיות בסדר עולה,

645
00:38:41,000 --> 00:38:43,130
זה הולך להיות במקרה הגרוע ביותר.

646
00:38:43,130 --> 00:38:49,800
זה הגבול העליון שלנו באורך המרבי של זמן האלגוריתם שלנו ייקח.

647
00:38:49,800 --> 00:38:54,740
מצד השני, Ω זה הולך לתאר את זמן ריצה הטובה ביותר במקרה.

648
00:38:54,740 --> 00:38:58,210
אז אם אנחנו נותנים מערך כבר ממוין לאלגוריתם מיון,

649
00:38:58,210 --> 00:39:00,940
כמה זמן זה ייקח כדי למיין אותו?

650
00:39:00,940 --> 00:39:06,610
וזו, אם כן, מתארת ​​חסם תחתון על זמן ריצה.

651
00:39:06,610 --> 00:39:10,980
אז הנה רק כמה מילים המתארות כמה פעמים רצופות נפוצות.

652
00:39:10,980 --> 00:39:13,120
אלה הם בסדר עולים.

653
00:39:13,120 --> 00:39:16,060
זמן הריצה המהירה ביותר שיש לנו נקרא מתמיד.

654
00:39:16,060 --> 00:39:19,800
>> זה אומר שלא משנה כמה אלמנטים שאנו נותנים האלגוריתם שלנו,

655
00:39:19,800 --> 00:39:22,280
לא משנה כמה גדול הוא המערך שלנו, מיונו

656
00:39:22,280 --> 00:39:26,510
או לעשות כל מה שאנחנו עושים למערך תמיד ייקח את אותה כמות של זמן.

657
00:39:26,510 --> 00:39:30,270
אז אנחנו יכולים לייצג אותו רק עם 1, שהוא קבוע.

658
00:39:30,270 --> 00:39:32,410
נראו גם בזמן ריצת לוגריתמים.

659
00:39:32,410 --> 00:39:34,800
אז משהו כמו חיפוש בינארי הוא לוגריתמים

660
00:39:34,800 --> 00:39:37,140
איפה אנחנו לחתוך את הבעיה בחצי בכל פעם

661
00:39:37,140 --> 00:39:40,970
ואז דברים פשוט להגיע גבוהים יותר משם.

662
00:39:40,970 --> 00:39:43,580
ואם אי פעם אתה כותב O של כל אלגוריתם עצרת,

663
00:39:43,580 --> 00:39:47,850
אתה כנראה לא צריך לשקול את זה כעבודת היום שלך.

664
00:39:47,850 --> 00:39:53,910
כאשר אנו משווים פעמים רצופות זה חשוב לזכור את הדברים האלה.

665
00:39:53,910 --> 00:39:57,760
אז אם יש לי אלגוריתם זה O (n), ומישהו אחר

666
00:39:57,760 --> 00:40:03,590
יש אלגוריתם של O (2n) אלה הם למעשה asymptotically מקבילים.

667
00:40:03,590 --> 00:40:06,590
אז אם אנחנו מדמיינים n להיות מספר גדול כמו eleventy מיליארדים:

668
00:40:06,590 --> 00:40:13,090
לכן כאשר אנו משווים eleventy מיליארדים למשהו כמו מיליארדים eleventy + 3,

669
00:40:13,090 --> 00:40:17,640
פתאום 3 שלא ממש יעשו הבדל גדול יותר.

670
00:40:17,640 --> 00:40:20,980
זו הסיבה שאנחנו הולכים להתחיל שוקלים את הדברים האלה כדי להיות שווים.

671
00:40:20,980 --> 00:40:24,220
אז דברים כמו בקבועים אלה כאן, יש 2 x זה, או להוסיף 3,

672
00:40:24,220 --> 00:40:27,180
אלה הם רק קבועים, ואלה הולכים טיפה למעלה.

673
00:40:27,180 --> 00:40:32,480
אז בגלל זה כל 3 לרוץ הפעמים האלה הם אותו דבר כמו להגיד שהם O (n).

674
00:40:32,480 --> 00:40:37,490
בדומה לכך, אם יש לנו 2 לרוץ פעמים אחרות, תניח O (n ³ + 2n ²), אנו יכולים להוסיף

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, ולאחר מכן יש לנו זמן אחר לרוץ זה רק O (n ³).

676
00:40:42,070 --> 00:40:46,290
שוב, אלה הם אותו דבר, כי אלה - כל אלה הם לא אותו הדבר.

677
00:40:46,290 --> 00:40:49,840
אלה הם אותם הדברים, מצטער. אז אלו הם אותו הדבר כי

678
00:40:49,840 --> 00:40:53,090
³ n זה הולך לשלוט ² 2n זה.

679
00:40:53,090 --> 00:40:59,130
>> מה היא לא אותו דבר הוא שאם יש לנו לרוץ פעמים כמו O (n ³) ו-O (n ²)

680
00:40:59,130 --> 00:41:02,820
בגלל ³ n זה הרבה יותר גדול מזה n ².

681
00:41:02,820 --> 00:41:05,470
אז אם יש לנו מעריכים, פתאום זה מתחיל משנה,

682
00:41:05,470 --> 00:41:08,280
אבל כאשר אנחנו עוסקים רק בגורמים כמו שאנחנו כאן,

683
00:41:08,280 --> 00:41:12,810
אז זה לא ישן דבר, כי הם פשוט הולכים לנשור.

684
00:41:12,810 --> 00:41:16,760
בואו נסתכל על כמה מהאלגוריתמים שראינו עד כה

685
00:41:16,760 --> 00:41:19,260
ומדבר על זמן הריצה שלהם.

686
00:41:19,260 --> 00:41:23,850
הדרך הראשונה של מחפש מספר ברשימה, שראינו, הייתה החיפוש ליניארי.

687
00:41:23,850 --> 00:41:26,950
ויישום החיפוש ליניארי הוא סופר פשוט.

688
00:41:26,950 --> 00:41:30,490
פשוט יש לנו רשימה, ואנחנו הולכים להסתכל על כל אלמנט יחיד ברשימה

689
00:41:30,490 --> 00:41:34,260
עד שאנחנו מוצאים את המספר שאנחנו מחפשים.

690
00:41:34,260 --> 00:41:38,370
אז זה אומר שבמקרה הגרוע ביותר, זה O (n).

691
00:41:38,370 --> 00:41:40,860
והמקרה הגרוע ביותר יכול להיות כאן אם הרכיב הוא

692
00:41:40,860 --> 00:41:45,710
האלמנט האחרון, ולאחר מכן באמצעות חיפוש יניארי אנחנו צריכים להסתכל על כל אלמנט יחיד

693
00:41:45,710 --> 00:41:50,180
עד שנגיע לזה שעבר כדי לדעת שזה היה בעצם ברשימה.

694
00:41:50,180 --> 00:41:52,910
אנחנו לא יכולים פשוט לוותר באמצע הדרך ולומר: "זה כנראה לא שם."

695
00:41:52,910 --> 00:41:55,980
בחיפוש ליניארי שאנחנו צריכים להסתכל על כל העניין.

696
00:41:55,980 --> 00:41:59,090
זמן הרצת המקרה הטוב, לעומת זאת, הוא מתמיד

697
00:41:59,090 --> 00:42:04,200
כי במקרה הטוב ביותר האלמנט שאנחנו מחפשים הוא רק ראשון ברשימה.

698
00:42:04,200 --> 00:42:08,930
אז זה הולך לקחת לנו בדיוק שלב 1, לא משנה כמה גדול היא הרשימה

699
00:42:08,930 --> 00:42:12,140
אם אנחנו מחפשים את האלמנט הראשון בכל פעם.

700
00:42:12,140 --> 00:42:15,390
>> לכן, כאשר אתה מחפש, יש לזכור, היא אינה דורשת כי הרשימה שלנו תהיה מסודרת.

701
00:42:15,390 --> 00:42:19,430
כי אנחנו פשוט הולכים להסתכל על כל אלמנט יחיד, וזה לא ממש משנה

702
00:42:19,430 --> 00:42:23,560
מה סדר אלה הם המרכיבים פנימה

703
00:42:23,560 --> 00:42:28,110
אלגוריתם חיפוש חכם יותר הוא משהו כמו חיפוש בינארי.

704
00:42:28,110 --> 00:42:31,500
זכור, ביצוע החיפוש בינארי הוא כאשר אתה הולך

705
00:42:31,500 --> 00:42:34,320
להמשיך לחפש באמצע הרשימה.

706
00:42:34,320 --> 00:42:38,000
ומכיוון שאנחנו מחפשים באמצע, אנו דורשים שהרשימה ממוינת

707
00:42:38,000 --> 00:42:40,580
או שאנחנו לא יודעים איפה הוא באמצע, ואנחנו צריכים להסתכל על

708
00:42:40,580 --> 00:42:44,480
כל הרשימה כדי למצוא אותו, ולאחר מכן בשלב זה אנחנו רק מבזבזים את הזמן.

709
00:42:44,480 --> 00:42:48,480
אז אם יש לנו רשימה ממוינת ואנו מוצאים את האמצע, אנחנו הולכים להשוות את האמצע

710
00:42:48,480 --> 00:42:51,590
לאלמנט שאנחנו מחפשים.

711
00:42:51,590 --> 00:42:54,640
אם הוא גבוה מדי, ואז אנחנו יכולים לשכוח את המחצית הימנית

712
00:42:54,640 --> 00:42:57,810
כי אנחנו יודעים שאם האלמנט שלנו הוא כבר גבוה מדי

713
00:42:57,810 --> 00:43:01,080
והכל לזכותו של רכיב זה הוא אף גבוה יותר,

714
00:43:01,080 --> 00:43:02,760
אז אנחנו לא צריכים להסתכל לשם יותר.

715
00:43:02,760 --> 00:43:05,430
איפה מצד השני, אם עיקרון היסוד שלנו הוא נמוך מדי,

716
00:43:05,430 --> 00:43:08,700
אנחנו יודעים הכל בצד השמאל של אלמנט שהוא גם נמוך מדי,

717
00:43:08,700 --> 00:43:11,390
אז זה לא ממש הגיוני להסתכל גם שם.

718
00:43:11,390 --> 00:43:15,760
בדרך זו, בכל צעד ובכל פעם שאנחנו מסתכלים על נקודת האמצע של הרשימה,

719
00:43:15,760 --> 00:43:19,060
אנחנו הולכים לחתוך את הבעיה שלנו בחצי כי פתאום אנחנו יודעים

720
00:43:19,060 --> 00:43:23,040
חבורה שלמה של מספרים שלא יכול להיות זה שאנחנו מחפשים.

721
00:43:23,040 --> 00:43:26,950
>> בpseudocode זה היה נראה משהו כזה,

722
00:43:26,950 --> 00:43:30,990
ובגלל שאנחנו חותכים את הרשימה בחצי בכל פעם,

723
00:43:30,990 --> 00:43:34,920
קפיצותינו מקרה הגרוע ביותר זמן הריצה לינארי מוגריתמית.

724
00:43:34,920 --> 00:43:39,260
אז פתאום יש לנו התחברות בצעדים על מנת למצוא אלמנט ברשימה.

725
00:43:39,260 --> 00:43:42,460
זמן הרצת המקרה הטוב ביותר, אם כי, עדיין מתמיד

726
00:43:42,460 --> 00:43:45,180
כי עכשיו, בואו רק נאמר שהאלמנט שאנחנו מחפשים הוא

727
00:43:45,180 --> 00:43:48,380
תמיד האמצע המדויק של הרשימה המקורית.

728
00:43:48,380 --> 00:43:52,080
אז אנחנו יכולים להגדיל את הרשימה שלנו גדול כמו שאנחנו רוצים, אבל אם היסוד שאנחנו מחפשים הוא באמצע,

729
00:43:52,080 --> 00:43:54,910
אז זה רק הולך לקחת אותנו הצעד 1.

730
00:43:54,910 --> 00:44:00,920
אז זאת הסיבה שאנחנו O (logn) וΩ (1) או קבוע.

731
00:44:00,920 --> 00:44:04,510
בואו למעשה להפעיל חיפוש בינארי ברשימה זו.

732
00:44:04,510 --> 00:44:08,020
אז אניח שאנחנו מחפשים את האלמנט 164.

733
00:44:08,020 --> 00:44:11,650
הדבר הראשון שאנחנו הולכים לעשות הוא למצוא את נקודת האמצע של רשימה זו.

734
00:44:11,650 --> 00:44:15,060
זה פשוט כל כך קורה שנקודת האמצע היא עומדת לנפול בין 2 מספרים אלה,

735
00:44:15,060 --> 00:44:18,960
אז בוא רק תגיד באופן שרירותי, בכל פעם לנקודת האמצע נופל בין 2 מספרים,

736
00:44:18,960 --> 00:44:21,150
בואו רק לעגל כלפי מעלה.

737
00:44:21,150 --> 00:44:24,330
אנחנו רק צריכים לוודא שאנחנו עושים את זה בכל שלב של הדרך.

738
00:44:24,330 --> 00:44:29,040
אז אנחנו הולכים לאסוף, ואנחנו הולכים לומר כי 161 הם אמצע הרשימה שלנו.

739
00:44:29,040 --> 00:44:34,640
אז 161 <164, וכל אלמנט בצד השמאל של 161

740
00:44:34,640 --> 00:44:39,120
גם <164, כך שאנחנו יודעים שזה לא הולך לעזור לנו בכל

741
00:44:39,120 --> 00:44:42,690
להתחיל לחפש כאן, כי הגורם שאנחנו מחפשים לא יכולים להיות שם.

742
00:44:42,690 --> 00:44:47,060
אז מה אנחנו יכולים לעשות הוא פשוט יכולים לשכוח שהמחצית השמאלית של כל הרשימה,

743
00:44:47,060 --> 00:44:51,700
ועכשיו רואים רק מזכותו של ואילך 161.

744
00:44:51,700 --> 00:44:54,050
>> אז שוב, זו היא נקודת האמצע, בואו פשוט לעגל כלפי מעלה.

745
00:44:54,050 --> 00:44:56,260
עכשיו 175 הם גדולים מדי.

746
00:44:56,260 --> 00:44:59,180
אז אנחנו יודעים שזה לא יעזור לנו לחפש כאן או לכאן,

747
00:44:59,180 --> 00:45:06,610
ולכן אנחנו יכולים פשוט לזרוק את הכל, וסופו של דבר אנחנו נפגענו 164.

748
00:45:06,610 --> 00:45:10,560
כל שאלה על החיפוש בינארי?

749
00:45:10,560 --> 00:45:14,180
בואו לעבור מחיפוש דרך רשימה ממוינת כבר

750
00:45:14,180 --> 00:45:17,660
למעשה לוקח רשימה של מספרים בכל סדר

751
00:45:17,660 --> 00:45:20,960
ומה שהופך את הרשימה בסדר עולה.

752
00:45:20,960 --> 00:45:24,060
האלגוריתם הראשון שבדקנו נקרא מיון בועות.

753
00:45:24,060 --> 00:45:27,300
וזה יהיה פשוט יותר מהאלגוריתמים שראינו.

754
00:45:27,300 --> 00:45:32,970
מיון בועות אומר שכאשר כל 2 אלמנטים בתוך הרשימה נמצאים מחוץ למקום,

755
00:45:32,970 --> 00:45:36,500
כלומר יש מספר גבוה יותר מהשמאל למספר נמוך יותר,

756
00:45:36,500 --> 00:45:40,190
אז אנחנו הולכים להחליף אותם, כי זה אומר שהרשימה תהיה

757
00:45:40,190 --> 00:45:42,860
"יותר מסודר" ממה שהיה לפני.

758
00:45:42,860 --> 00:45:45,180
ואנחנו פשוט הולכים להמשיך את התהליך הזה שוב ושוב ושוב

759
00:45:45,180 --> 00:45:52,100
עד סופו של דבר הסוג של בועת האלמנטים למיקומם הנכון ויש לנו רשימה ממוינת.

760
00:45:52,100 --> 00:45:57,230
>> זמן הריצה של זה הולך להיות O (n ²). למה?

761
00:45:57,230 --> 00:46:00,370
ובכן, משום שבמקרה הגרוע ביותר, אנחנו הולכים לקחת את כל אלמנטים, ו

762
00:46:00,370 --> 00:46:04,570
אנחנו הולכים בסופו השווה אותו לכל גורם אחר ברשימה.

763
00:46:04,570 --> 00:46:08,030
אבל במקרה הטוב, יש לנו רשימה כבר ממוינת, סוג של בועה

764
00:46:08,030 --> 00:46:12,230
פשוט הולך לעבור פעם אחת, אומרים "לא. אני לא בצעתי חילופים, כך אני עושה."

765
00:46:12,230 --> 00:46:17,410
אז יש לנו זמן הרצת מקרה הטוב של Ω (n).

766
00:46:17,410 --> 00:46:20,680
בואו לרוץ מיון בועות ברשימה.

767
00:46:20,680 --> 00:46:23,560
או ראשון, בואו פשוט להסתכל pseudocode חלק ממש מהר.

768
00:46:23,560 --> 00:46:28,160
אנחנו רוצים להגיד שאנחנו רוצים לעקוב אחר, בכל איטרציה של הלולאה,

769
00:46:28,160 --> 00:46:32,190
לעקוב אחרי האם או לא שינינו את כל אלמנטים.

770
00:46:32,190 --> 00:46:37,610
אז הסיבה לכך הוא, שאנחנו הולכים לעצור כאשר יש לנו לא החלפנו את כל אלמנטים.

771
00:46:37,610 --> 00:46:41,980
אז בתחילת הלולאה שלנו אנחנו לא החלפנו שום דבר, ולכן אנחנו אומרים שזה שקר.

772
00:46:41,980 --> 00:46:47,170
עכשיו, אנחנו הולכים לעבור על הרשימה והשווה אלמנטי לאלמנט אני + 1

773
00:46:47,170 --> 00:46:50,310
ואם זה המקרה שיש מספר גדול יותר בצד השמאל של מספר קטן יותר,

774
00:46:50,310 --> 00:46:52,310
אז אנחנו פשוט הולכים להחליף אותם.

775
00:46:52,310 --> 00:46:54,490
>> ואז אנחנו הולכים לזכור שאנחנו החלפנו אלמנט.

776
00:46:54,490 --> 00:46:58,900
זה אומר שאנחנו צריכים לעבור את הרשימה לפחות פעם 1 יותר

777
00:46:58,900 --> 00:47:02,160
בגלל המצב שבו עצרנו הוא כאשר כל הרשימה כבר ממוינת,

778
00:47:02,160 --> 00:47:04,890
כלומר יש לנו לא עשו שום עסקות חלף.

779
00:47:04,890 --> 00:47:09,960
אז בגלל זה המצב שלנו כאן הוא "תוך כמה אלמנטים שהוחלפו. '

780
00:47:09,960 --> 00:47:13,720
אז עכשיו בואו נראה את זה רץ על רשימה.

781
00:47:13,720 --> 00:47:16,640
יש לי רשימה 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
מיון בועות עומד להתחיל את כל הדרך בשמאל, וזה הולך להשוות

783
00:47:19,850 --> 00:47:24,700
אלמנטים ש, כך 0 עד ש+ 1, שהוא האלמנט 1.

784
00:47:24,700 --> 00:47:29,020
זה הולך לומר, גם 5> 0, אבל כרגע 5 הם לשמאל,

785
00:47:29,020 --> 00:47:32,500
אז אני צריך להחליף 5 ו 0.

786
00:47:32,500 --> 00:47:35,470
כשאני מחליף אותם, ופתאום אני מקבל רשימה אחרת זה.

787
00:47:35,470 --> 00:47:38,260
עכשיו 5> 1, אז אנחנו הולכים להחליף אותם.

788
00:47:38,260 --> 00:47:42,160
5 הן לא> 6, ולכן אנחנו לא צריכים לעשות שום דבר כאן.

789
00:47:42,160 --> 00:47:46,690
אבל 6> 4, כך שאנחנו צריכים להחליף.

790
00:47:46,690 --> 00:47:49,740
שוב, אנחנו צריכים לרוץ דרך כל רשימת סופו של דבר לגלות

791
00:47:49,740 --> 00:47:52,330
כי אלה הם מחוץ לסדר; להחליף אותם,

792
00:47:52,330 --> 00:47:57,120
ובשלב זה אנחנו צריכים לרוץ דרך הרשימה 1 יותר זמן

793
00:47:57,120 --> 00:48:05,390
כדי לוודא שהכול בשליטתה, ובמיון בועות שלב זה כבר הסתיים.

794
00:48:05,390 --> 00:48:10,720
אלגוריתם שונה ללוקחים כמה אלמנטים ומיונם הוא מיון בחירה.

795
00:48:10,720 --> 00:48:15,740
הרעיון מאחורי מיון בחירה הוא שאנחנו הולכים לבנות את חלק ממוין של הרשימה

796
00:48:15,740 --> 00:48:18,150
אלמנט 1 בכל פעם.

797
00:48:18,150 --> 00:48:23,170
>> והדרך שאנחנו הולכים לעשות את זה היא על ידי בניית הקטע השמאלי של הרשימה.

798
00:48:23,170 --> 00:48:27,510
ובעצם, בכל - בכל שלב, אנחנו הולכים לקחת את היסוד הקטן ביותר שנשארנו לנו

799
00:48:27,510 --> 00:48:32,310
שלא מוין עדיין, ואנחנו הולכים להעביר אותו לאותו מגזר מיון.

800
00:48:32,310 --> 00:48:35,850
זה אומר שאנחנו צריכים ברציפות כדי למצוא את האלמנט הממוין המינימום

801
00:48:35,850 --> 00:48:40,720
ואז לקחת אותו האלמנט מינימאלי ולהחליף אותו עם כל מה

802
00:48:40,720 --> 00:48:45,090
השמאלי ביותר אלמנט שאינו ממוין.

803
00:48:45,090 --> 00:48:50,890
זמן הריצה של זה הולך להיות O (n ²), כי במקרה הגרוע ביותר

804
00:48:50,890 --> 00:48:55,070
אנו צריכים להשוות כל אלמנט בודד לכל גורם אחר.

805
00:48:55,070 --> 00:48:59,250
בגלל שאנחנו אומרים שאם נתחיל במחצית השמאלית של הרשימה, אנחנו צריכים

806
00:48:59,250 --> 00:49:02,970
כדי לעבור את הקטע הנכון כל למצוא את היסוד הקטן ביותר.

807
00:49:02,970 --> 00:49:05,430
ואז, שוב, אנחנו צריכים ללכת על המגזר כולו וזכות

808
00:49:05,430 --> 00:49:08,210
להמשיך ללכת על זה שוב ושוב ושוב.

809
00:49:08,210 --> 00:49:11,350
זה הולך להיות ² n. אנחנו הולכים לצריכים בתוך לולאה אחרת ללולאה

810
00:49:11,350 --> 00:49:13,350
אשר טוען ² n.

811
00:49:13,350 --> 00:49:16,530
במקרה הטוב ביותר המחשבה, אניח שאנחנו נותנים לו רשימה כבר מסודרת;

812
00:49:16,530 --> 00:49:19,270
אנחנו באמת לא עושים יותר טוב מ² n.

813
00:49:19,270 --> 00:49:21,730
בגלל מיון בחירה אין דרך לדעת ש

814
00:49:21,730 --> 00:49:25,540
המרכיב המינימאלי הוא רק אחד אני במקרה מסתכל.

815
00:49:25,540 --> 00:49:28,970
זה עדיין צריך לוודא שזה הוא למעשה המינימום.

816
00:49:28,970 --> 00:49:31,670
>> והדרך היחידה לוודא שזה המינימום, באמצעות אלגוריתם זה,

817
00:49:31,670 --> 00:49:34,640
הוא להסתכל על כל אלמנט בודד שוב.

818
00:49:34,640 --> 00:49:38,420
אז באמת, אם אתה נותן לו - אם אתה נותן לי מיון בחירת רשימה כבר ממוינת,

819
00:49:38,420 --> 00:49:42,720
זה לא הולך לעשות יותר טוב מאשר לתת אותו ברשימה שאינו ממוינת עדיין.

820
00:49:42,720 --> 00:49:46,320
דרך אגב, אם זה קורה להיות המקרה שמשהו הוא O (משהו)

821
00:49:46,320 --> 00:49:50,640
והאומגה של משהו, אנחנו יכולים רק לומר באופן תמציתי יותר שזה θ של משהו.

822
00:49:50,640 --> 00:49:52,760
אז אם אתה רואה שעולה בכל מקום, זה מה שרק אומר.

823
00:49:52,760 --> 00:49:57,580
>> אם משהו הוא תטא של n ², זה גם גדול O (n ²) וΩ (n ²).

824
00:49:57,580 --> 00:49:59,790
אז במקרה הטוב ביותר ומקרה הגרוע ביותר, זה לא עושה את הבדל,

825
00:49:59,790 --> 00:50:04,400
האלגוריתם הוא הולך לעשות את אותו הדבר כל זמן.

826
00:50:04,400 --> 00:50:06,610
אז זה מה שpseudocode למיון בחירה יכולה להיראות כך.

827
00:50:06,610 --> 00:50:10,630
אנו בעצם הולכים להגיד שאני רוצה לחזר על הרשימה

828
00:50:10,630 --> 00:50:15,180
משמאל לימין, ובכל איטרציה של הלולאה, אני הולך לעבור

829
00:50:15,180 --> 00:50:19,780
המרכיב המינימאלי לחלק מסודר זו של הרשימה.

830
00:50:19,780 --> 00:50:23,260
וברגע שאני מזיז שם משהו, אני לא צריך להסתכל על אותו האלמנט שוב.

831
00:50:23,260 --> 00:50:28,600
כי ברגע שאני מחליף אלמנט במגזר השמאל של הרשימה, זה מסודר

832
00:50:28,600 --> 00:50:32,600
בגלל שאנחנו עושים הכל בסדר עולה באמצעות מינימום.

833
00:50:32,600 --> 00:50:38,740
אז אמר, בסדר, אנחנו בעמדתי, ואנחנו צריכים להסתכל על כל האלמנטים

834
00:50:38,740 --> 00:50:42,260
בצד הימין שלי כדי למצוא את המינימום.

835
00:50:42,260 --> 00:50:46,150
אז זה אומר שאנחנו רוצים לראות מאני + 1 לסוף הרשימה.

836
00:50:46,150 --> 00:50:51,610
ועכשיו, אם היסוד שאנחנו כרגע מסתכלים עליה הוא פחות מהמינימום שלנו עד כה,

837
00:50:51,610 --> 00:50:54,190
אשר, יש לזכור, אנחנו מתחילים מהמינימום רק כדי להיות

838
00:50:54,190 --> 00:50:57,020
כל אלמנט שאנחנו כרגע ב; אני מניח שזה המינימום.

839
00:50:57,020 --> 00:51:00,270
אם אני מוצא את אלמנט שהוא קטן יותר מזה, אז אני הולך להגיד, בסדר,

840
00:51:00,270 --> 00:51:02,700
כן, מצאתי מינימום חדש.

841
00:51:02,700 --> 00:51:06,080
אני הולך לזכור היכן שהיה מינימאלי.

842
00:51:06,080 --> 00:51:09,560
>> אז עכשיו, ברגע שעברתי עליי שהקטע הממוין הנכון,

843
00:51:09,560 --> 00:51:16,690
אני יכול להגיד שאני הולך להחליף את האלמנט המינימאלי עם האלמנט שהוא בעמדתי.

844
00:51:16,690 --> 00:51:21,100
זה הולך לבנות את הרשימה שלי, החלק שלי מסודר ברשימה משמאל לימין,

845
00:51:21,100 --> 00:51:25,190
ואנחנו אף פעם לא צריכים להסתכל על אלמנט שוב ​​פעם אחת היה זה באותו חלק.

846
00:51:25,190 --> 00:51:27,930
ברגע שהחלפנו אותה.

847
00:51:27,930 --> 00:51:30,260
אז בואו לרוץ מיון בחירה ברשימה זו.

848
00:51:30,260 --> 00:51:38,220
האלמנט הכחול כאן הולך להיות אני, והאלמנט האדום הולך להיות המרכיב המינימאלי.

849
00:51:38,220 --> 00:51:41,570
אז אני מתחיל את כל הדרך בצד השמאל של הרשימה, כך בשעת 5.

850
00:51:41,570 --> 00:51:44,610
עכשיו אנחנו צריכים למצוא את האלמנט הממוין המינימום.

851
00:51:44,610 --> 00:51:49,480
אז אנחנו אומרים 0 <5, ולכן 0 הם המינימום החדש שלי.

852
00:51:49,480 --> 00:51:53,820
>> אבל אני לא יכול לעצור שם, כי אף על פי שאנו יכולים להכיר בכך ש0 הוא הקטן ביותר,

853
00:51:53,820 --> 00:51:59,390
אנחנו צריכים לרוץ דרך כל אלמנט אחר של הרשימה כדי לוודא.

854
00:51:59,390 --> 00:52:01,760
אז 1 הוא גדול יותר, 6 הם גדולים יותר, 4 הם גדולים יותר.

855
00:52:01,760 --> 00:52:05,850
זה אומר שאחרי שמסתכל על כל המרכיבים האלה, אני כבר נקבעתי 0 הוא קטן ביותר.

856
00:52:05,850 --> 00:52:09,800
אז אני הולך להחליף 5 ו 0.

857
00:52:09,800 --> 00:52:15,480
ברגע שאני מחליף את זה, אני הולך לקבל רשימה חדשה, ואני יודע שאני לא צריך להסתכל על זה שוב 0

858
00:52:15,480 --> 00:52:19,380
כי ברגע שהחלפתי אותה, שאסדיר את זה ואנחנו נעשינו.

859
00:52:19,380 --> 00:52:22,730
עכשיו זה פשוט כל כך קורה כי האלמנט הכחול הוא שוב 5,

860
00:52:22,730 --> 00:52:26,030
ואנחנו צריכים להסתכל על 1, 6 ו 4 כדי לקבוע כי 1

861
00:52:26,030 --> 00:52:31,520
הוא האלמנט המינימאלי הקטן ביותר, ולכן אנחנו להחליף 1 ו 5.

862
00:52:31,520 --> 00:52:36,890
שוב, אנחנו צריכים להסתכל על - להשוות 5 עד 6 ו 4,

863
00:52:36,890 --> 00:52:39,830
ואנחנו הולכים להחליף 4 ו 5, ולבסוף, להשוות

864
00:52:39,830 --> 00:52:45,740
2 המספרים האלה ולהחליף אותם עד שנקבל הרשימה הממוינת שלנו.

865
00:52:45,740 --> 00:52:49,730
כל שאלות על מיון בחירה?

866
00:52:49,730 --> 00:52:56,420
אוקיי. בואו נעבור לנושא האחרון כאן, וזה רקורסיה.

867
00:52:56,420 --> 00:52:59,810
>> רקורסיה, יש לזכור, היא באמת הדבר הזה שבו המטא פונקציה

868
00:52:59,810 --> 00:53:02,740
קורא שוב ושוב את עצמו.

869
00:53:02,740 --> 00:53:05,620
אז בשלב מסוים, בעוד fuction שוב ושוב הוא קורא את עצמו,

870
00:53:05,620 --> 00:53:10,100
צריך שתהיה איזו נקודה שבה אנו קוראים להפסיק את עצמנו.

871
00:53:10,100 --> 00:53:13,670
כי אם אנחנו לא עושים את זה, אז אנחנו פשוט הולכים להמשיך לעשות זאת לנצח,

872
00:53:13,670 --> 00:53:16,660
והתכנית שלנו היא פשוט לא הולכת להפסיק.

873
00:53:16,660 --> 00:53:19,200
אנחנו קוראים למצב זה מקרה הבסיס.

874
00:53:19,200 --> 00:53:22,570
ומקרה הבסיס אומר, ולא קוראים לפונקציה שוב,

875
00:53:22,570 --> 00:53:25,330
אני רק הולך להחזיר ערך כלשהו.

876
00:53:25,330 --> 00:53:28,080
אז ברגע שאנחנו חוזרים ערך, הפסיק לקרוא לעצמנו,

877
00:53:28,080 --> 00:53:32,550
ואת שאר השיחות שעשינו עד כה יכול גם לחזור.

878
00:53:32,550 --> 00:53:36,050
ההפך ממקרה הבסיס הוא המקרה רקורסיבית.

879
00:53:36,050 --> 00:53:39,050
וזה כאשר אנו רוצים לבצע שיחה נוספת לפונקציה שאנחנו כרגע פנימה

880
00:53:39,050 --> 00:53:44,690
ואנחנו כנראה, אם כי לא תמיד, רוצים להשתמש בטיעונים שונים.

881
00:53:44,690 --> 00:53:48,940
>> אז אם יש לנו פונקציה שנקראת f, ו f פשוט נקראת לקחת את הטיעון 1,

882
00:53:48,940 --> 00:53:52,010
ואנחנו רק להמשיך לקרוא f (1), f (1), f (1), וזה פשוט כל כך קורה כי

883
00:53:52,010 --> 00:53:56,510
טענת 1 נופלת לתוך מקרה רקורסיבית, אנחנו עדיין לא מתכוונים לעצור.

884
00:53:56,510 --> 00:54:01,620
גם אם יש לנו מקרה בסיס, אנחנו צריכים לוודא שסופו של דבר אנחנו הולכים להכות מקרה זה בסיס.

885
00:54:01,620 --> 00:54:04,250
אנחנו לא רק לשמור על ההישארות במקרה זה רקורסיבית.

886
00:54:04,250 --> 00:54:09,870
בדרך כלל, כאשר אנו מכנים את עצמנו, אנחנו כנראה הולכים להיות ויכוח שונה בכל פעם.

887
00:54:09,870 --> 00:54:12,700
הנה פונקציה רקורסיבית ממש פשוט.

888
00:54:12,700 --> 00:54:15,090
אז זה יהיה לחשב את העצרת של מספר.

889
00:54:15,090 --> 00:54:17,790
למעלה כאן יש לנו מקרה הבסיס שלנו.

890
00:54:17,790 --> 00:54:22,330
במקרה שn ≤ 1, אנחנו לא מתכוון לקרוא לעצרת שוב.

891
00:54:22,330 --> 00:54:26,490
אנחנו הולכים להפסיק, אנחנו פשוט הולכים להחזיר ערך כלשהו.

892
00:54:26,490 --> 00:54:30,170
אם זה לא נכון, אז אנחנו הולכים להכות המקרה רקורסיבית שלנו.

893
00:54:30,170 --> 00:54:33,550
שימו לב כאן שאנחנו לא רק להתקשר לעצרת (n), בגלל שלא יהיו מאוד מועיל.

894
00:54:33,550 --> 00:54:36,810
אנחנו הולכים לקרוא לעצרת של משהו אחר.

895
00:54:36,810 --> 00:54:40,850
>> וכדי שתוכל לראות, בסופו אם אנחנו עוברים משהו עצרת (5) או,

896
00:54:40,850 --> 00:54:45,900
אנחנו הולכים לקרוא לעצרת (4) וכן הלאה, וסופו של דבר אנחנו הולכים להכות מקרה בסיס זה.

897
00:54:45,900 --> 00:54:51,730
אז זה נראה טוב. בואו נראה מה קורה כאשר אנו למעשה להפעיל את זה.

898
00:54:51,730 --> 00:54:57,840
זה הערימה, ונניח שעיקריים עומד לקרוא בפונקציה זו עם טענה (4).

899
00:54:57,840 --> 00:55:02,200
אז ברגע שרואה את העצרת ו= 4, עצרת תהיה שיחה עוצמה.

900
00:55:02,200 --> 00:55:05,010
עכשיו, פתאום, יש לנו עצרת (3).

901
00:55:05,010 --> 00:55:10,780
אז הפונקציות האלה הולכים להמשיך לגדול עד שלבסוף פגענו מקרה הבסיס שלנו.

902
00:55:10,780 --> 00:55:17,830
בשלב זה, את ערך ההחזרה של זה הוא התשואה (ערך ההחזרה של זה NX),

903
00:55:17,830 --> 00:55:21,290
ערך ההחזרה של זה nx ערך ההחזרה של זה.

904
00:55:21,290 --> 00:55:23,290
סופו של דבר אנחנו צריכים להכות חלק המספר.

905
00:55:23,290 --> 00:55:26,560
בראש כאן, אנחנו אומרים בתמורה 1.

906
00:55:26,560 --> 00:55:30,650
זה אומר שברגע שאנחנו חוזרים מספר זה, אנחנו יכולים לפוצץ זה את המחסנית.

907
00:55:30,650 --> 00:55:36,570
אז זה עצרת (1) נעשה.

908
00:55:36,570 --> 00:55:41,190
כשחוזר 1, (1) חוזר פקטוריאליים זה, ההחזרה ל1.

909
00:55:41,190 --> 00:55:46,910
ערך ההחזרה של זה, יש לזכור, היה nx ערך ההחזרה של זה.

910
00:55:46,910 --> 00:55:50,720
אז פתאום, הבחור הזה יודע שאני רוצה לחזור 2.

911
00:55:50,720 --> 00:55:55,910
>> אז תזכור, להחזיר ערך של זה הוא פשוט nx ערך ההחזרה לכאן.

912
00:55:55,910 --> 00:56:01,160
אז עכשיו אנחנו יכולים להגיד 3 X 2, ולבסוף, כאן אנו יכולים לומר

913
00:56:01,160 --> 00:56:04,010
זה פשוט הולך להיות 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
וברגע שחוזר זה, שניגשנו לבתוך שלם אחד עיקרי.

915
00:56:09,570 --> 00:56:15,460
כל שאלות ברקורסיה?

916
00:56:15,460 --> 00:56:17,090
בסדר. אז יש עוד זמן לשאלות בסוף,

917
00:56:17,090 --> 00:56:23,360
אבל עכשיו יוסף יכסה את הנושאים שנותרו.

918
00:56:23,360 --> 00:56:25,590
>> [יוסף אונג] בסדר. אז עכשיו שאנחנו כבר דברנו על recursions,

919
00:56:25,590 --> 00:56:27,840
בואו נדבר קצת על מה הוא למזג מיון.

920
00:56:27,840 --> 00:56:31,740
סוג המיזוג הוא בעצם דרך נוספת למיון רשימת המספרים.

921
00:56:31,740 --> 00:56:36,430
ואיך זה עובד היא, עם סוג המיזוג יש לך רשימה, ומה שאנחנו עושים הם

922
00:56:36,430 --> 00:56:39,120
אנחנו אומרים, בואו פיצול זה ל 2 חצי.

923
00:56:39,120 --> 00:56:42,750
אנו נפעיל 1 למזג מיון שוב בחלק השמאלי,

924
00:56:42,750 --> 00:56:45,040
אז להפעיל למזג מיון בחצי הימני,

925
00:56:45,040 --> 00:56:50,240
וזה נותן לנו עכשיו 2 חצי הממוינים, ועכשיו אנחנו הולכים לשלב חצאים אלה יחד.

926
00:56:50,240 --> 00:56:55,010
זה קצת קשה לראות בלי דוגמה, אז אצטרך לעבור את התנועות ולראות מה קורה.

927
00:56:55,010 --> 00:56:59,590
אז אתה מתחיל עם רשימה זו, אנו לפצל אותו ל 2 חצי.

928
00:56:59,590 --> 00:57:02,300
אנחנו רצים למזג מיון בחלק השמאלי ראשון.

929
00:57:02,300 --> 00:57:06,660
אז זה את חלקו השמאלי, ועכשיו אנחנו מריצים אותם דרך רשימה זו שוב

930
00:57:06,660 --> 00:57:09,800
אשר מקבל עבר למעין מיזוג, ולאחר מכן אנחנו נראים, שוב,

931
00:57:09,800 --> 00:57:13,270
בצד השמאל של רשימה זו ואנחנו רצים למזג מיון על זה.

932
00:57:13,270 --> 00:57:15,880
עכשיו, אנחנו ניגשים לרשימה של 2 מספרים,

933
00:57:15,880 --> 00:57:19,010
ועכשיו את חלקו השמאלי הוא האלמנט היחיד 1 זמן, ואנחנו לא יכולים

934
00:57:19,010 --> 00:57:23,380
פיצול רשימה שרק 1 גורם למחצית, אז אנחנו פשוט אומרים, ברגע שיש לנו 50,

935
00:57:23,380 --> 00:57:26,400
וזה רק אלמנט 1, זה כבר מסודר.

936
00:57:26,400 --> 00:57:29,860
>> ברגע שנסיים עם זה, אנו יכולים לראות שאנחנו יכולים

937
00:57:29,860 --> 00:57:32,230
לעבור למחצית הימנית של רשימה זו,

938
00:57:32,230 --> 00:57:36,480
ו 3 גם הם מסודר, ואז עכשיו ששני החצאים של רשימה זו מסודרים

939
00:57:36,480 --> 00:57:39,080
אנחנו יכולים להצטרף למספרים האלה בחזרה.

940
00:57:39,080 --> 00:57:45,320
אז אנחנו מסתכלים 50 ו 3; 3 הם קטנים יותר מ 50, כך שהוא נכנס ראשון ולאחר מכן 50 נכנס

941
00:57:45,320 --> 00:57:49,340
עכשיו, שזה נעשה, אנחנו חוזרים לאותה רשימה וסוג זה חצי נכון.

942
00:57:49,340 --> 00:57:52,440
42 הם מספר משלו, כך שזה כבר נפתר.

943
00:57:52,440 --> 00:57:57,850
אז עכשיו אנחנו להשוות אלה 2 ו 3 קטנים מ 42, כך שמקבל לשים בראשון,

944
00:57:57,850 --> 00:58:02,340
היום בן 42 מקבל את שלו ובמקבל 50 מכניסים פנימה

945
00:58:02,340 --> 00:58:07,220
עכשיו, זה מסודר, אנחנו הולכים את כל הדרך חזרה לחלק העליון, 1337 ו 15.

946
00:58:07,220 --> 00:58:14,560
ובכן, עכשיו אנחנו מסתכלים על חיצו השמאלי של רשימה זו; 1337 הן על ידי עצמו, כך שהוא מסודר ואותו דבר עם 15.

947
00:58:14,560 --> 00:58:19,020
אז עכשיו אנחנו משלבים 2 המספרים האלה כדי למיין שרשימה מקורית, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
כך זה ממשיך בראשון, אז 1337 הולכים פנימה

949
00:58:23,060 --> 00:58:26,640
ועכשיו אנחנו מסודרים שני החצאים של הרשימה המקורית למעלה.

950
00:58:26,640 --> 00:58:30,440
וכל מה שאנחנו צריכים לעשות הוא לשלב אלה.

951
00:58:30,440 --> 00:58:36,890
אנחנו מסתכלים על 2 המספרים הראשונים של רשימה זו, 3 <15, כך זה נמשך לתוך מערך הסוג ראשון.

952
00:58:36,890 --> 00:58:44,460
15 <42, כך שזה נכנס עכשיו, 42 <1337, שהולך פנימה

953
00:58:44,460 --> 00:58:51,010
50 <1337, כך שזה נכנס ושמים לב שאנחנו רק לקחנו את 2 מספרים של רשימה זו.

954
00:58:51,010 --> 00:58:53,640
אז אנחנו לא רק לסירוגין בין 2 הרשימות.

955
00:58:53,640 --> 00:58:56,050
אנחנו פשוט מחפשים בהתחלה, ואנחנו לוקחים את האלמנט

956
00:58:56,050 --> 00:59:00,270
זה קטן יותר ולאחר מכן לשים אותו לתוך המערך שלנו.

957
00:59:00,270 --> 00:59:04,080
עכשיו אנחנו כבר התמזגנו כל המחציות ואנחנו נעשינו.

958
00:59:04,080 --> 00:59:07,780
>> שאלות לגבי למזג מיון? כן?

959
00:59:07,780 --> 00:59:14,190
[סטודנטים] אם זה התפצלות לקבוצות שונות, למה הם לא רק לפצל אותו פעם אחת

960
00:59:14,190 --> 00:59:19,970
ויש לך 3 ו 2 בקבוצה? [שאר מובן שאלה]

961
00:59:19,970 --> 00:59:24,940
הסיבה - אז השאלה היא, למה אנחנו לא יכולים פשוט למזג אותם בצעד הראשון שאחרי יש לנו אותם?

962
00:59:24,940 --> 00:59:29,530
הסיבה שאנחנו יכולים לעשות את זה, להתחיל בשמאל רוב האלמנטים של שני הצדדים,

963
00:59:29,530 --> 00:59:33,040
ואז לקחת את אחד הקטן ולשים אותו ב, הוא שאנו יודעים אלה ש

964
00:59:33,040 --> 00:59:35,290
רשימות בודדות הן בהזמנות ממוינות.

965
00:59:35,290 --> 00:59:37,290
אז אם אני מסתכל על שמאל רוב האלמנטים של שני חצי,

966
00:59:37,290 --> 00:59:40,490
אני יודע שהם הולכים להיות האלמנטים הקטנים ביותר של רשימות אלה.

967
00:59:40,490 --> 00:59:43,930
אז אני יכול להכניס אותם לנקודתי היסוד הקטנות ביותר של הרשימה גדולה הזאת.

968
00:59:43,930 --> 00:59:47,810
מצד השני, אם אני מסתכל על 2 הרשימות האלה ברמה השנייה שם,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 ו 15, אלה אינם ממוינים.

970
00:59:51,640 --> 00:59:55,770
אז אם אני מסתכל על 50 ו1337, אני הולך לשים 50 לרשימה שלי ראשון.

971
00:59:55,770 --> 01:00:00,130
אבל זה לא ממש הגיוני, כי 3 הם הרכיב הקטן ביותר מתוך כל אלה.

972
01:00:00,130 --> 01:00:04,390
אז הסיבה היחידה שאנחנו יכולים לעשות צעד זה בגלל שילוב של הרשימות שלנו כבר מסודרות.

973
01:00:04,390 --> 01:00:07,010
וזו הסיבה שיש לנו כדי לקבל את כל הדרך עד לתחתית

974
01:00:07,010 --> 01:00:09,800
כי כאשר יש לנו רק מספר אחד, אתה יודע שמספר בודד

975
01:00:09,800 --> 01:00:14,120
בפני עצמו הוא כבר רשימה ממוינת.

976
01:00:14,120 --> 01:00:19,360
>> יש שאלות? לא?

977
01:00:19,360 --> 01:00:24,260
מורכבות? ובכן, אתה יכול לראות את זה בכל שלב יש מספרים סופיים,

978
01:00:24,260 --> 01:00:27,590
ואנחנו יכולים לחלק את רשימה ביומן 1/2 n פעמים,

979
01:00:27,590 --> 01:00:31,700
המקום שבו אנחנו מקבלים יומן זה n x n מורכבות.

980
01:00:31,700 --> 01:00:34,940
ותראה במקרה הטוב לסוג המיזוג הוא n log n, וזה פשוט כל כך קורה

981
01:00:34,940 --> 01:00:39,340
שהמקרה הגרוע ביותר, או Ω שם, גם n log n.

982
01:00:39,340 --> 01:00:42,480
משהו שכדאי לזכור.

983
01:00:42,480 --> 01:00:45,750
ההעברה ב, בואו נלך לחלק הקובץ בסיסי Super I / O.

984
01:00:45,750 --> 01:00:48,830
אם היית מסתכל על מירוץ, תוכל להבחין שיש לנו סוג מסוים של מערכת

985
01:00:48,830 --> 01:00:51,270
שבו אתה יכול לכתוב לקובץ יומן אם אתה קורא את הקוד.

986
01:00:51,270 --> 01:00:53,730
בואו לראות איך אפשר לעשות את זה.

987
01:00:53,730 --> 01:00:57,450
ובכן, יש לנו fprintf, שאתה יכול לחשוב עליו כפשוט printf,

988
01:00:57,450 --> 01:01:01,720
אבל פשוט מדפיס לקובץ במקום, ולכן f בהתחלה.

989
01:01:01,720 --> 01:01:07,570
סוג של קוד זה לכאן, מה שהיא עושה הוא, כפי שאולי ראה במירוץ,

990
01:01:07,570 --> 01:01:12,310
הוא עובר הדפסת המערך 2-הממדית שלכם את השורה אחרת השורה מה המספרים.

991
01:01:12,310 --> 01:01:17,850
במקרה זה, printf מדפיס למסוף שלך או מה שאנו מכנים את הפלט הסטנדרטי של סעיף.

992
01:01:17,850 --> 01:01:22,170
>> ועכשיו, במקרה זה, כל מה שאנחנו צריכים לעשות הוא להחליף את printf עם fprintf,

993
01:01:22,170 --> 01:01:26,770
אומר לו מה קובץ שאתה רוצה להדפיס, ובמקרה הזה זה פשוט מדפיס אותו כדי שהקובץ

994
01:01:26,770 --> 01:01:32,230
במקום להדפיס אותו למסוף שלך.

995
01:01:32,230 --> 01:01:36,500
טוב, אז שמעלה את השאלה: איפה אנחנו מקבלים את זה סוג של קובץ מ, נכון?

996
01:01:36,500 --> 01:01:39,840
עברנו להיכנס לfuction fprintf זה אבל לא היה לנו מושג מהאיפה זה בא.

997
01:01:39,840 --> 01:01:43,980
ובכן, בשלב המוקדם של הקוד, מה שהיינו לנו היה זה נתח של קוד לכאן,

998
01:01:43,980 --> 01:01:48,340
אשר בעצם אומר שפתוח קובץ שיחות Log.Txt.

999
01:01:48,340 --> 01:01:53,220
מה שאנחנו עושים אחרי שיש לנו הוא לוודא שהקובץ נפתח ממש בהצלחה.

1000
01:01:53,220 --> 01:01:57,070
אז זה עלול להיכשל מסיבות רבות, אין לך מספיק מקום במחשב שלך, למשל.

1001
01:01:57,070 --> 01:01:59,790
אז זה תמיד חשוב לפני שאתה עושה את כל פעולות עם הקובץ

1002
01:01:59,790 --> 01:02:03,300
שאנחנו בודקים אם הקובץ שנפתח בהצלחה.

1003
01:02:03,300 --> 01:02:09,330
אז מה ש, זה טיעון לfopen, ובכן, אנחנו יכולים לפתוח תיק בדרכים רבות.

1004
01:02:09,330 --> 01:02:13,510
מה אנחנו יכולים לעשות, אנחנו יכולים להעביר את זה w, כלומר לעקוף את הקובץ אם יציאתו כבר,

1005
01:02:13,510 --> 01:02:18,070
אנחנו יכולים לעבור, שהם יצורפו לסוף של הקובץ במקום דריסתו,

1006
01:02:18,070 --> 01:02:22,730
או שאנחנו יכולים לציין r, מה שאומר, בואו לפתוח את הקובץ לקריאה בלבד.

1007
01:02:22,730 --> 01:02:24,890
אז אם התכנית מנסה לבצע שינויים בקובץ,

1008
01:02:24,890 --> 01:02:30,140
צועק עליהם ולא נותנים להם לעשות את זה.

1009
01:02:30,140 --> 01:02:33,320
לבסוף, לאחר שנסיים עם הקובץ, תסיים עושה פעולות עליו,

1010
01:02:33,320 --> 01:02:35,860
אנחנו צריכים לוודא שאנחנו סוגרים את הקובץ.

1011
01:02:35,860 --> 01:02:38,830
וכך בסוף התכנית שלך, אתה הולך לעבור אותם שוב

1012
01:02:38,830 --> 01:02:42,120
זה קובץ שנפתחת, ופשוט לסגור אותו.

1013
01:02:42,120 --> 01:02:44,650
אז זה משהו חשוב שאתה צריך לוודא שאתה עושה.

1014
01:02:44,650 --> 01:02:47,180
אז זכור שאתה יכול לפתוח את קובץ, ואז אתה יכול לכתוב לקובץ,

1015
01:02:47,180 --> 01:02:51,270
לעשות פעולות בתיק, אבל אז אתה צריך לסגור את התיק בסוף.

1016
01:02:51,270 --> 01:02:53,270
>> כל שאלות בקובץ בסיסי קלט / פלט? כן?

1017
01:02:53,270 --> 01:02:58,050
[שאלת סטודנט, לא מובן]

1018
01:02:58,050 --> 01:03:02,480
ממש כאן. השאלה היא, איפה קובץ זה מופיע Log.Txt?

1019
01:03:02,480 --> 01:03:07,890
ובכן, אם אתה רק נותן לו Log.Txt, הוא יוצר אותו באותה הספרייה כמו קובץ ההפעלה.

1020
01:03:07,890 --> 01:03:10,500
אז אם אתה - >> [שאלת סטודנט, לא מובן]

1021
01:03:10,500 --> 01:03:18,830
כן. באותה התיקייה, או באותה ספרייה, כפי שאתה קורא לזה.

1022
01:03:18,830 --> 01:03:21,400
עכשיו זיכרון, מחסנית, וערימה.

1023
01:03:21,400 --> 01:03:23,400
אז איך הוא זיכרון שהותווה במחשב?

1024
01:03:23,400 --> 01:03:26,270
ובכן, אתה יכול לדמיין את הזיכרון כסוג של הבלוק הזה כאן.

1025
01:03:26,270 --> 01:03:30,260
ובזיכרון שיש לנו מה שנקרא הגל תקועים שם, והמחסנית שנמצאה שם.

1026
01:03:30,260 --> 01:03:34,480
והערימה גדלה כלפי מטה והמחסנית גדלה כלפי מעלה.

1027
01:03:34,480 --> 01:03:38,620
אז כפי שהוזכר טומי - הו, כן, ויש לנו 4 מקטעים אלה אחרים שאני אגיע לשני -

1028
01:03:38,620 --> 01:03:42,890
כשטומים אמרו קודם, אתה יודע איך קוראים לעצמם התפקידים וקוראים אחד לשני?

1029
01:03:42,890 --> 01:03:44,930
הם בונים את המסגרת מסוג כזה מחסנית.

1030
01:03:44,930 --> 01:03:47,360
ובכן, אם foo שיחות עיקריות, foo מקבל לשים על הערימה.

1031
01:03:47,360 --> 01:03:52,430
Foo קורא בר, בר לקבל נלבשנו את המחסנית, ושמקבל לשים על הערימה לאחר.

1032
01:03:52,430 --> 01:03:57,040
וכשהם חוזרים, הם כל אחד מאתנו לקחו את המחסנית.

1033
01:03:57,040 --> 01:04:00,140
מה כל אחד מהמקומות הללו וזיכרון להחזיק?

1034
01:04:00,140 --> 01:04:03,110
ובכן, העליון, שהנו מגזר הטקסט, מכיל את התכנית עוצמה.

1035
01:04:03,110 --> 01:04:06,390
אז את הקוד המכונה, ששם, ברגע שאתה לקמפל את התכנית שלך.

1036
01:04:06,390 --> 01:04:08,520
בשלב הבא, כל אותחלו משתנים גלובליים.

1037
01:04:08,520 --> 01:04:12,660
>> אז יש לך משתנה גלובלי בתכנית שלך, ואתה אומר כמו, = 5,

1038
01:04:12,660 --> 01:04:15,260
שמקבל לשים במגזר זה, וממש מתחת לזה,

1039
01:04:15,260 --> 01:04:18,990
יש לך את כל נתונים מאותחלים גלובליים, אשר רק int,

1040
01:04:18,990 --> 01:04:20,990
אבל אתה לא אומר שזה שווה משהו.

1041
01:04:20,990 --> 01:04:23,870
מבין אלה הם משתנים גלובליים, ולכן הם מחוץ לראשיים.

1042
01:04:23,870 --> 01:04:28,560
אז זה אומר שכל משתנים גלובליים שהוכרזו אך לא אותחלו.

1043
01:04:28,560 --> 01:04:32,310
אז מה יש בערימה? זיכרון שהוקצה באמצעות malloc, אשר יגיע לקצת.

1044
01:04:32,310 --> 01:04:35,990
ולבסוף, עם המחסנית יש לך משתנים מקומיים

1045
01:04:35,990 --> 01:04:39,950
וכל פונקציות שאפשר לקרוא בכל הפרמטרים.

1046
01:04:39,950 --> 01:04:43,720
הדבר האחרון, אתה לא באמת צריך לדעת מה את משתני הסביבה לעשות,

1047
01:04:43,720 --> 01:04:46,700
אבל בכל פעם שאתה מפעיל תכנית, יש משהו הקשור, כמו

1048
01:04:46,700 --> 01:04:49,550
זה הוא שם המשתמש של האדם שנהל את התכנית.

1049
01:04:49,550 --> 01:04:51,550
וזה הולך להיות סוג של בתחתית.

1050
01:04:51,550 --> 01:04:54,540
במונחים של כתובות זיכרון, שהם ערכים הקסדצימליים של,

1051
01:04:54,540 --> 01:04:58,170
הערכים בתחילה העליונה ב 0, והם הולכים את כל הדרך עד לתחתית.

1052
01:04:58,170 --> 01:05:00,440
במקרה זה, אם אתה על המערכה 32-bit,

1053
01:05:00,440 --> 01:05:05,390
הכתובת בתחתית הולכת להיות 0x, ואחרי af, כי זה 32 סיבי,

1054
01:05:05,390 --> 01:05:10,890
אשר הם 8 בתים, ובמקרה זה 8 בתים מתאימים ל8 ספרות הקסדצימליים.

1055
01:05:10,890 --> 01:05:20,110
אז פה אתה הולך, משהו כמו, 0xffffff, ושם למעלה אתה הולך יש 0.

1056
01:05:20,110 --> 01:05:23,660
אז מה הם מצביע? חלק מכם אולי לא כיסה את זה בסעיף קודם.

1057
01:05:23,660 --> 01:05:26,660
אבל אנחנו לא נעבור על זה בהרצאה, כך מצביע הוא בדיוק סוג נתונים

1058
01:05:26,660 --> 01:05:34,030
אילו חנויות, במקום איזשהו ערך כמו 50, הוא מאחסן את הכתובת של מיקום מסוים בזיכרון.

1059
01:05:34,030 --> 01:05:36,020
כמו שהזיכרון [לא מובן].

1060
01:05:36,020 --> 01:05:41,120
אז במקרה הזה, מה שיש לנו הוא, שיש לנו מצביע למספר שלם או * int,

1061
01:05:41,120 --> 01:05:46,210
והוא מכיל את כתובה הקסדצימלי זה של 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> אז מה יש לנו הוא, עכשיו, הצביע מצביע זה במיקום מסוים בזיכרון,

1063
01:05:50,880 --> 01:05:56,020
וזה בדיוק, הערך 50 הוא במיקום בזיכרון הזה.

1064
01:05:56,020 --> 01:06:01,810
בחלק מהמערכות של 32-bit, בכל המערכות של 32-bit, מצביעים לקחת עד 32 סיביים או 4 בתים.

1065
01:06:01,810 --> 01:06:06,020
אבל, לדוגמה, על מערכה 64-bit, מצביעים הם 64 סיביים.

1066
01:06:06,020 --> 01:06:08,040
אז זה משהו שאתה רוצה לזכור.

1067
01:06:08,040 --> 01:06:12,310
אז בסופו של דבר מערכת סיבית, מצביע הוא פיסות קצה ארוך.

1068
01:06:12,310 --> 01:06:17,320
מצביעים הם מסוג שקשה לעכל בלי דברים מיותרים,

1069
01:06:17,320 --> 01:06:20,300
אז בואו נעבור על דוגמה של הקצאת זיכרון דינמית.

1070
01:06:20,300 --> 01:06:25,130
הקצאת זיכרון דינמית מה עושה לך, או מה שאנו מכנים malloc,

1071
01:06:25,130 --> 01:06:29,280
זה מאפשר לך להקצות איזה נתונים מחוץ לסט.

1072
01:06:29,280 --> 01:06:31,830
אז נתון זה הוא סוג של יותר קבוע במשך תקופת התכנית.

1073
01:06:31,830 --> 01:06:36,430
כי כפי שאתה יודע, אם אתה מצהיר x בתוך של פונקציה והפונקציה שמחזירה,

1074
01:06:36,430 --> 01:06:40,910
אין לך יותר גישה לנתונים שאוחסנו בx.

1075
01:06:40,910 --> 01:06:44,420
מה מצביעים תנו לנו לעשות הוא שהם נותנים לנו לאחסן ערכי זיכרון או בחנות

1076
01:06:44,420 --> 01:06:46,840
בקטע אחר של זיכרון, כלומר הערימה.

1077
01:06:46,840 --> 01:06:49,340
עכשיו ברגע שנחזור מפונקציה, כל עוד יש לנו מצביע

1078
01:06:49,340 --> 01:06:54,960
למיקום זה בזיכרון, ואז מה שאנחנו יכולים לעשות זה אנחנו יכולים רק להסתכל על הערכים שם.

1079
01:06:54,960 --> 01:06:58,020
בואו נסתכל על דוגמה: זוהי פריסת הזיכרון שלנו שוב.

1080
01:06:58,020 --> 01:07:00,050
ויש לנו בפונקציה זו, עיקרי.

1081
01:07:00,050 --> 01:07:06,870
מה שהוא עושה זה - בסדר, כל כך פשוט, נכון -? Int x = 5, זה רק משתנה במחסנית בראשית.

1082
01:07:06,870 --> 01:07:12,450
>> מצד השני, עכשיו אנחנו מצהירים מצביע שקורא את giveMeThreeInts הפונקציות.

1083
01:07:12,450 --> 01:07:16,800
ואז עכשיו אנחנו נכנסים לפונקציה זו ואנו יוצרים מסגרת מחסנית חדשה עבורו.

1084
01:07:16,800 --> 01:07:20,440
עם זאת, במסגרת מערך זה, אנו מצהירים * int temp,

1085
01:07:20,440 --> 01:07:23,210
אשר ב3 מספרים שלמים mallocs עבורנו.

1086
01:07:23,210 --> 01:07:25,880
אז הגודל של int ייתן לנו כמה בתי int זה,

1087
01:07:25,880 --> 01:07:29,620
וmalloc נותן לנו שבתים רבים של החלל בערמה.

1088
01:07:29,620 --> 01:07:32,890
אז במקרה הזה, יצר מספיק מקום עבור 3 מספרים שלמים,

1089
01:07:32,890 --> 01:07:36,830
והערימה היא דרך לשם, וזו הסיבה שאני נמשך זה למעלה.

1090
01:07:36,830 --> 01:07:42,900
ברגע שנסיים, אנחנו חוזרים לכאן, אתה צריך רק 3 ints חזר,

1091
01:07:42,900 --> 01:07:47,000
וזה מחזיר את הכתובת, במקרה זה שבו על זיכרון זה.

1092
01:07:47,000 --> 01:07:51,250
ואנו קובעים מצביע = מתג, ושם יש לנו רק מצביע אחר.

1093
01:07:51,250 --> 01:07:54,550
אבל מה שמחזיר פונקציה הוא נערם כאן ונעלם.

1094
01:07:54,550 --> 01:07:59,250
אז טמפ נעלם, אבל אנחנו עדיין לשמור את הכתובת שבי

1095
01:07:59,250 --> 01:08:01,850
3 השלמים האלה הם פנימיים של רשת חשמל.

1096
01:08:01,850 --> 01:08:06,180
אז בקבוצה הזאת, המצביעים הם scoped מקומי למסגרת המוערמת,

1097
01:08:06,180 --> 01:08:09,860
אבל הזיכרון שאליו הם מתייחסים הוא בערימה.

1098
01:08:09,860 --> 01:08:12,190
>> האם זה הגיוני?

1099
01:08:12,190 --> 01:08:14,960
[סטודנטים] האם אתה יכול לחזור על זה? >> [יוסף] כן.

1100
01:08:14,960 --> 01:08:20,270
אז אם אני חוזר רק קצת, אתה רואה שטמפ הוקצה

1101
01:08:20,270 --> 01:08:23,500
כמה זיכרון על הערימה שם למעלה.

1102
01:08:23,500 --> 01:08:28,680
לכן, כאשר בפונקציה זו, giveMeThreeInts חזרות, מחסנית זה כאן הולכת להיעלם.

1103
01:08:28,680 --> 01:08:35,819
ועם זה אף אחד מהמשתנים, במקרה זה, מצביע זה שהוקצה במסגרת מוערמת.

1104
01:08:35,819 --> 01:08:39,649
כי הוא הולך להיעלם, אבל מאז שחזרנו טמפ

1105
01:08:39,649 --> 01:08:46,330
ואנו קובעים מצביע = temp, מצביע כעת הולך להושיט אותו הזיכרון של מיקום כזמני היה.

1106
01:08:46,330 --> 01:08:50,370
אז עכשיו, למרות שאנחנו מאבדים זמניים, שמצביע מקומי,

1107
01:08:50,370 --> 01:08:59,109
אנחנו עדיין שומרים את כתובת הזיכרון של מה שהיה מצביע על חלק פנימי של שהמצביע משתנה.

1108
01:08:59,109 --> 01:09:03,740
שאלות? זה יכול להיות סוג של נושא מבלבל אם לא עבר על זה בסעיף.

1109
01:09:03,740 --> 01:09:09,240
אנחנו יכולים, TF שלך בהחלט ללכת על זה וכמובן שאנחנו יכולים לענות על שאלות

1110
01:09:09,240 --> 01:09:11,500
בסיומה של פגישת הביקורת על כך.

1111
01:09:11,500 --> 01:09:14,220
אבל זה סוג של נושא מורכב, ויש לי עוד דוגמאות, כי הם הולכים להופיע

1112
01:09:14,220 --> 01:09:18,790
שיעזרו להבהיר את מה שהמצביעים בפועל.

1113
01:09:18,790 --> 01:09:22,500
>> במקרה זה, מצביעים הם שווים ערך למערכים,

1114
01:09:22,500 --> 01:09:25,229
אז אני פשוט יכול להשתמש בזה כמצביע אותו הדבר כמו מערך int.

1115
01:09:25,229 --> 01:09:29,840
אז אני לאינדקס 0, ושינוי המספר השלם הראשון ש1,

1116
01:09:29,840 --> 01:09:39,689
שינוי המספר שלם 2 ל 2, והמספר השלם 3 עד 3.

1117
01:09:39,689 --> 01:09:44,210
נוסף על כך מצביעים. ובכן, זוכר בינקי.

1118
01:09:44,210 --> 01:09:48,319
במקרה זה יש לנו הוקצה מצביע, או שהכרזנו מצביע,

1119
01:09:48,319 --> 01:09:52,760
אבל בהתחלה, כשרק הצהרתי מצביע, זה לא מצביע על כל מקום בזיכרון.

1120
01:09:52,760 --> 01:09:54,930
זה רק ערכי זבל שבתוכה.

1121
01:09:54,930 --> 01:09:56,470
אז אין לי מושג איפה זה מצביע כדי להצביע.

1122
01:09:56,470 --> 01:10:01,630
יש כתובת שפשוט מלאה בספרות 0 ו 1 של במקום בו היה מוצהר.

1123
01:10:01,630 --> 01:10:04,810
אני לא יכול לעשות שום דבר עם זה עד שאני קורא על זה malloc

1124
01:10:04,810 --> 01:10:08,390
ואז זה נותן לי מעט מקום על הערימה שבו אני יכול לשים את הערכים פנימה.

1125
01:10:08,390 --> 01:10:11,980
אז שוב, אני לא יודע מה יש בפנים בזיכרון הזה.

1126
01:10:11,980 --> 01:10:16,780
אז הדבר הראשון שצריך לעשות הוא לבדוק אם המערכת הייתה מספיק זיכרון

1127
01:10:16,780 --> 01:10:20,850
שיחזיר לי שלם 1 במקום הראשון, ולכן אני עושה את זה לבדוק.

1128
01:10:20,850 --> 01:10:25,020
אם המצביע הוא ריק, זה אומר שזה לא היה לי מספיק מקום או איזו שגיאה אחרת התרחשה,

1129
01:10:25,020 --> 01:10:26,320
אז אני צריך לצאת מהתכנית שלי.

1130
01:10:26,320 --> 01:10:29,400
 אבל אם זה יצליח, עכשיו אני יכול להשתמש במצביע כי

1131
01:10:29,400 --> 01:10:35,020
ומה מצביע * עושה זה כדלקמן בי הכתובת היא

1132
01:10:35,020 --> 01:10:38,480
למקום שבו הערך, והיא מגדירה אותו שווה ל 1.

1133
01:10:38,480 --> 01:10:41,850
אז הנה, אנחנו בודקים אם זיכרון שהיה קיים.

1134
01:10:41,850 --> 01:10:45,380
>> ברגע שאתה יודע שהוא קיים, אתה יכול להשקיע בזה

1135
01:10:45,380 --> 01:10:50,460
מה ערך שאתה רוצה להכניס אותו, ובמקרה זה 1.

1136
01:10:50,460 --> 01:10:53,060
ברגע שנסיים עם זה, אתה צריך לשחרר שמצביע

1137
01:10:53,060 --> 01:10:57,160
כי אנחנו צריכים לחזור למערכת שהזיכרון שבקשת במקום הראשון.

1138
01:10:57,160 --> 01:10:59,690
משום שהמחשב לא יודע מתי שנסיים עם זה.

1139
01:10:59,690 --> 01:11:02,510
במקרה זה אנחנו במפורש אומרים לה, בסדר, אנחנו גמרנו עם זה זיכרון.

1140
01:11:02,510 --> 01:11:10,780
אם חלק תהליך אחר צריך את זה, תכנית אחרת צריכה את זה, ירגיש חופשי ללכת קדימה ולקחת אותו.

1141
01:11:10,780 --> 01:11:15,110
מה שאנו כן יכולים לעשות הוא פשוט יכולים לקבל את הכתובת של משתנים מקומיים על הסט.

1142
01:11:15,110 --> 01:11:19,080
x אז int הוא בתוך המסגרת של ערמה ראשי.

1143
01:11:19,080 --> 01:11:23,060
וכאשר אנו משתמשים אמפרסנד זה, והמפעיל, מה שהוא עושה הוא

1144
01:11:23,060 --> 01:11:27,310
זה לוקח x, ו-x הוא רק כמה נתונים בזיכרון, אבל יש לו כתובת.

1145
01:11:27,310 --> 01:11:33,790
זה נמצא איפשהו. זאת על ידי הקריאה וx, מה המשמעות של זה הוא שזה נותן לנו את הכתובת של x.

1146
01:11:33,790 --> 01:11:38,430
בעשותם זאת, אנחנו עושים את הנקודה מצביעה לכאשר x הוא בזיכרון.

1147
01:11:38,430 --> 01:11:41,710
עכשיו אנחנו פשוט משהו כמו * x, אנחנו הולכים לקבל בחזרה 5.

1148
01:11:41,710 --> 01:11:43,820
הכוכב נקרא ביטול הפניה זה.

1149
01:11:43,820 --> 01:11:46,640
אתה עוקב כתובת ואתה מקבל את הערך שלו מאוחסן שם.

1150
01:11:51,000 --> 01:11:53,310
>> יש שאלות? כן?

1151
01:11:53,310 --> 01:11:56,500
[סטודנטים] אם אתה לא עושה את הדבר 3-המחודד, זה עדיין לקמפל?

1152
01:11:56,500 --> 01:11:59,490
כן. אם אתה לא עושה את הדבר 3-המצביע, זה עדיין הולך להדר,

1153
01:11:59,490 --> 01:12:02,720
אבל אני אראה לך מה קורה ברגע אחד, ובלי לעשות את זה,

1154
01:12:02,720 --> 01:12:04,860
זה מה שאנו מכנים דליפת זיכרון. את לא נותן למערכת

1155
01:12:04,860 --> 01:12:07,850
לגבות את הזיכרון שלה, ולכן לאחר זמן שהתכנית הולכת לצבור

1156
01:12:07,850 --> 01:12:10,940
הזיכרון שהוא לא משתמש, ושום דבר אחר לא יכול להשתמש בו.

1157
01:12:10,940 --> 01:12:15,750
אם אי פעם ראה אתר על 1.5 מיליון ק"ג במחשב שלך,

1158
01:12:15,750 --> 01:12:17,840
במנהל המשימות, זה מה שקורה.

1159
01:12:17,840 --> 01:12:20,760
יש לך דליפת זיכרון בתכנית שהם לא מטפלים.

1160
01:12:23,080 --> 01:12:26,240
אז איך עושה את מצביע עבודת חשבון?

1161
01:12:26,240 --> 01:12:29,480
ובכן, חשבון מצביע הוא סוג של אינדוקס כמו במערך.

1162
01:12:29,480 --> 01:12:36,370
במקרה זה, יש לי מצביע, ומה שאני עושה זה להפוך את הנקודה של מצביע על הרכיב הראשון

1163
01:12:36,370 --> 01:12:42,100
מזה מערך של 3 מספרים שלמים, כי אני כבר הוקציתי לה.

1164
01:12:42,100 --> 01:12:46,670
אז עכשיו מה שאני עושה, מצביע כוכב רק משנה את המרכיב הראשון ברשימה.

1165
01:12:46,670 --> 01:12:49,140
כוכב מצביע +1 נקודות כאן.

1166
01:12:49,140 --> 01:12:53,140
אז מצביע הוא כאן, המצביע +1 הוא כאן, מצביע 2 נגמר כאן.

1167
01:12:53,140 --> 01:12:56,610
>> אז רק מוסיף 1 הוא אותו הדבר כמו נע לאורך מערך זה.

1168
01:12:56,610 --> 01:12:59,880
מה שאנחנו עושים הוא, כאשר אנחנו עושים מצביע 1 אתה מקבל את הכתובת לכאן,

1169
01:12:59,880 --> 01:13:04,180
וכדי לקבל את הערך לכאן, אתה שם כוכב בכל הביטוי

1170
01:13:04,180 --> 01:13:05,990
לdereference.

1171
01:13:05,990 --> 01:13:09,940
לכן, במקרה זה, אני מגדיר את המיקום הראשון במערך זה ל1,

1172
01:13:09,940 --> 01:13:13,970
מיקום שני ל 2, ומיקום שלישי 3.

1173
01:13:13,970 --> 01:13:18,180
אז מה אני עושה כאן הוא שאני מדפיס מצביענו +1,

1174
01:13:18,180 --> 01:13:19,970
שרק נותן לי 2.

1175
01:13:19,970 --> 01:13:23,650
עכשיו אני הגדלת מצביע, ולכן שווה מצביע מצביע +1,

1176
01:13:23,650 --> 01:13:26,780
שמעביר אותו קדימה.

1177
01:13:26,780 --> 01:13:30,810
ואז עכשיו אם אני מדפיס את המצביע +1, מצביע +1 הוא כעת 3,

1178
01:13:30,810 --> 01:13:33,990
אשר במקרה זה יודפס 3.

1179
01:13:33,990 --> 01:13:36,560
וכדי לקבל משהו חינם, המצביע שאני נותן לו

1180
01:13:36,560 --> 01:13:40,540
יש הצבעה בתחילת המערך שחזרתי מmalloc.

1181
01:13:40,540 --> 01:13:43,430
לכן, במקרה זה, אם היינו קורא 3 ממש כאן, זה לא יהיה נכון,

1182
01:13:43,430 --> 01:13:45,070
בגלל שזה באמצע של המערך.

1183
01:13:45,070 --> 01:13:48,820
אני צריך לחסר כדי להגיע למיקום המקורי

1184
01:13:48,820 --> 01:13:50,420
המקום הראשון הראשוני לפני שאני יכול לשחרר אותו.

1185
01:13:56,300 --> 01:13:58,450
אז, הנה דוגמה מורכבת יותר.

1186
01:13:58,450 --> 01:14:03,360
במקרה זה, אנחנו הקצאת 7 תווים במערך תווים.

1187
01:14:03,360 --> 01:14:06,480
>> ובמקרה הזה מה שאנחנו עושים הוא שאנחנו לולאות מעל 1 6 מהם,

1188
01:14:06,480 --> 01:14:09,900
ואנחנו הגדרתם 'עד ת'

1189
01:14:09,900 --> 01:14:13,350
לכן, עבור int i = 0, i> 6, אני + +,

1190
01:14:13,350 --> 01:14:16,220
אז, מצביע + אני פשוט נותן לנו, במקרה זה,

1191
01:14:16,220 --> 01:14:20,860
מצביע, +1 מצביע, +2 מצביע, +3 מצביע, וכן הלאה וכן הלאה בלולאה.

1192
01:14:20,860 --> 01:14:24,040
מהו עומד לעשות הוא שהיא מקבלת כתובת ש, dereferences את זה כדי לקבל את הערך,

1193
01:14:24,040 --> 01:14:27,440
ושינויים שהערך לצ

1194
01:14:27,440 --> 01:14:30,350
אז בסוף תזכור את זה הוא מחרוזת, נכון?

1195
01:14:30,350 --> 01:14:33,560
כל המחרוזות יש לסיים עם אופי הסיום הריק.

1196
01:14:33,560 --> 01:14:38,620
לכן, מה שאני עושה הוא ב6 מצביע שמתי את אופי השליחות הקטלנית null פנימה

1197
01:14:38,620 --> 01:14:43,980
ועכשיו מה בעצם אני עושה כאן הוא יישום printf למחרוזת, נכון?

1198
01:14:43,980 --> 01:14:46,190
>> לכן, כאשר אין printf עכשיו כשזה הגיע לסוף המחרוזת?

1199
01:14:46,190 --> 01:14:48,230
כאשר הוא פוגע באופי הסיום הריק.

1200
01:14:48,230 --> 01:14:52,030
לכן, במקרה זה, הצביע המצביע המקורי שלי לתחילת מערך זה.

1201
01:14:52,030 --> 01:14:56,410
אני מדפיס את התו הראשון. אני מזיז אותה מעל אחד.

1202
01:14:56,410 --> 01:14:58,420
אני מדפיס את התו. אני עובר את זה.

1203
01:14:58,420 --> 01:15:02,180
ואני ממשיך לעשות את זה עד שאני מגיע לסוף.

1204
01:15:02,180 --> 01:15:07,750
ועכשיו המצביע * האם תסיים dereference הזה ולקבל את תו הסיום הריק בחזרה.

1205
01:15:07,750 --> 01:15:11,780
וכך בעוד לולאתי פועלת רק כאשר הערך שאינו דמות הפסקת null.

1206
01:15:11,780 --> 01:15:13,770
אז, עכשיו אני יוצא מהלולאה הזו.

1207
01:15:18,780 --> 01:15:21,180
ואז אם אני לחסר 6 מ מצביע זה,

1208
01:15:21,180 --> 01:15:22,860
אני חוזר כל הדרך עד להתחלה.

1209
01:15:22,860 --> 01:15:27,880
זכור, אני עושה את זה כי אני צריך ללכת להתחלה, על מנת לשחרר אותו.

1210
01:15:27,880 --> 01:15:30,270
>> אז, אני יודע שהיה הרבה. האם יש שאלות?

1211
01:15:30,270 --> 01:15:31,870
בבקשה, כן?

1212
01:15:31,870 --> 01:15:36,610
[לא מובן שאלת סטודנט]

1213
01:15:36,610 --> 01:15:38,190
האם אתה יכול לומר שיותר חזק? סליחה.

1214
01:15:38,190 --> 01:15:44,140
[סטודנטים] בשקופית האחרונה ממש לפני ששחררת את המצביע,

1215
01:15:44,140 --> 01:15:47,300
שבו אתה בעצם שינוי הערך של המצביע?

1216
01:15:47,300 --> 01:15:50,370
[יוסף] אז, ממש כאן. >> [סטודנטים] אה, בסדר.

1217
01:15:50,370 --> 01:15:51,890
[יוסף] לכן, יש לי מצביע מינוס מינוס, ימינה,

1218
01:15:51,890 --> 01:15:54,140
אשר מעביר את הדבר אחורי אחד, ואז לשחרר אותו,

1219
01:15:54,140 --> 01:15:57,000
כי מצביע זה יש הצביע על תחילתו של המערך.

1220
01:15:57,000 --> 01:16:00,420
[סטודנטים] אבל שלא יהיה צורך שהפסקת לאחר שהשורה.

1221
01:16:00,420 --> 01:16:03,130
[יוסף] לכן, אם אני הפסקתי אחרי זה, זה ייחשב דליפת זיכרון,

1222
01:16:03,130 --> 01:16:04,810
כי אני לא רצתי חופשי.

1223
01:16:04,810 --> 01:16:11,290
[סטודנטים] אני [לא מובן] לאחר השלוש השורות הראשונות שבו הייתה לך מצביע +1 [לא מובן].

1224
01:16:11,290 --> 01:16:13,140
[יוסף] אהה. אז מה השאלה שם?

1225
01:16:13,140 --> 01:16:14,780
סליחה. לא, לא. תלך, תלך, בבקשה.

1226
01:16:14,780 --> 01:16:16,870
[סטודנטים] אז, אתה לא משנה את הערך של מצביעים.

1227
01:16:16,870 --> 01:16:19,130
לא היית צריך לעשות מצביע מינוס מינוס.

1228
01:16:19,130 --> 01:16:19,730
[יוסף] כן, בדיוק.

1229
01:16:19,730 --> 01:16:21,890
לכן, כשאני עושה את המצביע +1 ומצביע +2,

1230
01:16:21,890 --> 01:16:24,410
אני לא עושה את המצביע שווה מצביע +1.

1231
01:16:24,410 --> 01:16:27,260
אז, המצביע פשוט נשאר מצביע על תחילתו של המערך.

1232
01:16:27,260 --> 01:16:31,460
זה רק כשאני עושה את תוספת בתוספת שהיא מגדירה את הערך פנימה את המצביע,

1233
01:16:31,460 --> 01:16:33,550
שזה דווקא מרגש את זה יחד.

1234
01:16:36,860 --> 01:16:37,780
בסדר.

1235
01:16:40,550 --> 01:16:42,030
עוד שאלות?

1236
01:16:44,680 --> 01:16:47,790
>> שוב, אם זה סוג של מכריע, זה יהיה מכוסה בפגישה.

1237
01:16:47,790 --> 01:16:50,710
שאל בחור ההוראה שלך על זה, ואנחנו יכולים לענות על שאלות בסוף.

1238
01:16:53,510 --> 01:16:56,600
ובדרך כלל אנחנו לא אוהבים לעשות דבר מינוס הזה.

1239
01:16:56,600 --> 01:16:59,760
זו יש לדרוש השמירה על המסלול שלי עד כמה אני כבר קוזזתי במערך.

1240
01:16:59,760 --> 01:17:04,520
אז, באופן כללי, זה רק כדי להסביר כיצד עובד פעולות אריתמטיות על מצביעים.

1241
01:17:04,520 --> 01:17:07,970
אבל מה שבדרך כלל אנחנו אוהבים לעשות הוא אנחנו אוהבים ליצור עותק של המצביע,

1242
01:17:07,970 --> 01:17:11,640
ואז להשתמש בעותק שכאשר אנחנו מסתובבים במחרוזת.

1243
01:17:11,640 --> 01:17:14,660
לכן, במקרה אלה שתשתמשו בעותק להדפיס כל המחרוזת,

1244
01:17:14,660 --> 01:17:19,040
אבל אנחנו לא צריכים לעשות כמו מצביע מינוס 6 או לעקוב אחר כמה עברנו בזה,

1245
01:17:19,040 --> 01:17:22,700
רק בגלל שאנחנו יודעים שהנקודה המקורית שלנו עדיין הצבעתי על תחילתה של הרשימה

1246
01:17:22,700 --> 01:17:25,340
וכל מה שאנחנו שינינו זה היה העתקה.

1247
01:17:25,340 --> 01:17:28,250
אז, באופן כללי, לשנות עותקים של המצביע המקורי שלך.

1248
01:17:28,250 --> 01:17:32,350
אל תנסה די אוהב - אל תשנה את העותקים מקוריים.

1249
01:17:32,350 --> 01:17:35,290
ניסיתי לשנות את העותקים היחידים שלך מקורי.

1250
01:17:41,540 --> 01:17:44,870
אז, אתה שם לב כאשר אנחנו מעבירים את המחרוזת לprintf

1251
01:17:44,870 --> 01:17:48,990
אתה לא צריך לשים את כוכב לפניו כמו שעשינו עם כל dereferences האחר, נכון?

1252
01:17:48,990 --> 01:17:54,180
לכן, אם אתה מדפיס% s המחרוזת כל צופה הוא כתובת,

1253
01:17:54,180 --> 01:17:57,610
ובמקרה הזה מצביע או במקרה זה כמו מערך של תווים.

1254
01:17:57,610 --> 01:18:00,330
>> תווים, char * s, ומערכים הם אותו הדבר.

1255
01:18:00,330 --> 01:18:03,690
מצביע הוא לתווים, ומערכי תווים הם אותו דבר.

1256
01:18:03,690 --> 01:18:05,720
וכך, כל שעלינו לעשות הוא לעבור במצביע.

1257
01:18:05,720 --> 01:18:08,150
אנחנו לא צריכים לעבור כבמצביע * או משהו כזה.

1258
01:18:13,110 --> 01:18:14,930
אז, מערכים ומצביעים הם אותו הדבר.

1259
01:18:14,930 --> 01:18:19,160
כשאתה עושה משהו כמו x [Y] הנה למערך,

1260
01:18:19,160 --> 01:18:21,960
מה הוא עושה מתחת למכסת המנוע הוא זה אומר, בסדר, זה מערך תווים,

1261
01:18:21,960 --> 01:18:23,690
כך שזה מצביע.

1262
01:18:23,690 --> 01:18:26,510
וכך x הוא אותו הדבר,

1263
01:18:26,510 --> 01:18:28,650
ואז מה שהוא עושה זה שהיא מוסיפה y ל x,

1264
01:18:28,650 --> 01:18:31,820
שזה אותו דבר כמו לנוע קדימה בזיכרון כל כך הרבה.

1265
01:18:31,820 --> 01:18:34,930
ועכשיו x + y נותן לנו איזו כתובת,

1266
01:18:34,930 --> 01:18:37,570
ואנחנו dereference כתובת או פעלו על החץ

1267
01:18:37,570 --> 01:18:41,640
לשם מיקום שהוא בזיכרון ואנחנו מקבלים את הערך ממיקום זה בזיכרון.

1268
01:18:41,640 --> 01:18:43,720
אז, אז שני אלה הם בדיוק אותו הדבר.

1269
01:18:43,720 --> 01:18:45,840
זה רק סוכר תחבירי.

1270
01:18:45,840 --> 01:18:48,090
הם עושים את אותו דבר. הם פשוט syntactics שונה זה לזה.

1271
01:18:51,500 --> 01:18:57,590
>> אז, מה יכול להשתבש עם מצביעים? כמו, והרבה. אוקיי. לכן, דברים רעים.

1272
01:18:57,590 --> 01:19:02,410
כמה דברים רעים שאתה יכול לעשות לא בודקים אם שיחת malloc מחזירה null, נכון?

1273
01:19:02,410 --> 01:19:06,560
במקרה זה, אני שואל את המערכת לתת לי - מהו מספר זה?

1274
01:19:06,560 --> 01:19:11,200
כמו 2 מיליארדים פעמים 4, בגלל גודלו של מספר שלם הוא 4 בתים.

1275
01:19:11,200 --> 01:19:13,810
אני שואל אותו למשהו כמו 8 מליארד בתים.

1276
01:19:13,810 --> 01:19:17,270
כמובן שהמחשב שלי לא הולך להיות מסוגל לתת לי שיחזור הזיכרון הרבה.

1277
01:19:17,270 --> 01:19:20,960
ולא לבדוק אם זה הוא ריק, ולכן כאשר אנו מנסים dereference אותו לשם -

1278
01:19:20,960 --> 01:19:24,270
פעל על החץ למקום שבו הולך - אין לנו זיכרון ש.

1279
01:19:24,270 --> 01:19:27,150
זה מה שאנו מכנים ביטול הפנית מצביע null.

1280
01:19:27,150 --> 01:19:29,710
וזה בעצם גורם לך segfault.

1281
01:19:29,710 --> 01:19:31,790
זוהי האחת הדרכים שאתה יכול segfault.

1282
01:19:34,090 --> 01:19:38,090
דברים רעים אחרים שאתה יכול לעשות - נו, טוב.

1283
01:19:38,090 --> 01:19:40,650
שביטול הפנית מצביע null. אוקיי.

1284
01:19:40,650 --> 01:19:45,160
דברים רעים אחרים - טוב, כדי לתקן את זה אתה פשוט לשים סימון שביש

1285
01:19:45,160 --> 01:19:46,980
שבודק אם המצביע הוא ריק

1286
01:19:46,980 --> 01:19:51,000
ולצאת מהתכנית אם זה קורה malloc שמחזיר מצביע null.

1287
01:19:55,110 --> 01:19:59,850
זה קומיקס xkcd. אנשים מבינים את זה עכשיו. סוג של.

1288
01:20:06,120 --> 01:20:09,350
>> לכן, זיכרון. ואני עברתי על זה.

1289
01:20:09,350 --> 01:20:12,000
אנחנו קוראים לmalloc בלולאה, אבל בכל פעם שאנו קוראים malloc

1290
01:20:12,000 --> 01:20:14,370
אנחנו מאבדים אחר שבו מצביע זה הוא מצביע,

1291
01:20:14,370 --> 01:20:15,750
כי אנחנו מחצנו אותו.

1292
01:20:15,750 --> 01:20:18,410
אז, בשיחה הראשונית לmalloc נותנת לי זיכרון לכאן.

1293
01:20:18,410 --> 01:20:19,990
מצביעי המצביע שלי לזה.

1294
01:20:19,990 --> 01:20:23,020
עכשיו, אני לא אשחרר אותו, אז עכשיו אני קורא malloc שוב.

1295
01:20:23,020 --> 01:20:26,070
עכשיו הוא מצביע לכאן. עכשיו הזיכרון שלי מצביע לכאן.

1296
01:20:26,070 --> 01:20:27,640
מצביע כאן. מצביע כאן.

1297
01:20:27,640 --> 01:20:31,820
אבל אני כבר אבדתי את הכתובות של כל הזיכרון מעל כאן שהוקציתי.

1298
01:20:31,820 --> 01:20:35,100
ואז עכשיו אין לי כל התייחסות אליהם יותר.

1299
01:20:35,100 --> 01:20:37,230
אז, אני לא יכול לשחרר אותם מחוץ למעגל הזה.

1300
01:20:37,230 --> 01:20:39,390
ולכן על מנת לתקן משהו כזה,

1301
01:20:39,390 --> 01:20:42,250
אם תשכח זיכרון פנוי ואתה מקבל דליפת זיכרון זה,

1302
01:20:42,250 --> 01:20:45,810
אתה צריך לשחרר את הזיכרון הפנימי של לולאה זה לאחר שתסיים עם זה.

1303
01:20:45,810 --> 01:20:51,400
ובכן, זה מה שקורה. אני מכיר הרבה שאתה שונא את זה.

1304
01:20:51,400 --> 01:20:55,270
אבל עכשיו - yay! אתה מקבל כמו 44,000 ק"ג.

1305
01:20:55,270 --> 01:20:57,110
אז, אתה תשחרר אותו בסוף הלולאה,

1306
01:20:57,110 --> 01:20:59,770
וזה הולך רק כדי לשחרר את הזיכרון בכל פעם.

1307
01:20:59,770 --> 01:21:03,620
בעיקרו של דבר, התכנית שלך אין דליפת זיכרון יותר.

1308
01:21:03,620 --> 01:21:08,150
>> ועכשיו משהו אחר שאתה יכול לעשות הוא לשחרר קצת זיכרון, כי אתה כבר בקשת פעמים.

1309
01:21:08,150 --> 01:21:11,060
במקרה זה, אתה משהו malloc, אתה משנה את הערך שלו.

1310
01:21:11,060 --> 01:21:13,140
אתה תשחרר אותו מייד, משום שאמרתם שאתם עושים עם זה.

1311
01:21:13,140 --> 01:21:14,940
אבל אז שחררתי אותו שוב.

1312
01:21:14,940 --> 01:21:16,730
זה משהו שהוא די גרוע.

1313
01:21:16,730 --> 01:21:18,820
זה לא הולך בתחילה לsegfault,

1314
01:21:18,820 --> 01:21:23,350
אך לאחר זמן מה שזה עושה הוא משחרר זה משחית כפול מבנה הערימה שלך,

1315
01:21:23,350 --> 01:21:27,200
ותלמד קצת יותר על זה, אם תבחר לקחת את כיתה כמו CS61.

1316
01:21:27,200 --> 01:21:30,000
אבל בעצם אחרי כמה זמן המחשב שלך עלול להתבלבל

1317
01:21:30,000 --> 01:21:33,010
על מיקומי זיכרון הם מה שבו ושבו הוא מאוחסן -

1318
01:21:33,010 --> 01:21:34,800
שבו נתונים מאוחסנים בזיכרון.

1319
01:21:34,800 --> 01:21:38,080
וכך משחרר את המצביע פעמים היא דבר רע, כי אתה לא רוצה לעשות.

1320
01:21:38,080 --> 01:21:41,600
>> דברים אחרים שיכולים להשתבש אינו משתמשים sizeof.

1321
01:21:41,600 --> 01:21:44,460
לכן, במקרה זה אתה malloc 8 בתים,

1322
01:21:44,460 --> 01:21:46,700
וזה אותו הדבר כמו שני מספרים שלמים, נכון?

1323
01:21:46,700 --> 01:21:49,580
אז, זה בטוח לחלוטין, אבל זה?

1324
01:21:49,580 --> 01:21:52,160
ובכן, כפי שלוקאס דבר על על ארכיטקטורות שונות,

1325
01:21:52,160 --> 01:21:54,220
מספרים שלמים הם באורכים שונים.

1326
01:21:54,220 --> 01:21:57,970
אז, על המכשיר שבו אתה משתמש, מספרים שלמים הם כ 4 בתים,

1327
01:21:57,970 --> 01:22:02,370
אבל במערכת אחרת שהם עלולים להיות 8 בתים או שהם יכולים להיות 16 בתים.

1328
01:22:02,370 --> 01:22:05,680
לכן, אם אני רק להשתמש במספר זה לכאן,

1329
01:22:05,680 --> 01:22:07,310
תכנית זו יכולה לעבוד על המכשיר,

1330
01:22:07,310 --> 01:22:10,360
אבל זה לא הולך להקצות מספיק זיכרון על מערכת אחרת.

1331
01:22:10,360 --> 01:22:14,020
במקרה זה, זה מה שמפעיל sizeof משמש ל.

1332
01:22:14,020 --> 01:22:16,880
כאשר אנו קוראים sizeof (int), מה המשמעות של זה הוא

1333
01:22:16,880 --> 01:22:21,910
 זה נותן לנו את הגודל של מספר שלם במערכת שהתכנית פועלת.

1334
01:22:21,910 --> 01:22:25,490
לכן, במקרה זה, sizeof (int) יחזיר 4 במשהו כמו המכשיר,

1335
01:22:25,490 --> 01:22:29,980
ועכשיו 4 * זה 2, שהוא 8,

1336
01:22:29,980 --> 01:22:32,330
וזה רק את כמות השטח דרוש לשני מספרים שלמים.

1337
01:22:32,330 --> 01:22:36,710
במערכת אחרת, אם int הוא כמו 16 בתים או 8 בתים,

1338
01:22:36,710 --> 01:22:39,380
זה רק הולך לחזור מספיק בתים כדי לאחסן את הסכום הזה.

1339
01:22:41,830 --> 01:22:45,310
>> ולבסוף, structs.

1340
01:22:45,310 --> 01:22:48,340
לכן, אם אתה רוצה לאחסן את לוח סודוקו בזיכרון, איך ניתן לעשות זאת?

1341
01:22:48,340 --> 01:22:51,570
אתה יכול לחשוב כמו משתנה לדבר הראשון,

1342
01:22:51,570 --> 01:22:53,820
משתנה לדבר השני, משתנה לדבר השלישי,

1343
01:22:53,820 --> 01:22:56,420
משתנה לדבר הרביעי - רע, נכון?

1344
01:22:56,420 --> 01:23:00,750
לכן, שיפור יחיד שאתה יכול לעשות על גבי זה הוא להפוך את מערך x 9 9.

1345
01:23:00,750 --> 01:23:04,480
זה בסדר, אבל מה אם אתה רוצה לשייך דברים אחרים עם לוח הסודוקו

1346
01:23:04,480 --> 01:23:06,490
אוהבים את מה הקושי של הלוח הוא,

1347
01:23:06,490 --> 01:23:11,740
או, למשל, מה הציון שלך הוא, או כמה זמן שלקח לך לפתור מערכת זו?

1348
01:23:11,740 --> 01:23:14,970
ובכן, מה שאתה יכול לעשות הוא שאתה יכול ליצור struct.

1349
01:23:14,970 --> 01:23:18,910
מה אני בעצם אומר זה שהם מגדירים את המבנה הזה לכאן,

1350
01:23:18,910 --> 01:23:23,230
ואני מגדיר את לוח סודוקו אשר מורכב מקרש שהוא 9 9 x.

1351
01:23:23,230 --> 01:23:26,650
>> ומה יש לו יש לו מצביעים לשם את הרמה.

1352
01:23:26,650 --> 01:23:30,730
כמו כן, יש x ו-y, שהם הקואורדינטות של איפה אני נמצא עכשיו.

1353
01:23:30,730 --> 01:23:35,980
זה גם זמן שבילה [לא מובן], ויש לו את המספר הכולל של מהלכים שהוזנתי עד כה.

1354
01:23:35,980 --> 01:23:40,010
ולכן במקרה זה, אני יכול לקבץ את כל חבורה של נתונים לתוך רק מבנה אחד

1355
01:23:40,010 --> 01:23:42,790
במקום שיש בו כמו מתעופף במשתנים שונים כמו

1356
01:23:42,790 --> 01:23:44,540
שאני באמת לא יכול לעקוב אחריו.

1357
01:23:44,540 --> 01:23:49,720
וזה מאפשר לנו יש תחביר פשוט נחמד לסוג של התייחסות דברים שונים בתוך struct זה.

1358
01:23:49,720 --> 01:23:53,430
אני רק יכול לעשות board.board, ואני מקבל את לוח הסודוקו בחזרה.

1359
01:23:53,430 --> 01:23:56,320
Board.level, אני מקבל כמה קשה.

1360
01:23:56,320 --> 01:24:00,540
Board.x וboard.y לתת לי את הקואורדינטות של איפה אני יכול להיות במועצת המנהלים.

1361
01:24:00,540 --> 01:24:04,730
ואז אני ניגש מה שאנו מכנים בשדות struct.

1362
01:24:04,730 --> 01:24:08,840
זה מגדיר sudokuBoard, שהוא סוג שיש לי.

1363
01:24:08,840 --> 01:24:14,800
ועכשיו אנחנו כאן. יש לי משתנה בשם "לוח" של sudokuBoard סוג.

1364
01:24:14,800 --> 01:24:18,820
ואז עכשיו אני יכול לגשת לכל התחומים המרכיבים את המבנה הזה לכאן.

1365
01:24:20,830 --> 01:24:22,450
>> שאלות לגבי structs? כן?

1366
01:24:22,450 --> 01:24:25,890
[סטודנטים] לint x, y, שהכרזת גם על קו אחד? >> [יוסף] אהה.

1367
01:24:25,890 --> 01:24:27,400
[סטודנטים] אז, אתה יכול פשוט לעשות את זה עם כולם?

1368
01:24:27,400 --> 01:24:31,200
כמו בx, y פעמי פסיק שכלל?

1369
01:24:31,200 --> 01:24:34,460
[יוסף] כן, אתה בהחלט יכול לעשות את זה, אבל הסיבה ששמתי את X ו-Y על אותו הקו -

1370
01:24:34,460 --> 01:24:36,330
והשאלה היא למה אנחנו לא יכולים לעשות את זה באותה השורה?

1371
01:24:36,330 --> 01:24:38,600
למה שלא פשוט לשים את כל אלה באותו הקו

1372
01:24:38,600 --> 01:24:42,090
x ו-y הם קשורים זה לזה,

1373
01:24:42,090 --> 01:24:44,780
וזו רק סגנונית נכונה יותר, במובן מסוים,

1374
01:24:44,780 --> 01:24:46,600
כי זה קיבוץ שני דברים באותו הקו

1375
01:24:46,600 --> 01:24:49,340
כזה כמו של מתייחס לאותו הדבר.

1376
01:24:49,340 --> 01:24:51,440
ואני רק לפצל אלה בנפרד. זה פשוט דבר בסגנון.

1377
01:24:51,440 --> 01:24:53,720
זה פונקציונלי לא משנה כלל.

1378
01:24:58,150 --> 01:24:59,270
יש עוד שאלות על structs?

1379
01:25:03,030 --> 01:25:06,620
באפשרותך להגדיר Pokedex עם struct.

1380
01:25:06,620 --> 01:25:11,720
פוקימון יש מספר ויש לה מכתב, בעלים, סוג.

1381
01:25:11,720 --> 01:25:16,990
ואז, אם יש לך מערך של פוקימון, אתה יכול לעשות את Pokedex, נכון?

1382
01:25:16,990 --> 01:25:20,810
אוקיי, מגניב. לכן, שאלות בstructs. אלה קשורים לstructs.

1383
01:25:20,810 --> 01:25:25,270
>> לבסוף, GDB. מה GDB לא ייתן לך לעשות? זה מאפשר לך לדבג את התכנית שלך.

1384
01:25:25,270 --> 01:25:27,650
ואם לא השתמש GDB, הייתי מומלץ צופים קצר

1385
01:25:27,650 --> 01:25:31,250
ורק עוברים על מה GDB הוא, איך אתה עובד איתו, איך ייתכן שמשתמש בו,

1386
01:25:31,250 --> 01:25:32,900
ולבדוק אותו בתכנית.

1387
01:25:32,900 --> 01:25:37,400
ואז מה GDB מאפשר לך לעשות זה מאפשר להשהות [לא מובנת] את התכנית שלך

1388
01:25:37,400 --> 01:25:38,920
וקו מעשי.

1389
01:25:38,920 --> 01:25:42,600
לדוגמה, אני רוצה ביצוע מתעכב ליד כמו קו 3 של התכנית שלי,

1390
01:25:42,600 --> 01:25:46,010
ואם אני כבר בשורה 3 אני יכול להדפיס את כל הערכים שנמצאים שם.

1391
01:25:46,010 --> 01:25:49,710
וכך מה שאנו מכנים כמו נעצרים בקו

1392
01:25:49,710 --> 01:25:52,350
אנחנו קוראים לזה הוא לשים נקודת עצירה באותו קו

1393
01:25:52,350 --> 01:25:55,920
ואז אנחנו יכולים להדפיס את המשתנים במצב התכנית באותו זמן.

1394
01:25:55,920 --> 01:25:58,990
>> אנחנו יכולים משם לעבור דרך קו אחר קו התכנית.

1395
01:25:58,990 --> 01:26:03,200
ואז אנחנו יכולים להסתכל במצב של המחסנית באותו הזמן.

1396
01:26:03,200 --> 01:26:08,600
ולכן על מנת להשתמש GDB, מה שאנחנו עושים הם שאנחנו קוראים בצלצול את קובץ C,

1397
01:26:08,600 --> 01:26:11,290
אבל אנחנו צריכים לעבור אותו דגל ggdb-.

1398
01:26:11,290 --> 01:26:15,850
וברגע שנסיים עם זה אנחנו פשוט להפעיל gdb על קובץ הפלט שנוצר.

1399
01:26:15,850 --> 01:26:18,810
ואז אתה מקבל קצת מסה כמו של טקסט כזה,

1400
01:26:18,810 --> 01:26:21,990
אבל באמת כל מה שאתה צריך לעשות הוא להקליד פקודות בהתחלה.

1401
01:26:21,990 --> 01:26:24,250
העיקרי לפרוץ מעמיד בנקודת עצירה עיקרית.

1402
01:26:24,250 --> 01:26:28,470
רשימה 400 מפרטת את שורות קוד סביב קו 400.

1403
01:26:28,470 --> 01:26:31,410
ולכן במקרה זה אתה יכול רק להסתכל לאחור ולומר, הו,

1404
01:26:31,410 --> 01:26:34,360
אני רוצה להגדיר נקודת עצירה בקו 397, שהוא קו זה,

1405
01:26:34,360 --> 01:26:37,170
ואז התכנית שלך פועלת לצעד ושזה הולך להישבר.

1406
01:26:37,170 --> 01:26:41,120
זה הולך לעצור שם, ואתה יכול להדפיס, למשל, ערך נמוך או גבוה.

1407
01:26:41,120 --> 01:26:46,410
וכך יש חבורה של פקודות שאתם צריכים לדעת,

1408
01:26:46,410 --> 01:26:48,660
ושקופיות זה תעלינה באתר האינטרנט,

1409
01:26:48,660 --> 01:26:54,000
כך שאם אתה רק רוצה להפנות אותם או רוצה לשים אותם על הגיליונות לרמות שלך, תרגיש חופשי.

1410
01:26:54,000 --> 01:27:00,650
>> מגניב. זה היה חידון סקירה 0, ואנחנו נשארים כאן, אם יש לך שאלות.

1411
01:27:00,650 --> 01:27:03,850
בסדר.

1412
01:27:03,850 --> 01:27:09,030
>>  [מחיאות כפות]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]