నిర్మాణం మరియు యూనియన్ మధ్య వ్యత్యాసం
విషయము
కస్టమ్ డేటాను సృష్టించడానికి సి భాష అందించిన ఐదు మార్గాలను సి ++ అనుమతిస్తుంది. ఆ ఐదు మార్గాలు ‘నిర్మాణం’, ‘బిట్-ఫీల్డ్’, ‘యూనియన్’, ‘ఎన్యూమరేషన్’, ‘టైప్‌డెఫ్’. దిగువ వ్యాసంలో మేము నిర్మాణం మరియు యూనియన్ మధ్య వ్యత్యాసాన్ని అధ్యయనం చేయబోతున్నాము. నిర్మాణం మరియు యూనియన్ రెండూ ఏదైనా “రకం” యొక్క డేటాను కలిగి ఉండే కంటైనర్ డేటా రకాలు. నిర్మాణం మరియు యూనియన్ను వేరుచేసే ఒక ప్రధాన వ్యత్యాసం ఏమిటంటే, నిర్మాణం దానిలోని ప్రతి సభ్యునికి ప్రత్యేక మెమరీ స్థానాన్ని కలిగి ఉంటుంది, అయితే యూనియన్ సభ్యులు ఒకే మెమరీ స్థానాన్ని పంచుకుంటారు.
పోలిక చార్ట్తో పాటు నిర్మాణం మరియు యూనియన్ మధ్య వ్యత్యాసాన్ని అర్థం చేసుకుందాం.
- పోలిక చార్ట్
- నిర్వచనం
- కీ తేడాలు
- సారూప్యతలు
- ముగింపు
పోలిక చార్ట్
| పోలిక యొక్క ఆధారం | నిర్మాణం | యూనియన్ |
|---|---|---|
| ప్రాథమిక | నిర్మాణం యొక్క ప్రతి సభ్యునికి ప్రత్యేక మెమరీ స్థానం కేటాయించబడుతుంది. | యూనియన్ సభ్యులందరూ ఒకే మెమరీ స్థానాన్ని పంచుకుంటారు. |
| ప్రకటన | struct struct_name { మూలకం 1 రకం; మూలకం 2 రకం; . . } వేరియబుల్ 1, వేరియబుల్ 2, ...; | యూనియన్ u_name { మూలకం 1 రకం; టైప్ ఎలిమెంట్ 2; . . } వేరియబుల్ 1, వేరియబుల్ 2, ...; |
| కీవర్డ్ | struct | యూనియన్ |
| పరిమాణం | నిర్మాణం యొక్క పరిమాణం = అన్ని డేటా సభ్యుల పరిమాణం. | యూనియన్ పరిమాణం = అతిపెద్ద సభ్యుల పరిమాణం. |
| స్టోర్ విలువ | సభ్యులందరికీ ప్రత్యేకమైన విలువలను నిల్వ చేస్తుంది. | సభ్యులందరికీ ఒకే విలువను నిల్వ చేస్తుంది. |
| ఒక సమయంలో | ఒక నిర్మాణం నిర్మాణం యొక్క విభిన్న సభ్యుల యొక్క బహుళ విలువలను నిల్వ చేస్తుంది. | యూనియన్ సభ్యులందరికీ ఒకే సమయంలో ఒకే విలువను నిల్వ చేస్తుంది. |
| వీక్షణ మార్గం | ప్రతి మెమరీ స్థానాన్ని వీక్షించడానికి ఒకే మార్గాన్ని అందించండి. | ఒకే మెమరీ స్థానాన్ని వీక్షించడానికి బహుళ మార్గాలను అందించండి. |
| అనామక లక్షణం | అనామక లక్షణం లేదు. | అనామక యూనియన్ ప్రకటించవచ్చు. |
నిర్మాణం యొక్క నిర్వచనం
నిర్మాణం అనేది వివిధ డేటా రకాల వేరియబుల్స్ యొక్క సమాహారం, వీటిని సాధారణ పేరుతో సూచిస్తారు. ఒక నిర్మాణంలోని వేరియబుల్స్‌ను “సభ్యులు” అంటారు. అప్రమేయంగా, ఒక నిర్మాణంలోని సభ్యులందరూ “పబ్లిక్”. మీరు ఒక నిర్మాణాన్ని ప్రకటించినప్పుడు, మీరు ఒక మూసను సృష్టిస్తారు, ఇది నిర్మాణ వస్తువులను సృష్టించడానికి ఉపయోగపడుతుంది, డేటా సభ్యుల యొక్క ఒకే సంస్థను మరియు సభ్యుల విధులను పంచుకుంటుంది. నిర్మాణం యొక్క ప్రకటన ఎల్లప్పుడూ "struct" అనే కీవర్డ్‌తో ముందే ఉంటుంది, ఇది కంపైలర్‌కు ఒక నిర్మాణం ప్రకటించబడిందని చెబుతుంది. ఒక ఉదాహరణ తీసుకుందాం.
ఒక ఉదాహరణ తీసుకుందాం.
నిర్మాణ ఉద్యోగి {స్ట్రింగ్ పేరు; స్ట్రింగ్ కంపెనీ_పేరు; స్ట్రింగ్ సిటీ; } Emp1, emp2;
ఇక్కడ, మేము ఉద్యోగుల సమాచారాన్ని నిల్వ చేయడానికి ఒక నిర్మాణాన్ని ప్రకటిస్తాము. స్ట్రక్చర్ డిక్లరేషన్ ఒక స్టేట్మెంట్ మరియు సి ++ లో స్టేట్మెంట్ సెమికోలన్ చేత ముగించబడినందున డిక్లరేషన్ సెమికోలన్ చేత ముగించబడుతుంది.
ఒక నిర్మాణానికి ఇచ్చిన పేరు “రకాన్ని” నిర్వచిస్తుంది (పై ఉదాహరణలో నిర్మాణం పేరు “ఉద్యోగి”). ఈ రకమైన వేరియబుల్స్ సృష్టించవచ్చు, పైన చెప్పినట్లుగా, మేము “ఉద్యోగి” రకం యొక్క రెండు వేరియబుల్ ’emp1 ′ మరియు’ emp2 type ను సృష్టించాము. పై ఉదాహరణలో, మేము డిక్లరేషన్ తర్వాత ‘స్ట్రక్చర్’ వేరియబుల్ సృష్టించాము; ప్రత్యామ్నాయంగా, దీనిని విడిగా సృష్టించవచ్చు.
struct ఉద్యోగి emp1, emp2; // struct అనే కీవర్డ్ తప్పనిసరి కాదు.
స్ట్రక్చర్ వేరియబుల్ యొక్క సభ్యులను ప్రారంభించవచ్చు లేదా డాట్ (.) ఆపరేటర్ ఉపయోగించి యాక్సెస్ చేయవచ్చు.
emp1.name "అశోక్" =;
ఒక స్ట్రక్చర్ వేరియబుల్‌లో ఉన్న సమాచారాన్ని అనుసరించే అదే రకమైన మరొక స్ట్రక్చర్ వేరియబుల్‌కు కేటాయించవచ్చు.
emp1.name "అశోక్" =; emp1.company_name = "టెక్పిక్స్"; emp1.city = "ఢిల్లీ"; emp2 = emp1; // emp1 యొక్క సభ్యుని విలువలను emp2 కు కేటాయించడం. న్యాయస్థానం <
ఇక్కడ, మేము స్ట్రక్చర్ వేరియబుల్ ’emp1’ ను ‘emp2 ′ కి కేటాయించాము, కాబట్టి’ emp1 its దాని సభ్యుల మొత్తం విలువను ‘epm2’ యొక్క సంబంధిత సభ్యునికి కాపీ చేస్తుంది.
స్ట్రక్చర్ వేరియబుల్ యొక్క సభ్యుడిని ఫంక్షన్‌కు పంపవచ్చు.
funct (emp1.city);
మొత్తం స్ట్రక్చర్ వేరియబుల్‌ను ఫంక్షన్‌కు పంపవచ్చు, రెండు పద్ధతుల ద్వారా విలువ ద్వారా కాల్ మరియు రిఫరెన్స్ ద్వారా కాల్ చేయబడతాయి.
ఫంట్ (emp1); // కాల్ పద్ధతి ద్వారా కాల్ పద్ధతి విలువ పద్ధతి. . . void funct (struct Employer emp) emp // emp1 సభ్యుల విలువలను స్వీకరించడం. న్యాయస్థానం <
ఇక్కడ, స్ట్రక్చర్ వేరియబుల్ యొక్క సభ్యుని విలువకు మార్పు ఫంక్షన్ వెలుపల ప్రతిబింబించదు, ఎందుకంటే వేరియబుల్ విలువ ద్వారా కాల్ ద్వారా పంపబడుతుంది. ఇప్పుడు రిఫరెన్స్ మెథడ్ ద్వారా కాల్ ద్వారా అదే పని చేద్దాం.
ఫంట్ (& emp1); // రిఫరెన్స్ పద్ధతి ద్వారా కాల్ ద్వారా ఫంక్షన్. . . void funct (struct ఉద్యోగి * emp) emp // emp1 యొక్క చిరునామాను స్వీకరించడం. emp-> నగరం = "నూర్"; // స్ట్రక్చర్ వేరియబుల్ emp1 యొక్క సభ్యుడు (నగరం) విలువను మార్చండి. . }
ఇక్కడ, స్ట్రక్చర్ వేరియబుల్ రిఫరెన్స్ ద్వారా పంపబడుతుంది కాబట్టి, స్ట్రక్చర్ వేరియబుల్ యొక్క సభ్యుల విలువకు మార్పు కూడా ఫంక్షన్ వెలుపల ప్రతిబింబిస్తుంది.
srtuct ఉద్యోగి * emp; // టైప్ ఉద్యోగి యొక్క స్ట్రక్చర్ పాయింటర్‌ను డికాల్రింగ్. EMP = & emp1; // పాయింటర్‌కు emp1 యొక్క చిరునామాను కేటాయించడం. emp-> city // పాయింటర్ emp1 యొక్క సభ్య నగరాన్ని యాక్సెస్ చేస్తుంది.
నిర్మాణానికి పాయింటర్ కూడా సృష్టించవచ్చు; ఇది స్ట్రక్చర్ వేరియబుల్ యొక్క చిరునామాను కలిగి ఉంటుంది.
నిర్మాణంలో నిర్వచనం లేనప్పుడు, ఏ వినియోగదారు అయినా కన్స్ట్రక్టర్ లేదా వర్చువల్ ఫంక్షన్లు లేదా బేస్ క్లాస్ లేదా ప్రైవేట్ లేదా రక్షిత ఫీల్డ్‌ను నిర్వచించినప్పుడు నిర్మాణంలో మొత్తం ప్రారంభించడం అనుమతించబడుతుంది.
int main () {struct epm3 = {"అనిల్", "టెక్పిక్స్", "నూర్"}; Employee // ఉద్యోగి యొక్క నిర్మాణం పైన పేర్కొన్న విషయాలను కలిగి ఉండదు.
యూనియన్ యొక్క నిర్వచనం
యూనియన్ అంటే ఒకే యూనియన్ రకం కింద ప్రకటించిన రెండు లేదా అంతకంటే ఎక్కువ విభిన్న రకాల వేరియబుల్ ద్వారా పంచుకునే మెమరీ స్థానం. యూనియన్ను ప్రకటించడానికి ఉపయోగించే కీవర్డ్ “యూనియన్”. C ++ లో, యూనియన్ సభ్యుల ఫంక్షన్ మరియు వేరియబుల్స్ రెండింటినీ కలిగి ఉండవచ్చు. అప్రమేయంగా, యూనియన్ సభ్యులందరూ “పబ్లిక్”. "యూనియన్" యొక్క ప్రకటన నిర్మాణం యొక్క ప్రకటనతో సమానంగా ఉంటుంది.
యూనియన్ u_type {int x, చార్ సి; ఫ్లోట్ ఎఫ్; } u1, u2;
ఇక్కడ, మేము u_type అనే యూనియన్ను ప్రకటించాము. U_type యొక్క సభ్యులు పూర్ణాంక రకం యొక్క ‘x’, అక్షర రకం ‘c’ మరియు ఫ్లోట్ రకం ‘f’. యూనియన్ ప్రకటించిన కొద్దిసేపటికే ‘u_type’ రకానికి చెందిన యూనియన్ వేరియబుల్స్ ‘u1’ మరియు ‘u2’ ను కూడా సృష్టించాము. మేము యూనియన్ డిక్లరేషన్ నుండి యూనియన్ వేరియబుల్‌ను విడిగా ప్రకటించవచ్చు.
int main () {యూనియన్ u_type u1, u2; C ++ లో కీవర్డ్ యూనియన్ తప్పనిసరి కాదు. }
యూనియన్ సభ్యుల ప్రాప్యతను డాట్ (.) ఆపరేటర్ ఉపయోగించి చేయవచ్చు, యూనియన్ వేరియబుల్ ముందు మరియు ఆ వేరియబుల్ సభ్యుడిని అనుసరిస్తుంది.
u1.x = 10;
నిర్మాణాల మాదిరిగా, యూనియన్‌లో మొత్తం ప్రారంభించడం సాధ్యం కాదు. మనకు తెలిసినట్లుగా, యూనియన్ ఒకేసారి దాని సభ్యులందరికీ ఒకే మెమరీ స్థానాన్ని పంచుకుంటుంది, ఒక వేరియబుల్ మాత్రమే ప్రారంభించబడుతుంది మరియు అన్ని వేరియబుల్ ప్రారంభ విలువతో స్వయంచాలకంగా నవీకరించబడుతుంది.
u1.x = 10; న్యాయస్థానం <
మీరు ‘u1’ లోని ఏదైనా సభ్యుని విలువను మార్చడానికి ప్రయత్నిస్తే. ఇతర సభ్యుడు స్వయంచాలకంగా ఆ విలువకు నవీకరించబడతారు.
u1.c = 65; న్యాయస్థానం <
యూనియన్‌కు కేటాయించిన స్థలం యూనియన్‌లోని అతిపెద్ద సభ్యుడి పరిమాణానికి సమానం. ‘చార్’ కి కేటాయించిన బైట్ 1 బైట్, ‘పూర్ణాంకం’ 4 బైట్ మరియు ‘ఫ్లోట్’ 4 బైట్లు కాబట్టి, అతిపెద్ద పరిమాణం 4 బైట్. కాబట్టి, ‘u1’ మరియు ‘u2’ లకు కేటాయించిన మెమరీ 4 బైట్.
int main () {int size_1 = sizeof (u1); // 4 int size_2 = sizeof (u2); // 4
నిర్మాణంలో ఉన్నట్లే యూనియన్‌కు పాయింటర్‌ను సృష్టించవచ్చు. పాయింటర్ యూనియన్ చిరునామాను కలిగి ఉంది.
యూనియన్ u_type * un; అన్ = & యూ 1; న్యాయస్థానం < నిర్మాణం వలె, యూనియన్ కూడా రెండు పద్ధతుల ద్వారా ఫంక్షన్లకు పంపబడుతుంది, అనగా విలువ ద్వారా కాల్ మరియు సూచన ద్వారా కాల్. funct (యూ 1); // కాల్ పద్ధతి ద్వారా కాల్ పద్ధతి విలువ పద్ధతి. . . void funct (యూనియన్ u_type un) {// u1 సభ్యుని విలువను పొందడం. న్యాయస్థానం < ఇప్పుడు, రిఫరెన్స్ పద్ధతి ద్వారా కాల్ ఉపయోగించి ఫంక్షన్‌కు కాల్ చేద్దాం. funct (& యూ 1); రిఫరెన్స్ పద్ధతి ద్వారా కాల్ ద్వారా // కాలింగ్ ఫంక్షన్. . . void funct (యూనియన్ u_type un) {// u1 యొక్క చిరునామాను స్వీకరించడం. un-> x = 20. } సి ++ లో అనామక యూనియన్ అని పిలువబడే ప్రత్యేక రకం యూనియన్ ఉంది ”. అనామక యూనియన్ రకం పేరును కలిగి ఉండదు మరియు అటువంటి యూనియన్ యొక్క వేరియబుల్ సృష్టించబడదు. కంపైలర్‌కు దాని సభ్యుల వేరియబుల్స్ ఒకే స్థానాన్ని పంచుకోవడమే చెప్పడం. అనామక యూనియన్ యొక్క వేరియబుల్ సాధారణ డాట్ (.) ఆపరేటర్ లేకుండా సూచించబడుతుంది. int main () {యూనియన్ {// రకం పేరుతో అనామక యూనియన్ను నిర్వచించండి. int x, చార్ సి; ఫ్లోట్ ఎఫ్; }; x = 10; // d ట్ డాట్ ఆపరేటర్ కౌట్ <తో యూనియన్ వేరియబుల్ ను సూచించింది అనామక యూనియన్‌లో సభ్యుల పనితీరు అనుమతించబడదు, ఇది ప్రైవేట్ లేదా రక్షిత డేటాను కలిగి ఉండదు మరియు గ్లోబల్ అనామక యూనియన్ తప్పనిసరిగా ‘స్టాటిక్’ గా పేర్కొనబడాలి. సాధారణ యూనియన్ డిక్లరేషన్ కోసం గుర్తుంచుకోవలసిన అంశాలు. రెండూ, నిర్మాణం మరియు యూనియన్ వివిధ రకాల సభ్యులను కలిగి ఉన్న కంటైనర్ డేటాటైప్. మేము సభ్యులందరికీ ప్రత్యేకమైన విలువను ప్రత్యేకమైన మెమరీ ప్రదేశంలో నిల్వ చేయాల్సిన అవసరం వచ్చినప్పుడు నిర్మాణాలు ఉపయోగించబడతాయి. రకం మార్పిడి అవసరమైనప్పుడు యూనియన్లు ఉపయోగించబడతాయి.
సారూప్యతలు:
ముగింపు:
