A conversão bool texto em C++

Question

Esta talvez seja uma pergunta idiota, mas existe alguma maneira de converter um valor booleano para uma seqüência de caracteres tais que 1 é para "true" e 0 transforma-se a "falsa"?Eu poderia simplesmente usar uma instrução if, mas seria bom saber se existe uma forma de fazer isso com o idioma ou bibliotecas padrão.Além do mais, eu sou um pedante.:)

Answer 1

Como sobre o uso da linguagem C++ em si?

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;

ATUALIZAÇÃO:

Se você quer mais do que 4 linhas de código sem qualquer console de saída, por favor, vá para cppreference.com's página falando sobre std::boolalpha e std::noboolalpha o que mostra a saída do console e explica mais sobre a API.

Além disso, usando std::boolalpha irá modificar o estado global de std::cout, você poderá restaurar o comportamento original vá aqui para mais informações sobre como restaurar o estado de std::cout.

Answer 2

Estamos falando de C++ certo?Por que na terra estamos ainda usando macros!?

C++ funções inline dar-lhe a mesma velocidade com que uma macro, com o benefício adicional de segurança de tipo e de parâmetros de avaliação (o que evita o problema de que Rodney e dwj mencionado.

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

Além de que tenho algumas outras queixas, especialmente com o aceite resposta :)

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

Felicidades :)

---

@DrPizza:Incluem um todo impulso lib para o bem de uma função simples?Você tem que estar brincando?

Answer 3

C++ possui a devida cadeias de caracteres, então você pode muito bem usá-los.Eles estão no padrão de cadeia de caracteres de cabeçalho.#include <string> para usá-los.Não mais strcat/strcpy saturações de buffer;não há mais falta de terminadores nulo;não mais confuso manual de gerenciamento de memória;adequada contados cadeias de caracteres com o próprio valor semântico.

C++ tem a capacidade de converter bools para legível representações também.Vimos sugere-lo mais cedo com o iostream exemplos, mas eles são um pouco limitadas, porque eles só podem explodir o texto para a consola (ou com fstreams, um arquivo).Felizmente, os desenvolvedores de C++ não eram completos idiotas;também temos iostreams que está feito não pelo console ou um arquivo, mas por uma gerenciados automaticamente buffer de seqüência de caracteres.Eles são chamados de stringstreams.#include <sstream> para obtê-los.Então, podemos dizer:

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

Claro, nós realmente não quero escrever tudo isso.Felizmente, C++ também possui uma excelente biblioteca de terceiros chamado Aumentar que pode nos ajudar aqui.Boost tem uma boa função chamada lexical_cast.Podemos usá-lo assim:

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

Agora, é verdadeiro dizer que este é o maior atraso de alguns macro;stringstreams lidar com as localidades que talvez você não se preocupa, e criar uma dinâmica de seqüência de caracteres (com alocação de memória) considerando que a macro pode produzir uma seqüência de caracteres literal, o que evita isso.Mas, por outro lado, o stringstream método pode ser utilizado para um grande número de conversões entre impressão e representações internas.Você pode executar em versões anteriores;boost::lexical_cast<bool>("true") faz a coisa certa, por exemplo.Você pode usá-los com números e na verdade qualquer tipo com o direito e/S formatada operadores.Então eles são bem versáteis e úteis.

E se depois de tudo isso o seu perfil e benchmarking revela que o lexical_casts são inaceitáveis para o gargalo, o que é quando você deve considerar fazer algumas macro horror.

Answer 4

Isso deve ser bem:

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

Mas, se você quiser fazer mais do que 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

Se você decidir usar macros (ou está usando C em um projeto de futuro), você deve adicionar parênteses à volta do 'b' na expansão de macro (eu não tenho pontos suficientes ainda para editar o conteúdo de outras pessoas):

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

Este é um programação defensivas técnica que protege contra a ordem oculta-de-operações de erros;por exemplo, como é que este avalie todos compiladores?

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

comparado com

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

Answer 6

Eu uso um ternário em um printf como este:

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

Se você macro :

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

em seguida, você precisará certificar-se que você passar como 'b' não tem quaisquer efeitos secundários.E não se esqueça de os colchetes ao redor do 'b' como você pode obter erros de compilação.

Answer 7

Com o C++11, você pode usar um lambda para obter um pouco mais compacto de código e, em 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);

Impressões:

string to print -> true

Answer 8

Este post é antigo mas agora que você pode usar std::to_string para converter um monte de variável como std::string.

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

Answer 9

Utilização boolalpha imprimir bool para a cadeia.

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

C++ Referência

Answer 10

Eu concordo que uma macro pode ser o melhor ajuste.Eu só chicoteado até um caso de teste (acredite, eu não sou boa com C/C++, mas parecia 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

Enquanto seqüências de caracteres podem ser visualizados diretamente como um array de char que vai ser muito difícil me convencer de que std::string representa cadeias de caracteres como cidadãos de primeira classe em C++.

Além disso, a combinação de alocação e boundedness parece ser uma má idéia para mim de qualquer maneira.

Answer 12

Tente esta Macro.Em qualquer lugar que você quer que o "verdadeiro" ou false para mostrar apenas substituí-lo com PRINTBOOL(var) onde var é o bool você deseja que o texto.

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