பாடம் 5 / 6 · Strings, Structs, Files · படிக்க 3 min · புதுப்பிக்கப்பட்டது

Unions

Members எல்லாம் ஒரே memory-ஐ பகிர்ந்துக்கிற type — struct-ல இருந்து எப்படி வேறுபடுது, எப்போ பயனுள்ளது.

Union struct மாதிரியே எழுதப்படும், ஆனா அதோட எல்லா members-ம் அதே memory-ல இருக்கும். அது அதோட பெரிய member அளவுக்கு மட்டும் தான் இருக்கும்; ஒரு நேரத்துல ஒரே ஒரு member-ஓட value-ஐ தான் வெச்சிருக்கும்: ஒண்ணுல store பண்ணா மத்தது அழிஞ்சிடும்.

Struct ஒவ்வொரு member-க்கும் தனி இடம் கொடுக்கும் (இங்க 12 bytes). Union எல்லாத்தையும் ஒரே இடத்தை பகிர வைக்கும் — பெரிய member அளவு (4 bytes).
c
#include <stdio.h>

struct S { int i; float f; char c; };
union  U { int i; float f; char c; };

int main(void)
{
    printf("struct size: %zu\n", sizeof(struct S));
    printf("union size:  %zu\n", sizeof(union U));

    union U u;
    u.i = 65;
    printf("u.i = %d\n", u.i);
    u.c = 'Z';                 /* overwrites the same memory */
    printf("u.c = %c\n", u.c);
    return 0;
}
Output
struct size: 12
union size:  4
u.i = 65
u.c = Z

Warning

கடைசியா store பண்ண member-ஐ மட்டும் படிங்க. u.c = 'Z'-க்கு அப்புறம் u.i-ஐ படிச்சா, machine-ஐ பொறுத்த ஒரு value கிடைக்கும் — 'Z'-ஓட bytes, 65-ல மிஞ்சினதோட கலந்து. எந்த member இப்போதையதுன்னு union ஞாபகம் வெச்சுக்காது; நீங்க தான் வெச்சுக்கணும்.

வழக்கமான pattern: struct-க்குள்ள ஒரு union

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

enum Kind { CASH, UPI };

struct Payment {
    enum Kind kind;            /* which member of data is in use */
    union {
        int rupees;
        char upi_id[20];
    } data;
};

int main(void)
{
    struct Payment p[2];

    p[0].kind = CASH;
    p[0].data.rupees = 500;

    p[1].kind = UPI;
    strcpy(p[1].data.upi_id, "priya@upi");

    for (int i = 0; i < 2; i++) {
        if (p[i].kind == CASH) {
            printf("Cash: Rs %d\n", p[i].data.rupees);
        } else {
            printf("UPI: %s\n", p[i].data.upi_id);
        }
    }
    return 0;
}
Output
Cash: Rs 500
UPI: priya@upi

ஒரு payment cash அல்லது UPI தான், ரெண்டும் இல்ல; அதனால use ஆகாததோட இடத்தை union மிச்சப்படுத்துது. kind field — ஒரு enum, பேர் வெச்ச constants-ஓட தொகுப்பு — எந்த member சரியானதுன்னு பதிவு பண்ணுது; படிக்கிற ஒவ்வொருத்தரும் அதை முதல்ல பார்க்கணும். இந்த "tagged union" தான் நிஜ code-ல union use ஆகுற விதம்.

ஒரு union-ல int a;, double b; (8 bytes), char c; இருக்கு. அது குறைஞ்சது எவ்வளவு பெருசு?

இப்போ இதை செஞ்சு பாருங்க

  1. அதே char name[20]; int id; members இருக்கிற struct-க்கும் union-க்கும் sizeof print பண்ணி, வித்தியாசத்தை விளக்குங்க.
  2. Payment example-ல மூணாவது payment வகையா CARD-ஐ, 4-digit card ending-ஓட சேருங்க.
  3. 3 மாணவர்களுக்கு, tag-ஓட, ஒரு mark (int) அல்லது grade (char) வெச்சிருக்கிற union எழுதுங்க.

Create a free account to save your progress, or sign in.