1
00:00:07,260 --> 00:00:09,180
[Powered by Google Translate] La oss snakke om structs.

2
00:00:09,180 --> 00:00:12,130
Structs gir oss en måte å gruppere en haug med variabler sammen

3
00:00:12,130 --> 00:00:14,350
inn i en fin pakke.

4
00:00:14,350 --> 00:00:17,020
Det er trolig lettest å se et eksempel med en gang,

5
00:00:17,020 --> 00:00:20,030
så vi sier struct,

6
00:00:20,030 --> 00:00:23,340
deretter åpne krøllete brace,

7
00:00:23,340 --> 00:00:26,630
og i dette struct, vil vi ha en int alder,

8
00:00:28,920 --> 00:00:31,350
en char * navn,

9
00:00:31,350 --> 00:00:34,670
og det er det.

10
00:00:37,350 --> 00:00:40,650
Det kan virke merkelig med et semikolon etter en krøllete brace,

11
00:00:40,650 --> 00:00:43,620
men det er faktisk nødvendig med structs.

12
00:00:43,620 --> 00:00:46,270
Enhver gyldig type kan gå i struct definisjonen.

13
00:00:46,270 --> 00:00:49,530
Her har vi brukt en int og en char *,

14
00:00:49,530 --> 00:00:52,610
men du kan også bruke en matrise, av si 100 elementer

15
00:00:52,610 --> 00:00:54,910
eller en annen struct.

16
00:00:54,910 --> 00:00:56,960
Når du bruker structs i C,

17
00:00:56,960 --> 00:00:58,430
du oppretter nye typer

18
00:00:58,430 --> 00:01:00,860
ut av en samling av andre typer.

19
00:01:00,860 --> 00:01:02,620
Her gjør vi en ny type

20
00:01:02,620 --> 00:01:05,060
ut av et heltall og en char *.

21
00:01:05,060 --> 00:01:07,400
Som vi skal se senere, en struct typen

22
00:01:07,400 --> 00:01:10,700
er på mange måter tilsvarer en annen type du er vant til.

23
00:01:10,700 --> 00:01:13,310
Vanligvis vil jeg være sammenligne hvordan en struct typen

24
00:01:13,310 --> 00:01:15,790
er lik et heltall attraksjon.

25
00:01:15,790 --> 00:01:18,520
Mens koden vi skrev er gyldig C,

26
00:01:18,520 --> 00:01:20,320
det er ikke veldig nyttig,

27
00:01:20,320 --> 00:01:22,340
og clang vil gi oss en advarsel.

28
00:01:22,340 --> 00:01:24,970
Husk hvordan structs og dens ligner?

29
00:01:24,970 --> 00:01:26,710
Vel, vi i utgangspunktet bare sa

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

31
00:01:30,060 --> 00:01:33,140
som ikke er en veldig nyttig linje.

32
00:01:33,140 --> 00:01:35,760
Så la oss faktisk erklære en variabel av denne typen

33
00:01:35,760 --> 00:01:38,760
ved å gi den et navn før semikolon.

34
00:01:42,170 --> 00:01:45,000
Vi kaller variabelen student.

35
00:01:48,190 --> 00:01:51,350
Nå har vi erklært en variabel kalt student

36
00:01:51,350 --> 00:01:53,980
med typen gitt av struct.

37
00:01:53,980 --> 00:01:56,730
Hvordan får vi til variablene inne i struct?

38
00:01:56,730 --> 00:01:59,040
Teknisk navnene for disse variablene

39
00:01:59,040 --> 00:02:01,070
er medlemmer.

40
00:02:01,070 --> 00:02:04,000
Å få tilgang til alle bestemt medlem i en student struct,

41
00:02:04,000 --> 00:02:06,440
du føye til et punkt til variabelen navn,

42
00:02:06,440 --> 00:02:08,860
etterfulgt av navnet på medlemmet du ønsker.

43
00:02:08,860 --> 00:02:11,690
Så her, bare 2 gyldige muligheter

44
00:02:11,690 --> 00:02:17,760
er 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 kan gjøre noe sånt

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

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

49
00:02:39,310 --> 00:02:42,580
Hva nå hvis vi ønsket å gjøre en ekstra student?

50
00:02:42,580 --> 00:02:44,760
Du kanskje tror å kopiere og lime inn disse linjene

51
00:02:44,760 --> 00:02:48,110
og endre student til student 2 eller noe,

52
00:02:48,110 --> 00:02:50,090
og som vil fungere,

53
00:02:50,090 --> 00:02:52,670
men teknisk, student og student 2

54
00:02:52,670 --> 00:02:54,540
har ikke samme type.

55
00:02:54,540 --> 00:02:56,940
Se, vil du ikke være i stand til å tilordne dem til hverandre.

56
00:02:56,940 --> 00:02:58,560
Dette er fordi, så langt,

57
00:02:58,560 --> 00:03:00,950
din struct har vært anonym.

58
00:03:00,950 --> 00:03:02,290
Vi trenger å gi den et navn.

59
00:03:02,290 --> 00:03:04,420
For å gjøre det, setter vi navnet på struct

60
00:03:04,420 --> 00:03:06,950
etter ordet struct.

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

62
00:03:11,170 --> 00:03:14,680
etterfulgt av definisjonen.

63
00:03:16,500 --> 00:03:18,940
Vi kan fortsatt umiddelbart erklære en variabel av typen

64
00:03:18,940 --> 00:03:21,570
struct student, som vi gjorde før.

65
00:03:24,320 --> 00:03:28,360
Vi kaller det S1

66
00:03:28,590 --> 00:03:30,760
Ved å gi struct et navn,

67
00:03:30,760 --> 00:03:33,050
Vi kan nå bruke struct student

68
00:03:33,050 --> 00:03:36,950
i nesten nøyaktig samme måte ville vi bruke int.

69
00:03:36,950 --> 00:03:39,580
Så vi kan erklære en variabel av typen struct student,

70
00:03:39,580 --> 00:03:42,360
som

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

72
00:03:51,020 --> 00:03:55,130
Som matriser, structs gi en snarvei initialisering syntaks,

73
00:03:55,130 --> 00:03:58,670
så vi kan si, struct student S2

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

75
00:04:01,420 --> 00:04:06,040
venstre krøllete 3 brace, S2.

76
00:04:09,210 --> 00:04:12,600
Her vil S2.age være 3,

77
00:04:12,600 --> 00:04:15,910
og S2.name vil peke på S2.

78
00:04:15,910 --> 00:04:19,149
Tenk på alle de tingene du kan gjøre med en int typen

79
00:04:19,149 --> 00:04:22,460
og de fleste av dem kan du gjøre med en struct student type.

80
00:04:22,460 --> 00:04:26,060
Vi kan bruke en struct student som en type funksjon parameter.

81
00:04:26,060 --> 00:04:28,790
Vi kan bruke struct student innsiden av en ny struct.

82
00:04:28,790 --> 00:04:31,010
Vi kan ha en peker til en struct student.

83
00:04:31,010 --> 00:04:33,540
Vi kan gjøre størrelsen på struct student.

84
00:04:33,540 --> 00:04:35,510
Struct student er en type

85
00:04:35,510 --> 00:04:38,030
akkurat som int er en type.

86
00:04:38,030 --> 00:04:40,540
Vi kan også tildele S1 til S2

87
00:04:40,540 --> 00:04:43,760
siden begge er av samme type, slik at vi kan gjøre

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

89
00:04:47,540 --> 00:04:50,430
Hva skjer hvis vi gjør

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

91
00:04:56,340 --> 00:04:58,880
Har S2 endring i det hele tatt?

92
00:04:58,880 --> 00:05:02,800
Igjen, tenk på de structs bare som vanlige heltall.

93
00:05:02,800 --> 00:05:05,590
Hvis vi tildeler noen int X til noen int Y,

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

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

96
00:05:10,850 --> 00:05:14,230
som i X + +,

97
00:05:14,230 --> 00:05:17,020
endrer Y i det hele tatt?

98
00:05:17,020 --> 00:05:20,980
Y endrer ikke her, og så heller ikke S2 ​​ovenfor.

99
00:05:20,980 --> 00:05:24,120
S2.age er fortsatt tre.

100
00:05:24,120 --> 00:05:27,350
Men merk at når du tilordner en struct til en annen,

101
00:05:27,350 --> 00:05:30,300
alle pekere fremdeles peker til det samme,

102
00:05:30,300 --> 00:05:32,260
siden de var bare kopiert.

103
00:05:32,260 --> 00:05:34,300
Hvis du ikke vil at pekere til å bli delt,

104
00:05:34,300 --> 00:05:36,100
må du manuelt håndtere det,

105
00:05:36,100 --> 00:05:39,780
kanskje ved malicking en blokk med minne for en av pekere til å peke på

106
00:05:39,780 --> 00:05:42,120
og kopiere data over.

107
00:05:42,120 --> 00:05:45,540
Det kan være irriterende å måtte skrive struct student overalt.

108
00:05:45,540 --> 00:05:48,730
Ved hjelp av en type def, kan vi gjøre

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

110
00:05:55,850 --> 00:05:58,830
struct

111
00:05:58,830 --> 00:06:01,270
og vi kaller det student.

112
00:06:05,620 --> 00:06:08,360
Nå kan vi bruke student overalt

113
00:06:08,360 --> 00:06:11,090
at vi pleide å bruke struct student.

114
00:06:11,090 --> 00:06:13,410
Denne typen def er en anonym struct

115
00:06:13,410 --> 00:06:15,750
og kaller det student.

116
00:06:15,750 --> 00:06:18,220
Men hvis vi også holde studenten identifikator

117
00:06:18,220 --> 00:06:22,380
ved siden av ordet struct, som i typedef struct student,

118
00:06:27,670 --> 00:06:31,590
vi kunne bruke både struct student og student hverandre nå.

119
00:06:31,590 --> 00:06:34,060
De trenger ikke engang å ha samme navn.

120
00:06:34,060 --> 00:06:36,710
Vi kunne skrive def struct student til Bob

121
00:06:36,710 --> 00:06:38,950
og deretter struct student og Bob

122
00:06:38,950 --> 00:06:41,270
ville være utskiftbare typer.

123
00:06:41,270 --> 00:06:44,050
Uavhengig av type def,

124
00:06:44,050 --> 00:06:46,750
vi trenger identifikator ved siden struct

125
00:06:46,750 --> 00:06:48,250
hvis definisjonen av struct

126
00:06:48,250 --> 00:06:50,450
er rekursiv.

127
00:06:50,450 --> 00:06:52,620
For eksempel,

128
00:06:52,620 --> 00:06:56,140
typen def struct node

129
00:06:56,140 --> 00:07:01,200
og det vil bli definert som en int val

130
00:07:01,200 --> 00:07:05,420
og det vil ha en peker som peker til en annen struct node.,

131
00:07:05,420 --> 00:07:09,490
som i struct node * neste.

132
00:07:09,490 --> 00:07:13,670
Og så får vi kalle det node.

133
00:07:15,490 --> 00:07:18,020
Dette struct er rekursiv,

134
00:07:18,020 --> 00:07:21,450
siden definisjonen av struct node inneholder innenfor det

135
00:07:21,450 --> 00:07:24,200
en peker til en struct node.

136
00:07:24,200 --> 00:07:27,740
Legg merke til at vi har å si struct node * neste

137
00:07:27,740 --> 00:07:30,690
innsiden av definisjonen av struct node,

138
00:07:30,690 --> 00:07:33,620
siden den typen def ikke er ferdig ennå å tillate oss å forenkle dette

139
00:07:33,620 --> 00:07:36,210
å bare node * neste.

140
00:07:36,210 --> 00:07:39,260
Du vil lære mer om structs som ligner på dette

141
00:07:39,260 --> 00:07:41,750
når du arbeider med koblede lister og trær.

142
00:07:41,750 --> 00:07:44,130
Hva om structs i en funksjon?

143
00:07:44,130 --> 00:07:46,800
Dette er også helt gyldig.

144
00:07:46,800 --> 00:07:49,430
Vi kunne ha

145
00:07:49,430 --> 00:07:53,630
annullere funk

146
00:07:53,630 --> 00:07:55,930
som tar som et argument,

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

148
00:07:59,590 --> 00:08:02,790
og gjør noe med det student.

149
00:08:05,270 --> 00:08:08,450
Og så kan vi sende den som student struct som så.

150
00:08:08,450 --> 00:08:12,850
Func av S1 fra før.

151
00:08:12,850 --> 00:08:15,230
Struct oppfører

152
00:08:15,230 --> 00:08:18,460
nøyaktig som et heltall ville når sendes til en funksjon.

153
00:08:18,460 --> 00:08:21,510
Func mottar en kopi av S1

154
00:08:21,510 --> 00:08:23,690
og kan derfor ikke endre S1;

155
00:08:23,690 --> 00:08:27,110
heller, bare kopien av det som er lagret i S.

156
00:08:27,110 --> 00:08:30,010
Hvis du vil at funksjonen skal kunne endre S1,

157
00:08:30,010 --> 00:08:33,000
func må ta en student * S,

158
00:08:33,000 --> 00:08:36,570
og du må passere S1 etter adresse, som så.

159
00:08:37,549 --> 00:08:41,100
Student * S, funk & S1.

160
00:08:41,100 --> 00:08:44,760
Det er en annen grunn til å passere etter adresse her.

161
00:08:44,760 --> 00:08:48,030
Hva om vår struct inneholdt 100 felt?

162
00:08:48,030 --> 00:08:51,250
Hver eneste gang vi passerer en student til funk,

163
00:08:51,250 --> 00:08:55,770
vårt program må kopiere alle de 100 felt i funk argument S,

164
00:08:55,770 --> 00:08:59,320
selv om den bruker aldri de aller fleste av dem.

165
00:08:59,320 --> 00:09:02,700
Så selv om funk ikke tenkt på å endre student,

166
00:09:02,700 --> 00:09:05,170
hvis kan fortsatt være verdifullt å passere adresse.

167
00:09:05,170 --> 00:09:08,990
Ok, hva om vi ønsker å skape en peker til en struct?

168
00:09:08,990 --> 00:09:11,130
Vi kunne gjøre noe sånt

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

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

171
00:09:20,980 --> 00:09:26,600
Størrelsen student.

172
00:09:30,450 --> 00:09:33,590
Legg merke til at størrelsen på fortsatt fungerer her.

173
00:09:33,590 --> 00:09:37,260
Så hvordan skal vi nå få tilgang til alder medlem

174
00:09:37,260 --> 00:09:39,640
av blokken at S peker?

175
00:09:39,640 --> 00:09:42,300
Du kanskje først tenker å gjøre

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

177
00:09:47,970 --> 00:09:50,220
men dette vil ikke helt fungerer.

178
00:09:50,220 --> 00:09:52,940
Siden dette vil virkelig bli tolket som

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

180
00:09:57,740 --> 00:10:00,160
som ikke engang kompilere,

181
00:10:00,160 --> 00:10:03,600
siden S er ikke en struct eller snarere en peker til en struct,

182
00:10:03,600 --> 00:10:06,270
og så prikken ikke vil fungere her.

183
00:10:06,270 --> 00:10:08,860
Vi kunne gjøre

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

185
00:10:13,760 --> 00:10:16,790
men parentes kan bli irriterende og forvirrende.

186
00:10:16,790 --> 00:10:19,880
Heldigvis har vi et spesielt pilen operatør

187
00:10:19,880 --> 00:10:22,350
som ser noe sånt

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

189
00:10:28,860 --> 00:10:31,600
Disse to måtene å referere alder

190
00:10:31,600 --> 00:10:33,270
er likeverdige

191
00:10:33,270 --> 00:10:36,870
og vi ikke egentlig trenger pilen operatør,

192
00:10:36,870 --> 00:10:39,300
men det gjør ting ser bedre.

193
00:10:39,300 --> 00:10:43,050
Siden S er en peker til noen blokk av minnet som inneholder den struct,

194
00:10:43,050 --> 00:10:47,820
du kan tenke på S> alder som følge Pekerpilen

195
00:10:47,820 --> 00:10:50,250
og ta tak i alderen medlem.

196
00:10:50,250 --> 00:10:53,750
Så hvorfor skal vi noen gang structs?

197
00:10:53,750 --> 00:10:57,560
Det er definitivt mulig å komme unna med bare primitive heltall,

198
00:10:57,560 --> 00:10:59,050
chars, pekere og lignende

199
00:10:59,050 --> 00:11:01,550
som vi er vant til;

200
00:11:01,550 --> 00:11:03,340
i stedet for S1 og S2 før,

201
00:11:03,340 --> 00:11:06,290
Vi kunne ha hatt alder1, age2, NAME1 og NAME2

202
00:11:06,290 --> 00:11:09,120
alle på separate variabler.

203
00:11:09,120 --> 00:11:11,390
Dette er greit med bare 2 studenter,

204
00:11:11,390 --> 00:11:13,310
men hva om vi hadde 10 av dem?

205
00:11:13,310 --> 00:11:15,540
Og hva hvis i stedet for bare 2 felt,

206
00:11:15,540 --> 00:11:17,720
studenten struct hadde 100 felt?

207
00:11:17,720 --> 00:11:21,240
GPA, kurs, hårfarge, kjønn og så videre.

208
00:11:21,240 --> 00:11:25,790
I stedet for bare 10 structs, trenger vi 1000 separate variabler.

209
00:11:25,790 --> 00:11:28,360
Også vurdere en funksjon

210
00:11:28,360 --> 00:11:32,270
som tar det struct med 100 felt med sin eneste argument

211
00:11:32,270 --> 00:11:34,350
og skriver ut alle felt.

212
00:11:34,350 --> 00:11:36,320
Hvis vi ikke bruker en struct,

213
00:11:36,320 --> 00:11:38,540
hver eneste gang vi kaller denne funksjonen,

214
00:11:38,540 --> 00:11:41,460
vi trenger å passere på alle 100 variabler,

215
00:11:41,460 --> 00:11:44,430
og hvis vi har 100 variabler for student 1,

216
00:11:44,430 --> 00:11:47,020
og 100 variabler for student 2,

217
00:11:47,020 --> 00:11:50,540
vi trenger å være sikker på at vi ikke tilfeldigvis passerer noen variabler fra student 1

218
00:11:50,540 --> 00:11:52,910
og noen variabler fra student 2.

219
00:11:52,910 --> 00:11:55,710
Det er umulig å gjøre det feil med en struct,

220
00:11:55,710 --> 00:11:59,010
siden alle 100 variabler som er med i en enkelt pakke.

221
00:11:59,010 --> 00:12:02,050
Bare et par avsluttende merknader:

222
00:12:02,050 --> 00:12:04,870
Hvis du har forstått alt opp til dette punktet, flott.

223
00:12:04,870 --> 00:12:07,900
Resten av videoen er bare for fullstendighet skyld.

224
00:12:07,900 --> 00:12:11,010
Fordi structs kan holde alle typer pekeren,

225
00:12:11,010 --> 00:12:14,220
de kan også holdfunksjon pekere.

226
00:12:14,220 --> 00:12:17,040
Hvis du er kjent med objektorientert programmering,

227
00:12:17,040 --> 00:12:21,790
Dette er en måte å bruke structs å programmere i et objektorientert stil.

228
00:12:21,790 --> 00:12:24,500
Mer på funksjonspekere på et annet tidspunkt.

229
00:12:24,500 --> 00:12:27,760
Også, noen ganger kan du ha 2 structs

230
00:12:27,760 --> 00:12:30,220
hvis definisjoner avhengig av hverandre.

231
00:12:30,220 --> 00:12:32,320
For eksempel,

232
00:12:32,320 --> 00:12:35,470
vi kunne ha struct A,

233
00:12:35,470 --> 00:12:38,580
som er definert som

234
00:12:38,580 --> 00:12:41,910
en peker til en struct B,

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

236
00:12:47,180 --> 00:12:50,470
og nå kan vi ha en struct B

237
00:12:53,890 --> 00:12:56,280
som er definert som en peker

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

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

240
00:13:07,230 --> 00:13:09,060
Men dette vil ikke kompilere,

241
00:13:09,060 --> 00:13:14,110
siden struct B finnes ikke på det tidspunktet struct A blir kompilert.

242
00:13:14,110 --> 00:13:17,600
Og hvis vi bytter struct A og struct B,

243
00:13:17,600 --> 00:13:20,100
da ville vi bare bli sittende igjen med det samme problemet;

244
00:13:20,100 --> 00:13:22,640
denne gangen, med struct En ikke eksisterende.

245
00:13:22,640 --> 00:13:24,720
For å løse dette, kan vi skrive

246
00:13:24,720 --> 00:13:29,290
struct B;

247
00:13:29,290 --> 00:13:32,460
før definisjonen av struct A.

248
00:13:32,460 --> 00:13:35,590
Dette kalles en fremtidsrettet erklæring.

249
00:13:35,590 --> 00:13:38,590
Dette kan bare kompilatoren vet at

250
00:13:38,590 --> 00:13:42,040
struct B er en gyldig type som vil bli fullt ut definert senere eller andre steder.

251
00:13:42,040 --> 00:13:45,980
Mitt navn er Rob Bowden, og dette er CS50.

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