Go Up to Unary Operators Index
& cast-expression * cast-expression
The & and * operators work together to reference and dereference pointers that are passed to functions.
Referencing operator ( & )
Use the reference operator to pass the address of a pointer to a function outside of
The cast-expression operand must be one of the following:
- A function designator.
- An lvalue designating an object that is not a bit field and is not declared with a register storage class specifier.
If the operand is of type <type>, the result is of type pointer to <type>.
Some non-lvalue identifiers, such as function names and array names, are automatically converted into "pointer-to-X" types when they appear in certain contexts. The & operator can be used with such objects, but its use is redundant and therefore discouraged.
Consider the following example:
T t1 = 1, t2 = 2; T *ptr = &t1; // Initialized pointer *ptr = t2; // Same effect as t1 = t2
T *ptr = &t1 is treated as
T *ptr; ptr = &t1;
So it is
*ptr, that gets assigned. Once
ptr has been initialized with the address
&t1, it can be safely dereferenced to give the lvalue
Indirection operator ( * )
Use the asterisk (*) in a variable expression to create pointers. Use the indirect operator in external functions to get a pointer's value that was passed by reference.
If the operand is of type pointer to function, the result is a function designator.
If the operand is a pointer to an object, the result is an lvalue designating that object.
The result of indirection is undefined if either of the following occur:
- The cast-expression is a null pointer.
- The cast-expression is the address of an automatic variable and execution of its block has terminated.
Note: & can also be the bitwise AND operator.
Note: * can also be the multiplication operator.