Date post: | 30-Dec-2015 |
Category: |
Documents |
Upload: | lawrence-maynard |
View: | 30 times |
Download: | 0 times |
POINTERS
Introduction to Systems Programming - COMP 1002, 1402
Outline
Memory Allocation Pointers in C Pointer and addresses Pointer Arithmetic Dynamic Memory Allocation
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.
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 nint * 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}
5
Declaring Pointers in C
int *p; — a pointer to an int double *q; — a pointer to a double char **r; — a pointer to a pointer to
achar
type *s; — a pointer to an object of
type type E.g, a struct, union, function, something defined by
a typedef, etc.
6
Declaring Pointers in C (continued)
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
7
Pointers in C
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;
Not the same as binary '&'
operator (bitwise AND)
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.
int n = 20; // declare an integer variable called nint * 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}
Variable Address Contentn 100 20iptr 101 0 100
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;
void func() { iptr = &n; // set the value of iptr to the address of variable n}
Variable Address Contentn 100 20iptr 101 0 100f 102 1.05fptr 103 102
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; }
Exercise: What gets printed?
#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;
}
Address200201202203204
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;}
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;}
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
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)
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)
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
C never checks that the
resulting pointer is valid
The “new” function
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.
void func( ) { int *iptr; iptr = new int(15);}
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);}
malloc and free
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 * malloc ( size_t size ); void free ( void * ptr );
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);}
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;}
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;}
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) { 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?
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)
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
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”); }}
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 integersint *iptr;
void func() { iptr = n; // set pointer to array n[0] = 5; printf(“%d”, *iptr); // n = iptr; // do not set array to pointer}
Treating Pointer as Array
int n[20]; // declare an array of 20 integersint *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]); }
}
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;}
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;}
Example: Creating a new array
// print 1! up to n! 2000 timesvoid 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}
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 an 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
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 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)
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
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];
} elsereturn A[0];
} // getLargest
37
Result
Even though all arguments are passed by value to functions …
… pointers allow functions to assign back to data of caller
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
Exercise: Change
Write a function CalculateChange(int m) that prints the change for a money value.
For example CalculateChange(115) should print “25 25 25 25 10 5”
The valid coin values are 1, 5, 10 and 25.
Review: Pointers
What does the following program print?
#include <stdio.h>
int main() { int i, j; int *iptr;
i = 256;
iptr = &i; printf(“%d “, (int)iptr);
printf(“%d “, *iptr);
iptr = (int *)i; printf(“%d “, (int)iptr);
return 0;
}
Variable Address Contenti 1000 ?j 1001 ?iptr 5000 ?
Memory:
Review: Pointers
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;}
Answer of previous page:
1000 256 256
01234567891011121314151617181920
Review: Pointers
Which line(s) may cause the program to crash at run-time?
#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;}
012345678910111213141516171819
Answer of previous page:Lines 7, 13, 14 and 17
Review: new and delete
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;}
012345678910111213141516171819
Answer of previous page:Lines 12 and 15
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?