C Arrow Operator (->): Access Struct Members Through Pointers

The C arrow operator, ->, accesses a structure or union member through a pointer. It is shorthand for dereferencing the pointer and then using the dot operator: pointer->member is equivalent to (*pointer).member. You will learn when to use . versus ->, how the expression is evaluated, and how this appears in real C programs.

In C, a struct groups related values into one custom type. You use the dot operator (.) when you have the structure value itself:

struct Person person;
person.age = 30;

A pointer stores the address of another value. If you have a pointer to a structure, you must access the structure located at that address. The arrow operator (->) does this in one expression:

struct Person *person_ptr = &person;
person_ptr->age = 30;

This is exactly equivalent to:

(*person_ptr).age = 30;

The parentheses are essential because . has higher precedence than unary *. Without parentheses, *person_ptr.age would try to access age from person_ptr itself before dereferencing it, which is not what you want.

-> works with pointers to and objects. It accesses such as , , or .

Think of a structure value as a filing cabinet you are standing next to. With the dot operator, you open a labeled drawer directly:

person.age

A pointer is a slip of paper containing the cabinet's address. With the arrow operator, you follow the address to the cabinet and open its labeled drawer:

person_ptr->age

So -> means: go to the structure this pointer points to, then select this member.

The core rule is:

pointer_to_struct->member

It means:

(*pointer_to_struct).member

Basic example

#include <stdio.h>

struct Book {
    const char *title;
    int pages;
};

int main(void) {
    struct Book book = {"The C Programming Language", 272};
    struct Book *book_ptr = &book;

    printf("%s has %d pages.\n", book.title, book.pages);
    printf("%s has %d pages.\n", book_ptr->title, book_ptr->pages);

    book_ptr->pages = 275;
    printf("Updated page count: %d\n", book.pages);

    return 0;
}

book is a structure value, so it uses . contains the address of , so it uses .

Consider this program:

#include <stdio.h>

struct Counter {
    int value;
};

int main(void) {
    struct Counter counter = {10};
    struct Counter *ptr = &counter;

    ptr->value += 5;

    printf("%d\n", counter.value);
    return 0;
}

Execution trace:

1. counter is created with one member: counter.value is 10.
2. &counter produces the memory address of counter.
3. ptr stores that address, so ptr points to counter.
4. ptr->value means : dereference , producing , then select .

The arrow operator is common whenever a C program passes structure pointers rather than copying whole structures.

• Function parameters: A function receives a pointer so it can update the caller's structure.

  void set_score(struct Player *player, int score) {
      player->score = score;
  }
  

• Dynamically allocated objects: malloc returns a pointer, so allocated structures use ->.

  struct Node *node = malloc(sizeof *node);
  node->value = 42;
  

• Linked lists: Each node often stores a pointer to the next node.

  current = current->next;
  

• Library APIs: Many C libraries use opaque structure pointers, such as file handles. For example, FILE * is used with library functions, although its internal members should not be accessed directly.

• Configuration and state objects: Programs often pass a pointer to a shared application state or configuration structure to avoid copying it.

In production C code, -> is most often seen in functions that receive pointers to structures.

Update an object owned by the caller

struct Account {
    int balance;
};

void deposit(struct Account *account, int amount) {
    if (account == NULL || amount <= 0) {
        return;
    }

    account->balance += amount;
}

This uses a guard clause to reject an invalid pointer or amount before accessing account->balance.

Read-only access with const

If a function should inspect a structure without changing it, use a pointer-to-const:

#include <stdio.h>

struct User {
    const char *name;
    int id;
};

void print_user(const struct User *user) {
    if (user == ) {
        ;
    }

    (, user->name, user->id);
}

Using . on a pointer

This is incorrect because person_ptr is a pointer, not a struct Person value:

struct Person *person_ptr;
person_ptr.age = 30; /* Incorrect */

Use:

person_ptr->age = 30;

Forgetting parentheses with *

This is incorrect:

(*person_ptr.age) = 30; /* Incorrect */

It is parsed as *(person_ptr.age). Use either form below:

person_ptr->age = 30;
(*person_ptr).age = 30;

Dereferencing a NULL pointer

This has undefined behavior and often crashes:

 ;
person_ptr->age = ; 

• Use . with a structure or union value: item.count.

• Use -> with a pointer to a structure or union: item_ptr->count.

• Equivalent expressions:

  item_ptr->count
  (*item_ptr).count
  

• Parentheses are required in the expanded form: (*ptr).member.

• ptr->member requires ptr to point to a valid structure or union object.

• Do not use -> through NULL, a dangling pointer, or an uninitialized pointer.

• C has no normal object methods. ptr->callback() is valid only when callback is a function-pointer member.

• A nested value often combines operators: ptr->address.zip_code.

What does -> mean in C?

It dereferences a pointer to a structure or union and accesses one of its members. ptr->member is shorthand for (*ptr).member.

When should I use . instead of -> in C?

Use . when your variable is the actual structure value. Use -> when your variable is a pointer to that structure.

Is ptr->member exactly the same as (*ptr).member?

Yes. They access the same member in the same object. The arrow form is shorter and easier to read.

Why are parentheses needed in (*ptr).member?

Because the dot operator binds more tightly than *. Parentheses ensure the pointer is dereferenced before selecting the member.

Can I use the arrow operator with arrays?

Not directly for an array itself. You can use it when a structure pointer has an array member, such as record_ptr->scores[0].

Can I call functions with -> in C?

Only if the selected structure member is a function pointer. Ordinary C functions are not structure members.

• C structures (struct) — Structures define the named members accessed by . and ->.
• Pointers in C — The arrow operator depends on a pointer holding the address of a structure.
• Dereference operator (*) — -> is shorthand that includes dereferencing.
• Address-of operator (&) — &object creates a pointer that can be used with ->.
• Dynamic memory allocation (malloc and free) — Dynamically allocated structures are accessed through pointers.
• Linked lists — Nodes commonly use next pointers accessed as node->next.
• const pointers and pointer-to-const — const struct Type * supports safe read-only member access.
• Function pointers — A function-pointer member can be accessed with -> and invoked.