What and c++ exception - c++

Question

I tried to create my custom exception class for printing helpful message's sakes:
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <sstream>
#include <cstdlib>
class invalid_input_exception : public std::exception
{
private:
const char* input;
public:
invalid_input_exception(const char *);
const char* what() const noexcept;
};
invalid_input_exception::invalid_input_exception(const char * input) : input(input) { }
const char * invalid_input_exception::what() const noexcept
{
std::string message;
message.append("Occured on: ")
.append(input);
return message.c_str();
}
int main(int argc, char ** argv)
{
const char* str = "Aaaaa";
throw invalid_input_exception(str);
}
But it doesn't excatly work because after throwing the instance of invalid_input_exception the what() message was actually empty.
DEMO
What was wrong?

Answer 1

return message.c_str();
message is local to the function, and you're returning a pointer to its internal buffer. Undefined behaviour ensues.

Answer 2

message is a local variable, which has been destroyed when out of invalid_input_exception::what(), and the pointer returned by string::c_str() became invalid too.
You need to deep copy the content here, and might store it to the member variable input. And pay attention to the allocation and deallocation of it.

Answer 3

Two main problems here:
message is a local variable and will go out of scope at the end of what - thus the returned pointer is not pointing to valid string conent.
The exception class MUST make a copy of the passed message since you cannot expect the source of the message to be still valid at the point the exception will be catched.
You could go for
#include <exception>
#include <string>
class invalid_input_exception : public std::exception
{
private:
std::string input;
public:
invalid_input_exception(const char *in) : input(in)
{
input = "Occured on: " + input;
}
const char* what() const noexcept
{
return input.c_str();
}
};
or you use runtime_error as a base which has a message-copy-constructor and what:
#include <stdexcept>
#include <string>
class invalid_input_exception : public std::runtime_error
{
public:
invalid_input_exception(const char *in) :
runtime_error(("Occured on" + std::string(in)).c_str())
{ }
const char* what() const noexcept
{
return runtime_error::what();
}
};

Answer 4

Consider this implementation instead:
#include <stdexcept>
class invalid_input_exception : public std::runtime_error
{
public:
invalid_input_exception(const std::string& msg): std::runtime_error{ msg }{}
};
This is better for the following reasons:
The what() member function is already implemented by std::runtime_error, to work with a std::string.
Your exception class is a std::runtime_error (inheriting from std::exception dirrectly only makes sense when it is imposed by the module's design, or when you need an exception offering another data format (that is, different than a text message). Alternately, you could inherit from std::logic_error.
The class manages it's resources correctly, through the use of std::string.