సింటాక్స్:
యూనియన్ అనేది వినియోగదారుచే నిర్వచించబడిన రకం, షేర్డ్ మెమరీ లొకేషన్‌లో విభిన్న డేటా రకాల నిల్వను అనుమతిస్తుంది. యూనియన్‌ని ఉపయోగించడం అనేది స్ట్రక్టుకు సమానమైన వాక్యనిర్మాణాన్ని అనుసరిస్తుంది.
ప్రాథమిక వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
యూనియన్ యూనియన్ పేరు {
// సభ్యుల ప్రకటనలు
డేటాటైప్1 సభ్యుడు1 ;
డేటాటైప్2 సభ్యుడు2 ;
//...
} ;
ఇక్కడ, 'UnionName' అనేది యూనియన్‌కు ఐడెంటిఫైయర్‌గా పనిచేస్తుంది, ఇది ఈ నిర్దిష్ట వినియోగదారు నిర్వచించిన రకాన్ని సూచించడానికి ఒక ప్రత్యేక పేరును అందిస్తుంది. యూనియన్ సభ్యుల డేటా రకాలు 'డేటాటైప్1', 'డేటాటైప్2' మరియు మొదలైనవిగా సూచించబడతాయి. ఈ డేటా రకాలు యూనియన్‌లో నిల్వ చేయగల వివిధ రకాల సమాచారాన్ని సూచిస్తాయి. యూనియన్‌లోని ప్రతి సభ్యుడు, 'సభ్యుడు1', 'సభ్యుడు2' మొదలైన పేర్లతో నిర్దేశించబడి, ఒక ప్రత్యేకమైన డేటాను సూచిస్తారు.
మేము ఇప్పుడు ప్రాథమిక వాక్యనిర్మాణాన్ని అర్థం చేసుకున్నాము. దీన్ని బాగా అర్థం చేసుకోవడానికి ఇప్పుడు కొన్ని ఉదాహరణలను ఉపయోగించుకుందాం.
ఉదాహరణ 1: ప్రాథమిక యూనియన్ వినియోగం
మొదటి ఉదాహరణ C++లో యూనియన్ల యొక్క ప్రాథమిక వినియోగాన్ని వివరిస్తుంది, అవి ఒకే నిర్మాణంలో వివిధ డేటా రకాల మధ్య మెమరీ స్థలాన్ని ఎలా పంచుకోవడాన్ని ప్రారంభిస్తాయో చూపిస్తుంది.
ఇక్కడ ఒక ఉదాహరణ:
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
యూనియన్ అర్రేయూనియన్ {
int intArray [ 5 ] ;
తేలుతుంది ఫ్లోట్అరే [ 5 ] ;
} ;
int ప్రధాన ( ) {
ArrayUnion arrayUnion ;
కోసం ( int i = 0 ; i < 5 ; ++ i ) {
శ్రేణి యూనియన్. intArray [ i ] = i * 2 ;
}
కోట్ << 'ఇంట్ అర్రే:' ;
కోసం ( int i = 0 ; i < 5 ; ++ i ) {
కోట్ << '' << శ్రేణి యూనియన్. intArray [ i ] ;
}
కోట్ << endl ;
కోసం ( int i = 0 ; i < 5 ; ++ i ) {
శ్రేణి యూనియన్. ఫ్లోట్అరే [ i ] = i * 1.5f ;
}
కోట్ << 'ఫ్లోట్ అర్రే:' ;
కోసం ( int i = 0 ; i < 5 ; ++ i ) {
కోట్ << '' << శ్రేణి యూనియన్. ఫ్లోట్అరే [ i ] ;
}
కోట్ << endl ;
తిరిగి 0 ;
}
ఈ C++ కోడ్ స్నిప్పెట్‌లో, మేము 'MyUnion' పేరుతో మూడు వేర్వేరు డేటా సభ్యులను కలిగి ఉన్న యూనియన్‌ను ఉపయోగిస్తాము: పూర్ణాంకం (intValue), ఫ్లోటింగ్ పాయింట్ నంబర్ (floatValue) మరియు అక్షరం (charValue). మెమరీ స్థలాన్ని పంచుకునే యూనియన్ సామర్థ్యం కారణంగా ఈ సభ్యులలో ఒకరు మాత్రమే ఏ సమయంలోనైనా సక్రియంగా ఉండవచ్చు.
'ప్రధాన' ఫంక్షన్‌లో, మేము యూనియన్ యొక్క ఉదాహరణను 'myUnion'గా ప్రకటిస్తాము. ముందుగా, మేము పూర్ణాంక సభ్యుని విలువను 42కి సెట్ చేస్తాము మరియు దానిని ప్రింట్ చేయడానికి 'కౌట్'ని ఉపయోగిస్తాము. తదనంతరం, మేము 'floatValue' సభ్యునికి 3.14 యొక్క ఫ్లోటింగ్ పాయింట్ విలువను కేటాయించి దానిని ముద్రిస్తాము. చివరగా, మేము 'A' అక్షరాన్ని 'charValue' సభ్యునికి కేటాయించి, దానిని ప్రింట్ చేస్తాము. యూనియన్ సభ్యులందరూ ఒకే మెమరీ స్థానాన్ని పంచుకుంటారు కాబట్టి, ఒక సభ్యుడిని మార్చడం ఇతర సభ్యుల విలువలపై ప్రభావం చూపుతుందని గుర్తుంచుకోవడం చాలా అవసరం. విజయవంతమైన అమలును సూచించే 0ని తిరిగి ఇవ్వడం ద్వారా కోడ్ ముగుస్తుంది.
ఉదాహరణ 2: స్ట్రక్ట్‌తో యూనియన్
struct అనేది C++లోని ఒక రకమైన డేటా, దీనిని వినియోగదారులు ఒక ఏకీకృత పేరుతో వివిధ రకాల వేరియబుల్స్‌ని కలపడానికి సృష్టించవచ్చు. మేము వివిధ రకాల డేటాను కలిగి ఉండే డేటా నిర్మాణాన్ని సృష్టించాలనుకున్నప్పుడు మరియు ప్రతి రకం నిర్దిష్ట ఫీల్డ్‌తో అనుబంధించబడినప్పుడు, ఒక స్ట్రక్టుతో యూనియన్‌ని కలపడం ఉపయోగకరంగా ఉంటుంది. విభిన్న ప్రాతినిధ్యాలను కలిగి ఉన్న సంక్లిష్ట డేటా నిర్మాణాలను అభివృద్ధి చేయడానికి ఈ జత చేయడం అనుమతిస్తుంది.
C++లో ఒక స్ట్రక్ట్‌లో యూనియన్‌ని ఉపయోగించడం యొక్క ఉదాహరణ ఇక్కడ ఉంది:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
నిర్మాణం పాయింట్ {
int s1 ;
int s2 ;
} ;
యూనియన్ ఆకారం {
int వైపులా ;
తేలుతుంది వ్యాసార్థం ;
పాయింట్ సెంటర్ ;
} ;
int ప్రధాన ( ) {
ఆకారం ఆకారం ;
ఆకారం. వైపులా = 5 ;
కోట్ << 'వైపులా:' << ఆకారం. వైపులా << endl ;
ఆకారం. వ్యాసార్థం = 6.0f ;
కోట్ << 'వ్యాసార్థం:' << ఆకారం. వ్యాసార్థం << endl ;
ఆకారం. కేంద్రం = { 10 , ఇరవై } ;
కోట్ << 'కేంద్రం: (' << ఆకారం. కేంద్రం . s1 << ',' << ఆకారం. కేంద్రం . s2 << ')' << endl ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, జ్యామితీయ ఆకృతిలోని విభిన్న అంశాలను సూచించడానికి యూనియన్ మరియు స్ట్రక్ట్‌ని ఉపయోగించే C++ ప్రోగ్రామ్‌ను మేము నిర్వచించాము. ముందుగా, మేము 2D స్పేస్‌లోని పాయింట్ యొక్క కోఆర్డినేట్‌లను సూచించే 's1' మరియు 's2' అనే రెండు పూర్ణాంకాల సభ్యులను కలిగి ఉన్న 'పాయింట్' నిర్మాణాన్ని ప్రకటిస్తాము. అప్పుడు, మేము ముగ్గురు సభ్యులతో కూడిన 'ఆకారం' అనే 'యూనియన్'ని నిర్వచించాము: ఒక 'భుజాలు' పూర్ణాంకం, 'వ్యాసార్థం' ఫ్లోటింగ్-పాయింట్ మరియు 'కేంద్రం' అనే 'పాయింట్' నిర్మాణం. 'ప్రధాన' ఫంక్షన్‌కి వెళుతున్నప్పుడు, మేము 'ఆకారం' అనే 'ఆకారం' వస్తువును ఇన్‌స్టాంటియేట్ చేస్తాము. మేము దాని విభిన్న సభ్యులకు విలువలను కేటాయించడం ద్వారా యూనియన్ యొక్క బహుముఖ ప్రజ్ఞను ప్రదర్శిస్తాము. ప్రారంభంలో, మేము భుజాల సంఖ్యను 5కి సెట్ చేసి ఫలితాన్ని ప్రింట్ చేస్తాము. తరువాత, మేము ఆకారానికి 6.0 వ్యాసార్థాన్ని కేటాయించి, వ్యాసార్థాన్ని అవుట్పుట్ చేస్తాము. చివరగా, మేము ఆకారానికి కోఆర్డినేట్‌లతో (10, 20) సెంటర్ పాయింట్‌ను కేటాయిస్తాము మరియు సెంటర్ కోఆర్డినేట్‌లను ప్రింట్ చేస్తాము.
ఉదాహరణ 3: Enumతో యూనియన్
C++లో, ఎన్యుమరేషన్‌లు, సాధారణంగా enums అని పిలుస్తారు, పేరున్న సమగ్ర స్థిరాంకాల సేకరణను నిర్వచించే ఉద్దేశ్యాన్ని అందిస్తాయి. యూనియన్‌లతో ఎన్యూమ్‌లను కలపడం అనేది విభిన్న రకాలను తీసుకోగల వేరియబుల్‌ను సూచించాలనుకునే దృశ్యాలలో ఉపయోగకరంగా ఉంటుంది, ప్రతి ఒక్కటి నిర్దిష్ట enum విలువతో అనుబంధించబడుతుంది.
ఇక్కడ ఒక ఉదాహరణ:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
enum సమాచార తరహా {
పూర్ణ సంఖ్య ,
ఫ్లోట్ ,
చార్
} ;
యూనియన్ డేటా విలువ {
int intvalue ;
తేలుతుంది floatValue ;
చార్ charValue ;
} ;
నిర్మాణం సమాచారం {
డేటా రకం రకం ;
డేటా విలువ విలువ ;
} ;
int ప్రధాన ( )
{
డేటా డేటా 1 , డేటా2 , డేటా3 ;
డేటా1. రకం = పూర్ణ సంఖ్య ;
డేటా1. విలువ . intvalue = 42 ;
డేటా2. రకం = ఫ్లోట్ ;
డేటా2. విలువ . floatValue = 3.14f ;
డేటా3. రకం = చార్ ;
డేటా3. విలువ . charValue = 'ఎ' ;
కోట్ << 'డేటా 1:' << డేటా1. విలువ . intvalue << endl ;
కోట్ << 'డేటా 2:' << డేటా2. విలువ . floatValue << endl ;
కోట్ << 'డేటా 3:' << డేటా3. విలువ . charValue << endl ;
తిరిగి 0 ;
}
ఈ ఉదాహరణ కోసం, వివిధ రకాల విలువలను కలిగి ఉండే సామర్థ్యాన్ని కలిగి ఉండే ఫ్లెక్సిబుల్ డేటా స్ట్రక్చర్‌ను రూపొందించడానికి enums, యూనియన్‌లు మరియు స్ట్రక్ట్‌లను ఉపయోగించే ప్రోగ్రామ్‌ని మేము కలిగి ఉన్నాము. 'డేటాటైప్' enum మూడు ప్రాథమిక డేటా రకాలను సూచించడానికి నిర్వచించబడింది: INTEGER, FLOAT మరియు CHAR. పేరు పెట్టబడిన సమగ్ర స్థిరాంకాల సమితిని అందించడం ద్వారా enum కోడ్ రీడబిలిటీ మరియు మెయింటెనబిలిటీని మెరుగుపరుస్తుంది.
అప్పుడు, మేము ముగ్గురు సభ్యులతో 'డేటా వాల్యూ' అనే యూనియన్‌ను తయారు చేస్తాము: చార్ టైప్ చార్ యొక్క 'చార్‌వాల్యూ', టైప్ ఫ్లోట్ యొక్క 'ఫ్లోట్ వాల్యూ' మరియు టైప్ ఇంట్ యొక్క 'ఇంట్‌వాల్యూ'. యూనియన్‌తో, ఈ సభ్యులు ఉమ్మడి మెమరీ స్థానాన్ని పంచుకుంటారు, ఇది యూనియన్‌ను విభిన్న రకాల విలువలను పరస్పరం మార్చుకోవడానికి అనుమతిస్తుంది. 'డేటా' నిర్మాణం అప్పుడు ఇద్దరు సభ్యులను కలిగి ఉంటుంది: 'రకం' అనే 'డేటాటైప్' ఎన్యుమరేటర్ మరియు 'విలువ' పేరుతో 'డేటా వాల్యూ' యూనియన్. నిర్మాణాత్మక ప్రాతినిధ్యాన్ని అందించడం ద్వారా డేటా రకాన్ని దాని సంబంధిత విలువతో అనుబంధించడానికి ఈ struct అనుమతిస్తుంది.
'ప్రధాన' ఫంక్షన్‌లో, మేము 'డేటా' నిర్మాణం యొక్క మూడు ఉదాహరణలను ఇన్‌స్టంట్ చేస్తాము: 'డేటా1', 'డేటా2' మరియు 'డేటా3'. మేము డేటా రకాన్ని పేర్కొనడం ద్వారా మరియు యూనియన్‌లో తగిన విలువను సెట్ చేయడం ద్వారా ఈ ఉదాహరణలకు విలువలను కేటాయిస్తాము. ఉదాహరణకు, “data1” 42 విలువతో INTEGER రకంతో కేటాయించబడుతుంది. చివరగా, ప్రతి “డేటా” ఉదాహరణలో నిల్వ చేయబడిన విలువలను ముద్రించడానికి మేము “cout” స్టేట్‌మెంట్‌లను ఉపయోగిస్తాము. ప్రోగ్రామ్ “డేటా1” యొక్క పూర్ణాంక విలువను, “డేటా2” యొక్క ఫ్లోటింగ్ పాయింట్ విలువను మరియు “డేటా3” అక్షర విలువను అందిస్తుంది.
ఈ ఉదాహరణ C++లో బహుముఖ మరియు టైప్-సురక్షిత డేటా ప్రాతినిధ్యాన్ని సృష్టించడానికి enums, యూనియన్‌లు మరియు స్ట్రక్ట్‌లను కలపడం ఎలా ఉపయోగించబడుతుందో వివరిస్తుంది.
ముగింపు
ఒకే మెమరీ స్థలంలో విభిన్న డేటా రకాలను నిర్వహించడానికి C++ యూనియన్‌లు శక్తివంతమైన మరియు సౌకర్యవంతమైన యంత్రాంగాన్ని అందిస్తాయి. ఈ కథనంలో ఉదహరించబడిన సందర్భాలు అనేక రకాల దృశ్యాలను పరిష్కరించడంలో యూనియన్ల అనుకూలత మరియు ప్రభావాన్ని హైలైట్ చేస్తాయి. డేటా రకాల పరస్పర మార్పిడిని ప్రదర్శించే ప్రాథమిక ఉపయోగాల నుండి స్ట్రక్చర్‌లు మరియు ఎన్యూమ్‌లతో కూడిన మరింత సంక్లిష్టమైన అప్లికేషన్‌ల వరకు, ఈ ఉదాహరణలు యూనియన్‌లు C++ ప్రోగ్రామింగ్‌కు తీసుకువచ్చే సామర్థ్యం మరియు అనుకూలతను నొక్కిచెబుతున్నాయి.