Introduction to Systems Programming - COMP 1002, 1402

Transcription

1 POINTERS Introduction to Systems Programming - COMP 1002, 1402

2 Outline Memory Allocation Pointers in C Pointer and addresses Pointer Arithmetic Dynamic Memory Allocation

3 Memory Allocation When you declare a variable, some memory is allocated to store the value of the variable. When you declare a global variable, the memory that is allocated for the global variable is permanent throughout the program. When you declare a local variable inside a function, then the memory allocated for the local variable exists in a part of memory called the stack, and it exists only for as long as the function is being called. Same for parameters to a function.

4 Declaring Pointers in C 4 int *p; a pointer to an int double *q; a pointer to a double char **r; type *s; a pointer to a pointer to a char a pointer to an object of type type E.g, a struct, union, function, something defined by a typedef, etc.

5 Declaring Pointers in C (continued) 5 Pointer declarations: read from right to left const int *p; p is a pointer to an integer constant I.e., pointer can change, thing it points to cannot int * const q; q is a constant pointer to an integer variable I.e., pointer cannot change, thing it points to can! const int * const r; r is a constant pointer to an integer constant

6 Pointers in C 6 Used everywhere For building useful, interesting, data structures For returning data from functions For managing arrays '&' unary operator generates a pointer to x E.g., scanf("%d", &x); E.g., p = &c; Operand of '&' must be an l-value i.e., a legal object on left of assignment operator ('=') Unary '*' operator dereferences a pointer i.e., gets value pointed to E.g. *p refers to value of c (above) E.g., *p = x + y; *p = *q;

7 Pointers and Addresses C allows you to get the address of a variable. C has a type called pointer that points to another type, such as int, unsigned char, float etc. So, in C, there is an int pointer, unsigned char pointer etc. A pointer to an integer is used to contain the address of an integer. int n; // declare an integer variable called n int * iptr; // declare a variable called iptr // this variable is a pointer to an integer void func() { iptr = &n; // set the value of iptr to the address of variable n

8 Pointer and Address Example Here, we show the address and content of the variables n and iptr as they are declared. After calling the function, the content at Address 101 will be the value 100. Variable Address Content n iptr int n = 20; // declare an integer variable called n int * iptr = 0; // declare a variable called iptr // this variable is a pointer to an integer void func() { iptr = &n; // set the value of iptr to the address of variable n

9 The & Operator As you saw in the preceding slide, the & operator is used to get the address of a variable. Here are some more examples. int n = 20; int * iptr = 0; float f = 1.05; float * fptr = &f; Variable Address Content n iptr f fptr void func() { iptr = &n; // set the value of iptr to the address of variable n

10 The * Operator: Dereferencing a Pointer You can get the contents of what the pointer is pointing to by dereferencing a pointer. int n = 20; int * iptr = 0; int i; void func() { iptr = &n; i = *iptr + 50;

11 Exercise: What gets printed? Address int i; #include <stdio.h> int n = 20; float f = 1.05; float * fptr = &f; int * iptr = 0; int i; int main() { iptr = &n; printf("addresses %d %d\n", iptr, fptr); printf("values %d %f\n", *iptr, *fptr); i = *iptr + 50; *iptr = 10; printf("values %d %d\n", n, i); return 0;

12 Dereferencing Pointer Dereferencing pointer actually refers to the contents of what the pointer is pointing to. This doesn t simply refer to the value. Hence, the content can be changed! #include <stdio.h> int n = 20; int * iptr = 0; int main() { iptr = &n; *iptr = 10; printf("values %d\n", n); return 0;

13 Call by Pointer Contrast the following functions One is call by value, the other is call by pointer. What exactly happens when those functions are called? #include <stdio.h> int n = 20; void func1(int i) { i = i + 10; void func2(int *r) { *r = *r + 20; int main() { func1(n); printf( n is %d\n", n); func2(&n); printf( n is %d\n", n); return 0;

14 Can pointer refer to invalid address? Yes, you can set pointer to any value you want. But, if you set it to some reserved address, then the program will crash when you re trying to refer to the reserved address. int i; int *iptr; int main() { iptr = (int *)500; i = *iptr + 50; Set to invalid address 500 (probably reserved by the operating system) Program crashes when trying to reference invalid address.

15 Pointer Arithmetic 15 int *p, *q; q = p + 1; Construct a pointer to the next integer after *p and assign it to q double *p, *r; int n; r = p + n; Construct a pointer to a double that is n doubles beyond *p, and assign it to r n may be negative

16 Pointer Arithmetic (continued) 16 long int *p, *q; p++; q--; Increment p to point to the next long int; decrement q to point to the previous long int float *p, *q; int n; n = p q; n is the number of floats between *p and *q; i.e., what would be added to q to get p

17 Pointer Arithmetic (continued) 17 long int *p, *q; p++; q--; Increment p to point to the next long int; decrement q to point to the previous long int float *p, *q; int n; n = p q; n is the number of floats between *p and *q; i.e., what would be added to q to get p

18 The new function void func( ) { int *iptr; iptr = new int(15); Refer to the highlighted line above. The new function does the following: Allocate memory in the part of memory called heap. The amount of memory allocated is the amount needed to contain one integer. The content of the memory location is set to the integer 15. new returns the address of the memory that has just been allocated.

19 The delete function The delete function frees the memory that has been created by new. Traditionally, C uses the functions malloc and free, but I don t like them. These days, we use the functions new and delete because they are cleaner. void func( ) { int *iptr; iptr = new int(15); delete iptr; iptr = new int(20);

20 malloc and free void * malloc ( size_t size ); void free ( void * ptr ); malloc requests some memory from the Operation System and returns the address of the memory allocated. free frees up the space previously received by malloc. void func(int n) { int i; int *iptr; iptr = (int *)malloc(n*sizeof(int)); for (i=0;i<n;i++) { iptr[i] = 15 + i * 2; free(iptr);

21 Pointer Example Program: Normalize (Part 1) Example: The normalize function to normalize a vector Mathematical background: Given a 3D vector V = (x,y,z), the magnitude of the vector V is sqrt(x*x+y*y+z*z) Normalizing a vector means to make the vector the same direction as before, but with unit length (that is, the magnitude of the normalized vector should be 1). void Normalize(float *x, float *y, float *z) { float mag; mag = (*x) * (*x) + (*y) * (*y) + (*z) * (*z); mag = sqrt(mag); // at the beginning of source file, need #include <math.h> // to use the function sqrt *x = (*x) / mag; *y = (*y) / mag; *z = (*z) / mag;

22 Pointer Example Program: Normalize (Part 2) Here, we use the Normalize function to change the values of a, b, c. The Normalize function can be used to change the values of other variables. This is a good use of pointers as parameters, because they can change the values of the contents they refer to. int main() { float a, b, c; a = 10.0; b = 20.0; c = 15.0; Normalize(&a, &b, &c); printf( vector is %f %f %f\n, a, b, c); return 0;

23 The NULL Pointer malloc returns the address of the memory that has been allocated. However, sometimes it fails. For example, when the heap is full, or when malloc requests too much memory, the OS cannot give malloc the memory. In this case, the return value of malloc is the NULL pointer. void func(int n) { void func(int n) { int i; int *iptr; iptr = (int *)malloc(n*sizeof(int)); if (iptr!= 0) { // check that malloc did not return the NULL pointer for (i=0;i<n;i++) { iptr[i] = 15 + i * 2; free(iptr);

24 What is the relationship between array and pointer? 24 Arrays and pointers are closely related in C In fact, they are essentially the same thing! Esp. when used as parameters of functions int A[10]; int *p; Type of A is int * p = A; and A = p; are legal assignments *p refers to A[0] *(p + n) refers to A[n] p = &A[5]; is the same as p = A + 5;

25 Arrays and Pointers (continued) 25 double A[10]; vs. double *A; Only difference: double A[10] sets aside ten units of memory, each large enough to hold a double, and A is initialized to point to the zeroth unit. double *A sets aside one pointer-sized unit of memory, not initialized You are expected to come up with the memory elsewhere! Note: all pointer variables are the same size in any given machine architecture Regardless of what types they point to

26 Array and Address When you declare an array, the name of the array also refers to the address of its first element. In the following example, the value of n is the same as the value of &(n[0]) int n[20]; // declare an array of 20 integers void func() { if (n==&(n[0])) { printf( they are the same\n );

27 Array and Pointer Since the name of an array is the same as an address, and a pointer is also the same as an address, a pointer can be set to an array. However, do not set array to pointer. int n[20]; // declare an array of 20 integers int *iptr; void func() { iptr = n; // set pointer to array n[0] = 5; printf( %d, *iptr); // n = iptr; // do not set array to pointer

28 Treating Pointer as Array int n[20]; // declare an array of 20 integers int *iptr; void func() { iptr = n; // set pointer to array for (i=0;i<20;i++) { iptr[i] = 5; // treat pointer as array for (i=0;i<20;i++) { printf( %d, n[i]);

29 Example: Average float fg[80]; float GetAverage(float *marray, int len) { int i; float sum; sum = 0; for (i=0;i<len;i++) { sum += marray[i]; return sum/(float)len; int main( ) { float f1[120]; float f2[60]; float a, b, c; // some code to set the values of f1, f2 and fg a = GetAverage(f1,120); b = GetAverage(f2,60); c = GetAverage(fg,80); return 0;

30 new and delete for Arrays We learned that new can be used to allocate space for an int, float etc. We learned that delete is used to free the space. Now, new can be used to allocate an entire array, and delete is used to free the entire array. void func() { int *iptr; iptr = new int[20]; delete [ ] iptr;

31 Example: Creating a new array // print 1! up to n! 2000 times void printfactorials(int n) { int *iptr; int i, j; iptr = new int[n]; // create an array of length n iptr[0] = 1; for (i=1;i<n;i++) { iptr[i] = iptr[i-1] * (i+1); // set each element of the array for (i=0;i<2000;i++) { for (j=0;j<n;j++) { printf( %d, iptr[j]); printf( \n ); delete [ ] iptr; // free the memory

32 Exercise: Delete Duplicates Write a function DeleteDuplicates This function receives an array arr as an argument, and an integer len, that tells the length of the array. The array received as argument has been allocated by new. The argument array contains floating point numbers in non-decreasing order. DeleteDuplicates should create a new array, except that this array should contain no duplicates. DeleteDuplicates should return the address of this new array. DeleteDuplicates should free the memory used by the old array. The length of the new array is set in nlen. float *DeleteDuplicates(float *arr, int len, int *nlen); // function declaration void func() { // example of use float *eptr; int nlen; eptr = new float[5]; eptr[0] = 1.0; eptr[1] = 1.6; eptr[2] = 1.6; eptr[3] = 2.3; eptr[4] = 2.3; eptr = DeleteDuplicates(eptr,5, &nlen);

33 Note 33 C does not assign arrays to each other E.g, double A[10]; double B[10]; A = B; assigns the pointer value B to the pointer value A Original contents of array A are untouched (and possibly unreachable!)

34 Arrays as Function Parameters 34 void init(float A[], int arraysize); void init(float *A, int arraysize); Are identical function prototypes! Pointer is passed by value I.e. caller copies the value of a pointer to float into the parameter A Called function can reference through that pointer to reach thing pointed to

35 Arrays as Function Parameters (continued) 35 void init(float A[], int arraysize){ int n; for(n = 0; n < arraysize; n++) A[n] = (float)n; //init Assigns values to the array A in place So that caller can see the changes!

36 Examples 36 while ((rc = scanf("%lf", &array[count]))!=eof && rc!=0) double getlargest(const double A[], const int sizea) { double d; if (sizea > 0) { d = getlargest(&a[1], sizea-1); return (d > A[0])? d : A[0]; else return A[0]; // getlargest

37 Result 37 Even though all arguments are passed by value to functions pointers allow functions to assign back to data of caller Arrays are pointers passed by value

38 Exercise: Reverse There is an array of integers int a[100]; Assume that the array contains some numbers. Reverse the array. In other words, after you run your code, the first element should contain the last element, and vice versa. And, the second element should contain the next to last element etc. int a[100]; int main() { Fill in code here

39 Exercise: Change Write a function CalculateChange(int m) that prints the change for a money value. For example CalculateChange(115) should print The valid coin values are 1, 5, 10 and 25.

40 Review: Pointers What does the following program print? #include <stdio.h> Memory: int main() { int i, j; Variable Address Content int *iptr; i 1000? j 1001? i = 256; iptr 5000? iptr = &i; printf( %d, (int)iptr); printf( %d, *iptr); iptr = (int *)i; printf( %d, (int)iptr); return 0;

41 Review: Pointers Answer of previous page: Which line(s) may cause compile time error? #include <stdio.h> int main() { int i, j; int *iptr; i = 256; iptr = 512; iptr = &i; iptr = (int *)i; *iptr = 20; j = iptr; j = &iptr; j = (int) &iptr; &i = iptr; return 0;

42 Review: Pointers Answer of previous page: Lines 7, 13, 14 and 17 Which line(s) may cause the program to crash at runtime? #include <stdio.h> int main() { int i, j; int *iptr; int *jptr; i = 256; iptr = (int *)512; jptr = iptr; i = *iptr + 10; iptr = (int *)i; *iptr = 20; return 0;

43 Review: new and delete Answer of previous page: Lines 12 and 15 Which line(s) may cause compile time error? Which line(s) may cause program to crash at run time? #include <stdio.h> int main() { int i; int *iptr; i = 10; iptr = new int(5); *iptr = 20; delete iptr; *iptr = 15; iptr = &i; delete iptr; return 0; Answer : Line 13 may cause a problem because you write to memory that has been freed. Line 16 has an error because you try to free memory from the stack, i.e. not created by new.

44 QUESTIONS? 44