ejemplo - enum union c++

C++: cómo comprobar, que enum tiene solo valores únicos

Question

usamos VS 2008

hay una gran enumeración, que está poblada por muchos desarrolladores

esta enumeración tiene un tipo __int64 (una extensión de Microsoft), y quiero hacer que el compilador se queje sobre valores no únicos en enum.

si fuera una enumeración habitual, me gustaría hacer esto:

enum E1
{
    E11 = 0x01F00,
    E12 = 0x01F00,
    E13
};
#pragma warning(push)
#pragma warning(error: 4061)
#pragma warning(error: 4062)
void F(E1 e1)
{
    switch (e1)
    {
    case E11:
    case E12:
    case E13:
        return;
    }
}
#pragma warning(pop)

y la función F tendría un error, si E1 tiene 2 mismos valores

y tendría otro error, si un desarrollador olvidó agregar un nuevo valor para cambiar

pero mi enum tiene el tipo __int64 (o largo)

y cuando intento hacer el mismo cambio para E1 e1 trunca los valores y se queja de los valores, que es 0x100000000 o 0x200000000 ....

si lanzo e1 a __int64, el compilador no se queja, si un desarrollador se olvida de agregar un nuevo valor al conmutador (por lo que la función de verificación completa se vuelve inútil)

la pregunta: ¿alguien sabe lo que puedo hacer al respecto? o tal vez VS 2008 (o C ++) tiene otro instrumento para garantizar enum: __int64 tiene solo valores únicos?

Answer 1

¿Alguien sabe lo que puedo hacer al respecto?

Otra respuesta puede ser un análisis algorítmico. El análisis estático no es necesariamente una búsqueda de vulnerabilidades de seguridad. Lamentablemente, en este caso, deberá usar una herramienta externa para verificar su restricción. Puedo ayudarte a implementar eso.

Answer 2

De su comentario, supondré que no tiene indicadores agregados (combinados) dentro de la enumeración en sí. En ese caso, puede usar dos enumeraciones para hacer que sea mucho más difícil cometer errores. Todavía puede subvertir el compilador, pero supongo que ese no es el problema real aquí.

enum Bit_Index
{
    FLAG1_INDEX,
    FLAG2_INDEX,
    FLAG_FANCY_INDEX,
    LAST_INDEX
};

#define DECLARE_BIT_VALUE(att) att##_VALUE = 1ULL << att##_INDEX
enum Bit_Value
{
    DECLARE_BIT_VALUE(FLAG1),
    DECLARE_BIT_VALUE(FLAG2),
    DECLARE_BIT_VALUE(FLAG_FANCY),

    // Declared NOT using the macro so we can static assert that we didn''t forget
    // to add new values to this enum.
    LAST_BIT   // Mainly a placeholder to prevent constantly having to add new commas with new ids.
};
#undef DECLARE_BIT_VALUE

Luego, en un archivo de implementación, static_assert para asegurarse de que las enumeraciones no se desalinean:

// Make sure to the best of our abilities that we didn''t mismatch the index/bit enums.
BOOST_STATIC_ASSERT((LAST_BIT - 1) == (1U << (LAST_INDEX - 1)));