[Powered by Google Translate] Dezagun structs buruz hitz egiteko.
Structs digu aldagai sorta bat elkarrekin multzokatzea egiteko modu bat
nice pakete batean.
Izango da seguru asko errazena adibide bat ikusteko berehala,
beraz, egiturari esaten dugu,
gero, kizkur giltza irekitzean
eta egiturari honetan, int adin bat izan dugu,
char * izen-abizenak,
eta hori izan da.
Badirudi bitxi daiteke puntu eta komaz kizkur giltza bat ondoren,
baina Izan structs beharrezkoa da.
Baliozko edozein motako struct definizio barruan.
Hemen, int bat erabili dugu eta char *
baina ere izan array bat erabili, esan, 100 elementu
edo egiturari beste ere.
Noiz structs C erabiltzen ari zarela,
mota berriak sortzen ari zaren
mota, beste bilduma bat da.
Bertan, mota berri bat egiten ari gara
zenbaki oso bat eta char * daudelarik.
Geroago ikusiko dugun bezala, eta egitura mota bat
erabiltzen zauden beste edozein mota baliokideak modu asko dago.
Normalean, alderatuz dut nola eta egitura mota bat
zenbaki oso mota bat antzekoa da.
Dugun kodea idatzi baliozko C bitartean,
ez da oso erabilgarria,
eta clang abisu bat emango digu.
Gogoratu nola structs eta bere antzekoak dira?
Tira, funtsean, esan
int,
hau da, ez da oso lagungarria lerro bat.
Beraz, dezagun benetan mota horretako aldagai bat deklaratzeko
puntu eta koma aurretik izena ematea.
Aldakorreko ikaslea deituko diogu.
Orain deklaratu dugu aldakorreko izenekoa ikaslea
egiturari, emandako mota.
Nola iritsi struct barruan aldagai dugu?
Teknikoki, aldagai horien izenak
kide dira.
Ikaslearen struct batean kide jakin sartzeko,
puntu bat eransteko aldagai izen
kide nahi duzun izena.
Beraz, hemen, 2 bakarrik baliozko aukera
dira student.age
eta student.name.
Eta zerbait atsegin dugu
student.age = 12
eta student.name = ikaslea.
Orain zer bigarren ikasle bat egin nahi badugu?
Uste lerro hauek kopiatu eta itsatsi dezakezu
aldatu eta ikasleak ikasleari 2 edo zerbait,
eta hori izango da lan egiteko,
baina, teknikoki, ikasle eta ikasle 2
ez dute mota berekoak.
Ikusi, ezin izango duzu bat esleitzeko.
Delako, eta, beraz, orain arte,
struct izan anonimoa da.
Izen bat eman behar dugu.
Horretarako, struct-izena sartu dugu
hitz eta egitura ondoren.
ikaslea,
definizioa.
Oraindik ere berehala mota aldagai bat deklaratzeko
egiturari ikaslea, genuen aurretik bezala.
Deitu S1 dugu
Struct izen bat ematea,
Gaur egun, erabili ahal izango dugu, eta egitura ikaslea
ia modu berean zehatza erabili int genuke.
Beraz, aldagai mota eta egitura ikaslea deklaratu ahal izango dugu,
bezala
struct S2 ikaslea.
Array bezala, structs shortcut Hasieratzea sintaxia,
beraz, esan dezakegu, egiturari ikaslea S2
berdinen
Ezkerraldean kizkur giltza 3, S2.
Hemen, S2.age 3 izango da,
eta S2.name S2 seinalatu.
Int mota bat egin dezakezu gauza guztien Think
eta horietako gehienak struct ikasle mota bat egin dezakezu.
Struct ikaslea funtzioak parametro baten mota erabili ahal izango ditugu.
Struct ikasleak ere erabili ahal izango dugu, eta egitura berri bat barruan.
Struct ikaslea erakuslea izan ahal izango dugu.
Struct ikaslea tamaina egin ahal izango dugu.
Egiturari ikaslea mota bat da
besterik ez int atsegin mota bat da.
Era berean, esleitu S1 S2
mota bereko bi baitira, eta, beraz, egin ahal izango dugu.
S1 = S2.
Zer gertatzen da ez badugu
S1.age = 10?
Does S2 aldaketa guztietan?
Berriz ere, zenbaki osoen erregular gisa structs pentsatu.
Esleitu diogu X batzuk int bada eta int Y batzuk,
X = Y bezalako
eta, ondoren, aldatu X,
bezala X + +,
Y aldatu ez guztietan?
Y ez aldatzeko hemen, eta beraz, ez du S2 goian.
S2.age da, oraindik ere 3.
Baina ohar struct bat esleitzea beste,
erakusleak, oraindik gauza bera,
ziren kopiatu besterik ez geroztik.
Partekatzeko erakusleak nahi ez baduzu,
eskuz kudeatu behar duzula,
beharbada, memoria-bloke bat malicking erakusleak, bat seinalatzen
eta datuak kopiatzea baino gehiago.
Struct ikasleek idazteko nonahi gogaikarriak izan daiteke.
Mota def bat erabiliz, egin ahal izango dugu.
mota def
struct
deitu eta ikasleak gara.
Orain, ikasleak nonahi erabili ahal izango dugu
erabiltzen dugun egiturari ikasleek erabili ahal izateko.
Mota def hau struct anonimo bat
deitzen da eta ikasleak.
Baina, era berean jarraituko dugu ikaslearen identifikatzailea
hurrengo hitza struct, struct typedef ikaslea bezala,
bai egiturari ikasle eta ikasle interchangeably erabili izan dugu gaur egun.
Are gehiago, ez dute izen berdina dute.
Def struct ikaslea idatzi izan dugu Bob
eta, ondoren, egiturari ikasle eta Bob
truka mota izango litzateke.
Mota def edozein izanda ere,
identifikatzailea, berriz, hurrengo egitura behar dugu
struct-definizioa bada
errekurtsibitatean.
Esate baterako,
mota def struct nodoa
eta int val gisa definitu egingo da
eta egitura nodo beste puntu erakuslea izango da.
struct nodo * hurrengo gisa.
Eta gero, deitu nodo dugu.
Struct hau errekurtsiboa da,
struct nodoaren definizioa barruan dauka geroztik
egitura nodo bat erakuslea.
Iragarki struct nodo * esan nahi dugun
struct nodo definizio barruan,
mota def oraindik ez baita amaitu baimendu hori errazteko
hurrengo besterik ez nodo *.
Structs honen antzeko buruz gehiago ikasteko aukera izango duzu
zerrendak eta zuhaitzak lotuta aurre.
Funtzio bat structs buruz?
Hau ere primeran baliozko.
Izan dugu
gal Bil
argumentu bat hartzen du,
ikaslea s
eta ikasleari zerbait du.
Eta, ondoren, gainditu ahal izango dugu ikaslearen egitura gisa honela.
S1 Bil aurretik.
Struct The jokatzen
bezala, zenbaki oso bat funtzio bat pasa da.
Bil S1 kopia bat jaso
eta, beraz, ezin aldatu S1;
baizik eta, kopia bakarrik gordetzen den S.
Nahi baduzu funtzioa S1 aldatu ahal izango da,
Bil ikaslearen * S hartu behar da,
eta S1 pasatzeko helbidea, eta, beraz, atsegin duzu.
Ikasleen * S, Bil eta S1.
Helbidea pasatu hemen beste arrazoi bat da.
Zer gertatuko da gure egiturari 100 eremuak?
Bakoitza denbora ikasle bat pasatzen dugu Bil,
100 eremu horiek guztiak kopiatu Bil argumentua S behar da gure programa,
nahiz eta horietako gehienak erabiltzen ez.
Beraz, nahiz eta Bil ikaslea aldatzeko asmoa ez da,
oraindik bada baliotsua helbidea pasatu.
Ongi da, zer erakuslea egitura bat sortu nahi badugu?
Zerbait egin izan dugu atsegin
ikaslea * S
berdinen malloc
ikaslea tamaina.
Iragarki tamaina hori, oraindik ere lan egiten du hemen.
Beraz, nola ez sartzeko dugun adina kide
blokea S puntu hori?
Lehen uste egin dezakezu
* S.age = 4,
baina hori ez da nahiko lan.
Hau benetan geroztik gisa interpretatu
* S.age parentesi = 4,
horrek ez du, nahiz eta konpilatu,
S ez baita, eta egitura bat edo, hobeto esanda, erakuslea egitura
eta, beraz, ez du funtzionatuko dot hemen.
Egin izan dugu
(* S). Adina = 4
baina parentesi gogaikarriak eta nahasgarria lor daiteke.
Zorionez, gezi berezi bat operadorea dugu
duen itxura zerbait
S-> adina = 4.
2 adina erreferentziatutako modu hauek
baliokideak dira
eta, ez dugu benetan inoiz behar gezi-operadorea,
baina gauzak begiratzen nicer egiten du.
S batzuk eta egitura dauka memoria bloke erakuslea da geroztik,
S> adin jarraitu ahal izango duzu uste erakuslea gezi
eta grab adina kide.
Beraz, zergatik erabiltzen dugu inoiz structs?
Behin betiko posible ihes aintzinako zenbaki osoen
karakteretan, erakusleak eta antzeko
dugu erabiltzen ari dela;
S1 eta S2 baino lehen ordez,
izan dute genezake age1, age2, NAME1, eta izena2
aldagai bereizi.
Hau da, bakarrik 2 ikasle fina,
baina, zer izan badugu horietako 10?
Eta zer ordez 2 eremuak bakarrik,
ikaslea struct 100 eremuak zituen?
GPA, ikastaroak, ile-kolorea, sexua, eta abar.
10 structs ordez, 1.000 aldagai bereizi behar dugu.
Era berean, kontuan hartu funtzio bat
struct duten 100 eremu hartzen ditu bere argumentu bakarra
eta bistaratzen du arlo guztietan.
Eta egitura bat erabili genuen ez bada,
bakoitza funtzio hori deitu dugu,
100 aldagai guztiak gainditu behar dugu,
ikaslea 1 100 aldagai dugu bada,
eta 100 ikasleak 2 aldagai
Ziur ez dugu aldagai batzuk ikaslea 1 ustekabean gainditu behar dugu
eta ikaslea 2 aldagai batzuk.
Ezinezkoa da, eta egitura bat huts egiten duten,
100 aldagai guztiak dira pakete soil batean jasotako geroztik.
Ohar azken pare bat besterik ez:
Duzun guztia ulertzen bada Puntu honetan, handia.
Bideoa gainerako osotasun 'mesedetan.
-Structs erakuslea edozein eduki daitekeelako,
eduki sakatuta funtzio erakusleak ere egin ahal izango dute.
Oraindik bideratutako objektu programazio ezagutzen bada,
modu bat, programak estilo bideratutako objektu structs erabili ematen.
Gehiago funtzioa erakusleak denbora batean.
Era berean, batzuetan 2 structs izan dezakezu
horren definizioak bata bestearen araberakoak dira.
Esate baterako,
struct A izan dugu,
den definitzen
egitura B erakuslea,
struct B * X,
eta, gaur egun, eta egitura bat izan dezakegu B
erakuslea gisa definitzen
egitura A,
struct A * Y.
Baina hau ez da konpilatu
struct B struct A konpilatuta denbora ez baita existitzen.
Eta swap struct A eta struct bada B,
egin nahiko genuke besterik ez da, arazo berdinarekin utzi;
Une honetan, egiturari ez lehendik dauden A.
Hori konpontzeko, idatzi ahal izango dugu
struct B;
struct A. definizioa aurretik
Deritzo forward adierazpen bat.
Hau besterik ez konpilatzailea ezagutzeko aukera ematen dizu hori
struct B baliozko mota guztiz definitu egingo da geroago edo beste nonbait.
Nire izena Rob Bowden da, eta hau da CS50.
[CS50.TV]