In C++, when reassigning an object, why does the constructor fire before the destructor?

I'm a beginner in C++. I'm compiling my code with GCC 9.2.0. Recently I've stumbled upon some weird behaviour which is segfaulting me.

I have a certain class wrapper for Hyperscan. I've made it so it basically has the same functionality as Python's re, but many times faster and multithreaded. I have a class regex which I usually allocate like

auto some_regex = regex();

Now, the what the constructor does, for those of you unfamiliar with Hyperscan is 2 (actually 3) things -> first it allocated memory for the regular expression database. This is done by calling their API, which is in C. Then, if it succeeds, you allocate scratch space. Now, because my implementation supports multithreading, my class instance holds a member which is a vector of scratch spaces. Nevertheless, I allocated a scratch space for each thread I use, also with their API. What I then have are a pointer to the compiled regex database and a vector of scratch space pointers.

When deconstructing the object, I have to free the database and scratch spaces (I also use the provided functions from the API) if they're allocated. So far so good. The problem arises when I do something like this:

auto some_regex = regex();
some_regex = regex(R"(\s+)");

Do you see a problem here? Maybe I'm too much of a noob to see it, but it looks good to me. But nope. It segfaults in the destructor while trying to free the database memory. Debugging it, I have come across these actions:

allocate memory for some_regex
initialize some_regex
allocated new memory for some_regex
initialize new some_regex
run destructor for the old some_regex
run destructor for the new some_regex

Basically, the destructor for the first instance is run only after the constructor for the second one fires. What this does is essentially making it so that the first destructor frees up the data allocated and initialized by the second constructor instead of just cleaning itself.

Now, things get weirder. I looked into the addresses at hand, because I started setting the freed up pointers to nullptr - it turns out that this happens:

allocate memory for some_regex
initialize some_regex
allocated new memory for some_regex
initialize new some_regex
run destructor for the old some_regex
database pointer is not 0, free it

set database pointer to nullptr
run destructor for the new some_regex
database pointer is not 0, free it (BUT THIS IS ALREADY FREED MEMORY???)
SIGSEGV

I'm utterly confused. Even after setting the database pointer to null explicitly, the new one, after the constructor did its job, assigns it a new address.

This reproduces the behaviour:

#include 
#include 

mock::mock()
{
    std::cout << "Starting constructor..." << std::endl;
    this->test = (int*)malloc(sizeof(int));
    *this->test = 0;
    std::cout << "Ending constructor..." << std::endl;
}


mock::mock(int x)
{
    std::cout << "Starting full constructor..." << std::endl;
    this->test = (int*)malloc(sizeof(int));
    *this->test = x;
    std::cout << "Ending full constructor..." << std::endl;
}

mock::~mock()

{
    std::cout << "Starting destructor...";
    free(this->test);
    this->test = nullptr;
    std::cout << "Address of test is " << this->test << std::endl;
    std::cout << "Ending destructor..." << std::endl;
}

run it in main like this:

auto some_mock = mock();
some_mock = mock();
some_mock = mock();
some_mock = mock(3);

Expected result:

Starting constructor...
Ending constructor...
Starting destructor...Address of test is 0
Ending destructor...
Starting constructor...
Ending constructor...
Starting destructor...Address of test is 0
Ending destructor...
Starting constructor...
Ending constructor...

Starting destructor...Address of test is 0
Ending destructor...
Starting full constructor...
Ending full constructor...
Starting destructor...Address of test is 0
Ending destructor...
Process returned 0

Actual result:

Starting constructor...
Ending constructor...
Starting constructor...
Ending constructor...
Starting destructor...Address of test is 0
Ending destructor...
Starting constructor...
Ending constructor...
Starting destructor...Address of test is 0

Ending destructor...
Starting full constructor...
Ending full constructor...
Starting destructor...Address of test is 0
Ending destructor...
*** Error in `/deploy/cmake-build-local-debug/CPP': double free or corruption (fasttop): 0x0000000002027c40 ***
.
.
.
Starting destructor...

Process finished with exit code 134 (interrupted by signal 6: SIGABRT)

Is this intended behaviour? If so, why??? And how can I get around it (aside from using new and deleting before reassigning)?