C++ delete operator and destructor:what do they actually do and what are the differences of the two?

Question

I am trying to figure out in C++ the difference between delete operator and destructor and I tried use the following two snippets (I use visual studio 2019 to compile them) :

code 1:

#include <stdio.h>
class A
{
    public:
        A() { a = new int; *a = 42; b = 33; }
        ~A()
        {
            printf("destructor!\n");
            delete a;
        }

        int* a;
        int  b;
};

int main(int argc, const char** argv)
{
    A* myA = new A();
    printf("a:%d  b:%d\n", *(myA->a), myA->b);
    //delete myA;
    myA->~A();
    printf("b:%d\n", myA->b);
    printf("a:%d\n", *(myA->a));
}

code2: (almost the same with code 1, just change use delete to use desctructor)

#include <stdio.h>
class A
{
    public:
        A() { a = new int; *a = 42; b = 33; }
        ~A()
        {
            printf("destructor!\n");
            delete a;
        }

        int* a;
        int  b;
};

int main(int argc, const char** argv)
{
    A* myA = new A();
    printf("a:%d  b:%d\n", *(myA->a), myA->b);
    delete myA;
    //myA->~A();
    printf("b:%d\n", myA->b);
    printf("a:%d\n", *(myA->a));
}

The result of code 1 is :

while running code 2 throws exception: , and the console is :

From the results I guess that when you run myA->~A(), it just execute the destructor defined, that is delete a, making this pointer a dangling pointer. when you run delete myA, it not will also execute destructor, and make pointer myA a dangling pointer. But I am not sure how exactly these are implemented.

The explanation of the difference of the two results is my first question

The second question is: the code snippet is copied from Here, and its result is also different from mine, hopefully if anyone can also explain this

Answer 1

delete myA; is a delete expression. If myA is not nullptr, it will first call the destructor of the object pointed to by myA (if the pointed type has a destructor), then it will release the storage used by the object which was previously allocated by a new expression.

myA->~A(); explicitly calls the destructor of the object pointed to by myA. It will not release the storage previously allocated. In this case, you are leaking the memory associated with the A. Unless you are using placement new (an advanced language feature which is not used in your example) then explicitly calling a destructor is almost certainly an error.

Regarding the output of printf("b:%d\n", myA->b); and printf("a:%d\n", *(myA->a)); in both examples these result in Undefined Behavior.

When you do delete myA; the pointer myA now has an invalid pointer value (often called "dangling pointer") which you are not allowed to dereference. In both printf you try myA-> which is Undefined Behavior, so the result is meaningless.

When you do myA->~A(); the pointer myA still points to valid storage, but it does not point to an A anymore. That A was destroyed. So, similarly, trying to dereference myA will also be Undefined Behavior, resulting in meaningless output.

It seems like you may be under the impression that if running your code doesn't produce a visible error, then it must be OK. But this is not true in C++. A lot of errors lead to Undefined Behavior which is not required to crash or give any clear diagnostic that something is wrong. The fact that the myA->~A(); example did not result in a runtime error for you does not mean it is any less incorrect than the example using delete myA;.