Por que as permissões enum geralmente têm 0, 1, 2, 4 valores?

Por que as pessoas sempre usam valores de enum como 0, 1, 2, 4, 8e não 0, 1, 2, 3, 4?

Isso tem algo a ver com operações de bits, etc.?

Eu realmente aprecio um pequeno trecho de amostra de como isso é usado corretamente :)

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

Porque eles são poderes de dois e eu posso fazer isso:

var permissions = Permissions.Read | Permissions.Write;

E talvez mais tarde ...

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

É um campo de bits, em que cada bit definido corresponde a alguma permissão (ou seja qual for o valor logicamente correspondente). Se eles fossem definidos, 1, 2, 3, ...você não seria capaz de usar operadores bit a bit dessa maneira e obter resultados significativos. Para aprofundar ...

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

Observe um padrão aqui? Agora, se pegarmos meu exemplo original, ou seja,

var permissions = Permissions.Read | Permissions.Write;

Então...

permissions == 00000011

Vejo? Os bits Reade Writeestão definidos, e posso verificar isso independentemente (observe também que o Deletebit não está definido e, portanto, esse valor não transmite permissão para excluir).

Ele permite armazenar vários sinalizadores em um único campo de bits.

Se ainda não estiver claro nas outras respostas, pense assim:

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

é apenas uma maneira mais curta de escrever:

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
} 

Existem oito possibilidades, mas você pode representá-las como combinações de apenas quatro membros. Se houvesse dezesseis possibilidades, você poderia representá-las como combinações de apenas cinco membros. Se houvesse quatro bilhões de possibilidades, você poderia representá-las como combinações de apenas 33 membros! Obviamente, é muito melhor ter apenas 33 membros, cada um (exceto zero), um poder de dois, do que tentar nomear quatro bilhões de itens em uma enumeração.

Como esses valores representam locais de bits exclusivos em binário:

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

etc., então

1 | 2 == binary 00000011

EDITAR:

3 == binary 00000011

3 em binário é representado por um valor de 1 nos dois lugares. Na verdade, é o mesmo que o valor 1 | 2. Portanto, quando você está tentando usar os locais binários como sinalizadores para representar algum estado, 3 geralmente não é significativo (a menos que exista um valor lógico que realmente seja a combinação dos dois)

Para esclarecimentos adicionais, convém estender seu exemplo de enum da seguinte maneira:

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

Portanto, em que eu tenho Permissions.All, eu também tenho implicitamente Permissions.Read, Permissions.WriteePermissions.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
}

Acho que escrever assim é mais fácil de entender e ler, e você não precisa calculá-lo.

Eles são usados ​​para representar sinalizadores de bits, o que permite combinações de valores de enumeração. Eu acho que é mais claro se você escrever os valores em notação hexadecimal

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

Isso é realmente mais um comentário, mas como isso não suporta a formatação, eu só queria incluir um método que empreguei para configurar as enumerações de sinalizadores:

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

Considero essa abordagem especialmente útil durante o desenvolvimento no caso em que você deseja manter suas bandeiras em ordem alfabética. Se você determinar que precisa adicionar um novo valor de sinalizador, basta inseri-lo em ordem alfabética e o único valor a ser alterado é o que precede agora.

Observe, no entanto, que depois que uma solução é publicada em qualquer sistema de produção (especialmente se o enum é exposto sem um acoplamento rígido, como em um serviço da Web), é altamente recomendável não alterar qualquer valor existente no enum.

Muitas respostas boas para essa aqui ... direi ... se você não gosta, ou não consegue entender facilmente o que a <<sintaxe está tentando expressar ... eu pessoalmente prefiro uma alternativa (e ouso dizer, estilo simples de declaração enum) ...

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

Muito mais fácil (pelo menos para mim) de compreender. Alinhe os… descreva o resultado desejado, obtenha o resultado que você deseja. Não são necessários "cálculos".