How do |= and &= work?

I want to make an enum in such a way that I can & parameters after |ing them in.

Can I simply do:

enum Things
{
   Something,
SomethingElse
};

Or must I be careful to give them specific numbers for this to work开发者_如何学Python?

Also if a value, like say, 3, has already been |='d in, would |= it in again cause this to malfunction (as in, if(attributes & 3) would no longer work)

Thanks

---

Then define your enum as:

enum Things
{
   Something = 1       //0000 0001
   SomethingElse = 2;  //0000 0010
   SomethingX = 4;     //0000 0100
   SomethingY = 8;     //0000 1000
   SomethingZ = 16;    //0001 0000
};

The idea is, only one bit in the binary representation should be 1, others should be 0, as shown in the comments above. Also, I used 8 bits only in the comment, that doesn't mean that the enum values are one byte size. I only used them for convenience. Enum values can be very large, can hold even long.

---

You have to use special values, namely powers of two (1, 2, 4, 8, 16, ...). And you should probably read this before investigating this "| and & feature" any further: http://en.wikipedia.org/wiki/Binary_numeral_system

This might also be worth reading: http://en.wikipedia.org/wiki/Flag_(computing)

---

Packing flags with | and & works best when you take advantage of the computer's native binary encoding.

So, using the powers of 2 (here in decimal representation):

enum Things
{
   Something     = 1,
   SomethingElse = 2,
   SomethingMore = 4,
   SomethingHuge = 8
};

This enables each flag to be represented exclusively in a single bit of an integer, allowing each one to be activated and de-activated individually.

The result is:

char x = 0;
x |=  Something;     // x in binary looks like 00000001
x |=  SomethingMore; // x in binary looks like 00001001
x &= ~Something;     // x in binary looks like 00001000

I hope that this makes sense.

---

If you want to use bit-wise operations with an Enum, the values must be a power of 2. This is commonly referred to as a Bit Field.

---

As Nawaz said and you can make it easier if you use a hexadecimal codes

enum Things
{
   Something =     0x00000001   //0000 0001
   SomethingElse = 0x00000002;  //0000 0010
   SomethingX    = 0x00000004;  //0000 0100
   SomethingY    = 0x00000008;  //0000 1000
   SomethingZ    = 0x00000010;  //0001 0000 // instead of 16
   SomethingZ2   = 0x00000020;  //0010 0000 // instead of 32
   SomethingZ3   = 0x00000040;  //0100 0000 // instead of 64
   SomethingZ4   = 0x00000080;  //1000 0000 // instead of 128
};

Or even better use a macro:

#define BITMASK(x) (1<<(x))

enum Things
{
   Something =    BITMASK(0)   //0000 0001
   SomethingElse = BITMASK(1) ;  //0000 0010
   SomethingX    = BITMASK(2) ;  //0000 0100
   SomethingY    = BITMASK(3) ;  //0000 1000
   SomethingZ    = BITMASK(4) ;  //0001 0000 
};