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 boolean value.

Answer 1

bool to_bool(std::string const& s) {
     return s != "0";
}

Answer 2

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 3

Try this:

bool value;

if(string == "1")
    value = true;
else if(string == "0")
    value = false;

Answer 4

bool to_bool(std::string const &string) { 
    return string[0] == '1';
}

Answer 5

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

Answer 6

It'll probably be overkill for you, but I'd use boost::lexical_cast

boost::lexical_cast<bool>("1") // returns true
boost::lexical_cast<bool>("0") // returns false

Answer 7

Here's a way similar to Kyle's except it handles the leading zeroes and stuff:

bool to_bool(std::string const& s) {
     return atoi(s.c_str());
}

Answer 8

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 9

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 10

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.