Does my C++ variable live on the stack or the heap?

Question

This is my first question on stack overflow. Apologies if this is a "dumb" question, but I'm currently learning C++, and I'm a little confused by something. As I understand it, in the code below, the variable "myVariable" is declared on the heap but instantiated in the constructor on the stack. So where does it "live" - on the heap or the stack?

class MyClass{
    int _myVariable;
    MyClass(int i){
        _myVariable = i;
    }
}

Answer 1

The member variable is allocated according to how class is instantiated.

void example() {
  MyClass a{17}; // This allocates memory on stack
  MyClass *b = new MyClass(17); // This allocates memory on heap
}

Answer 2

"Stack" and "Heap" are implementation details. The C++ standard defines Automatic Storage and Dynamic Storage. The most common implementations for the storage of variables are stack and heap, respectively.

The new operator makes an object live on the dynamic storage:

MyClass* mc = new MyClass(14);. Note how we now need to use a pointer to access it.

With automatic storage, we can omit the pointer semantics:

MyClass mc = MyClass(14); // constructs an object on the automatic storage.

The object lifetime is managed - you've guessed - automatically. More precisely until the end of the scope.

With dynamically allocated objects, you have to manage the lifetime of the objects yourself.

There are cases where you can't use automatic storage: Namely polymorphism.

If MyClass is polymorphic (that means, it has virtual functions), you can't put it into the automatic storage since the compiler needs to know the size of an object. Since with polymorphism, the size of the pointed-to object can change at runtime it's not possible to create it on the automatic storage.

MyClass c = MyClass2(); //Object Slicing 
c.foo(); // calls MyClass::foo()

MyClass* cc = new MyClass2(); //No Object Slicing
cc->foo(); // calls MyClass2::foo();

There are helper classes that take away the responsibility to clean up your memory: unique_ptr and shared_ptr (although the latter is used rarely).