🏗️ 14. Structures & Unions

So far, you have worked with individual values such as int, float, char, arrays and pointers.

But real programs often need to represent an entity containing different kinds of information.

For example, a student may have:

• Student ID → int
• Name → character array
• Marks → float
• Age → int

A structure lets us group these related members into one object.

A union also groups different members, but its members share the same storage.

14.1 What Is a Structure?

A structure is a user-defined type that groups related data items, called members, under one object.

The members can have different data types.

struct Student { int id; char name[50]; float marks; };

This defines a structure type named struct Student.

It defines the fields each student record will have. A separate object declaration creates storage for a particular student.

14.2 Why Are Structures Needed?

Suppose you want to store information about three students. Without structures, you might create separate variables:

int id1, id2, id3; char name1[50]; char name2[50]; char name3[50]; float marks1, marks2, marks3;

This becomes difficult to organize.

With structures:

struct Student students[3];

Each array element represents one complete student record.

14.3 Structure Syntax

struct StructureName { data_type member1; data_type member2; data_type member3; };

Example:

struct Employee { int id; char name[40]; float salary; };

The keyword struct introduces a structure specification.

The name after struct is called the tag.

14.4 Creating Structure Variables

After defining the structure type, create objects using:

struct Student s1; struct Student s2;

Now s1 and s2 are two separate structure objects.

struct Student { int id; float marks; }; int main(void) { struct Student s1; s1.id = 101; s1.marks = 85.5f; return 0; }

 struct Student s1 ┌───────────────────────────────┐ │ id │ 101 │ ├──────────┼────────────────────┤ │ marks │ 85.5 │ └───────────────────────────────┘ s1 is one complete Student object. Each member has its own storage. 

14.5 Accessing Structure Members with .

The dot operator . is used to access a member of a structure object.

s1.id s1.marks

Example:

#include <stdio.h>

struct Student {
    int id;
    float marks;
};
int main(void) {
    struct Student s;
    s.id = 101;
    s.marks = 92.5f;
    printf("ID = %d\n", s.id);
    printf("Marks = %.2f\n", s.marks);
    return 0;
}

14.6 Initializing Structures

A structure object can be initialized when it is created.

struct Student s = {101, 85.5f};

With positional initialization, each value initializes the corresponding member in declaration order. A designated initializer names its member explicitly.

struct Student { int id; float marks; }; struct Student s = {101, 85.5f};

Therefore:

s.id → 101 s.marks → 85.5

struct Student s = { .marks = 85.5f, .id = 101 };

14.7 Updating Structure Members

Structure members can be changed just like ordinary variables.

struct Student s = {101, 80.0f}; s.marks = 90.0f;

After the assignment:

s.id = 101 s.marks = 90.0

The complete structure object remains the same object; only one member is changed.

14.8 Program Tracing: Structure Members

struct Student { int id; int marks; }; int main(void) { struct Student s; s.id = 101; s.marks = 85; s.marks = s.marks + 5; return 0; }

 Step 1 struct Student s; ┌──────────────────────┐ │ id │ ? │ ├───────┼──────────────┤ │ marks │ ? │ └──────────────────────┘ Step 2 s.id = 101; ┌──────────────────────┐ │ id │ 101 │ ├───────┼──────────────┤ │ marks │ ? │ └──────────────────────┘ Step 3 s.marks = 85; ┌──────────────────────┐ │ id │ 101 │ ├───────┼──────────────┤ │ marks │ 85 │ └──────────────────────┘ Step 4 s.marks = s.marks + 5; ┌──────────────────────┐ │ id │ 101 │ ├───────┼──────────────┤ │ marks │ 90 │ └──────────────────────┘ 

14.9 Understanding the Structure Tag

struct Student { int id; float marks; };

Here Student is the structure tag.

You normally write the type as:

struct Student

not simply:

Student

14.10 Structure Definition vs Structure Variable

Type definition:

struct Book { int pages; float price; };

Object declaration:

struct Book b1;

The first describes the type. The second creates an object.

Both can also be written together:

struct Book { int pages; float price; } b1, b2;

14.11 Multiple Structure Variables

struct Point { int x; int y; }; int main(void) { struct Point p1 = {10, 20}; struct Point p2 = {30, 40}; printf("%d %d\n", p1.x, p1.y); printf("%d %d\n", p2.x, p2.y); return 0; }

Changing a member of s1 does not change the corresponding member of a separate s2 object. Each structure object holds its own record.

 p1 ┌───────────────┐ │ x = 10 │ │ y = 20 │ └───────────────┘ p2 ┌───────────────┐ │ x = 30 │ │ y = 40 │ └───────────────┘ p1 and p2 are separate objects. 

14.12 Structure Assignment

Two structure objects of compatible structure type can be assigned to each other.

struct Student { int id; float marks; }; int main(void) { struct Student s1 = {101, 85.0f}; struct Student s2; s2 = s1; printf("%d %.2f\n", s2.id, s2.marks); return 0; }

The member values are copied, including the elements of an array member. A character array inside the structure therefore gets its own copied characters.

14.13 Can We Compare Structures with ==?

C does not provide direct == or != operators for comparing complete structure objects.

Compare the fields that define equality for your application. Compare a character-array name with strcmp, not ==. Do not use memcmp as a general replacement: padding bytes can differ even when member values compare equal.

if (s1.id == s2.id && s1.marks == s2.marks) { printf("Same selected values"); }

14.14 Nested Structures

A structure can contain another structure as a member.

struct Date { int day; int month; int year; }; struct Student { int id; struct Date dob; };

Access nested members using multiple dot operators:

student.dob.day student.dob.month student.dob.year

Example:

struct Student s = { 101, {15, 8, 2004} }; printf("%d\n", s.dob.year);

Output:

2004

14.15 Array of Structures

An array of structures stores several complete records. For example, students[2].marks is the marks member of the third student, because array indexes start at zero.

struct Student { int id; float marks; }; struct Student students[3];

Access an element and its member using:

students[0].id students[0].marks students[1].id students[1].marks

Example

#include <stdio.h>

struct Student {
    int id;
    int marks;
};
int main(void) {
    struct Student students[3] = {
        {
            101, 78
        }, {
            102, 91
        }, {
            103, 84
        }
    };
    for (int i = 0; i < 3; i++) {
        printf("ID = %d, Marks = %d\n", students[i].id, students[i].marks);
    }
    return 0;
}

 students Index 0 ┌──────────────────┐ │ id = 101 │ │ marks = 78 │ └──────────────────┘ Index 1 ┌──────────────────┐ │ id = 102 │ │ marks = 91 │ └──────────────────┘ Index 2 ┌──────────────────┐ │ id = 103 │ │ marks = 84 │ └──────────────────┘ 

14.16 Structures with Functions

A structure can be passed to a function just like other values.

#include <stdio.h>

struct Student {
    int id;
    float marks;
};
void display(struct Student s) {
    printf("ID = %d\n", s.id);
    printf("Marks = %.2f\n", s.marks);
}
int main(void) {
    struct Student s = {
        101, 88.5f
    };
    display(s);
    return 0;
}

Here the structure is passed by value.

The function receives its own parameter object containing the copied structure value.

14.17 Passing a Structure by Value

struct Point { int x; int y; }; void change(struct Point p) { p.x = 100; } int main(void) { struct Point point = {10, 20}; change(point); printf("%d\n", point.x); return 0; }

The output remains:

10

Why?

The parameter is a separate structure object. Changing its ordinary members changes only that copy. A copied pointer member can still be used to reach shared data, so distinguish the member from its target.

14.18 Passing a Structure Using a Pointer

If a function needs to modify the original structure, pass its address.

#include <stdio.h>

struct Student {
    int id;
    int marks;
};
void updateMarks(struct Student *p) {
    p->marks = 95;
}
int main(void) {
    struct Student s = {
        101, 80
    };
    updateMarks(&s);
    printf("Marks = %d\n", s.marks);
    return 0;
}

Output:

Marks = 95

The pointer allows the function to access the original structure object.

14.19 The -> Operator

When you have a pointer to a structure, use -> to access its members.

p->marks

This is equivalent to:

(*p).marks

 struct Student s = {101, 85}; struct Student *p = &s; p │ │ stores address of s ▼ ┌───────────────────────────────┐ │ s │ ├──────────────┬────────────────┤ │ id │ 101 │ ├──────────────┼────────────────┤ │ marks │ 85 │ └──────────────┴────────────────┘ p->marks │ └──── accesses s.marks p->marks == (*p).marks 

14.20 . vs ->

14.21 Modifying a Structure Through a Pointer

struct Employee { int id; float salary; }; int main(void) { struct Employee e = {101, 45000.0f}; struct Employee *p = &e; p->salary = 50000.0f; printf("%.2f\n", e.salary); return 0; }

Since p points to e, modifying p->salary modifies e.salary.

14.22 Returning a Structure from a Function

A function can return a structure value.

#include <stdio.h>

struct Point {
    int x;
    int y;
};
struct Point createPoint(int x, int y) {
    struct Point p = {
        x, y
    };
    return p;
}
int main(void) {
    struct Point result;
    result = createPoint(10, 20);
    printf("(%d, %d)\n", result.x, result.y);
    return 0;
}

Returning the structure by value is valid.

14.23 Structure Size and sizeof

You can determine the size of a structure object using sizeof.

printf("%zu\n", sizeof(struct Student));

But do not assume that the structure size is always exactly the sum of the sizes of its members.

The implementation may insert padding bytes to satisfy alignment requirements.

 Possible memory layout ┌───────────────┐ │ member A │ ├───────────────┤ │ padding │ ├───────────────┤ │ member B │ ├───────────────┤ │ padding │ └───────────────┘ Padding depends on the implementation, member types and alignment requirements. 

14.24 Structure Alignment and Padding

Some types must start at suitable byte boundaries. The implementation may leave padding between members or after the last member. Use sizeof instead of adding member sizes yourself.

struct Example { char c; int x; };

It is possible for padding to appear between c and x.

The exact layout is implementation-dependent.

14.25 typedef with Structures — Preview

C also allows a type alias to be created with typedef.

typedef struct { int id; float marks; } Student;

Then:

Student s1;

instead of:

struct Student s1;

14.26 Bit-Fields — Advanced Preview

A bit-field requests a given number of bits for a member. For example, unsigned int enabled : 1 can store the values 0 and 1.

struct Flags { unsigned int ready : 1; unsigned int mode : 2; };

Bit-fields are useful in some low-level programming, embedded systems and hardware-oriented code.

14.27 What Is a Union?

A union is another user-defined type that contains multiple members.

The key difference is that the members share the same storage.

union Data { int number; float price; char letter; };

A union object has storage that is shared by its members.

14.28 Union Syntax

union UnionName { data_type member1; data_type member2; data_type member3; };

Example:

union Data { int number; float price; };

Create an object:

union Data data;

14.29 Union Memory Sharing

 union Data data ┌───────────────────────────────┐ │ │ │ SHARED STORAGE │ │ │ │ number / price / letter │ │ │ └───────────────────────────────┘ All members refer to overlapping storage. They do not each get an independent copy of the storage. 

For example:

union Data d; d.number = 100;

The union storage now contains the representation written through number.

If you then write:

d.price = 12.5f;

the shared storage changes again. The old integer and new floating-point value are not kept as independent values. In beginner code, read the member that was most recently written.

14.30 Initializing a Union

A union can be initialized when it is declared.

union Data { int number; float price; }; union Data d = {25};

Without a designated initializer, the first named member is initialized.

A designated initializer can explicitly select a member:

union Data d = { .price = 12.5f };

14.31 Accessing Union Members

Union members are accessed with the same dot operator used for structure objects.

union Data d; d.number = 50; printf("%d\n", d.number);

The syntax is:

unionObject.member

The difference is not the member-access operator. The difference is how the members occupy storage.

14.32 Program Tracing: Union Storage

union Data { int number; float price; }; int main(void) { union Data d; d.number = 100; d.price = 12.5f; return 0; }

 Step 1 d.number = 100 ┌────────────────────────────┐ │ shared storage │ │ representation of 100 │ └────────────────────────────┘ Step 2 d.price = 12.5f ┌────────────────────────────┐ │ shared storage │ │ representation of 12.5f │ └────────────────────────────┘ The second write uses the same storage. The integer value 100 is not independently preserved as another member value. 

14.33 Structure vs Union

 STRUCTURE ┌──────────────┐ │ int id │ ├──────────────┤ │ float marks │ ├──────────────┤ │ char grade │ └──────────────┘ Members occupy different regions. UNION ┌──────────────┐ │ │ │ shared │ │ storage │ │ │ └──────────────┘ Members overlap. 

14.34 When Should You Use a Structure?

Use a structure when multiple pieces of information need to exist together as one complete object.

14.35 When Should You Use a Union?

Use a union when a value has several possible forms but the program needs one form at a time. If the ID, name, and marks must all exist together, use a structure instead.

Typical examples include:

• Variant data representations
• Memory-constrained systems
• Low-level systems programming
• Hardware-oriented representations

14.36 Tagged Union Concept

A common design pattern combines an enum-like tag with a union.

enum DataType { TYPE_INT, TYPE_FLOAT }; struct Value { enum DataType type; union { int number; float price; } data; };

The type member tells the program which union member should be interpreted as the current value.

 Value │ ├── type │ ├── TYPE_INT │ └── TYPE_FLOAT │ └── data ├── number └── price 

For example, a tag can say whether the union currently stores an integer or a float. The program checks the tag and uses the matching member; C does not enforce that match automatically.

14.37 Program Tracing: Pointer to Structure

struct Student { int id; int marks; }; int main(void) { struct Student s = {101, 85}; struct Student *p = &s; p->marks = 90; return 0; }

 Initial object s ┌────────────────────┐ │ id = 101 │ │ marks = 85 │ └────────────────────┘ After: p = &s p ───────────────► s │ ├── id = 101 └── marks = 85 After: p->marks = 90 p ───────────────► s │ ├── id = 101 └── marks = 90 

The pointer does not create another structure object. It points to the existing one.

14.38 Complete Program: Student Record

#include <stdio.h>

struct Student {
    int id;
    char name[50];
    float marks;
};
int main(void) {
    struct Student student;
    printf("Enter ID: ");
    scanf("%d", &student.id);
    printf("Enter name: ");
    scanf("%49s", student.name);
    printf("Enter marks: ");
    scanf("%f", &student.marks);
    printf("\nStudent Record\n");
    printf("ID = %d\n", student.id);
    printf("Name = %s\n", student.name);
    printf("Marks = %.2f\n", student.marks);
    return 0;
}

What happens?

1. A structure type named Student is defined.
2. A structure object named student is created.
3. The ID is stored in student.id.
4. The name is stored in student.name.
5. The marks are stored in student.marks.
6. Each member is accessed using the dot operator.

14.39 Complete Program: Structure + Function + Pointer

#include <stdio.h>

struct Student {
    int id;
    int marks;
};
void addBonus(struct Student *student) {
    student->marks += 5;
}
void display(struct Student student) {
    printf("ID = %d\n", student.id);
    printf("Marks = %d\n", student.marks);
}
int main(void) {
    struct Student s = {
        101, 85
    };
    addBonus(&s);
    display(s);
    return 0;
}

This small program combines three important concepts:

14.40 Common Mistakes

Student s;

struct Student s;

s->marks;

s.marks;

p.marks;

p->marks;

if (s1 == s2)

14.41 Common Confusions

14.42 Structure Memory Model

 struct Employee e e │ ▼ ┌────────────────────────────────┐ │ id │ ├────────────────────────────────┤ │ name[] │ ├────────────────────────────────┤ │ salary │ ├────────────────────────────────┤ │ possible trailing padding │ └────────────────────────────────┘ Each member has its own storage, although padding may also be present. 

For an array of structures, the complete structure object forms each array element.

struct Employee employees[3];

Conceptually:

employees[0] employees[1] employees[2]

Each array element includes space for the complete structure and any padding. Moving to the next element advances by sizeof the structure, not by a hand-calculated sum of its member sizes.