type - Convirtiendo bool a texto en C++

if bool c++

Question

Tal vez esta es una pregunta tonta, pero ¿hay alguna manera de convertir un valor booleano a una cadena de modo que 1 se convierte en "verdadero" y 0 se convierte en "falso"? Podría usar una declaración if, pero sería bueno saber si hay una forma de hacerlo con el lenguaje o las bibliotecas estándar. Además, soy un pedante. :)

Answer 1

¿Qué hay de usar el lenguaje C ++ en sí?

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;

Answer 2

C ++ tiene las cuerdas adecuadas, por lo que también podría usarlas. Están en la cadena de encabezado estándar. #include <cadena> para usarlos. No más desbordamientos de buffer strcat / strcpy; ya no faltan terminadores nulos; no más administración desordenada de la memoria manual; cadenas contadas apropiadas con semántica de valor apropiado.

C ++ también tiene la capacidad de convertir bools en representaciones legibles por humanos. Vimos sugerencias anteriores con los ejemplos de iostream, pero son un poco limitados porque solo pueden enviar el texto a la consola (o con fstreams, un archivo). Afortunadamente, los diseñadores de C ++ no fueron completos idiotas; también tenemos iostreams que están respaldados no por la consola o un archivo, sino por un buffer de cadena gestionado automáticamente. Se llaman cadenas de transmisión. #include <sstream> para obtenerlos. 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, realmente no queremos escribir todo eso. Afortunadamente, C ++ también tiene una conveniente biblioteca de terceros llamada Boost que puede ayudarnos aquí. Boost tiene una función agradable llamada lexical_cast. Podemos usarlo así:

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

Ahora bien, es cierto que esto es una sobrecarga más alta que algunas macro; las cadenas de caracteres se relacionan con las configuraciones regionales que no le interesan, y crean una cadena dinámica (con asignación de memoria) mientras que la macro puede producir una cadena literal, lo cual evita eso. Pero por otro lado, el método de cadena de caracteres se puede utilizar para una gran cantidad de conversiones entre representaciones imprimibles e internas. Puedes ejecutarlos hacia atrás; boost :: lexical_cast <bool> ("true") hace lo correcto, por ejemplo. Puede usarlos con números y de hecho cualquier tipo con los operadores de E / S formateados correctos. Entonces son bastante versátiles y útiles.

Y si después de todo esto, su perfilación y evaluación comparativa revela que los lexical_casts son un cuello de botella inaceptable, entonces es cuando debería considerar hacer algo de macrohorror.

Answer 3

Esta publicación es antigua pero ahora puedes usar std::to_string para convertir muchas variables como std::string .

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

Answer 4

Estamos hablando de C ++ ¿verdad? ¿Por qué demonios seguimos usando macros?

Las funciones en línea de C ++ le dan la misma velocidad que una macro, con el beneficio adicional de seguridad de tipo y evaluación de parámetros (que evita el problema mencionado por Rodney y dwj).

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

Aparte de eso, tengo algunas otras quejas, particularmente con la respuesta aceptada :)

// 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: ¿Incluye un lib completo de impulso por el simple hecho de una función así de simple? ¿Tienes que estar bromeando?

Answer 5

Esto debería 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 6

Estoy de acuerdo en que una macro puede ser la mejor opción. Acabo de preparar un caso de prueba (créanme que no soy bueno con C / C ++ pero esto sonó 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 7

Prueba esta Macro. En cualquier lugar donde desee que aparezca "verdadero" o falso simplemente reemplácelo por PRINTBOOL (var) donde var es el bool para el que desea el texto.

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

Answer 8

Si decide usar macros (o está usando C en un proyecto futuro) debe agregar paréntesis alrededor de la ''b'' en la expansión de la macro (todavía no tengo suficientes puntos para editar el contenido de otras personas):

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

Esta es una técnica de programación defensiva que protege contra errores ocultos de orden de operaciones; es decir, ¿cómo se evalúa esto para todos los compiladores?

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

comparado con

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

Answer 9

Siempre que las cadenas se puedan ver directamente como una matriz de caracteres, será muy difícil convencerme de que std::string representa las cadenas como ciudadanos de primera clase en C ++.

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

Answer 10

Usa boolalpha para imprimir bool en una cuerda.

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

Referencia de C ++

Answer 11

Utilizo un ternario en un printf como este:

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

Si lo macroes:

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

entonces necesitas asegurarte de que lo que pases ya que ''b'' no tenga ningún efecto secundario. Y no te olvides de los corchetes alrededor de la ''b'' ya que podrías obtener errores de compilación.