C++: Is a Virtual Destructor needed for stack allocated objects?

I am new to C++ and would like to know if the use of a virtual destructor is required in the following program:

#include <iostream>

class Shape2D {
protected:
    int firstDimension;
    int secondDimension;
public:
    Shape2D(int a, int b) {
        firstDimension = a;
        secondDimension = b;
    }
    virtual void getArea() {
        std::cout << "Area undefined." << std::endl;
    }
};

class Rectangle : public Shape2D {
public:
    Rectangle(int length=0, int width=0) : Shape2D(length, width) { 
    }
    void getArea() {
        int area = firstDimension*secondDimension;
        std::cout << "Area of rectangle: " << area << " sq units." << std::endl;
    }
};

int main()
{
    Rectangle rct(4, 5); // stack allocated derived object
    Shape2D *sh = &rct; // base pointer to derived object
    sh->getArea();

    // object goes out of scope here.
}

I was reading this post and the most upvoted answer said that the use of a virtual destructor is suitable whenever we want to delete a derived object allocated by new through its base pointer. However, in this context, we are allocating a derived object Rectangle on the stack in the main routine and the base pointer is not being delete-ed so would it matter if a virtual destructor is provided?

Since the instance of the derived object rct is on the stack and not dynamically allocated using new, there is no need for a virtual destructor in the base. This is specific to your exact code though and not a general rule.

The purpose of a virtual destructor is to make sure that the destructor of the derived class is called when a derived object is deleted through a base class pointer. This is important when the derived class destructor has to do extra work like releasing resources, e.g. closing files, freeing memory, etc.

It is generally considered good practice to provide a virtual destructor in a base class if it is intended to be used as a polymorphic base class, and derived objects are expected to be allocated dynamically. There are other options like marking you non-virtual destructor as private or protected which will result in compile errors when you try to delete through the base.

If you intended to delete via the base class then it necessary to have a virtual destructor to avoid undefined behavior.

C++ Standard (ISO/IEC 14882:2017), deleting an object through a pointer to a base class with a non-virtual destructor is undefined behavior. Specifically, section 5.3.5, "Delete" states:

"If the static type of the object to be deleted is different from its dynamic type, the static type shall be a base class of the dynamic type of the object to be deleted and the static type shall have a virtual destructor or the behavior is undefined."

If you know that your code will not be extended by 3rd party's then you might consider the alternative approach using std::variant or similar construct if available to you.