Converting from a std::string to bool

Question

What is the best way to convert a std::string to bool? I am calling a function that returns either \"0\" or \"1\", and I need a clean solution for turning this into a boole

Answer 1

Write a free function:

bool ToBool( const std::string & s ) {
   return s.at(0) == '1';
}

This is about the simplest thing that might work, but you need to ask yourself:

• what should an empty string return? the version above throws an exception
• what should a character other than '1' or '0' convert to?
• is a string of more than one character a valid input for the function?

I'm sure there are others - this is the joy of API design!

Answer 2

I'd change the ugly function that returns this string in the first place. That's what bool is for.

Answer 3

You could always wrap the returned string in a class that handles the concept of boolean strings:

class BoolString : public string
{
public:
    BoolString(string const &s)
    :   string(s)
    {
        if (s != "0" && s != "1")
        {
            throw invalid_argument(s);
        }
    }

    operator bool()
    {
        return *this == "1";
    }
}

Call something like this:

BoolString bs(func_that_returns_string());
if (bs) ...;
else ...;

Which will throw invalid_argument if the rule about "0" and "1" is violated.

Answer 4

I'd use this, which does what you want, and catches the error case.

bool to_bool(const std::string& x) {
  assert(x == "0" || x == "1");
  return x == "1";
}

Answer 5

I am surprised that no one mentioned this one:

bool b;
istringstream("1") >> b;

or

bool b;
istringstream("true") >> std::boolalpha >> b;

Answer 6

Either you care about the possibility of an invalid return value or you don't. Most answers so far are in the middle ground, catching some strings besides "0" and "1", perhaps rationalizing about how they should be converted, perhaps throwing an exception. Invalid input cannot produce valid output, and you shouldn't try to accept it.

If you don't care about invalid returns, use s[0] == '1'. It's super simple and obvious. If you must justify its tolerance to someone, say it converts invalid input to false, and the empty string is likely to be a single \0 in your STL implementation so it's reasonably stable. s == "1" is also good, but s != "0" seems obtuse to me and makes invalid => true.

If you do care about errors (and likely should), use

if ( s.size() != 1
 || s[0] < '0' || s[0] > '1' ) throw input_exception();
b = ( s[0] == '1' );

This catches ALL errors, it's also bluntly obvious and simple to anyone who knows a smidgen of C, and nothing will perform any faster.