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

2
00:00:03,388 --> 00:00:05,104

3
00:00:05,104 --> 00:00:06,020
דאג LLOYD: בסדר.

4
00:00:06,020 --> 00:00:07,680
עבודה עם אחד
משתנים הוא די כיף.

5
00:00:07,680 --> 00:00:09,500
אבל מה אם אנחנו רוצים לעבוד
עם הרבה משתנה,

6
00:00:09,500 --> 00:00:12,760
אבל אנחנו לא רוצים שיהיו לי חבורה של
שמות שונים עפים הקוד שלנו?

7
00:00:12,760 --> 00:00:15,980
במקרה זה, הם מערכים
הולך לבוא בבאמת שימושי.

8
00:00:15,980 --> 00:00:19,510
מערכים הם נתונים באמת בסיסיים
מבנה לכל שפת תכנות

9
00:00:19,510 --> 00:00:20,260
שבו ישתמש.

10
00:00:20,260 --> 00:00:24,450
והם באמת, באמת שימושיים,
במיוחד, כפי שאנו תראו, ב -50 CS.

11
00:00:24,450 --> 00:00:27,870
>> אנו משתמשים במערכים להחזיק
ערכים מאותו סוג נתונים

12
00:00:27,870 --> 00:00:29,830
במקומות זיכרון רציפים.

13
00:00:29,830 --> 00:00:32,430
כלומר, זה
דרך שנוכל קבוצה

14
00:00:32,430 --> 00:00:35,430
חבורה של מספרים שלמים ביחד ב
זיכרון או חבורה של דמויות

15
00:00:35,430 --> 00:00:38,270
או צף בזיכרון באמת
לסגור ביחד ועבודה

16
00:00:38,270 --> 00:00:41,930
עם אותם מבלי לתת לכל
שם אחד ייחודי משלו, שיכול

17
00:00:41,930 --> 00:00:44,500
לקבל מסורבל לאחר זמן קצר.

18
00:00:44,500 --> 00:00:48,130
>> עכשיו, דרך אחת להקיש מערכים
הוא לחשוב על הפוסט המקומי שלך

19
00:00:48,130 --> 00:00:49,000
משרד לשנייה.

20
00:00:49,000 --> 00:00:51,820
אז להתרחק מתכנות
ורק לעצום את העיניים שלך

21
00:00:51,820 --> 00:00:54,120
ולדמיין בראש שלך
סניף הדואר המקומי שלך.

22
00:00:54,120 --> 00:00:57,160
בדרך כלל, ברוב הפוסט
משרדים, יש בנק גדול

23
00:00:57,160 --> 00:01:00,490
תיבות דואר על הקיר.

24
00:01:00,490 --> 00:01:03,510
>> מערך הוא גוש ענק
של זיכרון רציף,

25
00:01:03,510 --> 00:01:06,120
באותו אופן שדואר
בנק בסניף הדואר שלך

26
00:01:06,120 --> 00:01:11,230
חלל גדול ב
קיר של סניף הדואר.

27
00:01:11,230 --> 00:01:15,750
מערכים כבר מחולקים לקטנים,
זהה בלוקים בגודל של שטח,

28
00:01:15,750 --> 00:01:19,930
כל אחד מהם נקרא אלמנט, ב
באותו אופן שבו הקיר של הפוסט

29
00:01:19,930 --> 00:01:23,840
משרד כבר מחולק לקטן,
זהה בלוקים בגודל של שטח,

30
00:01:23,840 --> 00:01:27,560
שאנו מכנים תיבת דואר.

31
00:01:27,560 --> 00:01:31,650
של המערך כל אלמנט יכול
לאחסן כמות מסוימת של נתונים,

32
00:01:31,650 --> 00:01:37,540
בדיוק כמו כל תיבת דואר יכולה
להחזיק כמות מסוימת של דואר.

33
00:01:37,540 --> 00:01:41,540
>> מה יכול להיות מאוחסן בכל רכיב של
המערך הוא משתנים של אותם נתונים

34
00:01:41,540 --> 00:01:45,300
סוג, כגון int או char, רק
כמו בתיבת הדואר שלך,

35
00:01:45,300 --> 00:01:47,300
אתה יכול רק להתאים דברים
מסוג דומה,

36
00:01:47,300 --> 00:01:50,430
כגון מכתבים או חבילות קטנות.

37
00:01:50,430 --> 00:01:55,050
לבסוף, אנו יכולים לגשת לכל אלמנט של
המערך ישירות על ידי מספר אינדקס,

38
00:01:55,050 --> 00:01:59,770
בדיוק כפי שאנו יכולים לגשת לסניף הדואר שלנו
תיבה על ידי לדעת מספר תיבת הדואר שלה.

39
00:01:59,770 --> 00:02:02,750
יש לקוות, כי אנלוגיה
עוזר לך לקבל את הראש שלך

40
00:02:02,750 --> 00:02:05,540
סביב הרעיון של מערכים על ידי
אנלוגיה למשהו אחר

41
00:02:05,540 --> 00:02:08,400
כי אתה כנראה
כבר מכיר.

42
00:02:08,400 --> 00:02:13,182
>> ב- C, האלמנטים של מערך הם
האינדקס מתחיל מ -0, לא מ1.

43
00:02:13,182 --> 00:02:14,390
וזה באמת חשוב.

44
00:02:14,390 --> 00:02:18,530
ולמעשה, זו הסיבה שאנחנו, ב -50 CS,
ומדעני מחשב לעתים קרובות למה

45
00:02:18,530 --> 00:02:22,150
יספור מ -0, הוא
בגלל המערך של C

46
00:02:22,150 --> 00:02:24,660
אינדקס, שתמיד מתחיל ב 0.

47
00:02:24,660 --> 00:02:28,730
אז אם מערך מורכב מאלמנטי n,
האלמנט הראשון של מערך ש

48
00:02:28,730 --> 00:02:32,960
ממוקם במדד 0, ו
האלמנט האחרון של המערך

49
00:02:32,960 --> 00:02:36,610
ממוקם בn מדד מינוס 1.

50
00:02:36,610 --> 00:02:43,160
שוב, אם יש אלמנטי n בנו
מערך, המדד האחרון הוא n מינוס 1.

51
00:02:43,160 --> 00:02:46,820
>> אז אם יש לנו מערך של 50 אלמנטים,
האלמנט ראשון ממוקם במדד 0,

52
00:02:46,820 --> 00:02:51,060
והאלמנט האחרון
ממוקם במדד 49.

53
00:02:51,060 --> 00:02:53,940
לרוע המזל, או למרבה המזל,
בהתאם לנקודת המבט שלך,

54
00:02:53,940 --> 00:02:56,170
C הוא מאוד מקל כאן.

55
00:02:56,170 --> 00:02:59,480
זה לא ימנע ממך
הולך מחוץ לתחום של המערך שלך.

56
00:02:59,480 --> 00:03:03,080
אתה יכול לגשת למינוס
3 אלמנט של המערך שלך

57
00:03:03,080 --> 00:03:07,400
או אלמנט ה -59 של המערך שלך,
אם המערך שלך יש רק 50 אלמנטים.

58
00:03:07,400 --> 00:03:11,060
זה לא יעצור את התכנית שלך מ
קומפילציה, אבל בזמן הריצה,

59
00:03:11,060 --> 00:03:14,350
אתה עשוי להיתקל
אשמת פילוח מפחידה

60
00:03:14,350 --> 00:03:17,460
אם אתה מתחיל לגשת לזיכרון
שנמצא מחוץ לגבולות של מה

61
00:03:17,460 --> 00:03:19,260
שאל את התכנית שלך לתת לך.

62
00:03:19,260 --> 00:03:21,250
אז אל יהיה זהיר.

63
00:03:21,250 --> 00:03:23,120
>> מה עושה מערך
הכרזה נראה?

64
00:03:23,120 --> 00:03:26,940
איך קוד מערך לקיום
כמו שאנחנו קוד כל משתנה אחרים?

65
00:03:26,940 --> 00:03:31,250
ישנם שלושה חלקים למערך
declaration-- סוג, שם,

66
00:03:31,250 --> 00:03:31,880
וגודל.

67
00:03:31,880 --> 00:03:34,088
זה דומה מאוד ל
הצהרה משתנה, ש

68
00:03:34,088 --> 00:03:36,970
הוא רק סוג ושם,
להיות אלמנט הגודל

69
00:03:36,970 --> 00:03:39,860
המקרה המיוחד למערך,
כי אנחנו מקבלים חבורה שלהם

70
00:03:39,860 --> 00:03:41,830
באותו הזמן.

71
00:03:41,830 --> 00:03:45,560
>> אז הסוג הוא איזה סוג של משתנה
רוצה כל אלמנט של המערך להיות.

72
00:03:45,560 --> 00:03:47,150
רוצה את זה למערך של מספרים שלמים?

73
00:03:47,150 --> 00:03:49,010
ואז, סוג הנתונים שלך צריך להיות int.

74
00:03:49,010 --> 00:03:51,760
האם אתה רוצה שזה יהיה
מערך של זוגות או צף?

75
00:03:51,760 --> 00:03:54,545
סוג הנתונים צריך להיות כפול או לצוף.

76
00:03:54,545 --> 00:03:56,420
שם זה מה שאתה
רוצה לקרוא למערך שלך.

77
00:03:56,420 --> 00:04:00,970
מה אתה רוצה שם זה ענק
בנק של מספרים שלמים או צף או תווים

78
00:04:00,970 --> 00:04:03,250
או זוגות, או מה שיש לך?

79
00:04:03,250 --> 00:04:04,700
מה אתה רוצה לקרוא לזה?

80
00:04:04,700 --> 00:04:06,110
די מסביר עצמי.

81
00:04:06,110 --> 00:04:08,610
>> לבסוף, גודל, אשר הולך
בתוך סוגריים מרובעים,

82
00:04:08,610 --> 00:04:12,180
הוא כמה אלמנטים שהיית
כמו המערך שלך להכיל.

83
00:04:12,180 --> 00:04:13,530
כמה מספרים שלמים אתה רוצה?

84
00:04:13,530 --> 00:04:15,570
כמה צף אתה רוצה?

85
00:04:15,570 --> 00:04:19,070
>> כך למשל, int ציוני סטודנט 40.

86
00:04:19,070 --> 00:04:26,020
זה מגדיר מערך בשם סטודנטים
ציונים, אשר מורכב 40 מספרים שלמים.

87
00:04:26,020 --> 00:04:28,180
די מסביר עצמי, אני מקווה.

88
00:04:28,180 --> 00:04:29,330
הנה דוגמא נוספת.

89
00:04:29,330 --> 00:04:31,560
מחירי תפריט זוגיים 8.

90
00:04:31,560 --> 00:04:34,610
זה יוצר מערך בשם
מחירי תפריט, אשר מורכב

91
00:04:34,610 --> 00:04:38,300
של חדר בזיכרון לשמונה זוגות.

92
00:04:38,300 --> 00:04:42,000

93
00:04:42,000 --> 00:04:45,750
>> אם אתה חושב על כל אלמנט
מערך של טיפוס נתונים מסוג,

94
00:04:45,750 --> 00:04:49,860
כך למשל, אלמנט יחיד של
מערך של int הסוג, באותו אופן ש

95
00:04:49,860 --> 00:04:52,770
יחשוב על כל דבר אחר
משתנה מסוג int,

96
00:04:52,770 --> 00:04:56,440
כל הפעולות שאנחנו מכירים
דן בעבר בתפעול

97
00:04:56,440 --> 00:04:58,270
וידאו יהיה הגיוני.

98
00:04:58,270 --> 00:05:01,620
אז הנה, אנחנו יכולים להצהיר על מערך
של Booleans נקרא Truthtable,

99
00:05:01,620 --> 00:05:05,590
אשר מורכב מחדר למשך 10 Booleans.

100
00:05:05,590 --> 00:05:09,650
>> ואז, בדיוק כמו שאנחנו יכולים פשוט להקצות
ערך לכל משתנה אחרים מהסוג

101
00:05:09,650 --> 00:05:13,470
בוליאנית, אנחנו יכולים לומר משהו
כמו הסוגר מרובע Truthtable

102
00:05:13,470 --> 00:05:18,040
2, אשר הוא איך אנחנו מצביעים,
שאלמנט של טבלת האמת?

103
00:05:18,040 --> 00:05:20,350
המרכיב השלישי של
טבלת אמת, כי יזכור,

104
00:05:20,350 --> 00:05:21,800
אנחנו סופרים מ0.

105
00:05:21,800 --> 00:05:25,690
אז ככה אנחנו מצביעים
מרכיב שלישי של טבלת האמת.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2 שווה שווא,
בדיוק כמו שאנחנו יכולים declare--

107
00:05:28,680 --> 00:05:33,560
או שאנחנו יכולים להקצות, ולא, כל
משתנים מסוג בוליאני ככוזב.

108
00:05:33,560 --> 00:05:35,050
>> כמו כן, אנו יכולים להשתמש בו בתנאים.

109
00:05:35,050 --> 00:05:39,000
אם (7 == truthtable
אמיתי), כלומר,

110
00:05:39,000 --> 00:05:42,370
אם האלמנט השמיני
של Truthtable נכון,

111
00:05:42,370 --> 00:05:46,760
אולי אנחנו רוצים להדפיס הודעה
למשתמש, printf ("n נכון!") ;.

112
00:05:46,760 --> 00:05:50,290
שגורם לנו לומר Truthtable
10 שווים אמיתיים, נכון?

113
00:05:50,290 --> 00:05:53,590
ובכן, אני יכול, אבל זה די
מסוכן, כי תזכור,

114
00:05:53,590 --> 00:05:56,260
יש לנו מערך של 10 Booleans.

115
00:05:56,260 --> 00:06:02,340
אז המדד הגבוה ביותר ש
מהדר נתן לנו הוא 9.

116
00:06:02,340 --> 00:06:06,010
>> תכנית זו תהיה לקמפל, אבל
אם משהו בזיכרון אחר

117
00:06:06,010 --> 00:06:09,110
קיים בו אנחנו הייתם
מצפה Truthtable 10 ללכת,

118
00:06:09,110 --> 00:06:13,980
אנחנו יכולים לסבול אשמת פילוח. אנחנו
אולי לצאת מזה, אבל באופן כללי,

119
00:06:13,980 --> 00:06:14,710
די מסוכן.

120
00:06:14,710 --> 00:06:19,759
אז מה אני עושה כאן הוא C המשפטי,
אך לא בהכרח הצעד הטוב ביותר.

121
00:06:19,759 --> 00:06:22,300
עכשיו, כשאתה מצהיר ו
לאתחל מערך בו זמנית,

122
00:06:22,300 --> 00:06:23,960
יש למעשה די
תחביר מיוחד ש

123
00:06:23,960 --> 00:06:26,250
יכול להשתמש בו כדי למלא את המערך
עם ערכי ההתחלה שלה.

124
00:06:26,250 --> 00:06:30,130
זה יכול להגיע למסורבל
להצהיר על מערך בגודל 100,

125
00:06:30,130 --> 00:06:33,430
ואז יש לי לומר, אלמנט 0
שווה את זה; אלמנט 1 שווה זה;

126
00:06:33,430 --> 00:06:34,850
אלמנט 2 שווה את זה.

127
00:06:34,850 --> 00:06:36,370
מה הטעם, נכון?

128
00:06:36,370 --> 00:06:39,470
>> אם זה מערך קטן,
יכול לעשות משהו כזה.

129
00:06:39,470 --> 00:06:44,360
בול truthtable 3 שווה פתוח
סד מתולתל ולאחר מכן פסיק

130
00:06:44,360 --> 00:06:48,060
להפריד את הרשימה של אלמנטים
שאתה רוצה לשים במערך.

131
00:06:48,060 --> 00:06:50,520
ואז לסגור פסיק סד מתולתל.

132
00:06:50,520 --> 00:06:53,910
זה יוצר מערך של
גודל שלושה נקראים Truthtable,

133
00:06:53,910 --> 00:06:56,090
עם אלמנטי שווא, נכון, ואמיתי.

134
00:06:56,090 --> 00:06:59,270
ואכן, המופע
תחביר יש לי כאן הוא

135
00:06:59,270 --> 00:07:03,350
בדיוק כמו עושה
תחביר מרכיב בודד בהמשך.

136
00:07:03,350 --> 00:07:09,380
שתי דרכים אלה של קידוד היית
לייצר בדיוק את אותו המערך.

137
00:07:09,380 --> 00:07:11,740
>> כמו כן, אנו יכולים לחזר
על כל האלמנטים

138
00:07:11,740 --> 00:07:15,400
של מערך באמצעות לולאה, אשר, ב
למעשה, הוא מומלץ מאוד מאוד

139
00:07:15,400 --> 00:07:16,790
תרגיל בבית.

140
00:07:16,790 --> 00:07:20,720
איך אתה יוצר מערך
של 100 מספרים שלמים, שבו

141
00:07:20,720 --> 00:07:23,477
כל אלמנט של המערך הוא המדד שלה?

142
00:07:23,477 --> 00:07:26,560
כך למשל, יש לנו מערך של 100
מספרים שלמים, ובאלמנט הראשון,

143
00:07:26,560 --> 00:07:27,790
אנחנו רוצים לשים 0.

144
00:07:27,790 --> 00:07:29,810
במרכיב השני, אנחנו רוצים לשים 1.

145
00:07:29,810 --> 00:07:33,319
באלמנט השלישי, אנחנו רוצים
לשים 2; וכן הלאה וכן הלאה.

146
00:07:33,319 --> 00:07:35,360
זה ממש טוב
בבית התרגיל לעשות את זה.

147
00:07:35,360 --> 00:07:38,190

148
00:07:38,190 --> 00:07:40,220
>> הנה, זה לא נראה
כמו גם הרבה השתנה.

149
00:07:40,220 --> 00:07:44,170
אבל שם לב שבבין
סוגריים מרובעים, זה זמן,

150
00:07:44,170 --> 00:07:45,830
למעשה אני כבר השמטתי את המספר.

151
00:07:45,830 --> 00:07:48,000
אם אתה משתמש בזה מאוד
מופע מיוחד

152
00:07:48,000 --> 00:07:50,380
תחביר כדי ליצור
מערך, שאתה עושה בעצם לא

153
00:07:50,380 --> 00:07:53,491
צריך לציין את הגודל
של המערך מראש.

154
00:07:53,491 --> 00:07:55,740
מהדר הוא מספיק חכם
לדעת שאתה באמת

155
00:07:55,740 --> 00:07:58,980
רוצה מערך של גודל 3,
כי אתה שם את שלושה אלמנטים

156
00:07:58,980 --> 00:08:00,640
בצד הימין של סימן השוויון.

157
00:08:00,640 --> 00:08:04,140
אם הכניס ארבעה, תהיה לו
נתתי לך טבלת אמת של גודל ארבעה;

158
00:08:04,140 --> 00:08:06,270
וכן הלאה וכן הלאה.

159
00:08:06,270 --> 00:08:09,380
>> מערכים אינם מוגבלים ליחיד
ממד, וזה די מגניב.

160
00:08:09,380 --> 00:08:12,000
למעשה אתה יכול לקבל כמה שיותר
מצייני צד כרצונך.

161
00:08:12,000 --> 00:08:16,470
כך למשל, אם ברצונך ליצור
לוח למשחק צוללות, אשר,

162
00:08:16,470 --> 00:08:20,910
אם אי פעם שיחקת, הוא משחק שהוא
שיחק עם יתדות על 10 ב -10 רשת,

163
00:08:20,910 --> 00:08:22,450
אתה יכול ליצור מערך כזה.

164
00:08:22,450 --> 00:08:26,030
אפשר לומר בול
כיכר תושבת קרב 10

165
00:08:26,030 --> 00:08:29,590
כיכר הסוגר מרובעת סגורה
תושבת 10 סגורה סוגריים מרובעים.

166
00:08:29,590 --> 00:08:32,710
>> ואז, אתה יכול לבחור
לפרש את זה בראש שלך כמו 10

167
00:08:32,710 --> 00:08:35,576
ב -10 רשת של תאים.

168
00:08:35,576 --> 00:08:37,409
עכשיו, למעשה, בזיכרון,
זה באמת פשוט

169
00:08:37,409 --> 00:08:42,440
תישאר אלמנט 100,
מערך ממדי אחת.

170
00:08:42,440 --> 00:08:46,070
וזה, למעשה, הולך לאם אתה
יש שלושה ממדים או ארבעה או חמש.

171
00:08:46,070 --> 00:08:49,420
זה באמת פשוט להכפיל
כל indices--

172
00:08:49,420 --> 00:08:51,130
או כל הגודל
specifiers-- יחד,

173
00:08:51,130 --> 00:08:53,480
ואתה פשוט מקבל חד-ממדי
מערך של גודל ש.

174
00:08:53,480 --> 00:08:57,090
>> אבל במונחים של ארגון ו
הדמיה ותפיסה אנושית,

175
00:08:57,090 --> 00:08:59,240
יכול להיות שזה הרבה יותר קל
לעבוד עם רשת

176
00:08:59,240 --> 00:09:02,980
אם אתה עובד על משחק
כמו איקס עיגול או צוללות,

177
00:09:02,980 --> 00:09:05,179
או משהו כזה.

178
00:09:05,179 --> 00:09:06,970
זה הפשטה גדולה,
במקום שיש

179
00:09:06,970 --> 00:09:09,340
לחשוב על איקס עיגול
לוח כקו של תשע

180
00:09:09,340 --> 00:09:13,810
ריבועים או לוח הקרב
כקו של 100 ריבועים.

181
00:09:13,810 --> 00:09:16,010
10 על ידי 10 רשת או שלוש
על ידי שלוש רשת היא כנראה

182
00:09:16,010 --> 00:09:17,225
הרבה יותר קל לתפוס.

183
00:09:17,225 --> 00:09:19,820

184
00:09:19,820 --> 00:09:22,280
>> עכשיו, משהו באמת
חשוב על מערכים.

185
00:09:22,280 --> 00:09:25,950
אנחנו יכולים להתייחס לכל פרט
אלמנט של המערך כמשתנה.

186
00:09:25,950 --> 00:09:27,700
ראינו שקודם לכן
כשהיינו הקצאה

187
00:09:27,700 --> 00:09:32,240
הערך האמיתי לBooleans מסוים
או בדיקתם בתניות.

188
00:09:32,240 --> 00:09:35,960
אבל אנחנו לא יכולים לטפל בכל
מערכים עצמם כמשתנים.

189
00:09:35,960 --> 00:09:41,760
אנחנו לא יכולים, למשל, להקצות מערך אחד
למערך אחר באמצעות ההקצאה

190
00:09:41,760 --> 00:09:42,930
מפעיל.

191
00:09:42,930 --> 00:09:44,640
זה לא ג המשפטי

192
00:09:44,640 --> 00:09:47,920
>> אם אנחנו רוצים, לexample-- מה
אנחנו היו עושים בדוגמא ש

193
00:09:47,920 --> 00:09:50,200
יהיה להעתיק מערך אחד למשנו.

194
00:09:50,200 --> 00:09:53,810
אם אנחנו רוצים לעשות את זה, אנחנו באמת
צריך להשתמש בלולאה להעתיק מעל

195
00:09:53,810 --> 00:09:56,550
כל רכיב בודד אחד בכל פעם.

196
00:09:56,550 --> 00:09:58,700
אני יודע שזה מעט זמן רב.

197
00:09:58,700 --> 00:10:04,022
>> כך למשל, אם יש לנו זוג אלה
שורות קוד, היית עבודה זו?

198
00:10:04,022 --> 00:10:05,230
ובכן, לא, לא היית זה, נכון?

199
00:10:05,230 --> 00:10:07,860
מכיוון שאנחנו מנסים
כדי להקצות מזון לבר.

200
00:10:07,860 --> 00:10:09,860
זה לא הולך לעבודה,
כי זה מערך,

201
00:10:09,860 --> 00:10:13,130
ואנחנו רק תיארנו
שזה לא ג המשפטי

202
00:10:13,130 --> 00:10:15,580
>> במקום זאת, אם אנחנו רוצים
להעתיק את התוכן של מזון

203
00:10:15,580 --> 00:10:18,070
בשורת, וזה מה ש
אנחנו מנסים לעשות כאן,

204
00:10:18,070 --> 00:10:19,970
היינו צריך תחביר כמו זה.

205
00:10:19,970 --> 00:10:24,170
יש לנו ללולאה שעוברת
מJ שווה 0 עד 5,

206
00:10:24,170 --> 00:10:28,390
ואנחנו להגדיל J בכל איטרציה של
הלולאה ואלמנטים להקצות כזה.

207
00:10:28,390 --> 00:10:33,360
הדבר יביא גם בר
להיות אחד, שתיים, שלוש, ארבעה, חמש,

208
00:10:33,360 --> 00:10:36,730
אבל אנחנו צריכים לעשות את זה זה מאוד
דרך איטית אלמנט-ידי-יסוד,

209
00:10:36,730 --> 00:10:40,009
במקום רק על ידי
העתקת כל המערך.

210
00:10:40,009 --> 00:10:42,050
בתכנות אחר
שפות, מודרני יותר,

211
00:10:42,050 --> 00:10:45,610
אתה יכול, למעשה, לעשות בדיוק
שפשוט שווה תחביר.

212
00:10:45,610 --> 00:10:49,620
אבל C, למרבה הצער, אנחנו
אסור לעשות את זה.

213
00:10:49,620 --> 00:10:52,026
>> עכשיו, יש אחד אחר
דבר שאני רוצה לדבר

214
00:10:52,026 --> 00:10:54,650
על מערכים שיכול להיות קצת
קצת מסובך בפעם הראשונה ש

215
00:10:54,650 --> 00:10:55,990
לעבוד איתם.

216
00:10:55,990 --> 00:10:59,860
דנו בוידאו
על היקף משתנה,

217
00:10:59,860 --> 00:11:04,940
כי רוב המשתנים ב- C, כאשר אתה קורא
שלהם בפונקציות, מועברים על ידי ערך.

218
00:11:04,940 --> 00:11:08,620
האם אתה זוכר מה זה אומר
להעביר משהו בערך?

219
00:11:08,620 --> 00:11:12,570
זה אומר שאנחנו עושים עותק של
משתנה זה מועבר ב.

220
00:11:12,570 --> 00:11:16,290
פונקצית callee, הפונקציה
שמקבל משתנה,

221
00:11:16,290 --> 00:11:17,730
אינו מקבל את עצמו משתנה.

222
00:11:17,730 --> 00:11:20,850
זה נהיה מקומי שלה
עותק ממנו לעבוד איתו.

223
00:11:20,850 --> 00:11:24,070
>> מערכים, כמובן, לעשות
לא פעל כלל זה.

224
00:11:24,070 --> 00:11:27,600
במקום זאת, מה שאנחנו קוראים לזה
עובר על ידי התייחסות.

225
00:11:27,600 --> 00:11:31,360
Callee למעשה
אין לקבל את המערך.

226
00:11:31,360 --> 00:11:34,207
זה לא לקבלו
עותק מקומי של שלו.

227
00:11:34,207 --> 00:11:36,040
ואם אתה חושב על
זה, זה הגיוני.

228
00:11:36,040 --> 00:11:39,750
אם מערכים באמת גדולים, זה
לוקח זמן ומאמץ כל כך הרבה

229
00:11:39,750 --> 00:11:44,470
כדי ליצור עותק של מערך של
100 או 1,000 או 10,000 אלמנטים,

230
00:11:44,470 --> 00:11:48,290
שזה לא שווה את זה ל
לתפקד לקבל עותק שלו,

231
00:11:48,290 --> 00:11:51,037
לעשות קצת עבודה עם זה, ולאחר מכן
רק להיעשות עם העותק;

232
00:11:51,037 --> 00:11:53,120
זה לא צריך להיות
זה מסתובב יותר.

233
00:11:53,120 --> 00:11:54,710
>> בגלל מערכים כמה
מגושם ומסורבל,

234
00:11:54,710 --> 00:11:56,001
אנחנו פשוט להעביר אותם על ידי התייחסות.

235
00:11:56,001 --> 00:12:01,210
אנחנו פשוט סומכים על פונקציה ש
ל, לא לשבור שום דבר.

236
00:12:01,210 --> 00:12:03,010
אז זה ממש מקבל את המערך.

237
00:12:03,010 --> 00:12:05,290
הוא אינו מקבל העותק המקומי שלה שלה.

238
00:12:05,290 --> 00:12:07,170
>> אז מה זה אומר,
לאחר מכן, כאשר callee

239
00:12:07,170 --> 00:12:08,970
מתפעל אלמנטים של המערך?

240
00:12:08,970 --> 00:12:10,780
מה קורה?

241
00:12:10,780 --> 00:12:13,210
לעת עתה, אנו לחפות
על למה בדיוק זה

242
00:12:13,210 --> 00:12:15,320
קורה, למה מערכים
הם עברו על ידי התייחסות

243
00:12:15,320 --> 00:12:17,810
וכל דבר אחר הוא עבר על ידי ערך.

244
00:12:17,810 --> 00:12:20,470
אבל אני מבטיח לך, שיהיו
לחזור ולתת לך את התשובה

245
00:12:20,470 --> 00:12:23,750
לזה בוידאו בהמשך.

246
00:12:23,750 --> 00:12:28,110
>> הנה תרגיל יותר עבורך
לפני שלעטוף את הדברים על מערכים.

247
00:12:28,110 --> 00:12:31,400
החבורה של קוד כאן, זה
לא במיוחד סגנון טוב,

248
00:12:31,400 --> 00:12:33,400
רק אני אעשה את האזהרה ש.

249
00:12:33,400 --> 00:12:36,660
אין תגובות לכאן,
אשר היא צורה די רעה.

250
00:12:36,660 --> 00:12:39,750
אבל זה רק בגלל שאני רוצה להיות
תוכל להתאים את הכל על המסך.

251
00:12:39,750 --> 00:12:44,360
>> בחלק העליון, אתה יכול לראות שיש לי
שתי הצהרות פונקציה למערך קבוצה

252
00:12:44,360 --> 00:12:45,820
ולהגדיר int.

253
00:12:45,820 --> 00:12:49,680
מערך סט כנראה לוקח מערך
של ארבעה מספרים שלמים כקלט שלה.

254
00:12:49,680 --> 00:12:52,767
וint סט לוקח כנראה
שלם אחת כקלט שלה.

255
00:12:52,767 --> 00:12:54,350
אבל שניהם אין לי פלט.

256
00:12:54,350 --> 00:12:57,689
התפוקה, התמורה
הקלד, של כל אחד הוא חלל.

257
00:12:57,689 --> 00:12:59,480
בראשים, שיש לנו
כמה שורות של קוד.

258
00:12:59,480 --> 00:13:02,730
אנו מצהירים משתנים שלמים
נקרא ולהקצות לו את הערך 10.

259
00:13:02,730 --> 00:13:07,080
אנו מצהירים מערך של ארבעה מספרים שלמים
בשם B ולהקצות את האלמנטים 0, 1,

260
00:13:07,080 --> 00:13:08,730
2, ו- 3, בהתאמה.

261
00:13:08,730 --> 00:13:12,190
אז, יש לנו שיחה להגדיר
int ושיחה להגדיר מערך.

262
00:13:12,190 --> 00:13:15,910
ההגדרות של מערך קבוצה וסט
int הם למטה, בתחתית.

263
00:13:15,910 --> 00:13:17,640
>> וכך, שוב, אני שואל אותך את השאלה.

264
00:13:17,640 --> 00:13:20,770
מה מקבל הדפסת
כאן בסוף הראשי?

265
00:13:20,770 --> 00:13:23,020
יש col תדפיס. אני
להדפיס את שני מספרים שלמים.

266
00:13:23,020 --> 00:13:28,010
אני מדפיס את התוכן של ו
התוכן של הסוגר המרובע ב '0.

267
00:13:28,010 --> 00:13:29,880
להשהות את הווידאו כאן ולקחת דקות.

268
00:13:29,880 --> 00:13:35,482
אתה יכול להבין מה זה
פונקציה תדפיס בסוף?

269
00:13:35,482 --> 00:13:38,190
יש לקוות, אם אתה זוכר
הבחנה בין פטירתו של ערך

270
00:13:38,190 --> 00:13:41,680
ועובר על ידי התייחסות, זה
הבעיה לא הייתה מסובכת מדי בשבילך.

271
00:13:41,680 --> 00:13:44,130
ואתה היית התשובה
מצאתי היא זו.

272
00:13:44,130 --> 00:13:47,660
אם אתה לא ממש בטוח כמו ל
מדוע זה המקרה, לקחת שני,

273
00:13:47,660 --> 00:13:50,620
לחזור, לסקור את מה שאני היה רק
דיון על העברת מערכים

274
00:13:50,620 --> 00:13:53,450
על ידי התייחסות, לעומת עובר
משתנים אחרים על ידי ערך,

275
00:13:53,450 --> 00:13:56,680
ובתקווה, זה יעשה
קצת יותר הגיוני.

276
00:13:56,680 --> 00:13:59,760
>> אני דאג לויד, וזה CS50.

277
00:13:59,760 --> 00:14:01,467