1
00:00:07,260 --> 00:00:09,180
[Powered by Google Translate] Lad os tale om struct.

2
00:00:09,180 --> 00:00:12,130
Structs giver os en måde at gruppere en flok variabler sammen

3
00:00:12,130 --> 00:00:14,350
ind i en dejlig pakke.

4
00:00:14,350 --> 00:00:17,020
Det er nok nemmest at se et eksempel med det samme,

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

6
00:00:20,030 --> 00:00:23,340
derefter åbne klammeparentes,

7
00:00:23,340 --> 00:00:26,630
og i denne struct, vil vi have 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 synes mærkeligt med et semikolon efter en klammeparentes,

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

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

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

14
00:00:49,530 --> 00:00:52,610
men du kan også bruge en array, af sige, 100 elementer

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

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

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

18
00:00:58,430 --> 00:01:00,860
ud af en samling af andre typer.

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

20
00:01:02,620 --> 00:01:05,060
ud af et helt tal og et char *.

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

22
00:01:07,400 --> 00:01:10,700
er på mange måder svarer til nogen anden type du er vant til.

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

24
00:01:13,310 --> 00:01:15,790
svarer til et helt tal type.

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

26
00:01:18,520 --> 00:01:20,320
det er ikke meget nyttigt,

27
00:01:20,320 --> 00:01:22,340
og klang vil give os en advarsel.

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

29
00:01:24,970 --> 00:01:26,710
Nå, vi dybest set bare sagt

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

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

32
00:01:33,140 --> 00:01:35,760
Så lad os faktisk erklære en variabel af denne type

33
00:01:35,760 --> 00:01:38,760
ved at give det et navn, før semikolon.

34
00:01:42,170 --> 00:01:45,000
Vi ringer til variable studerende.

35
00:01:48,190 --> 00:01:51,350
Nu har vi erklæret en variabel kaldet elev

36
00:01:51,350 --> 00:01:53,980
med den type, som afgives af struct.

37
00:01:53,980 --> 00:01:56,730
Hvordan kommer vi til de variabler inde i struct?

38
00:01:56,730 --> 00:01:59,040
Teknisk set navne for disse variabler

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

40
00:02:01,070 --> 00:02:04,000
For at få adgang nogen særlig element i en student struct,

41
00:02:04,000 --> 00:02:06,440
du tilføje en prik til den variable navn,

42
00:02:06,440 --> 00:02:08,860
efterfulgt af navnet på det medlem, du ønsker.

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

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 gøre noget lignende

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

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

49
00:02:39,310 --> 00:02:42,580
Hvad nu hvis vi ønskede at lave en anden elev?

50
00:02:42,580 --> 00:02:44,760
Du tror måske at kopiere og indsætte disse linjer

51
00:02:44,760 --> 00:02:48,110
og ændre elev til elev 2 eller noget,

52
00:02:48,110 --> 00:02:50,090
og der vil arbejde,

53
00:02:50,090 --> 00:02:52,670
men teknisk, studerende og studerende 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 at tildele dem til hinanden.

56
00:02:56,940 --> 00:02:58,560
Dette skyldes indtil nu,

57
00:02:58,560 --> 00:03:00,950
Deres struct har været anonyme.

58
00:03:00,950 --> 00:03:02,290
Vi er nødt til at give det et navn.

59
00:03:02,290 --> 00:03:04,420
For at gøre det, vi indsætte navnet på den struct

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

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

62
00:03:11,170 --> 00:03:14,680
efterfulgt af definitionen.

63
00:03:16,500 --> 00:03:18,940
Vi kan stadig omgående erklære en variabel af typen

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

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

66
00:03:28,590 --> 00:03:30,760
Ved at give struct et navn,

67
00:03:30,760 --> 00:03:33,050
Vi kan nu bruge struct student

68
00:03:33,050 --> 00:03:36,950
i næsten nøjagtig samme måde, som vi ville bruge int.

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

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

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

72
00:03:51,020 --> 00:03:55,130
Ligesom arrays, giver struct en genvej initialisering syntaks,

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

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

75
00:04:01,420 --> 00:04:06,040
venstre klammeparentes 3, 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 pege på S2.

78
00:04:15,910 --> 00:04:19,149
Tænk på alle de ting, du kan gøre med en int type,

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

80
00:04:22,460 --> 00:04:26,060
Vi kan bruge en struct student som en form for en funktion parameter.

81
00:04:26,060 --> 00:04:28,790
Vi kan anvende struct student indersiden af ​​en ny struct.

82
00:04:28,790 --> 00:04:31,010
Vi kan have en pointer til en struct studerende.

83
00:04:31,010 --> 00:04:33,540
Vi kan gøre størrelsen af ​​struct studerende.

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

85
00:04:35,510 --> 00:04:38,030
ligesom 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
idet begge dele er af samme type, så vi kan gøre

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

89
00:04:47,540 --> 00:04:50,430
Hvad sker der, hvis vi gør

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

91
00:04:56,340 --> 00:04:58,880
Er S2 ændring overhovedet?

92
00:04:58,880 --> 00:05:02,800
Igen, tænk på de struct bare som almindelige heltal.

93
00:05:02,800 --> 00:05:05,590
Hvis vi tildele noget int X til nogle int Y,

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

95
00:05:08,970 --> 00:05:10,850
og derefter ændre X,

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

97
00:05:14,230 --> 00:05:17,020
gør Y ændre på alle?

98
00:05:17,020 --> 00:05:20,980
Y ikke ændrer sig her, og det heller ikke S2 ​​ovenfor.

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

100
00:05:24,120 --> 00:05:27,350
Men bemærk, at når de tildeler en struct til en anden,

101
00:05:27,350 --> 00:05:30,300
alle henvisninger stadig peger på den samme ting,

102
00:05:30,300 --> 00:05:32,260
da de bare blev kopieret.

103
00:05:32,260 --> 00:05:34,300
Hvis du ikke ønsker, at pointere, der skal deles,

104
00:05:34,300 --> 00:05:36,100
du bliver nødt til manuelt at håndtere det,

105
00:05:36,100 --> 00:05:39,780
måske ved malicking en blok af hukommelse til en af ​​pegepinde til at pege på

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

107
00:05:42,120 --> 00:05:45,540
Det kan være irriterende at skulle skrive struct studerende overalt.

108
00:05:45,540 --> 00:05:48,730
Ved hjælp af en type, def, kan vi gø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 vil kalde det elev.

112
00:06:05,620 --> 00:06:08,360
Nu kan vi bruge studerende overalt

113
00:06:08,360 --> 00:06:11,090
at vi plejede at bruge struct studerende.

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

115
00:06:13,410 --> 00:06:15,750
og kalder det elev.

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

117
00:06:18,220 --> 00:06:22,380
siden af ​​ordet struct, som i typedef struct studerende,

118
00:06:27,670 --> 00:06:31,590
vi kunne bruge både struct studerende og studerende i flæng nu.

119
00:06:31,590 --> 00:06:34,060
De behøver ikke engang at have samme navn.

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

121
00:06:36,710 --> 00:06:38,950
og derefter struct studerende og Bob

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

123
00:06:41,270 --> 00:06:44,050
Uanset typen def,

124
00:06:44,050 --> 00:06:46,750
vi har brug for identifikator siden struct

125
00:06:46,750 --> 00:06:48,250
Hvis definitionen af ​​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 den vil blive defineret som en int val

130
00:07:01,200 --> 00:07:05,420
og det vil have en pointer, der peger på en anden struct node.,

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

132
00:07:09,490 --> 00:07:13,670
Og så vil vi kalde det node.

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

134
00:07:18,020 --> 00:07:21,450
da definitionen af ​​struct node indeholder i sig

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

136
00:07:24,200 --> 00:07:27,740
Bemærk, at vi har at sige struct node * næste

137
00:07:27,740 --> 00:07:30,690
indersiden af ​​definitionen af ​​struct node,

138
00:07:30,690 --> 00:07:33,620
Da type def ikke er færdig endnu at tillade os at forenkle denne

139
00:07:33,620 --> 00:07:36,210
til lige node * næste.

140
00:07:36,210 --> 00:07:39,260
Du vil lære mere om struct svarende til dette

141
00:07:39,260 --> 00:07:41,750
når det drejer sig hægtede lister og træer.

142
00:07:41,750 --> 00:07:44,130
Hvad med struct i en funktion?

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

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

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

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

147
00:07:55,930 --> 00:07:59,590
studerendes

148
00:07:59,590 --> 00:08:02,790
og gør noget med, at studerende.

149
00:08:05,270 --> 00:08:08,450
Og så kan vi give det som studerende struct som så.

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

151
00:08:12,850 --> 00:08:15,230
Den struct opfører

152
00:08:15,230 --> 00:08:18,460
præcis som et heltal vil, når i en funktion.

153
00:08:18,460 --> 00:08:21,510
Func modtager en kopi af S1

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

155
00:08:23,690 --> 00:08:27,110
snarere, kun den kopi af det, der er lagret i S.

156
00:08:27,110 --> 00:08:30,010
Hvis du vil have den funktion at være i stand til at ændre S1,

157
00:08:30,010 --> 00:08:33,000
funk bliver nødt til at tage en studerende * S,

158
00:08:33,000 --> 00:08:36,570
og du bliver nødt til at passere S1 efter 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
Der er en anden grund til at passere efter adresse her.

161
00:08:44,760 --> 00:08:48,030
Hvad hvis vores struct indeholdt 100 felter?

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

163
00:08:51,250 --> 00:08:55,770
vores program skal kopiere alle disse 100 felter i funk argument S,

164
00:08:55,770 --> 00:08:59,320
Selv om det aldrig anvender det store flertal af disse.

165
00:08:59,320 --> 00:09:02,700
Så selv om funk har ikke planer om at ændre den studerende,

166
00:09:02,700 --> 00:09:05,170
hvis kan stadig være værdifuldt at passere efter adresse.

167
00:09:05,170 --> 00:09:08,990
Okay, hvad nu hvis vi ønsker at skabe en pointer til en struct?

168
00:09:08,990 --> 00:09:11,130
Vi kunne gøre noget lignende

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

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

171
00:09:20,980 --> 00:09:26,600
størrelse studerende.

172
00:09:30,450 --> 00:09:33,590
Bemærk, at størrelsen af ​​stadig arbejder her.

173
00:09:33,590 --> 00:09:37,260
Så hvordan kan vi nu få adgang til alder medlem

174
00:09:37,260 --> 00:09:39,640
af blokken, at S peger på?

175
00:09:39,640 --> 00:09:42,300
Du kan først tænker at gøre

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

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

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

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

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

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

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

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

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

185
00:10:13,760 --> 00:10:16,790
men parenteserne kan få irriterende og forvirrende.

186
00:10:16,790 --> 00:10:19,880
Heldigvis har vi en særlig pil operatør

187
00:10:19,880 --> 00:10:22,350
som ser ud som

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

189
00:10:28,860 --> 00:10:31,600
Disse 2 måder referencing alder

190
00:10:31,600 --> 00:10:33,270
svarer

191
00:10:33,270 --> 00:10:36,870
og vi har ikke rigtig nogensinde har brug pilen operatør,

192
00:10:36,870 --> 00:10:39,300
men det gør tingene ser pænere.

193
00:10:39,300 --> 00:10:43,050
Da S er en pointer til nogle blok af hukommelse, der indeholder struct,

194
00:10:43,050 --> 00:10:47,820
du kan tænke på S> alder som følge Markørpilen

195
00:10:47,820 --> 00:10:50,250
og få fat i den alder medlem.

196
00:10:50,250 --> 00:10:53,750
Så hvorfor skulle vi nogensinde Benyt strukturer?

197
00:10:53,750 --> 00:10:57,560
Det er absolut muligt at slippe af sted med kun de primitive heltal,

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

199
00:10:59,050 --> 00:11:01,550
at 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 have haft age1, age2, navn1, og NAME2

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

203
00:11:09,120 --> 00:11:11,390
Det er fint med kun 2 studerende,

204
00:11:11,390 --> 00:11:13,310
men hvad nu hvis vi havde 10 af dem?

205
00:11:13,310 --> 00:11:15,540
Og hvad hvis der i stedet for kun 2 felter,

206
00:11:15,540 --> 00:11:17,720
den studerende struct havde 100 felter?

207
00:11:17,720 --> 00:11:21,240
GPA, kurser, hårfarve, køn og så videre.

208
00:11:21,240 --> 00:11:25,790
I stedet for blot 10 struct har vi brug for 1.000 separate variabler.

209
00:11:25,790 --> 00:11:28,360
Også overveje en funktion

210
00:11:28,360 --> 00:11:32,270
der tager at struct med 100 felter med sit eneste argument

211
00:11:32,270 --> 00:11:34,350
og udskriver alle felter.

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

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

214
00:11:38,540 --> 00:11:41,460
vi er nødt til at passere på alle 100 variabler,

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

216
00:11:44,430 --> 00:11:47,020
og 100 variabler til studerende 2,

217
00:11:47,020 --> 00:11:50,540
vi nødt til at være sikker på, at vi ikke ved et uheld passere nogle variabler fra studerende 1

218
00:11:50,540 --> 00:11:52,910
og nogle variable fra studerende 2.

219
00:11:52,910 --> 00:11:55,710
Det er umuligt at lave den fejl med en struct,

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

221
00:11:59,010 --> 00:12:02,050
Blot et par sidste bemærkninger:

222
00:12:02,050 --> 00:12:04,870
Hvis du har forstået alt op til dette punkt, stor.

223
00:12:04,870 --> 00:12:07,900
Resten af ​​videoen er bare for fuldstændighedens skyld.

224
00:12:07,900 --> 00:12:11,010
Fordi struct kan holde enhver form for pointer,

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

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

227
00:12:17,040 --> 00:12:21,790
Dette tilvejebringer en måde at bruge struct at programmere i et objektorienteret stil.

228
00:12:21,790 --> 00:12:24,500
Mere om funktionspointere på et andet tidspunkt.

229
00:12:24,500 --> 00:12:27,760
Også, nogle gange kan du have 2 struct

230
00:12:27,760 --> 00:12:30,220
hvis definitioner afhængige af hinanden.

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

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

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

234
00:12:38,580 --> 00:12:41,910
en pointer 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 nu kan vi få en struct B

237
00:12:53,890 --> 00:12:56,280
der er defineret som en pegepind

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
da struct B ikke eksisterer på det tidspunkt, struct A bliver kompileret.

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
så ville vi bare stå tilbage med det samme problem;

244
00:13:20,100 --> 00:13:22,640
denne gang, med konstruere A ikke eksisterende.

245
00:13:22,640 --> 00:13:24,720
For at 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 definitionen af ​​struct A.

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

249
00:13:35,590 --> 00:13:38,590
Dette blot lader compileren vide, at

250
00:13:38,590 --> 00:13:42,040
struct B er en gyldig type, som vil blive fuldt ud defineret senere, eller andetsteds.

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

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