1 Memory management in C++

Size: px

Start display at page:

Download "1 Memory management in C++"

Rosaline George
5 years ago
Views:

1 Dynamic/Heap Memory CS 101 Abhiram Ranade Goal for today: Understand pointers and memory management in C++ Specific problem to solve: we want to be able to write something like: void turtlemain(){ poly a = readpoly(); poly b = readpoly(); poly c = addpoly(a,b); // read a polynomial // read another, of possibly different degree. // c is sum of a,b printpoly(c); The functions addpoly and readpoly will have to return something that represents polynomials of unknown length. Using a struct as we know it to represent poly will require the struct to contain an array of fixed but long length (Exercise 2). This will be inefficient as you can guess. We can get a better implementation using so called heap memory allocation. This is often also referred to as dynamic memory allocation. A concept in all this is that of pointers. 1 Memory management in C++ A C++ program has a certain amount of memory given to it in which its data is to be stored. The available memory can be thought of as a sequence of locations, from 0 to some M. This memory must be used carefully. It must be allocated for storing variables when needed, and reclaimed when the variables are not needed any longer. Here is a rough sketch of how memory is allocated for the programming constructs you have learned so far. When a program starts executing, the global variables are first allocated. Then the area of the main program (turtlemain) is created. This area (also called the activation record) may grow if the program declares more variables. If the program makes a function call, the area following the main program area is used as the activation record for the function call. If more function calls are made, then more activation records are allocated. If we write programs using the commands we know so far, then at any instant a snapshot of the memory will show a picture like the following, going from address 0 to address M. global variables are allocated turtlemain activation record ar of function called by turtlemain not yet finished ar of function called by above area which is free 1

2 When a function finishes execution, the memory used for its activation record is reclaimed, i.e. declared to be unused. So the allocated area always ranges from address 0 to some address m. The convention of reclaiming the activation record memory has arisen because it is noted that most of the time functions will use a lot of area, but will not need it after they finish. But sometimes this observation is incorrect, as in the case of our polynomial example mentioned earlier. Here we would like the function addpoly to return a polynomial which requires certain amount of area. C++ designers foresaw this possibility and a made a provision for it, which we study next. 1.1 Heap Memory It is customary to refer to the free are going backwards from address M as the heap memory. It is customary to fix the size of the heap memory at the beginning, i.e. we fix some number M such that the area 0 to M is used for storing activation records, and M + 1 to M is used for the heap. It is possible to allocate memory from the heap area by using a command new and the memory does not vanish when the function returns. To release it back, it is necessary to explicitly delete it. A key notion in all this is that of pointers. 1.2 Pointers A pointer variable is a variable that can contain addresses of other variables. examples of how a pointer variable might be declared. Here are int *x; particle *y; We really should read this as (int *) x, and think of int * as a type. This says, x is a variable which will always contain addresses of integer variables. Or y is a variable which will contain addresses of particle variables. It is customary to say x is of type pointer to integer and y of type pointer to particle. Note that the declarations above do not assign a value to x,y. To use these variables, we first need to assign a value of the appropriate kind. Given below is a detailed example, showing pointer declarations, initialization and use. It only uses integers and integer pointers, but the general idea should be clear. int *x, *y, *z; int q, b[10]; x = &q; *x = 5; y = b; y[3] = 6; y[4] = *x + 3; z = y; *z = 2; 2

3 The & symbol is a unary operator meaning address of. Thus x is assigned the address of q. This is a legal assignment consistent with the type of x. The * in the line *x = 5; is a unary operator meaning the variable whose address is contained in x. Since x has the address of q, the expression *x just means q. Thus this statement will set q to 5. Note that b is declared as an array and in C++ the symbol b represents the address of the zeroth element of the array. Hence it is legal to assign this to y, in the statement y=b;. The expression y[3] will thus be synonymous with b[3] and hence the statement y[3]=6; actually sets b[3] to 6. The statement y[4]=*x+3; sets b[4] to the content of x + 3, i.e. q+3=8. Finally, since y is a valid address of an integer, we can certainly assign it to z which is of the same type. The variable z gets the same value as y, i.e. z gets the value b also. The expression *z denotes the variable whose address is stored in z. Since z stores the address of b[0], *z denotes b[0]. The statement *z=2; sets b[0] to 2. It is important to note that, C++ type declarations are a bit strange. I can write int a,b[10],*x; This defines a to be an integer, b to be an array, x to be a pointer to an integer. You might think that it might be better to write these are int a, int[10] b, int* x; however for historical reasons this notation is not used. 1 There are precedence rules governing the use of operators & and * along with each other and with other operators; however, it is suggested that you use parentheses to indicate the precedence explicitly for reader convenience. 1.3 Heap Memory Allocation To allocate memory from the Heap, we simply write: int *x; particle *y; x = new int; y = new particle[5]; Similar statements can be executed with points to other data types as well. The statement x = new int; allocates a single word of memory from the heap, and assigns its address to x. It is customary to say allocates a single word of memory from the heap, and x is set to point to this word. Just as an example, suppose this is the first new statement to be executed. Then x would get the value M. We can now store data into location M by writing *x =... The next new statement allocates contiguous memory to store an array of 5 particle objects, and sets y to point to the zeroth object. So continuing our example, if each particle object occupies 6 words, then together the array will need 30 words. Thus y would be set to M-30. Each element of the array could be accessed simply by referring to it as y[0],y[1],...,y[4]. 1 To help our intuition some people read int *x as define an x such that whatever x points to is an integer. 3

4 Do note the key point: Suppose the above code is part of a function f. Suppose f was called from function g. The memory allocated in the above statements is on the heap and not in the activation record of function f. Thus f can return x or y, and the allocated memory can be accessed from the function g. We will see an example of this in the next section. If the heap memory gets exhausted by allocations like the one above, and there is a request that cannot be satisfied, then the program aborts with an error message. 1.4 Deallocation Heap memory must be deallocated explicitly, i.e. to deallocate the memory allocated above we would call delete x; delete[] y; In general, delete must be called to deallocated an element which was allocated singly, and delete[] to deallocate an array. Note that we may write x=new int; y = x; delete y; in which case the memory will get deallocated, and subsequently the expressions *x as well as *y would be illegal because they point to memory not allocated. It is good to deallocate memory which is known to not be useful subsequently. Subsequent new statements may cause such memory to be allocated again. 2 Implementation Using the mechanisms described in the previous section, we can indeed write the main program as given in the beginning. Here is it. // #include turtlesim.h struct poly { int size; float *coeffs; ; void printpoly(poly a){ for(int i=0; i<a.size; i++) cout << a.coeffs[i] << " "; cout << endl; poly readpoly(){ poly res; cin >> res.size; res.coeffs = new float[res.size]; for(int i=0; i<res.size; i++) cin >> res.coeffs[i]; 4

5 return res; poly addpoly(poly a, poly b){ poly res; res.size = max(a.size, b.size); res.coeffs = new float[res.size]; for(int i=0; i<res.size; i++){ if(i < a.size && i < b.size) res.coeffs[i] = a.coeffs[i] + b.coeffs[i]; else if( i < a.size) res.coeffs[i] = a.coeffs[i]; else res.coeffs[i] = b.coeffs[i]; return res; void turtlemain(){ poly a = readpoly(); poly b = readpoly(); printpoly(a); printpoly(b); poly c = addpoly(a,b); // a, b could have different degrees printpoly(c); // Some important points to note. The call readpoly() returns a struct poly. This struct only has two words, one for the member size and the other for the member coeffs. The member coeffs is a pointer to the array stored in heap memory. The coefficients of all 3 polynomials a,b,c as declared in the main program are stored in heap memory. Only 2 words for each the structs are stored in the activation record of turtlemain. 3 Exercises 1. A key rule in assignment statements is that the type of the value being assigned must match the type of the variable to which the assignment is made. Consider the following code: int *x,*y, z=3, b[3]; x = &b; 5

6 y = &x; z = y; y = *x; y = *b; Each of the assignments is incorrect. Can you guess why? If not, write the code in a program, compile it, and the compiler will tell you! 2. One way of writing the above program is to define poly as: struct poly { int size; float coeffs[1000]; Show that this can be used with the main program as given, with no new statements needed at all. The functions readpoly addpoly and printpoly will need to be modified a bit, and they will in fact become simpler. However, the program will work assuming all polynomials were of degree less than In addition, the program will be slower. Can you say why? 3. Write a polynomial multiplication function which takes as input two polynomials represented as above and returns the product. 6

Pointers. Addresses in Memory. Exam 1 on July 18, :00-11:40am

Pointers. Addresses in Memory. Exam 1 on July 18, :00-11:40am Exam 1 on July 18, 2005 10:00-11:40am Pointers Addresses in Memory When a variable is declared, enough memory to hold a value of that type is allocated for it at an unused memory location. This is the