Some Guidelines on Pointers
So when do you use * and &?

Pointer specification and deferencing traditionally cause more problems for programmers in C than anything else. The following is a short summary of their usage which, whilst not complete, should be sufficient to reduce the debugging strategy of arbitrarily inserting /removing & or * in the code and thinking positive thoughts.

• Declaring Pointer Variables.
   
  In a variable declaration, * means that the variable is a (starting) address.
  Hence type1* A defines a variable to store an address.
   
  Addresses don't have types, so why the type1? The most likely reason you would want to know an address is so you can do something with the data at that address, and it is usually necessary to know the type of the data you are operating on.
  Hence type1* A declares a starting address for data of type type1.
  If you really don't care about the type of the data you can use void* A
   
  Note that you never use an & in variable declarations.

• Using pointers to pass parameters
   
  Why would you want to specify an address?
  The most common reasons for using pointers is in passing data as a parameter to a function and the data is
   
  

  1. either too large or of indeterminate length,to pass as a parameter by value i.e. by copying it onto the stack
  2. the called function is to return you a set of values at the address specified
      
     
  Consider

        myFunction1(type1 X);
        myFunction2(type1* Y);
        
        main()
        {
            type1 A;
            type1 *B;
            
            myFunction1(A);
            myFunction2(B);
      

  In the first case, a copy of A (however large) is made and placed on the stack before myFunction1 is called.
  In the second a 4-byte address is placed on the stack before myFunction2 is called. So what is this address that is passed in B?
  There are 2 possibilities:
   
  
  1. The calling program reserves some space for data of type1 and passes the address for myFunction to fill it in. We need an operator to tell us the address of any variable - hence the &
     

      
           type1 A; /* reserve space of type1 */
           
           calledFunction(&A); /* tell myFunction where it is */
           

     The called function will receive an address so its definition must have the form
     

           calledFunction(type1 *anAddress)
           

     
      
     
  2. The called program has reserved the space for the data (perhaps via a malloc() call or a static declaration), fills it in and tells the calling program where to find it. The calling program only has to reserve enough space for this address
     

           type 1 *A; /* reserve 4 bytes for an address */
           
           A = calledFunction(); /* here it is */
           

     The called function will return an address so its definition must have the form
     

           type1 *calledFunction()
           

• Examples of Parameter Passing
   
  

  1. scanf() reads input, interprets it according to a format statement and stores it where it is told i.e. the calling program must have declared variables to hold the results and then pass scanf() the format statement and a list of the addresses of these variables.
     

           int A;
           char B;
           
           scanf("%d:%c\n", &A,&B);
           

     If the input line was 1234:b then A would contain the integer 1234 and B the character b
      
     
  2. stat() fills in a inode structure with the details for a particular pathname. The calling program must have reserved space for the inode structure - a struct (i.e. record) of type stat.
     

           struct stat inode;
           char path[255];
           int status;
           
           status = stat(path,&inode);
           

     
      
     
  3. opendir() creates a copy of a DIR stream entry and returns the address of this struct to the calling program.
     

           DIR *directory;
           char path[255];
           
           directory = opendir(path);
           

     
      
     

• De-referencing Pointers
   
  Pointers are typically used to pass addresses to or return addresses from functions. So how do we access the data that to which these addresses relate?
   
  Consider the case where the calling function reserves the space.

               'calling function'         myFunction(type1 *B)
      
               type1 variableA;          
               
               myFunction(&variableA);    *B = xxxxxxx
      
     

  If the data is a simple type (e.g. int, char etc.)

  • the calling function refers to it by its name i.e A
  • myFunction receives A's address as a parameter, so to access the data values it must specify 'the thing pointed at by the parameter' this is indicated as i.e. *B.

  Note that "type1 *anAddress" in a declaration reserves space for a variable of type1 but gives it no value.
  "*anAddress" in an expression gives the type1 value at memory location anAddress.
   
  If the data is an array, the name of the array specifies the address of the array, not its values i.e. A is the same as &A in this special case.
  To refer to the first element of A, use A[0] or *A (the first thing at address A). Thus both calling and called functions can refer to an array variable by its name.
   
  If the data is a structured type, i.e. has fields defined within it, the calling program refers to fields as direct elements i.e. A.field1name.
  The called program only has an address so it has to refer to the field indirectly as the "field of the structure pointed to by the address" i.e. anAddress->fieldname1

• copy the following program to a file pointers.c
• compile it gcc -o pointers pointers.c
• run it with some command line arguments e.g. pointers hello world

/* pointers.c -  */

main(int argc, char **argv)
{
      int   i,j;
      char* string;
      printf("\t\t\tMemory Location/Type\n");
      printf("Name\t\t\tchar**\tchar*\tchar\t\tValue\n\n");
      
      printf("argv  \t\t\t%d \t\t\t%d \n",&argv, argv); 
  
      for (i=0;i<argc;i++) 
      {
            printf("   argv[%d] \t\t\t%d \t\t%d  \n",i,&argv[i],argv[i]); 
            for (j=0;*(argv[i]+j)!=0;j++)
            {
                  printf("\t argv[%d][%d] \t\t\t%d \t%c \n",i,j,&argv[i][j],argv[i][j]);
             }
            printf("\t *(argv[%d]+%d) \t\t\t%d \tNULL \n",i,j,argv[i]+j);
      }

      printf("\n\nNOTE FROM THE ABOVE THAT\n\n");
      printf("1. If a variable NAME is of type XXX**, then it represents a list of addresses\n");
      printf("   and its value is the address of the head, %d , of the list\n\n",argv);
      printf("2. Each element of the list is of type XXX* and represents a list of XXX's\n");
      printf("   and the ith element is the address of the start, %d for i=0,of \n",argv[0]);
      printf("   list NAME[i]. Since each element is a pointer, it is %d bytes long\n\n",sizeof(char*));
      printf("3. Each element of NAME[i] is of type XXX and of length %d byte(s)\n",sizeof(char));
      printf("   It can be referred to as NAME[i][j] or as *(NAME[i]+j) i.e. the value of \n");
      printf("   the element located j*sizeof(XXX) bytes from the start of NAME[i] e.g.\n");
      printf("    argv[0][1]   located at %d with value %c is the same as\n",&argv[0][1],argv[0][1]);
      printf("    *(argv[0]+1) located at %d with value %c \n\n\n",argv[0]+1,*(argv[0]+1));

}