Hey all check this out:

struct A
{
    int val = 0;

    A() { printf( "Construct A [%d]", val ); }
    ~A() { printf( "Destruct A [%d]", val ); }
};

int main()
{
    A a;
    a.val = 500;

    a = A();
    printf( "Finally %d", a.val );
    a.val = 300;
    return 0;
}

You have two instances of A. The variable named a, which has a "val" of 300 at the time it is destructed, and the temporary created on the line "a = A();".

To be clear, that quoted line creates a temporary A, copies its value into the variable named "a" via the assignment operator, and then destructs the temporary.

Ah right it's the assignment operator that gets called. Weird, for some reason I expected the old a to be destructed. Must be because it's late. Thanks.

So you don't need to worry about memory leaks from this - the new A is destroyed, the variable a is only changed by assignment.
Destructors are only called when a variable goes out of scope (RAII), a temporary is created and destroyed (ie via a = A(); ), or when objects are explicitly destroyed (via delete, for example).

You could explicitly invoke the dtor before you invoke the ctor again.
a.~A();
a = A();

There are ways to make the pattern work, but you must know far more about memory management than you currently do.

The pattern is to use placement new on the memory address to create a new object at the location without automatically invoking the destructor. There are several risks involved, especially if it is using a polymorphic type.

The pattern is to destroy the object by explicitly calling the destructor, then use placement new to construct an object at that location in memory without regard to its prior contents.

It isn't really that difficult to do in code, I typed in the few characters involved but then removed them because if it is a pattern you are going to use you should invest the time to study out the side effects and potentially code-fatal consequences involved.

It is a fairly advanced technique in the language that comes with a lot of responsibility by assuming you know all the side effects and have taken steps to address them.

For completeness sake, in C++11 there is also std::is_trivially_destructible which officially allows you to copy-construct via placement new repeatedly without bothering to call the destructor.