He hecho una enumeración como:

enum class KeyPressSurfaces {
    KEY_PRESS_SURFACE_DEFAULT,
    KEY_PRESS_SURFACE_UP,
    KEY_PRESS_SURFACE_DOWN,
    KEY_PRESS_SURFACE_LEFT,
    KEY_PRESS_SURFACE_RIGHT,
    KEY_PRESS_SURFACE_TOTAL
};

y mas tarde lo intento de definir una matriz, como escribí más abajo, pero he recibido el error, size of array 'KEY_PRESS_SURFACES' has non-integral type 'KeyPressSurfaces'

SDL_Surface*KEY_PRESS_SURFACES[KeyPressSurfaces::KEY_PRESS_SURFACE_TOTAL];

Entiendo el error bien, pero no sé dónde mover el KeyPressSurfaces para calificar la constante en la enumeración.

También me doy cuenta de que sólo podría utilizar un enum y no un enum class, pero siento que esto debería funcionar, y yo quiero aprender a hacer esto.

Cualquier respuesta/consejos se agradece! Gracias!

  • ¿por qué quieres tanto a utilizar un enum para especificar el tamaño de un array? El tamaño debe ser una compilación de constante de tiempo.
  • La enumeración es una compilación de constante de tiempo.
  • al agregar más elementos de la enumeración, la KEY_PRESS_SURFACE_TOTAL ajustar automáticamente. Es una buena técnica realmente el uso de la enumeración para el tamaño de la matriz. Cuando es un número constante, tiene que modificar toda la parte de los códigos que están relacionados con el tamaño de la matriz, especialmente en algunos de cálculo donde el tamaño de la matriz se implican.
  • Me sorprende que nadie menciona esto: Dado que enum classes ámbito, yo he pensado en la mitad del punto de ellos es para evitar tener que repetir feo prefijos como KEY_PRESS_SURFACE_ en cada enumerador. No es necesario proteger el espacio de nombres global más. Pensando en usted, ahora usted tiene que escribir dos veces… KeyPressSurfaces::KEY_PRESS_SURFACE_DEFAULT Yuk! Basta con colocar el prefijo, la caída de la ALL_CAPS demasiado porque no hay macros aquí, caída de la plural que IMO es innecesario, y que mejor reservado para las instancias de las colecciones, y escribir KeyPressSurface::default. Mucho mejor.
InformationsquelleAutor Hayden Piper | 2016-03-11

4 Comentarios

  1. 13

    Ámbito de enums (enum class) no son convertibles implícitamente a enteros. Usted necesidad de utilizar un static_cast:

    SDL_Surface*KEY_PRESS_SURFACES[static_cast<int>(KeyPressSurfaces::KEY_PRESS_SURFACE_TOTAL)];
  2. 11

    Usted puede convertir su enum a int utilizando la función de plantilla y usted obtendrá un código más legible:

    #include <iostream>
    #include <string>
    #include <typeinfo>
    
    using namespace std;
    
    enum class KeyPressSurfaces: int {
        KEY_PRESS_SURFACE_DEFAULT,
        KEY_PRESS_SURFACE_UP,
        KEY_PRESS_SURFACE_DOWN,
        KEY_PRESS_SURFACE_LEFT,
        KEY_PRESS_SURFACE_RIGHT,
        KEY_PRESS_SURFACE_TOTAL
    };
    
    template <typename E>
    constexpr typename std::underlying_type<E>::type to_underlying(E e) {
        return static_cast<typename std::underlying_type<E>::type>(e);
    }
    
    
    int main() {
        KeyPressSurfaces val = KeyPressSurfaces::KEY_PRESS_SURFACE_UP;
        int valInt = to_underlying(val);
        std::cout << valInt << std::endl;
        return 0;
    }

    I fuente to_underlying función aquí

  3. 0

    Alternativamente, usted puede reemplazar su array con un map, lo que también significa que usted puede deshacerse de KEY_PRESS_SURFACE_TOTAL:

    enum class KeyPressSurfaces {
        KEY_PRESS_SURFACE_DEFAULT,
        KEY_PRESS_SURFACE_UP,
        KEY_PRESS_SURFACE_DOWN,
        KEY_PRESS_SURFACE_LEFT,
        KEY_PRESS_SURFACE_RIGHT
    };
    
    std::map<KeyPressSurfaces, SDL_Surface*> KEY_PRESS_SURFACES;
    • Esta no es realmente una solución general para el problema, ya std::map será más lento que el uso de una matriz.
    • «Optimización prematura es la raíz de todo mal». – no hay nada en la pregunta que sugiere que la velocidad es un problema, el compilador puede ser lo suficientemente inteligente como para manejar esto y esto me parece una solución más limpia.
    • Estoy bastante seguro de que no compilador (pasado, presente, o futuro) se pondrá de un std::map en una matriz. También hay una diferencia entre la escritura lenta código porque no quieres optimizar prematuramente y la escritura lenta código porque no tienen idea del concepto que usted está utilizando es lento. Se me ocurre escribir un programa de mí mismo ahora (un motor de ajedrez), donde el impacto en el rendimiento de usar std::map sería totalmente brutal.
    • esa cita no es siempre exacta. A menudo los errores de la causa por la optimización prematura es cuando su objetivo es la optimización de la velocidad o el uso de memoria y no considerar otras materias en su programa. También hay otro tipo de optimización como optimizar-de-mantenimiento-y-flexibilidad, lo que en gran parte va a disminuir los errores y será bueno para el negocio en el largo plazo. La producción puede ser lento al principio, pero vale la pena.
    • Me gusta @parsley72 idea. Claramente aumenta la legibilidad.
    • Aparte de todo lo demás que podrían ser objeto de debate, hay una clara disminución en la legibilidad y calidad de estilo mediante el uso de ALL_CAPS para nada, excepto una macro, especialmente de un nombre de variable (hay una cierta tradición de utilizar también para enumerador de nombres, pero que sigue siendo la mala de la OMI).

Dejar respuesta

Please enter your comment!
Please enter your name here