Pointer Declaration

A pointer declaration introduces an identifier as a pointer to a specified data type. It establishes the pointer’s name and the base type of the data it addresses, which dictates pointer arithmetic stride and dereference semantics. While a pointer definition allocates memory for the pointer variable itself, a pure declaration (such as one using the extern keyword) merely informs the compiler of the pointer’s type and identifier without allocating storage.

Basic Syntax

The standard syntax consists of a base type, an asterisk (*) acting as the pointer declarator, and an identifier:

type *identifier;

• type: The base type (e.g., int, char, float, or a struct). This dictates how the compiler interprets the memory at the target address.
• *: The pointer declarator. In the context of a declaration, it indicates that the identifier is a pointer.
• identifier: The name of the pointer variable.

Asterisk Binding and Multiple Declarations

In C, the asterisk binds to the identifier, not the base type. This is a critical syntactic rule when declaring multiple variables in a single statement.

int* ptr1, ptr2;   // ptr1 is a pointer to an int. ptr2 is a standard int.
int *ptr3, *ptr4;  // ptr3 and ptr4 are both pointers to ints.

Because the asterisk binds to the variable name, idiomatic C style places the asterisk immediately adjacent to the identifier (int *ptr) rather than the type (int* ptr).

Initialization and Storage Duration

The initial value of a pointer declared without an explicit initializer depends strictly on its storage duration:

• Automatic storage duration: Pointers declared locally without the static keyword are uninitialized and hold an indeterminate value (often called “wild pointers”).
• Static or thread storage duration: Pointers declared globally, or locally with the static keyword, are implicitly initialized to a null pointer.

When explicitly initializing a pointer to a null pointer constant using the NULL macro, a header defining the macro (such as <stddef.h>) must be included.

#include <stddef.h>

extern int *external_ptr;     // Pure declaration; no memory allocated for the pointer

int target_var = 42;
int *ptr_valid = &target_var; // Definition and initialization to a valid address
int *ptr_null = NULL;         // Definition and initialization to a null pointer constant

Type Qualifiers (const, volatile, restrict)

Pointer declarations can include type qualifiers. The placement of the qualifier strictly defines whether it applies to the pointer itself or the data being pointed to. The rule is read right-to-left: a qualifier applies to whatever is immediately to its left. If there is nothing to its left, it applies to whatever is immediately to its right.

const and volatile:

int target_var = 42;

// 1. Pointer to a constant integer
// The data cannot be modified through this pointer, but the pointer can point elsewhere.
const int *ptr1;
int const *ptr2; // Semantically identical to ptr1

// 2. Constant pointer to an integer
// The pointer must always point to the same address, but the data can be modified.
int * const ptr3 = &target_var; 

// 3. Constant pointer to a constant integer
// Neither the pointer's address nor the target data can be modified.
const int * const ptr4 = &target_var;

// 4. Pointer to a volatile integer
// Informs the compiler that the target data may change outside the program's control.
volatile int *ptr5;

restrict (C99): The restrict qualifier applies exclusively to pointers. It is a promise to the compiler that for the lifetime of the pointer, the memory it addresses is accessed only through that pointer (or pointers derived from it). This allows the compiler to perform aggressive optimizations, such as caching values in registers, by eliminating pointer aliasing concerns.

int target_var = 42;
int * restrict ptr6 = &target_var; // The compiler assumes exclusive access to target_var via ptr6

Complex Pointer Declarations

Pointer declarations can be combined with other declarators to form complex types. The Right-Left Rule (or spiral rule) is used to parse these declarations based on operator precedence.

Pointers to Pointers (Multiple Indirection): Requires multiple asterisks, each representing a level of indirection.

int **ptr_to_ptr; // A pointer that holds the address of an int pointer

Pointers to Arrays: Parentheses are required because the array subscript operator [] has higher precedence than the pointer declarator *.

int (*arr_ptr)[10]; // A pointer to an array of 10 integers
int *ptr_arr[10];   // An array of 10 pointers to integers (different from above)

Pointers to Functions: Parentheses are similarly required because the function call operator () has higher precedence than *.

int (*func_ptr)(int, float); // A pointer to a function taking an int and float, returning an int

Master C with Deep Grasping Methodology!

Learn More