>> [MUSIC SPILLE]
>> DOUG LLOYD: OK.
Vi har jobbet med heltall, vi har jobbet med tegn,
vi har jobbet flyter, dobbeltrom, strenger, og bools.
Vi har brukt ganske mye alle av de [uhørbart] typer som
har vært tilgjengelig for oss alle sammen.
Men nå ønsker vi å gjøre noe mer.
Hvordan gjør vi det?
Hvordan skaper vi forskjellige datatyper?
Vi kan gjøre det ved hjelp av strukturer.
Så strukturer tillate oss å forene variabler av forskjellige typer
i en enkelt, ny variabel type, som vi kan tildele sin egen type navn.
Dette er en veldig sterk ting å være i stand til å gjøre,
fordi vi kan nå gruppe elementer av forskjellige datatyper
sammen som har en logisk sammenheng.
Vi har vært i stand til å gjøre dette med matriser liksom, ikke sant?
Vi kan gruppere variabler av samme datatype
sammen i en stor enhet av hukommelse, en matrise.
>> Men vi har ikke vært i stand til å blande opp ulike datatyper sammen.
Vi kan ikke, si, pare et heltall, og en karakter, og en dobbel alle
i det samme og kalle det en enkelt enhet.
Men med strukturer, eller ofte referert til som structs,
vi faktisk kan.
Så en struktur er liksom som en super variabel.
Det er en variabel som inneholder andre variabler inne i den.
Så her er et eksempel på en meget enkel konstruksjon.
Dette er hva syntaksen ville se ønsker å lage en konstruksjon for en bil.
Nå, la oss gå gjennom syntaksen her.
Struct, er at søkeord som indikerer
at jeg oppretter en ny datatype her.
Spesielt er den datatype navn kommer til å være struct bil, så vi får se.
Men dette er den type spiss av til kompilatoren at denne
som en gruppe av variabler som går for å bli betraktet som en del av den samme typen
om et øyeblikk.
>> Biler, bare navnet på strukturen.
Igjen blir datatypen her kommer å være struct bil, ikke bare bil.
Men hvis du har different-- Hvis du oppretter flere structs
i det samme programmet, må du skille mellom struct og struct.
Så struct bil, kan jeg også ha struct student, f.eks
i samme program.
Innsiden av klammeparentes er alle av de såkalte felt
eller medlemmer av strukturen.
Så hva er noen av tingene som er iboende i en bil?
Vel, har det vanligvis et år, har et modellnavn, og en lisens plate,
en kilometerteller som vanligvis har noen antall miles på den,
og kanskje en motorstørrelse.
Og som du kan se, jeg blande opp heltall og tegn og dobler.
De kommer alle til å være del av denne nye datatype.
>> Til slutt, den siste tingen jeg må gjøre, ikke glem denne lille semikolon
I slutten.
Etter at vi er ferdig med å definere strukturen, vi trenger å sette et semikolon på slutten.
Det er en veldig vanlig syntaktisk feil, fordi med en funksjon,
for eksempel, ville du bare ha åpen klammeparentes, tett krøllete brace.
Du trenger ikke sette et semikolon på enden av en funksjonsdefinisjon.
Dette ser ut som en funksjon definisjon, men det er ikke,
og så semikolon der er bare en påminnelse om at du
trenger å sette den der, fordi kompilatoren ellers ikke vil
vet hva de skal gjøre med det.
Det er en veldig vanlig feil uhell gjøre
når du først definere strukturer.
>> OK.
Så vi vanligvis definerer våre strukturer på toppen av våre programmer
fordi de sannsynligvis kommer å bli brukt av flere funksjoner.
Vi ønsker ikke å definere en konstruere inne i en funksjon,
fordi da kan vi only-- den Omfanget av strukturen virkelig
kun eksisterer inne i den funksjonen.
Vi ville trolig vil definere en struktur slik at vi kan bruke det i flere funksjoner,
eller kanskje i multiple filer som er knyttet sammen
å lage vår eneste program.
Noen ganger også i stedet for å definere strukturen
helt på toppen hvor du setter din pound inkluderer og din pund definerer,
for eksempel, kan du sette dem i separate dot h-filer, som du deretter
pund inkluderer selv.
>> Så vi har strukturer, men nå vi trenger for å komme på innsiden av dem.
Hvordan får vi innsiden av en struktur for å få tilgang
disse sub-variabler, disse variablene som eksisterer inne i strukturen?
Vel, har vi noe som heter prikken operatør, noe som gir oss
for å få tilgang til felt av strukturen.
Så for eksempel, la oss si at jeg har erklært mine strukturdata skriver et sted
på toppen av min program, eller kanskje i en prikk h fil som jeg har pund inkludert.
Hvis jeg da ønsker å opprette en ny variabel av den datatypen, kan jeg si,
struct bil, bilen min, semikolon.
Akkurat som jeg kunne si int x, eller string name semikolon.
>> Datatypen her er struct bil, navnet på variabelen er bilen min,
og da kan jeg bruke dot operatøren få tilgang til de ulike feltene i bilen min.
Så jeg kan si bilen min dot år tilsvarer 2011.
Det er helt greit.
År, hvis du husker, ble definert som en heltallsfelt innsiden av denne struct bil
datatype.
Så noen variable av struct bilen data type, slik som bilen min, kan jeg si bilen min
dot år lik og deretter tildele det noen heltall 2011.
Min bil dot plate lik CS50.
Kortet mitt dot kilometerteller tilsvarer 50505 semikolon.
Alle disse er helt greit, og det er
hvordan vi får tilgang til felt av strukturen.
Strukturer, men ikke trenger skal opprettes på stakken.
Akkurat som alle andre variable, vi kan dynamisk tildele dem.
Hvis vi har et program som kan generere mange strukturer,
Vi vet ikke hvor mange vi kommer til å trenge,
da må vi dynamisk fordele disse strukturene
som vårt program er i gang.
Og så hvis vi kommer til å få tilgang til felt av en struktur i den sammenheng,
tilbakekalling at vi først må dereference pekeren til strukturen,
og deretter en gang vi dereference den pekeren, så vi kan få tilgang til feltene.
Hvis vi bare har en Peker til strukturen,
Vi kan ikke bare si pekeren dot-feltet navngi og få det vi leter etter.
Det er ekstra trinn av dereferencing.
Så la oss si at i stedet for den previous--
akkurat som forrige eksempel, i stedet for å erklære det
på stakken, struct bilen min bil, semikolon, sier jeg struct bil,
stjerne, en peker til en struct bilen heter bilen min,
tilsvarer malloc størrelsen struct bil.
Størrelsen vil vi finne ut hvor mange byte den nye datatypen tar opp.
Du trenger ikke nødvendigvis bare trenger å bruke Størrelsen, bredde, int eller røye, eller en hvilken som helst
av de innebygde datatyper.
Kompilatoren er smart nok å finne ut hvor mange bytes
kreves av den nye strukturen.
Så jeg malloc meg en enhet av minne stor nok til å holde en struct bil,
og jeg får en peker tilbake I tillegg minneblokk,
og at pekeren er tildelt til bilen min.
>> Nå, hvis jeg ønsker å få tilgang til innen bilen min,
Jeg først deferanseoperasjon bilen min hjelp den dereferanseoperator, stjerne
som vi har sett fra de pekere videoer, og deretter etter at jeg dereference,
Da kan jeg bruke dot operatøren få tilgang til de ulike feltene i bilen min.
Stjerners bilen min dot år tilsvarer 2011.
Det ville ha effekt Vi vil i dette tilfellet
fordi vi har dynamisk bevilget bilen min.
>> Det er litt irriterende, skjønt, ikke sant?
Det er en to-trinns prosess nå.
Nå må vi dereference-- vi har en stjerne operatør,
og vi har en prikk operatør.
Og som du kanskje forventer, fordi C-programmerere elsker kortere måter
å gjøre ting, er det en kortere vei til å gjøre dette.
Det er en annen operatør som heter pil, noe som gjør denne fremgangsmåten mye enklere.
Måten pil fungerer er det første dereferences
pekeren til venstre siden av førerhuset,
og så, etter å ha dereferenced pekeren til venstre,
det tilgang til feltet til høyre.
Og så tidligere hadde vi denne typen av Star bilen min dot alt dette,
som det var mye å gå på der.
Men det vi kan i stedet gjøre er dette-- min bil pil år tilsvarer 2 011.
>> Igjen, hva er det som skjer her?
Først, jeg dereferencing bilen min.
Som igjen er en peker her.
Deretter, etter å ha dereferenced bilen min, jeg
Deretter kan du få tilgang til feltene år, plate, og kilometerteller
akkurat som jeg kunne før etter først å ha brukte stjerne til deferanseoperasjon bilen min,
og prikk å få tilgang til feltet.
Så du kan ha strukturer, du kan ha pekere til strukturer,
og du har måter å få tilgang til felt av disse strukturer,
om du har pekere til dem eller variablene selv.
Dot eller pil, avhengig hvordan variabelen ble erklært.
Jeg er Doug Lloyd, dette er CS50.