Pointers and Allocatable Arrays

Analogy categoryAnalogies

Two Ways to Manage Memory Dynamically

Fortran offers two attributes for data whose size or existence is not known at compile time: ALLOCATABLE and POINTER. An ALLOCATABLE array, declared REAL, ALLOCATABLE :: temps(:), owns its storage; you grow or shrink it with ALLOCATE and DEALLOCATE, and the compiler automatically frees it when it goes out of scope, similar to how a C++ std::vector manages its own buffer. A POINTER, declared REAL, POINTER :: view(:), does not own storage by default; it must be associated with an existing TARGET or allocated storage before use, and multiple pointers can alias the same memory, which is powerful but requires more discipline than allocatable arrays.

🏏

Cricket analogy: An allocatable array is like a franchise owning its own stadium, such as the Chennai Super Kings owning Chepauk, fully responsible for its upkeep, while a pointer is like a broadcaster's camera feed that just views whichever stadium it's currently pointed at.

Working With Allocatable Arrays

You allocate an allocatable array with ALLOCATE(temps(100)) and free it with DEALLOCATE(temps), though modern Fortran also deallocates automatically when the variable goes out of scope or is reassigned via intrinsic assignment, which itself reallocates the left-hand side to match the shape of the right-hand side (automatic reallocation on assignment, from Fortran 2003 onward). Allocatable arrays can also be components of derived types or dummy arguments to procedures, and querying ALLOCATED(temps) before use avoids referencing unallocated memory, a common source of runtime crashes in codes that assume an array is always ready.

🏏

Cricket analogy: Calling ALLOCATE(temps(100)) is like the ICC booking exactly the right stadium capacity for a World Cup final, sized to fit the expected crowd rather than a fixed generic venue.

Pointers, Targets, and Association

A pointer becomes usable either by pointer assignment to a variable declared with the TARGET attribute, such as view => temps where temps has TARGET, or by directly allocating it with ALLOCATE(view(50)). The function ASSOCIATED(view) tests whether a pointer currently references valid storage, and NULLIFY(view) or view => NULL() disassociates it safely. Pointers are essential for building linked lists, trees, and other structures where a component needs to reference another instance of the same type without copying it, something an allocatable component alone cannot express as flexibly.

🏏

Cricket analogy: view => temps is like a TV director switching the live feed to point at the non-striker's end camera, referencing an existing camera rig rather than installing a new one.

Common Pitfalls: Dangling Pointers and Leaks

A dangling pointer results when the target is deallocated or goes out of scope while the pointer still references it, leaving undefined behavior on next use; this is why pointer targets are usually given the TARGET attribute explicitly and kept alive for at least as long as any pointer references them. Memory leaks occur when allocated memory (via ALLOCATE, whether for a pointer or, less commonly, a forgotten allocatable) is never deallocated and becomes unreachable, and MOVE_ALLOC provides an efficient way to transfer ownership of an allocatable array's storage to another allocatable variable without copying its contents, which is useful when growing dynamic buffers incrementally.

🏏

Cricket analogy: A dangling pointer is like a commentator still referring to 'the player at the crease' after that batter has already been given out and walked off, describing someone no longer there.

Referencing a pointer that is not ASSOCIATED, or one whose target has already been deallocated (a dangling pointer), is undefined behavior in Fortran and often will not produce an immediate crash, making it a notoriously hard bug to track down. Always check ASSOCIATED(ptr) before dereferencing a pointer whose association status is uncertain.

MOVE_ALLOC(FROM=old_array, TO=new_array) transfers the allocation from old_array to new_array in O(1) time without copying data, and automatically deallocates old_array. This is the idiomatic way to implement a growable buffer: allocate a bigger array, copy over what's needed, then MOVE_ALLOC the new storage into place.

ALLOCATABLE arrays own their storage and are automatically deallocated when they go out of scope.
POINTER variables do not own storage by default and must be associated with a TARGET or allocated directly.
ALLOCATE and DEALLOCATE manage allocatable and pointer storage explicitly; ASSOCIATED() checks pointer validity.
Intrinsic assignment automatically reallocates an allocatable left-hand side to match the right-hand side's shape (Fortran 2003+).
Dangling pointers arise when a target is deallocated while a pointer still references it; always guard with ASSOCIATED().
Pointers enable linked structures like lists and trees that allocatable components alone cannot express as flexibly.
MOVE_ALLOC transfers allocatable storage between variables without copying, useful for efficient buffer growth.