Conversion de bool en texte en C++

Question

C'est peut-être une question stupide, mais existe-t-il un moyen de convertir une valeur booléenne en chaîne telle que 1 devienne « vrai » et 0 devienne « faux » ?Je pourrais simplement utiliser une instruction if, mais ce serait bien de savoir s'il existe un moyen de le faire avec le langage ou les bibliothèques standard.De plus, je suis un pédant.:)

Answer 1

Que diriez-vous d’utiliser le langage C++ lui-même ?

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;

MISE À JOUR:

Si vous souhaitez plus de 4 lignes de code sans aucune sortie console, veuillez vous rendre sur La page de cppreference.com parle de std::boolalpha et std::noboolalpha qui vous montre la sortie de la console et explique plus en détail l'API.

En utilisant en plus std::boolalpha modifiera l'état global de std::cout, vous souhaiterez peut-être restaurer le comportement d'origine allez ici pour plus d'informations sur la restauration de l'état de std::cout.

Answer 2

Nous parlons de C++, n'est-ce pas ?Pourquoi diable utilisons-nous encore des macros !?

Les fonctions en ligne C++ vous offrent la même vitesse qu'une macro, avec l'avantage supplémentaire de la sécurité des types et de l'évaluation des paramètres (ce qui évite le problème mentionné par Rodney et dwj.

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

A part ça, j'ai quelques autres reproches, notamment avec la réponse acceptée :)

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

Acclamations :)

---

@DrPizza :Inclure toute une bibliothèque de boost pour le bien d'une fonction aussi simple ?Tu plaisantes?

Answer 3

C++ a des chaînes appropriées, vous pouvez donc aussi bien les utiliser.Ils sont dans la chaîne d'en-tête standard.#include <string> pour les utiliser.Fini les dépassements de tampon strcat/strcpy ;plus de terminateurs nuls manquants ;plus de gestion manuelle compliquée de la mémoire ;chaînes comptées appropriées avec une sémantique de valeur appropriée.

C++ a également la capacité de convertir les booléens en représentations lisibles par l'homme.Nous en avons vu des indices plus tôt avec les exemples iostream, mais ils sont un peu limités car ils ne peuvent envoyer le texte que vers la console (ou avec fstreams, un fichier).Heureusement, les concepteurs du C++ n’étaient pas complètement idiots ;nous avons également des iostreams qui ne sont pas sauvegardés par la console ou un fichier, mais par un tampon de chaîne géré automatiquement.On les appelle des flux de chaînes.#include <sstream> pour les obtenir.On peut alors 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();
}

Bien sûr, nous n’avons pas vraiment envie de taper tout cela.Heureusement, C++ dispose également d'une bibliothèque tierce pratique nommée Booster cela peut nous aider ici.Boost a une fonction intéressante appelée lexical_cast.On peut l'utiliser ainsi :

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

Maintenant, il est vrai de dire que cela représente une surcharge plus élevée que celle de certaines macros ;Les flux de chaînes traitent des paramètres régionaux qui ne vous intéressent peut-être pas et créent une chaîne dynamique (avec allocation de mémoire) alors que la macro peut produire une chaîne littérale, ce qui évite cela.Mais d’un autre côté, la méthode stringstream peut être utilisée pour un grand nombre de conversions entre représentations imprimables et internes.Vous pouvez les exécuter à l'envers ;boost::lexical_cast<bool>("true") fait la bonne chose, par exemple.Vous pouvez les utiliser avec des nombres et en fait n'importe quel type avec les opérateurs d'E/S correctement formatés.Ils sont donc assez polyvalents et utiles.

Et si après tout cela votre profilage et votre analyse comparative révèlent que les lexical_casts constituent un goulot d'étranglement inacceptable, c'est quand vous devriez envisager de faire de la macro-horreur.

Answer 4

Cela devrait aller :

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

Mais, si vous voulez le faire plus en 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

Si vous décidez d'utiliser des macros (ou si vous utilisez C sur un futur projet), vous devez ajouter des parenthèses autour du « b » dans l'expansion de la macro (je n'ai pas encore assez de points pour modifier le contenu des autres) :

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

C'est un programmation défensive technique qui protège contre les erreurs cachées d’ordre des opérations ;c'est-à-dire, comment cela s'évalue-t-il pour tous des compilateurs ?

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

par rapport à

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

Answer 6

J'utilise un ternaire dans un printf comme ceci :

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

Si vous le macro :

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

alors vous devez vous assurer que tout ce que vous transmettez comme 'b' n'a aucun effet secondaire.Et n'oubliez pas les crochets autour du 'b' car vous pourriez obtenir des erreurs de compilation.

Answer 7

Avec C++11, vous pouvez utiliser un lambda pour obtenir un code légèrement plus compact et une utilisation sur place :

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

Impressions :

string to print -> true

Answer 8

Ce message est ancien mais vous pouvez maintenant l'utiliser std::to_string pour convertir beaucoup de variables comme std::string.

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

Answer 9

Utiliser boolalpha pour imprimer un bool en chaîne.

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

Référence C++

Answer 10

Je suis d'accord qu'une macro pourrait être la meilleure solution.Je viens de concocter un scénario de test (croyez-moi, je ne suis pas bon en C/C++ mais cela avait l'air amusant) :

#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

Tant que les chaînes peuvent être considérées directement comme un tableau de caractères, il sera très difficile de me convaincre que std::string représente les chaînes en tant que citoyens de première classe en C++.

De plus, combiner allocation et limitation me semble de toute façon être une mauvaise idée.

Answer 12

Essayez cette macro.Partout où vous voulez que le "vrai" ou le faux apparaisse, remplacez-le simplement par PRINTBOOL(var) où var est le booléen pour lequel vous voulez le texte.

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