Dereference

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

1. Unary Indirection (Dereference) Operator

*operand

• Operand Requirement: The operand must have a pointer type.
• Return Value:
  • If the operand is a pointer to a function, the expression yields a function designator.
  • If the operand is a pointer to void, the expression yields a void expression. Because the C standard (C11 6.3.2.1) explicitly defines an lvalue as an expression with an object type other than void, dereferencing a void * does not yield an lvalue.
  • If the operand is a pointer to any other object type T (whether complete or incomplete), the expression yields an lvalue of type T. Dereferencing a pointer to an incomplete type is syntactically valid and does not violate constraints (e.g., &*ptr is legal because the lvalue is never evaluated to access the object).
• Modifiability: Yielding an lvalue does not guarantee assignability. If the pointed-to type T is const-qualified, dereferencing yields a non-modifiable lvalue, which will cause a compiler error if placed on the left side of an assignment.
• Precedence: It has high precedence (Level 2), associating right-to-left.
• Undefined Behavior: Applying the indirection operator to a null pointer, an uninitialized pointer, or a pointer to an invalid memory address results in undefined behavior.

int val = 100;
int *ptr = &val;
*ptr = 200; /* Yields a modifiable lvalue of type 'int' */

void *v_ptr = &val;
/* *v_ptr; -> Yields a void expression, not an lvalue */

struct OpaqueStruct *inc_ptr;
/* &*inc_ptr; -> Valid syntax; yields an lvalue of an incomplete type, immediately consumed by & */

​

2. Pointer Declarator

type *identifier;

• Binding: In C, the * token binds syntactically to the identifier (the declarator), not the type specifier.
• Type Derivation: It derives a pointer type from the base type. Multiple * tokens can be chained to declare pointers to pointers (e.g., int **ptr).
• Qualifiers: Type qualifiers (like const or volatile) placed after the * apply to the pointer itself, whereas qualifiers before the * apply to the pointed-to type.

int *p1, p2;        /* p1 is a pointer to int; p2 is a standard int */
const int *p3;      /* Pointer to a constant int */
int * const p4;     /* Constant pointer to a mutable int */

​

3. Binary Multiplication Operator

operand1 * operand2

• Operand Requirement: Both operands must be of arithmetic types (integer or floating-point).
• Type Conversion: The operands are subject to the usual arithmetic conversions before the operation is performed. The result type matches the promoted type of the operands.
• Precedence: It has multiplicative precedence (Level 3), associating left-to-right, which is lower than the unary indirection operator but higher than addition and subtraction.
• Overflow: If the mathematical result cannot be represented by the resulting type, integer overflow occurs (which is undefined behavior for signed integers and wraps around for unsigned integers).

int a = 5;
int b = 10;
int product = a * b; /* Binary arithmetic evaluation */

​

4. Unspecified Variable Length Array (VLA) Size Indicator

type identifier[*]
type identifier[size][*]

• Context Restriction: This usage is strictly limited to function prototype declarations (not function definitions).
• Type Compatibility: It serves as a syntactic placeholder indicating that the parameter is a VLA. It allows the compiler to perform type compatibility checking for multi-dimensional arrays where the inner dimensions are variable, without requiring the parameter names of the sizes to be specified in the prototype.
• Evaluation: It does not evaluate to a value or perform any operation at runtime.

/* Prototype using '*' to indicate a VLA of unspecified size */
void process_matrix(int rows, int cols, int matrix[rows][*]);