Lecture – Pointers and Arrays

Table of Contents

• Lecture – Pointers and Arrays
  • Table of Contents
  • Pointers and Arrays
  • Multiple operators can dereference pointers
  • Pointee Type and Array Element Type
  • So, how is an array different than a pointer?
    • Cant change where the array associated with an array name is
      • Generate a new view of an existing array
    • Usually an array decays into a pointer to the first element, but not always
  • Arrays as function parameters are pointers
  • Pointer Arithmetic
  • Iterating through an Array
  • Function Array Arguments
  • Array Length
  • Iteration through an Array
  • Arrays, strings, and pointers question
  • Arrays of pointers and arrays of strings
  • Beware of pointers to string literals and constant arrays
  • Command Line Arguments

Pointers and Arrays

• In C, there is a strong relationship between pointers and arrays.

• The declaration int a[10]; defines an array of 10 integers.

• The declaration int *p; defines p as a "pointer to an int".

• The assignment p = a; makes p an alias for the array and sets p to point to the first element of the array.

  • Could also write p = &a[0]; or p=&(a[0]);

• We can now reference members of the array using either a or p

  a[4] = 9;  
  p[3] = 7; 
  int x = p[3] + a[4] * 2;  //Same as int x = a[3] + p[4] * 2;
  

Multiple operators can dereference pointers

Let there be the declarations

int a[]={1,2,3,4,5,6,7,8}; 
int *intPtr; 

a is actually an address that can be referenced with an offset

a[0], so the square bracket operator [ ] is actually dereferencing with an offset

In fact, we can do the same with the pointer variable.

intPtr=a;

or

intPtr=&(a[0]); 

result in
intPtr[0] is the value 1;

So, we have learned two of three ways to dereference pointers:

Pointee Type and Array Element Type

• If p is a pointer to the type of the base element of an array, and p points to a particular element of an array, then p + 1 points to the next element of the array and p + n points n elements after p

• The meaning a "adding 1 to a pointer" is that
  p + 1 points to the next element in the array.

• Example:

  • int * p; The pointee type is int
  • int a[10];  The element type is int
  • int ** p;  The root pointee type is int , but p has an pointee type of int *

• The meaning of "adding an integer to a pointer" is that p + i is pointing to memory at address p with offset i*sizeof(pointee_type)

• The name of an array is nearly equivalent to a pointer where pointer arithmetic is concerned

  • when used in pointer arithmetic, the array decays into a pointer to the first element of the array

• Therefore, if a is the name of an array, the expression a[i] is functionally equivalent to *(a + i).

• &a[ i ] and (a + i) access the same element. Both access the i-th element beyond the starting element of a.

• since p is a pointer, it may also be used with a subscript as if it were the name of an array.
  p[ i ] is identical to *(p + i)

So, how is an array different than a pointer?

• If the name of an array is synonymous with a pointer to the first element of the array, and function parameters defined as arrays are "almost" like pointers, then what's the difference between an array name and a pointer?

Cant change where the array associated with an array name is

• One difference is that an array name can only "point" to the first element of its array (there is an exception to this rule when the array is a function parameter).  It can't be changed to point to anything else.  A pointer may be changed to point to any variable or array of the appropriate type

  • e.g. can't do the following:

  int vec[3] = {1,2,3}; 
  int i; 
  vec = &i;
  

  We aren't free to change the address stored in "variable" vec (may only be a compile time variable) like we can with an actual pointer. vec is more like a const pointer (int * const v=&(a[0]);)

  On the other hand, a pointer can point to an array, and then be pointed to other elements, and then be pointed to another location entirely

  int g, grades[ ] = {10, 20, 30, 40 }, myGrade = 100, yourGrade = 85, *pGrade; 
  
  /* grades can be (and usually is) used as array name */ 
  for (g = 0; g < 4; g++) 
      printf("%d\n",grades[g]); 
  
  /* grades can be used as a pointer to its array if it doesn't change*/ 
  for (g = 0; g < 4; g++) 
      printf("%d\n", *(grades + g)); 
  
  /* but grades can't point anywhere else */ 
  grades = &myGrade;        /* compiler error */ 
  
  /* pGrades can be an alias for grades and used like an array name */ 
  pGrades = grades;        /* or pGrades = &(grades[0]); */ 
  for( g = 0; g < 4; g++) 
      printf( "%d\n", pGrades[g]); 
  
  /* pGrades can be an alias for grades and be used like a pointer that changes */ 
  for (g = 0; g < 4; g++) 
      printf("%d\n",*(pGrades++));  //pGrades=pGrades+1 after each execution
  
  /* BUT, pGrades can point to something else entirely other than the grades array */ 
  pGrades = &myGrade; 
  printf( "%d\n", &pGrades); 
  pGrades = &yourGrade; 
  printf( "%d\n", &pGrades);
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

Generate a new view of an existing array

	int image5x5[25];
	int *middleRow = &arr[10];
	int *middle = &arr[12];

$$\begin{matrix} &0 & 1 & 2 & 3 & 4\\ &5 & 6 & 7 & 8 & 9\\ \rightarrow &\underline{10} & 11 & \textcircled{12} & 13 & 14\\ &15 & 16 & 17 & 18 & 19\\ &20 & 21 & 22 & 23 & 24 \end{matrix}$$

• middleRow[1] accesses element 1 of the middle row
• middle[-1] accesses the element just before (to the left) the middle pixel of the image

If you allocate an extra terminating element, you are allowed to get the address of it and work backwards:

	int image5x5[26];
	int *end = &arr[25];

• end[-1] is the last element
• end[-2] is the second-to-last element
• note if image5x5 is declared with size [25], you might be temped to use ptr=&arr[24]+1; but the address is not well-defined and may not work as expected accord to the C standard. I imagine one could have another member of a struct following the array and at least avoid moving into an invalid space, but check your C standard carfully

Usually an array decays into a pointer to the first element, but not always

• the value of array is the contents of the array, and the sizeof is the size of the entire array, but the use of the array label decays into a pointer to the first element under many circumstances
  • exceptions
    • &
      • &array generates a pointer to an array (e.g. (int (*)[8]) ), for which pointer arithmetic increments by the sizeof the entire array
      • &pointer generates a pointer to a pointer, for which pointer arithmetic increments by the sizeof a pointer
    • sizeof
      • sizeof(pointer) returns the size of a pointer
      • sizeof(array) returns the size of the array
    • in the form of an initializer e.g. = {10,20} or ="hello", the arrays can not be used with all the same syntax as a pointer

Arrays as function parameters are pointers

With respect to a function's formal parameters, C treats a one-level array just like a pointer (multi-dimensional and variable-length arrays will be discussed in a later lecture)

The following results from a function call from main to bubble(int arr[]) illustrate this as will as similarities and differences between arrays and pointers

File bubble.c:

void bubble(int arr[]){
  int tmp;
  for (int i=0;i<(4-1);i++){
    if (arr[i+1]<arr[i]){
      tmp=arr[i];
      arr[i+1]=arr[i];
      arr[i]=tmp;
    }
  }
}

int main() {
  int arr[8]={10,30,20,40};
  bubble(arr);
  return arr[0];
}

gcc -Wall -g -O0 bubble.c
gdb ./a.out

b bubble.c:3
run

Pointer Arithmetic

• If "p" is an alias for an array of ints, then p[ k ] is the $\rm (k+1)^{\it th}$ int and so is *(p + k).
• If "p" is an alias for an array of doubles, then p[ k ] is the $\rm (k+1)^{\it th}$ double and so is *(p + k).
• Adding a constant, k, to a pointer (or array name) actually adds k * sizeof(pointee type) to the value of the pointer.
• This is one important reason why the type of a pointer must be specified when it's defined.  Also, note that all pointers in a given system are the same size (one memory address).

Work through the following code and find what it prints by practicing diagraming pointers.

ptrAdd.c:

int main() {  
  char c, *cPtr = &c; 
  int i, *iPtr = &i; 
  double d, *dPtr = &d; 
  printf("\nThe addresses of c, i and d are:\n"); 
  printf("cPtr = %p, iPtr = %p, dPtr = %p\n",             cPtr, iPtr, dPtr) ;  
  cPtr = cPtr + 1 ; 
  iPtr = iPtr + 1 ; 
  dPtr = dPtr + 1 ; 
  printf("\nThe values of cPtr, iPtr and dPtr are:\n") ; 
  printf("cPtr = %p, iPtr = %p, dPtr = %p\n\n",         cPtr, iPtr, dPtr) ; 
  return 0; 
}

Iterating through an Array

• The code below shows how to use a parameter array name as a pointer.

• Notice the expression *grades++ .

  void printGrades( int grades[ ], int size )  //same as int * grades, int size
  { 
    int i; 
    for (i = 0; i < size; i++) 
      printf( "%d\n", *grades++);  //I prefer to write *(grades++) 
  } 
  

• What about the following prototype? Is it compatible?

  void printGrades( int *grades, int size);
  

• Does this alternative body do the same?

  {
    int * gradesEnd = grades+size; 
    for (; grades < gradesEnd; grades++) 
      printf( “%d\n”, *grades);
  } 
  

  what about this?

  {
    int * gradesEnd = grades+size; 
    for (; grades < gradesEnd;) //same as while 
      printf( “%d\n”, *grades++);
  } 
  

Function Array Arguments

• When an one-dimensional array is passed to a function, the address of the array is copied onto the function parameter.  Since an address is a pointer, the function parameter may be declared in either fashion.

  int sumArray( int a[ ], int size)
  

  is equivalent to

  int sumArray( int *a, int size)
  

• The compiler always sees the array argument a as a pointer within the function.   In fact, any error message produced within the function will refer to a as an int * in either version

Array Length

Managing array sizes in C is not a minor issue. (On an exam you should be prepare for questions about determining the size of an array or ask you about designing functions using arrays. )

Going outside the bounds of an array is not automatically checked and can lead to serious program or system crashes. The size of an array is also not usually available.

Basic approaches for approaching the design of functions using arrays in parameters are:

1. Predetermined Fixed Size: Use a predetermined size for the array or some other predetermined method for determining it that the caller and callee conform to
2. Additional Length Parameter: Use extra parameter to convey the number of elements in an array
3. Termination Value: Use a termination value in the array itself that can be discovered by iterating through the array.

Iteration through an Array

• size of array IS NOT automatically available

int SumArray( int a[ ], int length) 
{ 
  int k, sum = 0; 
  for (k = 0; k < length; k++) 
    sum += a[ k ]; 
  return sum; 
} 

Note the need to pass the size, which is not typically required in higher-level languages where the size of an array can be queried with expressions similar to

a.size()  

or

length(a) 

int a[]={3,1,4,1,5,9};
int len = sizeof(a)/sizeof(int);

const int PI_PRECISION=6;
int a[PI_PRECISION]={3,1,4,1,5,9};
int len = PI_PRECISION;

Use of pointer arithmetic with addition of variable offset

int SumArray( int arr[ ], int length) { 
  int k, sum = 0; 
  for (k = 0; k < length; k++) 
    sum += *(a + k);  //***
  return sum;  
} 

Using pointer arithmetic with fixed pointer increment:

int SumArray( int arr[ ], int length) { 
  int k, sum = 0;  
  for (k = 0; k < length; k++) 
    sum += *a++; //** implies use of dereference with auto-increment 
  return sum; 
} 

Arrays, strings, and pointers question

char hello[ ] = "Smith,Sara"; 

char * ptrChar; 

ptrChar = &(hello[6]); 

What is printed from each of the following?

printf("%s\n",hello); 

printf("%s\n",ptrChar ); 

printf("%s\n",&(hello[6])); 

printf("%s\n",hello + 6); 

printf("%s\n",hello[6]); //see compiler note 

What is wrong with this?

ptrChar[4]='h';

Would this be OK?

ptrChar[5]='\0';

Arrays of pointers and arrays of strings

Since a pointer is a variable type, we can create an array of pointers just like we can create any array of any other type.

A common use of an array of pointers is to create an array of strings.
The declaration below creates an initialized array of strings (char *) for some baby names.
The diagram below illustrates the memory configuration.

char *name[] = { "Bobby", "Sam", "Harold"};

Beware of pointers to string literals and constant arrays

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

int main(){
  char * name[]={"Bobby","Jim","Harold" }; //might be stored in read-only (e.g. program) memory
  printf("%s",name[1]);
  fflush(stdout); //needed to ensure output displayed before seg fault (useful to consider when debugging projects)
  name[1][2]='r'; // here
  printf("%s",name[1]);
  return 0;
}

Code compiles with no errors or warnings.

Code Output:

JimSegmentation fault

Command Line Arguments

• Command line arguments are passed to your program as parameters for main.

  int main( int argc, char *argv[ ] )
  

• argc is the number of command line arguments (and hence the size of argv)

• argv is an array of strings  which are the command line arguments. Note that argv[0] is always the name of your executable program.

• For example, typing myprog hello world 42 at the linux prompt results in

  argc = 4;
  argv[0] = "myprog";
  argv[1] = "hello";
  argv[2] = "world";
  argv[3] = "42";
  

• Note that to use argv[3] as an integer, you must convert it from a string to an int, perhaps by using the library function atoi( ). E.g. int age = atoi( argv[3] );