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

2
00:00:02,395 --> 00:00:05,750

3
00:00:05,750 --> 00:00:06,506
>> דאג LLOYD: אישור.

4
00:00:06,506 --> 00:00:08,880
אנחנו כבר עובדים עם מספרים שלמים,
אנחנו כבר עבדנו עם דמויות,

5
00:00:08,880 --> 00:00:11,930
אנחנו כבר עובדים צף,
זוגות, מחרוזות, וbools.

6
00:00:11,930 --> 00:00:14,870
אנחנו כבר מיצינו פחות או יותר את כל
של [לא ברור] הסוגים ש

7
00:00:14,870 --> 00:00:17,100
היה זמין לכולנו יחד.

8
00:00:17,100 --> 00:00:19,430
אבל עכשיו אנחנו רוצים לעשות משהו יותר.

9
00:00:19,430 --> 00:00:20,210
איך אנחנו עושים את זה?

10
00:00:20,210 --> 00:00:22,560
איך ליצור סוגי נתונים שונים?

11
00:00:22,560 --> 00:00:26,130
אנחנו יכולים לעשות זאת על ידי שימוש במבנים.

12
00:00:26,130 --> 00:00:30,180
אז מבנים מאפשרים לנו לאחד
משתנה מטיפוסים שונים

13
00:00:30,180 --> 00:00:34,810
לסוג אחד, חדש משתנה,
שבו אנו יכולים להקצות שם הסוג שלו.

14
00:00:34,810 --> 00:00:37,570
זה באמת חזק
דבר להיות מסוגל לעשות,

15
00:00:37,570 --> 00:00:40,900
כי עכשיו אנחנו יכולים קבוצה
אלמנטי סוגי נתונים שונים של

16
00:00:40,900 --> 00:00:43,910
יחד שיש להם קשר הגיוני.

17
00:00:43,910 --> 00:00:46,440
אנחנו כבר יכולים לעשות את זה
עם מערכי סוג של, נכון?

18
00:00:46,440 --> 00:00:49,540
אנחנו יכולים משתני קבוצה
מאותו סוג נתונים

19
00:00:49,540 --> 00:00:53,410
יחד ביחידה גדולה
זיכרון, מערך.

20
00:00:53,410 --> 00:00:56,660
>> אבל אנחנו לא הצלחנו לערבב
עד סוגי נתונים שונים ביחד.

21
00:00:56,660 --> 00:01:02,610
אנחנו לא יכולים, לומר, זוג שלם,
ואופי, וכפול כל

22
00:01:02,610 --> 00:01:05,330
באותו הדבר ו
קורא לזה יחידה אחת.

23
00:01:05,330 --> 00:01:08,830
אבל עם מבנים, או
לעתים קרובות מכונה structs,

24
00:01:08,830 --> 00:01:09,585
למעשה אנחנו יכולים.

25
00:01:09,585 --> 00:01:12,370
אז מבנה הוא סוג
כמו משתנה סופר.

26
00:01:12,370 --> 00:01:16,530
זה משתנה שמכיל
משתנים אחרים בתוכו.

27
00:01:16,530 --> 00:01:19,650
אז הנה דוגמא ל
מבנה פשוט מאוד.

28
00:01:19,650 --> 00:01:23,380
זה מה שהיה נראה התחביר
רוצה ליצור מבנה למכונית.

29
00:01:23,380 --> 00:01:25,250
עכשיו, בואו נלך דרך התחביר כאן.

30
00:01:25,250 --> 00:01:27,400
Struct, זה
מילת המפתח שמצביע

31
00:01:27,400 --> 00:01:30,270
שאני יוצר סוג נתונים חדש כאן.

32
00:01:30,270 --> 00:01:33,860
בפרט, שמו של סוג הנתונים הוא
הולך להיות מכונית struct, כפי שנראה.

33
00:01:33,860 --> 00:01:36,640
אבל זה הסוג של קצה
מחוץ למהדר שזה

34
00:01:36,640 --> 00:01:42,440
כקבוצה של משתנים שהוא הולך
כדי להיחשב חלק מאותו הסוג

35
00:01:42,440 --> 00:01:44,010
בדקה.

36
00:01:44,010 --> 00:01:46,340
>> מכוניות, רק את שמו של המבנה.

37
00:01:46,340 --> 00:01:50,590
שוב, את סוג הנתונים כאן הולך
להיות מכונית struct, לא רק מכונית.

38
00:01:50,590 --> 00:01:53,060
אבל אם יש לך different--
אם אתה יוצר structs מרובה

39
00:01:53,060 --> 00:01:56,950
באותה התכנית, אתה צריך
להבחין בין struct וstruct.

40
00:01:56,950 --> 00:02:00,140
מכונית אז struct, אני יכול גם
סטודנט struct, למשל,

41
00:02:00,140 --> 00:02:01,790
באותה התכנית.

42
00:02:01,790 --> 00:02:05,980
בתוך הסוגריים המסולסלים הם
כל השדות שנקרא,

43
00:02:05,980 --> 00:02:07,954
או חברים של המבנה.

44
00:02:07,954 --> 00:02:10,370
אז מה הם כמה הדברים
כי הם הגלומים במכונית?

45
00:02:10,370 --> 00:02:15,270
ובכן, בדרך כלל יש לו שנה, יש
שם דגם, ולוחית רישוי,

46
00:02:15,270 --> 00:02:18,000
מד מרחק, כי בדרך כלל יש
כמה מספר הקילומטרים על זה,

47
00:02:18,000 --> 00:02:19,225
ואולי נפח מנוע.

48
00:02:19,225 --> 00:02:23,570
וכמו שאתה יכול לראות, אני מערבב עד
מספרים שלמים ודמויות וזוגות.

49
00:02:23,570 --> 00:02:26,420
הם כולם הולכים להיות
חלק מסוג נתונים החדש.

50
00:02:26,420 --> 00:02:29,750
>> לבסוף, הדבר האחרון שאני צריך לעשות,
אל תשכחו פסיק הקטן הזה

51
00:02:29,750 --> 00:02:30,290
בסוף.

52
00:02:30,290 --> 00:02:34,380
לאחר שנסיים להגדיר את המבנה,
אנחנו צריכים לשים פסיק בסוף.

53
00:02:34,380 --> 00:02:37,325
זה תחבירי נפוץ מאוד
טעות, כי עם פונקציה,

54
00:02:37,325 --> 00:02:40,200
לדוגמא, היית צריכים רק
סד פתוח מתולתל, מסולסל סד קרוב.

55
00:02:40,200 --> 00:02:42,950
אתה לא שם פסיק ב
סוף הגדרת פונקציה.

56
00:02:42,950 --> 00:02:46,430
זה נראה כמו פונקציה
הגדרה, אבל זה לא,

57
00:02:46,430 --> 00:02:49,653
וכך פסיק שם
רק תזכורת ש

58
00:02:49,653 --> 00:02:52,440
צריך לשים אותו שם, כי
מהדר אחרת לא

59
00:02:52,440 --> 00:02:53,510
יודע מה לעשות עם זה.

60
00:02:53,510 --> 00:02:56,160
זה שגיאה נפוצה מאוד
כדי להפוך את טעות

61
00:02:56,160 --> 00:02:58,570
כאשר אתה מגדיר מבנים ראשון.

62
00:02:58,570 --> 00:02:59,500
>> אוקיי.

63
00:02:59,500 --> 00:03:02,824
אז אנחנו בדרך כלל להגדיר המבנים שלנו
בחלקו העליון של התוכניות שלנו

64
00:03:02,824 --> 00:03:05,490
כי הם כנראה הולכים
לשימוש על ידי פונקציות מרובות.

65
00:03:05,490 --> 00:03:08,850
אנחנו לא רוצים להגדיר
struct הפנימי של פונקציה,

66
00:03:08,850 --> 00:03:12,110
כי אז אנחנו יכולים only--
היקף המבנה באמת

67
00:03:12,110 --> 00:03:13,790
רק קיים בתוך הפונקציה ש.

68
00:03:13,790 --> 00:03:17,450
אנחנו בטח רוצים להגדיר מבנה
כדי שנוכל להשתמש בו בפונקציות מרובות,

69
00:03:17,450 --> 00:03:20,670
או אולי במספר רב של
קבצים שקשורים יחד

70
00:03:20,670 --> 00:03:22,920
כדי ליצור התכנית אחת שלנו.

71
00:03:22,920 --> 00:03:24,920
לפעמים גם במקום
הגדרת המבנה

72
00:03:24,920 --> 00:03:27,961
בחלקו העליון איפה אתה שם אותך
פאונד כולל והליש"ט מגדירה,

73
00:03:27,961 --> 00:03:32,080
לדוגמא, ייתכן שלשים אותם
קבצי h הנקודה נפרדים, אשר לאחר מכן

74
00:03:32,080 --> 00:03:35,020
פאונד כולל את עצמך.

75
00:03:35,020 --> 00:03:37,620
>> אז יש לנו מבנים, אבל עכשיו
אנחנו צריכים לקבל בתוכם.

76
00:03:37,620 --> 00:03:39,800
איך אנחנו מגיעים בתוך
מבנה לגישה

77
00:03:39,800 --> 00:03:43,530
אלה תת-משתנים, משתנה אלה
שקיים בתוך המבנה?

78
00:03:43,530 --> 00:03:46,810
ובכן, יש לנו משהו שנקרא
מפעיל הנקודה, אשר מאפשר לנו

79
00:03:46,810 --> 00:03:50,990
כדי לגשת לשדות של המבנה.

80
00:03:50,990 --> 00:03:55,490
כך למשל, נניח שהכרזתי
נתוני מבני להקליד איפשהו

81
00:03:55,490 --> 00:03:59,020
בחלק העליון של התכנית שלי, או אולי ב
קובץ h נקודה שיש לי לירה כלולה.

82
00:03:59,020 --> 00:04:03,360
אם אני מכן רוצה ליצור חדש
משתנה מסוג שהנתונים, אני יכול לומר,

83
00:04:03,360 --> 00:04:06,260
המכונית struct, המכונית שלי, נקודה-פסיק.

84
00:04:06,260 --> 00:04:11,580
בדיוק כמו שאני יכול לומר int
x, או שם מחרוזת פסיק.

85
00:04:11,580 --> 00:04:18,100
>> סוג הנתונים כאן הוא המכונית struct,
השם המשתנה הוא המכונית שלי,

86
00:04:18,100 --> 00:04:23,770
ואז אני יכול להשתמש במפעיל הנקודה ל
לגשת לתחומים השונים של המכונית שלי.

87
00:04:23,770 --> 00:04:27,494
אז אני יכול לומר את המכונית שלי
שנה הנקודה שווה 2011.

88
00:04:27,494 --> 00:04:28,410
זה בסדר גמור.

89
00:04:28,410 --> 00:04:34,210
שנה, אם אתה זוכר, הוגדרה כ
שדה שלם בתוך המכונית struct זה

90
00:04:34,210 --> 00:04:35,200
סוג מידע.

91
00:04:35,200 --> 00:04:39,966
אז כל משתנה של נתוני רכב struct
סוג, כגון המכונית שלי, אני יכול לומר את המכונית שלי

92
00:04:39,966 --> 00:04:44,030
שנה נקודה שווה ולאחר מכן להקצות
זה חלק המספר שלם, 2011.

93
00:04:44,030 --> 00:04:47,290
צלחת נקודת מכונית שלי שווה CS50.

94
00:04:47,290 --> 00:04:51,180
מד מרחק נקודת כרטיס שלי
שווה 50,505 פסיק.

95
00:04:51,180 --> 00:04:53,270
כל אלה הם
בסדר גמור וזה

96
00:04:53,270 --> 00:04:57,802
איך אנחנו לגשת ל
שדות של המבנה.

97
00:04:57,802 --> 00:05:00,260
מבנים, אם כי, לא צריכים
להיווצר בערימה.

98
00:05:00,260 --> 00:05:02,950
בדיוק כמו כל משתנה אחרים, אנחנו
דינמי יכול להקצות אותם.

99
00:05:02,950 --> 00:05:06,309
אם יש לנו תכנית שאולי
להיות יצירת מבנים רבים,

100
00:05:06,309 --> 00:05:08,100
אנחנו לא יודעים כמה
אנחנו הולכים צריכים,

101
00:05:08,100 --> 00:05:10,800
אז אנחנו צריכים באופן דינמי
להקצות מבנים אלה

102
00:05:10,800 --> 00:05:12,960
כתכנית שלנו פועל.

103
00:05:12,960 --> 00:05:16,600
ולכן אם אנחנו הולכים כדי לגשת ל
שדות של מבנה בהקשר זה,

104
00:05:16,600 --> 00:05:20,660
תזכיר כי אנחנו קודם צריכים dereference
המצביע למבנה,

105
00:05:20,660 --> 00:05:24,810
ואז ברגע שאנחנו dereference
מצביע, אז אנחנו יכולים לגשת לשדות.

106
00:05:24,810 --> 00:05:26,830
אם יש לנו רק
מצביע למבנה,

107
00:05:26,830 --> 00:05:32,120
אנחנו לא יכולים פשוט לומר שדה נקודת מצביע
שם ולקבל את מה שאנחנו מחפשים.

108
00:05:32,120 --> 00:05:34,259
יש צעד הנוסף של ביטול הפניה.

109
00:05:34,259 --> 00:05:36,050
אז בואו נגיד ש
במקום previous--

110
00:05:36,050 --> 00:05:38,770
בדיוק כמו בדוגמא הקודמת,
במקום להצהיר על כך

111
00:05:38,770 --> 00:05:43,680
על הערימה, מכונית struct,
מכונית, פסיק, אני אומר מכונית struct,

112
00:05:43,680 --> 00:05:48,020
כוכב, מצביע ל
המכונית struct בשם המכונית שלי,

113
00:05:48,020 --> 00:05:51,250
שווה גודל malloc של המכונית struct.

114
00:05:51,250 --> 00:05:54,950
גודל שלנו יהיה להבין כמה
ביטי סוג הנתונים החדש שלך לוקח את.

115
00:05:54,950 --> 00:05:58,570
אתה לא צריך בהכרח רק לשימוש
גודל, רוחב, int, char או, או כל

116
00:05:58,570 --> 00:05:59,715
של סוגי נתונים מובנים.

117
00:05:59,715 --> 00:06:02,090
מהדר הוא מספיק חכם
כדי להבין כמה בתים

118
00:06:02,090 --> 00:06:04,170
נדרשים על ידי המבנה החדש שלך.

119
00:06:04,170 --> 00:06:09,610
אז אני malloc עצמי יחידה של זיכרון
גדול מספיק כדי להחזיק מכונית struct,

120
00:06:09,610 --> 00:06:12,410
ואני מקבל את מצביע חזרה
לבלוק של זיכרון,

121
00:06:12,410 --> 00:06:16,090
והמצביע שהוקצה למכונית שלי.

122
00:06:16,090 --> 00:06:18,050
>> עכשיו, אם אני רוצה גישה
השדות של המכונית שלי,

123
00:06:18,050 --> 00:06:22,615
אני משתמש בראשון dereference המכונית שלי
מפעיל dereference, הכוכב

124
00:06:22,615 --> 00:06:26,620
שראינו מהמצביעים
קטעי וידאו, ולאחר מכן אחרי שdereference,

125
00:06:26,620 --> 00:06:32,200
אז אני יכול להשתמש במפעיל הנקודה ל
לגשת לתחומים השונים של המכונית שלי.

126
00:06:32,200 --> 00:06:35,490
כוכב המכונית שלי נקודת השנה שווה 2011.

127
00:06:35,490 --> 00:06:38,480
שיהיה לי ההשפעה
אנחנו רוצים במקרה זה,

128
00:06:38,480 --> 00:06:41,960
כי יש לנו באופן דינמי
הוקצה המכונית שלי.

129
00:06:41,960 --> 00:06:43,610
>> זה סוג של מעצבן, אם כי, נכון?

130
00:06:43,610 --> 00:06:44,818
יש תהליך 2-צעד עכשיו.

131
00:06:44,818 --> 00:06:47,460
עכשיו אנחנו צריכים dereference--
יש לנו מפעיל כוכב,

132
00:06:47,460 --> 00:06:48,910
ויש לנו מפעיל נקודה.

133
00:06:48,910 --> 00:06:51,660
וכפי שאפשר לצפות, כי
מתכנת C אוהב דרכים קצרות יותר

134
00:06:51,660 --> 00:06:53,740
לעשות דברים, יש
דרך קצרה יותר לעשות את זה.

135
00:06:53,740 --> 00:06:57,790
יש מפעיל אחר נקרא חץ,
מה שהופך את התהליך הזה הרבה יותר קל.

136
00:06:57,790 --> 00:07:00,750
דרך חץ עובד היא
dereferences הראשון זה

137
00:07:00,750 --> 00:07:03,560
המצביע על השמאל
צד של המפעיל,

138
00:07:03,560 --> 00:07:06,620
ולאחר מכן, לאחר שdereferenced
המצביע על השמאל,

139
00:07:06,620 --> 00:07:09,620
זה ניגש לשדה בצד הימין.

140
00:07:09,620 --> 00:07:14,170
וכך בעבר היו לנו סוג זה
של כוכב המכונית שלי dot את כל הדברים האלה,

141
00:07:14,170 --> 00:07:15,880
כמו היה הרבה קורה שם.

142
00:07:15,880 --> 00:07:22,040
אבל מה שאנחנו יכולים לעשות הוא במקום זה--
השנה שלי חץ רכב שווה 2011.

143
00:07:22,040 --> 00:07:23,580
>> שוב, מה קורה כאן?

144
00:07:23,580 --> 00:07:25,720
ראשית, אני ביטול הפנית המכונית שלי.

145
00:07:25,720 --> 00:07:27,810
אשר שוב, הוא מצביע כאן.

146
00:07:27,810 --> 00:07:31,270
ואז, לאחר ש
dereferenced המכונית שלי, אני

147
00:07:31,270 --> 00:07:35,130
לאחר מכן תוכל לגשת לשדות
שנה, צלחת, ומד מרחק

148
00:07:35,130 --> 00:07:40,020
בדיוק כמו שאני יכול לפני שראשון
כוכב משומש לdereference המכונית שלי,

149
00:07:40,020 --> 00:07:42,020
ונקודה כדי לגשת לשדה.

150
00:07:42,020 --> 00:07:45,290
אז אתה יכול לקבל מבנים,
יכול להיות מצביעים למבנים,

151
00:07:45,290 --> 00:07:48,360
ויש לך דרכים גישה
השדות של מבנים אלה,

152
00:07:48,360 --> 00:07:52,600
אם יש לך עצות ל
שלהם או המשתנים עצמם.

153
00:07:52,600 --> 00:07:57,640
דוט או חץ, בהתאם ל
איך משתנה הוכרז.

154
00:07:57,640 --> 00:08:00,510
אני דאג לויד, זה CS50.

155
00:08:00,510 --> 00:08:01,975