inizializzare Conversione di bool in testo in C++




funzioni bool (9)

Forse questa è una domanda stupida, ma esiste un modo per convertire un valore booleano in una stringa tale che 1 diventa "true" e 0 diventa "false"? Potrei semplicemente usare un'istruzione if, ma sarebbe bello sapere se c'è un modo per farlo con la lingua o le librerie standard. Inoltre, sono un pedante. :)


Answer #1

Questo dovrebbe andare bene:


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

Ma, se vuoi farlo più 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 #2

Che ne dici di usare il linguaggio C ++ stesso?

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 #3

Usa boolalpha per stampare bool in stringa.

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

Riferimento C ++


Answer #4

Prova questa macro. Ovunque si desideri il "true" o il falso da mostrare, basta sostituirlo con PRINTBOOL (var) dove var è il bool per il quale si desidera il testo.

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

Answer #5

Io uso un ternario in un printf come questo:

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

Se lo fai macro:

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

quindi è necessario assicurarsi che tutto ciò che si passa come 'b' non ha effetti collaterali. E non dimenticare le parentesi intorno alla 'b' come potresti ottenere errori di compilazione.



Answer #7

Stiamo parlando di C ++, giusto? Perché mai stiamo usando le macro !?

Le funzioni inline di C ++ ti danno la stessa velocità di una macro, con l'ulteriore vantaggio della sicurezza del tipo e della valutazione dei parametri (che evita il problema che Rodney e dwj menzionavano.

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

A parte questo ho poche altre lamentele, in particolare con la risposta accettata :)

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

Saluti :)

@DrPizza: includi un'intera lib di boost per il gusto di una funzione così semplice? Stai scherzando?


Answer #8

Se decidi di usare macro (o stai usando C su un progetto futuro) dovresti aggiungere una parentesi attorno alla 'b' nell'espansione macro (non ho ancora abbastanza punti per modificare il contenuto di altre persone):

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

Questa è una tecnica di programmazione difensiva che protegge da errori di ordine delle operazioni nascosti; cioè, come valuta questo per tutti i compilatori?

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

rispetto a

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

Answer #9

Il C ++ ha stringhe appropriate quindi potresti anche usarle. Sono nella stringa di intestazione standard. #include <string> per usarli. Nessun sovraccarico di buffer strcat / strcpy; non più terminatori null mancanti; niente più disordinata gestione manuale della memoria; corde contate corrette con semantica del valore appropriato.

C ++ ha anche la capacità di convertire bool in rappresentazioni leggibili. Abbiamo visto alcuni suggerimenti in precedenza con gli esempi di iostream, ma sono un po 'limitati perché possono solo far saltare il testo alla console (o con fliche, un file). Fortunatamente, i progettisti di C ++ non erano idioti completi; abbiamo anche iostream che non sono supportati dalla console o da un file, ma da un buffer di stringa gestito automaticamente. Si chiamano stringhe. #include <sstream> per ottenerli. Quindi possiamo dire:

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

Certo, non vogliamo davvero scrivere tutto questo. Fortunatamente, C ++ ha anche una comoda libreria di terze parti chiamata Boost che può aiutarci. Boost ha una bella funzione chiamata lexical_cast. Possiamo usarlo così:

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

Ora, è vero che si tratta di un overhead superiore rispetto ad alcune macro; le stringhe trattano le impostazioni locali che potrebbero non interessare e creano una stringa dinamica (con allocazione di memoria) mentre la macro può produrre una stringa letterale, che evita questo. Ma il rovescio della medaglia, il metodo stringstream può essere utilizzato per moltissime conversioni tra rappresentazioni interne e stampabili. Puoi eseguirli all'indietro; boost :: lexical_cast <bool> ("true") fa la cosa giusta, per esempio. Puoi usarli con i numeri e di fatto con qualsiasi tipo di operatore I / O formattato. Quindi sono abbastanza versatili e utili.

E se dopo tutto questo la tua profilazione e benchmarking rivela che i termini lexical_casts sono un collo di bottiglia inaccettabile, è allora che dovresti considerare di fare qualche macro horror.





boolean