Mengonversi bool menjadi teks di C ++

Mungkin ini pertanyaan bodoh, tetapi adakah cara untuk mengubah nilai boolean menjadi string sehingga 1 berubah menjadi "benar" dan 0 berubah menjadi "salah"? Saya bisa saja menggunakan pernyataan if, tetapi alangkah baiknya mengetahui apakah ada cara untuk melakukannya dengan bahasa atau pustaka standar. Plus, saya seorang pedant. :)

Bagaimana kalau menggunakan bahasa C ++ itu sendiri?

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;

MEMPERBARUI:

Jika Anda menginginkan lebih dari 4 baris kode tanpa keluaran konsol, buka halaman cppreference.com yang membahas tentang std::boolalphadanstd::noboolalpha yang menunjukkan keluaran konsol dan menjelaskan lebih lanjut tentang API.

Selain itu, penggunaan std::boolalphaakan mengubah status global std::cout, Anda mungkin ingin memulihkan perilaku asli, buka di sini untuk info selengkapnya tentang memulihkan statusstd::cout .

Kita sedang membicarakan C ++ kan? Kenapa kita masih menggunakan makro !?

Fungsi inline C ++ memberi Anda kecepatan yang sama dengan makro, dengan manfaat tambahan dari keamanan tipe dan evaluasi parameter (yang menghindari masalah yang disebutkan Rodney dan dwj.

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

Selain itu, saya memiliki beberapa keluhan lain, terutama dengan jawaban yang diterima :)

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

Bersulang :)

@DrPizza: Sertakan lib dorongan penuh demi fungsi sederhana ini? Kamu pasti bercanda?

C ++ memiliki string yang tepat sehingga Anda sebaiknya menggunakannya. Mereka ada di string header standar. #include <string> untuk menggunakannya. Tidak ada lagi strcat / strcpy buffer overruns; tidak ada lagi terminator nol yang hilang; tidak ada lagi manajemen memori manual yang berantakan; string yang dihitung dengan benar dengan semantik nilai yang tepat.

C ++ memiliki kemampuan untuk mengubah bools menjadi representasi yang dapat dibaca manusia juga. Kami melihat petunjuk sebelumnya dengan contoh iostream, tetapi mereka agak terbatas karena mereka hanya dapat meledakkan teks ke konsol (atau dengan fstreams, file). Untungnya, para perancang C ++ tidak sepenuhnya idiot; kami juga memiliki iostreams yang tidak didukung oleh konsol atau file, tetapi oleh buffer string yang dikelola secara otomatis. Mereka disebut aliran string. #include <sstream> untuk mendapatkannya. Kemudian kita bisa mengatakan:

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

Tentu saja, kami tidak ingin mengetik semua itu. Untungnya, C ++ juga memiliki pustaka pihak ketiga yang nyaman bernama Boost yang dapat membantu kami di sini. Boost memiliki fungsi bagus yang disebut lexical_cast. Kita bisa menggunakannya sebagai berikut:

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

Sekarang, benar untuk mengatakan bahwa ini adalah overhead yang lebih tinggi daripada beberapa makro; stringstream menangani lokal yang mungkin tidak Anda pedulikan, dan membuat string dinamis (dengan alokasi memori) sedangkan makro dapat menghasilkan string literal, yang menghindarinya. Tapi di sisi lain, metode stringstream dapat digunakan untuk banyak konversi antara representasi yang dapat dicetak dan internal. Anda bisa menjalankannya mundur; boost :: lexical_cast <bool> ("true") melakukan hal yang benar, misalnya. Anda dapat menggunakannya dengan angka dan bahkan tipe apa pun dengan operator I / O yang diformat dengan benar. Jadi mereka cukup serbaguna dan berguna.

Dan jika setelah semua ini profiling dan benchmarking mengungkapkan bahwa lexical_casts adalah bottleneck tidak dapat diterima, itulah saat Anda harus mempertimbangkan melakukan beberapa horor makro.

Ini seharusnya baik-baik saja:

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

Tetapi, jika Anda ingin melakukannya lebih banyak 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";
}

Jika Anda memutuskan untuk menggunakan makro (atau menggunakan C pada proyek mendatang) Anda harus menambahkan tanda kurung di sekitar 'b' dalam perluasan makro (Saya belum memiliki cukup poin untuk mengedit konten orang lain):

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

Ini adalah teknik pemrograman defensif yang melindungi dari kesalahan urutan operasi yang tersembunyi; yaitu, bagaimana evaluasi ini untuk semua kompiler?

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

dibandingkan dengan

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

Saya menggunakan terner di printf seperti ini:

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

Jika Anda membuatnya menjadi makro:

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

maka Anda perlu memastikan apa pun yang Anda berikan 'b'tidak memiliki efek samping. Dan jangan lupa tanda kurung di sekitar 'b'karena Anda bisa mendapatkan kesalahan kompilasi.

Dengan C ++ 11 Anda mungkin menggunakan lambda untuk mendapatkan kode yang lebih ringkas dan sebagai tempat penggunaan:

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

Cetakan:

string to print -> true

Posting ini sudah tua tetapi sekarang Anda dapat menggunakan std::to_stringuntuk mengonversi banyak variabel sebagai std::string.

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

Tanpa menyeret ostream ke dalamnya:

constexpr char const* to_c_str(bool b) {
   return  
    std::array<char const*, 2>{"false", "true "}[b]
   ;
};

Gunakan boolalphauntuk mencetak bool ke string.

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

Referensi C ++

Bagaimana dengan yang sederhana:

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

C ++ 20 std::format("{}"

https://en.cppreference.com/w/cpp/utility/format/formatter#Standard_format_specification mengklaim bahwa format keluaran default adalah string secara default:

auto s6 = std::format("{:6}", true);  // value of s6 is "true  "

dan:

Jenis presentasi bool yang tersedia adalah:

• none, s: Menyalin representasi tekstual (benar atau salah, atau bentuk khusus lokal) ke keluaran.
• b, B, c, d, o, x, X: Menggunakan tipe presentasi integer dengan nilai static_cast (nilai).

Terkait: std :: pemformatan string seperti sprintf

Saya setuju bahwa makro mungkin yang paling cocok. Saya baru saja membuat test case (percayalah, saya tidak mahir dengan C / C ++ tapi ini terdengar menyenangkan):

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

Selama string dapat dilihat secara langsung sebagai array karakter, akan sangat sulit untuk meyakinkan saya yang std::stringmewakili string sebagai warga kelas pertama di C ++.

Selain itu, menggabungkan alokasi dan batasan tampaknya merupakan ide yang buruk bagi saya.

Coba Makro ini. Di mana pun Anda ingin menampilkan "benar" atau salah, ganti saja dengan PRINTBOOL (var) di mana var adalah bool yang Anda inginkan untuk teks tersebut.

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