Passing pointers to functions

#include <stdio.h>

void swap(int i, int j)
{
    int temp;

    temp = i;
    i    = j;
    j    = temp;
}

int main(int argc, char *argv[])
{
    int a=3, b=5;  // MULTIPLE DEFINITIONS AND INITIALIZATIONS  

    printf("before a=%i, b=%i\n", a, b);

    swap(a, b);    // ATTEMPT TO SWAP THE 2 INTEGERS

    printf("after  a=%i, b=%i\n", a, b);
    return 0;
}

before a=3, b=5
after  a=3, b=5

Passing pointers to functions, continued

#include <stdio.h>

void swap(int *ip, int *jp)
{
    int temp;

    temp  = *ip;    // swap's temp is now 3
    *ip   = *jp;    // main's variable a is now 5
    *jp   = temp;   // main's variable b is now 3
}

int main(int argc, char *argv[])
{
    int a=3, b=5;

    printf("before a=%i, b=%i\n", a, b);

    swap(&a, &b);   // pass pointers to our local variables  

    printf("after  a=%i, b=%i\n", a, b);

    return 0;
}

before a=3, b=5
after  a=5, b=3

• The function swap() is now dealing with the original variables, rather than new copies of their values.
• A function may permit another function to modify its variables, by passing pointers to those variables.
• The receiving function now modifies what those pointers point to.

Duplicating a string

• C considers null-byte terminated character arrays as strings, and
• that the length of such strings is not determined by the array size, but by where the null-byte is.

#include <string.h>

char *my_strdup(char *str)
{
    char bigarray[SOME_HUGE_SIZE];

    strcpy(bigarray, str);  // WILL ENSURE THAT bigarray IS NULL-BYTE TERMINATED 

    return bigarray;        // RETURN THE ADDRESS OF bigarray
}

1. we'd never be able to know the largest array size required to copy the arbitrary string argument, and
2. we can't return the address of any local variable. Once function my_strdup() returns, variable bigarray no longer exists, and so we can't provide the caller with its address.

Allocating new memory

#include <stdlib.h>

extern void *malloc( size_t nbytes );

• malloc() is a function (external to our programs) that returns a pointer.
  However, malloc() doesn't really know what it's returning a pointer to - it doesn't know if it's a pointer to an integer, or a pointer to a character, or even to one our own user-defined types.
  For this reason, we use the generic pointer, pronounced "void star" or "void pointer".
  It's a pointer to "something", and we only "know" what that is when we place an interpretation on the pointer.

• malloc() needs to be informed of the amount of memory that it should allocate - the number of bytes we require.
  We use the standard datatype size_t to hold an integer value that may be 0 or positive (we obviously can't request a negative amount of memory!).
  We have used, but skipped over, the use of size_t before - it's the datatype of values returned by the sizeof operator, and the pedantically-correct type returned by the strlen() function.

Checking memory allocations

#include <stdlib.h>

  size_t bytes_wanted   = 1000000 * sizeof(int);

  int    *huge_array    = malloc( bytes_wanted );

  if(huge_array == NULL) {   // DID malloc FAIL?
      printf("Cannot allocate %i bytes of memory\n", bytes_wanted);    
      exit( EXIT_FAILURE );
  }

Duplicating a string revisited

#include <stdlib.h>
#include <string.h>

char *my_strdup2(char *str)
{
    char *new = malloc( strlen(str) + 1 );

    if(new != NULL) {
        strcpy(new, str);  // ENSURES THAT DUPLICATE WILL BE NUL-TERMINATED 
    }
    return new;
}

• we are not returning the address of a local variable from our function - we've solved both of our problems!

• we're returning a pointer to some additional memory given to us by the operating system.

• this memory does not "disappear" when the function returns, and so it's safe to provide this value (a pointer) to whoever called my_strdup2.

• the new memory provided by the operating system resides in a reserved (large) memory region termed the heap. We never access the heap directly (we leave that to malloc()) and just use (correctly) the space returned by malloc().

Allocating an array of integers

#include <stdlib.h>

int *randomints(int wanted)
{
    int  *array = malloc( wanted * sizeof(int) );

    if(array != NULL) {
        for(int i=0 ; i<wanted ; ++i) {
             array[i] = rand() % 100;
        }
    }
    return array;
}

• malloc() is used here to allocate memory that we'll be treating as integers.
• malloc() does not know about our eventual use for the memory it returns.
• how much memory did we need?
  We know how many integers we want, wanted, and we know the space occupied by each of them, sizeof(int).
  We thus just multiply these two to determine how many bytes we ask malloc() for.

Requesting that new memory be cleared

#include <stdlib.h>

extern void *calloc( size_t nitems, size_t itemsize );
    ....
    int  *intarray = calloc(N, sizeof(int));

#include <stdlib.h>
#include <string.h>

void *my_calloc( size_t nitems, size_t itemsize )
{
    size_t  nbytes  = nitems * itemsize;

    void *result = malloc( nbytes );

    if(result != NULL) {
        memset( result, 0, nbytes );  // SETS ALL BYTES IN result TO THE VALUE 0  
    }
    return result;
}

    ....
    int  *intarray = my_calloc(N, sizeof(int));

Deallocating memory with free

• run for a long time
  (perhaps long-running server programs such as web-servers), or
• temporarily require a lot of memory, and then no longer require it,

extern void free( void *pointer );

#include <stdlib.h>

    int   *vector = randomints( 1000 );

    if(vector != NULL) {
        // USE THE vector
        ......
        free( vector );
    }

Reallocating previously allocated memory

extern void *realloc( void *oldpointer, size_t newsize );

#include <stdlib.h>

  int  original;
  int  newsize;
  int  *array;
  int  *newarray;

  ....
  array = malloc( original * sizeof(int) );  
  if(array == NULL) {
      // HANDLE THE ALLOCATION FAILURE
  }
  ....

  newarray = realloc( array, newsize * sizeof(int) );
  if(newarray == NULL) {
      // HANDLE THE ALLOCATION FAILURE
  }
  ....

#include <stdlib.h>

  int  nitems = 0;
  int  *items = NULL;

  ....
  while( fgets(line ....) != NULL ) {
      items = realloc( items, (nitems+1) * sizeof(items[0]) );
      if(items == NULL) {
              // HANDLE THE ALLOCATION FAILURE
      }
      ....    // COPY OR PROCESS THE LINE JUST READ
      ++nitems;
  }
  ....
  if(items != NULL) {
      free( items );
  }

• if realloc() fails to allocate the revised size, it returns the NULL pointer.
• if successful, realloc() copies any old data into the newly allocated memory, and then deallocates the old memory.
• if the new request does not actually require new memory to be allocated, realloc() will usually return the same value of oldpointer.
• a request to realloc() with an "initial" address of NULL, is identical to just calling malloc().