C++ Parsing and Storing any kind of data - c++

Question

I'm working on a text-based a simple command processor for a microcontroller project (C and C++). It implements an "explicit setter" so to speak. It means that I store pointers to target memory locations and set them to the incoming data.
First of cource, I parse the data based a predefined set of syntactical rules:
"12345" -> string (char*)
12345 -> unsigned int
12.45 -> float
-123456 -> int (signed)
This is the method I've come up with:
void* CommandInterpreter::ParseArgumentValue(std::string token, size_t* ptrSize = nullptr) {
try {
void* value = NULL;
if(std::count(token.begin(), token.end(), '.') == 1) {
auto result = (float)std::atof(token.c_str());
value = malloc(sizeof(float));
ptrSize = sizeof(float);
memcpy(value, &result, sizeof(float));
} else if(token.front() == '"' && token.back() == '"') {
const char* result = token.substr(1, token.size()-2).c_str();
size_t size = (strlen(result) * sizeof(uint8_t)) + 1;
value = malloc(size);
ptrSize = size;
memcpy(value, result, size);
} else if(token.front() == '-') {
auto result = (int)std::atoi(token.c_str());
value = malloc(sizeof(int));
ptrSize = sizeof(int);
memcpy(value, &result, sizeof(int));
} else {
auto result = (unsigned int)std::stoul(token.c_str());
value = malloc(sizeof(unsigned int));
ptrSize = sizeof(unsigned int);
memcpy(value, &result, sizeof(unsigned int));
}
return value;
} catch(std::invalid_argument) {
//return NULL;
} catch(std::out_of_range) {
//return NULL;
}
}
I know it's not pretty, and it borders on bad-practice but it works.. however this will need to be freed after I process the value.
The actual setter-part looks like this:
auto setterdef = this->mDefinitions2[tokens[1]];
void* value = ParseArgumentValue(tokens[2]);
memcpy(setterdef.TargetPtr, value, setterdef.TargetSize);
if(memcmp(setterdef.TargetPtr, value, setterdef.TargetSize) != 0)
throw "COULD_NOT_SET";
free(value);
rbuilder.SetName("OK");
return rbuilder.Get();
The setter part works well, however I want to use the same function to parse an incoming parameter list and then store it in an std::map<std::string, void*> but this will keep the allocated memory even after the map is destroyed; as of right now I have a foreach in the destructor of my CommandParameterList class which frees the pointers in the map.. but it seems pretty odd to me.
My question would be.. how bad is this? And is there a better way to do this?
I know about std::any however, as far as I know I cannot just memcpy X amount of bytes from it, and I'd need to know the specific type to std::any_cast it.