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().

Sorting an array of values

Sorting an array of values, contined

#include <stdlib.h>

void qsort(void *array,
           size_t number_of_elements,
           size_t sizeof_each_element,
           int (*comparison_function)(const void *p1, const void *p2) ); 

1. qsort() is a function returning no value (a function of type void).

2. qsort() is a function receiving 4 parameters.

3. the 1st parameter is a pointer (think of it as an array), but qsort() doesn't care if it's an array of integers, an array of characters, or even an array of our own user-defined types.
   For this reason, we use the generic pointer, pronounced "void star" or "void pointer". This means that qsort() receives a pointer (the beginning of an array), but qsort() doesn't care what type it is.

4. the 2nd parameter indicates how many elements are in the array (how many are to be sorted). Standard C's type size_t is used (think of it as an integer whose value must be 0 or positive).

5. the 3rd parameter indicates the size of each array element. As qsort() doesn't know the datatype it's sorting, it needs to know how "big" each element is.

6. the 4th parameter... Oh boy! Where do we start?
   1. comparison_function is a function (that we must provide) that returns an integer.
   2. it receives 2 parameters, p1 and p2, each of which is a pointer.
   3. a pointer to what? We don't care (yet), so we declare p1 and p2 as "void pointers".
   4. comparison_function finally promises to not change what its parameters p1 and p2 point to, and so p1 and p2 are preceded by the keyword const, making p1 and p2 each a constant pointer.

Sorting an array of integers

#include <stdio.h>
#include <stdlib.h>

#define  N    10

int main(int argc, char *argv[])
{
    int values[N];

// FILL OUR ARRAY WITH N INTEGERS BETWEEN 0 and 99
    srand( time(NULL) );
    for(int i=0 ; i<N ; i++) {
        values[i] = rand() % 100;
    }
// PRINT THE ARRAY BEFORE SORTING
    for(int i=0 ; i<N ; i++) {
        printf("%i  ", values[i]);
    }
    printf("\n\n");

// SORT THE ARRAY USING qsort
    qsort(values, N, sizeof(values[0]), compareints);   

// PRINT THE ARRAY AFTER SORTING
    for(int i=0 ; i<N ; i++) {
        printf("%i  ", values[i]);
    }
    printf("\n");

    return 0;
}

Sorting an array of integers, continued

int compareints(const void *p1, const void *p2)
{
    int *ip1 = (int *)p1;
    int *ip2 = (int *)p2;

    int value1 = *ip1;
    int value2 = *ip2;

    if(value1 < value2) {
        return -1;
    }
    else if(value1 > value2) {
        return 1;
    }
    return 0;
}

1. We first convert the void pointers to integer pointers, with:

         int *ip1 = (int *)p1;
         int *ip2 = (int *)p2;
   

2. We next extract each integer value pointed to by our integer pointers.

         int value1 = *p1;
         int value2 = *p2;
   

3. We finally report (return) to qsort() the ordering of these two values. qsort() expects:
   1. a negative value if the 1st value is less-than the 2nd,
   2. zero if the 1st value and 2nd values are equal, and
   3. a positive value if the 1st value is greater-than the 2nd.
   We can support this simply by subtracting one value from the other.