Mengapa izin enum sering memiliki nilai 0, 1, 2, 4?

Mengapa orang selalu menggunakan nilai enum suka 0, 1, 2, 4, 8dan tidak 0, 1, 2, 3, 4?

Apakah ini ada hubungannya dengan operasi bit, dll?

Saya akan sangat menghargai cuplikan sampel kecil tentang bagaimana ini digunakan dengan benar :)

[Flags]
public enum Permissions
{
    None   = 0,
    Read   = 1,
    Write  = 2,
    Delete = 4
}

Karena mereka adalah kekuatan dua dan saya dapat melakukan ini:

var permissions = Permissions.Read | Permissions.Write;

Dan mungkin nanti ...

if( (permissions & Permissions.Write) == Permissions.Write )
{
    // we have write access
}

Ini adalah bidang bit, di mana setiap set bit sesuai dengan beberapa izin (atau apa pun nilai yang disebutkan secara logis sesuai dengan). Jika ini didefinisikan sebagai 1, 2, 3, ...Anda tidak akan dapat menggunakan operator bitwise dengan cara ini dan mendapatkan hasil yang bermakna. Untuk menggali lebih dalam ...

Permissions.Read   == 1 == 00000001
Permissions.Write  == 2 == 00000010
Permissions.Delete == 4 == 00000100

Perhatikan polanya di sini? Sekarang jika kita mengambil contoh asli saya, yaitu,

var permissions = Permissions.Read | Permissions.Write;

Kemudian...

permissions == 00000011

Lihat? Baik bit Readdan Writesudah diatur, dan saya bisa memeriksanya secara independen (Perhatikan juga bahwa Deletebit tidak diatur dan karena itu nilai ini tidak memberikan izin untuk menghapus).

Hal ini memungkinkan seseorang untuk menyimpan beberapa flag dalam satu bidang bit.

Jika masih tidak jelas dari jawaban lain, pikirkan seperti ini:

[Flags] 
public enum Permissions 
{   
   None = 0,   
   Read = 1,     
   Write = 2,   
   Delete = 4 
} 

hanyalah cara yang lebih singkat untuk menulis:

public enum Permissions 
{   
    DeleteNoWriteNoReadNo = 0,   // None
    DeleteNoWriteNoReadYes = 1,  // Read
    DeleteNoWriteYesReadNo = 2,  // Write
    DeleteNoWriteYesReadYes = 3, // Read + Write
    DeleteYesWriteNoReadNo = 4,   // Delete
    DeleteYesWriteNoReadYes = 5,  // Read + Delete
    DeleteYesWriteYesReadNo = 6,  // Write + Delete
    DeleteYesWriteYesReadYes = 7, // Read + Write + Delete
} 

Ada delapan kemungkinan tetapi Anda dapat mewakili mereka sebagai kombinasi dari hanya empat anggota. Jika ada enam belas kemungkinan maka Anda dapat mewakili mereka sebagai kombinasi dari hanya lima anggota. Jika ada empat miliar kemungkinan maka Anda dapat mewakili mereka sebagai kombinasi dari hanya 33 anggota! Jelas jauh lebih baik untuk memiliki hanya 33 anggota, masing-masing (kecuali nol) kekuatan dua, daripada mencoba menyebutkan empat miliar item dalam enum.

Karena nilai-nilai ini mewakili lokasi bit unik dalam biner:

1 == binary 00000001
2 == binary 00000010
4 == binary 00000100

dll

1 | 2 == binary 00000011

EDIT:

3 == binary 00000011

3 dalam biner diwakili oleh nilai 1 di kedua tempat dan dua tempat. Ini sebenarnya sama dengan nilainya 1 | 2. Jadi ketika Anda mencoba menggunakan tempat biner sebagai bendera untuk mewakili beberapa keadaan, 3 biasanya tidak bermakna (kecuali ada nilai logis yang sebenarnya adalah kombinasi keduanya)

Untuk klarifikasi lebih lanjut, Anda mungkin ingin memperluas contoh enum Anda sebagai berikut:

[Flags]
public Enum Permissions
{
  None = 0,   // Binary 0000000
  Read = 1,   // Binary 0000001
  Write = 2,  // Binary 0000010
  Delete = 4, // Binary 0000100
  All = 7,    // Binary 0000111
}

Oleh karena itu dalam saya punya Permissions.All, saya juga secara implisit memiliki Permissions.Read, Permissions.Write, danPermissions.Delete

[Flags]
public Enum Permissions
{
    None   =    0; //0000000
    Read   =    1; //0000001
    Write  = 1<<1; //0000010
    Delete = 1<<2; //0000100
    Blah1  = 1<<3; //0001000
    Blah2  = 1<<4; //0010000
}

Saya pikir menulis seperti ini lebih mudah dimengerti dan dibaca, dan Anda tidak perlu menghitungnya.

Ini digunakan untuk mewakili flag bit yang memungkinkan kombinasi nilai enum. Saya pikir ini lebih jelas jika Anda menulis nilai dalam notasi hex

[Flags]
public Enum Permissions
{
  None =  0x00,
  Read =  0x01,
  Write = 0x02,
  Delete= 0x04,
  Blah1 = 0x08,
  Blah2 = 0x10
}

Ini benar-benar lebih dari sebuah komentar, tetapi karena itu tidak akan mendukung pemformatan, saya hanya ingin memasukkan metode yang telah saya gunakan untuk menyiapkan enumerasi bendera:

[Flags]
public enum FlagTest
{
    None = 0,
    Read = 1,
    Write = Read * 2,
    Delete = Write * 2,
    ReadWrite = Read|Write
}

Saya menemukan pendekatan ini sangat membantu selama pengembangan dalam kasus di mana Anda ingin menjaga bendera Anda dalam urutan abjad. Jika Anda menentukan Anda perlu menambahkan nilai bendera baru, Anda bisa memasukkannya secara abjad dan satu-satunya nilai yang harus Anda ubah adalah yang sekarang mendahului.

Namun, perlu diketahui bahwa begitu suatu solusi diterbitkan untuk sistem produksi apa pun (terutama jika enum terbuka tanpa sambungan ketat, seperti melalui layanan web), maka sangat disarankan untuk tidak mengubah nilai apa pun yang ada dalam enum.

Banyak jawaban yang bagus untuk yang satu ini ... Saya hanya akan mengatakan .. jika Anda tidak suka, atau tidak dapat dengan mudah memahami apa yang <<sintaks coba katakan .. Saya pribadi lebih suka alternatif (dan berani saya katakan, gaya deklarasi enum langsung ) ...

typedef NS_OPTIONS(NSUInteger, Align) {
    AlignLeft         = 00000001,
    AlignRight        = 00000010,
    AlignTop          = 00000100,
    AlignBottom       = 00001000,
    AlignTopLeft      = 00000101,
    AlignTopRight     = 00000110,
    AlignBottomLeft   = 00001001,
    AlignBottomRight  = 00001010
};

NSLog(@"%ld == %ld", AlignLeft | AlignBottom, AlignBottomLeft);

LOG 513 == 513

Jauh lebih mudah (setidaknya bagi saya sendiri) untuk memahaminya. Sejajarkan yang ... jelaskan hasil yang Anda inginkan, dapatkan hasil yang Anda INGIN .. Tidak perlu "perhitungan".