C doesn't memiliki built-in tipe boolean. Apa's cara terbaik untuk menggunakan mereka dalam C?
Dari yang terbaik hingga yang buruk:
Opsi 1 (C99)
#include <stdbool.h>
Pilihan 2
typedef enum { false, true } bool;
3
typedef int bool;
enum { false, true };
4
typedef int bool;
#define true 1
#define false 0
Jika anda ragu-ragu, pergi dengan #1!
Beberapa pemikiran tentang boolean dalam C:
I'm cukup tua, jadi saya hanya menggunakan plain int karena saya tipe boolean tanpa typedefs atau khusus mendefinisikan atau enums untuk true/false nilai-nilai. Jika anda mengikuti saran saya di bawah ini pada pernah membandingkan terhadap boolean konstanta, maka anda hanya perlu menggunakan 0/1 untuk menginisialisasi bendera pula. Namun, pendekatan seperti itu mungkin dianggap terlalu reaksioner di zaman modern. Dalam kasus itu, salah satu pasti harus menggunakan
<stdbool.h>` sejak itu setidaknya memiliki keuntungan yang standar.
Apapun boolean konstanta yang disebut, gunakanlah hanya untuk inisialisasi. Jangan pernah menulis sesuatu seperti
if (ready == TRUE) ...
while (empty == FALSE) ...
Ini selalu dapat diganti dengan yang lebih jelas
if (ready) ...
while (!empty) ...
Perhatikan bahwa ini dapat benar-benar wajar dan maklum akan membaca dengan suara keras.
Memberikan anda boolean variabel positif nama-nama, yaitu penuh
dan bukan notfull
. Yang terakhir mengarah ke kode yang sulit untuk dibaca dengan mudah. Bandingkan
if (full) ...
if (!full) ...
dengan
if (!notfull) ...
if (notfull) ...
Kedua mantan pasangan baca secara alami, sementara !notfull
canggung untuk membaca bahkan saat itu, dan menjadi jauh lebih buruk secara lebih kompleks ekspresi boolean.
Boolean argumen umumnya harus dihindari. Mempertimbangkan fungsi yang didefinisikan seperti ini
void foo(bool option) { ... }
Dalam tubuh fungsi, hal ini sangat jelas apa argumen berarti sejak itu telah nyaman, dan mudah-mudahan bermakna, nama. Tapi, panggilan situs yang terlihat seperti
foo(TRUE);
foo(FALSE):
Di sini, it's pada dasarnya tidak mungkin untuk mengatakan apa parameter berarti tanpa selalu melihat pada definisi fungsi atau deklarasi, dan itu akan jauh lebih buruk lagi jika anda menambahkan lebih banyak parameter boolean. Saya sarankan baik
typedef enum { OPT_ON, OPT_OFF } foo_option;
void foo(foo_option option);
atau
#define OPT_ON true
#define OPT_OFF false
void foo(bool option) { ... }
Dalam kedua kasus, sebut situs sekarang terlihat seperti
foo(OPT_ON);
foo(OPT_OFF);
yang pembaca memiliki setidaknya kesempatan untuk memahami tanpa pengerukan definisi foo
.
Berikut ini adalah versi yang saya gunakan:
typedef enum { false = 0, true = !false } bool;
Karena palsu hanya memiliki satu nilai, tetapi benar logis bisa memiliki banyak nilai-nilai, tetapi teknik set true untuk menjadi apa compiler akan digunakan untuk sebaliknya palsu.
Ini mengurus masalah seseorang coding sesuatu yang akan datang ke ini:
if (true == !false)
Saya pikir kita semua akan setuju bahwa itu bukan praktik yang baik, tapi untuk satu kali biaya untuk melakukan "benar = !palsu" kita menghilangkan masalah itu.
[EDIT] Pada akhirnya saya digunakan:
typedef enum { myfalse = 0, mytrue = !myfalse } mybool;
untuk menghindari tabrakan nama dengan skema lain yang mendefinisikan benar
dan salah
. Tapi konsep tetap sama.
[EDIT] Untuk menunjukkan konversi dari integer ke boolean:
mybool somebool;
int someint = 5;
somebool = !!someint;
Yang pertama (paling kanan) ! mengkonversi non-nol integer ke 0, kemudian yang kedua (paling kiri) ! mengkonversi 0 untuk myfalse
nilai. Aku akan meninggalkan itu sebagai latihan bagi pembaca untuk mengkonversi integer nol.
[Sunting / SUNTING sumber]
Itu adalah gaya saya untuk menggunakan eksplisit menetapkan nilai enum ketika nilai tertentu diperlukan bahkan jika nilai default akan sama. Contoh: Karena palsu harus nol saya menggunakan false = 0,
daripada false,
Jika anda menggunakan C99 compiler ini memiliki built-in dukungan untuk bool jenis:
#include <stdbool.h>
int main()
{
bool b = false;
b = true;
}
Hal pertama yang pertama. C, yaitu ISO/IEC 9899 memiliki tipe boolean untuk 19 tahun. Itu adalah cara lama dari diharapkan panjang pemrograman C karir dengan amatir/akademik/profesional bagian dikombinasikan ketika mengunjungi pertanyaan ini. Saya tidak melampaui bahwa dengan hanya mungkin 1-2 tahun. Itu berarti bahwa selama waktu yang rata-rata pembaca telah belajar apa-apa sama sekali tentang C, C benar-benar telah boolean tipe data.
Untuk datatype, #include <stdbool.h>
, dan menggunakan benar
, false
dan bool
. Atau tidak seperti itu, dan menggunakan _Bool
, 1
dan 0
sebagai gantinya.
Ada berbagai berbahaya saran dalam jawaban ini thread. Aku akan mengatasinya:
typedef int bool;
#define true 1
#define false 0
Ini adalah tidak-tidak, karena pembaca kasual - siapa yang tidak belajar C dalam 19 tahun - akan berharap bahwa bool
mengacu pada aktual bool
tipe data dan akan bersikap sama, tapi itu doesn't! Misalnya
double a = ...;
bool b = a;
Dengan C99 bool
/ _Bool
, b
akan diatur ke palsu
iff a
adalah nol, dan benar
jika tidak. Dengan typedef
di tempat, double
akan dipaksa untuk sebuah int
- jika nilai ganda isn't dalam rentang int
, yang perilaku tidak terdefinisi.
Secara alami hal yang sama berlaku untuk jika benar
dan salah
itu dinyatakan dalam sebuah enum
.
Apa yang bahkan lebih berbahaya menyatakan
typedef enum bool {
false, true
} bool;
karena sekarang semua nilai-nilai selain 1 dan 0 yang tidak valid, dan nilai tersebut akan ditugaskan untuk variabel dari jenis, perilaku akan sepenuhnya tidak terdefinisi.
Oleh karena itu iff anda tidak dapat menggunakan C99 untuk beberapa alasan yang tak bisa dijelaskan, untuk variabel boolean yang harus anda gunakan:
int
dan nilai 0
dan 1
as -; dan dengan hati-hati apakah domain konversi dari nilai-nilai lain ini dengan double negasi !!
BOOL
, BENAR
dan SALAH
!Hanya untuk melengkapi jawaban yang lain dan beberapa klarifikasi, jika anda diperbolehkan untuk menggunakan C99.
+-------+----------------+-------------------------+--------------------+
| Name | Characteristic | Dependence in stdbool.h | Value |
+-------+----------------+-------------------------+--------------------+
| _Bool | Native type | Don't need header | |
+-------+----------------+-------------------------+--------------------+
| bool | Macro | Yes | Translate to _Bool |
+-------+----------------+-------------------------+--------------------+
| true | Macro | Yes | Translate to 1 |
+-------+----------------+-------------------------+--------------------+
| false | Macro | Yes | Translate to 0 |
+-------+----------------+-------------------------+--------------------+
Beberapa preferensi saya:
_Bool
atau bool
? Keduanya baik-baik saja, tapi bool
terlihat lebih baik daripada kata kunci _Bool
.bool
dan _Bool
adalah: palsu
atau benar
. Menetapkan 0
atau 1
bukan palsu
atau benar
adalah valid, tetapi lebih sulit untuk membaca dan memahami logika aliran.Beberapa info dari standar:
_Bool
TIDAK unsigned int
, tapi ini bagian dari kelompok unsigned integer types. Hal ini cukup besar untuk menampung nilai-nilai 0
atau 1
.bool
benar
dan salah
tapi pasti bukan ide yang baik. Kemampuan ini dianggap usang dan akan dihapus di masa depan._Bool
atau bool
, jika scalar nilai ini sama dengan 0
atau membandingkan ke 0
maka akan 0
, jika tidak hasilnya adalah 1
: _Bool x = 9;
9
diubah menjadi 1
ketika ditugaskan untuk x
._Bool
adalah 1 byte (8 bit), biasanya programmer tergoda untuk mencoba untuk menggunakan bit lainnya, tapi tidak dianjurkan, karena satu-satunya jaminan yang diberikan adalah bahwa hanya satu bit yang digunakan untuk menyimpan data, tidak seperti jenis char
yang memiliki 8 bit yang tersedia.@Thomas Matthews: ekspresi Kondisional dianggap benar jika mereka adalah non-nol, tapi C standar mengharuskan operator logis diri kembali baik 0 atau 1.
@Tom: #define TRUE !PALSU adalah buruk dan benar-benar sia-sia. Jika file header membuat jalan ke disusun kode C++, maka dapat menyebabkan masalah:
void foo(bool flag);
...
int flag = TRUE;
foo(flag);
Beberapa compiler akan menghasilkan peringatan tentang int => bool konversi. Kadang-kadang orang-orang menghindari hal ini dengan melakukan:
foo(flag == TRUE);
untuk memaksa ekspresi menjadi C++ bool. Tapi jika anda #define TRUE !PALSU, anda berakhir dengan:
foo(flag == !0);
yang akhirnya melakukan int-untuk-bool perbandingan yang dapat memicu peringatan pula.
Anda dapat menggunakan char, atau yang lain kecil jumlah wadah untuk itu.
Pseudo-code
#define TRUE 1
#define FALSE 0
char bValue = TRUE;
Anda bisa menggunakan _Bool, tapi yang mengembalikan nilai harus berupa bilangan bulat (1 untuk true, 0 untuk false). Namun, Hal's dianjurkan untuk mencakup <stdbool.h> dan menggunakan bool seperti dalam C++, seperti dikatakan dalam jawaban ini dari daniweb forum, serta jawaban ini, ini lain stackoverflow pertanyaan:
_Bool: C99's tipe boolean. Menggunakan _Bool langsung hanya disarankan jika anda're mempertahankan warisan kode yang sudah mendefinisikan macro untuk bool, benar, atau salah. Jika tidak, mereka makro yang standar di <stdbool.h> header. Termasuk header dan anda dapat menggunakan bool sama seperti anda akan di C++.
Jika anda menggunakan c99 anda dapat menggunakan _Book jenis yang merupakan bagian dari c99 I. e ada #meliputi' yang diperlukan. Anda tidak perlu memperlakukannya seperti int meskipun, di mana 1 = true dan 0 = false. Anda kemudian dapat menentukan BENAR dan SALAH.
_Bool this_is_a_Boolean_var = 1;
//or using it with true and false
#define TRUE 1
#define FALSE 0
_Book var = TRUE;
Anda hanya dapat menggunakan #define petunjuk sebagai berikut:
#define TRUE 1
#define FALSE 0
#define NOT(arg) (arg == TRUE)? FALSE : TRUE
typedef int bool;
Dan penggunaan sebagai berikut:
bool isVisible = FALSE;
bool isWorking = TRUE;
isVisible = NOT(isVisible);
dan begitu..di