C++ Memory Management
Download as PPTX, PDF0 likes1,963 views
This document discusses C++ memory management. It describes the different memory segments used in a C++ program including the code segment, BSS segment, data segment, heap, and stack. The stack and heap are discussed in more detail. The stack stores function parameters and local variables and uses a last-in, first-out approach. The heap stores dynamically allocated memory using new until explicitly freed. The document also provides details on how the call stack works, including pushing and popping stack frames when functions are called and returned from.
![Dynamic Memory
Heap Segment (also known as the âfree storeâ) keeps
track of memory used for dynamic memory allocation.
In C++, when you use the new operator to allocate memory,
this memory is allocated in the applicationâs heap segment.
ï int *ptr = new int; // ptr is assigned 4 bytes in the heap
ï int *array = new int[10]; // array is assigned 40 bytes in the heap
Heap has advantages and disadvantages:
ï Allocating memory on the heap is comparatively slow.
ï Allocated memory stays allocated until it is specifically
deallocated (beware memory leaks) or the application ends
(at which point the OS should clean it up).
ï Dynamically allocated memory must be accessed through a
pointer. Dereferencing a pointer is slower than accessing a
variable directly.
ï Because the heap is a big pool of memory, large arrays,
structures, or classes can be allocated here.](https://image.slidesharecdn.com/cmemorymanagement-190101012554/85/C-Memory-Management-5-320.jpg)
C++ Memory Management
- 2. Content 1. C++ Memory Segments 2. Program in RAM 3. Dynamic Memory 4. Call Stack 5. Call Stack Segment 6. Stack in Action
- 3. C++ Memory Segments ï A program is typically divide into different memory areas called segments. ï Code Segment ï It also called text segment where the compiled program sits in memory. The code segment is typically read-only. ï BSS Segment ï It is also called the uninitialized data segment, where zero- initialized global and static variables are stored. ï Data Segment ï It is also called initialized data segment where initialized global and static variables are stored ï Heap ï It holds dynamically allocated variables. ï Stack ï It stores function parameters, local variables, and other function- related information.
- 4. Program in RAM Sections: 1. Read only a) .text: Program code. b) .rodata: constants (const modifier) and strings. 2. Global and Static a) .data: Initialized global and static variables (startup value â 0) b) .bss: Uninitialized global and static variables (zero value on startup)
- 5. Dynamic Memory Heap Segment (also known as the âfree storeâ) keeps track of memory used for dynamic memory allocation. In C++, when you use the new operator to allocate memory, this memory is allocated in the applicationâs heap segment. ï int *ptr = new int; // ptr is assigned 4 bytes in the heap ï int *array = new int[10]; // array is assigned 40 bytes in the heap Heap has advantages and disadvantages: ï Allocating memory on the heap is comparatively slow. ï Allocated memory stays allocated until it is specifically deallocated (beware memory leaks) or the application ends (at which point the OS should clean it up). ï Dynamically allocated memory must be accessed through a pointer. Dereferencing a pointer is slower than accessing a variable directly. ï Because the heap is a big pool of memory, large arrays, structures, or classes can be allocated here.
- 6. Call Stack Call stack usually referred to as âstackâ . The call stack keeps track of all the active functions from the start of the program to the current point of execution, and handles allocation of all function parameters and local variables. The call stack is implemented as a stack data structure. A stack is a last-in, first-out (LIFO) structure. The last item pushed onto the stack will be the first item popped off. Stack has advantages and disadvantages: 1. Allocating memory on the stack is comparatively fast. 2. Memory allocated on the stack stays in scope as long as it is on the stack. It is destroyed when it is popped off the stack. 3. All memory allocated on the stack is known at compile time. Consequently, this memory can be accessed directly through a variable. 4. Because the stack is relatively small, it is generally not a good idea to do anything that eats up lots of stack space. This includes passing by value or creating local variables of large arrays or other memory-intensive structures, it leads to stack Overflow
- 7. Call Stack Segment The Call Stack Segment holds the memory used for the call stack. When a application function call is encountered, the function is pushed onto the call stack. When the current function ends, that function is popped off the call stack. There is no need erase the memory just leave it to be overwritten by the next item pushed to that piece of memory. The stack itself is a fixed-size chunk of memory addresses, and the âitemsâ weâre pushing and popping on the stack are called stack frames. A stack frame keeps track of all of the data associated with one function call. The âmarkerâ is a register (a small piece of memory in the CPU) known as the stack pointer (sometimes abbreviated âSPâ). The stack pointer keeps track of where the top of the call stack currently is.
- 8. Call Stack in Action How the call stack works? Below is the sequence of steps that takes place when a function is called: 1. The program encounters a function call. 2. A stack frame is constructed and pushed on the stack. The stack frame consists of: a) The address of the instruction beyond the function call (called the return address). This is how the CPU remembers where to return to after the called function exits. b) All function arguments. c) Memory for any local variables. d) Saved copies of any registers modified by the function that need to be restored when the function returns 3. The CPU jumps to the functionâs start point. 4. The instructions inside of the function begin executing. When the function terminates, the following steps happen: 1. Registers are restored from the call stack 2. The stack frame is popped off the stack. This frees the memory for all local variables and arguments. 3. The return value is handled. 4. The CPU resumes execution at the return address
- 9. Questions?