C Pointers to Structures – Access Structs Efficiently in C

Introduction – What Is a Pointer to Structure in C?

In C programming, a pointer to structure allows you to manipulate and access members of a struct using a pointer variable. Instead of working with entire structures directly, using pointers provides efficiency, especially when passing large structures to functions or working with dynamic memory.

In this guide, you’ll learn:

• How to declare and use pointers to structures
• How to access members using the arrow (->) operator
• Real-world use cases like linked lists and tree nodes
• Best practices and pitfalls to avoid

Core Concept – Struct Pointer Basics

A structure in C is a user-defined data type that groups related variables. A pointer to a structure holds the address of a structure variable.

Syntax:

struct Person {
    char name[20];
    int age;
};

struct Person p1;
struct Person *ptr = &p1;

• Access member using: (*ptr).age or ptr->age

Code Examples – Pointers to Structures in Action

Example 1: Accessing Struct Members with Pointer

#include <stdio.h>

struct Person {
    char name[20];
    int age;
};

int main() {
    struct Person p = {"Alice", 30};
    struct Person *ptr = &p;

    printf("Name: %s\n", ptr->name);
    printf("Age: %d\n", ptr->age);

    return 0;
}

Output:

Name: Alice
Age: 30

ptr->name is a shortcut for (*ptr).name

Example 2: Passing Struct Pointer to a Function

#include <stdio.h>

struct Book {
    char title[50];
    float price;
};

void display(struct Book *b) {
    printf("Title: %s\n", b->title);
    printf("Price: $%.2f\n", b->price);
}

int main() {
    struct Book myBook = {"C Programming", 29.99};
    display(&myBook);
    return 0;
}

Using a pointer avoids copying the whole structure during function calls.

Example 3: Struct Array with Pointers

#include <stdio.h>

struct Item {
    char name[20];
    int id;
};

int main() {
    struct Item items[2] = {{"Pen", 101}, {"Notebook", 102}};
    struct Item *ptr = items;

    for (int i = 0; i < 2; i++) {
        printf("Item: %s, ID: %d\n", ptr->name, ptr->id);
        ptr++;  // Move to next struct
    }

    return 0;
}

Use Cases of Struct Pointers

Best Practices & Tips

Best Practice:

• Use ptr->member instead of (*ptr).member for cleaner syntax.

Tip:

• When passing to functions, prefer struct *ptr to avoid overhead.

Pitfall:

• Ensure the pointer points to a valid memory address before dereferencing.

Real-World Applications

• Building linked lists, queues, and stacks
• Managing binary trees, graphs, and game objects
• Working with large configuration or file metadata structures
• Interfacing with hardware devices or system resources

Summary – Recap & Next Steps

Pointers to structures are essential in C for efficient memory use, clean code organization, and dynamic data structure creation. They make it easy to manipulate complex data models.

Key Takeaways:

• A struct pointer holds the address of a structure variable
• Use -> to access members via pointer
• Preferred when passing large structures to functions
• Crucial in dynamic data structures like linked lists and trees

Real-World Relevance:

Used in file handling, OS-level development, embedded systems, and compiler construction.

Frequently Asked Questions (FAQ)

What does ptr->member mean?

It accesses the member of the structure pointed to by ptr. Equivalent to (*ptr).member.

Can we use pointers with arrays of structures?

Yes. You can loop through struct arrays using a pointer and increment it (ptr++).

Why use a pointer to structure instead of direct access?

To avoid copying data, save memory, and support dynamic allocation.

Can I dynamically allocate a structure?

Yes:

struct Student *s = malloc(sizeof(struct Student));

Can a structure contain a pointer to itself?

Yes, it’s called a self-referential structure (used in linked lists).