> For the complete documentation index, see [llms.txt](https://cs.d19.in/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://cs.d19.in/structures-and-unions.md).

# Structures and Unions

## **Structures (Structs)**

Structures allow you to group different types of data into a single unit. This is useful for representing complex data.

**Declaration and Definition**

To define a structure, use the `struct` keyword followed by the structure name and the body containing the members.

```c
#include <stdio.h>

// Define a structure
struct Person {
    char name[50];
    int age;
    float height;
};

int main() {
    // Declare and initialize a structure variable
    struct Person person1 = {"Alice", 30, 5.5};
    
    printf("Name: %s\n", person1.name);   // Outputs: Alice
    printf("Age: %d\n", person1.age);     // Outputs: 30
    printf("Height: %.1f\n", person1.height);  // Outputs: 5.5
    
    return 0;
}
```

**Explanation:**

* **Structure Definition:** `struct Person` defines a structure with `name`, `age`, and `height`.
* **Access Members:** Use the dot operator `.` to access members of a structure.

**Dynamic Allocation with Structures**

You can also dynamically allocate memory for structures using pointers.

```c
#include <stdio.h>
#include <stdlib.h>

// Define a structure
struct Person {
    char name[50];
    int age;
};

int main() {
    // Dynamically allocate memory for a structure
    struct Person *ptr = (struct Person *)malloc(sizeof(struct Person));
    
    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }
    
    // Initialize structure members
    ptr->age = 25;
    snprintf(ptr->name, sizeof(ptr->name), "Bob");
    
    printf("Name: %s\n", ptr->name);  // Outputs: Bob
    printf("Age: %d\n", ptr->age);    // Outputs: 25
    
    free(ptr);  // Free the allocated memory
    
    return 0;
}
```

**Explanation:**

* `malloc` allocates memory for the structure.
* Use `->` to access members of a structure via a pointer.
* `free` releases the allocated memory.

***

## **Unions**

Unions are similar to structures but differ in how they manage memory. A union allows different data types to share the same memory location.

**Declaration and Definition**

To define a union, use the `union` keyword followed by the union name and its members.

```c
#include <stdio.h>

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

int main() {
    union Data data;
    
    data.i = 10;
    printf("Data as integer: %d\n", data.i); // Outputs: 10
    
    data.f = 220.5;
    printf("Data as float: %.1f\n", data.f); // Outputs: 220.5
    printf("Data as integer: %d\n", data.i); // Outputs: Undefined (overwritten)
    
    snprintf(data.str, sizeof(data.str), "Hello");
    printf("Data as string: %s\n", data.str); // Outputs: Hello
    printf("Data as float: %.1f\n", data.f);  // Outputs: Undefined (overwritten)
    
    return 0;
}
```

**Explanation:**

* **Memory Sharing:** All members of a union share the same memory location. Changing one member affects the others.
* **Size:** The size of a union is determined by the size of its largest member.

***

#### **Comparison: Structures vs. Unions**

* **Structures:** Each member has its own memory location. Size is the sum of sizes of all members.
* **Unions:** All members share the same memory location. Size is the size of the largest member.

***

#### **Using Structures and Unions**

1. **Structures:** Ideal for cases where you need to group data but keep them distinct.
2. **Unions:** Useful when you need to store different types of data but only one at a time.

**Example: Combining Structures and Unions**

```c
#include <stdio.h>

// Define a structure with a union
struct Employee {
    char name[50];
    union {
        int id;
        char code[10];
    } identifier;
};

int main() {
    struct Employee emp;
    
    snprintf(emp.name, sizeof(emp.name), "John Doe");
    emp.identifier.id = 12345;
    
    printf("Name: %s\n", emp.name);        // Outputs: John Doe
    printf("Employee ID: %d\n", emp.identifier.id); // Outputs: 12345
    
    // If you set code, the id will be overwritten
    snprintf(emp.identifier.code, sizeof(emp.identifier.code), "E123");
    printf("Employee Code: %s\n", emp.identifier.code); // Outputs: E123
    printf("Employee ID (overwritten): %d\n", emp.identifier.id); // Outputs: Undefined (overwritten)
    
    return 0;
}
```

**Explanation:**

* **Combining:** A `struct` can contain a `union` to allow different types of data in the same structure.

***

#### **Summary**

* **Structures** group different data types into a single unit.
* **Unions** allow different data types to share the same memory location, useful for memory-efficient storage when only one type is needed at a time.
* **Dynamic Allocation** for structures allows flexible memory management.
* **Combining** structures and unions can be powerful for complex data representations.

***