[Powered by Google Translate] యొక్క structs గురించి మాట్లాడేందుకు లెట్.
Structs కలిసి వేరియబుల్స్ యొక్క కొంత గుంపుకు ఒక మార్గం అందించండి
ఒక nice ప్యాకేజీ లోకి.
ఇది వెంటనే ఒక ఉదాహరణ చూడండి బహుశా సులభమైన యొక్క
కాబట్టి మేము, struct సే
అప్పుడు, గిరజాల తెరిచే బ్రాకెట్
మరియు ఈ struct లో, మేము, ఒక పూర్ణాంకానికి వయసు ఉంటుంది
ఒక చార్ * పేరు,
అంతే.
ఇది ఒక వంకర కలుపు తర్వాత ఒక సెమికోలన్ తో అసహజ విధంగా
కానీ structs తో అవసరమైన వాస్తవం ఉంది.
ఏదైనా చెల్లుబాటు అయ్యే రకం struct నిర్వచనంలో వెళ్ళవచ్చు.
ఇక్కడ, మనం, ఒక Int మరియు ఒక చార్ * ఉపయోగించి
కానీ మీరు కూడా, చెబుతారు, 100 అంశాలను వ్యూహం ఉపయోగించవచ్చు
లేదా మరొక struct.
మీరు C లో structs ఉపయోగించి చేసిన తర్వాత,
మీరు కొత్త రకాల సృష్టిస్తున్నారు
ఇతర రకాల సేకరణ నుండి.
ఇక్కడ, మేము ఒక కొత్త రకం చేస్తున్న
పూర్ణాంకం మరియు ఒక చార్ * బయటకు.
మేము తరువాత చూస్తారు, ఒక struct రకం
మీకు ఏ ఇతర రకం సమానం మార్గాలు చాలా ఉంది.
సాధారణంగా, నేను ఎలా struct రకం పోల్చడం వస్తుంది
పూర్ణాంకం రకం పోలి ఉంటుంది.
మేము రాశారు కోడ్ చెల్లుబాటు అయ్యే సి ఉంటుంది, అయితే
ఇది చాలా ఉపయోగకరంగా కాదు
మరియు గణగణమని ద్వని చేయు మాకు హెచ్చరిక ఇస్తుంది.
Structs మరియు దాని పోలి ఉంటాయి ఎలా గుర్తుంచుకో?
Well, మేము ప్రధానంగా కేవలం చెప్పారు
Int,
ఇది చాలా ఉపయోగకరంగా లైన్ కాదు.
కాబట్టి యొక్క వాస్తవానికి ఆ రకమైన ఒక వేరియబుల్ డిక్లేర్ తెలియజేయండి
అది సెమికోలన్ ముందు పేరు ఇవ్వడం ద్వారా.
మేము వేరియబుల్ విద్యార్థి పిలుస్తాను.
ఇప్పుడు మేము ఒక వేరియబుల్ అని విద్యార్థి డిక్లేర్డ్ చేసిన
struct ఇచ్చిన రకం.
మేము ఎలా struct లోపల చరరాశులకు వస్తుందా?
ఈ చరరాశులు కోసం సాంకేతికంగా, పేర్లు
సభ్యులు.
ఒక విద్యార్థి struct ఏ సభ్యుడు ఆక్సెస్ చెయ్యడానికి,
మీరు, వేరియబుల్ పేరు ఒక డాట్ జోడించు
మీకు కావలసిన సభ్యుని యొక్క పేరు తరువాత.
ఇక్కడ, కేవలం 2 చెల్లుబాటు అయ్యే అవకాశాలు
student.age ఉంటాయి
మరియు student.name.
మరియు మేము ఏదో వంటి చేయవచ్చు
student.age = 12
మరియు student.name = విద్యార్థి.
ఇప్పుడు మనం రెండవ విద్యార్థి అనుకున్నారు ఉంటే?
మీరు ఈ పంక్తులు కాపీ మరియు పేస్ట్ అనుకుంటున్నాను ఉండవచ్చు
మరియు విద్యార్థి 2 లేదా ఏదో విద్యార్ధి మార్చడానికి,
మరియు ఆ పని చేస్తుంది,
కానీ సాంకేతికంగా, విద్యార్థి మరియు విద్యార్థి 2
ఒకే రకమైన లేదు.
చూడండి, మీరు మరొక వాటిని అప్పగించడం చెయ్యలేరు.
ఇది ఎందుకంటే, ఇప్పటివరకు ఉంది
మీ struct అనామక ఉంది.
మేము దీనికి ఒక పేరును ఇవ్వండి అవసరం.
ఆ చేయుటకు మేము struct యొక్క పేరును ఇన్సర్ట్
పదం struct తర్వాత.
విద్యార్థి,
నిర్వచనం తరువాత.
మేము ఇంకా వెంటనే రకం ఒక వేరియబుల్ ప్రకటించవచ్చు
మేము ముందు చేశాడు, విద్యార్థి struct.
మేము S1 పిలుస్తాను
Struct ఒక పేరు ఇవ్వడం ద్వారా,
మేము ఇప్పుడు struct విద్యార్థి ఉపయోగించవచ్చు
దాదాపు ఖచ్చితమైన విధంగా మేము Int ఉపయోగించారు.
కాబట్టి మేము, రకం struct విద్యార్థి ఒక వేరియబుల్ ప్రకటించవచ్చు
వంటి
struct విద్యార్థి S2.
శ్రేణుల వలె, structs, ఒక షార్ట్కట్ ప్రారంభ సింటాక్స్ అందించడానికి
కాబట్టి మేము విద్యార్థి S2 struct, చెప్పగలదు
సమానం
ఎడమ వంకర కలుపు 3, S2.
ఇక్కడ, S2.age, 3 ఉంటుంది
మరియు S2.name S2 కు ఆకర్షిస్తాయి.
ఒక పూర్ణాంకానికి రకం మీకు చేయవచ్చు అన్ని విషయాలను ఆలోచించండి
మరియు అవి చాలా భాగం మీరు ఒక struct విద్యార్థి రకం చేయవచ్చు.
మేము ఒక ఫంక్షన్ పారామితి ఒక రకమైన ఒక struct విద్యార్థి ఉపయోగించవచ్చు.
మేము ఒక కొత్త struct లోపలి struct విద్యార్థి ఉపయోగించవచ్చు.
మేము ఒక struct విద్యార్థి ఒక పాయింటర్ ఉండవచ్చు.
మేము struct విద్యార్థి యొక్క పరిమాణం చేయవచ్చు.
Struct విద్యార్థి రకం
కేవలం Int వంటి రకం.
మేము కూడా S2 కు S1 కేటాయించవచ్చు
ఒకే రకమైన ఎందుకంటే, అందువలన మేము చేయవచ్చు
S1 = S2.
మేము ఏమవుతుంది
S1.age = 10?
అన్ని వద్ద S2 మార్పు వస్తుందా?
మళ్లీ, సాధారణ పూర్ణాంకాల వంటి structs భావిస్తారు.
మేము కొన్ని Int Y కొన్ని Int X కేటాయించి ఉంటే,
X = Y వంటి
తరువాత, X మార్పు
లో X + +,
Y అన్ని వద్ద మార్చదు?
Y ఇక్కడ మార్చవచ్చు మరియు కనుక ఏ పైన S2 లేదు.
S2.age ఇప్పటికీ 3.
కానీ గమనిక మరొక struct కేటాయించి ఆ,
గమనికలు అన్ని ఇప్పటికీ అదే పని సూచించడానికి
అవి కాపీ చేయబడ్డాయి నుండి.
మీరు గమనికలు పంచుకోవటానికి అనుకుంటే,
మీరు, మానవీయంగా ఆ నిర్వహించడానికి చేయాలి
బహుశా గమనికలు ఒకటి మెమరీ ఒక బ్లాక్ malicking ద్వారా సూచించడానికి
మరియు డేటా కాపీ.
ఇది ప్రతిచోటా struct విద్యార్థి రాయడానికి కలిగి బాధించే కావచ్చు.
ఒక రకం డెఫ్ ఉపయోగించి, మేము చేయవచ్చు
రకం డెఫ్
struct
మరియు మేము అది విద్యార్థి పిలుస్తాను.
ఇప్పుడు మేము ప్రతిచోటా విద్యార్థి ఉపయోగించవచ్చు
మేము struct విద్యార్థి ఉపయోగించడానికి ఉపయోగించారు.
ఈ రకం డెఫ్ ఒక అనామక struct యొక్క
మరియు విద్యార్థి పిలుస్తుంది.
కానీ మేము విద్యార్థి ఐడెంటిఫైయర్ ఉంచుకుంటే
పదం struct పక్కన, typedef struct విద్యార్థి వలె,
మేము పరస్పరం ఇప్పుడు struct విద్యార్థి మరియు విద్యార్థి రెండు ఉపయోగించవచ్చు.
వారు కూడా అదే పేరు లేదు.
మేము బాబ్ డెఫ్ struct విద్యార్థి పంపుకోవచ్చు
తరువాత విద్యార్థి మరియు బాబ్ struct
మార్చుకోగలిగిన రకాల ఉంటుంది.
రూపాలతో సంబంధం లేకుండా డెఫ్ యొక్క,
మేము struct పక్కన ఐడెంటిఫైయర్ అవసరం
ఒకవేళ struct యొక్క నిర్వచనం
పునరావృత ఉంది.
ఉదాహరణకు,
రకం డెఫ్ struct నోడ్
మరియు అది ఒక పూర్ణాంకానికి Val నిర్వచించబడుతుంది కనిపిస్తుంది
మరియు అది మరొక struct నోడ్ పాయింతు ఒక పాయింటర్ ఉంటుంది.,
* తర్వాత struct నోడ్ లో.
మరియు తర్వాత మేము అది నోడ్ పిలుస్తాను.
ఈ struct, పునరావృత ఉంది
struct నోడ్ యొక్క నిర్వచనం దానిలోని కలిగి నుండి
ఒక struct నోడ్ ఒక పాయింటర్.
మేము struct నోడ్ * తర్వాత చెప్పడానికి మేము గుర్తించాము
struct నోడ్ యొక్క నిర్వచనం లోపల,
రకం డెఫ్ అనుమతించడానికి ఇంకా పూర్తి కాలేదు ఎందుకంటే మాకు ఈ సరళీకృతం చేయడానికి
కేవలం నోడ్ * ప్రక్కన.
మీరు ఈ పోలి structs గురించి మరింత నేర్చుకుంటారు
ఉన్నప్పుడు లింక్ జాబితాలు మరియు చెట్లు వ్యవహరిస్తుంది.
ఒక ఫంక్షన్ లో structs గురించి ఏమిటి?
ఇది ఖచ్చితంగా చెల్లదు.
మేము కలిగి
func రద్దు
ఇది ఒక వాదన తీసుకుని
విద్యార్థి s
మరియు ఆ విద్యార్థి ఏదో చేస్తాడు.
మరియు తర్వాత మేము వంటి విద్యార్థి struct గా తరలిస్తారు.
ముందు నుండి S1 యొక్క func.
struct ప్రవర్తిస్తుంది
పూర్ణాంకం ఒక ఫంక్షన్ జారీ ఎప్పుడు ఖచ్చితంగా.
Func S1 కాపీని అందుకున్న
అందువలన S1 సవరించలేరు;
బదులుగా, S. దానిని మాత్రమే కాపీ నిల్వ చేసే
మీకు కావాలంటే ఫంక్షన్ S1 సవరించడానికి చేయగలరు కు
func, ఒక విద్యార్థి * S తీసుకోవలసిన అవసరం ఉంటుంది
మరియు మీరు వంటి, చిరునామా ద్వారా S1 పాస్ ఉంటుంది.
స్టూడెంట్ * S, func & S1.
ఇక్కడ చిరునామా ద్వారా దాటిన మరొక కారణం ఉంది.
మా struct 100 ఖాళీలను కలిగి ఏమి ఉంటే?
మేము func ఒక విద్యార్థి పాస్ ప్రతి సమయం,
మా కార్యక్రమం, func యొక్క వాదన S లోకి ఆ 100 ఖాళీలను అన్ని కాపీ అవసరం
కూడా వారిని మెజారిటీ ఉపయోగిస్తుంది ఎప్పుడూ.
Func విద్యార్థి సవరించుట ప్లాన్ లేదు కాబట్టి కూడా,
ఇప్పటికీ చిరునామా ద్వారా దాటిన విలువైన మారవచ్చు.
సరే, మేము ఒక struct ఒక పాయింటర్ సృష్టించాలని మీరు అనుకుంటే ఏమి?
మేము వంటి ఏదో ఒకటి కాలేదు
విద్యార్థి * S
malloc సమానం
విద్యార్థి యొక్క పరిమాణం.
ఇప్పటికీ ఇక్కడ పనిచేస్తుంది యొక్క పరిమాణం గమనించండి.
కాబట్టి మేము ఎలా ఇప్పుడు వయసు సభ్యుడు యాక్సెస్ చేయాలి
బ్లాక్ యొక్క S పాయింట్లు ఆ?
మీరు తొలి భావిస్తున్నారా ఉండవచ్చు
* S.age = 4,
కానీ ఈ చాలా సాధ్యం కాదు.
ఇది నిజంగా వంటి వివరించబడతాయి నుండి
కుండలీకరణాలు = 4 లో * S.age,
ఇది కూడా, కంపైల్ లేదు
S ఒక struct ఒక struct లేదా బదులుగా ఒక పాయింటర్ కాదు,
అందువలన డాట్ ఇక్కడ సాధ్యం కాదు.
మేము చేయగల
(* S). వయసు = 4
కానీ కుండలీకరణాలు బాధించే మరియు గందరగోళంగా పొందవచ్చు.
కృతజ్ఞతగా, మేము ఒక ప్రత్యేక బాణం ఆపరేటర్లు కలిగి
ఏదో కనిపిస్తోంది
S-> వయసు = 4.
వయసు సూచిస్తూ ఈ 2 మార్గాలు
సమానంగా ఉంటాయి
మరియు మేము నిజంగా ఎప్పుడూ, బాణం ఆపరేటర్లు లేదు
కానీ విషయాలు NICER చూడండి చేస్తుంది.
S struct కలిగి మెమరీ కొన్ని బ్లాక్ ఒక పాయింటర్ కనుక,
పాయింటర్ బాణం అనుసరించండి మీరు S> వయస్సు ఆలోచించవచ్చు
మరియు వయస్సు సభ్యుడు పట్టుకొను.
ఎందుకు మనం structs ఉపయోగించాలి?
ఇది కేవలం ప్రాచీనమైన పూర్ణాంకాల తో దూరంగా ఖచ్చితంగా అవకాశం
అక్షరాలు, గమనికలు మరియు వంటి
మనం చేస్తున్న;
బదులుగా S1 మరియు S2 ముందు,
మేము age1, age2, NAME1 మరియు NAME2 కలిగి ఉండవచ్చు
ప్రత్యేక వేరియబుల్స్ వద్ద అన్ని.
ఇది మాత్రమే 2 విద్యార్థులు చిన్నగా ఉంది
కానీ మనం వాటిలో 10 ఉన్నట్లయితే?
మరియు ఏం బదులుగా కేవలం 2 ఖాళీలను,
విద్యార్థి struct 100 క్షేత్రాలను?
GPA, కోర్సులు, జుట్టు రంగు, లింగం, మరియు మొదలైనవి.
బదులుగా కేవలం 10 structs యొక్క, మేము 1,000 ప్రత్యేక వేరియబుల్స్ అవసరం.
అలాగే, ఒక ఫంక్షన్ పరిగణలోకి
దాని మాత్రమే వాదన తో 100 ఖాళీలను ఆ struct పడుతుంది
మరియు అన్ని రంగాల్లో అవుట్ ముద్రిస్తుంది.
మేము ఒక struct ఉపయోగించడానికి లేకపోతే,
మేము ఆ ఫంక్షన్ కాల్ ప్రతి సమయం
మేము, మొత్తం 100 వేరియబుల్స్ వద్ద పాస్ అవసరం
మరియు మేము విద్యార్థి 1 కోసం 100 వేరియబుల్స్ ఉంటే,
మరియు 100 విద్యార్థి 2 కోసం వేరియబుల్స్,
మేము అనుకోకుండా విద్యార్థి 1 నుండి కొన్ని వేరియబుల్స్ అనుమతించబడవు ఖచ్చితంగా ఉండాలి
మరియు విద్యార్థి 2 నుండి కొన్ని వేరియబుల్స్.
ఇది ఒక struct ఆ తప్పు చేయడానికి అసాధ్యం
మొత్తం 100 వేరియబుల్స్ ఒక ప్యాకేజీ ఉంటాయి నుండి.
చివరి గమనికలు కేవలం జంట:
మీరు ఈ పాయింట్ ప్రతిదీ అప్ గొప్ప అర్థం ఉంటే.
వీడియో మిగిలిన పరిపూర్ణత 'కొరకు ఉంది.
Structs పాయింటర్ ఏ రకమైన కలిగి ఎందుకంటే,
వారు కూడా ఫంక్షన్ గమనికలు పట్టుకోగలదు.
మీరు ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్ గురించి తెలిసి ఉంటే,
ఈ ఒక ఆబ్జెక్ట్ ఓరియంటెడ్ శైలిలో కార్యక్రమానికి structs ఉపయోగించడానికి మార్గాన్ని అందిస్తుంది.
మరొక సమయంలో ఫంక్షన్ గమనికలు మరింత.
అలాగే, కొన్నిసార్లు మీరు 2 structs ఉండవచ్చు
దీని నిర్వచనాలు ఒక మరొక ఆధారపడి.
ఉదాహరణకు,
మేము, struct ఒక కలిగి ఉంటుంది
ఇది నిర్వచించబడింది
ఒక struct B ఒక పాయింటర్,
struct B * X,
మరియు ఇప్పుడు మేము ఒక struct B కలిగి
ఒక పాయింటర్ నిర్వచించవచ్చు
ఒక struct A,
struct A * వై
కానీ ఈ, కంపైల్ లేదు
struct B struct ఒక సంకలనం ఉంది ఆ సమయంలో ఉనికిలో లేదు నుంచి.
మరియు మేము struct ఒక మరియు struct స్వాప్ ఉంటే B,
అప్పుడు మేము అదే సమస్య తో వదిలి ఇష్టం;
ఈ సమయంలో, ఒక ఇప్పటికే లేదు struct.
దీనిని పరిష్కరించడానికి, మేము రాయడం
struct B;
struct A. యొక్క నిర్వచనం ముందు
ఈ ఒక ముందుకు ప్రకటన అంటారు.
ఇది కంపైలర్ తెలిపే
struct B తరువాత పూర్తిగా లేదా మరెక్కడైనా నిర్వచించవచ్చు ఒక చెల్లుబాటు అయ్యే రకం.
నా పేరు రాబ్ బౌడెన్, మరియు ఈ CS50 ఉంది.
[CS50.TV]