C++ reading char from stack to string results in "Unrecognized enum" - c++

Question

I am new to C++ and there must be something that I am missing. My code is this:
std::stack<char> operators;
std::stringstream stream;
stream.str("5.2 + 3");
while(stream.peek() != -1){
char token = static_cast<char>(stream.get());
//some code checking if the token is valid
operators.push(token);
auto tmp = operators.top(); //there I can still see the char (for example '+')
std::string tmpStr = "" + tmp; //But when put into string, there is "Unrecognized enum"
}
The variable tmpStr is filled with "Unrecognized enum" instead of the contents of tmp.
I couldn't find any solution but I believe it must be something very simple.
Thanks for any help.
Edit:
So if I use tmpStr.push_back(tmp) it works. But then I use it like this:
std::queue<std::string> outQueue;
outQueue.push(" " + operators.top());
//some code
std::string result = "";
while(!outQueue.empty()){
result.append(outQueue.front() + " ");
outQueue.pop();
}
//result then has for example something like "5.2 own enum 3 own enum"
There on the positions that are appended from the operators stack, there is "own enum" and not what was actually saved there.

Answer 1

Stop doing "" + something!
This is C++ and it will not magically make a string object out of a string literal.
If the above code actually compiles, it means that somethign is of some integral type and you are taking a stack pointer (const char*) of the location that "" points to and adding a pointer offset onto that. You are not reading some random data until the next NULL.
If you want to convert something to a string you need to convert it. The standard way to this is though a output stream operator.
enum OP
{
OP_ADD,
OP_SUB,
OP_DIV,
OP_MUL
};
std::ostream& operator << (std::ostream& os, OP op)
{
switch (op)
{
case OP_ADD:
os << "ADD";
break;
case OP_SUB:
os << "SUB";
break;
case OP_DIV:
os << "DIV";
break;
case OP_MUL:
os << "MUL";
break;
default:
throw std::logic_error("Invalid OP");
}
}
This can then be used like so:
OP op = OP_ADD;
std::stringstream buff;
buff << op;
std::string sop = buff.str();
But since the above code it quite stupid, I have a shorthand for the object to string conversion:
template <typename T>
std::string to_string(T value)
{
std::stringstream buff;
buff << value;
return buff.str();
}
This can then be used like so:
OP op = OP_ADD;
std::string sop = to_string(op);