Warum haben Enum-Berechtigungen häufig 0, 1, 2, 4 Werte?

Warum verwenden Menschen immer Enum-Werte wie 0, 1, 2, 4, 8und nicht 0, 1, 2, 3, 4?

Hat dies etwas mit Bitoperationen usw. zu tun?

Ich würde mich sehr über einen kleinen Beispielausschnitt darüber freuen, wie dies richtig verwendet wird :)

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

Weil sie Zweierkräfte sind und ich das kann:

var permissions = Permissions.Read | Permissions.Write;

Und vielleicht später ...

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

Es ist ein Bitfeld, in dem jedes gesetzte Bit einer Berechtigung entspricht (oder was auch immer der aufgezählte Wert logisch entspricht). Wenn diese als definiert 1, 2, 3, ...wären, könnten Sie auf diese Weise keine bitweisen Operatoren verwenden und aussagekräftige Ergebnisse erzielen. Um tiefer zu tauchen ...

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

Beachten Sie hier ein Muster? Nehmen wir nun mein ursprüngliches Beispiel, dh

var permissions = Permissions.Read | Permissions.Write;

Dann...

permissions == 00000011

Sehen? Sowohl das Readals auch das WriteBit sind gesetzt, und ich kann dies unabhängig überprüfen (Beachten Sie auch, dass das DeleteBit nicht gesetzt ist und dieser Wert daher keine Berechtigung zum Löschen vermittelt).

Es ermöglicht das Speichern mehrerer Flags in einem einzigen Bitfeld.

Wenn es aus den anderen Antworten immer noch nicht klar hervorgeht, denken Sie so darüber nach:

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

ist nur eine kürzere Art zu schreiben:

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
} 

Es gibt acht Möglichkeiten, aber Sie können sie als Kombinationen von nur vier Mitgliedern darstellen. Wenn es 16 Möglichkeiten gäbe, könnten Sie sie als Kombinationen von nur fünf Mitgliedern darstellen. Wenn es vier Milliarden Möglichkeiten gäbe, könnten Sie sie als Kombinationen von nur 33 Mitgliedern darstellen! Es ist offensichtlich weitaus besser, nur 33 Mitglieder zu haben, von denen jedes (außer null) eine Zweierpotenz hat, als zu versuchen, vier Milliarden Gegenstände in einer Aufzählung zu benennen.

Weil diese Werte eindeutige Bitpositionen in Binärform darstellen:

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

usw., so

1 | 2 == binary 00000011

BEARBEITEN:

3 == binary 00000011

3 in binär wird durch einen Wert von 1 sowohl an der Einsen- als auch an der Zweierstelle dargestellt. Es ist eigentlich das gleiche wie der Wert 1 | 2. Wenn Sie also versuchen, die binären Stellen als Flags zu verwenden, um einen Zustand darzustellen, ist 3 normalerweise nicht aussagekräftig (es sei denn, es gibt einen logischen Wert, der tatsächlich die Kombination der beiden ist).

Zur weiteren Verdeutlichung möchten Sie möglicherweise Ihre Beispielaufzählung wie folgt erweitern:

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

Deshalb in ich habe Permissions.All, habe ich auch implizit Permissions.Read, Permissions.WriteundPermissions.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
}

Ich denke, so zu schreiben ist leichter zu verstehen und zu lesen, und Sie müssen es nicht berechnen.

Diese werden verwendet, um Bitflags darzustellen, die Kombinationen von Aufzählungswerten ermöglichen. Ich denke, es ist klarer, wenn Sie die Werte in Hex-Notation schreiben

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

Dies ist eigentlich eher ein Kommentar, aber da dies die Formatierung nicht unterstützen würde, wollte ich nur eine Methode einfügen, die ich zum Einrichten von Flag-Aufzählungen verwendet habe:

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

Ich finde diesen Ansatz besonders hilfreich während der Entwicklung, wenn Sie Ihre Flags in alphabetischer Reihenfolge halten möchten. Wenn Sie feststellen, dass Sie einen neuen Flag-Wert hinzufügen müssen, können Sie ihn einfach alphabetisch einfügen. Der einzige Wert, den Sie ändern müssen, ist der, dem er jetzt vorausgeht.

Beachten Sie jedoch, dass es nach der Veröffentlichung einer Lösung für ein Produktionssystem (insbesondere wenn die Aufzählung ohne enge Kopplung verfügbar ist, z. B. über einen Webdienst) dringend empfohlen wird, einen vorhandenen Wert innerhalb der Aufzählung nicht zu ändern.

Viele gute Antworten auf diese Frage ... Ich sage nur ... wenn Sie nicht mögen oder nicht leicht verstehen können, was die <<Syntax auszudrücken versucht ... Ich persönlich bevorzuge eine Alternative (und wage es zu sagen, einen einfachen Enum-Deklarationsstil). …

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

So viel einfacher (zumindest für mich) zu verstehen. Richten Sie die aus ... beschreiben Sie das gewünschte Ergebnis, erhalten Sie das gewünschte Ergebnis. Keine "Berechnungen" erforderlich.