>> [REPRODUCCIÓ DE MÚSICA]
>> DOUG LLOYD: OK.
Hem treballat amb nombres enters, hem treballat amb personatges,
hem treballat carrosses, dobles, cadenes i bools.
Hem esgotat gairebé tot dels [inaudible] tipus que
han estat a disposició de nosaltres tot el temps.
Però ara volem fer alguna cosa més.
Com ho fem?
Com creem diferents tipus de dades?
Podem fer-ho utilitzant estructures.
Així estructures ens permeten unificar variables de diferents tipus
en una sola, nou tipus de variable, que podem assignar el seu propi nom de tipus.
Aquest és un molt fort cosa és ser capaç de fer,
perquè ara podem grup elements de diferents tipus de dades
junts de tenir una connexió lògica.
Hem estat capaços de fer això amb arranjaments de tipus, no?
Podem agrupar variables del mateix tipus de dades
junts en una unitat gran de la memòria, una matriu.
>> Però no hem estat capaços de barrejar fins a diferents tipus de dades junts.
No podem, per exemple, associar un nombre enter, i un caràcter, i un doble de tot
en el mateix i trucar a que una sola unitat.
Però amb estructures, o a què es refereix amb freqüència com estructures,
que realment pot.
Així que una estructura és una espècie així com una variable de super.
És una variable que conté altres variables dins d'ella.
Així que aquí està un exemple de una estructura molt simple.
Això és el que la sintaxi seria vol crear una estructura per a un cotxe.
Ara, anem a anar a través de la sintaxi aquí.
Struct, aquesta és la paraula clau que indica
que estic creant un nou tipus de dades aquí.
En particular, el nom del tipus de dades és serà un cotxe estructura, com veurem.
Però aquest és el tipus de punta off al compilador que aquesta
com un grup de variables que es va per ser considerat part del mateix tipus
en un minut.
>> Cotxes, només el nom de l'estructura.
Un cop més, el tipus de dades que aquí es va ser acte estructura, no només cotxe.
Però si vostè té diferent-- si crea múltiples estructures
en el mateix programa, cal distingir entre struct i struct.
Així cotxe struct, jo també podria tenir struct estudiant, per exemple,
en el mateix programa.
Dins de les claus són tots els camps anomenats,
o els membres de l'estructura.
Així que quins són algunes de les coses que són inherents en un cotxe?
Bé, en general té un any, ha un nom de model, i una placa de matrícula,
1 odòmetre que en general té cert nombre de milles en ell,
i potser una mida de motor.
I com es pot veure, estic barrejant sencers i caràcters i dobles.
Estan tots van a ser part d'aquest nou tipus de dades.
>> Finalment, l'última cosa que heu de fer, no s'oblidi d'aquest petit punt i coma
al final.
Després que acabem de definir l'estructura, hem de posar un punt i coma al final.
És una sintàctica molt comú error, perquè amb una funció,
per exemple, només tindria clau d'obrir, tancar claudàtor.
No posa un punt i coma al final d'una definició de funció.
Això s'assembla a una funció definició, però no ho és,
i així el punt i coma allà és només un recordatori que vostè
hagi de posar-ho allà, perquè el compilador no ho farà d'una altra manera
saber què fer amb ell.
És un error molt comú fer accidentalment
quan s'està definint en primer lloc les estructures.
>> D'ACORD.
Així que en general definim les nostres estructures a la part superior dels nostres programes
perquè estan probablement va per a ser utilitzat per múltiples funcions.
No volem definir un struct interior d'una funció,
perquè llavors podem only-- la àmbit d'aplicació de l'estructura realment
només existeix dins d'aquesta funció.
Probablement ens agradaria definir una estructura perquè puguem utilitzar-lo en múltiples funcions,
o potser en múltiples els arxius que estan vinculats entre si
per crear el nostre programa únic.
A vegades també lloc de definir l'estructura
a la part superior, on vostè posa el seu lliura inclou i la seva lliura defineix,
per exemple, és possible que els va posar en arxius punt h separades, que després
lliura inclou a tu mateix.
>> Així que tenim estructures, però ara hem d'aconseguir dins d'ells.
Com aconseguim l'interior de una estructura per a l'accés
els sub-variables, les variables que hi ha dins de l'estructura?
Bé, tenim alguna cosa que es diu l'operador punt, el que ens permet
per accedir als camps de l'estructura.
Així, per exemple, diguem que he declarat meves dades de l'estructura de tipus algun lloc
a la part superior del meu programa, o potser en un arxiu de punts h que tinc lliures inclòs.
Doncs si jo vull crear un nou variable d'aquest tipus de dades, puc dir,
struct cotxe, el meu cotxe, punt i coma.
Igual que jo pogués dir int x, o el nom de cadena de punt i coma.
>> El tipus de dades que aquí és struct cotxe, el nom de la variable és el meu cotxe,
i després puc utilitzar l'operador punt per accedir als diversos camps del meu cotxe.
Així que puc dir que el meu cotxe dot any és igual a 2.011.
Això és perfectament bé.
Any, si vostè recorda, es va definir com un camp sencer a l'interior d'aquesta estructura de cotxe
tipus de dades.
Així que qualsevol variable de les dades struct cotxe tipus, com el meu cotxe, puc dir que el meu cotxe
any de punts iguals i després assignar que algun valor sencer de 2011.
El meu plat punt del cotxe és igual CS50.
El meu punt targeta odòmetre és igual a 50.505 punt i coma.
Tots aquests són perfectament bé i això és
com accedim a la camps de l'estructura.
Estructures, però, no cal que es crearà a la pila.
Igual que qualsevol altra variable, que pot assignar dinàmicament ells.
Si tenim un programa que podria estar generant moltes estructures,
no sabem quants necessitarem,
llavors hem de dinàmicament assignar aquestes estructures
com el nostre programa s'està executant.
I pel que si tindrem accés a la camps d'una estructura en aquest context,
recordem que primer hem d'eliminar la referència el punter a l'estructura,
i després una vegada que eliminar la referència al punter, llavors pot accedir als camps.
Si tan sols tenim una Punter a l'estructura,
no podem dir que el camp de punt punter Nom i vam aconseguir el que estem buscant.
Aquí hi ha el pas addicional d'eliminació de referències.
Així que diguem que en lloc de la previous--
igual que l'exemple anterior, en lloc de declarar que
a la pila, cotxe struct, el meu cotxe, punt i coma, dic struct cotxe,
estrella, un punter a una struct cotxe va cridar al meu cotxe,
és la mateixa mida malloc de struct cotxe.
Mida de anem a esbrinar quants bytes del seu nou tipus de dades ocupa.
No necessàriament només es necessita utilitzar mida, ample, int o char, o qualsevol
dels tipus de dades incorporats.
El compilador és prou intel·ligent per esbrinar quants bytes
són requerits per la seva nova estructura.
Així que malloc mi una unitat de memòria prou gran com per contenir un cotxe struct,
i em dóna un punter cap enrere a aquest bloc de memòria,
i que el punter s'assigna al meu cotxe.
>> Ara, si vull accedir els camps del meu cotxe,
La primera vegada que eliminar la referència del meu cotxe usant l'operador eliminar la referència, estel
que hem vist dels punters vídeos, i després després d'eliminar la referència,
llavors puc utilitzar l'operador punt per accedir als diversos camps del meu cotxe.
Estrella meu cotxe dot any és igual a 2.011.
Això tindria l'efecte volem que en aquest cas,
perquè hem dinàmicament assignat el meu cotxe.
>> Això és una mica molest, però, ¿no?
Hi ha un procés de 2 passos ara.
Ara hem de dereference-- tenim un operador de l'estrella,
i tenim un operador punt.
I com era d'esperar, ja que C programadors estimen camins més curts
de fer les coses, hi ha un camí més curt per fer això.
Hi ha un altre operador anomenat fletxa, el que fa que aquest procés sigui molt més fàcil.
La forma de fletxa funciona és Primer es desreferencias
el punter de l'esquerra costat de l'operador,
i després, després d'haver desreferenciado el punter a l'esquerra,
s'accedeix al camp de la dreta.
I així prèviament teníem aquest tipus de l'estrella del meu cotxe esquitxen tota aquesta matèria,
com havia molt a fer allà.
Però el que en canvi sí que podem fer és esto-- el meu cotxe fletxa any és igual a 2.011.
>> Un cop més, què està passant aquí?
En primer lloc, estic dereferencing meu cotxe.
Que al seu torn, és un punter aquí.
Llavors, després d'haver desreferenciado meu cotxe,
a continuació, pot accedir als camps any, la placa, i el odòmetre
de la mateixa manera que vaig poder abans de tenir primer estrella usada per eliminar la referència del meu cotxe,
i el punt d'accés al camp.
Així que vostè pot tenir estructures, que pot tenir punters a estructures,
i vostè té maneres d'accedir els camps d'aquestes estructures,
si vostè té punters a ells o les pròpies variables.
Dot o fletxa, depenent de com es va declarar la variable.
Sóc Doug Lloyd, això és CS50.