Take this very simple class. The main() function just creates an object of it. Even though the constructor and destructor don't have an implementation here. My assumption is that the constructor will push the three member variables onto the stack when the object is created.

At the end of main() the object's destructor will get implicitly called. Is it the job of the destructor to then pop these variables off the stack?

class MyClass1
{
   public:
       MyClass1(){}
       ~MyClass1(){}

   private:
      int num1_ = 1;
      int num2_ = 2;
      int num3_ = 3;
};

int main()
{
     MyClass1 mc1; // Constructor gets called

     // Destructor implicitly called here as the object is going out of scope
}

Take this very simple class. The main() function just creates an object of it. Even though the constructor and destructor don't have an implementation here. My assumption is that the constructor will push the three member variables onto the stack when the object is created.

At the end of main() the object's destructor will get implicitly called. Is it the job of the destructor to then pop these variables off the stack?

class MyClass1
{
   public:
       MyClass1(){}
       ~MyClass1(){}

   private:
      int num1_ = 1;
      int num2_ = 2;
      int num3_ = 3;
};

int main()
{
     MyClass1 mc1; // Constructor gets called

     // Destructor implicitly called here as the object is going out of scope
}

• c++
• constructor
• destructor
• raii
• member-variables

• 1 "My assumption is that the constructor will push the three member variables onto the stack when the object is created." This is a wrong assumption. The C++ standard does not define a stack. Constructors and destructors work at given storages. They don't pop or push storages on stack. This is a work of a compiled runtime. – 3CxEZiVlQ Commented Apr 1 at 22:22
• There is no stack or heap in the standard except for the data structures. The standard talks auto automatic and dynamic initialization and the lifetimes associated with those concepts. A constructor should initialize all member of a class, and the destructor should clean up all members of the class. Idealy this is an empty destructor because all of your members are RAII types or fundemental types. – NathanOliver Commented Apr 1 at 22:24
• "My assumption is that the constructor will push the three member variables onto the stack when the object is created." -- Why do you assume this? A question based on an unsupported and false assumption is often poorly received (call it "insufficient research"). Would you assume the existence of a different constructor to handle the case where a MyClass1 object is dynamically allocated (hence not on the stack)? – JaMiT Commented Apr 1 at 22:24
• 3 Even though the constructor and destructor don't have an implementation here -- They do have implementations. Once you did this {}, an implementation exists, even if it's empty. – PaulMcKenzie Commented Apr 1 at 22:28
• On my machines's compilers, a function call (even main) has a frame, which is where the local variables get allotted their space (on the stack) by the compiler (unless they are optimized away or put into registers). Individual variables (or member variables of a class) are not individually pushed/popped on the stack. – Eljay Commented Apr 1 at 22:35

1 Answer 1

No, the destructor does not pop member variables. Likewise, the constructor does not push member variables.

The job of a constructor is to initialize already-allocated storage so that, afterward, that storage contains a valid object. Symmetrically, the job of a destructor is to perform any necessary cleanup before the object's storage is reclaimed; when the destructor returns, the storage is still allocated, but does not contain a valid object anymore.

For your main() function, when compiled by a typical compiler, the generated object code will begin by reserving storage for mc1 on the call stack. Normally this is done by adjusting the stack pointer register. We don't usually refer to this as "pushing", because to "push" there should be an existing value being pushed, whereas here, typically, the reserved storage is left uninitialized.

Then, main() will invoke the constructor, passing the address of the reserved stack storage as the this argument. For this program, the constructor will write the values 1, 2, and 3 into the passed storage.

Next, main() will invoke the destructor, again passing the same address as the this argument. For this program, the destructor will not do anything.

Finally, main() will reclaim the storage used by mc1 by adjusting the stack pointer register back to what it was originally. This would not usually be called "popping" because the values contained in the storage are discarded.

The key point is that allocation (including on the stack) and construction are separate activities, as are deallocation and destruction.

In fact, it is possible to invoke a constructor on already-allocated storage by using the "placement new" syntax, and possible to explicitly invoke a destructor without reclaiming storage, although in both cases one must be careful not to violate the language rules and thereby cause undefined behavior.