C Programming Structures

What Are Structures in C?

Structures in C are user-defined data types that group variables of different data types under a single name. They are defined using the struct keyword and are ideal for representing records, such as a student’s details or a book’s information. Unlike arrays, which store elements of the same type, structures can hold mixed data types (see C Arrays).

Key characteristics of structures include:

• Grouping: Combine variables like int, float, or char into one unit.
• Access: Members are accessed using the dot operator (.) or arrow operator (->) for pointers.
• Flexibility: Support nesting and can be passed to functions or used with pointers.

Structures rely on data types (see C Data Types) and are often used with pointers (see C Pointers) for advanced applications.

Core Concepts of Structures

Structures involve several key concepts, each critical for their effective use in C. We’ll cover these in detail.

1. Declaring and Defining Structures

A structure is defined using the struct keyword, followed by a name and a block of member variables. You can declare structure variables at definition or separately.

• Definition: struct Student { int id; char name[50]; float gpa; }; – Defines a structure type.
• Variable Declaration: struct Student s1; – Declares a variable of type struct Student.
• Combined: struct Student { int id; char name[50]; float gpa; } s1, s2; – Defines and declares variables.

#include <stdio.h>

struct Book {
    char title[100];
    int pages;
};

int main() {
    struct Book b1; // Declare structure variable
    printf("Size of struct Book: %zu bytes\n", sizeof(struct Book));

    return 0;
}
            

Output:

Size of struct Book: [size in bytes]
            

Note: The size depends on the system and may include padding for alignment.

2. Initializing Structures

Structures can be initialized at declaration or by assigning values to individual members.

• At Declaration: struct Student s1 = {101, "Alice", 3.8}; – Initializes members in order.
• Member Assignment: s1.id = 101; strcpy(s1.name, "Alice"); s1.gpa = 3.8; – Assigns values individually.
• Partial Initialization: struct Student s1 = {101}; – Initializes id, sets others to 0 or null.

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

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

int main() {
    struct Student s1 = {101, "Alice", 3.8};
    printf("Student: ID=%d, Name=%s, GPA=%.2f\n", s1.id, s1.name, s1.gpa);

    return 0;
}
            

Output:

Student: ID=101, Name=Alice, GPA=3.80
            

3. Accessing Structure Members

Structure members are accessed using the dot operator (.) for variables and the arrow operator (->) for pointers to structures.

• Dot Operator: s1.id – Accesses the id member of s1.
• Arrow Operator: ptr->id – Accesses the id member via a pointer.

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    struct Point p1 = {5, 10};
    struct Point *ptr = &p1;

    printf("Using dot: (%d, %d)\n", p1.x, p1.y);
    printf("Using arrow: (%d, %d)\n", ptr->x, ptr->y);

    return 0;
}
            

Output:

Using dot: (5, 10)
Using arrow: (5, 10)
            

4. Nested Structures

Structures can contain other structures, allowing complex data organization. Nested structures are defined either by embedding a structure or using a separate structure type.

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

struct Date {
    int day;
    int month;
    int year;
};

struct Employee {
    char name[50];
    struct Date hire_date;
};

int main() {
    struct Employee emp = {"Bob", {15, 6, 2023}};
    printf("Employee: %s, Hired: %d/%d/%d\n",
           emp.name, emp.hire_date.day, emp.hire_date.month, emp.hire_date.year);

    return 0;
}
            

Output:

Employee: Bob, Hired: 15/6/2023
            

5. Pointers to Structures

Pointers to structures are used to efficiently pass structures to functions or dynamically allocate memory for structures.

• Declaration: struct Student *ptr; – Declares a pointer to a structure.
• Dynamic Allocation: ptr = (struct Student *)malloc(sizeof(struct Student)); – Allocates memory for a structure.

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

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

int main() {
    struct Student *ptr = (struct Student *)malloc(sizeof(struct Student));
    if (ptr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    ptr->id = 102;
    strcpy(ptr->name, "Charlie");
    printf("Student: ID=%d, Name=%s\n", ptr->id, ptr->name);

    free(ptr);
    ptr = NULL;

    return 0;
}
            

Output:

Student: ID=102, Name=Charlie
            

6. Passing Structures to Functions

Structures can be passed to functions by value or by reference (using pointers). Passing by reference is more efficient for large structures.

• By Value: Copies the entire structure, which can be memory-intensive.
• By Reference: Passes a pointer, allowing modification of the original structure.

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

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

void update_student(struct Student *s, int new_id, char *new_name) {
    s->id = new_id;
    strcpy(s->name, new_name);
}

int main() {
    struct Student s1 = {103, "David"};
    update_student(&s1, 104, "Eve");
    printf("Updated Student: ID=%d, Name=%s\n", s1.id, s1.name);

    return 0;
}
            

Output:

Updated Student: ID=104, Name=Eve
            

7. Arrays of Structures

Arrays of structures allow storing multiple records, such as a list of students or employees.

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

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

int main() {
    struct Student students[3] = {
        {101, "Alice"},
        {102, "Bob"},
        {103, "Charlie"}
    };

    for (int i = 0; i < 3; i++) {
        printf("Student %d: ID=%d, Name=%s\n", i + 1, students[i].id, students[i].name);
    }

    return 0;
}
            

Output:

Student 1: ID=101, Name=Alice
Student 2: ID=102, Name=Bob
Student 3: ID=103, Name=Charlie
            

8. Typedef with Structures

The typedef keyword creates an alias for a structure, simplifying declarations.

#include <stdio.h>

typedef struct {
    int x;
    int y;
} Point;

int main() {
    Point p1 = {7, 8}; // No need for 'struct' keyword
    printf("Point: (%d, %d)\n", p1.x, p1.y);

    return 0;
}
            

Output:

Point: (7, 8)
            

Why Are Structures Important?

Structures are critical for the following reasons:

1. Data Organization: Group related data, making complex programs easier to manage.
2. Flexibility: Support mixed data types, nesting, and pointers for versatile applications.
3. Efficiency: Enable passing large data sets to functions via pointers, reducing memory overhead.
4. Real-World Modeling: Represent real-world entities like records or objects in programs.

Tips for Using Structures

• Use Meaningful Names: Choose descriptive structure and member names, e.g., struct Student with id, name (see C Identifiers).
• Initialize Structures: Always initialize structure members to avoid garbage values, e.g., struct Student s1 = {0};.
• Use Pointers for Efficiency: Pass structures to functions using pointers to avoid copying large data.
• Check Dynamic Allocation: Verify malloc returns a valid pointer before use, and free memory afterward.
• Add Comments: Document structure purpose and members with comments (see C Comments).
• Use Typedef for Simplicity: Simplify structure declarations with typedef for cleaner code.

Example: Using Structures in a Program

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

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

// Function to print student details
void print_student(Student *s) {
    printf("Student: ID=%d, Name=%s, GPA=%.2f\n", s->id, s->name, s->gpa);
}

int main() {
    // Array of structures with dynamic allocation
    Student *class = (Student *)malloc(2 * sizeof(Student));
    if (class == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Initialize students
    class[0].id = 101;
    strcpy(class[0].name, "Alice");
    class[0].gpa = 3.9;
    class[1].id = 102;
    strcpy(class[1].name, "Bob");
    class[1].gpa = 3.7;

    // Print using function
    for (int i = 0; i < 2; i++) {
        print_student(&class[i]);
    }

    free(class);
    class = NULL;

    return 0;
}
            

Output:

Student: ID=101, Name=Alice, GPA=3.90
Student: ID=102, Name=Bob, GPA=3.70
            

This example demonstrates a structure with typedef, an array of structures, dynamic memory allocation, and passing structures to functions via pointers.

Did You Know?

• Structures in C were introduced to support structured programming, as outlined in The C Programming Language by Kernighan and Ritchie.
• Padding in structures may add extra bytes to align members, affecting sizeof results.
• Structures are the foundation for complex data structures like linked lists and trees when combined with pointers.