Pointers and Allocatable Arrays

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.

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.

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.

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.