Pointers

Pointer Basics

• Memory is a vast collection of bits, either 0 or 1.
• Bits are grouped into 8-bit blocks called bytes. (8 is arbitrary but most modern computers use this.)
• Bytes are grouped into words depending on the wordsize of the computer:
• A 16-bit machine has 2 bytes per word
• A 32-bit machine has 4 bytes per word
• A 64-bit machine has 8 bytes per word
• Every byte in a computer's memory is uniquely identified by it's location in memory.
• Each location is a cell and has two attributes: an address (the cell's location in memory) and a value (contents of cell)
• Addresses and contents are known as l-values and r-values, respectively.
• Note that even though a word is made up of multiple bytes, it only has a single address.
• A byte is the smallest addressable unit (i.e. you can't address a single bit)
• All data in memory has an address from 0 up to the size of memory. 4 GB of memory would look like this (the contents are arbitrary)
• We can find out the address of a variable by simply using the address operator (which we've already seen with scanf)

  int i = 10;
  
  printf("The address of i is %p\n", (void *)&i); /* Use & to get the address */
  printf("The contents of i is %i\n", i);
  
  Output:
  The address of i is 0x22cca4
  The contents of i is 10
  

• Addresses look like integers, but they are different. (e.g. just like 3.0 is not the same as 3.0F or 3)

  3     00000000000000000000000000000011 (int)
  3.0F  01000000010000000000000000000000 (float)
  3.0   0100000000001000000000000000000000000000000000000000000000000000 (double)
  

• The compiler will complain if you treat an address like an integer and vice-versa.
• The type of the address depends on what is stored there. (e.g. the address of an integer is not the same type as an address of a float)
• Up until now, all of the addresses (variables) the compiler has been using for data have contained integer, float, and double values.
• An address (variable) that holds the address of another variable is called a pointer.

void foo(void)
{
  int i;  /* i can only store integer values            */
          /* The value of i is undefined at this point  */

  int *p; /* p can only store the address of an integer */
          /* The value of p is undefined at this point  */

  p = &i; /* The value of p is now the address of i     */
          /* The value of p is now defined              */
          
  i = 10; /* The value of i is now 10                   */
          /* The value of i is now defined              */
}

• identifier - The name of the identifier
• address - The arbitrary address (the actual values are meaningless, but are useful for discussion purposes)
• contents - The value stored at this location. ???? means it is undefined.
• When looking at arrays, since each cell is anonymous (unnamed), I'll only show the address above the first cell.

Visualizing the code above:

After declarations for i and p	After assignment to p	After assignment to i

Note: Be sure not to confuse the asterisk ( * ) used for multiplication with the asterisk used to declare pointers. They are the same token, but have very different meanings.

int    *pi; /* pi can only "point" to integers */
float  *pf; /* pf can only "point" to floats   */
double *pd; /* pd can only "point" to doubles  */
short  *ps; /* ps can only "point" to shorts   */
long   *pL; /* pL can only "point" to longs    */

unsigned short *pus; /* pus can only "point" to unsigned shorts */
unsigned int   *pui; /* pui can only "point" to unsigned ints   */

/* etc.... you get the idea   */

void foo(void)
{
  int i = 10;
  int *p = &i; /* operator * is used as a declaration here */

  printf("The value of i is %i\n", i);
  printf("The address of i is %p\n", (void *)&i);

  printf("The value of p is %p\n", (void *)p);
  printf("The address of p is %p\n", (void *)&p);
  printf("The value of what p is pointing at is %i\n", *p); /* operator * is dereferencing the pointer p */
}

Output:
The value of i is 10
The address of i is 0x22cca4
The value of p is 0x22cca4
The address of p is 0x22cca0
The value of what p is pointing at is 10

void f5(void)
{
  int i = 10;  /* i has the value 10     */
  int *p = &i; /* p has the address of i */
  int j;       /* j has undefined value  */ 

  printf("The value of i is %i\n", i);
  printf("The value of *p is %i\n", *p);

  j = *p;  /* j has the value of i   */
  *p = 20; /* i has the value 20     */

  printf("The value of j is %i\n", j);
  printf("The value of i is %i\n", i);
}

Output:
The value of i is 10
The value of *p is 10
The value of j is 10
The value of i is 20	

After declarations for i, p, j	After j = *p	After *p = 20

void foo(void)
{
  int i = 10;  /* i has the value 10     */
  int *p = &i; /* p has the address of i */
  int j;       /* j has undefined value  */ 

  j = p;  /* ILLEGAL: different types (compiler won't implicitly convert) */
  p = 20; /* ILLEGAL: different type (compiler won't implicitly convert)  */
}

void f7(void)
{
  int *p;  /* p has undefined value (some random memory location)      */
  *p = 10; /* BAD: writing the value 10 to some random memory location */
}

void foo(void)
{
  int i = 10; /* i gets value 10 */
  int *p;     /* undefined       */
  int *q;     /* undefined       */

  p = &i;   /* p gets address of i              */
  q = p;    /* q gets value of p (address of i) */

  *p = 20;  /* i gets value 20 (*p and *q evaluate to 20) */
  *q = 30;  /* i gets value 30 (*p and *q evaluate to 30) */
}

After declarations for p, q, i	After p = &i	After q = p

After *p = 20	After *q = 30

Self-check: Given the code below, which of the assignment statements are illegal and why? What does the compiler say about the illegal statements?

int i;   
int *pi; 

pi = i;   /* 1. ??? */
pi = 5;   /* 2. ??? */
pi = &i;  /* 3. ??? */
*pi = i;  /* 4. ??? */
*pi = 5;  /* 5. ??? */
*pi = &i; /* 6. ??? */

  /* Assume addresses of variables are */
  /* a:100, b:104, c:108, d:112, e:116 */
  /* Assume a 32-bit computer          */
int a = 10;
int b = 108;
float c = 3.14F;
int *d = &a;
float *e = &c;

Expression    Type         Value
---------------------------------
     a         int           10
     b         int          108
     c        float        3.14
     d        int *         100
     e       float *        108
    *d         int           10
    *e        float        3.14
    &a        int *         100
    &d        int * *       112
    *a       illegal       -----
    *b       illegal       -----
    *c       illegal       -----

Passing Pointers to Functions

int a, b, c;
scanf("%d%d%d", &a, &b, &c);

Suppose we want to write a function that exchanges the values of two integers. Here's our first (failed) attempt:

int main(void) { int x = 10; int y = 20; printf("Before: x = %i, y = %i\n", x, y); swap(x, y); printf(" After: x = %i, y = %i\n", x, y); return 0; }	/* Exchanges the values of the parameters */ void swap(int a, int b) { int temp = a; /* Save a for later */ a = b; /* a gets value of b */ b = temp; /* b gets old value of a */ } Output: Before swap: x = 10, y = 20 After swap: x = 10, y = 20

Note that to swap we can't just do this:

a = b; /* value of a is lost */
b = a;

Visually:

Initialize values, pass to swap	Make copy of a in temp	Exchange a,b

/* Exchanges the values of the parameters */ void swap(int *a, int *b) { int temp = *a; /* Save a for later */ *a = *b; /* a gets value of b */ *b = temp; /* b gets old value of a */ }	int main(void) { int x = 10; int y = 20; printf("Before swap: x = %i, y = %i\n", x, y); swap(&x, &y); printf(" After swap: x = %i, y = %i\n", x, y); return 0; } Output: Before swap: x = 10, y = 20 After swap: x = 20, y = 10

Visually:

In main before swap	Call swap, pass addresses	Make copy of a for later

Copy *b to *a (y to x in main)	Copy temp to *b (temp to y in main)

After swap in main	swap function is gone

Notes to remember:

• The correct swap function takes pointers to integers as parameters:

  void swap(int *a, int *b); /* a and b are pointers to integers */
  

• You must pass the address of the integers you wish to swap:

  int x = 10;
  int y = 20;
  swap(&x, &y); /* Must pass the addresses (pointers) of a and b */
  

• You must dereference the pointers in the function to get the contents:

  int temp = *a; /* Dereference the pointer with the * operator */
  

• Watch out for this:

  Incorrect		Correct
  /* Exchanges the pointers, incorrect */ void swap3(int *a, int *b) { int *temp = a; /* Save a for later */ a = b; /* a gets value of b */ b = temp; /* b gets old value of a */ }		/* Exchanges the pointers, correct */ void swap4(int **a, int **b) { int *temp = *a; /* Save a for later */ *a = *b; /* a gets value of b */ *b = temp; /* b gets old value of a */ }

  The code above (left) is simply swapping the pointers inside the function. However, what is actually being swapped are copies of the pointers. Remember, all functions in C take parameters by value, which means that we are making a copy everytime. The question becomes: "A copy of what?" The code on the right shows the correct way to swap pointers.

Passing Arrays to Functions (review)

Let's see how this might be a problem.

This example works as expected (It finds the largest element in an array of integers). A pointer to the first element is passed to the function find_largest, along with the size (number of elements) in the array. Since the function has a pointer to the first element, it can access every element of the array using the subscript operator:

int main(void) { int a[] = {4, 5, 3, 9, 5, 2, 7, 6}; int largest; printf("Array before:\n"); print_array(a, 8); largest = find_largest(a, 8); printf("Largest value: %i\n", largest); printf("Array after:\n"); print_array(a, 8); return 0; } Output: Array before: 4 5 3 9 5 2 7 6 Largest value: 9 Array after: 4 5 3 9 5 2 7 6	/* Assumes there is at least */ /* one element in the array */ int find_largest(int a[], int size) { int i; int max = a[0]; /* assume 1st is largest */ for (i = 1; i < size; i++) if (a[i] > max) max = a[i]; /* found a larger one */ return max; }

Now, the function is modifying the original data (not a copy). It seems that passing a pointer to the data, rather than a copy, could be dangerous if the function does something we don't expect.

Passing a pointer to a function allows the function to modify our data even if we don't want it to:

/* Modifies the array the was passed in!! */ int find_largest_BAD(int a[], int size) { int i; int max = a[0]; /* assume 1st is largest */ a[0] = 0; /* change first element! */ for (i = 1; i < size; i++) { if (a[i] > max) max = a[i]; /* found a larger one */ a[i] = 0; /* set element to 0!! */ } return max; }	Output: Array before: 4 5 3 9 5 2 7 6 Largest value: 9 Array after: 0 0 0 0 0 0 0 0

/* Unable to modify the array since it's const */
int find_largest_BAD(const int a[], int size)
{
  int i;
  int max = a[0]; /* assume 1st is largest       */
  a[0] = 0;       /* ILLEGAL: elements are const */
  for (i = 1; i < size; i++)
  {
    if (a[i] > max) 
      max = a[i]; /* found a larger one          */
    a[i] = 0;     /* ILLEGAL: elements are const */
  }
  return max;
}

int find_largest(int a[], int size);

int main(void)
{
  const int a[] = {4, 5, 3, 9, 5, 2, 7, 6}; /* Elements are constant (can't be changed)  */
  int largest = find_largest(a, 8);         /* ILLEGAL: Function expects non-const array */
  
  return 0;
}

Important: When you create a function that will accept arrays as parameters, be sure to mark them as const if you do not intend to modify them. If you don't make them const, a lot of code will not be able to use your function.

Now that we know that when passing arrays to functions, we are really just passing a pointer, these function declarations are 100% identical. Period. Absolutely NO difference. At. All. It is purely cosmetic, the compiler treats them exactly the same, always, every time, without exception. Any questions?

int find_largest(int a[], int size); /* Use array notation   */
int find_largest(int *a, int size);  /* Use pointer notation */

Finally, never do this! Never return a pointer to a local variable. Ever. In other words, don't do this:

/* Function returns a pointer to an int */
int *foo(void)
{
  int i = 10; /* i is local (on the stack)      */
  return &i;  /* This will soon be undefined!!  */
}

Fortunately, most compilers today will point out the sheer insanity of your code:

main.c: In function `foo':
main.c:174: warning: function returns address of local variable

More on const

With pointers, you have more flexibility with const. You can make the pointer itself constant, which means once it points at something, it can never be changed to point at something else. Or, you can make the data pointed at constant, which means that although you can change the pointer to point at something else, you can't change what's being pointed at.

Here are the four cases:

1. Neither the pointer nor the data being pointed at (the pointee) is const. Both can be changed:

   int *pi = &i; /* pi is a (non-const) pointer to a (non-const) int */
   

   

2. The pointer is not const, but the data pointed at (the pointee) is const. The data is protected. Only the pointer can change:

   const int *pci = &i; /* pci is a pointer to a const int */
   

   

3. The pointer is const but the data being pointed at is non-const. The pointer is protected. The data can be changed through the pointer.

   int * const cpi = &i; /* cpi is a const pointer to an int */
   

   

4. Both the pointer and the data being pointed at are const. Both are protected. Neither can be changed:

   const int * const cpci = &ci;  /* cpci is a const pointer to a const int */
   

   

• If you mark something as const, you are indicating that it should not change.
• If you DO NOT mark something as const, you are indicating that it should change.
• Therefore, if you are not going to change some data in your program, make sure to mark it const.
• Note that with function parameters, these rules really only apply to pointers (addresses) and arrays. Why?
• Answer: Because by passing pointers, you are giving the function direct access to your data.
• When reading pointer declarations with const, read it from right-to-left instead of left-to-right.
• The const is a qualifier on the type.
• The "constness" of the pointer has no bearing on the data being pointed at. (See #2 above)
• Video review

Self-check: Here is an example that shows the const keyword in action in various ways. Make sure you understand every statement.

void foo(void)
{
  int i = 5;          /* 1. i is a non-constant int */
  int j = 6;          /* 2. j is a non-constant int */
  const int ci = 10;  /* 3. ci is a constant int    */
  const int cj = 11;  /* 4. cj is a constant int    */

  int *pi;                      /* 5. pi is a pointer to an int              */
  const int *pci;               /* 6. pci is a pointer to a const int        */
  int * const cpi = &i;         /* 7. cpi is a const pointer to an int       */
  const int * const cpci = &ci; /* 8. cpci is a const pointer to a const int */

  i = 6;      /*  9. Ok, i is not const    */
  j = 7;      /* 10. Ok, j is not const    */
  ci = 8;     /* 11. ERROR: ci is const    */
  cj = 9;     /* 12. ERROR: cj is const    */

  pi = &i;    /* 13. Ok, pi is not const   */
  *pi = 8;    /* 14. Ok, *pi is not const  */
  pi = &j;    /* 15. Ok, pi is not const   */
  *pi = 9;    /* 16. Ok, *pi is not const  */

  pci = &ci;  /* 17. Ok, pci is not const  */
  *pci = 8;   /* 18. ERROR: *pci is const  */
  pci = &cj;  /* 19. Ok, pci is not const  */
  *pci = 9;   /* 20. ERROR: *pci is const  */

  cpi = &j;   /* 21. ERROR: cpi is const   */
  *cpi = 10;  /* 22. Ok, *cpi is not const */
  *cpi = 11;  /* 23. Ok, *cpi is not const */

  cpci = &j;  /* 24. ERROR: cpci is const  */
  *cpci = 10; /* 25. ERROR: *cpci is const */
  
  pi = &ci;   /* 26. DANGER: constant ci can be changed through pi */
}

Detailed messages

This is why #26 is marked DANGER:

const int value1 = 10; /* const, once initialized, cannot change */

void bar(void)
{
  const int value2 = 5; /* const, once initialized, cannot change          */
  int *pi1 = &value1;   /* DANGER, var can be changed through the pointer! */
  int *pi2 = &value2;   /* DANGER, var can be changed through the pointer! */

  value1 = 10; /* ERROR, constant */
  value2 = 10; /* ERROR, constant */

  *pi1 = 10; /* Woops! Warning, bad things can happen! */
  *pi2 = 10; /* Woops! Warning, bad things can happen! */
}