POINTERS AND ACCESS VALUES

Pointers are variables that have as their value an address, i.e. a reference to another data object. Given a pointer we can access the value "pointed" to through a process known as dereferencing.

C POINTERS

C makes extensive use of pointers and uses two prefix operators:
```
* (Asterisk)
& (Ampersand)
```
* when used in a declaration is read as "pointer to a data type". Example:
```
int *numberPtr;
```
* when used elsewhere is interpreted as "the value contained in the reference/ address pointed at" (i.e. the pointer is dereferenced). Example:
```
*numberPtr = *numberPtr + 1;
```
& when used anywhere is read as the "reference/address of ...". Example:
```
numberPtr = &x
```
In this case x is referred to as a reference variable.

Consider the following example:

#include 

void main(void)
{
int n, *nptr;

scanf("%d",&n);

nptr = &n;
printf("Value of n = %d\n",n);
printf("Address of n = %d\n",&n);
printf("Value of nptr = %d\n",nptr);
printf("Address of nptr = %d\n",&nptr);
printf("Value pointed at by nptr = %d\n",*nptr);
}

Note that the address of n and the value of nptr are the same.

Ada Access Values

In Ada pointers are referred to as access values.

To declare an access value the reserved word access is used in the declaration . Example:

with CS_IO; use CS_IO;

procedure ACCESS is
        type INTEGERPTR is access integer;
        INT_PTR: INTEGERPTR:= new integer'(2);
begin
        put(INT_PTR.ALL); new_line;
end ACCESS;

Note that the variable INT_PTR is referred to as an access variable.

Created and maintained by Frans Coenen. Last updated Wednesday July 3 1996.