Conversione di bool in testo in C++

Question

Forse questa è una domanda stupida, ma esiste un modo per convertire un valore booleano in una stringa tale che 1 diventi "vero" e 0 diventi "falso"?Potrei semplicemente usare un'istruzione if, ma sarebbe bello sapere se esiste un modo per farlo con il linguaggio o le librerie standard.In più sono un pedante.:)

Answer 1

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;

AGGIORNAMENTO:

Se desideri più di 4 righe di codice senza alcun output della console, vai a La pagina di cppreference.com parla di std::boolalpha E std::noboolalpha che mostra l'output della console e spiega ulteriori informazioni sull'API.

Inoltre utilizzando std::boolalpha modificherà lo stato globale di std::cout, potresti voler ripristinare il comportamento originale vai qui per maggiori informazioni sul ripristino dello stato di std::cout.

Answer 2

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

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

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

A parte questo ho qualche altra lamentela, 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:Includere un'intera libreria di boost per il bene di una funzione così semplice?Stai scherzando?

Answer 3

C++ ha stringhe adeguate, quindi potresti anche usarle.Sono nella stringa di intestazione standard.#include <string> per usarli.Niente più sovraccarichi del buffer strcat/strcpy;niente più terminatori nulli mancanti;niente più disordinata gestione manuale della memoria;stringhe contate correttamente con semantica dei valori corretta.

C++ ha anche la capacità di convertire i bool in rappresentazioni leggibili dall'uomo.Abbiamo visto dei suggerimenti in precedenza con gli esempi iostream, ma sono un po' limitati perché possono solo inviare il testo alla console (o con fstreams, un file).Fortunatamente, i progettisti del C++ non erano dei completi idioti;abbiamo anche iostream che non sono supportati dalla console o da un file, ma da un buffer di stringhe gestito automaticamente.Si chiamano stringstream.#include <sstream> per ottenerli.Allora 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();
}

Naturalmente, non vogliamo davvero scrivere tutto questo.Fortunatamente, C++ dispone anche di una comoda libreria di terze parti denominata Aumento che può aiutarci qui.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 sovraccarico maggiore rispetto ad alcune macro;stringstreams si occupa di impostazioni locali di cui potresti non preoccuparti e crea una stringa dinamica (con allocazione di memoria) mentre la macro può produrre una stringa letterale, il che lo evita.D'altro canto, il metodo stringstream può essere utilizzato per un gran numero di conversioni tra rappresentazioni stampabili e interne.Puoi eseguirli all'indietro;boost::lexical_cast<bool>("true") fa la cosa giusta, ad esempio.Puoi usarli con i numeri e di fatto con qualsiasi tipo con gli operatori I/O formattati correttamente.Quindi sono abbastanza versatili e utili.

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

Answer 4

Questo dovrebbe andare bene:

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

Ma se vuoi farlo più in stile C++:

#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 decidi di utilizzare le macro (o stai utilizzando C in un progetto futuro) dovresti aggiungere parentesi attorno alla "b" nell'espansione della macro (non ho ancora abbastanza punti per modificare il contenuto di altre persone):

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

Questo è un programmazione difensiva tecnica che protegge da errori nascosti nell'ordine delle operazioni;cioè, come valuta questo Tutto compilatori?

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

rispetto a

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

Answer 6

Uso un ternario in un printf come questo:

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

Se lo macro:

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

quindi devi assicurarti di qualunque cosa passi come 'b' non ha effetti collaterali.E non dimenticare le parentesi attorno a 'b' poiché potresti ottenere errori di compilazione.

Answer 7

Con C++11 potresti utilizzare un lambda per ottenere un codice leggermente più compatto e un utilizzo sul posto:

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

Stampe:

string to print -> true

Answer 8

Questo post è vecchio ma ora puoi usarlo std::to_string per convertire molte variabili come std::string.

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

Answer 9

Utilizzo boolalpha per stampare bool in stringa.

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

Riferimento C++

Answer 10

Sono d'accordo che una macro potrebbe essere la soluzione migliore.Ho appena preparato un caso di prova (credetemi, non sono bravo con C/C++ ma sembrava divertente):

#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

Finché le stringhe possono essere visualizzate direttamente come un array di caratteri, sarà davvero difficile convincermi di ciò std::string rappresenta le stringhe come cittadini di prima classe in C++.

Inoltre, combinare allocazione e limitatezza mi sembra comunque una cattiva idea.

Answer 12

Prova questa macro.Ovunque tu voglia che venga visualizzato "vero" o falso, sostituiscilo semplicemente con PRINTBOOL(var) dove var è il bool per il quale desideri il testo.

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