Structure and Union in C

Structure and union in C programming are two powerful mechanisms for organizing and manipulating related data elements. Both structures and unions allow programmers to create custom data types that can hold multiple pieces of data of different types. However, they have distinct differences in how they allocate memory and how their members are accessed. Let’s delve into structures and unions in C.

Structure in C:

A structure in C is a user-defined data type that can hold multiple variables of different data types. It’s particularly useful when you want to represent a real-world entity or a group of related data items.

Structure in C provide a way to define a composite data type that groups together variables of different types under a single name. This concept allows programmers to create custom data structures to represent complex entities more efficiently.


The syntax for defining a structure in C is as follows:

struct structure_name {
    type member1;
    type member2;
    // More members if needed

Here’s a breakdown of the syntax elements:

  • struct: This keyword is used to define a structure.
  • structure_name: It’s the name of the structure.
  • member1, member2, etc.: These are variables of different data types that collectively form the structure.


Let’s define a structure to represent a simple employee record:

struct Employee {
    int employeeId;
    char name[50];
    float salary;

In this example:

  • Employee is the name of the structure.
  • employeeId, name, and salary are its members, representing an employee’s ID, name, and salary, respectively.

Accessing Structure Members:

You can access structure members using the dot ( . ) operator. Here’s how you can declare a structure variable and access its members:

struct Employee emp1;
emp1.employeeId = 101;
strcpy(, "John Doe");
emp1.salary = 50000.0;

Initializing Structure Variables:

You can initialize structure variables during declaration using curly braces {}:

struct Employee emp2 = {102, "Jane Smith", 60000.0};

Arrays of Structure:

You can create arrays of structure to store multiple records of the same type. For instance:

struct Employee employees[100];

This declaration creates an array of 100 Employee structures.

Passing Structure to Functions:

You can pass structure to functions by value or by reference. When passed by value, a copy of the structure is passed to the function. When passed by reference, you pass a pointer to the structure. This allows the function to modify the original structure. Here’s an example:

void displayEmployee(struct Employee emp) {
printf("Employee ID: %d\n", emp.employeeId);
printf("Name: %s\n",;
printf("Salary: %.2f\n", emp.salary);

int main() {
struct Employee emp = {101, "John Doe", 50000.0};
return 0;

Benefits of Using Structure:

  • Organization: Structures help organize related data items into a single unit.
  • Readability: They improve code readability by providing a clear representation of complex data.
  • Modularity: Structures facilitate modular programming by allowing you to encapsulate data and operations on that data within a single unit.
  • Reusability: Once defined, structures can be reused across multiple parts of a program.

Union in C-

A union in C is a user-defined data type similar to a structure, but with a crucial difference: it allocates memory to hold only one of its members at a time, sharing the same memory location for all its members. This means that a union can hold data of different types but only one piece of data is active or “in use” at any given time.


The syntax for defining a union in C is similar to that of a structure:

union union_name {
    type member1;
    type member2;
    // More members if needed


  • union is the keyword used to define a union.
  • union_name is the name of the union.
  • member1, member2, etc., are variables of different data types that share the same memory location.


Let’s define a union to represent either an integer or a float:

union Number {
    int intValue;
    float floatValue;

In this union:

  • intValue is of type int.
  • floatValue is of type float.
  • Both share the same memory location, and only one of them can be active at any given time.

Accessing Union Members:

You can access union members in the same way you would access structure members, using the dot ( . ) operator. However, it’s important to note that only one member should be accessed at a time.

union Number num;
num.intValue = 10; // Assigning an integer value
printf("Integer value: %d\n", num.intValue);

num.floatValue = 3.14; // Assigning a float value
printf("Float value: %f\n", num.floatValue);

Size of Union:

A union’s size is determined by the size of its largest member. This is because the union reserves enough memory to accommodate the largest data type it can hold.

Use Cases:

Unions are useful in scenarios where you need to represent different types of data using the same memory space. Some common use cases include:

  1. Representing variant data types, such as in parsers or data serialization.
  2. Efficiently managing memory when a data structure can hold different types of data at different times.
  3. Implementing type punning, where you interpret the bits of one type as another type.

Benefits and Considerations:

  • Memory Efficiency: Unions can be memory-efficient since they share memory space among their members.
  • Flexibility: They provide flexibility in representing different types of data without the need for separate variables.
  • Careful Usage: However, care must be taken when accessing union members to ensure that the correct member is being accessed at any given time. Improper usage can lead to undefined behavior and bugs.

Differences between Structure and Union in C:

Memory Allocation

  • Structures allocate memory separately for each member, resulting in memory allocation equal to the sum of the sizes of all members.
  • Unions allocate memory that is large enough to hold the largest member.

Accessing Members:

  • In structures, each member retains its own memory location, and you can access members independently using the dot (.) operator.
  • In unions, all members share the same memory location, and changing the value of one member affects the others.


  • Structures are typically used when you want to group related data elements together.
  • Unions are useful when you need to store different types of data in the same memory location, and only one member needs to be active at a time.

Example Usage:

#include <stdio.h>

struct Rectangle {
    int length;
    int width;

union Value {
    int intValue;
    float floatValue;

int main() {
    struct Rectangle rect;
    rect.length = 10;
    rect.width = 5;

    printf("Rectangle: length = %d, width = %d\n", rect.length, rect.width);

    union Value val;
    val.intValue = 10;
    printf("Integer value: %d\n", val.intValue);

    val.floatValue = 3.14;
    printf("Float value: %f\n", val.floatValue);

    return 0;

In this example, we define a structure Rectangle to represent a rectangle’s dimensions and a union Value to store either an integer or a float value. We demonstrate how to declare variables of these types and access their members.


In summary, structures and unions are fundamental constructs in C that allow for flexible organization and manipulation of data. Understanding their differences and appropriate usage can greatly enhance your programming capabilities.