Membandingkan sedikit ke boolean

Katakanlah saya memiliki satu set bendera, yang dikodekan dalam uint16_t flags. Sebagai contoh AMAZING_FLAG = 0x02,. Sekarang, saya punya fungsi. Fungsi ini perlu memeriksa apakah saya ingin mengubah bendera, karena jika saya ingin melakukan itu, saya perlu menulis ke flash. Dan itu mahal. Oleh karena itu, saya ingin cek yang memberi tahu saya apakah flags & AMAZING_FLAGsama dengan doSet. Ini adalah ide pertama:

setAmazingFlag(bool doSet)
{
    if ((flags & AMAZING_FLAG) != (doSet ? AMAZING_FLAG : 0)) {
        // Really expensive thing
        // Update flags
    }
}

Ini bukan pernyataan intuitif jika. Saya merasa harus ada cara yang lebih baik, seperti:

if ((flags & AMAZING_FLAG) != doSet){

}

Tapi ini tidak benar-benar berfungsi, truetampaknya sama dengan 0x01.

Jadi, apakah ada cara yang rapi untuk membandingkan sedikit dengan boolean?

Untuk mengonversi angka yang bukan nol menjadi 1 (benar), ada trik lama: terapkan !operator (bukan) dua kali.

if (!!(flags & AMAZING_FLAG) != doSet){

Anda perlu mengonversi bit mask ke pernyataan boolean, yang dalam C sama dengan nilai 0atau 1.

• (flags & AMAZING_FLAG) != 0. Cara paling umum.

• !!(flags & AMAZING_FLAG). Agak umum, juga OK untuk digunakan, tetapi agak samar.

• (bool)(flags & AMAZING_FLAG). Cara C modern dari C99 dan seterusnya.

Ambil salah satu dari alternatif di atas, lalu bandingkan dengan boolean Anda menggunakan !=atau ==.

Dari sudut pandang logis, flags & AMAZING_FLAGhanya sedikit operasi yang menutupi semua flag lainnya. Hasilnya adalah nilai numerik.

Untuk menerima ke nilai boolean, Anda akan menggunakan perbandingan

(flags & AMAZING_FLAG) == AMAZING_FLAG

dan sekarang dapat membandingkan nilai logis ini dengan doSet.

if (((flags & AMAZING_FLAG) == AMAZING_FLAG) != doSet)

Dalam C mungkin ada singkatan, karena aturan konversi angka ke nilai boolean. Jadi Anda juga bisa menulis

if (!(flags & AMAZING_FLAG) == doSet)

untuk menulis yang lebih singkat. Tetapi versi sebelumnya lebih baik dalam hal keterbacaan.

Anda dapat membuat topeng berdasarkan doSetnilai:

#define AMAZING_FLAG_IDX 1
#define AMAZING_FLAG (1u << AMAZING_FLAG_IDX)
...

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Sekarang cek Anda dapat terlihat seperti ini:

setAmazingFlag(bool doSet)
{
    const uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

    if (flags & set_mask) {
        // Really expensive thing
        // Update flags
    }
}

Pada beberapa arsitektur, !!dapat dikompilasi ke cabang dan dengan ini, Anda mungkin memiliki dua cabang:

1. Normalisasi oleh !!(expr)
2. Dibandingkan dengan doSet

Keuntungan dari proposal saya adalah cabang tunggal yang dijamin.

Catatan: pastikan Anda tidak memperkenalkan perilaku tidak terdefinisi dengan menggeser ke kiri lebih dari 30 (dengan asumsi integer adalah 32 bit). Ini dapat dengan mudah dicapai oleh astatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Ada beberapa cara untuk melakukan tes ini:

Operator ternary mungkin menghasilkan lompatan mahal:

if ((flags & AMAZING_FLAG) != (doSet ? AMAZING_FLAG : 0))

Anda juga dapat menggunakan konversi boolean, yang mungkin efisien atau tidak:

if (!!(flags & AMAZING_FLAG) != doSet)

Atau alternatifnya yang setara:

if (((flags & AMAZING_FLAG) != 0) != doSet)

Jika multiplikasi murah, Anda dapat menghindari lompatan dengan:

if ((flags & AMAZING_FLAG) != doSet * AMAZING_FLAG)

Jika flagstidak ditandatangani dan kompilernya sangat pintar, divisi di bawah ini dapat dikompilasi ke perubahan sederhana:

if ((flags & AMAZING_FLAG) / AMAZING_FLAG != doSet)

Jika arsitektur menggunakan aritmatika komplemen dua, berikut adalah alternatif lain:

if ((flags & AMAZING_FLAG) != (-doSet & AMAZING_FLAG))

Bergantian, orang bisa mendefinisikan flags sebagai struktur dengan bitfields dan menggunakan sintaks yang lebih mudah dibaca:

if (flags.amazing_flag != doSet)

Sayangnya, pendekatan ini biasanya disukai karena spesifikasi bitfield tidak memungkinkan kontrol yang tepat atas implementasi bit-level.