Pourquoi les autorisations enum ont-elles souvent des valeurs 0, 1, 2, 4?

Pourquoi les gens utilisent-ils toujours des valeurs d'énumération comme 0, 1, 2, 4, 8et non 0, 1, 2, 3, 4?

Cela a-t-il quelque chose à voir avec les opérations sur les bits, etc.?

J'apprécierais vraiment un petit extrait de code sur la façon dont cela est utilisé correctement :)

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

Parce qu'ils sont des pouvoirs de deux et que je peux le faire:

var permissions = Permissions.Read | Permissions.Write;

Et peut-être plus tard ...

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

C'est un champ de bits, où chaque bit défini correspond à une autorisation (ou à toute autre valeur à laquelle correspond logiquement la valeur énumérée). Si ceux-ci étaient définis comme cela, 1, 2, 3, ...vous ne seriez pas en mesure d'utiliser des opérateurs au niveau du bit de cette façon et d'obtenir des résultats significatifs. Pour approfondir ...

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

Remarquez un modèle ici? Maintenant, si nous prenons mon exemple original, à savoir,

var permissions = Permissions.Read | Permissions.Write;

Ensuite...

permissions == 00000011

Voir? Les bits Readet Writesont tous deux définis, et je peux le vérifier indépendamment (notez également que le Deletebit n'est pas défini et que cette valeur ne transmet donc pas l'autorisation de suppression).

Il permet de stocker plusieurs indicateurs dans un seul champ de bits.

Si ce n'est toujours pas clair d'après les autres réponses, pensez-y comme ceci:

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

est juste une manière plus courte d'écrire:

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
} 

Il existe huit possibilités, mais vous pouvez les représenter sous forme de combinaisons de quatre membres seulement. S'il y avait seize possibilités, vous pourriez les représenter comme des combinaisons de seulement cinq membres. S'il y avait quatre milliards de possibilités, vous pourriez les représenter comme des combinaisons de seulement 33 membres! Il est évidemment préférable de n'avoir que 33 membres, chacun (sauf zéro) une puissance de deux, que d'essayer de nommer quatre milliards d'éléments dans une énumération.

Parce que ces valeurs représentent des emplacements de bits uniques en binaire:

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

etc., donc

1 | 2 == binary 00000011

ÉDITER:

3 == binary 00000011

3 en binaire est représenté par une valeur de 1 à la fois à la place des unités et à la place des deux. C'est en fait la même que la valeur 1 | 2. Ainsi, lorsque vous essayez d'utiliser les emplacements binaires comme indicateurs pour représenter un état, 3 n'est généralement pas significatif (à moins qu'il n'y ait une valeur logique qui est en fait la combinaison des deux)

Pour plus de précisions, vous pouvez étendre votre exemple d'énumération comme suit:

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

Par conséquent , dans je Permissions.All, j'ai aussi implicitement Permissions.Read, Permissions.WriteetPermissions.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
}

Je pense qu'écrire comme ça est plus facile à comprendre et à lire, et vous n'avez pas besoin de le calculer.

Ceux-ci sont utilisés pour représenter des indicateurs de bits qui permettent des combinaisons de valeurs d'énumération. Je pense que c'est plus clair si vous écrivez les valeurs en notation hexadécimale

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

C'est vraiment plus un commentaire, mais comme cela ne prendrait pas en charge le formatage, je voulais simplement inclure une méthode que j'ai utilisée pour configurer les énumérations d'indicateurs:

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

Je trouve cette approche particulièrement utile lors du développement dans le cas où vous souhaitez conserver vos drapeaux par ordre alphabétique. Si vous décidez que vous devez ajouter une nouvelle valeur d'indicateur, vous pouvez simplement l'insérer par ordre alphabétique et la seule valeur que vous devez modifier est celle qu'elle précède maintenant.

Notez, cependant, qu'une fois qu'une solution est publiée sur n'importe quel système de production (en particulier si l'énumération est exposée sans un couplage étroit, comme sur un service Web), il est fortement déconseillé de modifier toute valeur existante dans l'énumération.

Il y a beaucoup de bonnes réponses à celle-ci… Je vais juste dire .. si vous n'aimez pas, ou ne pouvez pas facilement saisir ce que la <<syntaxe essaie d'exprimer .. Personnellement, je préfère une alternative (et oserais-je dire, un style de déclaration d'énumération simple ) …

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

Tellement plus facile (pour moi du moins) à comprendre. Alignez-les… ​​décrivez le résultat que vous désirez, obtenez le résultat que vous VOULEZ .. Aucun «calcul» nécessaire.