1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] בואו נדבר על מערכים.

2
00:00:09,360 --> 00:00:12,780
אז למה שאי פעם אנו רוצים להשתמש במערכים?

3
00:00:12,780 --> 00:00:17,210
ובכן בואו נגיד שיש לך תכנית שזקוקה לאחסון 5 תעודות סטודנט.

4
00:00:17,210 --> 00:00:21,270
זה אולי נראה סביר יש 5 משתנים נפרדים.

5
00:00:21,270 --> 00:00:24,240
מסיבות שנראות בקצת, תתחילו לספור מ 0.

6
00:00:24,240 --> 00:00:30,700
המשתנים שאנחנו נאלץ יהיו id0 int, ID1 int, וכן הלאה.

7
00:00:30,700 --> 00:00:34,870
כל היגיון שאנו רוצים לבצע בתעודת סטודנט יהיה הצורך להעתיק ולהדביק

8
00:00:34,870 --> 00:00:36,870
לכל אחד ממזהי הסטודנטים אלה.

9
00:00:36,870 --> 00:00:39,710
אם אנחנו רוצים לבדוק שתלמידים במקרה בCS50,

10
00:00:39,710 --> 00:00:43,910
אנחנו קודם כל צריכים לבדוק אם id0 מייצג את הסטודנט בקורס.

11
00:00:43,910 --> 00:00:48,070
ואז לעשות את אותו הדבר לתלמיד הבא, תצטרכו להעתיק ולהדביק את הקוד לid0

12
00:00:48,070 --> 00:00:54,430
ולהחליף את כל המופעים של id0 עם ID1 וכן הלאה עבור id2, 3 ו 4.

13
00:00:54,430 --> 00:00:57,560
>> ברגע שאתה שומע שאנחנו צריכים להעתיק ולהדביק,

14
00:00:57,560 --> 00:01:00,440
אתה צריך להתחיל לחשוב שיש פתרון טוב יותר.

15
00:01:00,440 --> 00:01:05,360
עכשיו מה אם אתה מבין שאתה לא צריך 5 מזהי סטודנטים אלא 7?

16
00:01:05,360 --> 00:01:09,570
אתה צריך לחזור לקוד המקור שלך ולהוסיף בid5, id6,

17
00:01:09,570 --> 00:01:14,260
ולהעתיק ולהדביק את ההיגיון לבדיקה אם את המזהים שייכים למעמד עבור 2 תעודות חדשות.

18
00:01:14,260 --> 00:01:19,600
אין שום דבר שהמחבר בין כל התעודות הללו יחד, ולכן אין דרך לשאול

19
00:01:19,600 --> 00:01:22,040
התכנית שתעשה זאת עבור מזהים 0 עד 6.

20
00:01:22,040 --> 00:01:26,120
ובכן עכשיו אתה מבין שיש לך 100 תעודות סטודנט.

21
00:01:26,120 --> 00:01:30,770
זה מתחיל להיראות פחות אידיאלי לצריך להצהיר בנפרד כל אחד ממזהים אלה,

22
00:01:30,770 --> 00:01:33,760
ולהעתיק ולהדביק כל היגיון לתעודות חדשות.

23
00:01:33,760 --> 00:01:38,380
אבל אולי אנו נחושים, ואנחנו עושים את זה לכל 100 התלמידים.

24
00:01:38,380 --> 00:01:42,240
אבל מה אם אתה לא יודע כמה סטודנטים יש דווקא הם?

25
00:01:42,240 --> 00:01:47,320
יש רק כמה סטודנטי n והתכנית שלך יש לשאול את המשתמש מה שn הוא.

26
00:01:47,320 --> 00:01:50,250
אה אה. זה לא הולך לעבודה טובה מאוד.

27
00:01:50,250 --> 00:01:53,820
התכנית שלך עובדת רק עבור חלק מספר קבוע של תלמידים.

28
00:01:53,820 --> 00:01:57,520
>> פתרון כל הבעיות הללו הוא היופי של מערכים.

29
00:01:57,520 --> 00:01:59,930
אז מה הוא מערך?

30
00:01:59,930 --> 00:02:04,480
בחלק משפות תכנות סוג מערך עלול להיות מסוגל לעשות קצת יותר,

31
00:02:04,480 --> 00:02:09,960
אבל כאן אנו נתמקד במבנה נתוני המערך הבסיסי בדיוק כפי שתראה אותו בג

32
00:02:09,960 --> 00:02:14,030
מערך הוא רק גוש גדול של זיכרון. זה הכל.

33
00:02:14,030 --> 00:02:17,770
כאשר אנו אומרים שיש לנו מערך של 10 מספרים שלמים, שרק אומר שיש לנו כמה בלוק

34
00:02:17,770 --> 00:02:20,740
זיכרון שהוא גדול מספיק כדי להחזיק 10 מספרים שלמים נפרדים.

35
00:02:29,930 --> 00:02:33,410
בהנחה שמספר שלם הוא 4 בתים, זה אומר שמערך של 10 מספרים שלמים

36
00:02:33,410 --> 00:02:37,180
הוא בלוק רציף של 40 בתים בזיכרון.

37
00:02:42,660 --> 00:02:46,280
גם כאשר אתה משתמש במערכים רבים ממדים, שאנו לא הולכים לכאן,

38
00:02:46,280 --> 00:02:49,200
זה עדיין רק גוש גדול של זיכרון.

39
00:02:49,200 --> 00:02:51,840
סימון הרב הממדי הוא רק נוחות.

40
00:02:51,840 --> 00:02:55,640
אם יש לך 3 על ידי מערך רב ממדי של מספרים שלמים 3,

41
00:02:55,640 --> 00:03:00,650
אז התכנית שלך תהיה באמת פשוט להתייחס לזה כמו גוש גדול של 36 בתים.

42
00:03:00,650 --> 00:03:05,460
המספר הכולל של מספרים שלמים הוא 3 פעמים 3, וכל המספר שלם תופס 4 בתים.

43
00:03:05,460 --> 00:03:07,750
>> בואו נסתכל על דוגמה בסיסית.

44
00:03:07,750 --> 00:03:10,660
אנחנו יכולים לראות כאן 2 דרכים שונות של מערכים המכריזים.

45
00:03:15,660 --> 00:03:18,580
נצטרך להגיב 1 מתוכם לתכנית להדר

46
00:03:18,580 --> 00:03:20,900
מאז אנו מצהירים x פעמים.

47
00:03:20,900 --> 00:03:25,140
אנחנו נסתכל על כמה מההבדלים בין 2 סוגים אלה של הצהרות בקצת.

48
00:03:25,140 --> 00:03:28,560
שתי שורות אלה להצהיר על מערך של N גודל,

49
00:03:28,560 --> 00:03:30,740
יש לנו שם # define N כמו 10.

50
00:03:30,740 --> 00:03:34,460
אנחנו יכולים בקלות שאלנו את המשתמש למספר חיובי

51
00:03:34,460 --> 00:03:37,250
ומשמש כשלם שמספר האלמנטים במערך שלנו.

52
00:03:37,250 --> 00:03:41,960
רוצה דוגמא תעודת הסטודנט שלנו לפני, זה כמו סוג של הכרזת 10 נפרדים לחלוטין

53
00:03:41,960 --> 00:03:49,000
משתנים דמיוניים; X0, x1, x2, וכן הלאה עד xn-1.

54
00:03:57,270 --> 00:04:00,840
התעלמות מהקווים שבו אנו מצהירים המערך, להבחין בסוגריים המרובעים שלמים

55
00:04:00,840 --> 00:04:02,090
בתוך לולאות.

56
00:04:02,090 --> 00:04:09,660
כאשר אנו כותבים משהו כמו x [3], שאני אקרא רק כx 3 הסוגר

57
00:04:09,660 --> 00:04:13,090
אתה יכול לחשוב על זה כמו לבקש x3 הדמיוני.

58
00:04:13,090 --> 00:04:17,519
שים לב מאשר עם מערך בגודל n, זה אומר שמספר בתוך הסוגריים,

59
00:04:17,519 --> 00:04:22,630
שאנחנו קוראים למדד, יכול להיות כל דבר מ0 עד N-1,

60
00:04:22,630 --> 00:04:25,660
שהנו בסך של מדדי N.

61
00:04:25,660 --> 00:04:28,260
>> לחשוב על איך זה עובד באמת

62
00:04:28,260 --> 00:04:31,260
לזכור שהמערך הוא גוש גדול של זיכרון.

63
00:04:31,260 --> 00:04:37,460
בהנחה שמספר שלם הוא 4 בתים, x המערך כולו הוא בלוק 40 בייט של זיכרון.

64
00:04:37,460 --> 00:04:41,360
אז x0 מתייחס ל4 הבתים הראשונים של השכונה.

65
00:04:45,810 --> 00:04:49,230
X [1] מתייחס ל4 הבתים הבאים וכך הלאה.

66
00:04:49,230 --> 00:04:53,760
משמעות הדבר הוא כי תחילתו של x היא כל התכנית אי פעם צריך לעקוב אחריו.

67
00:04:55,660 --> 00:04:59,840
אם ברצונך להשתמש x [400], ולאחר מכן את התכנית יודעת שזה שווה ערך

68
00:04:59,840 --> 00:05:03,460
רק 1,600 בתים לאחר תחילת x.

69
00:05:03,460 --> 00:05:08,780
איפה ישיג 1,600 בתים מ? זה רק 400 פעמים 4 בתים לכל מספר שלם.

70
00:05:08,780 --> 00:05:13,170
>> לפני שתמשיך, זה מאוד חשוב להבין כי בג

71
00:05:13,170 --> 00:05:17,080
אין אכיפה של המדד שאנו משתמשים במערך.

72
00:05:17,080 --> 00:05:23,180
הבלוק הגדול שלנו הוא ארוך רק 10 מספרים שלמים, אבל שום דבר לא צועק עלינו אם נכתוב X [20]

73
00:05:23,180 --> 00:05:26,060
או אפילו x [-5].

74
00:05:26,060 --> 00:05:28,240
המדד אפילו לא חייב להיות מספר.

75
00:05:28,240 --> 00:05:30,630
זה יכול להיות כל ביטוי שרירותי.

76
00:05:30,630 --> 00:05:34,800
בתכנית אנו משתמשים אני משתנה מלולאה לאינדקס לתוך המערך.

77
00:05:34,800 --> 00:05:40,340
זהו דפוס נפוץ מאוד, המתעקלים מi = 0 עד האורך של המערך,

78
00:05:40,340 --> 00:05:43,350
ואז אני משתמש כמדד למערך.

79
00:05:43,350 --> 00:05:46,160
בדרך זו אתה למעשה לולאה על כל המערך,

80
00:05:46,160 --> 00:05:50,600
ואתה גם יכול להקצות לכל מקום במערך או להשתמש בו לחישוב מסוים.

81
00:05:50,600 --> 00:05:53,920
>> בראשון ללולאה, אני מתחיל ב0,

82
00:05:53,920 --> 00:05:58,680
וכך זה יהיה להקצות ל0 מקום במערך, הערך פעמים 0 2.

83
00:05:58,680 --> 00:06:04,370
אז אני מרווחים, ואנחנו מקצים המקום הראשון במערך 1 פעמי הערך 2.

84
00:06:04,370 --> 00:06:10,170
אז מרווחים שוב וכן הלאה עד שאנו מקצים למצב N-1 במערך

85
00:06:10,170 --> 00:06:13,370
ערך N-1 פעמים 2.

86
00:06:13,370 --> 00:06:17,810
משום כך יצרו מערך עם 10 מספרים הזוגיים הראשונים.

87
00:06:17,810 --> 00:06:21,970
אולי מאזן הייתה שם קצת יותר טובות למשתנים מ-X,

88
00:06:21,970 --> 00:06:24,760
אבל זה היה נותן לי דברים.

89
00:06:24,760 --> 00:06:30,210
השני ללולאה ואז פשוט מדפיס את הערכים שכבר מאוחסנים בתוך המערך.

90
00:06:30,210 --> 00:06:33,600
>> בואו ננסה להפעיל את התכנית בשני הסוגים של הצהרות מערך

91
00:06:33,600 --> 00:06:36,330
ותסתכל בפלט של התכנית.

92
00:06:51,450 --> 00:06:57,020
ככל שאנחנו יכולים לראות, התכנית מתנהגת באותה הצורה לשני הסוגים של הצהרות.

93
00:06:57,020 --> 00:07:02,230
בואו גם להעיף מבט על מה שקורה אם נשנה את הלולאה הראשונה לא לעצור בN

94
00:07:02,230 --> 00:07:05,040
אלא אומר 10,000.

95
00:07:05,040 --> 00:07:07,430
הרבה מעבר לקצה של המערך.

96
00:07:14,700 --> 00:07:17,210
אופס. אולי ראה את זה בעבר.

97
00:07:17,210 --> 00:07:20,440
אשמת פילוח משמעות התכנית שלך התרסקה.

98
00:07:20,440 --> 00:07:24,430
אתה מתחיל לראותם, כשאתה נוגע באזורי הזיכרון אתה לא צריך להיות נוגע.

99
00:07:24,430 --> 00:07:27,870
כאן אנו נוגעים ב10,000 מקומות שמעבר תחילתו של x,

100
00:07:27,870 --> 00:07:31,920
שכנראה הוא מקום בזיכרון, אנחנו לא צריכים להיות נוגעים ללב.

101
00:07:31,920 --> 00:07:37,690
אז רובנו כנראה לא הייתי מכניס את 10000 בטעות במקום N,

102
00:07:37,690 --> 00:07:42,930
אבל מה אם אנחנו עושים משהו עדין יותר כמו כתיבה אומר פחות או שווה ל N

103
00:07:42,930 --> 00:07:46,830
במצב הלולאה לעומת פחות מ נ

104
00:07:46,830 --> 00:07:50,100
זכור כי יש מערך מדדים בין 0 ל N-1 בלבד,

105
00:07:50,100 --> 00:07:54,510
מה שאומר שהמדד N הוא מעבר לסוף המערך.

106
00:07:54,510 --> 00:07:58,050
התכנית אולי לא לקרוס במקרה הזה, אבל זה עדיין שגיאה.

107
00:07:58,050 --> 00:08:01,950
למעשה, טעות זו היא כל כך נפוצה שיש לו שם משלו,

108
00:08:01,950 --> 00:08:03,970
את השגיאות על ידי 1.

109
00:08:03,970 --> 00:08:05,970
>> זהו לדברים הבסיסיים.

110
00:08:05,970 --> 00:08:09,960
אז מה הם ההבדלים העיקריים בין 2 הסוגים של הצהרות מערך?

111
00:08:09,960 --> 00:08:13,960
הבדל אחד הוא שבו הגוש הגדול של זיכרון הולך.

112
00:08:13,960 --> 00:08:17,660
בהצהרה הראשונה, שאני אתקשר סוג הסוגר-מערך,

113
00:08:17,660 --> 00:08:20,300
אם כי זה בהחלט לא שם קונבנציונלי,

114
00:08:20,300 --> 00:08:22,480
זה ילך במחסנית.

115
00:08:22,480 --> 00:08:27,450
ואילו במקרה השני, שבו אני קורא את סוג המצביע-מערך, זה ילך בערימה.

116
00:08:27,450 --> 00:08:32,480
זה אומר שכשאת חוזר לתפקד, מערך הסוגר באופן אוטומטי deallocated,

117
00:08:32,480 --> 00:08:36,419
בעוד כעליך להתקשר חינם באופן מפורש על מערך המצביע

118
00:08:36,419 --> 00:08:38,010
או שיש לך דליפת זיכרון.

119
00:08:38,010 --> 00:08:42,750
בנוסף, מערך הסוגר הוא לא ממש משתנה.

120
00:08:42,750 --> 00:08:45,490
זה חשוב. זה רק סמל.

121
00:08:45,490 --> 00:08:49,160
אתה יכול לחשוב על זה כקבוע שהמהדר בוחר בשבילך.

122
00:08:49,160 --> 00:08:52,970
זה אומר שאנחנו לא יכולים לעשות משהו כמו x + + עם סוג הסוגר

123
00:08:52,970 --> 00:08:56,240
למרות שזה חוקי לחלוטין עם סוג המצביע.

124
00:08:56,240 --> 00:08:58,270
>> סוג המצביע הוא משתנה.

125
00:08:58,270 --> 00:09:01,510
לסוג המצביע, יש לנו 2 בלוקים נפרדים של זיכרון.

126
00:09:01,510 --> 00:09:06,060
משתנה עצמו מאוחסן במחסנית ורק מצביע יחיד,

127
00:09:06,060 --> 00:09:08,620
אבל הגוש הגדול של זיכרון מאוחסן בערימה.

128
00:09:08,620 --> 00:09:11,010
X משתנה על הערימה פשוט שומר את הכתובה

129
00:09:11,010 --> 00:09:14,010
של הגוש הגדול בזיכרון על הערימה.

130
00:09:14,010 --> 00:09:17,370
אחת משמעויות של זה הוא בגודלו של מפעיל.

131
00:09:17,370 --> 00:09:22,480
אם אתה שואל על הגודל של מערך הסוגר, זה ייתן לך את הגודל של הבלוק הגדול של זיכרון,

132
00:09:22,480 --> 00:09:24,620
משהו כמו 40 בתים,

133
00:09:24,620 --> 00:09:26,920
אבל אם אתה שואל על הגודל של סוג המצביע של מערך,

134
00:09:26,920 --> 00:09:32,740
זה ייתן לך את הגודל של x משתנה עצמו, שעל המכשיר הוא סביר רק 4 בתים.

135
00:09:32,740 --> 00:09:36,530
השימוש בסוג המצביע-המערך, אי אפשר ישירות לבקש

136
00:09:36,530 --> 00:09:38,530
גודלו של הגוש הגדול של זיכרון.

137
00:09:38,530 --> 00:09:42,530
זה לא בדרך כלל הרבה יותר מהגבלה מאז שלעתים רחוקות מאוד רוצים את הגודל

138
00:09:42,530 --> 00:09:46,980
של הגוש הגדול של זיכרון, ואנחנו בדרך כלל יכולים לחשב את זה אם אנחנו צריכים אותו.

139
00:09:46,980 --> 00:09:51,490
>> לבסוף, מערך הסוגר קורה לספק לנו קיצור לאתחול מערך.

140
00:09:51,490 --> 00:09:56,130
בואו לראות איך אנחנו יכולים לכתוב את 10 מספרים שלמים אפילו הראשונים באמצעות initilization הקיצור.

141
00:10:11,220 --> 00:10:14,470
עם מערך המצביע, אין דרך לעשות קיצור כזה.

142
00:10:14,470 --> 00:10:18,120
זה רק הקדמה למה שאתה יכול לעשות עם מערכים.

143
00:10:18,120 --> 00:10:20,990
הם מופיעים כמעט בכל תכנית שאתה כותב.

144
00:10:20,990 --> 00:10:24,390
אני מקווה שאתה יכול לראות עכשיו דרך טובה יותר לעשות דוגמא תעודות הסטודנט

145
00:10:24,390 --> 00:10:26,710
מההתחלה של וידאו.

146
00:10:26,710 --> 00:10:29,960
>> השם שלי הוא רוב אודן, וזה CS50.