Memory Management

Question 1

Explain the difference between the stack and the heap

Answer 1

Stack - when we know how much data needs to be stored at compile time

Heap - This is dynamically created during the programs run. Different space in memory

If we have a game where we don’t know how many enemy characters will be needed, this will need to go on the heap

Question 2

You don’t know how big a number is going to be in your program.
How would you create a variable on the heap?

Answer 2

int *ptr_to_int = new int;

This creates a pointer on the stack that points to the heap

• = dereferenc operator

*prt_to_int = 5; <- 5 is stored in the memory address on the heap

or just

int *ptr_to_int = new int(5)

after you delete make sure to:
ptr = nullptr

Question 3

We’re finished with our new int operator, free up the space

Answer 3

delete ptr_to_int;
ptr_to_int = nullptr

Question 4

What is a memory leak?

Make one

Answer 4

int *ptr_to_int = new int(5);

prt_to_int = new int(10);

delete ptr_to_int;

ptr_to_int points to the heap with a value of 5

Next, it points to a different memory location on the heap with 10

delete only deletes the new memory location, the previous is now there forever

Question 5

Create an array of doubles on the heap

Answer 5

double *arrary = new double[4];

array[0] = 1;
etc

delete[] array;

Question 6

Create a student class,
create a student object on the heap

Answer 6

class Student
{
public:
std::string name;
void Print()
{
std::cout &laquo_space;name &laquo_space;endl;
}
}

Student student = new Student
(student).name = “John”
(*student).print();

we put *student in () because we want to make sure this runs first before the .

or

student->name = “Mary”;
student->print();

Question 7

What is an initializer list

Answer 7

When you create a constructor and ask for a variable to be put in so it can update the main variable of the class it takes two steps, and name would be an empty string for a bit.

Initializer lists automatically plug that value in for you without you having to specify it

class Student{
std::string name;
public:
Strudent(std::string n) : name(n) {};

When the program makes ‘name’ here it immediately uses n right away.

Look further into this
}

Question 8

If your class has a constructor, how do you create memory on the heap for it

Answer 8

Student *student = new Student(“Mary”);

std::cout &laquo_space;student->name;

Question 9

Create a try catch statement to make sure you have enough memory available or no contiguous block that’s big enough

Answer 9

try
{
double *big_array = new double[99999999999];
delete[] big_array;
}
catch (const std::bad_alloc& exp)
{
std::cout&raquo_space; “Bad_alloc caught: “ &laquo_space;exp.what() &laquo_space;endl;
}

For the catch, bad_alloc is the type and it references exp, exp is also a constant

Question 10

What are smart pointers?

Answer 10

When you call new, you don’t have to call delete, sometimes you don’t have to even call new either.

Question 11

What is a unique pointer

Answer 11

When the pointer goes out of scope it will get destroyed.

Can’t be copied

Question 12

Create a unique pointer that is destroyed after main is finished

Answer 12

include memory

int main()
{
std::unique_ptr<int> ptr = std::make_unique<int>(42);
std::cout << *ptr << std::endl;
return 0;
}</int></int>

Question 13

What is a shared pointer?

Answer 13

smart pointer that can be copied
uses REFERENCE COUNTING
It counts down until the last reference is done before destroying itself.

Deleted when both are out of scope

Question 14

Create a shared pointer

Answer 14

class Student
{
public:
std::string name;
Student(std::string n) : name(n) {
std::cout &laquo_space;name &laquo_space;” created.\n”;
}
~Student() {
std::cout &laquo_space;name &laquo_space;” destroyed.\n”;
}
};

int main()
{
std::shared_prt<Student> ptr1 = std::make_shared<Student>("Alice");
std::share_ptr<Student> ptr2 = ptr1;</Student></Student></Student>

std::cout &laquo_space;ptr2->name;
std::cout &laquo_space;ptr1.use_count()
return 0;
}

~Student defined the destructor for the class. Whenever an object is deleted this is called.

Question 15

What is a weak pointer?

Answer 15

Refers to an object managed by shared pointer

Does not affect the reference count of the object

A shared pointer is someone holding a balloon, it stays there as long as someone’s holding it

A weak pointer just watches the balloon but doesn’t hold it up

Question 16

What does lock() do?

Answer 16

Tries to “lock in” access to the object if it still exists

Question 17

What are the steps for creating a weak pointer?

Answer 17

Create a weak pointer with no value

Create a shared pointer

Give weak pointer the value of the shared pointer

Create a temp shared pointer that tries to lock-in the value of the weak pointer if it exists (if it exists it gives you the value, if not it gives you a nullptr)

Question 18

Create a weak pointer

Answer 18

include <iostream></iostream>

#include <memory></memory>

class Thing {
public:
void hello() {
std::cout &laquo_space;“Hello from Thing!\n”;
}
};

int main() {
std::weak_ptr<Thing> weak;</Thing>

{
    // Create a shared_ptr and a Thing object
    std::shared_ptr<Thing> shared = std::make_shared<Thing>();
    weak = shared;  // weak points to the same Thing

    // Lock the weak_ptr to get a usable shared_ptr
    std::shared_ptr<Thing> temp = weak.lock();

    if (temp) {
        temp->hello();  // Call the hello() function
    }
} // shared_ptr is destroyed here, object is deleted

// Try to use weak_ptr again
std::shared_ptr<Thing> temp = weak.lock();

if (temp) {
    temp->hello();
} else {
    std::cout << "The object no longer exists.\n";
}

return 0; }