Presentation is loading. Please wait.

Presentation is loading. Please wait.

Memory Management.

Published byAsher Webster Modified over 6 years ago

Similar presentations

Presentation on theme: "Memory Management."— Presentation transcript:

1 Memory Management

2 Objectives At the conclusion of this lesson, students should be able to: Explain why it is important to correctly manage dynamically allocated storage. Write programs that correctly use * Destructors to return dynamically allocated storage to the system. * Overloaded assignment operators to make a deep copy when necessary and return dynamically allocated storage to the system. * Copy constructors to make a deep copy when necessary.

3 Memory Management One of the major program design issues in C++
is memory management. The mishandling of dynamically allocated storage in C++ is among the most serious programming errors made when using the language. Many of these issues can be addressed by designing classes as Concrete Data Types.

4 Concrete Data Types One of the goals of good software development in C++ is to construct each class so that it appears, to the applications programmer, to be equivalent to a built-in type for the language. That is, it is well behaved in all of the ways that a standard built-in data type is well behaved. A C++ class written in this way has been termed a “concrete data type''. Although in detail, the implementation of a class is specific to the class, all concrete data types have a similar structure. Some author’s refer to this structure as the orthodox canonical class form.

5 Review C++ Programs can allocate objects in one of three memory areas.
local variables size and amount known at compile time The run-time stack The static data area or data segment The heap or free store global and static variables storage allocated at run-time because we don’t know how much or what type of data will be stored when the program is compiled.

6 An object is allocated on the heap using
the new operator. The allocated object has no name, but is referenced through a pointer returned by the new operator. Storage allocated using new must be recycled back to the heap when the storage is no longer required. Storage that is no longer accessible, but has not been returned to the heap is called a memory leak.

7 Un-initialized pointers should be set to NULL.
Pointers should also be set to NULL after calling delete to return storage to the heap.

8 Destructors All Concrete Data Types must have a destructor if it
manages resources through a pointer. When program execution reaches the end of a block in which an object was declared, the storage allocated for that object on the stack is relinquished. If a destructor is defined for the class to which the object belongs, the destructor is called first. The purpose of the destructor is to clean up any resources that the object may have acquired. The most common resource that needs to be managed is storage allocated from the heap.

9 Linked Lists The concepts discussed in this slide set will be illustrated using a linked list. Before going through the examples, it will be necessary that you understand what a linked list is and how they are used.

10 Memory Issues This diagram illustrates an example of
node node node 3 12 list 7 9 null This diagram illustrates an example of a linked list. In this example, each node of the list is dynamically allocated from the heap and contains an integer value and a pointer to the next node in the list.

11 class List { private: Node* head; int length; public: . . . }; 3 list
12 list 7 9 null class List { private: Node* head; int length; public: . . . }; the List class just contains a pointer to the first node in the list, and an integer containing the number of elements in the list.

12 3 list class Node { private: int data; Node* next; public:
12 list 7 9 null class Node { private: int data; Node* next; public: Node* getNext( ); … }; Each node object contains an integer data member and a pointer to the next node. The storage for each node is allocated from the heap as it is needed.

13 So … what happens in this case when the list object goes out of scope?
node node node list 3 12 7 9 null So … what happens in this case when the list object goes out of scope? With no destructor, the pointer data member in the list object is relinquished when the object goes out of scope. Without this pointer, the first node, and all subsequent nodes, become inaccessible to the program. Since the storage for these nodes is still owned by the program, we have a memory leak. some block { List myList; . . . blah … blah … blah }

14 Can you come up with a destructor that keeps
node node node list 3 12 7 9 null Can you come up with a destructor that keeps The memory leak from happening?

15 3 list List::~List { } node node node head length 12 7 9 null data
next List::~List { }

16 The following destructor will solve the problem.
node node node list 3 head length 12 7 9 null data next List::~List( ) { Node* p = head; while ( p!=NULL) Node* pnext = p->getNext( ); delete p; p = pnext; } this function returns the value of next

17 p pnext 3 list List::~List( ) { Node* p = head; while ( p!=NULL)
length 12 7 9 null data next List::~List( ) { Node* p = head; while ( p!=NULL) Node* pnext = p->getNext( ); delete p; p = pnext; } this function returns the value of next

18 p pnext 3 list List::~List( ) { Node* p = head; while ( p!=NULL)
12 data next node node list 3 head length 7 9 null List::~List( ) { Node* p = head; while ( p!=NULL) Node* pnext = p->getNext( ); delete p; p = pnext; } this function returns the value of next

19 p pnext 3 list List::~List( ) { Node* p = head; while ( p!=NULL)
length 7 9 null List::~List( ) { Node* p = head; while ( p!=NULL) Node* pnext = p->getNext( ); delete p; p = pnext; } this function returns the value of next

20 Assignment Operator We just illustrated how to manage the memory
allocated dynamically for Node objects when the list goes out of scope. However, the automatic invocation of the destructor when the object goes out of scope introduces another serious problem. Consider the following …

21 list_a 3 list list_b 2 list node node node 12 7 9 null node node 21 6

22 list_a = list_b; Problem: The pointer to this
Data has been lost. Memory Leak! node node node list_a 3 12 list 7 9 null node node list_b 2 2 21 list 6 null the default assignment operator does a member-by member copy of each data member in the list objects.

23 Now … suppose list_b goes out of scope.
node node node list_a 2 12 list 7 9 null node node Problem: the pointer in list_a points to memory no longer owned by the program. list_b 2 21 list 6 null Our destructor, as specified, cleans up the list, returning the storage for each node to the heap.

24 Adding insult to injury, what happens when list_a goes out of scope?
node node node list_a 2 12 list 7 9 null this storage gets returned twice! This could totally destroy the memory manager! Storage belonging to the heap.

25 We solve this problem by overloading the
assignment operator in the List class. The assignment operator must do two things: list_a = list_b; Free the storage used by the left operand (list_a) Make a copy the entire data structure of the right operand (list_b) and point to it in the left operand -– do a deep copy.

26 Free this storage list_a 3 list list_b 2 list node node node 12 7 9
null node node list_b 2 21 list 6 null

27 Make a copy the entire list …
list_a 3 2 list node 21 6 null node node list_b 2 21 list 6 null Make a copy the entire list …

28 const List& List::operator=(const List& b) {
it is customary to name the parameter ‘b’ return a List reference to allow multiple assignment always pass the operand as a constant reference const List& List::operator=(const List& b) { if (this ==&b) return *this; first, check to make sure that we are not doing the assignment a = a; We don’t want to clean up storage for a if this is the case.

29 const List& List::operator=(const List& b) {
if (this ==&b) return *this; Node* p = head; while (p != NULL) Node* pnext = p->getNext( ); delete p; p = pnext; } this code cleans up the storage allocated to the left hand list. Note: It’s the same code we wrote for the destructor.

30 Next, we are going to do the copy. We are
going to do what is called a deep copy. That is, we are going to create a complete copy of the data structure that is on the right hand side. A shallow copy only copies pointers, not what they point to.

31 n->setNext (NULL); n->setData (q->getData( )); if (p == NULL)
start by copying the length data. set the Node* p to Null, we will use this later. length = b.length; p = NULL; Node* q = b.getHead( ); while (q != NULL) { Node* n = new Node; n->setNext (NULL); n->setData (q->getData( )); if (p == NULL) head = n; else p->setNext (n); p = n; q = q->getNext ( ); } return *this; then declare another Node* q, and set it to the head data member in list b.

32 length = b.length; P = NULL; Node *q = b.getHead( ); q list_a n p list
list_b 2 2 21 list 6

33 n->setNext (NULL); n->setData (q->getData( )); if (p == NULL)
length = b.length; p = NULL; Node* q = b.getHead( ); while (q != NULL) { Node* n = new Node; n->setNext (NULL); n->setData (q->getData( )); if (p == NULL) head = n; else p->setNext (n); p = n; q = q->getNext ( ); } return *this; Now, allocate storage for the first node in the new list. set its pointer to the next node to NULL. get the data member of the current node in the right-hand list and store its value in this new node.

34 n -> setNext (NULL); n -> setData (q.getData( ));
Node *n = new Node; n points to the new node just created q list_a NULL n 2 list NULL p q points to the current node in the right hand list node node list_b 2 21 list 6 n -> setNext (NULL); n -> setData (q.getData( ));

35 n->setNext (NULL); n->setData (q.getData( )); if (p == NULL)
length = b.length; p = NULL; Node* q = b.getHead( ); while (q != NULL) { Node* n = new Node; n->setNext (NULL); n->setData (q.getData( )); if (p == NULL) head = n; else p->setNext (n); p = n; q = q->getNext ( ); } return *this; If this is the first node store its pointer in the list object.

36 if (p == NULL) head = n; q list_a n 2 p list list_b 2 list head 21
node node list_b 2 21 list 6

37 n->setNext (NULL); n->setData (q.getData( )); if (p == NULL)
length = b.length; p = NULL; Node* q = b.getHead( ); while (q != NULL) { Node* n = new Node; n->setNext (NULL); n->setData (q.getData( )); if (p == NULL) head = n; else p->setNext (n); p = n; q = q->getNext ( ); } return *this; set to point to the end node in left hand list, the one we just created set to point to the next node in the right hand list.

38 p = n; q = q->getNext( ); q list_a n 2 p list list_b 2 list head 21
NULL n 2 list p node node list_b 2 21 list 6

39 We have copied the List Object and the
first Node. Since q is not null (it points to a node) go through the while block again.

40 list_a = list_b; q list_a n 2 p list list_b 2 list Node* n = new Node;
head q list_a 21 NULL n 2 NULL list p node node list_b 2 21 list 6 Node* n = new Node; n->setNext (NULL); n->setData (q.getData( ));

41 list_a = list_b; q list_a n 2 p list list_b 2 list else
head q list_a 21 n 2 6 NULL list p node node NULL list_b 2 21 list 6 p is not null, so … else p->setNext (n); p = n; q = q->getNext ( );

42 We have successfully copied the second
node from the right-hand list. q is now = NULL, so we drop out of the loop.

43 Copy Constructor We have fixed the assignment operator so that is
correctly creates a copy of the object. However, objects also get copied when passed by value. When a function is called, all of the function arguments are copied into local variables associated with the function. When the function exits, these variables go out of scope and are destroyed. This will cause similar problems to the ones we just discussed with the default assignment operator.

44 Consider the list shown. What happens in the function invocation
node node node 3 12 list_a 7 9 Consider the list shown. What happens in the function invocation double average (List a);

45 when the function is called, a copy
node node node 3 3 12 list_a 7 9 when the function is called, a copy of the list object goes on the stack. The default is a shallow copy …. stack

46 when the function exits, all of the
node node node Oh-oh! 3 12 list_a 7 9 when the function exits, all of the variables associated with the function go out of scope. This includes the copy of the list object passed on the stack. When it goes out of scope, its destructor is called … 3 stack

47 The Copy Constructor List::List(const List& b) { length = b.length;
the compiler invokes this code automatically whenever it needs to create a copy of the object. List::List(const List& b) { length = b.length; Node* p =NULL; Node* q = b.head; while (q != NULL) Node* n = new Node; n->getNext (NULL); n->setData (q->getData( )); if (p == NULL) head = n; else p->setNext (n); p = n; q = q.getNext( ); } this is a copy constructor because it takes an object of its own type as a parameter. If this looks familiar, it is because it is the same code we used to copy the object in the overloaded assignment operator.

48 Copy Constructor It is important to note that like a normal constructor, the function of the copy constructor is to initialize the data members of the object that just got created. The compiler generates the code to create the object when you do a pass by value.

49 Factoring Common Code There is a lot of common code between the
destructor, the assignment operator, and the copy constructor. We can factor this common free and copy code out. Then the destructor, copy constructor, and assignment operator look as shown in the following slide.

50 List::List (const List& b)
{ copy(b); } List::~List( ) free( ); const List& List::operator=(const List& b) if (this != &b) return *this;

51 The Run-Time Stack A stack is a first-in last-out data structure.

52 The Run-Time Stack Data comes off of the stack
in the opposite order of how it was out on.

53 The Run-Time Stack When a function is invoked,
space is allocated on the stack for: the function’s parameters the function’s return address the function’s locally declared variables parameters return address Local variables Stack frame for b( ) parameters return address Local variables Stack frame for a( ) This is called an Activation Record or Stack Frame

54 Reference Counts Suppose that two objects share a common value: value
How would you manage this if the value were dynamically allocated?

55 Reference Counts Suppose that two objects share a common value:
2 value How would you manage this if the value were dynamically allocated?

56 Reference Counts What would the destructor do in this case?
2 1 value

57 The Bridge Pattern Also known as the Handle/Body pattern, the bridge
pattern provides a way for the programmer to completely hide the details of an implementation.

58 C++ provides encapsulation and data abstraction by
using the private keyword to hide the details of a class’s implementation. However, the private keyword only prevents access to the class’s private elements, it does not really hide them. A programmer only need look at the class’s header file to glean a great deal of information about how a class is implemented. What if you really want to hide the details? For example, what if you have a proprietary algorithm you don’t want users of your class to know about.

59 Example class Handle { public: Handle ( ); ~Handle( ); void foo ( );
The Impl class contains the actual implementation details. The pointer _theImpl is used to pass a request on to an object of the Impl class. For example, in the Handle class, the foo( ) function might be written as void Handle::foo ( ) { _theImpl -> foo( ); } class Handle { public: Handle ( ); ~Handle( ); void foo ( ); private: Impl* _theImpl; };

60 A good paper on the Bridge design pattern
can be found here:

Download ppt "Memory Management."

Similar presentations

Constructor. 2 constructor The main use of constructors is to initialize objects. A constructor is a special member function, whose name is same as class.

Constructor. 2 constructor The main use of constructors is to initialize objects. A constructor is a special member function, whose name is same as class.
Object Oriented Programming COP3330 / CGS5409.  C++ Automatics ◦ Copy constructor () ◦ Assignment operator =  Shallow copy vs. Deep copy  DMA Review.

Object Oriented Programming COP3330 / CGS5409.  C++ Automatics ◦ Copy constructor () ◦ Assignment operator =  Shallow copy vs. Deep copy  DMA Review.
Pointers Revisited l What is variable address, name, value? l What is a pointer? l How is a pointer declared? l What is address-of (reference) and dereference.

Pointers Revisited l What is variable address, name, value? l What is a pointer? l How is a pointer declared? l What is address-of (reference) and dereference.
Chapter 15 Memory Management: Four main memory areas for a C++ program: Code: code for instructions, methods, etc. static data: Global variables (declared.

Chapter 15 Memory Management: Four main memory areas for a C++ program: Code: code for instructions, methods, etc. static data: Global variables (declared.
Object Oriented Programming.  OOP Basic Principles  C++ Classes  September 2004  John Edgar 22.

Object Oriented Programming.  OOP Basic Principles  C++ Classes  September 2004  John Edgar 22.
Pointers and Dynamic Variables. Objectives on completion of this topic, students should be able to: Correctly allocate data dynamically * Use the new.

Pointers and Dynamic Variables. Objectives on completion of this topic, students should be able to: Correctly allocate data dynamically * Use the new.
Operator Overloading and Memory Management. Objectives At the conclusion of this lesson, students should be able to: Overload C++ operators Explain why.

Operator Overloading and Memory Management. Objectives At the conclusion of this lesson, students should be able to: Overload C++ operators Explain why.
Shallow Versus Deep Copy and Pointers Shallow copy: when two or more pointers of the same types point to the same memory – They point to the same data.

Shallow Versus Deep Copy and Pointers Shallow copy: when two or more pointers of the same types point to the same memory – They point to the same data.
Review of C++ Programming Part II Sheng-Fang Huang.

Review of C++ Programming Part II Sheng-Fang Huang.
 2006 Pearson Education, Inc. All rights reserved. 1 9-10 Classes: A Deeper Look.

 2006 Pearson Education, Inc. All rights reserved Classes: A Deeper Look.
Object Oriented Programming with C++/ Session 6 / 1 of 44 Multiple Inheritance and Polymorphism Session 6.

Object Oriented Programming with C++/ Session 6 / 1 of 44 Multiple Inheritance and Polymorphism Session 6.
Computer Science and Software Engineering University of Wisconsin - Platteville 2. Pointer Yan Shi CS/SE2630 Lecture Notes.

Computer Science and Software Engineering University of Wisconsin - Platteville 2. Pointer Yan Shi CS/SE2630 Lecture Notes.
Constructors CMSC 202. Object Creation Objects are created by using the operator new in statements such as… The following expression invokes a special.

Constructors CMSC 202. Object Creation Objects are created by using the operator new in statements such as… The following expression invokes a special.
C++ Memory Overview 4 major memory segments Key differences from Java

C++ Memory Overview 4 major memory segments Key differences from Java
Pointers and Dynamic Memory Allocation Copyright Kip Irvine 2003, all rights reserved. Revised 10/28/2003.

Pointers and Dynamic Memory Allocation Copyright Kip Irvine 2003, all rights reserved. Revised 10/28/2003.
Chapter 12: Pointers, Classes, Virtual Functions, and Abstract Classes.

Chapter 12: Pointers, Classes, Virtual Functions, and Abstract Classes.
Classes In C++ 1. What is a class Can make a new type in C++ by declaring a class. A class is an expanded concept of a data structure: instead of holding.

Classes In C++ 1. What is a class Can make a new type in C++ by declaring a class. A class is an expanded concept of a data structure: instead of holding.
CS 376b Introduction to Computer Vision 01 / 23 / 2008 Instructor: Michael Eckmann.

CS 376b Introduction to Computer Vision 01 / 23 / 2008 Instructor: Michael Eckmann.
CPSC 252 The Big Three Page 1 The “Big Three” Every class that has data members pointing to dynamically allocated memory must implement these three methods:

CPSC 252 The Big Three Page 1 The “Big Three” Every class that has data members pointing to dynamically allocated memory must implement these three methods:
Chapter 10: Classes and Data Abstraction. Objectives In this chapter, you will: Learn about classes Learn about private, protected, and public members.

Chapter 10: Classes and Data Abstraction. Objectives In this chapter, you will: Learn about classes Learn about private, protected, and public members.

Similar presentations

Ads by Google