Structures in C

C Programming: Organizing Data with Structures

Arrays are fantastic for storing large amounts of data, but they have one massive flaw: they only allow a single data type. You can create an array of 100 integers, or an array of 100 characters, but you cannot mix them. Real-world data rarely works this way.

Real-life example: Think of a filing cabinet at a doctor's office. A patient's physical file folder does not contain just one type of data. It holds their name (text), their age (whole number), and their exact weight (decimal).

In C programming, we build these custom file folders using Structures (the struct keyword). Structures allow you to group completely different data types together under one single, logical name.

1. The Anatomy of a Structure

Creating a structure tells the compiler to design a new, custom blueprint. Once you design the blueprint, you can build as many variables from it as you want.

// This is the blueprint. It doesn't take up memory yet.
struct Student
{
    int id;
    char name[20];
    float gpa;
};

// Now we build an actual box using that blueprint
struct Student student1;

To access or modify the data inside your new structure, you use the Dot Operator (.). For example, student1.id = 101; safely places the number 101 into that specific folder.

2. Deep Topics: Expanding Structures

To write professional, scalable code, programmers combine structures with other advanced C features.

• Array of Structures: If one structure acts as a single file folder, an array of structures acts as the entire filing cabinet. You use this to create databases. Instead of writing struct Student s1, s2, s3;, you write struct Student class[100]; to instantly create 100 folders.
• Nested Structures: You can place one structure completely inside another structure. Real-life example: An Employee structure might need an address. Instead of writing out the street, city, and zip code directly inside the employee folder, you create a separate Address structure and drop it inside the Employee structure.
• Structure Pointers: When you pass a massive structure to a function, the computer wastes time and RAM photocopying all that data. Instead, programmers use a Structure Pointer. You pass the memory address of the structure. When you use pointers with structures, you must drop the Dot Operator (.) and use the Arrow Operator (->) to access the data.

3. Problem Solving Focus: Managing Complex Data

Let us put these concepts into action by solving two real-world data management problems.

Problem 1: Student Management System

We need to store the records of multiple students and print them out. We will use an Array of Structures to build a mini-database inside the RAM.

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

// 1. Define the Blueprint
struct Student {
    int id;
    char name[30];
    float grade;
};

int main() {
    // 2. Create an array that holds 3 Student structures
    struct Student db[3];

    // 3. Manually fill the database
    db[0].id = 1;
    strcpy(db[0].name, "Alice Smith");
    db[0].grade = 92.5;

    db[1].id = 2;
    strcpy(db[1].name, "Bob Johnson");
    db[1].grade = 88.0;

    db[2].id = 3;
    strcpy(db[2].name, "Charlie Brown");
    db[2].grade = 79.5;

    // 4. Print the database using a loop
    printf("--- Student Database ---\n");
    for(int i = 0; i < 3; i++) {
        printf("ID: %d | Name: %-15s | Grade: %.1f\n", db[i].id, db[i].name, db[i].grade);
    }

    return 0;
}

Problem 2: Employee Records (Using Pointers & Nested Structs)

To make our code modular, we will create a Date structure and nest it inside an Employee structure. Then, we will use a Structure Pointer and the Arrow Operator (->) to securely modify the employee's data.

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

// Inner Structure
struct Date {
    int day;
    int month;
    int year;
};

// Outer Structure
struct Employee {
    int empId;
    char name[30];
    struct Date joinDate; // Nested structure
};

// Function accepting a pointer to prevent copying massive data blocks
void printEmployeeRecord(struct Employee *ptr) {
    // Notice the Arrow Operator (->) used with pointers!
    printf("Employee ID: %d\n", ptr->empId);
    printf("Name: %s\n", ptr->name);
    
    // We use the arrow to enter the employee, then the dot to access the date
    printf("Join Date: %02d/%02d/%d\n", ptr->joinDate.day, ptr->joinDate.month, ptr->joinDate.year);
}

int main() {
    struct Employee emp1;

    // Fill the data using standard Dot Operators
    emp1.empId = 90210;
    strcpy(emp1.name, "David Martinez");
    emp1.joinDate.day = 14;
    emp1.joinDate.month = 8;
    emp1.joinDate.year = 2021;

    // Pass the memory address to our function
    printEmployeeRecord(&emp1);

    return 0;
}

Summary: Structures

• Structures (struct) allow you to bundle variables of totally different data types under one single name.
• You define the blueprint outside of your functions, and build the actual variables inside your functions.
• You use the Dot Operator (.) to access data inside a standard structure.
• You use the Arrow Operator (->) to access data when working with a pointer to a structure.
• Nesting structures and creating arrays of structures provides the foundational logic for all modern databases.

C Programming Interview Questions (FAQs)

1. What is the fundamental difference between an Array and a Structure?

An array is a homogenous data collection. It can hold dozens of items, but every single item must be exactly the same data type (e.g., all integers). A structure is a heterogeneous data collection. It allows you to mix integers, floats, characters, and even arrays perfectly together into one single custom object.

2. Why do we use the Arrow Operator (->) instead of the Dot Operator (.) with pointers?

When you have a pointer to a structure, using the dot operator directly fails because the dot tries to look inside the pointer itself, not the memory it points to. To fix this, you must dereference the pointer first like this: (*ptr).id. Because programmers hate typing parentheses and asterisks repeatedly, the creators of C invented the arrow operator (ptr->id) as a clean, lightning-fast shortcut.