Combinando Enum Value usando Bitmask

Question

Entiendo que es posible usar máscaras de bits en valores enum, pero no sé cómo crearlo.

Tengo una enumeración simple:

enum State 
{ 
    minimizing = 0, 
    maximizing, 

    minimized, 
    maximized 
}; 

Un estado es siempre State.minimized o State.maximized, y puede tener estatal sobre cambio de tamaño. Entonces algo se puede maximizar y minimizar

Answer 1

Voy a suponer que myState tiene el tipo de su enum State.

El uso tradicional de enum es crear los valores constantes que una variable de este tipo puede tomar. Desea establecer la variable myState en una combinación de los valores definidos en enum.

El enum define 1, 2, 4 y 8 como valores válidos, pero desea poder establecer la variable en 4 | 2 = 6. Mientras que C usa su tipo int definido por implementación para todos enum, no es el caso en C++. myState = 6 no es válido en C++. En realidad, myState = 4 no es válido en C++, necesita emitir explícitamente o usar uno de los nombres de constante del enum.

Aunque es posible en C, no es una buena práctica establecer myState en un valor que no esté definido por su tipo (por ejemplo, a 6).

En su caso, una solución que parece consecuente sería:

typedef enum { 
    OTHER, 
    MINIMIZED, 
    MAXIMIZED 
} win_size_t; 

typedef struct { 
    win_size_t current; 
    win_size_t next; 
} state_t; 

state_t myState; 

De esta manera, se puede escribir en los campos current y next undependently.

Si aún desea tener campos de bit, puede establecer el tamaño de los elementos de su estructura en bits. Aunque es algo peligroso, la implementación de los campos de bit depende de tu compilador. Ni siquiera estoy seguro de si los compiladores aceptarían tener un tipo de enumeración en un campo de bit (debería estar bien en C, ya que enum s son int).

typedef struct { 
    win_size_t current : 2; // not tested 
    win_size_t next : 2; 
} state_t; 

Las soluciones anteriores son válidas, por supuesto.Mi punto es que si su variable myState tiene su tipo enum State, solo debe usar los miembros de enum para sus valores, no una combinación.

Tal vez myState tiene otro tipo, ¿qué sé yo?

---

Si myState no es del tipo enum State, entonces puede usar las constantes definidas en su enum en combinación.

enum State { 
    MINIMIZING = (1u << 0), 
    MAXIMIZING = (1u << 1), 
    MINIMIZED = (1u << 2), 
    MAXIMIZED = (1u << 3), 
}; 

unsigned int myState = 0; 

myState |= MAXIMIZED; // sets that bit 
myState &= ~MAXIMIZED; // resets that bit 

Esto le permite hacer dos cosas en una asignación:

myState = MAXIMIZED | MINIMIZING; 

Pero también cosas que no es probable que desee:

myState = MAXIMIZED | MINIMIZED; // does that make sense? 

Answer 2

Puede obtener este efecto especificando todos los campos en la enumeración y aumentando en potencias de dos para obtener el efecto de máscara de bits. Por ejemplo, en su caso:

enum State 
{ 
    minimizing = 1, 
    maximizing = 2, 

    minimized = 4, 
    maximized = 8 
}; 

modo que lo pueda tener sus combinaciones de (State.maximized | State.minimizing). Sin embargo, esto no aplicará la restricción de solo ser State.maximized o State.minimized. Si quieres hacer eso, podrías convertirlos a un solo bit, pero imagino que en este ejemplo querrás tener un caso en el que no se maximice ni se minimice.

Answer 3

utilizar un poco diferente para cada valor en su enumeración, tales como:

enum State 
{ 
    minimizing = 0x01, // 00000001 
    maximizing = 0x02, // 00000010 
    minimized = 0x04, // 00000100 
    maximized = 0x08 // 00001000 
}: 

A continuación, puede combinar varios valores con bit a bit o (minimizing | maximized) y prueba de los valores con bit a bit y (bool is_minimized = (flags & minimized);).

Answer 4

simplemente he intentado esto en VS2012, la el optimizador parece combinar bits correctamente sin necesidad de asistencia si está utilizando bitfields.

struct BITS { int x: 1; int y:1; }; 

continuación

BITS b; 
b.x = b.y = 1; 

conjuntos de los dos bits con una instrucción.