Object-Oriented Programming for Scientific Computing Dynamic Memory Management Ole Klein Interdisciplinary Center for Scientific Computing Heidelberg University ole.klein@iwr.uni-heidelberg.de 21. April 2015 Ole Klein (IWR) Object-Oriented Programming 21. April 2015 1 / 35
Administrativa Current situation: • Registered students: 84 (75 BaMa / 9 PhD) • Expected audience: 15 - 25 people • Up to now only one tutor for the whole lecture ⇒ seriously understaffed 6 credit points for everybody: • Master students: lecture + exercises + final exam • PhD students: lecture + exercises Ole Klein (IWR) Object-Oriented Programming 21. April 2015 2 / 35
Administrativa In anticipation of a second tutor: • A second exercise group slot is created, everybody from the Master group is moved to this slot • You may freely choose, moving you just forces you to make an active decision • The PhD group will be moved to the time slot with fewer Master students Capacity for correction is severely limited, therefore • You must hand in the exercises in groups of three to four students (normally I would allow single hand in) • Exercise submission only digitally via GitLab, will be explained on Thursday • PhD students must hand in solutions, but these are only corrected if capacities allow Ole Klein (IWR) Object-Oriented Programming 21. April 2015 3 / 35
Memory Management Organization of Memory Organization of Memory Static Memory • Here global variables, variables belonging to a namespace and static variables are created. • The memory is allocated when the program starts and is kept until the program ends. • The addresses of variables in static memory don’t change while the program is running. Stack (Automatic Memory) • Here local and temporary variables are created (e.g. for function calls or return values). • The allocated memory is automatically freed when the variable goes out of scope (e.g. when leaving the function in which it is defined). • The size of the stack is limited (e.g. in Ubuntu by default 8192kb). Ole Klein (IWR) Object-Oriented Programming 21. April 2015 4 / 35
Memory Management Organization of Memory Organization of Memory Heap (Free Memory) • Can be requested by the program with the command new . • Must be released with the command delete . • Is in general limited only by the size of the main memory. • May get lost due to programming errors. Ole Klein (IWR) Object-Oriented Programming 21. April 2015 5 / 35
Memory Management Variables, References and Pointers Variables • A variable designates a memory location in which data of a certain type can be stored. • A variable has a name and a type. • The amount of memory required for a variable depends on its type. • The amount of memory that is required for a particular type of variable can be retrieved using the function sizeof(variable type) . • Each variable has a memory address that can be queried with the address operator & . • The address of a variable cannot be modified. Ole Klein (IWR) Object-Oriented Programming 21. April 2015 6 / 35
Memory Management Variables, References and Pointers References • A reference only defines a different name for an already existing variable. • The type of the reference is the type of the variable followed by a & . • A reference is initialized the moment it is defined and cannot be changed thereafter. It therefore always points to the same variable. • A reference can be used in exactly the same way as the original variable. • Modifications of the reference also change the content of the original variable. • There can be multiple references to the same variable. • A reference can also be initialized with a reference. Ole Klein (IWR) Object-Oriented Programming 21. April 2015 7 / 35
Memory Management Variables, References and Pointers Example for References #include <iostream > int main () { int a = 12; int& b = a; // defines a reference int& c = b; // is allowed float& d = a; // is not allowed , type mismatch int e = b; b = 2; c = a * b; std :: cout << a << std :: endl; std :: cout << e << std :: endl; } Ole Klein (IWR) Object-Oriented Programming 21. April 2015 8 / 35
Memory Management Variables, References and Pointers Pointers • Pointers are a concept that is closely linked to the hardware. • A pointer can store the address of a variable of a certain type or the address of a function. • The type of a pointer variable is the type of the underlying variable followed by an asterisk * . • Pointer contain memory addresses of variables, changing the pointer changes the memory location it points to. • If one wants to access the value at that memory address, one places a * in front of the name of the pointer. • If a pointer points at an object and one wants to access the attributes or methods of the object, one can use the operator -> . The expressions *a.value and a->value are equivalent. Ole Klein (IWR) Object-Oriented Programming 21. April 2015 9 / 35
Memory Management Variables, References and Pointers Pointers • If a pointer is not initialized during its definition, then it just points at a random memory location. • If a pointer points to a memory location that wasn’t assigned to the program by the operating system and reads or writes to the value at that address, then the program will terminate with an error message named segmentation fault . • To clearly mark a pointer as not pointing to a variable or function one assigns the value 0 . In C++11 the special keyword nullptr can be used for this. • This makes it simple to test whether a pointer is valid. Ole Klein (IWR) Object-Oriented Programming 21. April 2015 10 / 35
Memory Management Variables, References and Pointers Pointers • There are also pointers pointing to pointers, e.g. int a = 2; int* b = &a; int ** c = &b; • The increment and decrement Operators ++/-- increase a pointer not by one byte, but by the size of the variable type to which the pointer points (the pointer then points to the “next” element) . • If a number i is added/substracted from a pointer, then the memory address changes by i times the size of the variable to which the pointer points. Ole Klein (IWR) Object-Oriented Programming 21. April 2015 11 / 35
Memory Management Variables, References and Pointers Example for Pointers #include <iostream > int main () { int a = 12; int* b = &a; // defines a pointer to a float* c; // defines a pointer to floats (pointing // to somewhere unspecified ) double* d = nullptr; // better this way float e; c = &e; *b = 3; // modifies variable a b = &e; // not allowed , wrong type e = 2 * *b; // allowed , equivalent to *c = 2 * a std :: cout << b << std :: endl; b = b + a; // is allowed , but risky // b now points to another memory cell std :: cout << a << std :: endl; std :: cout << d << std :: endl; std :: cout << b << std :: endl; } Ole Klein (IWR) Object-Oriented Programming 21. April 2015 12 / 35
Memory Management Variables, References and Pointers Arrays in C (and C++) • Arrays in C are closely related to pointers. • The name of an array in C is also a pointer to the first element of the array. • The use of the bracket operator a[i] corresponds to a pointer operation *(a+i) #include <iostream > int main () { int numbers [27]; for (int i = 0; i <27; ++i) numbers[i] = i*i; int* end = numbers + 26; for (int* current = numbers; current <= end; ++ current) std :: cout << *current << std :: endl; } Ole Klein (IWR) Object-Oriented Programming 21. April 2015 13 / 35
Memory Management Variables, References and Pointers Risks of Pointers While dealing with pointers and arrays in C/C++, there are two major threats: 1 A pointer (particularly in the use of arrays) will be modified (accidentally or on purpose), so that it points to memory areas which haven’t been allocated. At best, this leads to closing of the program due to a segmentation fault . In the worst case it can be used to gain access to the operating system. 2 Data is written beyond the end of an arry. If the affected memory was allocated by the program (because other variables are stored in that location), this often leads to very strange errors, because these other variables suddenly contain wrong values. In large programs the exakt spot where this happens may be hard to find. Ole Klein (IWR) Object-Oriented Programming 21. April 2015 14 / 35
Memory Management Call by Value and Call by Reference Call by Value If an argument is passed to a function, then a local copy on the stack is created for this argument with each function call. • If a normal variable is in the argument list, then a copy of this variable is generated. • This is called Call by Value . • Modification of the variables within the function does not change the original variable where the function was called. • If large objects are passed this way, then generating this copy can become very expensive (running time, memory requirements). double SquareCopy (double x) { x = x * x; return x; } Ole Klein (IWR) Object-Oriented Programming 21. April 2015 15 / 35
Recommend
More recommend
