Dlaczego uprawnienia wyliczenia często mają wartości 0, 1, 2, 4?

Dlaczego ludzie zawsze używają wartości wyliczenia, jak 0, 1, 2, 4, 8lub nie 0, 1, 2, 3, 4?

Czy ma to coś wspólnego z operacjami bitowymi itp.?

Naprawdę byłbym wdzięczny za mały przykładowy fragment pokazujący, jak to jest poprawnie używane :)

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

Ponieważ są one potęgą dwojga i mogę to zrobić:

var permissions = Permissions.Read | Permissions.Write;

A może później ...

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

Jest to pole bitowe, w którym każdy ustawiony bit odpowiada pewnemu zezwoleniu (lub czemukolwiek logicznie odpowiada wyliczona wartość). Gdyby zostały zdefiniowane 1, 2, 3, ..., nie byłby w stanie używać operatorów bitowych w ten sposób i uzyskać znaczących wyników. Aby zagłębić się głębiej ...

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

Zauważyłeś tutaj wzór? Jeśli weźmiemy mój oryginalny przykład, tj.

var permissions = Permissions.Read | Permissions.Write;

Następnie...

permissions == 00000011

Widzieć? Zarówno bity, jak Readi Writesą ustawione i mogę to sprawdzić niezależnie (zauważ również, że Deletebit nie jest ustawiony i dlatego ta wartość nie oznacza uprawnień do usuwania).

Pozwala na przechowywanie wielu flag w jednym polu bitów.

Jeśli nadal nie jest to jasne z innych odpowiedzi, pomyśl o tym w ten sposób:

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

to tylko krótszy sposób na napisanie:

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
} 

Istnieje osiem możliwości, ale można je przedstawić jako kombinacje tylko czterech członków. Gdyby istniało szesnaście możliwości, można by je przedstawić jako kombinacje tylko pięciu członków. Gdyby istniały cztery miliardy możliwości, można by je przedstawić jako kombinację tylko 33 członków! Oczywiście o wiele lepiej jest mieć tylko 33 członków, z których każdy (oprócz zera) ma potęgę dwóch, niż próbować nazwać cztery miliardy elementów w wyliczeniu.

Ponieważ te wartości reprezentują unikalne lokalizacje bitów w systemie binarnym:

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

itd., więc

1 | 2 == binary 00000011

EDYTOWAĆ:

3 == binary 00000011

3 w systemie dwójkowym jest reprezentowane przez wartość 1 zarówno w miejscu jedynek, jak i dwójek. W rzeczywistości jest taka sama jak wartość 1 | 2. Więc kiedy próbujesz użyć miejsc binarnych jako flag do reprezentowania jakiegoś stanu, 3 zazwyczaj nie ma znaczenia (chyba że istnieje wartość logiczna, która w rzeczywistości jest kombinacją tych dwóch)

Aby uzyskać dalsze wyjaśnienia, możesz chcieć rozszerzyć przykładowe wyliczenie w następujący sposób:

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

Dlatego w mam Permissions.All, ja też pośrednio mają Permissions.Read, Permissions.WriteiPermissions.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
}

Myślę, że pisanie w ten sposób jest łatwiejsze do zrozumienia i czytania i nie musisz tego obliczać.

Są one używane do reprezentowania flag bitowych, które pozwalają na kombinacje wartości wyliczeniowych. Myślę, że jest to wyraźniejsze, jeśli napiszesz wartości w notacji szesnastkowej

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

To jest bardziej komentarz, ale ponieważ nie obsługuje to formatowania, chciałem po prostu dołączyć metodę, której użyłem do ustawiania wyliczeń flag:

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

Uważam, że to podejście jest szczególnie pomocne podczas programowania w przypadku, gdy chcesz zachować swoje flagi w porządku alfabetycznym. Jeśli zdecydujesz, że musisz dodać nową wartość flagi, możesz po prostu wstawić ją alfabetycznie, a jedyną wartością, którą musisz zmienić, jest ta, którą teraz poprzedza.

Należy jednak pamiętać, że po opublikowaniu rozwiązania w dowolnym systemie produkcyjnym (zwłaszcza jeśli wyliczenie jest ujawniane bez ścisłego powiązania, na przykład w usłudze sieci Web), zdecydowanie odradza się zmienianie jakiejkolwiek istniejącej wartości w wyliczeniu.

Wiele dobrych odpowiedzi na to pytanie… powiem tylko… jeśli nie podoba ci się lub nie możesz łatwo pojąć, co <<próbuje wyrazić składnia… Osobiście wolę alternatywę (i ośmielę się powiedzieć, prosty styl deklaracji wyliczenia) …

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

O wiele łatwiejsze (przynajmniej dla mnie) do zrozumienia. Ułóż je w jednej linii… opisz pożądany rezultat, uzyskaj wynik, którego CHCESZ .. Nie są potrzebne żadne „obliczenia”.