Mengapa operator TIDAK logis dalam bahasa C-style "!" Dan bukan "~~"?

Untuk operator biner, kami memiliki operator bitwise dan logical:

& bitwise AND
| bitwise OR

&& logical AND
|| logical OR

BUKAN (operator unary) berperilaku berbeda. Ada ~ untuk bitwise dan! untuk logika.

Saya mengenali NOT adalah operasi yang tidak disadari sebagai lawan dari AND dan ATAU tetapi saya tidak dapat memikirkan alasan mengapa para perancang memilih untuk menyimpang dari prinsip bahwa single bitwise dan double logis di sini, dan sebagai gantinya memilih karakter yang berbeda. Saya kira Anda bisa membacanya salah, seperti operasi bitwise ganda yang akan selalu mengembalikan nilai operan. Tapi itu sepertinya bukan masalah bagi saya.

Apakah ada alasan saya hilang?

Anehnya, sejarah bahasa pemrograman C-style tidak dimulai dengan C.

Dennis Ritchie menjelaskan dengan baik tantangan kelahiran C dalam artikel ini .

Ketika membacanya, menjadi jelas bahwa C mewarisi bagian dari desain bahasanya dari BCPL pendahulunya , dan terutama operator. Bagian “Neonatal C” dari artikel tersebut menjelaskan bagaimana BCPL &dan |diperkaya dengan dua operator baru &&dan ||. Alasannya adalah:

• prioritas berbeda diperlukan karena penggunaannya dalam kombinasi dengan ==
• evaluasi yang berbeda logika: kiri ke kanan evaluasi dengan hubungan arus pendek (yaitu ketika aadalah falsedi a&&b, btidak dievaluasi).

Menariknya, penggandaan ini tidak menciptakan ambiguitas bagi pembaca: a && btidak akan disalahartikan sebagai a(&(&b)). Dari sudut pandang parsing, tidak ada ambiguitas baik: &bbisa masuk akal jika bmerupakan nilai, tetapi itu akan menjadi pointer sedangkan bitwise &akan membutuhkan operan integer, sehingga logika DAN akan menjadi satu-satunya pilihan yang masuk akal.

BCPL sudah digunakan ~untuk negasi bitwise. Jadi dari sudut pandang konsistensi, bisa digandakan untuk memberikan ~~arti logis. Sayangnya ini akan menjadi sangat ambigu karena ~merupakan operator unary: ~~bbisa juga berarti ~(~b)). Inilah sebabnya mengapa simbol lain harus dipilih untuk negasi yang hilang.

Saya tidak dapat memikirkan alasan mengapa para desainer memilih untuk menyimpang dari prinsip bahwa tunggal itu bitwise dan double adalah logis di sini,

Itu bukan prinsip di tempat pertama; begitu Anda menyadarinya, itu lebih masuk akal.

Cara yang lebih baik untuk memikirkan &vs &&bukan biner dan Boolean . Cara yang lebih baik adalah menganggap mereka bersemangat dan malas . The &Operator mengeksekusi sisi kiri dan kanan dan kemudian menghitung hasilnya. The &&Operator mengeksekusi sisi kiri, dan kemudian mengeksekusi sisi kanan hanya jika diperlukan untuk menghitung hasilnya.

Selain itu, alih-alih berpikir tentang "biner" dan "Boolean", pikirkan tentang apa yang sebenarnya terjadi. Versi "biner" hanya melakukan operasi Boolean pada array Boolean yang telah dikemas menjadi sebuah kata .

Jadi mari kita kumpulkan. Apakah masuk akal untuk melakukan operasi malas pada array Boolean ? Tidak, karena tidak ada "sisi kiri" untuk diperiksa terlebih dahulu. Ada 32 "sisi kiri" untuk diperiksa terlebih dahulu. Jadi kami membatasi operasi malas ke satu Boolean, dan dari situlah intuisi Anda bahwa salah satunya adalah "biner" dan satu adalah "Boolean" berasal, tetapi itu adalah konsekuensi dari desain, bukan desain itu sendiri!

Dan ketika Anda memikirkannya seperti itu, menjadi jelas mengapa tidak ada !!dan tidak ^^. Tak satu pun dari operator tersebut memiliki properti yang dapat Anda lewati saat menganalisis salah satu operan; tidak ada "malas" notatau xor.

Bahasa lain membuatnya lebih jelas; beberapa bahasa digunakan anduntuk berarti "bersemangat dan" tetapi and alsoberarti "malas dan", misalnya. Dan bahasa lain juga membuatnya lebih jelas &dan &&bukan "biner" dan "Boolean"; misalnya dalam C #, kedua versi dapat menggunakan Boolean sebagai operan.

TL; DR

C mewarisi !dan ~operator dari bahasa lain. Keduanya &&dan ||ditambahkan bertahun-tahun kemudian oleh orang yang berbeda.

Jawaban panjang

Secara historis, C dikembangkan dari bahasa awal B, yang didasarkan pada BCPL, yang didasarkan pada CPL, yang didasarkan pada Algol.

Algol , kakek buyut C ++, Java dan C #, mendefinisikan benar dan salah dengan cara yang terasa intuitif bagi para programmer: "nilai kebenaran yang, dianggap sebagai angka biner (benar sesuai dengan 1 dan salah ke 0), adalah sama dengan nilai integral intrinsik ”. Namun, satu kelemahan dari ini adalah bahwa logis dan bitwise tidak tidak bisa menjadi operasi yang sama: Pada komputer modern apa pun, ~0sama dengan -1 daripada 1 dan ~1sama dengan -2 daripada 0. (Bahkan pada beberapa mainframe berusia enam puluh tahun di mana ~0mewakili - 0 atau INT_MIN, ~0 != 1pada setiap CPU yang pernah dibuat, dan standar bahasa C telah mengharuskannya selama bertahun-tahun, sementara sebagian besar bahasa putrinya bahkan tidak repot-repot mendukung tanda-dan-besarnya atau komplemen seseorang sama sekali.)

Algol mengatasi ini dengan memiliki mode berbeda dan menafsirkan operator berbeda dalam mode boolean dan integral. Yaitu, operasi bitwise adalah pada tipe integer, dan operasi logis adalah pada tipe boolean.

BCPL memiliki tipe boolean yang terpisah, tetapi satu notoperator , untuk bitwise dan logical tidak. Cara cikal bakal awal C ini bekerja adalah:

Nilai dari true adalah pola bit yang seluruhnya terdiri dari yang; nilai salah adalah nol.

Catat itu true = ~ false

(Anda akan mengamati bahwa istilah nilai p telah berkembang berarti sesuatu yang sama sekali berbeda dalam bahasa C-keluarga. Kami akan hari ini panggilan itu “objek representasi” di C.)

Definisi ini akan memungkinkan logis dan bitwise untuk tidak menggunakan instruksi bahasa mesin yang sama. Jika C telah menempuh rute itu, file header di seluruh dunia akan mengatakan #define TRUE -1.

Tetapi bahasa pemrograman B diketik dengan lemah, dan tidak memiliki tipe boolean atau bahkan floating-point. Semuanya setara intdengan penggantinya, C. Ini membuatnya menjadi ide yang baik bagi bahasa untuk mendefinisikan apa yang terjadi ketika suatu program menggunakan nilai selain benar atau salah sebagai nilai logis. Pertama-tama didefinisikan ekspresi yang benar sebagai "tidak sama dengan nol." Ini efisien pada minicomputer tempat ia berlari, yang memiliki flag nol CPU.

Ada, pada saat itu, sebuah alternatif: CPU yang sama juga memiliki flag negatif, dan nilai kebenaran BCPL adalah -1, jadi B mungkin telah mendefinisikan semua angka negatif sebagai benar dan semua angka non-negatif sebagai kepalsuan. (Ada satu sisa dari pendekatan ini: UNIX, yang dikembangkan oleh orang yang sama pada saat yang sama, mendefinisikan semua kode kesalahan sebagai bilangan bulat negatif. Banyak panggilan sistemnya mengembalikan salah satu dari beberapa nilai negatif kegagalan yang berbeda.) Jadi bersyukurlah: bisa lebih buruk!

Tetapi mendefinisikan TRUEsebagai 1dan FALSEseperti 0dalam B berarti bahwa identitas true = ~ falsetidak lagi dipegang, dan itu telah menghilangkan ketikan yang kuat yang memungkinkan Algol untuk ambigu antara ekspresi bitwise dan logis. Untuk itu diperlukan operator logis-bukan yang baru, dan desainer memilih !, mungkin karena sudah tidak sama dengan yang sudah !=, yang terlihat seperti bar vertikal melalui tanda sama. Mereka tidak mengikuti konvensi yang sama dengan &&atau ||karena belum ada satu pun.

Boleh dibilang, mereka harus memiliki: &operator di B rusak seperti yang dirancang. Di B dan di C, 1 & 2 == FALSEmeskipun 1dan 2keduanya adalah nilai-nilai yang benar, dan tidak ada cara intuitif untuk mengekspresikan operasi logis dalam B. Itu adalah satu kesalahan C mencoba untuk memperbaiki sebagian dengan menambahkan &&dan ||, tetapi perhatian utama pada saat itu adalah untuk akhirnya mendapatkan hubungan arus pendek, dan membuat program berjalan lebih cepat. Buktinya adalah bahwa tidak ada ^^: 1 ^ 2adalah nilai yang benar meskipun kedua operannya benar, tetapi tidak dapat mengambil manfaat dari hubungan arus pendek.