[Powered by Google Translate] Räägime structs.
Structs anda meile võimalus rühmitada kamp muutujad koos
arvesse kena paketi.
See on ilmselt kõige lihtsam näha näiteks kohe,
nii me ütleme struct,
Seejärel avatakse lokkis traksidega,
ja selle struktuure, me peame int vanus,
char * nimi,
ja ongi kõik.
See võib tunduda imelik semikooloniga pärast lokkis traksidega,
aga see on tegelikult vajalik structs.
Suvaline kehtiv tüüp võib minna jooksul struct määratlus.
Siin me oleme kasutanud int ja char *,
aga sa võiksid ka kasutada massiivi, on sõnaõigus, 100 elementi
või isegi teise struct.
Kui te kasutate structs C,
loote uut tüüpi
välja kogumik muud liiki.
Siin teeme uut tüüpi
välja täisarv ja char *.
Nagu näeme hiljem, struct tüüp
on palju võimalusi samaväärne mistahes muud tüüpi sa oled harjunud.
Tavaliselt ma tulen võrrelda kuidas struct tüüp
on sarnane täisarv tüüp.
Kuigi koodi me kirjutas kehtib C,
see ei ole väga kasulik,
Ja rõkkama annab meile hoiatuse.
Mäletan, kuidas structs ja tema on sarnased?
Noh, me põhiliselt just ütles
int,
mis ei ole väga kasulik rida.
Nii et olgem tegelikult kuulutada muutuja seda tüüpi
andes sellele nime enne semikoolonit.
Me kutsume muutuja õpilane.
Nüüd oleme deklareeritud muutuja nimega üliõpilane
tüübiga antud struct.
Kuidas me saame muutujate sees struct?
Tehniliselt nimed need muutujad
on kohal.
Et pääseda mõne konkreetse liikmesriigi õpilase struct,
sa lisab dot muutuva nimi,
järgneb liikme nimel soovite.
Nii et siin, ainult 2 kehtiv võimalusi
on student.age
ja student.name.
Ja me saame teha midagi
student.age = 12
ja student.name = üliõpilane.
Mis nüüd, kui me tahtsime teha teise üliõpilane?
Võite arvata, kopeeri ja kleebi need read
ja muuta õpilane üliõpilane 2 või midagi,
ja mis töötab,
kuid tehniliselt, õpilane ja üliõpilane 2
ei ole sama tüüpi.
Vaata, sa ei saa lähetada neid üksteisega.
Seda seetõttu, et seni
oma struct on anonüümne.
Me peame andma sellele nime.
Selleks, et me sisestada nimi struct
pärast sõna struct.
õpilane,
millele järgneb mõiste.
Me saame veel viivitamata teatama tüüpi muutuja
vatseti õpilane, nagu me tegime enne.
Me kutsume seda S1
Andes struct nimi,
saame nüüd kasutada struct õpilane
peaaegu täpselt samal viisil me kasutaks int.
Nii saame kuulutada tüüpi muutuja struct õpilane,
nagu
struct õpilane S2.
Nagu massiivid, structs anda otsetee initsialiseerimise süntaks,
Nii võime öelda, vatseti õpilane S2
võrdub
vasak lokkis traksidega 3, S2.
Siin S2.age on 3,
ja S2.name toob välja S2.
Mõtle kõik asjad, mida saate teha int tüüpi
ja enamik neist saab teha struct õpilane tüüp.
Saame kasutada struct õpilane nagu tüüpi funktsiooni parameeter.
Saame kasutada struct õpilane sees uus struct.
Me ei pea kursorit struct õpilane.
Me ei saa teha suurust struct õpilane.
Struct õpilane on teatud tüüpi
nagu int on tüüp.
Me võime määrata ka S1 S2
kuna mõlemad on sama tüüpi, et saaksime teha
S1 = S2.
Mis juhtub, kui me teeme
S1.age = 10?
Kas S2 muutus üldse?
Jällegi, mõtle structs lihtsalt regulaarne täisarvud.
Kui anname mõned int X mõned int y,
nagu X = Y
ja siis muutus X
nagu X + +,
ei jah muutu üldse?
Y ei muuda siin, ja nii pole ka S2 eespool.
S2.age on veel 3.
Aga teadmiseks, et kui määrates 1 struct teise,
kõik osuti ikka osutada sama asi,
kuna nad olid lihtsalt kopeeritud.
Kui te ei soovi vihjeid jagada,
peate käsitsi hakkama,
võib-olla malicking üks plokk mälu üks osuti osutada
ja andmete kopeerimist üle.
See võib olla tüütu on kirjutada struct õpilane kõikjal.
Kasutades tüüp def, me saame teha
tüüp def
struct
ja me kutsume seda õpilane.
Nüüd saame kasutada õpilane kõikjal
et me kasutasime kasutada struct õpilane.
Seda tüüpi def on anonüümne struct
ja nimetab seda õpilane.
Aga kui me ka pidada õpilase tunnus
kõrval sõna struct, nagu typedef struktuure õpilane,
saaksime kasutada nii struct õpilane ja üliõpilane vaheldumisi nüüd.
Nad isegi ei pea olema sama nimi.
Me võiksime kirjutada def struct õpilane Bob
ja siis vatseti õpilane ja Bob
oleks vahetatavad tüübid.
Sõltumata tüüpi def,
peame tunnus kõrval vatseti
kui määratlus struct
on rekursiivne.
Näiteks
tüüp def struct tipp
ja see on määratletud kui int val
ja see on osuti, mis näitab teise struct tipp.,
nagu struct tipp * kõrval.
Ja siis me kutsume seda sõlme.
See struct on rekursiivne,
kuna mõiste struct tipp sisaldab endas
kursor struct tipp.
Pange tähele, et meil öelda struct tipp * Järgmine
sees mõiste struct tipp,
kuna tüüp def ei ole veel lõppenud, et me saaksime seda lihtsustada
lihtsalt sõlme * kõrval.
Te õpite lähemalt structs sarnane sellele
kui küsimus on seotud nimekirju ja puid.
Aga structs sisse funktsioon?
See on ka täiesti kehtiv.
Meil võiks olla
void func
mis võtab argumendiks,
üliõpilane s
ja teeb midagi selle õpilane.
Ja siis me edastame selle kui student struct nagu nii.
Func S1-st enne.
Struct käitub
täpselt nii, nagu täisarv oleks kui edasi funktsiooni.
Func saab koopia S1
ja nii ei saa muuta S1;
pigem, vaid koopia, mis salvestatakse S.
Kui soovite funktsiooni, et oleks võimalik muuta S1,
funktsioonide puhul tuleb võtta õpilase * S
ja sa pead läbima S1 aadressi järgi, nii nagu.
Student * S, funkt-S1.
On veel teinegi põhjus, et mööda aadress siin.
Mis siis, kui meie struct sisalduvate 100 väljad?
Iga kord võtame õpilane peab toimima,
Meie programm peab kopeerida kõik neist 100 väljad func argument S,
isegi kui ta ei ole kunagi kasutab valdav enamus neist.
Nii et isegi kui func ei kavatse muuta üliõpilane,
kui saab veel väärtuslik mööda aadress.
Okei, aga kui me tahame luua kursori struct?
Me võiksime teha midagi
õpilane * S
võrdub malloc
suurus õpilane.
Pange tähele, et suurus ikka töötab siin.
Niisiis, kuidas me nüüd kasutada vanus liige
raskus, et S punkte?
Sa võid kõigepealt mõelda, mida teha
* S.age = 4,
kuid see ei ole päris töö.
Kuna see tõesti tuleb tõlgendada nii,
* S.age sulgudes = 4,
mis ei ole isegi koguma,
kuna S ei ole struct või pigem kursor struct,
ja nii dot juhul ei toimi.
Võiksime teha
(* S). Vanus = 4
kuid sulgudes saab tüütu ja segadusttekitav.
Õnneks on meil eriline nool operaator
, mis näeb välja
S-> vanus = 4.
Need 2 võimalust viitamine vanus
on samaväärsed
ja me ei tõesti kunagi vaja nool operaator,
kuid see teeb asjad ilusam oleks.
Kuna S on viit mõned ploki mälu, mis sisaldab struct,
sa ei mõtle S> vanuse järgi osuti nool
ja haarata vanus liige.
Miks me peaksime kunagi kasutada structs?
See on kindlasti võimalik välja tulla lihtsalt primitiivne täisarvud,
tähemärki, viiteid jms
et me oleme harjunud;
asemel S1 ja S2 enne,
oleksime võinud Age1, east2, NAME1 ja NAME2
kõik on eraldi muutujad.
See on tore, ainult 2 õpilast,
aga kui me pidime neist 10?
Ja mis siis, kui selle asemel, et ainult 2 välja,
õpilane struct oli 100 valdkondades?
GPA, kursused, juuste värv, sugu, ja nii edasi.
Selle asemel, et vaid 10 structs, peame 1000 eraldi muutujat.
Samuti leiavad funktsioon
mis võtab et struct 100 valdkondades, mille ainus argument
ja prindib välja kõik väljad.
Kui me ei kasutanud struct,
iga kord, kui me nimetame seda funktsiooni,
peame läbima üldse 100 muutujaga,
ja kui meil on 100 muutujaga õpilane 1
ja 100 muutujaga üliõpilane 2
me peame olema kindlad, et me ei kogemata läbida mõned muutujaid õpilane 1
ja mõned muutujaid üliõpilane 2.
See on võimatu, et ekslikult struct,
kuna kõik 100 muutujad, mis moodustavad ühe paketi.
Lihtsalt paar viimast märkused:
Kui oled kõigest aru kuni see punkt, tore.
Ülejäänud video on lihtsalt täielikkuse pärast.
Sest structs mahub igat tüüpi pointer,
nad võivad samuti omada funktsiooni osuti.
Kui te olete juba tuttav objektorienteeritud programmeerimise,
see annab võimaluse kasutada structs et programmi objektorienteeritud stiilis.
Veel funktsiooni osuti muul ajal.
Ka mõnikord võite on 2 structs
kelle määratlused sõltuvad üksteisest.
Näiteks
oleksime võinud struct,
mis on määratletud
kursor struct B
struct B * X
ja nüüd saame struct B
mis on määratletud kui osuti
kuni struct,
struct * Y.
Aga see ei kompileerida,
alates struct Bd ei ole, siis samal ajal struct on koostamisel.
Ja kui me swap struct ja struct B
siis olime lihtsalt ei jää sama probleem;
Selle aja koos vatseti ole olemasolev.
Et seda lahendada, saame kirjutada
struct B;
enne määratlus struct A.
Seda nimetatakse edasi deklaratsiooni.
See lihtsalt võimaldab kompilaator teada, et
struct B on kehtiv tüüp, mis on täielikult määratletud hiljem või mujal.
Minu nimi on Rob Bowden, ja see on CS50.
[CS50.TV]