UNDERSTANDING MEMORY USAGE BY A C PROGRAM code

UNDERSTANDING MEMORY USAGE BY A C++ PROGRAM

code memory static memory stack memory heap

EVERY VARIABLE/OBJECT HAS A SCOPE • WHERE IN THE PROGRAM CODE IS THE NAME OF A VARIABLE/OBJECT VISIBLE? • DEPENDS ON WHERE THE NAME WAS DECLARED • GLOBAL SCOPE - THROUGHOUT THE PROGRAM • LOCAL SCOPE – WITHIN A FUNCTION • SCOPE IS KNOWN AT COMPILE TIME

EVERY VARIABLE/OBJECT HAS A LIFETIME • LIFETIME IS A RUN-TIME ISSUE • THE PERIOD OF TIME DURING PROGRAM EXECUTION THAT A VARIABLE/OBJECT IS MAKING USE OF MEMORY SPACE • GLOBAL VARIABLES USE MEMORY SPACE FROM START TO END OF PROGRAM EXECUTION • A FUNCTION’S LOCAL VARIABLES USE MEMORY SPACE ONLY WHILE THAT FUNCTION IS EXECUTING • AMOUNT OF MEMORY NEEDED FOR A FUNCTION’S LOCAL VARIABLES IS KNOWN AT COMPILE TIME • WHEN A FUNCTION IS CALLED SPACE FOR ITS VARIABLES IS STORED ON THE STACK • WHEN A FUNCTION RETURNS THAT SPACE IS RELEASED

MEMORY USAGE BY LAB 1 PROGRAM main get. Number double. Largest find. Average display. Result

program code cin cout activation records for function(s) currently executing code memory static memory stack memory heap

WHAT IS STORED IN THE ACTIVATION RECORD FOR A FUNCTION? • VALUE OF EACH LOCAL VARIABLE (PARAMETERS ARE LOCAL VARIABLES) • ADDRESS OF CODE TO BE EXECUTED WHEN FUNCTION RETURNS

program code cin cout activation records for function(s) currently executing main num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main get. Num num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main get. Num num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main double Larger num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main display num 1 average num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing main num 1 num 2 average code memory static memory stack memory heap

program code cin cout activation records for function(s) currently executing code memory static memory stack memory heap

NEW AND HEAP MEMORY • THE C++ NEW STATEMENT REQUESTS MEMORY FOR AN OBJECT AT RUN-TIME • WHEN A NEW STATEMENT IS EXECUTED • REQUESTED SPACE IS ALLOCATED IN THE HEAP • ADDRESS OF THE HEAP SPACE IS RETURNED • SUPPOSE A FUNCTION CONTAINS THE FOLLOWING CODE • INT N 1 ; N 1 = 36; • INT* N 2 = NEW INT; *N 2 = 36; • N 1 AND N 2 ARE LOCAL VARIABLES WHOSE SPACE IS STORED ON THE STACK • THE SPACE FOR *N 2 IS IN THE HEAP • WHAT HAPPENS WHEN THIS FUNCTION IS CALLED?

Activation record created on the stack code memory static memory main function n 1 n 2 stack memory heap memory

When new is executed code memory static memory main function n 1 n 2 stack memory heap memory

When function returns? code memory static memory main function n 1 n 2 stack memory heap memory

When function returns code memory static memory main stack memory heap memory

WHAT HAPPENS WHEN THE FOLLOWING FUNCTION IS CALLED? void func (){ Array. List a. List; Linked. List l. List; a. List. append(“C++”); l. List. append(“Java”); } func caller stack heap

func caller l. List a. List func items size 0 head size 0 stack heap

func caller func l. List a. List items size 0 head size 0 stack a. List. append(“C++”); l. List. append(“Java”); heap

func caller func l. List a. List items size 1 head size 1 stack a. Stack. push(“C++”) ; l. Stack. push(“Java”); Java heap What happens when func returns to its caller?

func caller stack heap Java

A PROGRAM THAT USES NEW TO ALLOCATE HEAP MEMORY SPACE HAS TO • MAKE SURE ALL MEMORY ALLOCATED USING NEW IS RELEASED (USING DELETE) WHEN IT IS NO LONGER NEEDED • WHICH LINKEDLIST METHODS USE NEW? • WHICH LINKEDLIST METHODS NEED TO USE DELETE?

THE BIG 3 • COMPILER PROVIDES 3 METHODS FOR ALL TYPES (INCLUDING CLASSES YOU DEFINE) • A DESTRUCTOR • FREES MEMORY RESOURCES USED BY AN OBJECT OF THAT TYPE • CALLED WHEN AN OBJECT GOES “OUT OF SCOPE” • EX: FUNCTION TO WHICH IT IS LOCAL RETURNS • A COPY CONSTRUCTOR • MAKES A COPY OF AN EXISTING OBJECT • VALUE PARAMETER REQUIRES A COPY OF THE ARGUMENT • RETURN MYOBJECT; REQUIRES A COPY OF MYOBJECT • ASSIGNMENT OPERATOR (OPERATOR=) • REPLACES ONE EXISTING OBJECT WITH A COPY OF ANOTHER EXISTING OBJECT • EX: VEC 2 = VEC 1; • EX: MYLIST 2 = MYLIST 1;

SOME CLASSES NEED TO OVERRIDE THE BIG 3 METHODS PROVIDED BY THE COMPILER • CLASSES THAT DO NOT USE HEAP MEMORY SPACE CAN USE THE COMPILER PROVIDED METHODS • FRACTION • ARRAYLIST (A FIXED SIZE ARRAY DOES NOT USE HEAP MEMORY) • VECTORLIST (A VECTOR DOES USE HEAP MEMORY BUT HAS THE BIG 3 METHODS ALREADY DEFINED) • CLASSES THAT USE HEAP MEMORY SPACE MUST OVERRIDE THE BIG 3 TO • PREVENT MEMORY LEAKS WHEN AN OBJECT GOES OUT OF SCOPE • MAKE A “DEEP” COPY OF AN OBJECT RATHER THAN A “SHALLOW” COPY

COPY CONSTRUCTOR • MAKES A COPY OF AN EXISTING OBJECT WHEN NEEDED • COMPILER PROVIDED COPY CONSTRUCTOR MAKES A COPY OF AN EXISTING OBJECT BY MAKING A COPY OF ALL OF THE DATA MEMBERS • THIS RESULTS IN A SHALLOW COPY RATHER THAN A DEEP COPY

a shallow copy of a Linked. List original copy size head 3 ----- copy. append(----);

after copy. append(----) original copy size head 34 size head 3 -----

a deep copy of a Linked. List copy size head 3 original ----- -----

PROTOTYPES FOR THE BIG 3 • ~CLASSNAME(); // RETURNS HEAP MEMORY SPACE USED BY THIS OBJECT • CLASSNAME (CONST CLASSNAME & OBJECT_TO_COPY); // MAKES A DEEP COPY OF OBJECT_TO_COPY • CLASSNAME& OPERATOR=(CONST CLASSNAME & OBJECT_TO_COPY); // RETURNS HEAP MEMORY SPACE BEING USED BY OBJECT BEING ASSIGNED TO // AND REPLACES IT WITH A DEEP COPY OF OBJECT_TO_COPY • LAST LINE WILL BE RETURN *THIS (ALLOWS ASSIGNMENTS TO BE CHAINED)

TRY THIS • WRITE A FUNCTION THAT IS SENT THE POINTER TO THE BEGINNING OF A LINKED LIST AND USES DELETE TO RETURN THE NODES OF THAT LINKED LIST ONE AT A TIME size head 3 • VOID DESTROY_LIST(NODE* P); -----

TRY THIS • WRITE A FUNCTION THAT IS SENT THE POINTER TO THE BEGINNING OF A LINKED LIST AND MAKES A DEEP COPY OF THAT LINKED LIST size head 3 • VOID COPY_LIST(NODE* P); -----
- Slides: 37