C Structure & Union

struct Point {
    int x;
    int y;
};

struct Address {
    char street[50];
    char city[30];
    char state[20];
    char zip[10];
};

struct Person {
    char name[50];
    int age;
    struct Address address;
};

C Union

a union is a composite data type similar to a structure, but with a significant difference. While a structure allows you to group together variables of different data types under a single name, a union allows you to use the same memory location to store different types of data. In a union, all members share the same memory space, and only one of its members can contain a value at any given time.

Here's a simple example of a C union:

union Number {
    int intValue;
    double doubleValue;
};

In this example, the "Number" union has two members, "intValue" and "doubleValue." However, only one of them can be used at a time to store a value.

Nested Union:

You can create nested unions within structures or other unions, just as you can with structures. This allows you to create complex data structures that can represent various data types within one another. Nested unions can be useful in situations where you need to store and manage data with different structures at different levels of hierarchy.

struct Employee {
    int empID;
    char name[50];
    union {
        int hourlyWage;
        double annualSalary;
    } salary;
};

In this example, we have defined a structure "Employee" that contains an integer "empID," a character array "name," and a nested union called "salary." The "salary" union has two members: "hourlyWage" and "annualSalary," which represent different ways to express an employee's compensation.

Note: The structure & union definition ends with a semicolon (;) after the closing brace.

Structure vs Union

Both 'struct' and 'union' are used to create custom data types that can hold multiple variables of different data types. However, they have some key differences in how they allocate memory and store data:

struct	union
A 'struct' allocates memory for each member variable independently. This means that the size of a 'struct' is the sum of the sizes of its members. Each member of a 'struct' has its own memory location.	A 'union' allocates enough memory to hold the largest member variable. All members share the same memory location, and only one member can hold a value at any given time. The size of a 'union' is determined by the size of its largest member.
All member variables in a 'struct' can hold data simultaneously. Each member has its own memory space, and you can access all of them individually.	A 'union' can hold data in only one member at a time. Writing to one member of the 'union' will overwrite the data in the previously used member. Reading from a member will give you the value that was last written to that member.

The '.' Dot Operator

The dot ('.') or period operator is used to access members of a structure or a union. It allows you to access individual variables or fields within a structure or union by specifying the structure/union variable followed by a dot and the name of the member you want to access.

Here's the general syntax for using the dot operator:

structure_variable.member_name

For example, if you have a structure named 'Person':

struct Person {
    char name[50];
    int age;
    float height;
};

You can access its members like this:

struct Person person1;
person1.age = 28;
strcpy(person1.name, "Ayan");
person1.height = 179.83;

In this example, we use the dot operator to access the 'age', 'name', and 'height' members of the 'person1' structure variable.

* If you want to access members of a structure or union through a pointer to the structure or union, you would use the -
arrow operator ('->').