How Do I Use Pointers to Access Struct Members?

After this lesson, you will be able to:

• Use the arrow operator (->) to access fields through a struct pointer
• Dynamically allocate structs with calloc and avoid the sizeof pointer bug
• Pass struct pointers to functions for efficient in-place modification
• Implement nested allocation and free inner allocations before outer

Dot vs. Arrow

You’ve seen s.name for accessing struct fields. But when you have a pointer to a struct, you need the arrow operator (->):

Student s;
s.gpa = 3.85;          // Dot: s is a struct value

Student *p = &s;
p->gpa = 3.85;         // Arrow: p is a pointer to a struct

p->gpa is shorthand for (*p).gpa — dereference the pointer, then access the field. The arrow saves you from writing parentheses everywhere.

Struct Pointers in Practice

The Rule

Dynamic Struct Allocation

Student *s = calloc(1, sizeof(Student));
if (s == NULL) { /* handle error */ }

s->id = 12345;
s->gpa = 3.85;
strcpy(s->name, "Alice");

// When done:
free(s);

Common Pitfall: Use sizeof(Student) — not sizeof(Student *). sizeof(Student *) is the size of a pointer (8 bytes), not the struct. This allocates far too little memory and causes buffer overflows.

Dynamic Arrays of Structs

int n = 30;
Student *roster = calloc(n, sizeof(Student));

for (int i = 0; i < n; i++)
{
    roster[i].id = 1000 + i;
    roster[i].gpa = 0.0;
    strcpy(roster[i].name, "TBD");
}

// Access through pointer arithmetic:
// roster[i] is the same as *(roster + i)
// roster[i].name is the same as (roster + i)->name

free(roster);

Passing Struct Pointers to Functions

Pass by pointer to avoid copying and to allow modification:

void update_gpa(Student *s, double new_gpa)
{
    s->gpa = new_gpa;     // Modifies the original
}

void print_student(const Student *s)
{
    printf("%-20s %5d  %.2f\n", s->name, s->id, s->gpa);
}

Use const when the function only reads:

void print_roster(const Student *roster, int size)
{
    for (int i = 0; i < size; i++)
    {
        print_student(&roster[i]);
    }
}

Structs with Pointer Fields (Nested Allocation)

When a struct has char * instead of char[50], you need two allocations:

typedef struct
{
    char *name;       // Pointer to dynamically allocated string
    int id;
    double gpa;
} Student;

Student *s = calloc(1, sizeof(Student));
s->name = calloc(50, sizeof(char));        // Separate allocation
strcpy(s->name, "Alice");

And two frees — in the right order:

free(s->name);    // Free the string FIRST
free(s);          // Then free the struct

Common Pitfall: If you free the struct before the string, you’ve lost the pointer to the string — memory leak. Always free inner allocations before outer ones.

The Trick: For labs, use fixed-size char name[50] inside structs when possible. It avoids nested allocation and simplifies cleanup. Save char * for when you genuinely need variable-length strings.

From Java: In Java, nested objects are handled by the garbage collector — you never worry about freeing inner fields before outer objects. In C, you’re the garbage collector. Free from the inside out.

Big Picture: Struct pointers bridge the gap between static data and dynamic programs. Without them, every struct would live on the stack with a fixed lifetime. With them, you can allocate records on demand, build arrays that grow at runtime, and pass data efficiently to functions. This is the machinery behind every database, linked list, and file parser you’ll write.

Structs + Pointers = Real Data Structures

With struct pointers, you can dynamically allocate individual records, build arrays of records, and pass them efficiently to functions. This is the foundation for file I/O (reading records from disk), sorting (rearranging struct arrays), and linked lists (self-referential structs).

Next: file I/O. You’ll learn fopen, fclose, fprintf, and fscanf — reading data from files into struct arrays, which is how most real programs get their data.