pointer -- C Language

A pointer is  an object whose value is the  address of another object.  The
name  ``pointer'' derives  from  the fact  that its  contents ``point  to''
another object.   A pointer may point to any  type, complete or incomplete,
including another pointer.  It may also point to a function, or to nowhere.

The term  pointer type refers  to the object  of a pointer.   The object to
which a pointer points is called the referenced type. For example, an int *
(``pointer  to  int'') is  a  pointer  type; the  referenced  type is  int.
Constructing a  pointer type from a referenced type  is called pointer type
derivation.

The Null Pointer

A pointer that  points to nowhere is a null  pointer. The macro NULL, which
is  defined in  the header  stdio.h,  defines the  null pointer.   The null
pointer is an integer constant with the value zero.  It compares unequal to
a pointer to any object or function.

Declaring a Pointer

To declare  a pointer, use the indirection operator  `*'.  For example, the
declaration

    int *pointer;

declares  that the  variable  pointer holds  the address  of an  int-length
object.  Likewise, the declaration

    int **pointer;

declares that  pointer holds  the address of  a pointer whose  contents, in
turn, point to an int-length object.

Failure to  declare a function that  returns a pointer will  result in that
function being implicitly declared as an  int. This does not cause an error
on  microprocessors in  which an  int  and a  pointer have  the same  size;
however, if  you transport this  code to a  microprocessor in which  an int
consists of 16 bits and a  pointer consists of 32 bits, the pointer will be
truncated truncated to 16 bits and the program probably will fail.

C allows  pointers and integers to  be compared or converted  to each other
without restriction.   The COHERENT C compiler  flags such conversions with
the strict message

    integer pointer pun

and comparisons with the strict message

    integer pointer comparison

These problems should be corrected if  you want your code to be portable to
other computing environments.

See C language for more information.

Wild Pointers

Pointers are omnipresent in C.  C  also allows you to use a pointer to read
or write  the object to  which the pointer  points; this is  called pointer
dereferencing. Because  a pointer can point to any  place within memory, it
is possible to write  C code that generates unpredictable results, corrupts
itself, or even obliterates  the operating system if running in unprotected
mode.  A pointer that aims where it ought not is called a wild pointer.

When a  program declares a  pointer, space is  set aside in  memory for it.
However, this space has not yet  been filled with the address of an object.
To fill  a pointer  with the address  of the object  you wish to  access is
called initializing  it.  A wild pointer,  as often as not,  is one that is
not properly initialized.

Normally,  to initialize  a  pointer means  to  fill it  with a  meaningful
address.  For example, the following initializes a pointer:

    int number;
    int *pointer;
       . . .
    pointer = &number;

The  address operator  `&' specifies  that you want  the address  of an
object rather than its contents.   Thus, pointer is filled with the address
of number, and it can now be used to access the contents of number.

The   initialization  of   a  string   is   somewhat  different   than  the
initialization of a pointer to an integer object.  For example,

    char *string = "This is a string."

declares that  string is  a pointer  to a char.  It then stores  the string
literal This is a string in memory and fills string with the address of its
first  character.  string  can then  be passed to  functions to  access the
string, or you can step through the string by incrementing string until its
contents point to the null character at the end of the string.

Another way to initialize a pointer  is to fill it with a value returned by
a function that returns a pointer.  For example, the code

    extern char *malloc(size_t variable);
    char *example;
       . . .
    example = malloc(50);

uses the  function malloc to allocate  50 bytes of dynamic  memory and then
initializes example to the address that malloc returns.

Reading What a Pointer Points To

The indirection  operator `*'  can be  used to read  the object to  which a
pointer points.  For example,

    int number;
    int *pointer;
       . . .
    pointer = &number;
       . . .
    printf("%d\n", *pointer);

uses pointer to access the contents of number.

When a pointer points to a structure, the elements within the structure can
be read by using the structure  offset operator `->'.  See the entry for
operators for more information.

Pointers to Functions

A pointer can also contain the address of a function.  For example,

    char *(*example)();

declares example to be a pointer  to a function that returns a pointer to a
char.

This declaration is quite different from:

    char **different();

The latter declares that different is  a function that returns a pointer to
a pointer to a char.

The following demonstrates how to call a function via a pointer:

    (*example)(arg1, arg2);

Here, the `*' takes the contents  of the pointer, which in this case is the
address of  the function, and uses  that address to pass  to a function its
list of arguments.

A pointer to  a function can be passed as  an argument to another function.
The  functions  bsearch  and qsort  each  take  a  function  pointer as  an
argument.  A program may also use arrays of pointers to functions.

void *

void * is the generic pointer;  it replaces char * in that role.  A pointer
may be cast to void * and then back to its original type without any change
in  its value.   void  * is  also  aligned for  any type  in the  execution
environment.  Please note that COHERENT's C compiler does not yet recognize
the type void *.

In Kernighan and Ritchie C, character pointers are equivalent to void *. To
convert a program to use void *, rewrite the sources so that instances of

    char *foo(bar);

is replaced by:

    VOID_T *foo(bar);

Be sure  that you do  not replace legitimate  char *s --  that is, pointers
that actually point to character strings.  Then put the code

    #if defined(__ANSI__) || defined(__GNUC__)
    typedef void VOID_T
    #else
    typedef char VOID_T
    #endif

into  an application-owned  header file  that is  included by  every source
file.

Pointer Conversion

One type of pointer may be  converted, or cast, to another.  For example, a
pointer to a char may be cast to a pointer to an int, and vice versa.

The ANSI  Standard states that any  pointer can be cast to  type void * and
back  again without  its value  being  affected in  any way.   (Once again,
please note that COHERENT's C compiler does not yet recognize the type void
*.) Likewise, any pointer of a scalar type may be cast to its corresponding
const or volatile version.   The qualified pointers are equivalent to their
unqualified originals.

Pointers to different data types are compatible in expressions, but only if
they  are  cast  appropriately.   Using  them  without casting  produces  a
pointer-type mismatch.  The translator should produce  a diagnostic message
when it detects this condition.

Pointer Arithmetic

Arithmetic may be performed on all pointers to scalar types, i.e., pointers
to chars or  int.  Pointer arithmetic is quite limited  and consists of the
following:

1. One pointer may be subtracted from another.

2. An int or a long, either variable or constant, may be added to a pointer
   or subtracted from it.

3. The operators ++ or -- may be used to increment or decrement a pointer.

No other  pointer arithmetic is permitted.  No  arithmetic can be performed
on pointers to non-scalar objects, e.g., pointers to functions.

When an  int or long is  added to a pointer, it is  first multiplied by the
length of what the pointer is  declared as pointing to.  Thus, if a pointer
to an int is incremented by two, it points down two more ints, not two more
characters.  The following program demonstrates this feature:

char *pc = "Welcome";
int array[5] = { 1, 2, 3, 4, 5 };
int  *pi = array;

main()
{
     pc += 2;  /* pc points to  'l' */
     pi += 2;  /* pi points to 3 */
}

See Also

C language
data formats
operators,
portability,
Programming COHERENT
ANSI Standard,  §6.1.2.5, §6.2.2.1, §6.2.2.3, §6.3.2.2-
3, §6.5.4.1

© 2012 by Stephen A. Ness