Dynamic Memory Allocation

Pointers Revisited What is variable address, name, value? What is a pointer? How is a pointer declared? What is address-of and dereference operators? How can a pointer be assigned a value? How can a value of a memory location referred to by a pointer be accessed? What is a constant pointer? What is a pointer to a constant? What is the relationship between array name and a pointer? What is null pointer? What is lose pointer problem? Can pointers be used with objects? How can a method be invoked on an object using pointer? What is -> operator?

Why Dynamic Memory When a variable is declared - a certain memory area (sufficient to hold the variable of this type or class) is allocated Not all memory can be allocated or efficiently allocated at the compilation time we are manipulating an set of data of arbitrary size what if we allocate an array too small? what if we allocate an array too large? static memory allocation - memory allocation at compile time dynamic memory allocation - allocation at execution time Dynamic memory allocation is more flexible since the program can claim and release memory as needed and potentially can get as much memory as the computer resources allow heap - the system structure where the memory is allocated heap is separate for every program and it is removed when the program finishes

new and delete new and delete - operations are used to dynamically manipulate memory new - allocates a nameless variable of specified type (or class) and returns a pointer to it int *ip; // declare pointer ip = new int; // ip points to integer variable Note: the variable has no name and the only way to access the variable is though pointer: cin >> *ip; *ip += 20; cout << *ip; new may take a parameter to initialize the variable with ip = new int(5); // 5 assigned to the variable delete - releases memory back to heap so that it can be reused delete ip; Note: the memory pointed to by ip goes away not the pointer variable itself dynamic variable - variable created with new automatic variable – local variables, parameters, temp. variables

Memory Leak Problem Note: the pointer that points to the dynamic variable is the only way to access this variable If the pointer is reassigned the dynamic variable is “lost”. This is called a memory leak problem int *ptr = new int; ptr = new int; // ERROR - memory leak Is this a memory leak? int *ptr1,*ptr2 = new int; ptr1=ptr2; ptr2 = new int;

Pointers and Arrays Array name is equivalent to: base_type * const That is array name is a pointer that cannot be changed Array name points to the first element of the array Array name can be used as pointer Pointer can be used as an array name int a[10], *p1, *p2; p1=a; // where does p1 point now? p1[2]=5; // which element does p1 access a=p2; // is this legal? p1[20]; // is this legal?

Dynamic Arrays Arrays can be created dynamically just as non-aggregate variables new has to be passed the number of elements of the array int *p1, p2, num; p1 = new int[10]; The number of array elements need not be constant: cin >> num; p2 = new int[num]; new returns the pointer to the first element of the dynamically allocated array. This pointer can be used just like regular array name: p1[2]=42; Note: unlike regular array name this pointer can still be changed p1=p2; delete has special syntax for array deallocation: delete [] p1;