1
00:00:00,000 --> 00:00:02,395
>> [MUSIK SPELA]

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
Vi har arbetat med heltal,
Vi har arbetat med tecken,

5
00:00:08,880 --> 00:00:11,930
Vi har arbetat flottar,
dubbel, strängar och bools.

6
00:00:11,930 --> 00:00:14,870
Vi har uttömt ganska mycket alla
av [OHÖRBAR] typer som

7
00:00:14,870 --> 00:00:17,100
har varit tillgängliga för oss hela tiden.

8
00:00:17,100 --> 00:00:19,430
Men nu vill vi göra något mer.

9
00:00:19,430 --> 00:00:20,210
Hur gör vi det?

10
00:00:20,210 --> 00:00:22,560
Hur skapar vi olika datatyper?

11
00:00:22,560 --> 00:00:26,130
Vi kan göra det genom att använda strukturer.

12
00:00:26,130 --> 00:00:30,180
Så strukturer ger oss möjlighet att förena
variabler av olika typ

13
00:00:30,180 --> 00:00:34,810
i en enda, ny variabel typ,
som vi kan överlåta sin egen typ namn.

14
00:00:34,810 --> 00:00:37,570
Detta är en riktigt stark
sak att kunna göra,

15
00:00:37,570 --> 00:00:40,900
eftersom vi kan nu grupp
element av olika datatyper

16
00:00:40,900 --> 00:00:43,910
tillsammans som har en logisk förbindelse.

17
00:00:43,910 --> 00:00:46,440
Vi har kunnat göra detta
med arrayer slags, eller hur?

18
00:00:46,440 --> 00:00:49,540
Vi kan gruppera variabler
av samma datatyp

19
00:00:49,540 --> 00:00:53,410
tillsammans i en stor enhet
minne, en matris.

20
00:00:53,410 --> 00:00:56,660
>> Men vi har inte kunnat blanda
upp olika datatyper tillsammans.

21
00:00:56,660 --> 00:01:02,610
Vi kan inte säga, koppla ihop ett heltal,
och ett tecken, och en dubbel alla

22
00:01:02,610 --> 00:01:05,330
i samma sak och
ring att en enda enhet.

23
00:01:05,330 --> 00:01:08,830
Men med strukturer, eller
ofta kallad structs,

24
00:01:08,830 --> 00:01:09,585
vi faktiskt kan.

25
00:01:09,585 --> 00:01:12,370
Så en struktur är typ
av som en super variabel.

26
00:01:12,370 --> 00:01:16,530
Det är en variabel som innehåller
andra variabler inne i det.

27
00:01:16,530 --> 00:01:19,650
Så här är ett exempel på
en mycket enkel struktur.

28
00:01:19,650 --> 00:01:23,380
Detta är vad syntaxen skulle se
vilja skapa en struktur för en bil.

29
00:01:23,380 --> 00:01:25,250
Nu ska vi gå igenom syntaxen här.

30
00:01:25,250 --> 00:01:27,400
Struct, det är
nyckelord som indikerar

31
00:01:27,400 --> 00:01:30,270
att jag skapar en ny datatyp här.

32
00:01:30,270 --> 00:01:33,860
I synnerhet är datatypens namn
kommer att bli struct bil, som vi får se.

33
00:01:33,860 --> 00:01:36,640
Men detta är den typ av spets
av till kompilatorn att detta

34
00:01:36,640 --> 00:01:42,440
som en grupp av variabler som kommer
att vara en del av samma typ

35
00:01:42,440 --> 00:01:44,010
om en minut.

36
00:01:44,010 --> 00:01:46,340
>> Bilar, bara namnet på strukturen.

37
00:01:46,340 --> 00:01:50,590
Återigen, är typ här data går
vara struct bil, inte bara bil.

38
00:01:50,590 --> 00:01:53,060
Men om du har different--
Om du skapar flera structs

39
00:01:53,060 --> 00:01:56,950
i samma program, måste du
skilja mellan struct och struct.

40
00:01:56,950 --> 00:02:00,140
Så struct bil, jag kan också ha
struct student, till exempel,

41
00:02:00,140 --> 00:02:01,790
i samma program.

42
00:02:01,790 --> 00:02:05,980
Inuti klammerparenteserna är
alla av de så kallade fält,

43
00:02:05,980 --> 00:02:07,954
eller medlemmar i strukturen.

44
00:02:07,954 --> 00:02:10,370
Så vad är några av de saker
som är inneboende i en bil?

45
00:02:10,370 --> 00:02:15,270
Jo, oftast har det ett år, har
ett modellnamn och en registreringsskylt,

46
00:02:15,270 --> 00:02:18,000
en vägmätare som vanligtvis har
ett visst antal miles på den,

47
00:02:18,000 --> 00:02:19,225
och kanske en storlek motor.

48
00:02:19,225 --> 00:02:23,570
Och som ni kan se, jag blandar ihop
heltal och tecken och dubbel.

49
00:02:23,570 --> 00:02:26,420
De kommer alla att vara
en del av denna nya datatypen.

50
00:02:26,420 --> 00:02:29,750
>> Slutligen, den sista jag behöver göra,
Glöm inte den här lilla semikolon

51
00:02:29,750 --> 00:02:30,290
i slutet.

52
00:02:30,290 --> 00:02:34,380
Efter att vi har definierat strukturen,
Vi måste sätta ett semikolon i slutet.

53
00:02:34,380 --> 00:02:37,325
Det är en mycket vanlig syntaktisk
misstag, eftersom med en funktion,

54
00:02:37,325 --> 00:02:40,200
till exempel, skulle du bara ha
öppna klammerparentes, nära klammerparentes.

55
00:02:40,200 --> 00:02:42,950
Du behöver inte sätta ett semikolon på
änden av en funktionsdefinition.

56
00:02:42,950 --> 00:02:46,430
Det ser ut som en funktion
definition, men det är inte,

57
00:02:46,430 --> 00:02:49,653
och så semikolon där
är bara en påminnelse om att du

58
00:02:49,653 --> 00:02:52,440
måste lägga den där, eftersom
kompilatorn kommer annars inte

59
00:02:52,440 --> 00:02:53,510
vet vad de ska göra med det.

60
00:02:53,510 --> 00:02:56,160
Det är ett mycket vanligt fel
misstag göra

61
00:02:56,160 --> 00:02:58,570
när du först definiera strukturer.

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

63
00:02:59,500 --> 00:03:02,824
Så vi brukar definiera våra strukturer
högst upp på våra program

64
00:03:02,824 --> 00:03:05,490
eftersom de förmodligen kommer
som skall användas av flera funktioner.

65
00:03:05,490 --> 00:03:08,850
Vi vill inte definiera en
struct inne i en funktion,

66
00:03:08,850 --> 00:03:12,110
för då kan vi only-- den
omfattningen av strukturen verkligen

67
00:03:12,110 --> 00:03:13,790
bara finns inne i denna funktion.

68
00:03:13,790 --> 00:03:17,450
Vi skulle antagligen vill definiera en struktur
så att vi kan använda det i flera funktioner,

69
00:03:17,450 --> 00:03:20,670
eller kanske i flera
filer som är sammanbundna

70
00:03:20,670 --> 00:03:22,920
att skapa vårt enda program.

71
00:03:22,920 --> 00:03:24,920
Ibland också i stället
definiera strukturen

72
00:03:24,920 --> 00:03:27,961
högst upp där du sätter din
pundet omfattar och din pund definierar

73
00:03:27,961 --> 00:03:32,080
till exempel, kan du lägga dem i
separata dot h-filer, som du sedan

74
00:03:32,080 --> 00:03:35,020
pound inkluderar själv.

75
00:03:35,020 --> 00:03:37,620
>> Så vi har strukturer, men nu
vi behöver för att komma in i dem.

76
00:03:37,620 --> 00:03:39,800
Hur ska vi komma in i
en struktur för att åtkomst

77
00:03:39,800 --> 00:03:43,530
dessa under variabler, dessa variabler
som finns inne i strukturen?

78
00:03:43,530 --> 00:03:46,810
Tja, har vi något som kallas
punktoperatorn, vilket gör att vi

79
00:03:46,810 --> 00:03:50,990
att få tillgång till de områden av strukturen.

80
00:03:50,990 --> 00:03:55,490
Så till exempel, låt oss säga att jag har förklarat
skriver min strukturera data någonstans

81
00:03:55,490 --> 00:03:59,020
på toppen av mitt program, eller kanske i
en punkt h fil som jag har pundet ingår.

82
00:03:59,020 --> 00:04:03,360
Om jag sedan vill skapa en ny
variabel av denna typ uppgifter, kan jag säga,

83
00:04:03,360 --> 00:04:06,260
struct bil, min bil, semikolon.

84
00:04:06,260 --> 00:04:11,580
Precis som jag kunde säga int
x, eller strängnamn semikolon.

85
00:04:11,580 --> 00:04:18,100
>> Datatypen här är struct bil,
namnet på variabeln är min bil,

86
00:04:18,100 --> 00:04:23,770
och då kan jag använda punktoperatorn till
tillgång till olika områden av min bil.

87
00:04:23,770 --> 00:04:27,494
Så jag kan säga min bil
dot år är lika med 2011.

88
00:04:27,494 --> 00:04:28,410
Det är alldeles utmärkt.

89
00:04:28,410 --> 00:04:34,210
År, om ni minns, definierades som en
heltalsfält insidan av denna struct bil

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

91
00:04:35,200 --> 00:04:39,966
Så någon variabel av struct bil uppgifter
typ, såsom min bil, kan jag säga min bil

92
00:04:39,966 --> 00:04:44,030
dot år jämlikar och sedan tilldela
det lite heltal 2011.

93
00:04:44,030 --> 00:04:47,290
Min bil prick plattan är lika med CS50.

94
00:04:47,290 --> 00:04:51,180
Mitt kort dot vägmätare
är lika med 50.505 semikolon.

95
00:04:51,180 --> 00:04:53,270
Alla dessa är
helt bra och det är

96
00:04:53,270 --> 00:04:57,802
hur vi öppnar
områden av strukturen.

97
00:04:57,802 --> 00:05:00,260
Konstruktioner, fast, inte behöver
som skall skapas på stacken.

98
00:05:00,260 --> 00:05:02,950
Precis alla andra variabler, vi
kan dynamiskt fördela dem.

99
00:05:02,950 --> 00:05:06,309
Om vi ​​har ett program som kanske
genererar många strukturer,

100
00:05:06,309 --> 00:05:08,100
Vi vet inte hur många
vi kommer att behöva,

101
00:05:08,100 --> 00:05:10,800
då måste vi dynamiskt
fördela dessa strukturer

102
00:05:10,800 --> 00:05:12,960
som vårt program körs.

103
00:05:12,960 --> 00:05:16,600
Och så om vi ska få tillgång till
fält med en struktur i det sammanhanget,

104
00:05:16,600 --> 00:05:20,660
Minns att måste vi först dereference
pekaren till strukturen,

105
00:05:20,660 --> 00:05:24,810
och sedan när vi dereference den
pointer, då kan vi få tillgång till fälten.

106
00:05:24,810 --> 00:05:26,830
Om vi ​​bara har en
pekare till strukturen,

107
00:05:26,830 --> 00:05:32,120
vi kan inte bara säga pekar dot fält
namn och få vad vi letar efter.

108
00:05:32,120 --> 00:05:34,259
Det finns det extra steget av Återgång.

109
00:05:34,259 --> 00:05:36,050
Så låt oss säga att
i stället för den previous--

110
00:05:36,050 --> 00:05:38,770
precis som i föregående exempel,
i stället för att förklara det

111
00:05:38,770 --> 00:05:43,680
på stacken, struct bil, min
bil, semikolon, säger jag struct bil,

112
00:05:43,680 --> 00:05:48,020
stjärna, en pekare till en
struct bil ringde min bil,

113
00:05:48,020 --> 00:05:51,250
lika malloc storlek struct bil.

114
00:05:51,250 --> 00:05:54,950
Storlek på vi ska räkna ut hur många
bytes nya datatyp tar upp.

115
00:05:54,950 --> 00:05:58,570
Du behöver inte nödvändigtvis bara behöver använda
storlek, bredd, int eller röding, eller

116
00:05:58,570 --> 00:05:59,715
av de inbyggda datatyper.

117
00:05:59,715 --> 00:06:02,090
Kompilatorn är smart nog
att räkna ut hur många bytes

118
00:06:02,090 --> 00:06:04,170
är enligt den nya strukturen.

119
00:06:04,170 --> 00:06:09,610
Så jag malloc mig en enhet av minne
stor nog att rymma en struct bil,

120
00:06:09,610 --> 00:06:12,410
och jag får en pekare tillbaka
till den minnesblock,

121
00:06:12,410 --> 00:06:16,090
och att pekaren tilldelas min bil.

122
00:06:16,090 --> 00:06:18,050
>> Nu, om jag vill ha tillgång till
områdena min bil,

123
00:06:18,050 --> 00:06:22,615
Jag först dereference min bil med hjälp av
den dereference operatör, stjärna

124
00:06:22,615 --> 00:06:26,620
att vi har sett från pekare
videor, och sedan efter att jag dereference,

125
00:06:26,620 --> 00:06:32,200
då kan jag använda punktoperatorn till
tillgång till olika områden av min bil.

126
00:06:32,200 --> 00:06:35,490
Star min bil dot år är lika med 2011.

127
00:06:35,490 --> 00:06:38,480
Det skulle innebära
Vi vill i detta fall,

128
00:06:38,480 --> 00:06:41,960
eftersom vi har dynamiskt
tilldelats min bil.

129
00:06:41,960 --> 00:06:43,610
>> Det är typ av irriterande, men hur?

130
00:06:43,610 --> 00:06:44,818
Det finns en 2-stegsprocess nu.

131
00:06:44,818 --> 00:06:47,460
Nu måste vi dereference--
vi har en stjärn operatör,

132
00:06:47,460 --> 00:06:48,910
och vi har en punktoperatorn.

133
00:06:48,910 --> 00:06:51,660
Och som du kan förvänta sig, eftersom
C programmerare gärna kortare vägar

134
00:06:51,660 --> 00:06:53,740
att göra saker, finns det en
kortare sätt att göra detta.

135
00:06:53,740 --> 00:06:57,790
Det finns en annan operatör som kallas pil,
vilket gör denna process mycket enklare.

136
00:06:57,790 --> 00:07:00,750
Sättet arrow fungerar är
den först dereferences

137
00:07:00,750 --> 00:07:03,560
pekaren till vänster
sida av operatör,

138
00:07:03,560 --> 00:07:06,620
och sedan, efter att ha dereferenced
pekaren till vänster,

139
00:07:06,620 --> 00:07:09,620
Det åtkomst till fältet till höger.

140
00:07:09,620 --> 00:07:14,170
Och så tidigare hade vi den här sortens
av stjärn min bil dot allt det här,

141
00:07:14,170 --> 00:07:15,880
som om det fanns en hel del som händer där.

142
00:07:15,880 --> 00:07:22,040
Men vad vi kan i stället göra är this--
min bil arrow år är lika med 2011.

143
00:07:22,040 --> 00:07:23,580
>> Återigen, vad som händer här?

144
00:07:23,580 --> 00:07:25,720
Först, jag Namnåtergång min bil.

145
00:07:25,720 --> 00:07:27,810
Som återigen, är en pekare här.

146
00:07:27,810 --> 00:07:31,270
Sedan, efter att ha
dereferenced min bil, jag

147
00:07:31,270 --> 00:07:35,130
kan sedan komma åt fälten
år, tallrik, och vägmätare

148
00:07:35,130 --> 00:07:40,020
precis som jag kunde innan du får först
begagnad stjärna till avreferera min bil,

149
00:07:40,020 --> 00:07:42,020
och prick för att gå in i fältet.

150
00:07:42,020 --> 00:07:45,290
Så du kan ha strukturer, du
kan ha pekare till strukturer,

151
00:07:45,290 --> 00:07:48,360
och du har olika sätt att komma åt
områdena dessa strukturer,

152
00:07:48,360 --> 00:07:52,600
om du har pekare till
dem eller variablerna själva.

153
00:07:52,600 --> 00:07:57,640
Dot eller pil, beroende på
hur variabeln förklarades.

154
00:07:57,640 --> 00:08:00,510
Jag är Doug Lloyd, är detta CS50.

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