C Language
यूनियन

संरचना और संघ के बीच अंतर

इससे पता चलता है कि संघ के सदस्य स्मृति साझा करते हैं और यह कि संरचना सदस्य स्मृति साझा नहीं करते हैं।

#include <stdio.h>
#include <string.h>

union My_Union
{
  int variable_1;
  int variable_2;
};

struct My_Struct
{
  int variable_1;
  int variable_2;
};

int main (void)
{
  union My_Union u;
  struct My_Struct s;
  u.variable_1 = 1;
  u.variable_2 = 2;
  s.variable_1 = 1;
  s.variable_2 = 2;
  printf ("u.variable_1: %i\n", u.variable_1);
  printf ("u.variable_2: %i\n", u.variable_2);
  printf ("s.variable_1: %i\n", s.variable_1);
  printf ("s.variable_2: %i\n", s.variable_2);
  printf ("sizeof (union My_Union): %i\n", sizeof (union My_Union));
  printf ("sizeof (struct My_Struct): %i\n", sizeof (struct My_Struct));
  return 0;
}

मूल्यों की पुनर्व्याख्या के लिए यूनियनों का उपयोग करना

कुछ सी कार्यान्वयन संघ कोड को एक यूनियन प्रकार के एक सदस्य को लिखने की अनुमति देते हैं, फिर एक दूसरे से पढ़ते हैं ताकि एक प्रकार की पुनर्व्याख्या करने वाले कलाकारों का प्रदर्शन किया जा सके (पुराने प्रकार के बिट प्रतिनिधित्व के रूप में नए प्रकार को पार्स करना)।

हालांकि, यह नोट करना महत्वपूर्ण है, यह सी मानक वर्तमान या अतीत द्वारा अनुमत नहीं है और अपरिभाषित व्यवहार के परिणामस्वरूप होगा, कोई भी कम संकलक द्वारा प्रस्तुत एक बहुत ही सामान्य विस्तार नहीं है (इसलिए यदि आप ऐसा करने की योजना बनाते हैं तो अपने संकलक डॉक्स की जांच करें) ।

इस तकनीक का एक वास्तविक जीवन उदाहरण "फास्ट इनवर्स स्क्वायर रूट" एल्गोरिथम है जो फ्लोटिंग पॉइंट ऑपरेशन्स का उपयोग करने की तुलना में अधिक तेजी से उलटा वर्ग रूट निष्पादित करने के लिए IEEE 754 फ़्लोटिंग पॉइंट नंबरों के कार्यान्वयन विवरणों पर निर्भर करता है, यह एल्गोरिथम पॉइंटर कास्टिंग के माध्यम से या तो प्रदर्शन किया जा सकता है। (जो बहुत खतरनाक है और सख्त अलियासिंग नियम को तोड़ता है) या एक संघ के माध्यम से (जो अभी भी अपरिभाषित व्यवहार है लेकिन कई संकलक में काम करता है):

union floatToInt
{
    int32_t intMember;
    float floatMember; /* Float must be 32 bits IEEE 754 for this to work */
};

float inverseSquareRoot(float input)
{
    union floatToInt x;
    int32_t i;
    float f;
    x.floatMember = input;     /* Assign to the float member */
    i = x.intMember;           /* Read back from the integer member */
    i = 0x5f3759df - (i >> 1);
    x.intMember = i;           /* Assign to the integer member */
    f = x.floatMember;         /* Read back from the float member */
    f = f * (1.5f - input * 0.5f * f * f);
    return f * (1.5f - input * 0.5f * f * f);
}

फ्लोटिंग पॉइंट ऑपरेशंस का उपयोग करने की तुलना में इसकी तकनीक का उपयोग अतीत में कंप्यूटर ग्राफिक्स और गेम्स में व्यापक रूप से किया गया था, और यह बहुत अधिक समझौता है, कुछ सटीकता खो देता है और गति के बदले में बहुत गैर पोर्टेबल होता है।

एक संघ के सदस्य को लिखना और दूसरे से पढ़ना

एक संघ के सदस्य स्मृति में समान स्थान साझा करते हैं। इसका मतलब यह है कि एक सदस्य को लिखना अन्य सभी सदस्यों में डेटा को अधिलेखित करता है और एक सदस्य के पढ़ने से सभी सदस्यों के पढ़ने के समान डेटा प्राप्त होता है। हालाँकि, क्योंकि यूनियन के सदस्यों के प्रकार और आकार अलग-अलग हो सकते हैं, इसलिए जो डेटा पढ़ा जाता है, उसकी व्याख्या अलग-अलग तरीके से की जा सकती है, http://www.riptutorial.com/c/example/9399/use-unions-to-reinterpret-values देखें

नीचे दिए गए सरल उदाहरण में एक ही प्रकार के दो सदस्यों के साथ एक संघ प्रदर्शित किया गया है। इससे पता चलता है कि सदस्य के लिए लेखन m_1 सदस्य से पढ़ा जा रहा लिखा मूल्य में परिणाम m_2 और सदस्य के लिए लिख m_2 परिणाम लिखा मूल्य में सदस्य से पढ़ा जा रहा m_1 ।

#include <stdio.h>

union my_union /* Define union */
{
    int m_1;
    int m_2;
};

int main (void)
{
    union my_union u;             /* Declare union */
    u.m_1 = 1;                    /* Write to m_1 */
    printf("u.m_2: %i\n", u.m_2); /* Read from m_2 */
    u.m_2 = 2;                    /* Write to m_2 */
    printf("u.m_1: %i\n", u.m_1); /* Read from m_1 */
    return 0;
}

परिणाम

u.m_2: 1
u.m_1: 2