[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]