Mask izin berbasis integer mudah salah digunakan: pemeriksaan dapat memakai operator yang keliru, bit tak dikenal dapat lolos, dan perubahan nilai enum dapat mengubah arti data tersimpan. Bitset bertipe membatasi operasi pada kumpulan izin yang dikenal dan membuat maksud kode lebih jelas.

Pendekatan ini sejalan dengan gagasan menggunakan tipe khusus untuk membatasi operasi flag, seperti yang dibahas dalam konteks artikel tentang enum flags. Namun, tipe kuat hanya membantu mencegah kesalahan pemrograman. Server tetap harus memeriksa otorisasi pada setiap permintaan.

Rancang enum sebagai indeks bit yang stabil

std::bitset menyimpan kumpulan bit dengan ukuran tetap. Enum di bawah ini menyatakan posisi bit, bukan nilai mask. Nilainya ditulis eksplisit agar perubahan urutan deklarasi tidak mengubah pemetaan bit secara tidak sengaja.

#include <bitset>
#include <cstdint>
#include <optional>

class Permissions {
public:
    enum class Flag : std::size_t {
        Read = 0,
        Write = 1,
        Admin = 2
    };

    static constexpr std::size_t count = 3;

private:
    std::bitset<count> bits_;

    static constexpr std::uint32_t known_mask = (1u << count) - 1u;

    static bool valid_index(Flag flag) {
        return static_cast<std::size_t>(flag) < count;
    }

public:
    bool set(Flag flag) {
        if (!valid_index(flag)) return false;
        bits_.set(static_cast<std::size_t>(flag));
        return true;
    }

    bool clear(Flag flag) {
        if (!valid_index(flag)) return false;
        bits_.reset(static_cast<std::size_t>(flag));
        return true;
    }

    bool test(Flag flag) const {
        return valid_index(flag) && bits_.test(static_cast<std::size_t>(flag));
    }

    std::uint32_t to_raw() const {
        return static_cast<std::uint32_t>(bits_.to_ulong());
    }

    static std::optional<Permissions> from_raw(std::uint32_t raw) {
        if ((raw & ~known_mask) != 0) return std::nullopt;

        // Admin harus berdiri sendiri, bukan digabung dengan izin granular.
        constexpr std::uint32_t admin = 1u << static_cast<unsigned>(Flag::Admin);
        if ((raw & admin) != 0 && (raw & ~admin) != 0) return std::nullopt;

        Permissions result;
        for (std::size_t i = 0; i < count; ++i) {
            if ((raw & (1u << i)) != 0)
                result.bits_.set(i);
        }
        return result;
    }
};

Validasi input dan kombinasi izin

from_raw menjadi batas antara data eksternal—misalnya kolom DB, konfigurasi, atau pesan API—dan representasi internal. Pemeriksaan raw & ~known_mask menolak bit di luar enum yang diketahui. Tanpa pemeriksaan ini, nilai masa depan atau data rusak dapat diterima diam-diam sebagai izin.

Bit yang dikenal belum tentu membentuk kombinasi yang sah. Contoh menetapkan aturan bahwa Admin tidak boleh digabung dengan Read atau Write. Ganti aturan tersebut sesuai model izin aplikasi; jangan menganggap semua kombinasi bit otomatis valid. Jika aturan lebih kompleks, validasi dalam fungsi khusus tetap lebih jelas daripada menyebarkannya ke pemanggil.

Periksa hasil parsing sebelum menggunakan izin:

auto permissions = Permissions::from_raw(input_mask);
if (!permissions) {
    // Tolak input tidak dikenal atau kombinasi yang tidak valid.
    return;
}

if (permissions->test(Permissions::Flag::Write)) {
    // Lanjutkan hanya setelah pemeriksaan otorisasi pada server.
}

Operasi set, clear, dan test tanpa kesalahan bit

Gunakan operasi yang diberi nama, bukan manipulasi mask langsung. set dan clear memeriksa indeks enum sebelum mengakses bitset. Ini penting karena pemanggil masih dapat membuat nilai enum di luar anggota yang didefinisikan melalui konversi eksplisit.

Pemeriksaan seperti (mask & flag) == flag juga rawan jika flag bukan satu bit atau jika maksudnya adalah “setidaknya satu bit cocok”. Bitset menyediakan pemeriksaan satu flag yang eksplisit. Untuk pemeriksaan beberapa izin sekaligus, tentukan dengan jelas apakah semua izin atau salah satu izin harus terpenuhi.

Uji kasus batas

Uji parsing, perubahan status, nilai enum tidak valid, bit tak dikenal, dan kombinasi yang dilarang. Contoh berikut dapat dijalankan sebagai pemeriksaan kecil dengan assert:

#include <cassert>

int main() {
    using Flag = Permissions::Flag;

    Permissions p;
    assert(p.set(Flag::Read));
    assert(p.test(Flag::Read));
    assert(p.clear(Flag::Read));
    assert(!p.test(Flag::Read));

    assert(!p.set(static_cast<Flag>(99)));
    assert(!Permissions::from_raw(1u << 3)); // Bit tak dikenal.
    assert(!Permissions::from_raw(0b101));   // Admin + Read dilarang.
    assert(Permissions::from_raw(0b011));    // Read + Write valid.
    assert(Permissions::from_raw(0b100));    // Admin sendiri valid.
}

Pastikan nilai raw yang diserialisasi juga diuji round-trip jika format tersebut digunakan untuk penyimpanan atau komunikasi. Untuk protokol yang dapat berkembang, uji data versi lama dan perilaku saat menerima bit yang belum didukung.

Bitset bertipe atau integer mask?

  • Pilih bitset bertipe ketika jumlah flag tetap, kode C++ perlu operasi izin yang mudah dibaca, dan pemeriksaan indeks serta ukuran bit yang terbatas membantu mencegah bug.
  • Pilih integer mask biasa ketika format eksternal memang mensyaratkan mask integer, interoperabilitas menjadi prioritas, atau operasi bit mentah diperlukan. Tetap validasi bit dan kombinasi di batas input.

Bitset tidak otomatis menjamin keamanan. Ia tidak menentukan siapa yang berhak mengubah izin, tidak menggantikan pemeriksaan akses pada server, dan tidak memperbaiki data yang telah disimpan dengan arti bit berbeda.

Jaga kompatibilitas saat enum berubah

Jangan mengubah posisi bit yang sudah digunakan dalam data persisten atau protokol. Tambahkan flag baru pada posisi yang belum dipakai, dokumentasikan bit cadangan, dan gunakan versi format bila aturan atau arti izin berubah. Jangan menganggap penambahan flag aman bagi pembaca lama: pembaca yang menolak bit tak dikenal akan menolak data baru, sedangkan pembaca yang mengabaikannya dapat menyembunyikan ketidakcocokan.

Gunakan bitset bertipe sebagai lapisan pencegah kesalahan dalam kode C++; tetap lakukan validasi eksplisit pada input dan pemeriksaan otorisasi pada setiap operasi server.