Pointers to Structures in C

In the last lesson, you saw that passing a struct to a function hands over a copy, so the function can't change the original. Pointers to structures in C solve that problem. By passing the struct's address instead, a function can update the real thing, and your program skips copying the whole record every time. In this lesson, you'll learn the arrow operator ->, write functions that modify structs, protect read-only data with const, and create structs on the heap with malloc().

What is a pointer to a structure?

A pointer to a structure is a pointer variable that holds the address of a struct. You declare it with the struct type and a star, and fill it with the & (address-of) operator, exactly as with pointers to ints:

struct Account {
    char owner[30];
    double balance;
};

struct Account acc = {"Priya", 250.00};
struct Account *p = &acc;   /* p holds the address of acc */

Now p doesn't contain an account. It contains the location of one.

The arrow operator -> vs (*p).field

To reach a member through a pointer, you could first dereference the pointer and then use the dot: (*p).balance. The parentheses are required because the dot binds more tightly than the star. Since that's awkward to type, C offers a shortcut: the arrow operator ->. Writing p->balance means exactly the same thing as (*p).balance.

#include <stdio.h>

struct Account {
    char owner[30];
    double balance;
};

int main(void) {
    struct Account acc = {"Priya", 250.00};
    struct Account *p = &acc;

    printf("%s has $%.2f\n", (*p).owner, (*p).balance);
    printf("%s has $%.2f\n", p->owner, p->balance);
    return 0;
}

Priya has $250.00
Priya has $250.00

How the arrow operator updates a struct

Because p holds the address of acc, writing through p->balance changes acc.balance itself. There is only one account; the pointer is just another way to reach it.

Passing a struct pointer to a function to modify it

This is the most common use of struct pointers. First, here's what goes wrong with pass-by-value: the function updates its own copy, and the caller's balance never changes.

#include <stdio.h>

struct Account {
    char owner[30];
    double balance;
};

void deposit_copy(struct Account acc, double amount) {
    acc.balance += amount;   /* changes the copy only */
    printf("Inside function: $%.2f\n", acc.balance);
}

int main(void) {
    struct Account acc = {"Priya", 250.00};

    deposit_copy(acc, 100.00);
    printf("Balance: $%.2f\n", acc.balance);
    return 0;
}

Inside function: $350.00
Balance: $250.00

Now pass the address with &acc and accept a struct Account *. Inside the function, use -> to reach the real members:

#include <stdio.h>

struct Account {
    char owner[30];
    double balance;
};

void deposit(struct Account *acc, double amount) {
    acc->balance += amount;
}

int withdraw(struct Account *acc, double amount) {
    if (amount > acc->balance) {
        return 0;   /* not enough money */
    }
    acc->balance -= amount;
    return 1;
}

int main(void) {
    struct Account acc = {"Priya", 250.00};

    deposit(&acc, 100.00);
    printf("After deposit: $%.2f\n", acc.balance);

    if (!withdraw(&acc, 500.00)) {
        printf("Withdrawal of $500.00 declined\n");
    }

    withdraw(&acc, 75.50);
    printf("After withdrawal: $%.2f\n", acc.balance);
    return 0;
}

After deposit: $350.00
Withdrawal of $500.00 declined
After withdrawal: $274.50

This is the same idea as pass by reference with plain ints, applied to a whole record.

const struct pointers: read without changing

Sometimes a function only needs to read a struct, like printing a statement. You still want the speed of a pointer, but you don't want the function to change anything by accident. Mark the pointer const:

#include <stdio.h>

struct Account {
    char owner[30];
    double balance;
};

void print_statement(const struct Account *acc) {
    printf("Owner: %s\n", acc->owner);
    printf("Balance: $%.2f\n", acc->balance);
}

int main(void) {
    struct Account acc = {"Diego", 1200.75};

    print_statement(&acc);
    return 0;
}

Owner: Diego
Balance: $1200.75

If print_statement tried acc->balance = 0;, the compiler would stop you:

error: assignment of member 'balance' in read-only object

Looping over an array of structs with a pointer

An array name acts like a pointer to its first element, so a struct pointer can walk through an array of structs. Each a++ moves forward by one whole struct, as you saw in pointer arithmetic.

#include <stdio.h>

struct Account {
    char owner[30];
    double balance;
};

int main(void) {
    struct Account bank[3] = {
        {"Ana", 120.50},
        {"Ben", 75.25},
        {"Chloe", 300.00}
    };
    double total = 0.0;

    for (struct Account *a = bank; a < bank + 3; a++) {
        printf("%s: $%.2f\n", a->owner, a->balance);
        total += a->balance;
    }
    printf("Total held: $%.2f\n", total);
    return 0;
}

Ana: $120.50
Ben: $75.25
Chloe: $300.00
Total held: $495.75

Dynamically allocated structs with malloc

When you don't know in advance how many records you'll need, you create structs on the heap with malloc(). It returns a pointer, so -> is the natural way to use the new struct:

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

struct Account {
    char owner[30];
    double balance;
};

int main(void) {
    struct Account *acc = malloc(sizeof *acc);
    if (acc == NULL) {
        printf("Out of memory\n");
        return 1;
    }

    strcpy(acc->owner, "Tom");
    acc->balance = 40.00;
    acc->balance += 60.00;

    printf("%s has $%.2f\n", acc->owner, acc->balance);

    free(acc);
    acc = NULL;
    return 0;
}

Tom has $100.00

sizeof *acc asks for "the size of whatever acc points to", so the line stays correct even if you later rename the struct. Memory from malloc() isn't initialized, so set every member before reading it, and always free() it when you're done to avoid memory leaks. You'll build whole chains of heap structs in the linked list lesson.

Common mistakes with struct pointers

1. Using a dot on a pointer

Writing p.balance when p is a pointer fails. GCC even suggests the fix: 'p' is a pointer; did you mean to use '->'?

2. Forgetting the parentheses in (*p).balance

*p.balance means *(p.balance), because the dot runs before the star. It doesn't compile. Use p->balance and the problem disappears.

3. Using a pointer that points nowhere

struct Account *p;      /* not initialized */
p->balance = 10.0;      /* undefined behavior */

An uninitialized pointer holds a random address, so this may crash or silently corrupt memory. Always point it at a real struct (&acc) or at memory from malloc() first.

4. Returning the address of a local struct

A function that returns &local_account hands back an address that stops being valid the moment the function returns. Return the struct by value, or allocate it with malloc() and let the caller free() it.

Practice exercise

#include <stdio.h>

struct Player {
    char name[20];
    int score;
    int level;
};

void add_points(struct Player *pl, int points) {
    pl->score += points;
    if (pl->score >= pl->level * 100) {
        pl->level++;
        printf("%s reached level %d!\n", pl->name, pl->level);
    }
}

int main(void) {
    struct Player hero = {"Zoe", 0, 1};

    add_points(&hero, 60);
    add_points(&hero, 50);
    add_points(&hero, 30);

    printf("%s: score %d, level %d\n", hero.name, hero.score, hero.level);
    return 0;
}

Zoe reached level 2!
Zoe: score 140, level 2

What's next?

Structs give every member its own space. Next, meet their space-saving cousin: unions in C, where all members share the same memory.