Converting bool to text in C++

We're talking about C++ right? Why on earth are we still using macros!?

C++ inline functions give you the same speed as a macro, with the added benefit of type-safety and parameter evaluation (which avoids the issue that Rodney and dwj mentioned.

inline const char * const BoolToString(bool b) { return b ? "true" : "false"; } 

Aside from that I have a few other gripes, particularly with the accepted answer :)

// this is used in C, not C++. if you want to use printf, instead include <cstdio> //#include <stdio.h> // instead you should use the iostream libs #include <iostream> // not only is this a C include, it's totally unnecessary! //#include <stdarg.h> // Macros - not type-safe, has side-effects. Use inline functions instead //#define BOOL_STR(b) (b?"true":"false") inline const char * const BoolToString(bool b) { return b ? "true" : "false"; } int main (int argc, char const *argv[]) { bool alpha = true; // printf? that's C, not C++ //printf( BOOL_STR(alpha) ); // use the iostream functionality std::cout << BoolToString(alpha); return 0; } 

Cheers :)

@DrPizza: Include a whole boost lib for the sake of a function this simple? You've got to be kidding?

C++ has proper strings so you might as well use them. They're in the standard header string. #include <string> to use them. No more strcat/strcpy buffer overruns; no more missing null terminators; no more messy manual memory management; proper counted strings with proper value semantics.

C++ has the ability to convert bools into human-readable representations too. We saw hints at it earlier with the iostream examples, but they're a bit limited because they can only blast the text to the console (or with fstreams, a file). Fortunately, the designers of C++ weren't complete idiots; we also have iostreams that are backed not by the console or a file, but by an automatically managed string buffer. They're called stringstreams. #include <sstream> to get them. Then we can say:

std::string bool_as_text(bool b) { std::stringstream converter; converter << std::boolalpha << b; // flag boolalpha calls converter.setf(std::ios_base::boolalpha) return converter.str(); } 

Of course, we don't really want to type all that. Fortunately, C++ also has a convenient third-party library named Boost that can help us out here. Boost has a nice function called lexical_cast. We can use it thus:

boost::lexical_cast<std::string>(my_bool) 

Now, it's true to say that this is higher overhead than some macro; stringstreams deal with locales which you might not care about, and create a dynamic string (with memory allocation) whereas the macro can yield a literal string, which avoids that. But on the flip side, the stringstream method can be used for a great many conversions between printable and internal representations. You can run 'em backwards; boost::lexical_cast<bool>("true") does the right thing, for example. You can use them with numbers and in fact any type with the right formatted I/O operators. So they're quite versatile and useful.

And if after all this your profiling and benchmarking reveals that the lexical_casts are an unacceptable bottleneck, that's when you should consider doing some macro horror.

C++20 std::format("{}", true) (GCC 13, CLANG 14)

main.cpp

#include <format> #include <iostream> #include <string> int main() { std::string s = std::format("Is it {} or {}?", true, false); std::cout << s << std::endl; } 

Compile and run:

g++ -ggdb3 -O0 -std=c++20 -Wall -Wextra -pedantic -o main.out main.cpp ./main.out 

Output:

Is it true or false? 

Tested on GCC 13.2.0, Ubuntu 24.04.

Documented at:

• https://en.cppreference.com/w/cpp/utility/format/format
• https://en.cppreference.com/w/cpp/utility/format/formatter#Standard_format_specification

libfmt-dev: compatible library if your stdlib doesn't have std::format yet

libfmt-dev is the awesome library that became C++20 std::format, so if your C++ Standard Library doesn't have the feature yet you can also:

sudo apt install libfmt-dev 

Modify source to replace:

• <format> with <fmt/core.h>
• std::format to fmt::format

main2.cpp

#include <fmt/core.h> #include <iostream> #include <string> int main() { std::string s = fmt::format("Is it {} or {}?", true, false); std::cout << s << std::endl; } 

and compile and run with:

g++ -std=c++11 -o main2.out main2.cpp -lfmt ./main2.out 

Output:

Is it true or false? 

Tested on GCC 10.0.1, Ubuntu 20.04.

Related: std::string formatting like sprintf

This should be fine:

 const char* bool_cast(const bool b) { return b ? "true" : "false"; } 

But, if you want to do it more C++-ish:

 #include <iostream> #include <string> #include <sstream> using namespace std; string bool_cast(const bool b) { ostringstream ss; ss << boolalpha << b; return ss.str(); } int main() { cout << bool_cast(true) << "\n"; cout << bool_cast(false) << "\n"; } 

If you decide to use macros (or are using C on a future project) you should add parenthesis around the 'b' in the macro expansion (I don't have enough points yet to edit other people's content):

#define BOOL_STR(b) ((b)?"true":"false") 

This is a defensive programming technique that protects against hidden order-of-operations errors; i.e., how does this evaluate for all compilers?

1 == 2 ? "true" : "false" 

compared to

(1 == 2) ? "true" : "false" 

A really quick and clean solution, if you're only doing this once or don't want to change the global settings with bool alpha, is to use a ternary operator directly in the stream, like so:

bool myBool = true; std::cout << "The state of myBool is: " << (myBool ? "true" : "false") << std::endl; enter code here 

Ternarys are easy to learn. They're just an IF statement on a diet, that can be dropped pretty well anywhere, and:

(myBool ? "true" : "false") 

is pretty well this (sort of):

{ if(myBool){ return "true"; } else { return "false"; } } 

You can find all kinds of fun uses for ternarys, including here, but if you're always using them to output a "true" "false" into the stream like this, you should just turn the boolalpha feature on, unless you have some reason not to:

std::cout << std::boolalpha; 

somewhere at the top of your code to just turn the feature on globally, so you can just drop those sweet sweet booleans right into the stream and not worry about it.

But don't use it as a tag for one-off use, like this:

std::cout << "The state of myBool is: " << std::boolalpha << myBool << std::noboolalpha; 

That's a lot of unnecessary function calls and wasted performance overhead and for a single bool, when a simple ternary operator will do.

I use a ternary in a printf like this:

printf("%s\n", b?"true":"false"); 

If you macro it :

B2S(b) ((b)?"true":"false") 

then you need to make sure whatever you pass in as 'b' doesn't have any side effects. And don't forget the brackets around the 'b' as you could get compile errors.

With C++11 you might use a lambda to get a slightly more compact code and in place usage:

bool to_convert{true}; auto bool_to_string = [](bool b) -> std::string { return b ? "true" : "false"; }; std::string str{"string to print -> "}; std::cout<<str+bool_to_string(to_convert); 

Prints:

string to print -> true 

Without dragging ostream into it:

constexpr char const* to_c_str(bool b) { return std::array<char const*, 2>{"false", "true "}[b] ; }; 

Use boolalpha to print bool to string.

std::cout << std::boolalpha << b << endl; std::cout << std::noboolalpha << b << endl; 

C++ Reference

How about the simple:

constexpr char const* toString(bool b) { return b ? "true" : "false"; } 

Strictly speaking, you CAN'T convert any numerical value (boolean included) into string in C++ using built-in type conversion, becuase these are incompatible types of different spaces. What you can do is write code which return one of two strings you want to represent bool with. Simplest case is use of ternary operator:

 std::string s = b ? "true" : "false"; 

or

std::string s; if (b) s = "true"; else s = "false"; 

These two generate similar code.

Later you'll find that C++ allows user-defined conversions and overloaded operators which allow other methods, rather transarent to work, e.g. this would allow to convert class Boolean into a std::string:

// this is a simplified example: class Boolean { bool b; public: Boolean (bool oth) : b(oth) {} // user-defined conversion opeartor std::string() { return b ? "true" : "false"; } }; 

after this a Boolean can be assigned to a std::string.

There are alot of library-provided tools for string generation including format output into a string stream.

This post is old but now you can use std::to_string to convert a lot of variable as std::string.

http://en.cppreference.com/w/cpp/string/basic_string/to_string

#include <iostream> #include <string> using namespace std; string toBool(bool boolean) { string result; if(boolean == true) result = "true"; else result = "false"; return result; } int main() { bool myBoolean = true; //Boolean string booleanValue; booleanValue = toBool(myBoolean); cout << "bool: " << booleanValue << "\n"; }