C++ on Arduino: Struct constructor calls own Destructor and destroys itself - struct

Question

I want to create a class to manage data using serial communications, I re-wrote and was able to repeat the same issue.
Issue
I have a structure of data that can allocate memory on the constructor and de-allocate on the destructor. Before the next call of dataHelper.parse(), the newly created data struct instance in nextData will be passed as a pointer to a callback function to use the data. This will not work though because the destructor of the newly created data gets called right after the constructor and nextData becomes a dangling pointer. This behavior is confusing and I cannot figure out the issue here. Thanks for any help.
Struct
struct Data
{
uint8_t len;
uint16_t dataId;
uint8_t *dat;
Data()
:len(0), dataId(0), dat(nullptr)
{
}
Data(uint16_t newDataId, void *newData, uint8_t length)
:len(length), dataId(newDataId), dat(nullptr)
{
Serial.println("Called Constructor");
dat = (uint8_t *)malloc(length);
if (dat == nullptr)
{
len = 0;
return;
}
memmove(dat, newData, length);
}
~Data()
{
Serial.println("Called destructor");
free(dat);
}
};
...
Class to help with Data
...
class DataHelper
{
private:
Data* nextData = nullptr;
uint16_t exampleGetID(uint8_t bytes[])
{
return 0x000A;
}
public:
DataHelper()
{
}
void parse()
{
// Check Size IDB2 IDB1 DB1-2 DB1
// | | | | | |
uint8_t raw[TEST_SIZE] = { 0x01, 0x01, 0x00, 0x0A, 'F', 'F'}; //Example raw data. Last two are characters representing data in hex.
if (raw[0] != 0x01)
{
return; //Bad data
}
uint8_t sizeInBytes = raw[1]; //<- Size of data in bytes, not how many characters of hex.
uint16_t dataId = exampleGetID(&raw[2]); //<- Turning two bytes to one uint16_t.
if (nextData != nullptr)
{
Serial.println("Destroying old unwanted data...");
nextData->~Data(); //<- Destroying old data.
}
Serial.println("Allocating memory for new empty data...");
nextData = (Data *)malloc(sizeof(Data)); //<- Allocating space for next new data.
Serial.println("Assigning new data...");
// Data size as chars, 1 byte is 2 Hex-chars
// |
*nextData = Data(dataId, &raw[4], sizeInBytes * 2); //<- Calls destructor at end of constructor?
Serial.println("Assigned new data.\n\n\n");
}
};
...
DB1 & DB1-2 is a byte represented in hex format which is to be saved into the new instance of nextData as a hex c-string, with no null terminator.
Output
-> Allocating memory for new empty data...
-> Assigning new data...
-> Called Constructor
-> Called destructor
-> Assigned new data.
->
->
->
-> Destroying old unwanted data...
-> Called destructor
-> Allocating memory for new empty data...
-> Assigning new data...
-> Called Constructor
-> Called destructor <- Why is this called right after constructor?
-> Assigned new data.