[Powered by Google Translate] Beszéljünk struktúrákat.
Struktúrák adjon nekünk egy módja annak, hogy csoportosítani egy csomó változók együttes
egy szép csomagot.
Ez talán a legkönnyebb látni példát azonnal,
így mondjuk struct,
majd megnyitásáról kapcsos zárójel,
és ebben struct, akkor van egy int kor,
egy char * név,
és ennyi.
Úgy tűnhet, furcsa pontosvesszővel után kapcsos zárójel,
de valójában szükség struktúrákat.
Bármilyen típusú érvényes lehet menni a struct definíciót.
Itt is használtam egy int és egy char *
de akkor is használ egy sor, mondjuk, 100 elem
vagy akár egy másik struktúra.
Amikor használja Struktúrák C,
te új típusú
közül gyűjteménye más típusú.
Itt vagyunk, hogy egy új típusú
ki egy egész és egy char *.
Mint később látni fogjuk, a struct típus
van egy csomó szempontból egyenértékű bármely más típusú, amit használt.
Általában fogok összehasonlítva hogyan struct típus
olyan, mint az egész típusú.
Míg a kódot, írta érvényes C,
ez nem túl hasznos,
és csenget ad nekünk egy figyelmeztetés.
Emlékszel, hogy Struktúrák és hasonló?
Nos, alapvetően csak azt mondta,
int,
ami nem nagyon hasznos vonal.
Szóval valójában, hogy egy változót az ilyen típusú
azáltal, hogy a nevet a pontosvessző előtt.
Hívjuk a változó diák.
Most már bejelentett egy változó nevezett tanuló
a típus által adott struct.
Hogyan jutunk el a változókat belsejében struct?
Technikailag a neveket ezen változók
tagja.
Eléréséhez egy adott tag diák struct,
Ön mellékel egy pont a változó nevét,
neve követ a tag akarsz.
Tehát itt, az csak 2 érvényes lehetőségek
vannak student.age
és student.name.
És mi is valami ehhez hasonlót
student.age = 12
és student.name = diák.
Most mi van, ha azt akartuk, hogy egy második diák?
Azt hihetnénk, hogy másolja és illessze be ezeket a sorokat
és módosítsa diák diák 2 vagy valami,
és hogy működni fog,
de technikailag, diák és diák 2
nem rendelkeznek az ugyanolyan típusú.
Látod, nem lesz képes, hogy azokat egymással.
Ennek az az oka, eddig,
A struct volt névtelen.
Meg kell adni egy nevet.
Ehhez, hogy mi be a nevét a struct
szó után struct.
diák,
majd a definíció.
Még mindig azonnal nyilvánítja egy változó típusú
struct diák, mint mi korábban.
Fogjuk hívni S1
Azáltal, hogy a struct egy nevet,
most már használni struct diák
szinte pontosan ugyanúgy szeretnénk használni int.
Így tudjuk, hogy egy változót típusú struct diák,
mint
struct diák S2.
Mint tömbök Struktúrák nyújtanak egy parancsikont inicializáló szintaxis,
így azt mondhatjuk, struct diák S2
egyenlő
bal oldali kapcsos zárójel 3, S2.
Itt, S2.age 3 lesz,
és S2.name fog mutatni S2.
Gondolj az összes dolog, amit tehetünk egy int típusú
és a legtöbb, amit tehetünk egy struct tanuló típus.
Mi lehet használni struct diák egyfajta függvény paraméter.
Tudjuk használni struktúra hallgató belsejében egy új struktúra.
Mi lehet egy mutató egy struct diák.
Meg tudjuk csinálni méret struct diák.
Struct diák olyan típusú
mint egy int típusú.
Azt is rendelhet S1 S2
mivel mindkettő azonos típusú, így nem tehetünk
S1 = S2.
Mi történik, ha nem
S1.age = 10?
Vajon S2 változás egyáltalán?
Ismét gondoljunk a struktúrákat csak rendszeres egészek.
Ha rendelni néhány int X egyes int Y,
mint X = Y
majd módosítsa X,
mint az X + +,
nem igen változik egyáltalán?
Y nem változik itt, és így ugyanakkor nem S2 fent.
S2.age még 3.
De megjegyezzük, hogy mikor rendel 1 struct a másikba,
az összes mutató még mindig mutatnak ugyanaz a dolog,
mivel azokat csak másolt.
Ha nem szeretné, hogy a mutatókat meg kell osztani,
akkor kézzel kell kezelni, hogy a
talán malicking egy blokk memória az egyik mutató mutasson
és másolása az adatok felett.
Lehet, hogy bosszantó, hogy kell írni struct diákok mindenhol.
Egy típus def, meg tudjuk csinálni
típus def
struct
és mi hívjuk diák.
Most már tudjuk használni diákok mindenhol
, amit használtam struct diák.
Ez a típus def Ez egy névtelen struct
és hívja diák.
De ha azt is, hogy a hallgatói azonosító
mellett a szó struct, mint typedef struct diák,
tudtuk használni mind a struct diák és diák szinonimaként most.
Nem is kell, hogy ugyanaz a neve.
Tudnánk írja def struct hallgató Bob
majd a struct diák és Bob
lenne cserélhető típusok.
Függetlenül attól, hogy típus def,
szükségünk van az azonosító mellett struct
ha a meghatározása a struct
rekurzív.
Például,
típusú def struct csomópont
és azt kell meghatározni, mint egy int val
és ez lesz egy mutató, amely rámutat egy másik struct csomópont.,
mint a struct node * következő.
És aztán hívni csomópont.
A struktúra rekurzív,
mivel a meghatározása struct csomópont tartalmaz belül
a mutató egy struct csomópont.
Figyeljük meg, hogy azt kell mondanunk struct node * next
belül meghatározása a struct csomópont,
mivel a típus def még nem fejeződött be, hogy lehetővé teszik számunkra, hogy egyszerűsítse a
hogy csak node * következő.
Majd többet szeretne megtudni Struktúrák ehhez hasonló
kezelése során kapcsolt listák és a fák.
Mi a helyzet a struktúrákat a funkciót?
Ez is teljesen érvényes.
Tudtuk, hogy
semmisnek func
amely úgy, mint egy érvet,
diák s
és csinál valamit azzal a diák.
És akkor tudjuk átadni, mint diák struct mint így.
Func S1 előtti.
A struct viselkedik
pontosan úgy, ahogy egy egész szám lenne, ha átadja a funkciót.
Func másolatot kap S1
, és így nem lehet módosítani S1;
inkább csak a másolatát, ami tárolt S.
Ha azt szeretné, hogy a funkció, hogy képes módosítani S1,
func kell venni a tanuló * S,
és akkor kell átadni S1 a cím, mint így.
Diák * S & func S1.
Van egy másik ok, hogy adja át a címet.
Mi van, ha a struct található 100 mezőket?
Minden egyes alkalommal, amikor át egy tanulót, hogy func,
a program kell másolni az összes a 100 mezőket func érvét S,
akkor is, ha nem használja a túlnyomó többségük.
Így még ha func nem tervezi módosításával a diák,
ha még lehet értékes, hogy adja át a címet.
Oké, mi van, ha azt akarjuk, hogy hozzon létre egy mutatót a struktúra?
Mi is valami ehhez hasonlót
tanuló * S
egyenlő malloc
mérete diák.
Figyeljük meg, hogy mérete még mindig itt dolgozik.
Szóval hogyan lehet most elérni a kor member
A mondat, hogy az S pontot?
Lehet, hogy először gondol a teendő
* S.age = 4,
de ez nem igazán működik.
Mivel ez valóban értelmezhető úgy, mint
* S.age zárójelben = 4,
ami nem is fordítani,
S mivel nem egy struktúra, vagy inkább egy pointert a struct,
és így a pont nem működik itt.
Megtehetjük
(* S). Életkor = 4
de a zárójelek kaphat bosszantó és zavaró.
Szerencsére, van egy különleges operátort
úgy néz ki, valami ilyesmi
S-> életkor = 4.
Ezek a 2 módjait hivatkozás kor
egyenértékűek
és nem igazán valaha is szüksége lehet a nyíl üzemeltető,
de ez teszi a dolgok szebb.
Mivel az S mutató néhány mondatban memóriával rendelkezik, amely tartalmazza a struct,
lehet gondolni S> korban követi a mutató nyilat
és megragad az életkor tagja.
Akkor miért kellene valaha is használni struktúrákat?
Minden bizonnyal lehetséges, hogy megússza csak a primitív egészek,
karakter, mutatók és hasonlók
hogy mi használt;
helyett S1 és S2 előtt,
tudtuk volna Age1, age2, NAME1 és NAME2
mindezt külön változót.
Ez rendben van, csak 2 diák,
de mi van, ha volt 10 közülük?
És mi van, ha ahelyett, hogy csak 2 területen,
a hallgató struct volt 100 mezőket?
GPA, tanfolyamok, haja színe, neme, és így tovább.
Ahelyett, hogy csak 10 Struktúrák, szükségünk van 1000 különböző változók.
Is, úgy a függvény
hogy úgy, hogy a 100 struct mezőket az egyetlen érve
és kiírja az összes mezőt.
Ha nem használja a struct,
minden egyes alkalommal hívjuk ezt a funkciót,
meg kell tennie minden 100 változót,
és ha már 100 változók hallgatói 1,
és 100 változók hallgatói 2,
meg kell bizonyosodni arról, hogy nem véletlenül át bizonyos változók a hallgatói 1
és bizonyos változók hallgatói 2.
Lehetetlen, hogy győződjön meg, hogy a hibát egy struct,
mivel mind a 100 változót tartalmaz egy csomagban.
Csak egy pár végső megjegyzések:
Ha már mindent megértett a pontig, remek.
A többi videó csak a teljesség kedvéért.
Mivel a struktúrákat képes tárolni bármilyen típusú mutató,
ők is tartani funkciót mutatók.
Ha ismeri az objektum-orientált programozás,
ez egy módja, hogy használja struktúrákat a program egy objektum orientált stílusban.
További információk függvénymutatók máskor.
Is, néha akkor van 2 Struktúrák
amelynek meghatározások függnek egymástól.
Például,
mi lehetett volna struct A,
amely a meghatározás szerint
a mutató egy struct B,
struct B * X,
és most már van egy struct B
amely a meghatározás szerint egy mutató
egy struct A,
struct A * Y.
De ez nem fog fordítani,
mivel struct B nem létezik az idő, hogy struct A jelenleg összeállítani.
És ha cserélni struct A. és struct B,
akkor épp kell hagyni, ugyanazzal a problémával;
Ebben az időben, a struct A nem létező.
Megoldani ezt tudjuk írni
struct B;
előtt a meghatározása struct A.
Ezt nevezzük előre nyilatkozatot.
Ez csak hagyja, hogy a fordító tudja, hogy
struct B egy érvényes típust, amely teljes mértékben határozza meg később, vagy máshol.
A nevem Rob Bowden, és ez CS50.
[CS50.TV]