1
00:00:00,000 --> 00:00:02,395
>> [Speel van musiek]

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

3
00:00:05,750 --> 00:00:06,506
>> DOUG LLOYD: OK.

4
00:00:06,506 --> 00:00:08,880
Ons het gewerk met heelgetalle,
Ons het gewerk met karakters,

5
00:00:08,880 --> 00:00:11,930
Ons het gewerk dryf,
dubbelspel, stringe en bools.

6
00:00:11,930 --> 00:00:14,870
Ons het mooi uitgeput much al
van die [onhoorbaar] tipes wat

7
00:00:14,870 --> 00:00:17,100
het saam beskikbaar vir ons almal was.

8
00:00:17,100 --> 00:00:19,430
Maar nou wil ons iets meer te doen.

9
00:00:19,430 --> 00:00:20,210
Hoe kan ons dit doen?

10
00:00:20,210 --> 00:00:22,560
Hoe weet ons die verskillende tipes data te skep?

11
00:00:22,560 --> 00:00:26,130
Ons kan dit doen deur die gebruik van strukture.

12
00:00:26,130 --> 00:00:30,180
So strukture toelaat om ons te verenig
veranderlikes van die verskillende tipes

13
00:00:30,180 --> 00:00:34,810
in 'n enkele, nuwe veranderlike tipe,
waarin ons sy eie soort naam kan toewys.

14
00:00:34,810 --> 00:00:37,570
Dit is 'n baie sterk
ding om in staat wees om te doen,

15
00:00:37,570 --> 00:00:40,900
want ons kan nou die groep
elemente van verskillende tipes data

16
00:00:40,900 --> 00:00:43,910
saam dat 'n logiese verband het.

17
00:00:43,910 --> 00:00:46,440
Ons het in staat om dit te doen nie
met skikkings soort, reg?

18
00:00:46,440 --> 00:00:49,540
Ons kan veranderlikes groep
van dieselfde tipe data

19
00:00:49,540 --> 00:00:53,410
saam in 'n groot eenheid
geheue, 'n skikking.

20
00:00:53,410 --> 00:00:56,660
>> Maar ons het nie in staat was om te meng
up verskillende tipes data saam.

21
00:00:56,660 --> 00:01:02,610
Ons kan nie sê, paar 'n heelgetal,
en 'n karakter, en 'n dubbele al

22
00:01:02,610 --> 00:01:05,330
in die dieselfde ding en
noem dat 'n enkele eenheid.

23
00:01:05,330 --> 00:01:08,830
Maar met strukture, of
dikwels na verwys as structs,

24
00:01:08,830 --> 00:01:09,585
ons eintlik kan.

25
00:01:09,585 --> 00:01:12,370
So 'n struktuur is 'n soort
soos 'n super veranderlike.

26
00:01:12,370 --> 00:01:16,530
Dit is 'n veranderlike wat bevat
ander veranderlikes binnekant van dit.

27
00:01:16,530 --> 00:01:19,650
So hier is 'n voorbeeld van
'n baie eenvoudige struktuur.

28
00:01:19,650 --> 00:01:23,380
Dit is wat die sintaksis sou kyk
graag 'n struktuur te skep vir 'n motor.

29
00:01:23,380 --> 00:01:25,250
Nou, laat ons gaan deur die sintaksis hier.

30
00:01:25,250 --> 00:01:27,400
Struct, dit is die
term wat dui

31
00:01:27,400 --> 00:01:30,270
dat ek 'n nuwe soort data hier.

32
00:01:30,270 --> 00:01:33,860
In die besonder, die naam van die tipe se data is
gaan struct motor, soos ons sal sien.

33
00:01:33,860 --> 00:01:36,640
Maar dit is die soort van punt
af na die samesteller dat dit

34
00:01:36,640 --> 00:01:42,440
as 'n groep van veranderlikes wat gaan
word beskou as deel van dieselfde soort

35
00:01:42,440 --> 00:01:44,010
in 'n minuut.

36
00:01:44,010 --> 00:01:46,340
>> Motors, net die naam van die struktuur.

37
00:01:46,340 --> 00:01:50,590
Weereens, die tipe hier data gaan
om struct motor, nie net die motor wees.

38
00:01:50,590 --> 00:01:53,060
Maar as jy different-- het
as jy verskeie structs skep

39
00:01:53,060 --> 00:01:56,950
in dieselfde program, moet jy
onderskei tussen struct en struct.

40
00:01:56,950 --> 00:02:00,140
So struct motor, het ek dalk ook
struct student, byvoorbeeld,

41
00:02:00,140 --> 00:02:01,790
in dieselfde program.

42
00:02:01,790 --> 00:02:05,980
Binnekant van die krulhakies is
al die sogenaamde velde,

43
00:02:05,980 --> 00:02:07,954
of lede van die struktuur.

44
00:02:07,954 --> 00:02:10,370
So, wat is 'n paar van die dinge
wat inherent in 'n motor?

45
00:02:10,370 --> 00:02:15,270
Wel, dit het gewoonlik 'n jaar, het
'n model naam, en 'n lisensie plaat,

46
00:02:15,270 --> 00:02:18,000
'n odometer wat gewoonlik
sommige aantal myl oor dit,

47
00:02:18,000 --> 00:02:19,225
en miskien 'n enjin grootte.

48
00:02:19,225 --> 00:02:23,570
En soos jy kan sien, ek meng
heelgetalle en karakters en dubbelspel.

49
00:02:23,570 --> 00:02:26,420
Hulle is almal gaan wees
deel van hierdie nuwe tipe data.

50
00:02:26,420 --> 00:02:29,750
>> Laastens, die finale ding wat ek nodig het om te doen,
moenie vergeet hierdie klein kommapunt

51
00:02:29,750 --> 00:02:30,290
aan die einde.

52
00:02:30,290 --> 00:02:34,380
Nadat ons klaar die definisie van die struktuur,
ons nodig het om 'n kommapunt aan die einde te plaas.

53
00:02:34,380 --> 00:02:37,325
Dit is 'n baie algemene sintaktiese
fout, want met 'n funksie,

54
00:02:37,325 --> 00:02:40,200
byvoorbeeld, sou jy net
oop krullerige brace, naby krullerige brace.

55
00:02:40,200 --> 00:02:42,950
Jy hoef nie 'n kommapunt aan die
einde van 'n funksie definisie.

56
00:02:42,950 --> 00:02:46,430
Dit lyk soos 'n funksie
definisie, maar dit is nie,

57
00:02:46,430 --> 00:02:49,653
en so die kommapunt daar
is net 'n herinnering dat jy

58
00:02:49,653 --> 00:02:52,440
nodig het om dit daar te vestig, want
samesteller sal andersins nie

59
00:02:52,440 --> 00:02:53,510
weet wat om te doen met dit.

60
00:02:53,510 --> 00:02:56,160
Dit is 'n baie algemene fout
om per ongeluk te maak

61
00:02:56,160 --> 00:02:58,570
wanneer jy die eerste keer die definisie strukture.

62
00:02:58,570 --> 00:02:59,500
>> OK.

63
00:02:59,500 --> 00:03:02,824
So het ons gewoonlik ons ​​strukture te definieer
op die top van ons programme

64
00:03:02,824 --> 00:03:05,490
omdat hulle waarskynlik gaan
om gebruik te word deur verskeie funksies.

65
00:03:05,490 --> 00:03:08,850
Ons wil nie 'n definieer
struct binnekant van 'n funksie,

66
00:03:08,850 --> 00:03:12,110
want dan kan ons die only--
omvang van die struktuur regtig

67
00:03:12,110 --> 00:03:13,790
net bestaan ​​binne daardie funksie.

68
00:03:13,790 --> 00:03:17,450
Ons sou waarskynlik wil hê om 'n struktuur te definieer
sodat ons dit kan gebruik in verskeie funksies,

69
00:03:17,450 --> 00:03:20,670
of dalk in verskeie
lêers wat saam vasgebind

70
00:03:20,670 --> 00:03:22,920
ons enkele program te skep.

71
00:03:22,920 --> 00:03:24,920
Soms ook plaas
van die definisie van die struktuur

72
00:03:24,920 --> 00:03:27,961
op die heel boonste waar jy jou
pond sluit en u pond definieer,

73
00:03:27,961 --> 00:03:32,080
byvoorbeeld, kan jy hulle in
aparte dot h lêers, wat jy dan

74
00:03:32,080 --> 00:03:35,020
pond sluit jouself.

75
00:03:35,020 --> 00:03:37,620
>> So het ons strukture, maar nou
ons moet aan die binnekant van hulle te kry.

76
00:03:37,620 --> 00:03:39,800
Hoe kry ons binnekant van
'n struktuur om toegang

77
00:03:39,800 --> 00:03:43,530
diegene sub-veranderlikes, daardie veranderlikes
wat bestaan ​​binne die struktuur?

78
00:03:43,530 --> 00:03:46,810
Wel, ons het iets genoem
die dot-operateur, wat ons toelaat

79
00:03:46,810 --> 00:03:50,990
om toegang tot die velde van die struktuur.

80
00:03:50,990 --> 00:03:55,490
So byvoorbeeld, kom ons sê ek het verklaar
my struktuur data tik iewers

81
00:03:55,490 --> 00:03:59,020
aan die bokant van my program, of dalk in
'n dot h lêer wat ek pond ingesluit.

82
00:03:59,020 --> 00:04:03,360
As ek wil dan na 'n nuwe te skep
veranderlike van daardie tipe data, kan ek sê,

83
00:04:03,360 --> 00:04:06,260
struct motor, my motor, kommapunt.

84
00:04:06,260 --> 00:04:11,580
Net soos wat ek kon sê int
x, of naam string kommapunt.

85
00:04:11,580 --> 00:04:18,100
>> Die tipe hier data is struct motor,
die naam van die veranderlike is my motor,

86
00:04:18,100 --> 00:04:23,770
en dan kan ek die dot operateur om te gebruik
toegang tot die verskillende velde van my motor.

87
00:04:23,770 --> 00:04:27,494
So ek kan my motor sê
dot jaar gelyk 2011.

88
00:04:27,494 --> 00:04:28,410
Dit is heeltemal fyn.

89
00:04:28,410 --> 00:04:34,210
Jaar, as jy onthou, is gedefinieer as 'n
heelgetal veld binne hierdie struct motor

90
00:04:34,210 --> 00:04:35,200
tipe data.

91
00:04:35,200 --> 00:04:39,966
So 'n veranderlike van die struct motor data
tipe, soos my motor, het ek kan my motor sê

92
00:04:39,966 --> 00:04:44,030
dot jaar gelyk en dan wys
dit 'n heelgetal waarde 2011.

93
00:04:44,030 --> 00:04:47,290
My motor dot plaat gelyk CS50.

94
00:04:47,290 --> 00:04:51,180
My kaart dot odometer
gelyk 50505 kommapunt.

95
00:04:51,180 --> 00:04:53,270
Al wat is
heeltemal fyn, en dis

96
00:04:53,270 --> 00:04:57,802
hoe ons toegang tot die
velde van die struktuur.

97
00:04:57,802 --> 00:05:00,260
Strukture, al is, hoef nie
geskep moet word op die stapel.

98
00:05:00,260 --> 00:05:02,950
Net soos enige ander veranderlike, ons
kan hulle dinamiese toewys.

99
00:05:02,950 --> 00:05:06,309
As ons 'n program wat kan
genereer baie strukture,

100
00:05:06,309 --> 00:05:08,100
ons weet nie hoeveel
ons gaan nodig,

101
00:05:08,100 --> 00:05:10,800
dan moet ons dinamiese
toeken die strukture

102
00:05:10,800 --> 00:05:12,960
as ons program loop.

103
00:05:12,960 --> 00:05:16,600
En so as ons gaan die toegang
velde van 'n struktuur in daardie konteks,

104
00:05:16,600 --> 00:05:20,660
Onthou dat ons eers moet dereference
die wyser na die struktuur,

105
00:05:20,660 --> 00:05:24,810
en dan wanneer ons dereference die
wyser, dan kan ons toegang tot die velde.

106
00:05:24,810 --> 00:05:26,830
As ons net 'n
wyser na die struktuur,

107
00:05:26,830 --> 00:05:32,120
Ons kan nie net wyser dot veld sê
noem en kry wat ons soek.

108
00:05:32,120 --> 00:05:34,259
Daar is die ekstra stap van dereferencing.

109
00:05:34,259 --> 00:05:36,050
So kom ons sê dat
in plaas van die previous--

110
00:05:36,050 --> 00:05:38,770
net soos die vorige voorbeeld,
in plaas van verklaar dat dit

111
00:05:38,770 --> 00:05:43,680
op die stapel, struct motor, my
motor, kommapunt, sê ek struct motor,

112
00:05:43,680 --> 00:05:48,020
star, 'n verwysing na 'n
struct motor het my motor,

113
00:05:48,020 --> 00:05:51,250
gelyk malloc grootte van struct motor.

114
00:05:51,250 --> 00:05:54,950
Grootte van ons sal uitvind hoeveel
grepe jou nuwe tipe data neem.

115
00:05:54,950 --> 00:05:58,570
Jy hoef nie noodwendig net nodig om te gebruik
grootte van, breedte, int of char, of enige

116
00:05:58,570 --> 00:05:59,715
van die gebou in die tipes data.

117
00:05:59,715 --> 00:06:02,090
Die samesteller is slim genoeg
om uit te vind hoeveel bytes

118
00:06:02,090 --> 00:06:04,170
vereis word deur jou nuwe struktuur.

119
00:06:04,170 --> 00:06:09,610
So ek malloc myself 'n eenheid van die geheue
groot genoeg om 'n struct motor te hou,

120
00:06:09,610 --> 00:06:12,410
en ek kry 'n wyser terug
dat die blok van die geheue,

121
00:06:12,410 --> 00:06:16,090
en dat wyser is opgedra aan my motor.

122
00:06:16,090 --> 00:06:18,050
>> Nou, as ek wil toegang
die velde van my motor,

123
00:06:18,050 --> 00:06:22,615
Ek het eers dereference my motor met behulp van
die dereference operateur, ster

124
00:06:22,615 --> 00:06:26,620
wat ons gesien het uit die wysers
video's, en dan nadat ek dereference,

125
00:06:26,620 --> 00:06:32,200
dan kan ek die dot operateur om te gebruik
toegang tot die verskillende velde van my motor.

126
00:06:32,200 --> 00:06:35,490
Ster my motor dot jaar gelyk 2011.

127
00:06:35,490 --> 00:06:38,480
Dit sou die effek
ons wil in hierdie geval,

128
00:06:38,480 --> 00:06:41,960
want ons het dinamies
my motor toegeken.

129
00:06:41,960 --> 00:06:43,610
>> Dit is soort van irriterende, al is, reg?

130
00:06:43,610 --> 00:06:44,818
Daar is 'n 2-stap proses nou.

131
00:06:44,818 --> 00:06:47,460
Nou moet ons dereference--
ons het 'n ster-operateur,

132
00:06:47,460 --> 00:06:48,910
en ons het 'n dot-operateur.

133
00:06:48,910 --> 00:06:51,660
En as jy kan verwag, want
C programmeerders lief korter maniere

134
00:06:51,660 --> 00:06:53,740
om dinge te doen, daar is 'n
korter manier om dit te doen nie.

135
00:06:53,740 --> 00:06:57,790
Daar is 'n ander operateur genoem pyl,
wat maak hierdie proses 'n baie makliker.

136
00:06:57,790 --> 00:07:00,750
Die manier waarop pyl werk is
dit die eerste dereferences

137
00:07:00,750 --> 00:07:03,560
die wyser aan die linkerkant
kant van die operateur,

138
00:07:03,560 --> 00:07:06,620
en dan, nadat dereferenced
die wyser op die linkerkant,

139
00:07:06,620 --> 00:07:09,620
dit toegang tot die veld aan die regterkant.

140
00:07:09,620 --> 00:07:14,170
En so het ons voorheen dié soort
Star my motor dot al hierdie dinge,

141
00:07:14,170 --> 00:07:15,880
soos daar was 'n baie gaan op daar.

142
00:07:15,880 --> 00:07:22,040
Maar wat kan ons doen in plaas this-- is
my motor pyl jaar gelyk 2011.

143
00:07:22,040 --> 00:07:23,580
>> Weereens, wat hier gebeur?

144
00:07:23,580 --> 00:07:25,720
Eerstens, ek dereferencing my motor.

145
00:07:25,720 --> 00:07:27,810
Wat weer, is 'n wyser hier.

146
00:07:27,810 --> 00:07:31,270
Dan, nadat
dereferenced my motor, het ek

147
00:07:31,270 --> 00:07:35,130
kan dan toegang tot die velde
jaar, plaat, en odometer

148
00:07:35,130 --> 00:07:40,020
net soos ek kon voordat hy die eerste
gebruikte ster dereference my motor,

149
00:07:40,020 --> 00:07:42,020
en dot om toegang tot die veld.

150
00:07:42,020 --> 00:07:45,290
Sodat jy kan strukture hê, moet jy
kan pointers het om strukture,

151
00:07:45,290 --> 00:07:48,360
en jy het maniere om toegang
die velde van die strukture,

152
00:07:48,360 --> 00:07:52,600
of jy het verwysings na
hulle of die veranderlikes self.

153
00:07:52,600 --> 00:07:57,640
Dot of pyl, afhangende van
hoe die veranderlike verklaar is.

154
00:07:57,640 --> 00:08:00,510
Ek is Doug Lloyd, dit is CS50.

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