Convertir un 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 une chaîne de caractères de sorte que 1 devienne "vrai" et 0 "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

Pourquoi ne pas 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;

UPDATE :

Si vous souhaitez obtenir plus de 4 lignes de code sans aucune sortie console, veuillez vous rendre à l'adresse suivante La page de cppreference.com parle de std::boolalpha y std::noboolalpha qui vous montre la sortie de la console et explique davantage l'API.

De plus, en utilisant std::boolalpha modifiera l'état global de std::cout vous voudrez peut-être rétablir le comportement original Pour plus d'informations sur le rétablissement de l'état d'urgence, cliquez ici. std::cout .

Answer 2

On parle de C++, non ? 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é de type 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 cela, j'ai quelques autres griefs, notamment en ce qui concerne 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;
}

Santé :)

---

@DrPizza : Inclure une librairie entière de boost pour une fonction aussi simple ? C'est une blague ?

Answer 3

Le C++ dispose de chaînes de caractères appropriées, alors autant les utiliser. Elles sont dans la chaîne d'en-tête standard. #include <string> pour les utiliser. Finis les dépassements de tampon de strcat/strcpy ; finis les terminaisons nulles manquantes ; finie la gestion manuelle désordonnée de la mémoire ; des chaînes comptées correctes avec une sémantique de valeur correcte.

Le C++ permet également de convertir les bools en représentations lisibles par l'homme. Nous en avons eu un aperçu plus tôt avec les exemples iostream, mais ils sont un peu limités car ils ne peuvent envoyer le texte que sur la console (ou avec fstreams, dans un fichier). Heureusement, les concepteurs du C++ n'étaient pas complètement idiots ; nous avons aussi des iostreams qui ne sont pas soutenus par la console ou un fichier, mais par un tampon de chaîne géré automatiquement. Ils sont appelés stringstreams. #include <sstream> pour les obtenir. Alors on peut 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 ça. Heureusement, le C++ dispose également d'une bibliothèque tierce pratique appelée Boost qui peuvent nous aider ici. Boost possède une belle fonction appelée lexical_cast. Nous pouvons l'utiliser ainsi :

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

Maintenant, il est vrai de dire qu'il s'agit d'une surcharge plus importante que certaines macros ; les flux de chaînes de caractères traitent des locales dont vous pouvez ne pas vous soucier, 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 les 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 avec n'importe quel type avec les bons opérateurs d'E/S 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 l'horreur macro.

Answer 4

Cela devrait aller :

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

Mais, si vous voulez le faire plus proche de 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 le C sur un projet futur), vous devez ajouter des parenthèses autour du 'b' dans l'expansion de la macro (je n'ai pas encore assez de points pour éditer le contenu d'autres personnes) :

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

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

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

par rapport à

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