>> [MUSIK SPELA]
>> DOUG LLOYD: OK.
Vi har arbetat med heltal, Vi har arbetat med tecken,
Vi har arbetat flottar, dubbel, strängar och bools.
Vi har uttömt ganska mycket alla av [OHÖRBAR] typer som
har varit tillgängliga för oss hela tiden.
Men nu vill vi göra något mer.
Hur gör vi det?
Hur skapar vi olika datatyper?
Vi kan göra det genom att använda strukturer.
Så strukturer ger oss möjlighet att förena variabler av olika typ
i en enda, ny variabel typ, som vi kan överlåta sin egen typ namn.
Detta är en riktigt stark sak att kunna göra,
eftersom vi kan nu grupp element av olika datatyper
tillsammans som har en logisk förbindelse.
Vi har kunnat göra detta med arrayer slags, eller hur?
Vi kan gruppera variabler av samma datatyp
tillsammans i en stor enhet minne, en matris.
>> Men vi har inte kunnat blanda upp olika datatyper tillsammans.
Vi kan inte säga, koppla ihop ett heltal, och ett tecken, och en dubbel alla
i samma sak och ring att en enda enhet.
Men med strukturer, eller ofta kallad structs,
vi faktiskt kan.
Så en struktur är typ av som en super variabel.
Det är en variabel som innehåller andra variabler inne i det.
Så här är ett exempel på en mycket enkel struktur.
Detta är vad syntaxen skulle se vilja skapa en struktur för en bil.
Nu ska vi gå igenom syntaxen här.
Struct, det är nyckelord som indikerar
att jag skapar en ny datatyp här.
I synnerhet är datatypens namn kommer att bli struct bil, som vi får se.
Men detta är den typ av spets av till kompilatorn att detta
som en grupp av variabler som kommer att vara en del av samma typ
om en minut.
>> Bilar, bara namnet på strukturen.
Återigen, är typ här data går vara struct bil, inte bara bil.
Men om du har different-- Om du skapar flera structs
i samma program, måste du skilja mellan struct och struct.
Så struct bil, jag kan också ha struct student, till exempel,
i samma program.
Inuti klammerparenteserna är alla av de så kallade fält,
eller medlemmar i strukturen.
Så vad är några av de saker som är inneboende i en bil?
Jo, oftast har det ett år, har ett modellnamn och en registreringsskylt,
en vägmätare som vanligtvis har ett visst antal miles på den,
och kanske en storlek motor.
Och som ni kan se, jag blandar ihop heltal och tecken och dubbel.
De kommer alla att vara en del av denna nya datatypen.
>> Slutligen, den sista jag behöver göra, Glöm inte den här lilla semikolon
i slutet.
Efter att vi har definierat strukturen, Vi måste sätta ett semikolon i slutet.
Det är en mycket vanlig syntaktisk misstag, eftersom med en funktion,
till exempel, skulle du bara ha öppna klammerparentes, nära klammerparentes.
Du behöver inte sätta ett semikolon på änden av en funktionsdefinition.
Det ser ut som en funktion definition, men det är inte,
och så semikolon där är bara en påminnelse om att du
måste lägga den där, eftersom kompilatorn kommer annars inte
vet vad de ska göra med det.
Det är ett mycket vanligt fel misstag göra
när du först definiera strukturer.
>> OK.
Så vi brukar definiera våra strukturer högst upp på våra program
eftersom de förmodligen kommer som skall användas av flera funktioner.
Vi vill inte definiera en struct inne i en funktion,
för då kan vi only-- den omfattningen av strukturen verkligen
bara finns inne i denna funktion.
Vi skulle antagligen vill definiera en struktur så att vi kan använda det i flera funktioner,
eller kanske i flera filer som är sammanbundna
att skapa vårt enda program.
Ibland också i stället definiera strukturen
högst upp där du sätter din pundet omfattar och din pund definierar
till exempel, kan du lägga dem i separata dot h-filer, som du sedan
pound inkluderar själv.
>> Så vi har strukturer, men nu vi behöver för att komma in i dem.
Hur ska vi komma in i en struktur för att åtkomst
dessa under variabler, dessa variabler som finns inne i strukturen?
Tja, har vi något som kallas punktoperatorn, vilket gör att vi
att få tillgång till de områden av strukturen.
Så till exempel, låt oss säga att jag har förklarat skriver min strukturera data någonstans
på toppen av mitt program, eller kanske i en punkt h fil som jag har pundet ingår.
Om jag sedan vill skapa en ny variabel av denna typ uppgifter, kan jag säga,
struct bil, min bil, semikolon.
Precis som jag kunde säga int x, eller strängnamn semikolon.
>> Datatypen här är struct bil, namnet på variabeln är min bil,
och då kan jag använda punktoperatorn till tillgång till olika områden av min bil.
Så jag kan säga min bil dot år är lika med 2011.
Det är alldeles utmärkt.
År, om ni minns, definierades som en heltalsfält insidan av denna struct bil
data typ.
Så någon variabel av struct bil uppgifter typ, såsom min bil, kan jag säga min bil
dot år jämlikar och sedan tilldela det lite heltal 2011.
Min bil prick plattan är lika med CS50.
Mitt kort dot vägmätare är lika med 50.505 semikolon.
Alla dessa är helt bra och det är
hur vi öppnar områden av strukturen.
Konstruktioner, fast, inte behöver som skall skapas på stacken.
Precis alla andra variabler, vi kan dynamiskt fördela dem.
Om vi ​​har ett program som kanske genererar många strukturer,
Vi vet inte hur många vi kommer att behöva,
då måste vi dynamiskt fördela dessa strukturer
som vårt program körs.
Och så om vi ska få tillgång till fält med en struktur i det sammanhanget,
Minns att måste vi först dereference pekaren till strukturen,
och sedan när vi dereference den pointer, då kan vi få tillgång till fälten.
Om vi ​​bara har en pekare till strukturen,
vi kan inte bara säga pekar dot fält namn och få vad vi letar efter.
Det finns det extra steget av Återgång.
Så låt oss säga att i stället för den previous--
precis som i föregående exempel, i stället för att förklara det
på stacken, struct bil, min bil, semikolon, säger jag struct bil,
stjärna, en pekare till en struct bil ringde min bil,
lika malloc storlek struct bil.
Storlek på vi ska räkna ut hur många bytes nya datatyp tar upp.
Du behöver inte nödvändigtvis bara behöver använda storlek, bredd, int eller röding, eller
av de inbyggda datatyper.
Kompilatorn är smart nog att räkna ut hur många bytes
är enligt den nya strukturen.
Så jag malloc mig en enhet av minne stor nog att rymma en struct bil,
och jag får en pekare tillbaka till den minnesblock,
och att pekaren tilldelas min bil.
>> Nu, om jag vill ha tillgång till områdena min bil,
Jag först dereference min bil med hjälp av den dereference operatör, stjärna
att vi har sett från pekare videor, och sedan efter att jag dereference,
då kan jag använda punktoperatorn till tillgång till olika områden av min bil.
Star min bil dot år är lika med 2011.
Det skulle innebära Vi vill i detta fall,
eftersom vi har dynamiskt tilldelats min bil.
>> Det är typ av irriterande, men hur?
Det finns en 2-stegsprocess nu.
Nu måste vi dereference-- vi har en stjärn operatör,
och vi har en punktoperatorn.
Och som du kan förvänta sig, eftersom C programmerare gärna kortare vägar
att göra saker, finns det en kortare sätt att göra detta.
Det finns en annan operatör som kallas pil, vilket gör denna process mycket enklare.
Sättet arrow fungerar är den först dereferences
pekaren till vänster sida av operatör,
och sedan, efter att ha dereferenced pekaren till vänster,
Det åtkomst till fältet till höger.
Och så tidigare hade vi den här sortens av stjärn min bil dot allt det här,
som om det fanns en hel del som händer där.
Men vad vi kan i stället göra är this-- min bil arrow år är lika med 2011.
>> Återigen, vad som händer här?
Först, jag Namnåtergång min bil.
Som återigen, är en pekare här.
Sedan, efter att ha dereferenced min bil, jag
kan sedan komma åt fälten år, tallrik, och vägmätare
precis som jag kunde innan du får först begagnad stjärna till avreferera min bil,
och prick för att gå in i fältet.
Så du kan ha strukturer, du kan ha pekare till strukturer,
och du har olika sätt att komma åt områdena dessa strukturer,
om du har pekare till dem eller variablerna själva.
Dot eller pil, beroende på hur variabeln förklarades.
Jag är Doug Lloyd, är detta CS50.