Do you know that? $49 average hourly rates for Graphic Designer freelance next

When is a null pointer used?

The null pointer is used in three ways:

1. To stop indirection in a recursive data structure.

2. As an error value.

3. As a sentinel value.

1. Using a Null Pointer to Stop Indirection or Recursion

Recursion is when one thing is defined in terms of itself. A recursive function calls itself. The following
factorial function calls itself and therefore is considered recursive:

/* Dumb implementation; should use a loop */
unsigned factorial( unsigned i )
{
     if ( i == 0 || i == 1 )
     {
          return 1;
     }
     else
     {
          return i * factorial( i - 1 );
     }
}

A recursive data structure is defined in terms of itself. The simplest and most common case is a (singularly)
linked list. Each element of the list has some value, and a pointer to the next element in the list:

struct string_list
{
     char    *str;   /* string (in this case) */
     struct string_list      *next;
};

There are also doubly linked lists (which also have a pointer to the preceding element) and trees and hash
tables and lots of other neat stuff. You'll find them described in any good book on data structures.
You refer to a linked list with a pointer to its first element. That's where the list starts; where does it stop?
This is where the null pointer comes in. In the last element in the list, the next field is set to NULL when there
is no following element. To visit all the elements in a list, start at the beginning and go indirect on the next
pointer as long as it's not null:

while ( p != NULL )
{
     /* do something with p->str */
     p = p->next;
}

Notice that this technique works even if p starts as the null pointer.

2. Using a Null Pointer As an Error Value

The second way the null pointer can be used is as an error value. Many C functions return a pointer to some
object. If so, the common convention is to return a null pointer as an error code:

if ( setlocale( cat, loc_p ) == NULL )
{
     /* setlocale() failed; do something */
     /* ... */
}

This can be a little confusing. Functions that return pointers almost always return a valid pointer (one that
doesn't compare equal to zero) on success, and a null pointer (one that compares equal to zero) pointer on
failure. Other functions return an int to show success or failure; typically, zero is success and nonzero is
failure. That way, a "true" return value means "do some error handling":

if ( raise( sig ) != 0 ) {
        /* raise() failed; do something */
        /* ... */
}

The success and failure return values make sense one way for functions that return ints, and another for
functions that return pointers. Other functions might return a count on success, and either zero or some
negative value on failure. As with taking medicine, you should read the instructions first.

Using a Null Pointer As a Sentinel Value

The third way a null pointer can be used is as a "sentinel" value. A sentinel value is a special value that marks
the end of something. For example, in main(), argv is an array of pointers. The last element in the array
(argv[argc]) is always a null pointer. That's a good way to run quickly through all the elements:

/* A simple program that prints all its arguments. 
It doesn't use argc ("argument count"); instead, 
it takes advantage of the fact that the last value 
in argv ("argument vector") is a null pointer. */
#include <stdio.h>
#include <assert.h>
int
main( int argc, char **argv)
{
        int i;
        printf("program name = \"%s\"\n", argv[0]);
        for (i=1; argv[i] != NULL; ++i)
                printf("argv[%d] = \"%s\"\n", i, argv[i]);
        assert(i == argc);    
        return 0; 
}