La conversión de bool de texto en C++

Question

Tal vez esta es una pregunta tonta, pero, ¿hay alguna manera de convertir un valor booleano para una cadena tal que 1 se convierte en "verdad" y 0 se convierte en "falso"?Yo sólo podría utilizar una sentencia if, pero sería bueno saber si hay una manera de hacer eso con la lengua o con las bibliotecas estándar.Además, soy un pedante.:)

Answer 1

Cómo sobre el uso del lenguaje C++ sí mismo?

bool t = true;
bool f = false;
std::cout << std::noboolalpha << t << " == " << std::boolalpha << t << std::endl;        
std::cout << std::noboolalpha << f << " == " << std::boolalpha << f << std::endl;

ACTUALIZACIÓN:

Si desea más de 4 líneas de código sin ningún tipo de salida de la consola, por favor vaya a cppreference.com's página de hablar acerca de std::boolalpha y std::noboolalpha la que se muestra la salida de la consola y explica más acerca de la API.

Además, el uso de std::boolalpha se modifica el estado global de std::cout, puede que desee restaurar el comportamiento original vaya aquí para obtener más información acerca de cómo restaurar el estado de std::cout.

Answer 2

Estamos hablando de C++ derecho?¿Por qué en la tierra estamos todavía con macros!?

C++ funciones en línea te dan la misma velocidad como una macro, con el beneficio añadido de seguridad de tipo y los parámetros de evaluación (que evita el problema de que Rodney y dwj mencionado.

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

Aparte de eso tengo un par de otras quejas, en particular con la aceptada respuesta :)

// 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;
}

Saludos :)

---

@DrPizza:Incluyen un conjunto de boost lib para el bien de una función de este simple?Tienes que estar bromeando?

Answer 3

C++ tiene cadenas apropiadas, así que podrías usarlos.Están en el estándar de la cadena de encabezado.#include <string> el uso de ellos.No más strcat/strcpy desbordamientos de búfer;no más falta terminadores nulos;no más desordenado manual de gestión de la memoria;adecuado cadenas contadas con el valor correcto de la semántica.

C++ tiene la capacidad de convertir bools en legible representaciones demasiado.Vimos indicios de antes con la de iostream ejemplos, pero son un poco limitadas, ya que solo la explosión del texto a la consola (o con fstreams, un archivo).Afortunadamente, los diseñadores de C++ no estaban completos idiotas;también tenemos iostreams que no están respaldados por la consola o en un archivo, pero por un gestionadas automáticamente búfer de cadena.Se llaman stringstreams.#include <sstream> para llegar a ellos.Entonces podemos decir:

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();
}

Por supuesto, no queremos realmente para escribir todo eso.Afortunadamente, C++ también dispone de una librería de terceros llamado Boost que puede ayudarnos a salir de aquí.Boost tiene una buena función llamada lexical_cast.Podemos utilizar de la siguiente manera:

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

Ahora, es cierto que decir que esta es la mayor sobrecarga de algunos macro;stringstreams lidiar con los locales, que podría no importarle, y crear una dinámica de cadena (con la asignación de memoria), mientras que la macro se puede producir una cadena literal, lo que evita que.Pero por el otro lado, el stringstream método puede ser utilizado para un gran número de conversiones entre imprimible y representaciones internas.Usted puede ejecutar 'em hacia atrás;boost::lexical_cast<bool>("true") hace lo correcto, por ejemplo.Usted las puede utilizar con números y en realidad cualquier tipo con la derecha con formato de e/S de los operadores.Así que son muy versátiles y útiles.

Y si después de todo esto, su perfil y la evaluación comparativa revela que el lexical_casts son inaceptables cuello de botella, que cuando usted debe considerar hacer algunos macro horror.

Answer 4

Este debe estar bien:

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

Pero, si quieres hacerlo más 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";
}

Answer 5

Si usted decide utilizar macros (o usa C en un proyecto de futuro) se debe añadir entre paréntesis alrededor de la 'b' en la expansión de macro (no tengo puntos suficientes sin embargo para editar el contenido de otras personas):

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

Este es un la defensiva de programación técnica que protege contra el orden oculto de las operaciones de errores;es decir, ¿cómo evaluar este para todos los compiladores?

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

en comparación con

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

Answer 6

Yo uso un ternario en un printf como este:

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

Si usted macro :

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

entonces usted necesita para asegurarse de que lo que sea que pase como 'b' no tiene efectos secundarios.Y no te olvides de los corchetes alrededor de la 'b' como usted puede obtener errores de compilación.

Answer 7

Con C++11 podría utilizar una expresión lambda para obtener un poco más compacto código y en el lugar de uso:

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);

Impresiones:

string to print -> true

Answer 8

Este post es viejo, pero ahora usted puede utilizar std::to_string para convertir una gran cantidad de variables como std::string.

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

Answer 9

Uso boolalpha para imprimir bool a la cadena.

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

Referencia De C++

Answer 10

Estoy de acuerdo en que una macro puede ser la mejor opción.Acabo de batida de un caso de prueba (yo creo que no soy buena con C/C++ pero esto sonaba divertido):

#include <stdio.h>
#include <stdarg.h>

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

int main (int argc, char const *argv[]) {
    bool alpha = true;
    printf( BOOL_STR(alpha) );
    return 0;
}

Answer 11

Mientras las cadenas se pueden ver directamente como una matriz de char va a ser muy difícil convencerme de que std::string representa cadenas como ciudadanos de primera clase en C++.

Además, la combinación de la asignación y el acotamiento parece ser una mala idea para mí de todos modos.

Answer 12

Pruebe esta Macro.En cualquier lugar que desee el "verdadero" o falso para mostrar simplemente reemplazarlo con PRINTBOOL(var) donde var es el bool desea que el texto.

#define PRINTBOOL(x) x?"true":"false"