¿Por qué usar el operador Bitwise-Shift para valores en una definición de enumeración C?

Tal vez escribir los valores en hexadecimal (o binario) ayuda : -)

enum {
  kCGDisplayBeginConfigurationFlag  = (1 << 0), /* 0b0000000000000001 */
  kCGDisplayMovedFlag               = (1 << 1), /* 0b0000000000000010 */
  kCGDisplaySetMainFlag             = (1 << 2), /* 0b0000000000000100 */
  kCGDisplaySetModeFlag             = (1 << 3), /* 0b0000000000001000 */
  kCGDisplayAddFlag                 = (1 << 4), /* 0b0000000000010000 */
  kCGDisplayRemoveFlag              = (1 << 5), /* 0b0000000000100000 */
  kCGDisplayEnabledFlag             = (1 << 8), /* 0b0000000100000000 */
  kCGDisplayDisabledFlag            = (1 << 9), /* 0b0000001000000000 */
  kCGDisplayMirrorFlag              = (1 << 10),/* 0b0000010000000000 */
  kCGDisplayUnMirrorFlag            = (1 << 11),/* 0b0000100000000000 */
  kCGDisplayDesktopShapeChangedFlag = (1 << 12) /* 0b0001000000000000 */
};

Ahora puede agregarlos (o" o " ellos) y obtener diferentes valores

kCGDisplayAddFlag | kCGDisplayDisabledFlag /* 0b0000001000010000 */

Si tienes FlagA=1, FlagB=2 y FlagC=3, FlagA o FlagB daría el mismo valor que FlagC. El operador de cambio se utiliza para garantizar que cada combinación de banderas sea única.

Esto permitirá que una variable combine fácilmente múltiples banderas:

unit32_t multFlag = kCGDisplayRemoveFlag | kCGDisplayMirrorFlag | kCGDisplaySetMainFlag'

Lo nuevo en C# 7 es finalmente literales binarios, así que puedes escribirlo así:

enum MyEnum
{
    kCGDisplayBeginConfigurationFlag  = 0b0000000000000001;
    kCGDisplayMovedFlag               = 0b0000000000000010;
    kCGDisplaySetMainFlag             = 0b0000000000000100;
    kCGDisplaySetModeFlag             = 0b0000000000001000;
    kCGDisplayAddFlag                 = 0b0000000000010000;
    kCGDisplayRemoveFlag              = 0b0000000000100000;
    kCGDisplayEnabledFlag             = 0b0000000001000000;
    kCGDisplayDisabledFlag            = 0b0000000010000000;
    kCGDisplayMirrorFlag              = 0b0000000100000000;
    kCGDisplayUnMirrorFlag            = 0b0000001000000000;
    kCGDisplayDesktopShapeChangedFlag = 0b0000010000000000;
};

Y si quieres hacer las cosas aún más limpias, usa esto: _ que también es nuevo en C # 7, que te permite poner espacios en números para hacer las cosas más legibles, así:

enum MyEnum
{
    kCGDisplayBeginConfigurationFlag  = 0b_0000_0000_0000_0001;
    kCGDisplayMovedFlag               = 0b_0000_0000_0000_0010;
    kCGDisplaySetMainFlag             = 0b_0000_0000_0000_0100;
    kCGDisplaySetModeFlag             = 0b_0000_0000_0000_1000;
    kCGDisplayAddFlag                 = 0b_0000_0000_0001_0000;
    kCGDisplayRemoveFlag              = 0b_0000_0000_0010_0000;
    kCGDisplayEnabledFlag             = 0b_0000_0000_0100_0000;
    kCGDisplayDisabledFlag            = 0b_0000_0000_1000_0000;
    kCGDisplayMirrorFlag              = 0b_0000_0001_0000_0000;
    kCGDisplayUnMirrorFlag            = 0b_0000_0010_0000_0000;
    kCGDisplayDesktopShapeChangedFlag = 0b_0000_0100_0000_0000;
};

Hace que sea mucho más fácil llevar un registro de los números.

Permítanme darles un ejemplo más práctico. En c++ cuando desea abrir un archivo (Abierto para salida, y en modo binario opuesto al modo texto), puede hacerlo de la siguiente manera:

const char *filename = "/home/xy/test.bin";
fstream output(filename, ios::out | ios::binary);

Puede ver, ios::out | ios::binary puede establecer dos modos(Abierto para salida, y en modo binario).

¿Cómo funciona esto ? Es por enum (valores bitwise-shift):

enum _Ios_Openmode 
{ 
  _S_app        = 1L << 0,
  _S_ate        = 1L << 1,
  _S_bin        = 1L << 2,  /* 0b0000000000000100 */
  _S_in         = 1L << 3,
  _S_out        = 1L << 4,  /* 0b0000000000010000 */
  _S_trunc      = 1L << 5
  //.....
};

/// Perform input and output in binary mode (as opposed to text mode).
static const openmode binary =  _S_bin;

/// Open for input.  Default for @c ifstream and fstream.
static const openmode in =      _S_in;

/// Open for output.  Default for @c ofstream and fstream.
static const openmode out =     _S_out;

Si usa incremento de valor por 1 en enum _Ios_Openmode, tiene que set(ios::out) y set(ios::binary) hacer dos veces. Puede no ser tan conveniente comprobar y establecer el valor por una vez.

.. porque 1<<7 parece más conciso y más fácil de leer que 01000000. ¿No es así?

Usar #define es más comprensible. pero enum podría agrupar estos valores togater.