1 Memory, Arrays & Pointers

Memory 2 int main() { char c; int i,j; double x; cijx

Arrays Defines a block of consecutive cells int main() { int i; int a[3]; ia[0]a[1]a[2]

Arrays - the [ ] operator 4 int arr[5] = { 1, 5, 2, 1,3 }; /*arr begins at address 40*/ Address Computation Examples: 1. arr[0] 40+0*sizeof(int) = arr[3] 40+3*sizeof(int) = arr[i] 40+i*sizeof(int) = *i 4. arr[-1] 40+(-1)*sizeof (int) = 36 // can be the code // segment or other variables

Arrays 5 C does not provide any run time checks int a[4]; a[-1] = 0; a[4] = 0; This will compile and run (no errors?!) …but can lead to unpredictable results. It is the programmer’s responsibility to check whether the index is out of bounds…

Arrays C does not provide array operations: int a[4]; int b[4]; a = b; // illegal if( a == b ) // legal. ==0, address comparison. 6

Arrays a[i] is just translated to (*(a+i)), thus this code will compile and run fine int a[4]; 0[a]= 42;// first element of array is 42 1[a]= -1;// second element of array is -1 7

Array Initialization 8 // Works, but IMHO in some cases, bad style int arr[3] = {3, 4, 5}; // Good (robust to changes) int arr[] = {3, 4, 5}; // Bad style - Init all items to 0 takes O(n) int arr[3] = {0}; // Bad style - The last is 0 int arr[4] = {3, 4, 5};

Array Initialization 9 // Bad int arr[2] = {3, 4, 5}; // Bad - array assignment // only in initialization int arr[3]; arr = {2,5,7};

Array Initialization – multidimensional (more on this later) 10 // Good, works same as arr[2][3] int arr[][3] = {{2,5,7},{4,6,7}}; // Bad style, but same as above int arr[2][3] = {2,5,7,4,6,7}; // Bad int arr[3][2] = {{2,5,7},{4,6,7}};

Pointers Data type for addresses (almost) all you need to know is: & *

Pointers Declaration *p; * p; Both, p points to objects of type Pointer  value *p = x; y = *p; *p refers to the object p points to Value  pointer &x - the pointer to x(x’s address) 12

Pointers - 64 bit! int main() { int i,j; int *x; // x points to an integer i = 1; x = &i; j = *x; x = &j; (*x) = 3; ???????????????? ijx

Pointers - 64 bit! int main() { int i,j; int *x; // x points to an integer i = 1; x = &i; j = *x; x = &j; (*x) = 3; 1000???????????? ijx

Pointers - 64 bit! int main() { int i,j; int *x; // x points to an integer i = 1; x = &i; j = *x; x = &j; (*x) = 3; 1000???????????? ijx Little Endian

Pointers - 64 bit! int main() { int i,j; int *x; // x points to an integer i = 1; x = &i; j = *x; x = &j; (*x) = 3; 1000???? ijx

Pointers - 64 bit! int main() { int i,j; int *x; // x points to an integer i = 1; x = &i; j = *x; x = &j; (*x) = 3; ijx

Pointers - 64 bit! int main() { int i,j; int *x; // x points to an integer i = 1; x = &i; j = *x; x = &j; (*x) = 3; ijx

Pointers - 64 bit! int main() { int i,j; int *x; // x points to an integer i = 1; x = &i; j = *x; x = &j; (*x) = 3; ijx

Example – the swap function Does nothingWorks 20 void swap(int a, int b) { int temp = a; a = b; b = temp; } int main() { int x, y; x = 3; y = 7; swap(x, y); // now x==3, y==7 void swap(int *pa, int *pb) { int temp = *pa; *pa = *pb; *pb = temp; } int main() { int x, y; x = 3; y = 7; swap(&x, &y); // x == 7, y == 3

Pointers & Arrays 21 int *p; int a[3]; p = &a[0]; // same as p = a *(p+1) = 1; // assignment to a[1]! Pa[0]a[1]a[2]

Pointers & Arrays 22 Arrays are can sometimes be treated as address of the first member. int *p; int a[4]; p = a; // same as p = &a[0]; p[1] = 102; // same as *(p+1)=102; *(a+1) = 102; // same as prev. line p++; // p == a+1 == &a[1] a = p; // illegal a++; // illegal

Pointers & Arrays 23 But: int *p; int a[4]; sizeof (p) == sizeof (void*) sizeof (a) == 4 * sizeof (int)  Size of the array is known in compile time

Pointers & Arrays 24 int main() { int arr[4] = {1,3,5,4}; int i, sum = 0; for (i=0; i<sizeof(arr)/sizeof(arr[0]); ++i) { sum += arr[i]; } }

Pointers & Arrays int foo( int *p ); and int foo( int a[] ); Are declaring the same interface. In both cases, a pointer to int is being passed to the function foo 25

Pointers & Arrays int foo( int *p ); and int foo( int a[3] ); Are declaring the same interface. In both cases, a pointer to int is being passed to the function foo 26

Pointers & Arrays 27 int sum (int arr[]) { int i, sum = 0; for (i=0; i<sizeof(arr)/sizeof(arr[0]); ++i) { sum += arr[i]; } return sum; } // error: sizeof (arr) = sizeof (void*) int* ≡ arr[] !≡ arr[N]

Pointers & Arrays 28 int sum (int arr[42]) { int i, sum = 0; for (i=0; i<sizeof(arr)/sizeof(arr[0]); ++i) { sum += arr[i]; } return sum; } // error: sizeof (arr) = sizeof (void*) int* ≡ arr[] !≡ arr[N]

Pointers & Arrays 29 int sum (int arr[], int n) { int i, sum = 0; for (i=0; i<n; ++i) { sum += arr[i]; // = arr+ i*sizeof(int) } return sum; } Array size must be passed as a parameter

Pointer Arithmetic int a[3]; int *p = a; char *q = (char *)a; // Explicit cast // p and q point to the same location p++; // increment p by 1 int (4 bytes) q++; // increment q by 1 char (1 byte) a[2]a[3]a[0]a[1] qP 30

Pointer Arithmetic 31 int FindFirstNonZero( int a[], int n ) { int *p= a; while( (p<a+n) && ((*p) == 0) ) ++p; return p-a; } Same as int FindFirstNonZero( int a[], int n ) { int i= 0; while( (i<n) && (a[i] == 0) ) ++i; return i; } Preferable

Pointer Arithmetic 32 int a[4]; int *p= a; long i= (long)a; long j= (long)(a+1); // add 1*sizeof(int) to a; long dif= (long)(j-i); // dif= sizeof(int) Be careful: Pointer arithmetic works just with pointers

void * 33 void* p defines a pointer to undetermined type int j; int* p= &j; void* q= p; // no cast needed p = (int*)q ; // cast is needed

void * 34 void* address jumps in bytes (like char*) We cannot access to the content of the pointer int j; void *p = &j; int k = *p; // illegal int k = (int)*p ; // still illegal int k = *(int*)p; // legal

NULL pointer 35 Special value: points to “nothing” (defined in stdlib.h, usually as 0 of type void*): int *p = NULL; if( p != NULL ) { }

NULL pointer 36 int *p = NULL; *p = 1; Will compile… … but will lead to runtime error

Pointers to pointers 37 Pointer is a variable type, it also has an address: int main() { int n = 17; int *p = &n; int **p2 = &p; printf("the address of p2 is %p \n",&p2); printf("the address of p is %p \n",p2); printf("the address of n is %p \n",*p2); printf("the value of n is %d \n",**p2); return 0; }

C Strings premier

39 char str[] = "Hello"; const char *str = "Hello"; ‘H’‘e’‘l’ ‘o’‘\0’ str+0 C strings are null-terminated arrays

40 char str[] = "Hello"; const char *str = "Hello"; ‘H’‘e’‘l’ ‘o’‘\0’ str+0 C strings are null-terminated arrays More on C strings and the difference between these 2 versions, later

C strings, be careful! 41 char str[] = {H,e,l,l,o}; str+0 ‘H’‘e’‘l’ ‘o’?

C strings manipulation 42 #include strcmp strcpy strlen … e/cstring/