Controlando la visibilidad de los valores enum

Question

Considere una clase C++ que exporta una enumeración, mantiene una matriz interna sobre esa enumeración, y desea exportar un comando que acepte valores de la enumeración.

class foo { 
public: 
    enum color { 
    red, 
    yellow, 
    green, 
    NUM_COLORS 
    }; 
private: 
    something somebody[NUM_COLORS]; 
public: 
    void command(color c); 
}; 

¿Hay una manera limpia de exportar solo los colores reales, pero no NUM_COLORS? No quiero tener que buscar el caso límite en cada llamada cuando el sistema de tipo de compilación realmente debería poder hacerlo por mí.

El truco es obvia:

class foo { 
public: 
    enum color { 
    red, 
    yellow, 
    green 
    }; 
private: 
    /* something like */ const unsigned NUM_COLORS = green+1; 
    unsigned LEDs_in_stock[NUM_COLORS]; 
public: 
    void command(color c); 
}; 

Por supuesto, esto es una bomba de tiempo, a la espera de algún pobre programador de mantenimiento con exceso de trabajo para agregar disposiciones para los LEDs azules, y se olvidan de actualizar la línea NUM_COLORS.

Déjenme aclarar un poco. Lo que yo quiero, en este caso particular, es ser capaz de decir:

class foo { 
public: 
    enum color { 
    red, 
    yellow, 
    green 
    }; 
    void command(color c); 
private: 
    something somebody[color]; 
}; 

Es mi entendimiento de que C++ no permite esto.

Answer 1

Mi primer pensamiento sería para tratar de resolver el problema, ya que la pongo, pero después de una reflexión poco, sería trasladar la carga a command:

void command(color c) { 
    assert(0 <= c && c < NUM_COLORS && "Invalid argument"); 
} 

Desde enumeraciones son tipos tan débiles , es necesario comprobar la entrada de todos modos, ya que cualquiera podría fácilmente dar argumentos cutres:

Foo foo; 
foo.command(static_cast<Foo::color>(3)); // 3 is green, right ? 

---

solución original:

class Foo { 
    struct impl { enum { red, yellow, green, NUM_COLORS }; }; 
public: 
    enum color { red = impl::red, yellow = impl::yellow, green = impl::green }; 

    void command(color c); 
}; 

Desafortunadamente, hay un alto grado de duplicación pasando (y de hecho originalmente escrito green = impl::yellow; aunque no importa si nunca se refieren a impl 's valores directamente).

De lo contrario, siempre existe el truco macro:

#define MY_DEFINE_ENUM(Type, Elements)  \ 
    enum Type { BOOST_PP_SEQ_ENUM(Elements) }; \ 
    inline size_t size(Type) { return BOOST_PP_SEQ_SIZE(Elements); } 

que utiliza un preprocesador macro maquinaria y oscuro para evitar el mal código duplicaton. Obviamente, solo funciona para elementos enum consecutivos (devuelve el número de elementos, no el número máximo).

Answer 2

Una solución sería utilizar un mapa:

std::map<color, unsigned> LEDs_in_stock; 

LEDs_in_stock[red] += 2; 

LEDs_in_stock[red]; // = 2 
LEDs_in_stock[green]; // = 0 

De esta manera se mantiene limpia que ENUM, y no es necesario codificar cualquier tamaño.

Answer 3

¿Está poniendo la enumeración en una clase base una opción?

class foo_enums { 
public: 
    enum color { 
    red, 
    yellow, 
    green, 
    NUM_COLORS 
    }; 

protected: 
    foo_enums() { } 
    ~foo_enums() { } 
}; 

class foo : public foo_enums { 
private: 
    unsigned LEDs_in_stock[NUM_COLORS]; 

    /* make NUM_* values inaccessible */ 
    using foo_enums::NUM_COLORS; 

public: 
    void command(color c); 
}; 

Personalmente, no haría esto, ya que parece una tarea demasiado compleja. Simplemente prohibiría que la persona que llama pase NUM_COLORS. Es cierto que el sistema de tipo no verifica eso. Pero seguramente esto es algo fácil de verificar para los programadores humanos. ¿Por qué pasarían NUM_COLORS?

Answer 4

Hay una línea muy fina entre proteger a sus futuros mantenedores de cometer errores simples/fáciles e intentar detener algo que debería ser obviamente incorrecto, como usar el valor de NUM_COLORS.

En su caso, le sugiero que afirme la entrada en las funciones clave y lo deje así.

Creo que podría utilizar una clase de proxy de plantilla que se especializa y static_assert s en NUM_COLORS para evitar que los usuarios lo pasen a sus funciones.

Escribí algo que parece funcionar.

class foo { 
public: 
    enum color { 
    red, 
    yellow, 
    green, 
    NUM_COLORS 
    }; 

    class Color_Rep 
    { 
    color c; 
    protected: 
    Color_Rep(color which_color) : c(which_color) { } 
    }; 

    template <color C> 
    struct Color : public Color_Rep 
    { 
    Color() : Color_Rep(C) { } 
    enum { value = C }; 
    }; 

private: 
    int bar[NUM_COLORS]; 

public: 
    void command(Color_Rep c); 
}; 

// Deny access to command(NUM_COLORS). 
template <> 
struct foo::Color<foo::NUM_COLORS> 
{ 
}; 

int main() 
{ 
    foo().command(foo::Color<foo::red>()); 
    foo().command(foo::Color<foo::green>()); 
    foo().command(foo::Color<foo::NUM_COLORS>()); // Won't compile. 
}