Structures in C are used to store multiple related variables of different data types under a single name. In many situations, especially when working with large structures, passing entire structure variables can be inefficient. To solve this problem, C allows pointers to structures.
A pointer to a structure stores the memory address of a structure variable instead of storing the actual data. This approach improves memory efficiency, simplifies data manipulation, and is widely used in dynamic memory allocation, linked lists, trees, and other advanced data structures.
 

Table of Contents

---

 

What are Pointers to Structures in C?

A pointer to a structure is a pointer variable that stores the address of a structure variable. Instead of directly accessing the structure, the pointer can be used to access and modify its members.
For example, if a structure variable stores employee information, a structure pointer can store the address of that employee record and access its members whenever required.
Syntax:

struct structure_name *pointer_name;

Example:

struct Student
{
    int rollNo;
    float marks;
};

struct Student *ptr;

Explanation:
In this example, ptr is a pointer that can store the address of a structure variable of type Student. However, it does not point to any valid structure until an address is assigned to it.

Initializing a Structure Pointer

A structure pointer is usually initialized by storing the address of a structure variable.
Example:

// C program to initialize a structure pointer
#include stdio.h

struct Student
{
    int rollNo;
    float marks;
};

int main()
{
    struct Student s1 = {101, 89.5};

    struct Student *ptr = &s1;

    printf("Address of s1: %p\n", &s1);
    printf("Value stored in ptr: %p\n", ptr);

    return 0;
}

Output:

Address of s1: 0x7ffd12345678
Value stored in ptr: 0x7ffd12345678

Explanation:
The pointer ptr stores the address of the structure variable s1. Both addresses displayed in the output are the same because the pointer points to the structure variable.

Accessing Structure Members Using Arrow Operator

The arrow (-) operator is used to access structure members through a pointer. It provides a simple and readable way to work with structure pointers.
Syntax:

pointer_name-member_name

Example:

// C program to access structure members using 
// arrow operator
Example Program
#include stdio.h

struct Student
{
    int rollNo;
    float marks;
};

int main()
{
    struct Student s1 = {101, 95.5};

    struct Student *ptr = &s1;

    printf("Roll Number: %d\n", ptr-rollNo);
    printf("Marks: %.2f\n", ptr-marks);

    return 0;
}

Output:

Roll Number: 101
Marks: 95.50

Explanation:
The pointer ptr stores the address of s1. The arrow operator accesses the members of the structure through the pointer. This is the most common method used when working with structure pointers.

Accessing Structure Members Using Dereference Operator

Structure members can also be accessed using the dereference operator (*) along with the dot operator.
Example:

// C program to access structure members using 
// dereference operator
#include stdio.h

struct Student
{
    int rollNo;
    float marks;
};

int main()
{
    struct Student s1 = {101, 90.5};

    struct Student *ptr = &s1;

    printf("Roll Number: %d\n", (*ptr).rollNo);
    printf("Marks: %.2f\n", (*ptr).marks);

    return 0;
}

Output:

Roll Number: 101
Marks: 90.50

Explanation:
The expression (*ptr).rollNo first dereferences the pointer and then accesses the member using the dot operator. Although this method works correctly, the arrow operator is generally preferred because it is shorter and easier to read.

Structure Pointer with Functions

Structure pointers are commonly passed to functions because they avoid copying the entire structure and improve program efficiency.
Example:

// C program to implement structure pointers 
// with functions
#include stdio.h

struct Student
{
    int rollNo;
    float marks;
};

void display(struct Student *ptr)
{
    printf("Roll Number: %d\n", ptr-rollNo);
    printf("Marks: %.2f\n", ptr-marks);
}

int main()
{
    struct Student s1 = {101, 88.5};

    display(&s1);

    return 0;
}

Output:

Roll Number: 101
Marks: 88.50

Explanation:
The address of the structure variable is passed to the function. The function accesses the members using the arrow operator without creating a copy of the entire structure.

Difference Between Structure Variable and Structure Pointer

Basis of Comparison	Structure Variable	Structure Pointer
Storage	A structure variable stores actual data.	A structure pointer stores the address of a structure variable.
Memory Usage	It requires memory for all structure members.	It requires memory only for storing an address.
Access Method	Members are accessed using the dot operator.	Members are accessed using the arrow operator.
Data Handling	Data is accessed directly.	Data is accessed indirectly through an address.
Usage	Suitable for simple programs.	Suitable for dynamic memory allocation and large applications.

Advantages of Structure Pointers

1. Better Memory Efficiency: A structure pointer stores only the address of a structure variable. This reduces memory usage, especially when dealing with large structures.
2. Faster Function Calls: Passing a structure pointer to a function avoids copying the entire structure. As a result, function calls become more efficient.
3. Supports Dynamic Memory Allocation: Structure pointers can be used with functions such as malloc() and calloc() to create structures dynamically at runtime.
4. Essential for Data Structures: Advanced data structures such as linked lists, trees, stacks, and queues rely heavily on structure pointers for linking nodes together.
5. Easy Data Modification: Changes made through a structure pointer directly affect the original structure variable because both refer to the same memory location.

Common Mistakes While Using Structure Pointers

1. Accessing an Uninitialized Structure Pointer: Using a structure pointer without assigning it a valid address can lead to undefined behavior.

Incorrect Code:
struct Student *ptr;
printf("%d", ptr-rollNo);

Explanation:
The pointer does not point to a valid structure object. It should be initialized before use.

2. Using Dot Operator Instead of Arrow Operator: Many beginners mistakenly use the dot operator with structure pointers.

Incorrect Code:
ptr.rollNo;
Correct Code:
ptr-rollNo;

Explanation:
The arrow operator must be used when accessing members through a structure pointer.

3. Dereferencing a Null Pointer: Accessing members through a null pointer can cause program crashes.
Example:

struct Student *ptr = NULL;
printf("%d", ptr-rollNo);

Explanation:
Always ensure that the pointer points to a valid structure before accessing its members.

4. Forgetting Parentheses with Dereference Operator: Incorrect placement of parentheses can change the meaning of an expression.

Incorrect Code:
*ptr.rollNo
Correct Code:
(*ptr).rollNo

Explanation:
The dereference operator must be applied to the pointer before accessing the member.

5. Assigning Incorrect Address Types: A structure pointer should only store the address of a compatible structure type.

Incorrect Code:
int num = 10;
struct Student *ptr = #

Explanation:
This assignment is invalid because the pointer type and variable type do not match.

Applications of Structure Pointers

1. Linked Lists: Linked lists use structure pointers to connect one node to another. Each node stores the address of the next node through a pointer.
2. Tree Data Structures: Binary trees and other hierarchical data structures rely on structure pointers to establish parent-child relationships between nodes.
3. Dynamic Memory Allocation: Structure pointers are used with memory allocation functions to create structures dynamically during program execution.
4. Database and Record Management: Large applications use structure pointers to manage records efficiently without copying large amounts of data.
5. Operating System and System Programming: Structure pointers are extensively used in operating systems, device drivers, and system-level programming for efficient memory management.

Conclusion

Pointers to structures are an important feature of C programming that combines the power of structures and pointers. They allow programmers to access structure data efficiently while reducing memory overhead and improving performance.
Understanding structure pointers is essential for learning advanced concepts such as dynamic memory allocation, linked lists, trees, and system programming. Mastering this concept helps build efficient and scalable C applications.

Frequently Asked Questions

1. What is a pointer to a structure in C?

A pointer to a structure is a pointer variable that stores the address of a structure variable.

2. Which operator is used to access members through a structure pointer?

The arrow (-) operator is used to access structure members through a pointer.

3. Can structure pointers be passed to functions?

Yes, structure pointers are commonly passed to functions because they improve efficiency and avoid copying entire structures.

4. What is the difference between ptr-member and (*ptr).member?

Both expressions access the same structure member. The arrow operator is simply a shorter and more readable form of the dereference-and-dot notation.

5. Why are structure pointers important?

Structure pointers improve memory efficiency, support dynamic memory allocation, and are essential for implementing advanced data structures.