En mi proyecto tengo muchas enumeraciones que necesitan tener atributos adicionales asociados con los miembros de la enumeración y métodos estáticos auxiliares asociados con el tipo de enumeración.

Por lo que sé, esto no es posible tenerlo con la clase de enumeración estándar MyItem {...}, por lo que para cada clase de enumeración en mi proyecto tengo una clase auxiliar MyItemEnum que encapsula estos métodos estáticos auxiliares y también crea instancias auxiliares de en sí, de modo que pueda acceder a sus métodos para obtener atributos adicionales.

A continuación se muestra un ejemplo (simplificado tanto como sea posible, pero creo que todas las características que se analizarán permanecieron allí).

MyItem.h

enum class MyItem : unsigned int {
    Item1   = 1,
    Item2   = 5
};

class MyItemEnum {
private:
    MyItem myItem;
    size_t extInfo;

    MyItemEnum(const MyItem& myItem, size_t extInfo);
    ~MyItemEnum();
public:
    static MyItemEnum Item1;
    static MyItemEnum Item2;
    static const MyItemEnum &get(MyItem myItem);

    operator MyItem() const;
    size_t getExt() const;
    bool hasNext() const;
    MyItem next() const;
};

Creo que el significado es obvio y no necesito proporcionar aquí la parte .cpp ... Utilizo MyItem como un argumento para pasar en las interfaces y MyItemEnum cuando necesito acceder a la funcionalidad extendida.

Mi primera pregunta es, ¿está bien el enfoque anterior o debo considerar algo completamente diferente?

Mi segunda pregunta se refiere a una optimización de esta enumeración que estoy tratando de hacer usando constexpr:

enum class MyItem : unsigned int {
    Item1   = 1,
    Item2   = 5
};

class MyItemEnum {
private:
    MyItem myItem;
    size_t extInfo;

    constexpr MyItemEnum(const MyItem& myItem, size_t extInfo);
public:
    static MyItemEnum Item1;
    static MyItemEnum Item2;
    static constexpr MyItemEnum &get(MyItem myItem);

    constexpr operator MyItem();
    constexpr size_t getExt();
    constexpr bool hasNext();
    constexpr MyItem next();
};

Se compila, pero al parecer el constexpr no tiene oportunidad de acostumbrarse porque si accedo a:

MyItemEnum::Item1.getExt()

así que el compilador no sabe con qué valores se creó una instancia de Item1.¿Existe la posibilidad de que la expresión anterior se evalúe como constexpr durante la optimización del tiempo de enlace? Alternativamente podría usar

static constexpr MyItemEnum Item1 = MyItemEnum(MyItem::Item1, 123);

Esto activaría las optimizaciones de tiempo de compilación constexpr, pero me temo que en algunos casos,cuando el constexpr no se puede evaluar en tiempo de compilación, el compilador tendría que crear una instancia local de MyItemEnum (en lugar de usar la referencia a una única instancia estática global) y me temo que esto podría llevar a una penalización de rendimiento (¿mis enums reales tienen más atributos que solo un miembro, por lo que la creación de instancias local puede tomar algún tiempo?).¿Es esta una preocupación justificada?