12: Memory Management

A dynamic data structure where elements can only be added or removed from the top, like a stack of books.

A struct that holds a value (data) and a pointer to the next node in the linked list. It is the building block of a stack.

A pointer that points to the top-most node of the stack, allowing access to the entire structure.

Adds a new element to the top of the stack.

Removes and returns the top element from the stack.

Returns the value of the top element on the stack without removing it.

Checks whether the stack is empty or not.

A data structure that allows elements to be added and removed only from the top, following the LIFO (Last-In, First-Out) principle.

A constructor that initializes a stack by setting the topn pointer to nullptr, making the stack empty. This ensures a clean slate.

A memory allocation technique that dynamically allocates memory for a new node when an element is pushed onto the stack. This allows the stack to grow as needed.

An error that occurs when a program attempts to access or modify memory that it is not allowed to. This can happen if a program tries to dereference a null pointer.

A member function of a class that cleans up the nodes of the stack by deleting each node starting from the top until the top becomes nullptr. It iterates through the linked list, freeing memory for each node.

The function that is called automatically when an object of the stack class goes out of scope. It is responsible for releasing the memory allocated to the stack's nodes to avoid memory leaks.

An operator that allows assigning one stack object to another. It ensures efficient copying by first cleaning up the left operand's existing nodes, then copying the nodes from the right operand (source stack) to the left operand (destination stack).

Refers to the practice of avoiding direct calls to the destructor within the assignment operator's implementation to prevent potential issues with object state.

A technique for implementing the assignment operator that leverages the copy constructor and the swap function. It creates a local copy of the right operand, swaps the nodes between the original and the copy, and then lets the local copy's destructor handle the cleanup.

The process of creating a new instance of a class using an existing instance as a template. It involves copying the data from the existing instance to the new instance, but not referencing the same memory locations. This ensures that changes to the existing instance don't affect the newly created one.

A special function in a class that is automatically called when an object of that class is being destroyed. This ensures that resources allocated to the object are properly deallocated, like releasing memory and closing files.

An operation that allows you to create a new instance of a class using the data from an existing instance. It involves copying relevant data from the existing object while ensuring that any modifications to the copied object don't affect the original object.

A design principle that suggests that if you need to manually implement either a destructor, copy constructor, or assignment operator, then all three should be implemented to ensure proper object management, even if they seem like obvious operations.

A special type of constructor that takes a constant reference to an object of the same class as its parameter. It's used for copying data from one object to another.

When copy constructors are not explicitly defined for a class, the compiler generates a default copy constructor. This constructor performs a shallow copy, where the data members of the new object are simply copied from the original object. This can lead to problems if the original object contains pointers.

A copy constructor that copies the data members of the original object, but instead of just copying the pointers, it allocates new memory for the data pointed to by the pointers and copies the data into that new memory. This ensures that both objects have independent copies of the data.

The assignment operator that is automatically generated by the compiler. This operator, just like the automatically generated copy constructor, performs a shallow copy. As a result, issues can arise if any data members are pointers.

When we overload the assignment operator, we provide our own implementation to handle the assignment operation. This allows for custom behavior, such as deep copies of data, which is essential for avoiding unintended side effects.

This refers to the process of allocating and deallocating memory for objects. It usually involves managing the lifetime of dynamically allocated memory to prevent leaks or corruption.

This describes the process of allocating memory for objects during program execution, which is used for creating objects within the program's runtime environment.

A strategy for managing memory that involves tracking and releasing unused memory to prevent leaks. This approach allows for efficient and safe memory usage by freeing up resources for future allocation.

A data type that holds a sequence of characters. It can be visualized as a container that stores individual characters, allowing you to access and manipulate them.

A type of error that occurs when a program tries to access data through a pointer that is no longer valid. Imagine trying to open a door that has disappeared!

The process of releasing memory that was dynamically allocated previously. It eliminates the need for unnecessary space, preventing memory leaks.

A memory allocation error that occurs when a program requests more memory than is available in the heap. It's like trying to store too many packages in a small box.

A fundamental programming principle that suggests that every dynamic memory allocation (using 'new') should have a matching deallocation (using 'delete'). It's like keeping your space tidy by returning what you borrow.

A pointer that points to the top node of the stack which allows you to access the entire stack structure. Similar to the head pointer in a linked list.

A function in C++ that creates a new object of a given data type (in this case, a linked node) in memory. You need this to dynamically make new nodes in the stack.

This function lets you peek at the very top element of the stack without removing it. This function is useful to check what element is currently at the top. It is defined with the const keyword to ensure that the top value is not changed.

A function that removes the top element from a non-empty stack. It returns the value that was at the top of the stack. In the stack implementation, it updates 'topn', the pointer to the top of the stack.

A function that adds a new element to the top of the stack. This function creates a new node (using the 'new' operator) and inserts it at the top of the stack, updating the 'topn' pointer appropriately.

This function checks if the stack is empty (no elements). It returns true if the stack is empty or false if the stack has at least one element. It checks if the topn pointer has been initialized (if it is null)

If the stack is not cleared before a new stack is assigned, it results in dangling pointers and memory leaks. This function cleans up by delete-ing all of the lnode objects using a loop, setting topn to NULL to signify the end of the list.

A process that ensures all nodes in a stack are deleted, releasing the memory they were holding.

In C++, new allocates memory for an object and calls the constructor to initialize it, while delete calls the destructor and frees the allocated memory. Think of new as reserving a table at a restaurant and delete as leaving the table and releasing it for others.

A destructor is a special member function that's automatically called when an object goes out of scope (e.g., when it's deleted or leaves the scope). It's like cleaning up your room before leaving, ensuring everything is in order.

The operator= is used to copy data from one object to another after initialization. Consider it as copying recipes from one cookbook to another - the content is copied, but the source remains unchanged.

A copy constructor is invoked when a new object is initialized using an existing object. Think of it as making a duplicate of a recipe - both the original and the copy exist, allowing you to modify one without affecting the other.

The copy constructor is called during object initialization, while the assignment operator is used after initialisation. Think of the difference between taking a photo immediately after buying a camera (copy constructor) and taking a photo later after the camera is set up (assignment operator).

Dynamic memory allocation involves allocating memory during runtime. Think of it as reserving a parking spot for your car at a busy parking lot.

A memory leak occurs when dynamically allocated memory isn't properly freed. Imagine leaving a parking spot occupied even after your car is gone - it's wasted space.

The delete operator releases the memory allocated with new, preventing memory leaks. Think of it as returning a rented car to the rental company.

It's crucial to ensure that every new operation has a corresponding delete to avoid leaks. This ensures resources are freed up and prevents memory exhaustion. Think of it as balancing your bank account by spending and earning in equal amounts.

The Rule of Three indicates that if you need to explicitly define a destructor, copy constructor, or assignment operator for a class, you should implement all three to maintain proper object management. Think of it as a set of instructions for maintaining a car: If you need to change the tires, you should also check the engine and car fluids.