Pointer to Struct in C: The Arrow Operator and Heap Structs

A struct passed to a function is copied. That is fine for a two-int point and wasteful for a 200-byte record - and it makes mutation impossible, because the function only ever sees its own copy. Pointing at a struct solves both problems at once, and it is also the only way to build structures that grow: lists, trees, graphs.

Taking a Pointer to a Struct

Nothing special is needed. & gives you the address, and the type is "pointer to struct":

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p = {3, 4};
    struct Point *ptr = &p;

    printf("x via struct : %d\n", p.x);
    printf("x via pointer: %d\n", (*ptr).x);
    printf("x via arrow  : %d\n", ptr->x);
    return 0;
}

All three print 3. The last two are the same operation written two ways.

Why (*ptr).x Needs Its Parentheses

You might try to drop them and write *ptr.x. That compiles to something quite different, or more often refuses to compile at all - because the member operator . has higher precedence than the dereference *:

*ptr.x        // parses as *(ptr.x)  -- wrong
(*ptr).x      // dereference first, then take the member -- correct
ptr->x        // the same thing, said shortly

ptr.x asks for a member of the pointer, and a pointer has no members. The compiler's complaint ("request for member 'x' in something not a structure or union") is a precedence bug in disguise.

Because that parenthesized form is ugly and easy to get wrong, C provides ->. In practice you will almost never see (*p).x in real code; reach for p->x and forget the long form exists, except as the explanation for what the arrow means.

Passing a Struct by Pointer

A pointer parameter gives the function the caller's actual struct, so changes stick:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

/* Mutates the caller's struct. */
void translate(struct Point *p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

/* Reads only - const says so, and the compiler enforces it. */
void print_point(const struct Point *p) {
    printf("(%d, %d)\n", p->x, p->y);
}

int main(void) {
    struct Point p = {3, 4};

    print_point(&p);
    translate(&p, 10, -2);
    print_point(&p);
    return 0;
}

Two habits worth forming here:

• Mark read-only pointers const. const struct Point *p promises the function will not change what p points at. If someone later adds p->x = 0 inside, the compile fails instead of the bug shipping. It also documents intent at the call site.
• Pass a pointer for large structs even when reading. A struct with a 64-byte name buffer costs 64 bytes of copying per call by value; a pointer costs 8.

Small structs are still fine to pass by value - struct Point at 8 bytes copies as cheaply as a pointer, and the by-value version cannot be NULL, which removes a whole failure mode.

Pointers Into Arrays of Structs

Pointer arithmetic works on struct arrays exactly as it does on int arrays: p + 1 advances by one whole struct, padding included.

#include <stdio.h>

struct Employee {
    int id;
    char name[16];
    double salary;
};

double total_payroll(const struct Employee *staff, int n) {
    double total = 0.0;
    for (const struct Employee *e = staff; e < staff + n; e++) {
        total += e->salary;
    }
    return total;
}

int main(void) {
    struct Employee staff[] = {
        {101, "Ada",   92000.0},
        {102, "Grace", 105000.0},
        {103, "Alan",  87000.0},
    };
    int n = sizeof(staff) / sizeof(staff[0]);

    printf("Payroll: %.2f\n", total_payroll(staff, n));
    return 0;
}

An array name decays to a pointer to its first element, so staff is already a struct Employee * at the call. That is also why the function needs n passed separately - sizeof inside the function would measure the pointer, not the array.

Allocating a Struct on the Heap

Stack structs die at the end of their scope. To make one that outlives the function that created it - or to make as many as the input demands - allocate with malloc:

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

struct Employee {
    int id;
    char name[16];
    double salary;
};

struct Employee *make_employee(int id, const char *name, double salary) {
    struct Employee *e = malloc(sizeof *e);
    if (e == NULL) {
        return NULL;            /* out of memory - the caller must check */
    }
    e->id = id;
    snprintf(e->name, sizeof e->name, "%s", name);
    e->salary = salary;
    return e;
}

int main(void) {
    struct Employee *e = make_employee(101, "Ada", 92000.0);
    if (e == NULL) {
        fprintf(stderr, "allocation failed\n");
        return 1;
    }

    printf("%d %s %.2f\n", e->id, e->name, e->salary);

    free(e);
    return 0;
}

Four details in that small function are all load-bearing:

• sizeof *e, not sizeof(struct Employee). It reads as "the size of whatever e points at", so if the type ever changes the allocation follows automatically. There is no way for the two to drift apart.
• Check for NULL. malloc returns NULL when it cannot satisfy the request. Writing e->id through a null pointer is a segmentation fault.
• Initialize every member. malloc does not zero memory; the struct arrives full of garbage. (calloc(1, sizeof *e) zeroes it for you.)
• Someone must free it. Returning an allocated pointer transfers that duty to the caller. Say so in a comment - an unclear ownership rule is how memory leaks start.

The Payoff: a Linked List Node

Here is the thing structs cannot do without pointers. A struct cannot contain itself - that would be infinitely large - but it can contain a pointer to one of its own kind, and that single trick builds every linked data structure in C.

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

struct Node {
    int value;
    struct Node *next;     /* a pointer to the same type is fine */
};

/* Adds a node to the front and returns the new head. */
struct Node *push(struct Node *head, int value) {
    struct Node *n = malloc(sizeof *n);
    if (n == NULL) {
        return head;       /* out of memory: list is unchanged */
    }
    n->value = value;
    n->next = head;
    return n;
}

void print_list(const struct Node *head) {
    for (const struct Node *n = head; n != NULL; n = n->next) {
        printf("%d -> ", n->value);
    }
    printf("NULL\n");
}

void free_list(struct Node *head) {
    while (head != NULL) {
        struct Node *next = head->next;   /* save before freeing */
        free(head);
        head = next;
    }
}

int main(void) {
    struct Node *head = NULL;

    head = push(head, 3);
    head = push(head, 2);
    head = push(head, 1);

    print_list(head);
    free_list(head);
    return 0;
}

Note that struct Node *next; refers to struct Node while struct Node is still being declared. That is legal precisely because a pointer has a known size regardless of what it points at - the compiler does not need the full definition yet. It is also the one place where you must use the struct Node tag even if you also wrote a typedef: the typedef name does not exist yet inside its own definition.

The free_list loop saves head->next before calling free(head). Reading head->next after the free is a use-after-free - the memory is no longer yours, and the value you read is whatever the allocator put there.

Common Mistakes

• p->x on an uninitialized or NULL pointer. The most common cause of a crash in struct-heavy code. Initialize pointers to NULL and check before dereferencing.
• Returning a pointer to a local struct. struct Point *bad(void) { struct Point p = {1,2}; return &p; } returns the address of memory that stops existing the moment the function returns. Return the struct by value, or allocate it.
• Freeing twice, or forgetting to free. Each malloc pairs with exactly one free. After freeing, set the pointer to NULL so a later accidental use crashes loudly instead of corrupting memory quietly.
• Copying a struct that contains a pointer. Struct assignment copies the pointer value, not what it points at. Both structs now reference the same buffer, and whichever one frees it first leaves the other dangling.