वाक्य - विन्यास:
यूनियन एक प्रकार है जिसे उपयोगकर्ता द्वारा परिभाषित किया जाता है, जो एक साझा मेमोरी स्थान के भीतर विविध डेटा प्रकारों के भंडारण को सक्षम बनाता है। यूनियन का उपयोग एक सिंटैक्स का अनुसरण करता है जो एक संरचना के समान होता है।
मौलिक वाक्यविन्यास इस प्रकार है:
मिलन संघ का नाम {
// सदस्य घोषणाएँ
डेटाटाइप1 सदस्य1 ;
डेटाटाइप2 सदस्य2 ;
//...
} ;
यहां, 'यूनियननाम' यूनियन के लिए पहचानकर्ता के रूप में कार्य करता है जो इस विशिष्ट उपयोगकर्ता-परिभाषित प्रकार को संदर्भित करने के लिए एक अद्वितीय नाम प्रदान करता है। यूनियन सदस्यों के डेटा प्रकारों को 'डेटाटाइप1', 'डेटाटाइप2' इत्यादि के रूप में दर्शाया जाता है। ये डेटा प्रकार विभिन्न प्रकार की सूचनाओं को दर्शाते हैं जिन्हें संघ के भीतर संग्रहीत किया जा सकता है। संघ के भीतर प्रत्येक सदस्य, जिसे 'सदस्य 1', 'सदस्य 2', आदि नामों से नामित किया गया है, डेटा के एक अलग टुकड़े का प्रतिनिधित्व करता है।
अब हम मूल वाक्यविन्यास को समझते हैं। आइए अब इसे बेहतर ढंग से समझने के लिए कुछ उदाहरणों का उपयोग करें।
उदाहरण 1: मूल संघ उपयोग
पहला उदाहरण C++ में यूनियनों के बुनियादी उपयोग को दर्शाता है, यह दर्शाता है कि वे एक ही संरचना के भीतर विभिन्न डेटा प्रकारों के बीच मेमोरी स्पेस को साझा करने को कैसे सक्षम करते हैं।
यहाँ एक उदाहरण है:
#शामिल करें
नेमस्पेस एसटीडी का उपयोग करना ;
मिलन ऐरेयूनियन {
int यहाँ intArray [ 5 ] ;
तैरना फ्लोटअरे [ 5 ] ;
} ;
int यहाँ मुख्य ( ) {
ऐरेयूनियन ऐरेयूनियन ;
के लिए ( int यहाँ मैं = 0 ; मैं < 5 ; ++ मैं ) {
arrayUnion. intArray [ मैं ] = मैं * 2 ;
}
अदालत << 'इंट ऐरे:' ;
के लिए ( int यहाँ मैं = 0 ; मैं < 5 ; ++ मैं ) {
अदालत << ' ' << arrayUnion. intArray [ मैं ] ;
}
अदालत << अंतः ;
के लिए ( int यहाँ मैं = 0 ; मैं < 5 ; ++ मैं ) {
arrayUnion. फ्लोटअरे [ मैं ] = मैं * 1.5f ;
}
अदालत << 'फ्लोट ऐरे:' ;
के लिए ( int यहाँ मैं = 0 ; मैं < 5 ; ++ मैं ) {
अदालत << ' ' << arrayUnion. फ्लोटअरे [ मैं ] ;
}
अदालत << अंतः ;
वापस करना 0 ;
}
इस C++ कोड स्निपेट में, हम 'MyUnion' नामक एक यूनियन का उपयोग करते हैं जिसमें तीन अलग-अलग डेटा सदस्य शामिल होते हैं: एक पूर्णांक (intValue), एक फ़्लोटिंग-पॉइंट नंबर (फ़्लोटValue), और एक वर्ण (charValue)। यूनियन की मेमोरी स्पेस साझा करने की क्षमता के कारण इनमें से केवल एक सदस्य किसी भी बिंदु पर सक्रिय हो सकता है।
'मुख्य' फ़ंक्शन के भीतर, हम यूनियन का एक उदाहरण घोषित करते हैं जो 'myUnion' है। सबसे पहले, हम पूर्णांक सदस्य का मान 42 पर सेट करते हैं और इसे प्रिंट करने के लिए 'काउट' का उपयोग करते हैं। इसके बाद, हम 'फ्लोटवैल्यू' सदस्य को 3.14 का फ्लोटिंग-पॉइंट मान निर्दिष्ट करते हैं और इसे प्रिंट करते हैं। अंत में, हम 'charValue' सदस्य को 'A' अक्षर निर्दिष्ट करते हैं और उसे प्रिंट करते हैं। यह याद रखना आवश्यक है कि चूंकि सभी यूनियन सदस्य एक ही मेमोरी स्थान साझा करते हैं, इसलिए एक सदस्य को बदलने से अन्य सदस्यों के मूल्यों पर प्रभाव पड़ सकता है। कोड 0 लौटाकर समाप्त होता है जो सफल निष्पादन को दर्शाता है।
उदाहरण 2: संरचना के साथ मिलन
स्ट्रक्चर C++ में एक प्रकार का डेटा है जिसे उपयोगकर्ता एक एकीकृत नाम के तहत विभिन्न प्रकार के वेरिएबल्स को संयोजित करने के लिए बना सकते हैं। एक संघ को एक संरचना के साथ जोड़ना तब उपयोगी हो सकता है जब हम एक डेटा संरचना बनाना चाहते हैं जो विभिन्न प्रकार के डेटा को धारण कर सके, और प्रत्येक प्रकार एक विशिष्ट क्षेत्र से जुड़ा हो। यह जोड़ी विविध अभ्यावेदन वाली जटिल डेटा संरचनाओं के विकास की अनुमति देती है।
यहां C++ में किसी संरचना के भीतर यूनियन का उपयोग करने का एक उदाहरण दिया गया है:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
struct बिंदु {
int यहाँ एस 1 ;
int यहाँ एस 2 ;
} ;
मिलन आकार {
int यहाँ दोनों पक्ष ;
तैरना RADIUS ;
बिंदु केंद्र ;
} ;
int यहाँ मुख्य ( ) {
आकार आकार ;
आकार। दोनों पक्ष = 5 ;
अदालत << 'पक्ष:' << आकार। दोनों पक्ष << अंतः ;
आकार। RADIUS = 6.0f ;
अदालत << 'त्रिज्या:' << आकार। RADIUS << अंतः ;
आकार। केंद्र = { 10 , बीस } ;
अदालत << 'केंद्र: (' << आकार। केंद्र . एस 1 << ', ' << आकार। केंद्र . एस 2 << ')' << अंतः ;
वापस करना 0 ;
}
इस कोड में, हम एक C++ प्रोग्राम को परिभाषित करते हैं जो एक ज्यामितीय आकार के विभिन्न पहलुओं का प्रतिनिधित्व करने के लिए एक संघ और एक संरचना का उपयोग करता है। सबसे पहले, हम एक 'प्वाइंट' संरचना घोषित करते हैं जिसमें दो पूर्णांक सदस्य, 'एस1' और 'एस2' होते हैं, जो 2डी स्पेस में एक बिंदु के निर्देशांक का प्रतिनिधित्व करते हैं। फिर, हम 'शेप' नामक एक 'संघ' को परिभाषित करते हैं जिसमें तीन सदस्य होते हैं: एक 'पक्ष' पूर्णांक, एक 'त्रिज्या' फ़्लोटिंग-पॉइंट, और 'केंद्र' नामक एक 'प्वाइंट' संरचना। 'मुख्य' फ़ंक्शन पर आगे बढ़ते हुए, हम 'आकार' नामक एक 'आकार' ऑब्जेक्ट को इंस्टेंट करते हैं। फिर हम इसके विभिन्न सदस्यों को मान निर्दिष्ट करके संघ की बहुमुखी प्रतिभा को प्रदर्शित करते हैं। प्रारंभ में, हम पक्षों की संख्या 5 निर्धारित करते हैं और परिणाम प्रिंट करते हैं। इसके बाद, हम आकृति को 6.0 का त्रिज्या निर्दिष्ट करते हैं और त्रिज्या को आउटपुट करते हैं। अंत में, हम आकृति को निर्देशांक (10, 20) के साथ एक केंद्र बिंदु निर्दिष्ट करते हैं और केंद्र के निर्देशांक प्रिंट करते हैं।
उदाहरण 3: एनम के साथ मिलन
C++ में, गणनाएँ, जिन्हें आमतौर पर एनम्स कहा जाता है, नामित अभिन्न स्थिरांक के संग्रह को परिभाषित करने के उद्देश्य से काम करती हैं। यूनियनों के साथ एनम का संयोजन उन परिदृश्यों में उपयोगी हो सकता है जहां हम एक वेरिएबल का प्रतिनिधित्व करना चाहते हैं जो विभिन्न प्रकार ले सकता है, प्रत्येक एक विशिष्ट एनम मान से जुड़ा हुआ है।
यहाँ एक उदाहरण है:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
enum डेटा प्रकार {
पूर्णांक ,
तैरना ,
चार
} ;
मिलन डेटा का मान {
int यहाँ intवैल्यू ;
तैरना फ्लोटवैल्यू ;
चार charValue ;
} ;
struct डेटा {
डेटा प्रकार प्रकार ;
डेटावैल्यू मान ;
} ;
int यहाँ मुख्य ( )
{
डेटा डेटा1 , डेटा2 , डेटा3 ;
डेटा1. प्रकार = पूर्णांक ;
डेटा1. कीमत . intवैल्यू = 42 ;
डेटा2. प्रकार = तैरना ;
डेटा2. कीमत . फ्लोटवैल्यू = 3.14एफ ;
डेटा3. प्रकार = चार ;
डेटा3. कीमत . charValue = 'ए' ;
अदालत << 'डेटा 1:' << डेटा1. कीमत . intवैल्यू << अंतः ;
अदालत << 'डेटा 2:' << डेटा2. कीमत . फ्लोटवैल्यू << अंतः ;
अदालत << 'डेटा 3:' << डेटा3. कीमत . charValue << अंतः ;
वापस करना 0 ;
}
इस उदाहरण के लिए, हमारे पास एक प्रोग्राम है जो एक लचीली डेटा संरचना बनाने के लिए एनम, यूनियन और स्ट्रक्चर का उपयोग करता है जो विभिन्न प्रकार के मान रखने में सक्षम है। 'डेटाटाइप' एनम को तीन मूलभूत डेटा प्रकारों का प्रतिनिधित्व करने के लिए परिभाषित किया गया है: पूर्णांक, फ़्लोट और CHAR। एनम नामित अभिन्न स्थिरांक के एक सेट की पेशकश करके कोड की पठनीयता और रखरखाव को बढ़ाता है।
फिर, हम तीन सदस्यों के साथ 'डेटावैल्यू' नामक एक यूनियन बनाते हैं: चार प्रकार का 'चारवैल्यू', प्रकार फ्लोट का 'फ्लोटवैल्यू', और प्रकार इंट का 'इंटवैल्यू'। एक संघ के साथ, ये सदस्य एक सामान्य मेमोरी स्थान साझा करते हैं जो संघ को अलग-अलग प्रकार के मूल्यों को परस्पर समायोजित करने की अनुमति देता है। फिर 'डेटा' संरचना बनाई जाती है जिसमें दो सदस्य होते हैं: एक 'डेटाटाइप' एन्यूमरेटर जिसे 'टाइप' नाम दिया गया है और एक 'डेटावैल्यू' यूनियन जिसे 'वैल्यू' कहा जाता है। यह संरचना हमें एक डेटा प्रकार को उसके संबंधित मूल्य के साथ जोड़ने की अनुमति देती है, जो एक संरचित प्रतिनिधित्व प्रदान करती है।
'मुख्य' फ़ंक्शन में, हम 'डेटा' संरचना के तीन उदाहरणों को इंस्टेंट करते हैं: 'डेटा1', 'डेटा2', और 'डेटा3'। हम डेटा प्रकार निर्दिष्ट करके और यूनियन के भीतर उचित मान सेट करके इन उदाहरणों को मान निर्दिष्ट करते हैं। उदाहरण के लिए, 'डेटा1' को 42 के मान के साथ एक पूर्णांक प्रकार के साथ असाइन किया गया है। अंत में, हम प्रत्येक 'डेटा' उदाहरण में संग्रहीत मानों को मुद्रित करने के लिए 'काउट' स्टेटमेंट का उपयोग करते हैं। प्रोग्राम 'डेटा1' का पूर्णांक मान, 'डेटा2' का फ़्लोटिंग-पॉइंट मान और 'डेटा3' का वर्ण मान आउटपुट करता है।
यह उदाहरण दिखाता है कि C++ में एक बहुमुखी और प्रकार-सुरक्षित डेटा प्रतिनिधित्व बनाने के लिए एनम, यूनियन और स्ट्रक्चर के संयोजन को कैसे नियोजित किया जा सकता है।
निष्कर्ष
C++ यूनियन एक ही मेमोरी स्पेस के भीतर विविध डेटा प्रकारों के प्रबंधन के लिए एक शक्तिशाली और लचीला तंत्र प्रदान करता है। इस आलेख में दर्शाए गए उदाहरण विभिन्न परिदृश्यों को संबोधित करने में यूनियनों की अनुकूलन क्षमता और प्रभावशीलता पर प्रकाश डालते हैं। मूलभूत उपयोगों से जो संरचनाओं और एनमों से जुड़े अधिक जटिल अनुप्रयोगों के लिए डेटा प्रकारों की अदला-बदली को प्रदर्शित करते हैं, ये उदाहरण उस दक्षता और अनुकूलनशीलता को रेखांकित करते हैं जो यूनियन C++ प्रोग्रामिंग में लाते हैं।