C Programming Unions And Memory Sharing Complete Guide

What is a Union?

A union in C is a special data type that allows storing different data types in the same memory location. Only one member of a union can contain a value at any given time. The size of the union will be the size of its largest member.

Why Use Unions?

Unions are useful for memory optimization. For example, if you have multiple variables that won't be used simultaneously, using a union can save memory.

Step-by-Step Guide

Step 1: Define a Union

Let's start by defining a simple union that can store either an integer, a float, or a character.

#include <stdio.h>

union Data {
   int i;
   float f;
   char str[20];
};

int main() {
   union Data data; 

   printf("Memory size occupied by data : %ld\n", sizeof(data));

   return 0;
}

Explanation:

• In this example, we define a union named Data with three members: an integer i, a float f, and a character array str.
• When you create a variable of type union Data (data), you're reserving enough memory to hold its largest member. Here, sizeof(data) will give us the size of the str array, which is the largest member.

Output: Assuming the platform you are using, the output might look something like this:

Memory size occupied by data : 24

Step 2: Accessing Union Members

Now let's see how we can use this union to store different types of data.

#include <stdio.h>

union Data {
   int i;
   float f;
   char str[20];
};

int main() {
   union Data data;

   data.i = 10;
   printf( "data.i: %d\n", data.i);

   data.f = 220.5;
   printf( "data.f: %f\n", data.f);

   strcpy( data.str, "C Programming");
   printf( "data.str: %s\n", data.str);

   // Let's check the value of 'data.i' after assigning to 'data.str'
   printf( "data.i: %d\n", data.i); 

   return 0;
}

Explanation:

• After assigning an integer to data.i, when you print data.i, it displays the expected value.
• Similarly, when a float is assigned to data.f, it prints this new value.
• When a string is copied into data.str, the previous values of data.i and data.f are overwritten because they share the same memory location.
• As a result, the final print statement for data.i shows some unexpected value (garbage) since the integer memory was reused to store the string.

Output:

data.i: 10
data.f: 220.500000
data.str: C Programming
data.i: 987727596

Step 3: Using Unions for Memory Sharing

One practical scenario where unions are useful is when you need to store different data types but only one of them at a time.

#include <stdio.h>

union Student {
    char name[50]; 
    int roll_no; 
    float marks;
} student;

int main() {
    // Assigning name to union variable
    strcpy(student.name, "John Doe");
    printf("Student Name: %s\n", student.name);
    // printf("Roll No: %d\n", student.roll_no); // This would show garbage
    
    // Assigning roll_no to same union variable, name gets overwritten
    student.roll_no = 56;
    printf("Roll No: %d\n", student.roll_no);
    // printf("Marks: %.2f\n", student.marks); // This would show garbage

    // Assigning marks to same union variable, both name and roll_no get overwritten
    student.marks = 85.6;
    printf("Marks: %.2f\n", student.marks);
    // printf("Name: %s\n", student.name); // This would show garbage or part of old name
    // printf("Roll No: %d\n", student.roll_no); // This would show garbage

    return 0;
}

Explanation:

• The union Student is designed to hold a student's name, roll number, or marks at any given time.
• When you assign a value to one member of the union, you must ensure that you do not try to read the previous values from other members, as they will have been overwritten.

Output:

Student Name: John Doe
Roll No: 56
Marks: 85.60

Step 4: Practical Example - BitField Structure

Unions can also be used in conjunction with bitfields to access parts of an integer representing different flags.

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

union Packet {
    char cfield;        // can be accessed as a char
    int ifield;         // or can be accessed as an int

    struct {             // or can be bit-wise accessed...
       unsigned int f1:1;
       unsigned int f2:1;
       unsigned int f3:1;
       unsigned int f4:1;
       unsigned int f5:1;
       unsigned int f6:1;
       unsigned int f7:1;
       unsigned int f8:1;
    } bits;
};

int main() {
    union Packet packet;

    /* Using char format */
    packet.cfield = 'A';
    printf("packet.cfield: %c\n", packet.cfield);      // Output: A
    printf("packet.ifield: %d\n", packet.ifield);      // Output: 65

    /* Using int format directly */
    packet.ifield = 2;
    // Print character format
    printf("packet.cfield: %c\n", packet.cfield);      // Output: Control-Z
    // Print int format
    printf("packet.ifield: %d\n", packet.ifield);      // Output: 2

    /* Accessing individual bits */
    packet.bits.f1 = 1;
    packet.bits.f6 = 1;
    printf("\npacket.ifield: %d\n", packet.ifield);     // Output: 65
    // Printing individual bits
    printf("packet.bits.f1: %d\n", packet.bits.f1);     // Output: 1
    printf("packet.bits.f6: %d\n", packet.bits.f6);     // Output: 1

    return 0;
}

Explanation:

• This union Packet has three members: a char field, an int field, and a structure containing eight bit fields.
• We demonstrate how the data shared between these members can be accessed and used differently.
• The first member stores a character, which is represented by a byte in memory.
• The second member stores an integer, which may take more bytes.
• The third member is a bitfield, allowing us to set and retrieve individual bits within an integer.

Output:

packet.cfield: A
packet.ifield: 65
packet.cfield: @
packet.ifield: 2

packet.ifield: 65
packet.bits.f1: 1
packet.bits.f6: 1

Final Note

While unions are powerful for memory conservation, they can lead to bugs if not handled carefully. Always remember that only one member of the union can have a valid value at any time.