Stack and Heap Memory

• Study Unit 7 covers memory and memory management, focusing on stack and heap memory.
• Specifically, it deals with string objects defined in the string library with pointers and how values of types are stored on the stack and the heap.

Stack and Heap Memory

• Stack memory stores local variables and the state of a function when called, residing in the higher primary memory address space.
• Allocation in stack memory happens below the previous allocation.
• Allocation and deallocation of stack memory is automatic, with predictable lifetime and size. Also, it it fixed in size.
• Heap memory necessitates manual allocation and deallocation by the programmer, using new and delete, respectively.
• Every new call must have a corresponding delete call.
• Heap memory is in the lower primary memory address space.
• Incorrect heap management can lead to run-time errors.
• Heap memory allocation is dynamic, and the size and lifetime are determined at run-time.
• As the program allocates from both stack and heap, their addresses approach each other, leading to a crash if they meet without deallocations.
• When memory is allocated on the stack, both the variable and its value are placed there, and the memory address is termed the reference.
• When heap memory is allocated, a pointer is placed on the stack, pointing to an address in heap memory where the associated value resides.

References

• A reference is another name for an existing variable, linking to the memory address where the variable's value is located, existing on the stack.

Pointers

• Pointers are allocated at run-time on the heap, making them useful when the amount of memory needed is unknown during compile-time.
• Pointers enable the construction and use of large memory-based structures like linked lists, trees, and graphs at runtime with minimal stack memory.
• Pointers reside in stack memory and holds a memory address to a location in heap memory with a stated value.
• Memory allocation is done using the new operator, and the location to which a pointer points is assigned a value by dereferencing.
• Memory allocated with new must be deallocated using delete, returning the memory to the operating system.
• After deallocation, the pointer variable should be nulled (assigned NULL, 0, or nullptr)

Errors and Exceptions

• A segmentation fault arises when a program attempts to access a memory location without permission, often when reading/writing outside allocated memory.
• The operating system terminates the program when a segmentation fault occurs, generating a core dump for analysis.

Scenarios leading to segmentation faults include

• Dereferencing NULL pointers: Accessing memory through an uninitialized or NULL pointer which leads to undefined behaviour.
• Dereferencing Freed Memory: Accessing memory through a pointer that has been freed, as it might no longer be allocated.
• Buffer Overflow: Writing data beyond the allocated buffer can overwrite adjacent memory.
• Stack Overflow: Deep or infinite recursion consumes too much stack memory.

Tips to avoid/fix segmentation faults:

• Initialize Pointers: Always initialise pointers to valid memory addresses..
• Validate Pointers: Before dereferencing, check if pointers are NULL or have valid memory addresses.
• Manage Memory Carefully: Ensure allocation and deallocation are correctly matched.
• Boundary Checks: Always perform boundary checks when assessing arrays or buffers to prevent out-of-bounds access.

Functions Reprised

• C++ programs can be modular by using encapsulation, reusable code for specific tasks, improving readability and maintainability.
• The function syntax contains returnType, functionName, FormalParameterList, and FunctionBody.
• Functions can have return types, parameters or both. Additionally, Function overloading allows multiple functions with identical names but with different parameters.

Pass by Value

• Pass by Value means that a value is sent to the function, but if changed, it does not update after execution.
• Effectively copies of the values are made and used in the function. After the function returns, the copies are destroyed without impacting the values of the variables used to call the function.

Pass by Reference

• Pass by Reference means that the function does not make copies of the actual parameters (as is done with pass by value), but actually modifies the original.
• Useful when a function manipulates more than one parameter value needing access by the calling code given that a function can return only one value using the return statement.
• When functions use reference parameters, the actual arguments must be existing variables in memory, because the reference operator (&) in the function's signature requires a memory address to bind to.
• Passing literals (such as 5, 10.5, or 'a') or expressions (like x + y orz * 2) directly into a function that expects references will result in a compilation error.

Passing Parameters as Pointers

• The address must be passed to the function
• (*value)++ in the function dereferences the pointer (accesses the memory location the pointer refers to) and increments the integer stored there.
• To increment where value is pointing to, dereference (*value) and increment (*value)++. The brackets ensures the integer is incremented and not the pointer.

Constness

• Constness refers to the immutability of variables and parameters
• Parameters can be defined as const and is read from the right to the left to the definition.

Manipulating Strings with Pointers

• Strings can be manipulated using pointers, which provide a direct way to access and modify individual characters.
• C++ distinguishes between small strings stored on the stack and larger strings on the heap, with this section focusing on the latter.
• A string is stored in memory, plus the string termination character.
• Indexing can be used to access a string's first character and strings are null terminated.
• Use char* variables to ensure you do not loose the beginning of a string when incrementing or decrementing, specifically a variable of char*.

Iterating Over Strings with Pointers

• Iteration can be done using a while loop. This also requires pointer arithmetic.

Length of a string

• The function accepts a reference to a string as a parameter and returns an integer representing the number of characters that string comprises of excluding the string termination character.

Reversing A String

• When reversing strings, you use two pointers: one pointing at the start of the string and the other at the end. You then swop the characters at these pointers, moving them towards the center until they meet or cross each other.
• Code can be written to make use of c-strings with functions to reverse strings to allow for C++ strings and C style strings.

Operator precedence

• C++ has two operators, being address-of operator (&) and the dereference operator (*).