Konwersja bool na tekst w C++

Mówimy o C++ prawda? Dlaczego wciąż używamy makr!?

Funkcje wbudowane w C++ dają taką samą prędkość jak makro, z dodatkową korzyścią związaną z bezpieczeństwem typu i oceną parametrów (co pozwala uniknąć problemu, o którym wspomniał Rodney i dwj.

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

Poza tym mam jeszcze kilka innych narzekań, szczególnie z zaakceptowaną odpowiedzią:)

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

@DrPizza: Załącz cały boost lib dla funkcji tak prostej? Masz chyba żartujesz?

C++ ma odpowiednie ciągi, więc równie dobrze możesz ich używać. Są w standardowym nagłówku. # include to use them. Koniec z przekroczeniem bufora strcat/strcpy; koniec z brakowaniem Terminatorów null; koniec z bałaganiarskim ręcznym zarządzaniem pamięcią; odpowiednie zliczane ciągi znaków z odpowiednią semantyką wartości.

C++ ma również możliwość konwersji Booli na reprezentacje czytelne dla człowieka. Widzieliśmy podpowiedzi na to wcześniej z przykładami iostream, ale są one nieco ograniczone, ponieważ mogą tylko wybuch tekst do konsoli (lub z fstream, plik). Na szczęście, projektanci C++ nie byli kompletnymi idiotami; mamy również iostreams, które są wspierane nie przez konsolę lub plik, ale przez automatycznie zarządzany bufor łańcuchów. Nazywają się stringstreams. # include to get them. Wtedy możemy powiedzieć:

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

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

Teraz, prawdą jest, że jest to wyższe obciążenie niż niektóre makra; stringstreams zajmują się lokalizacjami, które mogą cię nie obchodzić i tworzą dynamiczny ciąg znaków (z alokacją pamięci), podczas gdy makro może dać dosłowny ciąg znaków, co pozwala tego uniknąć. Ale z drugiej strony, metoda stringstream może być używana do wielu konwersji między reprezentacjami drukowanymi i wewnętrznymi. Możesz je uruchomić do tyłu.; boost:: lexical_cast("true") robi to, co należy, na przykład. Można ich używać z numerami, a w rzeczywistości dowolnego typu z odpowiednimi sformatowanymi operatorami We/Wy. Są więc dość wszechstronne i użyteczne.

I jeśli po tym wszystkim twoje profilowanie i analiza porównawcza ujawnią, że lexical_casts są niedopuszczalnym wąskim gardłem, to jest, Kiedy powinieneś rozważyć zrobienie jakiegoś makro horroru.

To powinno być w porządku:

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

Ale, jeśli chcesz to zrobić bardziej C++-owskie:

#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";
}

Jeśli zdecydujesz się na użycie makr (lub używasz C w przyszłym projekcie), powinieneś dodać nawias wokół 'b' w rozszerzeniu makr (nie mam jeszcze wystarczająco dużo punktów, aby edytować zawartość innych osób):

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

Jest todefensywna technika programowania , która chroni przed ukrytymi błędami kolejności operacji; czyli jak to ocenia dlawszystkich kompilatorów?

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

W porównaniu do

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

Używam trójnika w printf jak ten:

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

If you makro it:

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

Potem musisz się upewnić, że cokolwiek podasz jako {[2] }nie ma żadnych skutków ubocznych. I nie zapomnij o nawiasach wokół 'b', ponieważ możesz uzyskać błędy kompilacji.

Ten post jest stary, ale teraz możesz użyć std::to_string, Aby przekonwertować wiele zmiennych jako std::string.

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

Użyj boolalpha Aby wydrukować bool na string.

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

C++ Reference

Zgadzam się, że najlepiej pasuje makro. Właśnie zrobiłem test (uwierz mi, nie jestem dobry w C / C++ , ale to zabrzmiało fajnie):

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

Dopóki ciągi mogą być postrzegane bezpośrednio jako tablica znaków, naprawdę trudno będzie mnie przekonać, że std::string reprezentuje ciągi jako obywatele pierwszej klasy w C++.

Poza tym, łączenie alokacji i ograniczeń wydaje mi się i tak złym pomysłem.

Spróbuj tego makra. Gdziekolwiek chcesz "true" lub false, aby pokazać się po prostu zastąp go PRINTBOOL (var), gdzie var jest bool, dla którego chcesz tekst.

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