1
00:00:07,260 --> 00:00:09,180
[Powered by Google Translate] Við skulum tala um structs.

2
00:00:09,180 --> 00:00:12,130
Structs gefa okkur leið til hóp fullt af breytum saman

3
00:00:12,130 --> 00:00:14,350
í a ágætur pakki.

4
00:00:14,350 --> 00:00:17,020
Það er líklega auðveldast að sjá dæmi strax,

5
00:00:17,020 --> 00:00:20,030
svo við segjum strúktúr,

6
00:00:20,030 --> 00:00:23,340
þá opna hrokkið Brace,

7
00:00:23,340 --> 00:00:26,630
og í þessum strúktúr, munum við hafa int aldri,

8
00:00:28,920 --> 00:00:31,350
a char * nafn,

9
00:00:31,350 --> 00:00:34,670
og það er það.

10
00:00:37,350 --> 00:00:40,650
Það kann að virðast skrýtið með semíkommu eftir hrokkið borsveif,

11
00:00:40,650 --> 00:00:43,620
en það er í raun nauðsynlegt structs.

12
00:00:43,620 --> 00:00:46,270
Hvaða gildi tegund getur farið í strúktúrinn skilgreiningu.

13
00:00:46,270 --> 00:00:49,530
Hér höfum við notað að int og char *,

14
00:00:49,530 --> 00:00:52,610
en þú getur líka notað fylki, um að segja, 100 þætti

15
00:00:52,610 --> 00:00:54,910
eða jafnvel annað strúktúr.

16
00:00:54,910 --> 00:00:56,960
Þegar þú ert að nota structs í C,

17
00:00:56,960 --> 00:00:58,430
þú ert að búa til nýjar tegundir

18
00:00:58,430 --> 00:01:00,860
út af safni af öðrum tegundum.

19
00:01:00,860 --> 00:01:02,620
Hér erum við að gera nýja tegund

20
00:01:02,620 --> 00:01:05,060
út af heiltölu og char *.

21
00:01:05,060 --> 00:01:07,400
Eins og við munum sjá síðar, a struct tegund

22
00:01:07,400 --> 00:01:10,700
er í a einhver fjöldi af lifnaðarhættir sem jafngilda öðrum tegund þú átt að venjast.

23
00:01:10,700 --> 00:01:13,310
Venjulega, ég er að bera saman hvernig strúktúr tegund

24
00:01:13,310 --> 00:01:15,790
er svipað heiltala tegund.

25
00:01:15,790 --> 00:01:18,520
Þó að númerið sem við skrifaði gildir C,

26
00:01:18,520 --> 00:01:20,320
það er ekki mjög gagnlegt,

27
00:01:20,320 --> 00:01:22,340
og clang mun gefa okkur viðvörun.

28
00:01:22,340 --> 00:01:24,970
Mundu hvernig structs og þess eru svipuð?

29
00:01:24,970 --> 00:01:26,710
Jæja, í grundvallaratriðum við bara segja

30
00:01:27,840 --> 00:01:30,060
int,

31
00:01:30,060 --> 00:01:33,140
sem er ekki mjög gagnlegt línu.

32
00:01:33,140 --> 00:01:35,760
Svo skulum í raun að lýsa yfir breytu af þeirri tegund

33
00:01:35,760 --> 00:01:38,760
með því að gefa honum nafn áður en semíkommu.

34
00:01:42,170 --> 00:01:45,000
Við munum hringja í breytilega nemanda.

35
00:01:48,190 --> 00:01:51,350
Nú höfum við lýst breytilega kallað nemandi

36
00:01:51,350 --> 00:01:53,980
við gerð gefið af strúktúr.

37
00:01:53,980 --> 00:01:56,730
Hvernig fáum við til breytur inni strúktúr?

38
00:01:56,730 --> 00:01:59,040
Tæknilega, nöfn fyrir þessar breytur

39
00:01:59,040 --> 00:02:01,070
eru meðlimir.

40
00:02:01,070 --> 00:02:04,000
Til að fá aðgang að þeim tiltekna félagi í nemanda struct,

41
00:02:04,000 --> 00:02:06,440
þú auka punkt að breyta nafni,

42
00:02:06,440 --> 00:02:08,860
eftir nafni félagi þú vilt.

43
00:02:08,860 --> 00:02:11,690
Svo hér, aðeins 2 gild möguleikar

44
00:02:11,690 --> 00:02:17,760
eru student.age

45
00:02:17,760 --> 00:02:24,460
og student.name.

46
00:02:24,460 --> 00:02:26,820
Og við getum gert eitthvað eins og

47
00:02:26,820 --> 00:02:30,320
student.age = 12

48
00:02:30,320 --> 00:02:39,310
og student.name = nemanda.

49
00:02:39,310 --> 00:02:42,580
Nú hvað ef við vildum að gera annað nemanda?

50
00:02:42,580 --> 00:02:44,760
Þú gætir held að afrita og líma þessar línur

51
00:02:44,760 --> 00:02:48,110
og breyta nemanda til nemanda 2 eða eitthvað,

52
00:02:48,110 --> 00:02:50,090
og sem vilja vinna,

53
00:02:50,090 --> 00:02:52,670
en tæknilega, nemandi og nemandi 2

54
00:02:52,670 --> 00:02:54,540
hafa ekki sömu gerð.

55
00:02:54,540 --> 00:02:56,940
Sjá, þú munt ekki vera fær um að framselja þá til annars.

56
00:02:56,940 --> 00:02:58,560
Þetta er vegna þess, að svo miklu leyti,

57
00:02:58,560 --> 00:03:00,950
struct hefur verið nafnlaus.

58
00:03:00,950 --> 00:03:02,290
Við þurfum að gefa honum nafn.

59
00:03:02,290 --> 00:03:04,420
Til að gera það, setja við nafnið á strúktúr

60
00:03:04,420 --> 00:03:06,950
eftir orðinu strúktúr.

61
00:03:09,440 --> 00:03:11,170
nemandi,

62
00:03:11,170 --> 00:03:14,680
eftir skilgreiningar.

63
00:03:16,500 --> 00:03:18,940
Við getum samt strax lýsa yfir breytu af tegund

64
00:03:18,940 --> 00:03:21,570
strúktúr nemanda, eins og við gerðum áður.

65
00:03:24,320 --> 00:03:28,360
Við munum kalla það S1

66
00:03:28,590 --> 00:03:30,760
Með því að gefa struct nafn,

67
00:03:30,760 --> 00:03:33,050
við getum nú notað struct nemanda

68
00:03:33,050 --> 00:03:36,950
í næstum nákvæmlega sama hátt við myndum nota int.

69
00:03:36,950 --> 00:03:39,580
Þannig að við getum lýst breytu af tegund strúktúrinn nemanda,

70
00:03:39,580 --> 00:03:42,360
eins og

71
00:03:42,360 --> 00:03:49,500
struct nemandi S2.

72
00:03:51,020 --> 00:03:55,130
Eins og fylki, veita structs á frumstilling smákaka setningafræði,

73
00:03:55,130 --> 00:03:58,670
þannig að við getum sagt, strúktúr nemandi S2

74
00:03:58,670 --> 00:04:01,420
jafngildir

75
00:04:01,420 --> 00:04:06,040
vinstri hrokkið Brace 3, S2.

76
00:04:09,210 --> 00:04:12,600
Hér S2.age verða 3,

77
00:04:12,600 --> 00:04:15,910
og S2.name mun benda á S2.

78
00:04:15,910 --> 00:04:19,149
Hugsaðu um allt það sem þú getur gert með int

79
00:04:19,149 --> 00:04:22,460
og flestir af þeim sem þú getur gert með nemanda strúktúrinn tegund.

80
00:04:22,460 --> 00:04:26,060
Við getum notað til strúktúr nemanda sem gerð fall viðfang.

81
00:04:26,060 --> 00:04:28,790
Við getum notað struct nemanda inni í nýja strúktúr.

82
00:04:28,790 --> 00:04:31,010
Við getum haft músina til að strúktúrinn nemanda.

83
00:04:31,010 --> 00:04:33,540
Við getum gert stærð nemanda strúktúrinn.

84
00:04:33,540 --> 00:04:35,510
Struct nemandi er gerð

85
00:04:35,510 --> 00:04:38,030
bara eins og int er gerð.

86
00:04:38,030 --> 00:04:40,540
Við getum einnig tengja S1 að S2

87
00:04:40,540 --> 00:04:43,760
Þar sem bæði eru af sömu gerð, þannig að við getum gert

88
00:04:44,390 --> 00:04:47,540
S1 = S2.

89
00:04:47,540 --> 00:04:50,430
Hvað gerist ef við gerum

90
00:04:50,430 --> 00:04:55,300
S1.age = 10?

91
00:04:56,340 --> 00:04:58,880
Er S2 breyting á öllum?

92
00:04:58,880 --> 00:05:02,800
Aftur, hugsa um structs bara eins og venjulegur heiltölur.

93
00:05:02,800 --> 00:05:05,590
Ef við gefum einhverjum int x að einhverju int Y,

94
00:05:05,590 --> 00:05:08,970
eins og X = Y

95
00:05:08,970 --> 00:05:10,850
og breyta X,

96
00:05:10,850 --> 00:05:14,230
eins og í X + +,

97
00:05:14,230 --> 00:05:17,020
er Y breyting á öllum?

98
00:05:17,020 --> 00:05:20,980
Y er ekki breytt hér, og svo hvorki er S2 ofan.

99
00:05:20,980 --> 00:05:24,120
S2.age er enn 3.

100
00:05:24,120 --> 00:05:27,350
En athugið að þegar framselja einn struct til annars,

101
00:05:27,350 --> 00:05:30,300
öllum ábendingum benda enn á sama,

102
00:05:30,300 --> 00:05:32,260
þar sem þeir voru bara að afrita.

103
00:05:32,260 --> 00:05:34,300
Ef þú vilt ekki að ábendingar til að deila,

104
00:05:34,300 --> 00:05:36,100
þú þarft að höndunum höndla það,

105
00:05:36,100 --> 00:05:39,780
kannski með malicking eitt blokk minni fyrir einn af ábendingum að benda á

106
00:05:39,780 --> 00:05:42,120
og afrita gögnin yfir.

107
00:05:42,120 --> 00:05:45,540
Það gæti verið pirrandi að þurfa að skrifa struct nemenda alls staðar.

108
00:05:45,540 --> 00:05:48,730
Using a tegund def, getum við gert

109
00:05:51,630 --> 00:05:55,850
tegund def

110
00:05:55,850 --> 00:05:58,830
strúktúr

111
00:05:58,830 --> 00:06:01,270
og við munum kalla það nemandi.

112
00:06:05,620 --> 00:06:08,360
Nú getum við notað nemenda alls staðar

113
00:06:08,360 --> 00:06:11,090
sem við notuðum til að nota struct nemanda.

114
00:06:11,090 --> 00:06:13,410
Þessi tegund def er nafnlaus strúktúr

115
00:06:13,410 --> 00:06:15,750
og kallar það nemandi.

116
00:06:15,750 --> 00:06:18,220
En ef við höldum einnig nemandi auðkenni

117
00:06:18,220 --> 00:06:22,380
við hliðina á orðinu struct, eins og í typedef strúktúr nemanda,

118
00:06:27,670 --> 00:06:31,590
við getum notað bæði strúktúr nemanda og nemandi jöfnum höndum núna.

119
00:06:31,590 --> 00:06:34,060
Þeir gera ekki einu sinni að hafa sama nafn.

120
00:06:34,060 --> 00:06:36,710
Við gætum slegið def struct nemanda við Bob

121
00:06:36,710 --> 00:06:38,950
og svo strúktúr nemanda og Bob

122
00:06:38,950 --> 00:06:41,270
væri víxlanlegur tegundir.

123
00:06:41,270 --> 00:06:44,050
Óháð því hvaða gerð def,

124
00:06:44,050 --> 00:06:46,750
þurfum við auðkenni hliðina strúktúr

125
00:06:46,750 --> 00:06:48,250
ef skilgreining á strúktúr

126
00:06:48,250 --> 00:06:50,450
er endurkvæma.

127
00:06:50,450 --> 00:06:52,620
Til dæmis,

128
00:06:52,620 --> 00:06:56,140
tegund def struct hnút

129
00:06:56,140 --> 00:07:01,200
og það verður skilgreint sem int Val

130
00:07:01,200 --> 00:07:05,420
og það mun hafa músina sem vísar til annars strúktúrinn hnút.,

131
00:07:05,420 --> 00:07:09,490
eins og í strúktúrinn hnút * næsta.

132
00:07:09,490 --> 00:07:13,670
Og þá munum við kalla það hnút.

133
00:07:15,490 --> 00:07:18,020
Þetta struct er endurkvæma,

134
00:07:18,020 --> 00:07:21,450
þar sem skilgreining á hnút strúktúrinn inniheldur innan þess

135
00:07:21,450 --> 00:07:24,200
bendi til strúktúrinn hnút.

136
00:07:24,200 --> 00:07:27,740
Takið eftir að við verðum að segja struct hnút * Næsta

137
00:07:27,740 --> 00:07:30,690
inni skilgreiningu á strúktúrinn hnút,

138
00:07:30,690 --> 00:07:33,620
þar sem tegund def hefur ekki lokið enn að leyfa okkur að einfalda þetta

139
00:07:33,620 --> 00:07:36,210
við bara hnút * næst.

140
00:07:36,210 --> 00:07:39,260
Þú munt læra meira um structs svipað þessu

141
00:07:39,260 --> 00:07:41,750
þegar að takast á við tengd listum og tré.

142
00:07:41,750 --> 00:07:44,130
Hvað structs í aðgerð?

143
00:07:44,130 --> 00:07:46,800
Þetta er líka fullkomlega gild.

144
00:07:46,800 --> 00:07:49,430
Við gætum hafa

145
00:07:49,430 --> 00:07:53,630
ógilt störf

146
00:07:53,630 --> 00:07:55,930
sem tekur sem rök,

147
00:07:55,930 --> 00:07:59,590
nemandi s

148
00:07:59,590 --> 00:08:02,790
og gerir eitthvað með þeim nemanda.

149
00:08:05,270 --> 00:08:08,450
Og þá getum við að gefa það sem strúktúr nemenda eins og svo.

150
00:08:08,450 --> 00:08:12,850
Störf í S1 undan.

151
00:08:12,850 --> 00:08:15,230
The struct hagar sér

152
00:08:15,230 --> 00:08:18,460
nákvæmlega sem heiltala væri þegar liðin til að virka.

153
00:08:18,460 --> 00:08:21,510
Störf fær afrit af S1

154
00:08:21,510 --> 00:08:23,690
og svo má ekki breyta S1;

155
00:08:23,690 --> 00:08:27,110
heldur aðeins afrit af því sem er geymt í S.

156
00:08:27,110 --> 00:08:30,010
Ef þú vilt að virka til að vera fær um að breyta S1,

157
00:08:30,010 --> 00:08:33,000
störf þurfa að taka nemanda * s,

158
00:08:33,000 --> 00:08:36,570
og þú þarft að fara S1 eftir heimilisfangi, eins og svo.

159
00:08:37,549 --> 00:08:41,100
Student * S, störf og S1.

160
00:08:41,100 --> 00:08:44,760
Það er önnur ástæða til að fara með heimilisfang hér.

161
00:08:44,760 --> 00:08:48,030
Hvað ef strúktúr okkar innihélt 100 reiti?

162
00:08:48,030 --> 00:08:51,250
Hvert einasta skipti sem við standast nemanda við störf,

163
00:08:51,250 --> 00:08:55,770
kerfi okkar þarf að afrita allar þessar 100 sviðum í S rifrildi störf er,

164
00:08:55,770 --> 00:08:59,320
jafnvel ef það notar aldrei mikill meirihluti þeirra.

165
00:08:59,320 --> 00:09:02,700
Svo jafnvel ef störf ekki ætla að breyta nemanda,

166
00:09:02,700 --> 00:09:05,170
Ef geta enn vera dýrmæt líða heimilisfang.

167
00:09:05,170 --> 00:09:08,990
Jæja, hvað ef við viljum búa til bendi til strúktúr?

168
00:09:08,990 --> 00:09:11,130
Við gætum gert eitthvað eins og

169
00:09:11,130 --> 00:09:17,580
Nemandi * S

170
00:09:17,580 --> 00:09:20,980
jafngildir malloc

171
00:09:20,980 --> 00:09:26,600
stærð nemanda.

172
00:09:30,450 --> 00:09:33,590
Takið eftir að stærð samt virkar hér.

173
00:09:33,590 --> 00:09:37,260
Svo hvernig gera við aðgang nú aldri félagi

174
00:09:37,260 --> 00:09:39,640
í blokk Það er bendir á?

175
00:09:39,640 --> 00:09:42,300
Þú gætir fyrst að hugsa til að gera

176
00:09:42,300 --> 00:09:47,970
* S.age = 4,

177
00:09:47,970 --> 00:09:50,220
en það mun ekki alveg virka.

178
00:09:50,220 --> 00:09:52,940
Þar sem þetta mun í raun að túlka sem

179
00:09:52,940 --> 00:09:57,740
* S.age í sviga = 4,

180
00:09:57,740 --> 00:10:00,160
sem mun ekki einu sinni saman,

181
00:10:00,160 --> 00:10:03,600
þar S er ekki strúktúr eða frekar bendi til strúktúr,

182
00:10:03,600 --> 00:10:06,270
og svo punktur vilja ekki vinna hér.

183
00:10:06,270 --> 00:10:08,860
Við gætum gert

184
00:10:08,860 --> 00:10:13,760
(* S). Aldur = 4

185
00:10:13,760 --> 00:10:16,790
en svigar geta fá pirrandi og truflandi.

186
00:10:16,790 --> 00:10:19,880
Sem betur fer, höfum við sérstaka ör stjórnandi

187
00:10:19,880 --> 00:10:22,350
sem lítur eitthvað eins og

188
00:10:22,350 --> 00:10:28,860
S-> aldur = 4.

189
00:10:28,860 --> 00:10:31,600
Þessir 2 leiðir tilvísun aldri

190
00:10:31,600 --> 00:10:33,270
eru jafngild

191
00:10:33,270 --> 00:10:36,870
og við í raun ekki alltaf þörf á örina rekstraraðila,

192
00:10:36,870 --> 00:10:39,300
en það gerir það líta ágætur.

193
00:10:39,300 --> 00:10:43,050
Þar S er bendi að einhverju blokk minni sem inniheldur struct,

194
00:10:43,050 --> 00:10:47,820
hægt er að hugsa um S> aldri sem fylgja músina ör

195
00:10:47,820 --> 00:10:50,250
og grípa aldri félagi.

196
00:10:50,250 --> 00:10:53,750
Svo hvers vegna ættum við að nota alltaf structs?

197
00:10:53,750 --> 00:10:57,560
Það er örugglega hægt að komast upp með aðeins frumstæðum heiltölur

198
00:10:57,560 --> 00:10:59,050
chars, ábendingum og þess háttar

199
00:10:59,050 --> 00:11:01,550
sem við erum að nota til að;

200
00:11:01,550 --> 00:11:03,340
stað S1 og S2 áður,

201
00:11:03,340 --> 00:11:06,290
við gætum haft age1, age2, NAME1 og NAME2

202
00:11:06,290 --> 00:11:09,120
allt á mismunandi breytum.

203
00:11:09,120 --> 00:11:11,390
Þetta er allt í lagi með aðeins 2 nemendur,

204
00:11:11,390 --> 00:11:13,310
en hvað ef við hefðum 10 af þeim?

205
00:11:13,310 --> 00:11:15,540
Og hvað ef í stað þess að aðeins 2 svið,

206
00:11:15,540 --> 00:11:17,720
nemandi strúktúr hafði 100 sviðum?

207
00:11:17,720 --> 00:11:21,240
GPA, námskeið, hár lit, kyn, og svo framvegis.

208
00:11:21,240 --> 00:11:25,790
Í stað þess að aðeins 10 structs, þurfum við 1.000 aðskilin breytur.

209
00:11:25,790 --> 00:11:28,360
Einnig skaltu íhuga aðgerð

210
00:11:28,360 --> 00:11:32,270
sem tekur að strúktúr með 100 reiti með aðeins röksemdafærslu hennar

211
00:11:32,270 --> 00:11:34,350
og prentar út alla reiti.

212
00:11:34,350 --> 00:11:36,320
Ef við höfum ekki nota struct,

213
00:11:36,320 --> 00:11:38,540
hvert einasta skipti sem við köllum að virka,

214
00:11:38,540 --> 00:11:41,460
við þurfum að fara á alla 100 breytur,

215
00:11:41,460 --> 00:11:44,430
og ef við höfum 100 breytur fyrir nemendur 1.,

216
00:11:44,430 --> 00:11:47,020
og 100 breytur fyrir nemanda 2,

217
00:11:47,020 --> 00:11:50,540
við þurfum að vera viss um að við gerum ekki óvart framhjá nokkrum breytum frá nemanda 1

218
00:11:50,540 --> 00:11:52,910
og sumir breytur af nemanda 2.

219
00:11:52,910 --> 00:11:55,710
Það er ómögulegt að gera þessi mistök með strúktúr,

220
00:11:55,710 --> 00:11:59,010
þar sem allar 100 breytur eru í einum pakka.

221
00:11:59,010 --> 00:12:02,050
Bara nokkrar endanlega skýringum:

222
00:12:02,050 --> 00:12:04,870
Ef þú hefur skilið allt fram að þessu, frábært.

223
00:12:04,870 --> 00:12:07,900
The hvíla af the vídeó er bara fyrir sakir heilleika '.

224
00:12:07,900 --> 00:12:11,010
Þar structs getur haldið hvers konar músina,

225
00:12:11,010 --> 00:12:14,220
þeir geta einnig haldið virka ábendingum.

226
00:12:14,220 --> 00:12:17,040
Ef þú ert kunnuglegur með mótmæla stilla af forritun,

227
00:12:17,040 --> 00:12:21,790
þetta veitir möguleika til að nota structs að forrita í hlut stilla stíl.

228
00:12:21,790 --> 00:12:24,500
Meira á ábendingum virka á öðrum tíma.

229
00:12:24,500 --> 00:12:27,760
Einnig, stundum þú gætir hafa 2 structs

230
00:12:27,760 --> 00:12:30,220
skilgreiningar Hvers ráðast á annan.

231
00:12:30,220 --> 00:12:32,320
Til dæmis,

232
00:12:32,320 --> 00:12:35,470
við gætum hafa struct A,

233
00:12:35,470 --> 00:12:38,580
sem er skilgreint sem

234
00:12:38,580 --> 00:12:41,910
bendi til strúktúrinn B,

235
00:12:41,910 --> 00:12:47,180
struct B * X,

236
00:12:47,180 --> 00:12:50,470
og nú getum við haft struct B

237
00:12:53,890 --> 00:12:56,280
sem er skilgreint sem bendillinn

238
00:12:56,280 --> 00:12:59,180
til a struct A,

239
00:12:59,180 --> 00:13:03,640
struct A * Y.

240
00:13:07,230 --> 00:13:09,060
En þetta mun ekki þýða,

241
00:13:09,060 --> 00:13:14,110
þar struct B er ekki til á þeim tíma sem strúktúr A er unnin.

242
00:13:14,110 --> 00:13:17,600
Og ef við skipta strúktúr A og struct B,

243
00:13:17,600 --> 00:13:20,100
þá viljum við bara vera vinstri með sama vandamál,

244
00:13:20,100 --> 00:13:22,640
í þetta sinn, með strúktúr A ekki fyrir hendi.

245
00:13:22,640 --> 00:13:24,720
Til að leysa þetta, getum við skrifað

246
00:13:24,720 --> 00:13:29,290
strúktúr B;

247
00:13:29,290 --> 00:13:32,460
fyrir skilgreiningu á strúktúr A.

248
00:13:32,460 --> 00:13:35,590
Þetta er kallað fram yfirlýsingu.

249
00:13:35,590 --> 00:13:38,590
Þetta gerir bara þýðanda veit að

250
00:13:38,590 --> 00:13:42,040
struct B er gild tegund sem verður að fullu skilgreind síðar eða annars staðar.

251
00:13:42,040 --> 00:13:45,980
Mitt nafn er Rob Bowden, og þetta er CS50.

252
00:13:45,980 --> 00:13:48,980
[CS50.TV]