CSC 1061: Pointers and Dynamic Memory

A pointer is a variable that stores the memory address of another variable. It does not store the actual value, but rather the location where the value is stored in memory.

The 'new' operator is used to allocate memory on the heap during runtime. It returns a pointer to the allocated memory, allowing you to access the newly created space.

The dereference operator '*' is used to access the value stored at the memory address pointed to by a pointer variable.

The heap is a region of memory managed by the programmer during runtime. It allows for dynamic memory allocation, where the size of memory can be adjusted based on the program's needs.

The stack is a region of memory managed by the compiler at compile time. It holds local variables and function call information, following a LIFO (last-in, first-out) structure.

The 'delete' operator is used to deallocate memory that was previously allocated on the heap using 'new'. This releases the allocated memory back to the system for reuse.

The 'nullptr' keyword represents a pointer that does not point to any valid memory address. It's a safer alternative to using a NULL pointer, which might lead to unexpected behavior.

Memory leaks occur when dynamically allocated memory is not properly freed using 'delete', resulting in the program holding onto unused memory, potentially reducing system performance.

Dangling pointers refer to pointers that point to a memory location that has been deallocated, leading to undefined behavior and potential crashes.

Pointers can be used to pass arrays to functions as arguments, allowing the function to modify the original array directly by working on the same memory location.

A special type of array in C++ where its size can be defined during runtime rather than when the program gets compiled. This flexibility allows the array to adapt to the amount of data that needs to be stored.

A pointer that references the beginning of an array, allowing direct access to its elements.

The process of releasing memory that is no longer needed. In C++, the delete operator is used to free dynamically allocated memory that was previously created using new.

An error that occurs when memory allocated dynamically (using new) is never released, leading to a gradual consumption of available memory. It could eventually cause the program to crash.

A method of copying pointers, which results in both pointers pointing to the same memory location. Changes to data through one pointer will affect the other.

A method of copying dynamic memory, creating a new memory allocation for the copy and copying the data into it. Changes made to one copy will not affect the other.

A built-in function in C++ that copies a range of elements from one location to another. It uses pointers internally for efficient memory manipulation.

A pointer to an object is first dereferenced using -> before accessing its member functions. It is essential for working with objects in memory to ensure proper function call.

A pointer points to an array of objects. Each element in the array can be accessed by dereferencing the pointer and using the array index.

A copy of dynamic memory is created, allocating new memory for the copy and copying the data into it. It's an essential technique for maintaining data integrity and preventing unintended side effects.