Problem with a parsing function (int to const char*) - c++

Question

I needed to create a parsing function so i wrote this:
inline const char* parse(const int &arg)
{
return std::to_string(arg).c_str();
}
Looks pretty rational - at least to me - but when i try to see the value of this function with std::cout instead of an integer value i get some random ascii characters.
So i tried changing the function and i ended up with something like this:
inline const char* parse(const int &arg)
{
return (new std::string(std::to_string(arg)))->c_str();
}
And it works as intended, but what I would like to know is why the first case of function doesn't work properly.
Also, there's a secondary question that has arisen (probably a stupid one as im a beginner) - should I return the value of the function with std::move if i create the std::string dynamically?
return std::move((new std::string(std::to_string(arg)))->c_str());

Answer 1

inline const char* parse(const int &arg)
{
return std::to_string(arg).c_str();
}
A new string local to the function parse is created from the std::to_string(arg), and you get it's internal string with c_str. c_str of course returns a const char *, but now this creates an issue. The string is still local to the function, but so after it's destroyed when the function ends, what exactly is returned? c_str only returns a pointer to the internal string, it doesn't create a copy. Thus, you have a dangling pointer: it points to deallocated memory.
inline const char* parse(const int &arg)
{
return (new std::string(std::to_string(arg)))->c_str();
}
new creates a string on the heap. In the previous example, a string was created on the stack, which was deallocated after the function ended, but the heap doesn't work this way. You have to delete the memory manually with delete. This creates another issue: you return the c_str and it works because the string has not been deallocated, but how do you deallocate the string now? Indeed, you can't because there is no pointer to it left, so you've created a memory leak.
Your reason to return a const char * is:
I need to return const char* because the function is meant to only be used as an argument in another function (the argument's type is const char*).
But you can still return an std::string and use c_str on the returned value. An example with puts:
#include <cstdio>
#include <string>
std::string parse(const int &arg)
{
return std::to_string(arg);
}
int main()
{
std::puts(parse(42).c_str());
return 0;
}

Answer 2

This invokes undefined behavior in the first case. You create a string object which lifetime is ended when the function returns, so the pointer you return will also be invalid at that time.
In the second case, you will create a memory leak, because the string object is never deleted.
What you can do is to copy the string i.e. like this:
return strdup(str.c_str());
But of course the caller has to free this pointer when it is done. So the main question is why you can not return the string object itself, which would be the safe way to do.
std::string parse(const int &arg)
{
return std::to_string(arg);
}