Dari yang terbaik hingga yang buruk:

Opsi 1 (C99)

#include 

Pilihan 2

typedef enum { false, true } bool;

3

typedef int bool;
enum { false, true };

4

typedef int bool;
#define true 1
#define false 0

Penjelasan

• Opsi 1 akan bekerja hanya jika anda menggunakan C99 dan's "standar" untuk melakukannya. Pilih ini jika mungkin.
• Pilihan 2, 3 dan 4 akan memiliki dalam prakteknya identik sama perilaku. #2 dan #3, don't menggunakan #mendefinisikan meskipun, yang menurut pendapat saya adalah lebih baik.

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.

Boolean dalam C adalah bilangan bulat: nol untuk salah dan non-nol untuk benar.

Lihat juga Boolean tipe data, bagian C, C++, Objective-C, AWK.

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 
int main()
{
  bool b = false;
  b = true;
}

http://en.wikipedia.org/wiki/Boolean_data_type

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:

• ketik int dan nilai 0 dan 1 as -; dan dengan hati-hati apakah domain konversi dari nilai-nilai lain ini dengan double negasi !!
• atau jika anda ngotot anda don't ingat bahwa 0 adalah falsy dan non-nol truish, setidaknya menggunakan huruf sehingga mereka don't mendapatkan bingung dengan C99 konsep: BOOL, BENAR dan SALAH!

C memiliki tipe boolean: bool (setidaknya untuk yang terakhir 10(!) tahun)

Termasuk stdbool.h dan benar/palsu akan bekerja seperti yang diharapkan.

Sesuatu nol dievaluasi ke true pada operasi boolean, sehingga anda hanya bisa

#define TRUE 1
#define FALSE 0

dan menggunakan konstanta.

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.
• Nilai-nilai yang diterima untuk 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.
• TIDAK, tapi ya, anda dapat mendefinisikan bool benar dan salah tapi pasti bukan ide yang baik. Kemampuan ini dianggap usang dan akan dihapus di masa depan.
• Menetapkan scalar type (aritmatika jenis dan tipe penunjuk) ke _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.

Itu adalah ini:

#define TRUE 1
#define FALSE 0

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