Numaralandırma izinleri neden genellikle 0, 1, 2, 4 değerlerine sahiptir?

İnsanlar neden daima enum değerlerini kullanıyor 0, 1, 2, 4, 8ve kullanmıyor 0, 1, 2, 3, 4?

Bunun bit işlemleri vb. İle bir ilgisi var mı?

Bunun nasıl doğru kullanıldığı konusunda küçük bir örnek snippet'i gerçekten takdir ediyorum :)

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

Çünkü onlar ikisinin gücüdür ve bunu yapabilirim:

var permissions = Permissions.Read | Permissions.Write;

Ve belki sonra ...

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

Her bitin bazı izinlere (veya numaralandırılmış değerin mantıksal olarak karşılık geldiği her neyse) karşılık geldiği bir bit alanıdır. Bunlar olarak tanımlanmış 1, 2, 3, ...olsaydınız, bu şekilde bitsel operatörleri kullanamaz ve anlamlı sonuçlar elde edemezdiniz. Daha derine inmek için ...

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

Burada bir model fark ettiniz mi? Şimdi orijinal örneğimi alırsak, yani,

var permissions = Permissions.Read | Permissions.Write;

Sonra...

permissions == 00000011

Görmek? Hem Readve Writebit'lerinin ve bunu bağımsız kontrol edebilirsiniz (yani Ayrıca haber Deletebit edilir değil ayarlamak ve dolayısıyla bu değer silmek için izniniz iletmek değildir).

Tek bir bit alanında birden çok bayrak saklanmasına izin verir.

Diğer cevaplardan hala net değilse, şöyle düşünün:

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

yazmanın sadece daha kısa bir yoludur:

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
} 

Sekiz olasılık var, ancak bunları sadece dört üyenin birleşimi olarak temsil edebilirsiniz. On altı olasılık olsaydı, onları sadece beş üyenin birleşimi olarak temsil edebilirdin. Dört milyar olasılık olsaydı, onları sadece 33 üyeden oluşan kombinasyonlar olarak temsil edebilirsin! Her biri (sıfır hariç) sadece 33 üyeye sahip olmak, bir numarada dört milyar maddeyi adlandırmaya çalışmaktan çok daha iyidir.

Bu değerler ikili dosyadaki benzersiz bit konumlarını temsil ettiğinden:

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

vb.

1 | 2 == binary 00000011

DÜZENLE:

3 == binary 00000011

İkilikteki 3 değeri, hem yer hem de ikişer yerde 1 değeriyle temsil edilir. Aslında değerle aynı 1 | 2. İkili yerleri bazı devletleri temsil etmek için bayrak olarak kullanmaya çalıştığınızda, 3 genellikle anlamlı değildir (aslında ikisinin birleşimi olan mantıksal bir değer yoksa)

Daha fazla açıklama için örnek numaralandırmanızı aşağıdaki gibi genişletmek isteyebilirsiniz:

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

Bu nedenle ben de Permissions.All, ben de örtülü olarak var Permissions.Read, Permissions.WritevePermissions.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
}

Bunun gibi yazmanın anlaşılması ve okunması daha kolay olduğunu ve bunu hesaplamanıza gerek olmadığını düşünüyorum.

Bunlar, enum değerlerinin kombinasyonlarına izin veren bit bayraklarını temsil etmek için kullanılır. Değerleri onaltılı gösterimde yazarsanız daha net olduğunu düşünüyorum

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

Bu daha çok bir yorum, ancak bu biçimlendirmeyi desteklemeyeceği için, bayrak numaralandırmalarını ayarlamak için kullandığım bir yöntemi dahil etmek istedim:

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

Bayraklarınızı alfabetik sırayla korumak istediğinizde bu yaklaşımı özellikle geliştirme sırasında faydalı buluyorum. Yeni bir bayrak değeri eklemeniz gerektiğini belirlerseniz, bunu sadece alfabetik olarak ekleyebilirsiniz ve değiştirmek zorunda olduğunuz tek değer, bundan önce olduğu değerdir.

Bununla birlikte, herhangi bir üretim sistemine bir çözüm yayınlandıktan sonra (özellikle numaralandırma bir web servisi gibi sıkı bir bağlantı olmadan açığa çıkarsa), enum içindeki mevcut herhangi bir değerin değiştirilmesine karşı kesinlikle tavsiye edilir.

Bu konuda çok iyi cevaplar… Sadece söyleyeceğim .. Eğer sözdiziminin neyi ifade etmeye çalıştığını sevmezseniz veya kolayca kavrayamazsanız<< .. Şahsen bir alternatifi tercih ederim (ve diyorum ki, basit numaralandırma beyanı stili) ...

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

Anlamak çok daha kolay (en azından kendim için). Bunları sıralayın… istediğiniz sonucu tanımlayın, istediğiniz sonucu alın .. Gerekli "hesaplamalar" yok.