1 What is the name of an array?

• The name of an array, say arr, is a pointer constant
• Array is designed to store a number of elements with the same type.
  • arr and &arr[0] are equivalent.
  • The name arr can not be assigned by an address. The following is wrong

  int a=0;
  int arr[]={1,2,3};
  arr = &a; //Array type "int [3]" is not assignable

  • It’s address can be accessed, but usually there is a warnning

  int *pt;
  int arr[]={1,2,3};
  pt = &arr; //Incompatible pointer types assigning to "int *" from "int (*)[3]"

  • It’s element can be accessed by arr[2] or *(arr+2), which are equivalent

  int arr[]={1,2,3};
  printf("arr[2]= %d\t *(arr+2)= %d\n",arr[2],*(arr+2)); //They are equivalent

• For a 2-dimensional array arr[10][5]
  • Expression arr[0]+1 means that the computer moves arr[0] by sizeof(int) bytes
    • arr[0] is a pointer constant to the array with 5 elements: arr[0][0], \(\cdots\), arr[0][4]
  • Expression arr+1 means that the computer moves arr by 5*sizeof(int) bytes
    • arr is a pointer constant to the 1-dimensional array with 10 elements, each element of which stores a pointer to an int-array
    • arr stores 10 elements: arr[0], arr[1], …, arr[9]
  • It should be very clear that arr, arr[0], arr[1], …, arr[9] are all pointer constants

  int main(){
    int arr[10][5]={1,2,3,4,5;
    printf("arr=%p,\t arr[0]+1=%p,\t arr+1=%p,\t aar[1]=%p \n",arr, arr[0]+1, arr+1, arr[1]);
    return 0;
  }

  • The following is not allowed, because both arr and arr[0] are pointer constants

  int main(){
    int arr[10][5]={1,2,3,4,5};
    int a=1;
    arr=&a;
    arr[0]=&a;
    return 0;
  }

2 What is the pointer variable

• A pointer variable pt, short for pointer, is a variable with value pointing to some address
• The pointer is mainly designed to pass reference between functions, which avoids passing whole array.
  • Since it is a variable, it can be assigned by an address.

  int *pt;
  int arr[]={1,2,3};
  pt = arr; 

  • It has owen address, just like other variables

  int *pt;
  int arr[]={1,2,3};
  pt = arr; 
  printf("pt=%p,\t &pt=%p\n",pt,&pt);

  • It’s element can be accessed by pt[2] or *(pt+2), which are equivalent

  int arr[]={1,2,3};
   int *pt=arr;
   printf("pt[2]= %d\t *(pt+2)= %d\n",pt[2],*(pt+2)); //They are equivalent

  • In int *pt, we can treat int * as a new data type that is “int-pointer”
    • int * can be treated as an extension of type “int”
    • pt stores address that is treated as new type “int-pointer”
    • Thus, pt enjoys all properties of other variables, and is constrained to rules of other variables simultaneously
• Understand (*pt)[5]
  • Just like 2-dimensional array in previous section
  • understand the relationship of pt+1, *pt+1, pt[1]

  int main(){
    int arr[2][5]={1,2,3,4,5};
    int (*pt)[5];
  
    pt = arr;
    printf("pt=%p,\t*pt=%p,\tpt[0]=%p\n",pt+1,*pt+1,pt[1]);
  
    pt = arr+1;
    printf("pt=%p,\t*pt=%p,\tpt[0]=%p\n",pt,*pt,pt[0]);
    printf("&arr+1=%p,\t arr+1=%p,\t arr[1]=%p \n",&arr+1,arr+1,arr[1]);
  
    return 0;
  }

3 Comparison

• Difference from thier functions
  • Array is designed to store a number of elements with the same type
  • Pointer is mainly designed to pass reference between functions
• For the subscrip and iterator, a[2] or *(a+2) are equivalent, where a is either an array or a pointer
• For a 1-dimensional array in a function fun(), the follows are equivalent

int fun1(int a[],int n);
int fun2(int *a,int n);
int fun3(int a[20],int n); // They are equivalent

• For a 2-dimensional array in a function fun(), the follows are equivalent

int fun1(int a[][3],int n);
int fun2(int (*a)[3],int n);
int fun3(int a[2][3],int n);
// They are equivalent

• For the character array, It is allowed to assign a string when it is initialized, but not be allowed after initialized

char arr[]="I am Chinese!"; // allowed
arr = "I am student!"; //not be allowed

• For the character pointer, it is allowed to assign a string when it is initialized, and allowed too after initialized

char *pt="I am Chinese!"; // allowed
pt = "I am student!"; //allowed

• Operator ++ or - - are allowed for the pointer, but not for the array’s name

int arr[]={1,2,3};
int *pt=arr;
pt++; // Legal
arr++;// Illegal
printf("%d,\n", *(pt+1)) // allowed
printf("%d,\n", *(arr+1)) // allowed

• What is difference below
  • In int *pt1[10], pt1 is an array with 10 elements, each of which is a pointer to an “int”-type
  • In int (*pt2)[10], pt2 is a pointer to an array with 10 elements, each of which is an “int”-type

int *pt1[10];
int (*pt2)[10];

• What is difference below
  • Both arr and &arr are same, because arr is a pointer constant
  • Both pt and &pt are different, because pt is a variable

int main(){
  int arr[5]={1,2,3,4,5};
  int  *pt=arr;
  printf("pt=%p,\t&pt=%p,\n",pt,&pt);
  printf("arr=%p,\t&arr=%p,\n",arr,&arr);
  
  getchar();
  return 0;  
}

• What are *pt1+1 and *pt2+1

int main(){
   int arr[5]={1,2,3,4,5};
   int (*pt1)[3] = &arr;
   int (*pt2)[3] = arr;
   
   return 0;
}

4 Common syntar errors

• A value of type “int” can not be assigned to an entity of type “int”

    int *pt;
    pt = 100;

• Undeclared identifier

    int *pt;
    *pt = 100;

void add(int *a, int *b){
    int *pt;
    *pt=*a;
    *b+=*pt;
}

int main(){
    int a=0,b=2;
    add(&a,&b);
    
    return 0;
}

• Can not be changed (try to swap a and b)

void swap(int *a, int *b){
    int *pt=a;
    a = b;
    b = pt; 
}

int main(){
    int a=0,b=2;
    swap(&a,&b);
    printf("a=%d,\t b=%d",a,b);
    
    return 0;
}

• • What’s wrong

  void swap(int *a, int *b){
  int *pt=a;
  *a = *b;
  *b = *pt; 
  }
  
  int main(){
  int a=0,b=2;
  swap(&a,&b);
  printf("a=%d,\t b=%d",a,b);
  
  return 0;
  }

• • Should be

  void swap(int *a, int *b){
  int pt=*a;
  *a = *b;
  *b = pt;  
  }
  
  int main(){
  int a=0,b=2;
  swap(&a,&b);
  printf("a=%d,\t b=%d",a,b);
  
  return 0;
  }

• A static pointer can not be assigned by auto type, vice versa.

int main(){
  int arr[5]={1,2,3,4,5};
  int  *pt=arr; //allowed
  static int *pt1=arr; // not be allowed
  
  return 0;
}

int main(){
  static int arr[5]={1,2,3,4,5}; 
  int *pt=arr; //not be allowed
  static int  *pt1=arr; //allowed

  return 0;
}

5 Common compiler errors

• Undeclared identifier val

int main(){
  int *pt=&val;
  int val=0;
  
  return 0;
}

• Operand of indirection operator must be a pointer expression

int main(){
  int val=0;
  printf("%d",*val);
  
  return 0;
}

• Operand of address operator must be an 1value or function designator

int main(){
  int *pt;
  int val;
  pt = &(val+10);
  
  return 0;
}

• Operation between types “int " and "int( )[2]” is not allowed

int main(){
  int arr[]={1,2};
  int *pt;
  pt = &arr;
  
  return 0;
}

6 What causes one faster?

7 Exercises

• Exercise 1
  • Understand int *pt[5] and int (*pt)[5]
  • understand the warnnings

  int main() {
  int arr[5]={1,2,3,4,5};
  int (* pt1)[5];
  int (* pt2)[5];
  int *pt3[5];
  pt1 = &arr; 
  pt2 = arr; //Incompatible pointer types assigning to "int (*)[5]" from "int (*)[2][5]"
  pt3[0] = arr;
  printf("arr = %p \t &arr=%p \t arr[0]=%p \t arr[1]=%p\n",arr, &arr, arr[0], arr[1]);
  printf("pt1=%p\t pt2=%p \t pt3[0]=%p\n",pt1,pt2,pt3[0]);
  printf("pt1+1=%p\t pt2+1=%p \n",pt1+1,pt2+1);
  printf("*pt1+1=%p\t *pt2+1=%p \t pt3[0]+1=%p\n",*pt1+1,*pt2+1,pt3[0]+1);
  printf("*(*pt1+1)=%d\t *(*pt2+1)=%d \t *(pt3[0]+1)=%d\n",*(*pt1+1),*(*pt2+1),*(pt3[0]+1));
  
  getchar();
  return 0;
  }

  int main() {
  int arr[2][5]={1,2,3,4,5};
  int (* pt1)[5];
  int (* pt2)[5];
  int *pt3[5];
  pt1 = &arr; //Incompatible pointer types assigning to "int (*)[5]" from "int (*)[2][5]"
  pt2 = arr;
  pt3[0] = arr[0];
  printf("arr = %p \t &arr=%p \t arr[0]=%p \t arr[1]=%p\n",arr, &arr, arr[0], arr[1]);
  printf("pt1=%p\t pt2=%p \t pt3[0]=%p\n",pt1,pt2,pt3[0]);
  printf("pt1+1=%p\t pt2+1=%p \n",pt1+1,pt2+1);
  printf("*pt1+1=%p\t *pt2+1=%p \t pt3[0]+1=%p\n",*pt1+1,*pt2+1,pt3[0]+1);
  printf("*(*pt1+1)=%d\t *(*pt2+1)=%d \t *(pt3[0]+1)=%d\n",*(*pt1+1),*(*pt2+1),*(pt3[0]+1));
  
  getchar();
  return 0;
  }

  • • Understand further int (*pt)[5]

  int main(){
  int a=1;
  int arr[2][5]={1,2,3,4,5};
  int (*pt)[5];
  
  pt = arr;
  printf("pt=%p,\t*pt=%p,\tpt[0]=%p\n",pt,*pt,pt[0]);
  printf("&arr=%p,\t arr=%p,\t arr[0]=%p \n\n",&arr,arr,arr[0]);
  
  printf("pt+1=%p,\t*pt+1=%p,\tpt[1]=%p\n",pt+1,*pt+1,pt[1]);
  pt = arr+1;
  printf("pt=%p,\t*pt=%p,\tpt[0]=%p\n",pt,*pt,pt[0]);
  printf("&arr+1=%p,\t arr+1=%p,\t arr[1]=%p \n",&arr+1,arr+1,arr[1]);
  
  return 0;
  }

• Exercise 2

  double add(int x[], double y){
  double z;
  z = x[0] + y;
  x[0] += 1;
  y += 1;
  printf("&x[0] is %p\t, x[0]=%d\t, &z = %p\t,  y=%f\t, &y=%p\n", x, x[0], &z,y,&y);
  return z;
  }
  
  int main(){
  int a[10] = { 1 };
  double b1=2,z;
  printf("&add is %p\n", add);
  printf("before call: &a[0] is %p\t, a[0]=%d\t, &z = %p\t, b1=%f\t, &b1=%p \n", a, a[0], &z, b1,&b1);
  add(a, b1);
  printf("after call: &a[0] is %p\t, a[0]=%d\t, &z = %p\t, b1=%f\n", a, a[0], &z, b1);  
  
  getchar();
  return 0;  
  }

• Exercise 3
  • In fun(int a[]), both int a[] and int *a are equivalent

  void fun(int a[], int n){
  int i;
  for(i=0;i<n;i++)
  *a++ = 2*i;
  }
  
  int main(){
  int i;
  int arr[5]={1,2,3,4,5};
  for(i=0;i<5;i++)
  printf("*a++=%d\n",arr[i]);  
  
  fun(arr,5)
  for(i=0;i<5;i++)
  printf("*a++=%d\n",arr[i]); 
  
  return 0;
  }

  void fun(int *a, int n){
  int i;
  for(i=0;i<n;i++)
  *a++=i;
  }
  
  int main(){
  int i;
  int arr[5]={1,2,3,4,5};
  for(i=0;i<5;i++)
  printf("*a++=%d\n",arr[i]);  
  
  fun(arr,5)
  for(i=0;i<5;i++)
  printf("*a++=%d\n",arr[i]); 
  
  return 0;
  }

• Exercise 4
  • In fun(int *pt1), the changes of value pt1 and pt2 does not pass back to a and b in main(), respectively
  • This can be illustrated as that
    • First, declaring an int pointer variable pt1
    • Second, assigning &a to pt1, which is a copy
    • Consequently, just as other variable val, we only change pt1 in fun()

  void fun(int *pt1, int *pt2, int val){
  int c[]={1,2,3};
  pt1=pt2;
  pt2=c;
  val = c[0];
  }
  
  int main(){
  int a=0,b=2,c=3;
  fun(&a,&b,c);
  printf("a=%d,\t b=%d, \t c=%d\n",a,b,c);
  
  return 0;
  }

• Exercise 5
  • Pointer variable can be transfered
  • Note the difference of address changes from values changes

  #include <stdio.h>
  int main() {
  int i=1,j=2;
  int *pt1=&i, *pt2=&j;
  printf("pt1=%p,\t pt2=%p,\t *pt1=%d,\t *pt2=%d\n",pt1,pt2,*pt1,*pt2);
  
  char c1='1',c2='2';
  char *p1=&c1,*p2=&c2;
  printf("p1=%p,\t p2=%p,\t *p1=%c,\t *p2=%c\n",p1,p2,*p1,*p2);
  
  pt1=(char*)p1;    pt2=(char*)p2;
  printf("pt1=%p,\t pt2=%p,\t *pt1=%d,\t *pt2=%d\n",pt1,pt2,*pt1,*pt2);
  
  
  return 0;
  }

• Exercise 6
  • From the view of copying value, passing by pointer is same as passing by value
  • The value of a pointer variable is some address, because the pointer variable stores address
  • The value of a common variable is some type data, because the common variable stores some type data

  void fun(int *pt, int val){
  *pt=1;
  val=2;
  printf("*pt=%d,\tpt=%p,\tval=%d,\t&val=%p\n",*pt,pt,val,&val);
  }
  
  int main(){
  int a=0,b=2;
  int *pt1=&a;
  printf("pt1=%p,\t&pt1=%p,\t*pt1=%d\n",pt1,&pt1,*pt1);
  printf("a=%d,\t&a=%p\n",a,&a);
  printf("b=%d,\t&b=%p\n",b,&b);
  fun(&a,b);
  printf("pt1=%p,\t&pt1=%p,\t*pt1=%d\n",pt1,&pt1,*pt1);
  printf("a=%d,\t&a=%p\n",a,&a);
  printf("b=%d,\t&b=%p\n",b,&b);
  
  return 0;
  }

8 References

• Bronson, G. J., (2006). “A First Book of ANSI C”, 4nd, McGraw-Hill, Inc.
• Kernighan, B. W. and Ritchie, D., (1988). “C Programming Language”, 2nd, Prentice Hall.
• Cheng, H. H., (1996). “C for Engineers and Scientists :An interpretive approach”, Pearson.
• Bryant, R. E. and O’Hallaron D, R., (2003). “Computer systems: a programmer’s perspective”, 3nd, Prentice Hall Upper Saddle River