[Powered by Google Translate] Gadewch i ni siarad am structs.
Structs ein darparu gyda ffordd i grwpio'r criw o newidynnau at ei gilydd
i mewn i becyn 'n glws.
Mae'n debyg hawsaf i weld enghraifft ar unwaith,
felly rydym yn dweud strwythur,
yna agor cyrliog Brace,
ac yn y strwythur, bydd gennym oed int,
enw * torgoch,
a dyna ni.
Gall ymddangos yn od gyda hanner colon ar ôl Brace cyrliog,
ond mae'n mewn gwirionedd angenrheidiol gyda structs.
Gall unrhyw fath dilys fynd o fewn y diffiniad strwythur.
Yma, rydym wedi defnyddio yn int a * torgoch,
ond gallech hefyd ddefnyddio amrywiaeth, o ddweud, 100 elfen
neu hyd yn oed arall strwythur.
Pan fyddwch chi'n defnyddio structs yn C,
eich bod yn creu mathau newydd
allan o gasgliad o fathau eraill.
Yma, rydym yn gwneud math newydd
allan o gyfanrif a * torgoch.
Fel byddwn yn gweld yn nes ymlaen, math strwythur
mewn llawer o ffyrdd sy'n cyfateb i unrhyw fath arall rydych yn ei ddefnyddio i.
Fel arfer, byddaf yn cymharu sut fath strwythur
yn debyg i fath cyfanrif.
Er bod y cod ni ysgrifennu yn C dilys,
nid yw'n ddefnyddiol iawn,
a bydd yn rhoi clang rhybudd inni.
Cofiwch sut structs a'i yn debyg?
Wel, yn y bôn rydym newydd ei ddweud
int,
nad yw llinell yn ddefnyddiol iawn.
Felly, gadewch i ni mewn gwirionedd yn datgan amrywiol o'r math
trwy roi enw iddo cyn y colon.
Byddwn yn galw'r myfyriwr amrywiol.
Nawr rydym wedi datgan yn fyfyriwr elwir yn amrywiol
â'r math a roddwyd gan y strwythur.
Sut ydym yn cyrraedd y newidynnau y tu mewn i'r strwythur?
Yn dechnegol, yr enwau ar gyfer y newidynnau
yn aelodau.
I gael mynediad i unrhyw aelod penodol mewn strwythur i fyfyrwyr,
chi atodi dot i'r enw amrywiol,
ddilyn gan enw'r aelod ydych ei eisiau.
Felly yma, y ​​2 yn unig posibiliadau dilys
yn student.age
a student.name.
A gallwn wneud rhywbeth fel
student.age = 12
ac student.name = myfyrwyr.
Nawr beth os ydym am wneud ail fyfyriwr?
Efallai y byddwch yn meddwl i gopïo a gludo y llinellau hyn
a newid fyfyriwr i fyfyriwr 2 neu rywbeth,
a fydd yn gweithio,
ond yn dechnegol, myfyrwyr a myfyrwyr 2
nad oes ganddynt yr un fath.
Gweler, ni fyddwch yn gallu neilltuo i un arall.
Mae hyn oherwydd, hyd yn hyn,
eich strwythur wedi bod yn ddienw.
Mae angen i ni roi enw iddo.
I wneud hynny, rydym yn mewnosoder enw'r y strwythur
ar ôl y strwythur gair.
myfyriwr,
dilyn gan y diffiniad.
Gall Rydym yn dal yn syth datgan amrywiol o fath
strwythur i fyfyrwyr, fel y gwnaethom o'r blaen.
Byddwn yn ei alw'n S1
Drwy roi y strwythur enw,
gallwn yn awr ddefnyddio myfyrwyr strwythur
mewn bron yr un ffordd union y byddem yn defnyddio int.
Felly gallwn ddatgan amrywiol o fyfyrwyr strwythur fath,
fel
strwythur i fyfyrwyr S2.
Fel arrays, structs yn darparu llwybr byr cystrawen initialization,
fel y gallwn ddweud, strwythur myfyrwyr S2
yn hafal i
chwith cyrliog brês 3, S2.
Yma, bydd S2.age fod yn 3,
a bydd S2.name yn cyfeirio at S2.
Meddyliwch am yr holl bethau y gallwch eu gwneud gyda math int
ac mae'r rhan fwyaf ohonynt y gallwch ei wneud gyda myfyriwr strwythur fath.
Gallwn ddefnyddio myfyriwr strwythur fel math o paramedr swyddogaeth.
Gallwn ddefnyddio myfyrwyr strwythur tu mewn i strwythur newydd.
Gallwn gael pwyntydd i fyfyriwr strwythur.
Gallwn wneud maint y myfyrwyr strwythur.
Strwythur myfyriwr yn fyfyriwr math
yn union fel int yn fath.
Gallwn hefyd neilltuo S1 S2 i
gan fod y ddau o'r un math, fel y gallwn wneud
S1 S2 =.
Beth fydd yn digwydd os ydym yn ei wneud
S1.age = 10?
Yn newid S2 o gwbl?
Unwaith eto, meddyliwch am y structs yn union fel y gyfanrifau rheolaidd.
Os byddwn yn neilltuo rhywfaint o X int i rai Y int,
fel X = Y
ac yna newid X,
fel yn X + +,
Y mae newid o gwbl?
Nid yw Y yn newid yma, ac felly nid yw'n S2 uchod.
S2.age yn dal i fod 3.
Ond noder, pan penodi un strwythur i un arall,
pob un o'r pwyntiau yn dal yn pwyntio at yr un peth,
ers iddynt gael eu copïo yn unig.
Os nad ydych am i'r awgrymiadau i gael ei rannu,
bydd angen i chi manually ymdrin â hynny,
efallai drwy malicking un bloc o cof am un o'r awgrymiadau i dynnu sylw at
ac yn copïo'r data dros.
Gallai fod yn annifyr gorfod ysgrifennu myfyrwyr strwythur ym mhob man.
Gan ddefnyddio def fath, gallwn wneud
math def
strwythur
a byddwn yn ei alw'n myfyrwyr.
Yn awr, gallwn ddefnyddio myfyrwyr ym mhob man
a ddefnyddiwyd gennym i ddefnyddio myfyrwyr strwythur.
Mae hyn yn def math 'na strwythur dienw
ac yn ei alw myfyrwyr.
Ond os ydym hefyd yn cadw y dynodwr myfyrwyr
nesaf at y strwythur gair, fel yn fyfyrwyr strwythur typedef,
gallem ddefnyddio strwythur i fyfyrwyr yn gyfnewidiol a myfyrwyr yn awr.
Nid ydynt yn hyd yn oed yn rhaid i chi gael yr un enw.
Gallem deipio myfyrwyr strwythur def i Bob
ac yna strwythur i fyfyrwyr a Bob
byddai mathau ymgyfnewidiol.
Beth bynnag am y def fath,
mae angen y dynodwr nesaf i strwythur
os yw'r diffiniad o'r strwythur
yn ailadroddus.
Er enghraifft,
math def strwythur nod
a bydd yn cael ei ddiffinio fel Val int
a bydd yn cael pwyntydd sy'n cyfeirio at un arall nod strwythur.,
fel yn strwythur nod * nesaf.
Ac yna byddwn yn ei alw'n nod.
Mae'r strwythur yn ailadroddus,
ers y diffiniad o nod strwythur yn cynnwys o'i fewn
pwyntydd i nod strwythur.
Sylwch fod rhaid i ni ddweud strwythur nod * nesaf
tu mewn i'r diffiniad o'r nod strwythur,
gan nad yw'r def fath wedi gorffen eto i ganiatáu i ni symleiddio hyn
i ychydig * nod nesaf.
Byddwch yn dysgu mwy am structs tebyg i hyn
wrth ddelio â rhestrau cysylltiedig a choed.
Beth am structs mewn swyddogaeth?
Mae hyn hefyd yn berffaith ddilys.
Gallem gael
gwag func
sy'n cymryd fel dadl,
myfyriwr
ac yn gwneud rhywbeth gyda'r myfyriwr hwnnw.
Ac yna gallwn drosglwyddo fel strwythur i fyfyrwyr fel hyn.
Func o S1 o'r blaen.
Mae'r strwythur yn ymddwyn
yn union fel y byddai cyfanrif pan gaiff ei basio i swyddogaeth.
Func yn derbyn copi o S1
ac felly ni all addasu S1;
yn hytrach, dim ond y copi ohono sy'n cael ei storio yn S.
Os ydych am y swyddogaeth i fod yn gallu addasu S1,
Bydd func angen i chi gymryd * fyfyrwyr S,
a bydd yn rhaid i chi basio S1 ôl cyfeiriad, fel hynny.
Myfyriwr * S, func & S1.
Mae rheswm arall i basio drwy cyfeiriad yma.
Beth os yw ein strwythur yn cynnwys 100 caeau?
Bob tro y byddwn yn trosglwyddo'r un myfyriwr i func,
ein rhaglen mae angen gwneud copi o'r cyfan o'r y 100 caeau i S ddadl func, yn
erioed hyd yn oed os yw'n defnyddio y mwyafrif llethol ohonynt.
Felly hyd yn oed os nad yw func yn cynllunio ar addasu y myfyriwr,
os gall ddal i fod yn werthfawr i basio gan gyfeiriad.
Iawn, beth os ydym am greu pwyntydd i strwythur?
Gallem wneud rhywbeth fel
myfyrwyr * S
yn hafal i malloc
faint o fyfyrwyr.
Hysbysiad bod maint yn dal yn gweithio yma.
Felly sut ydym yn awr yn cael mynediad i'r aelod oed
y bloc bod pwyntiau S i?
Efallai i chi yn gyntaf yn meddwl i wneud
* S.age = 4,
ond ni fydd hyn yn eithaf yn gweithio.
Gan y bydd hyn yn wir yn cael ei ddehongli fel
* S.age mewn cromfachau = 4,
Ni fydd yn hyd yn oed lunio,
gan nad S yn strwythur neu yn hytrach pwyntydd i strwythur,
ac felly ni fydd y dot yn gweithio yma.
Gallem wneud
(* S). Oed = 4
ond gall y cromfachau yn cael blino ac yn ddryslyd.
Diolch byth, mae gennym gweithredwr saeth arbennig
sy'n edrych rhywbeth fel
S-> oedran = 4.
Mae'r rhain yn 2 ffyrdd o gyfeirnodi oed
yn cyfateb
ac nid ydym yn wir erioed angen y gweithredwr saeth,
ond mae'n gwneud i bethau edrych yn brafiach.
Gan S rhoi syniad i rai bloc o gof sy'n cynnwys y strwythur,
y gallwch chi feddwl am oedran S> fel a ganlyn y saeth pwyntydd
ac yn mynnu y aelod oed.
Felly, pam fyddwn byth yn defnyddio structs?
Mae'n bendant yn bosibl i fynd i ffwrdd gyda dim ond y cyfanrifau cyntefig,
chars, awgrymiadau ac ati
ein bod yn eu defnyddio i;
yn hytrach na S1 ac S2 o'r blaen,
gallem fod wedi age1, age2, name1, a name2
i gyd ar newidynnau ar wahân.
Mae hyn yn iawn gyda dim ond 2 fyfyrwyr,
ond beth os oedd gennym 10 ohonynt?
A beth os yn hytrach na dim ond 2 gae,
y strwythur i fyfyrwyr o 100 caeau?
GPA, cyrsiau, lliw gwallt, rhyw, ac yn y blaen.
Yn hytrach na dim ond 10 structs, mae angen 1000 newidynnau ar wahân.
Hefyd, ystyriwch swyddogaeth
bod yn cymryd y strwythur gyda 100 o gaeau ei ddadl yn unig
ac yn argraffu pob maes.
Pe na baem yn defnyddio strwythur,
bob tro rydym yn galw swyddogaeth honno,
angen i ni roi ar y 100 newidyn,
ac os mae gennym 100 newidynnau ar gyfer myfyrwyr 1,
a 100 newidynnau i fyfyrwyr 2,
mae angen i ni fod yn siŵr nad ydym yn ddamweiniol drosglwyddo rhai newidynnau o fyfyriwr 1
ac mae rhai newidynnau o fyfyriwr 2.
Mae'n amhosibl i wneud y camgymeriad gyda strwythur,
ers y 100 newidynnau yn cael eu cynnwys mewn un pecyn.
Dim ond ychydig o nodiadau terfynol:
Os ydych chi wedi deall popeth i fyny at y pwynt hwn, gwych.
Mae gweddill y fideo yn unig ar gyfer mwyn cyflawnrwydd '.
Oherwydd y gall structs gynnal unrhyw fath o pwyntydd,
gallant hefyd yn cynnal awgrymiadau swyddogaeth.
Os ydych yn gyfarwydd gyda rhaglenni gwrthrych oriented,
hyn yn cynnig ffordd i ddefnyddio structs i'r rhaglen mewn arddull oriented gwrthrych.
Mwy o wybodaeth am awgrymiadau swyddogaeth ar adeg arall.
Hefyd, weithiau efallai y byddwch yn cael 2 structs
y mae eu diffiniadau yn dibynnu ar ei gilydd.
Er enghraifft,
gallem gael strwythur A,
sy'n cael ei ddiffinio fel
pwyntydd i B strwythur,
strwythur B * X,
ac yn awr gallwn gael B strwythur
sy'n cael ei ddiffinio fel pwyntydd
i strwythur A,
strwythur A * Y.
Ond ni fydd hyn yn llunio,
gan nad strwythur B yn bodoli ar yr adeg y strwythur A yn cael ei lunio.
Ac os ydym yn cyfnewid strwythur A a B strwythur,
yna byddem yn unig yn cael eu gadael gyda'r un broblem;
y tro hwn, gyda strwythur Nid yw presennol.
Er mwyn datrys hyn, gallwn ysgrifennu
strwythur B;
cyn y diffiniad o strwythur A.
Gelwir hyn yn ddatganiad ymlaen.
Mae hyn yn unig yn gadael y casglwr yn gwybod bod
strwythur B yn fath dilys a fydd yn cael eu diffinio yn llawn yn ddiweddarach neu yn rhywle arall.
Fy enw i yw Rob Bowden, ac mae hyn yn CS50.
[CS50.TV]