Enumeração contínua C ++ 11

Existe uma maneira de verificar no C ++ 11 se uma enumeração é contínua ?

É totalmente válido fornecer valores de enumeração que não são. Existe talvez um recurso como um traço de tipo em C ++ 14, C ++ 17 ou C ++ 20 para verificar se o enum é contínuo? Isso deve ser usado em um static_assert.

Um pequeno exemplo a seguir:

enum class Types_Discontinuous {
  A = 10,
  B = 1,
  C = 100
};

enum class Types_Continuous {
  A = 0,
  B = 1,
  C = 2
};

static_assert(SOME_TEST<Types_Discontinuous>::value, "Enum should be continuous"); // Fails
static_assert(SOME_TEST<Types_Continuous>::value, "Enum should be continuous");    // Passes

Para vários enums, você provavelmente pode abrir caminho usando a biblioteca Magic Enum . Por exemplo:

#include "magic_enum.hpp"

template <typename Enum>
constexpr bool is_continuous(Enum = Enum{}) {
    // make sure we're actually testing an enum
    if constexpr (!std::is_enum_v<Enum>)
        return false;
    else {
        // get a sorted list of values in the enum
        const auto values = magic_enum::enum_values<Enum>();
        if (std::size(values) == 0)
            return true;

        // for every value, either it's the same as the last one or it's one larger
        auto prev = values[0];
        for (auto x : values) {
            auto next = static_cast<Enum>(magic_enum::enum_integer(prev) + 1);
            if (x != prev && x != next)
                return false;
            else
                prev = x;
        }
        return true;
    }
}

Observe que isso é realmente, como o nome da biblioteca implica, "magic" - a biblioteca funciona em vários hacks específicos do compilador. Como tal, ele realmente não atende aos seus requisitos de "C ++ puro", mas provavelmente é o melhor possível, até termos instalações de reflexão na linguagem.

Isso não é possível no C ++ puro, porque não há como enumerar os valores da enumeração ou descobrir o número dos valores e os valores mínimo e máximo. Mas você pode tentar usar a ajuda do seu compilador para implementar algo parecido com o que você deseja. Por exemplo, no gcc, é possível aplicar um erro de compilação se uma switchinstrução não manipular todos os valores de uma enumeração:

enum class my_enum {
    A = 0,
    B = 1,
    C = 2
};

#pragma GCC diagnostic push
#if __GNUC__ < 5
#pragma GCC diagnostic error "-Wswitch"
#else
#pragma GCC diagnostic error "-Wswitch-enum"
#endif

constexpr bool is_my_enum_continuous(my_enum t = my_enum())
{
    // Check that we know all enum values. Effectively works as a static assert.
    switch (t)
    {
    // Intentionally no default case.
    // The compiler will give an error if not all enum values are listed below.
    case my_enum::A:
    case my_enum::B:
    case my_enum::C:
        break;
    }

    // Check that the enum is continuous
    auto [min, max] = std::minmax({my_enum::A, my_enum::B, my_enum::C});
    return static_cast< int >(min) == 0 && static_cast< int >(max) == 2;
}

#pragma GCC diagnostic pop

Obviamente, isso é especializado para um determinado enum, mas a definição de tais funções pode ser automatizada com o pré-processador.

Eu adoraria ver uma resposta sobre isso. Eu também preciso disso.

Infelizmente, acho que isso não é possível usando os utilitários existentes. Se você deseja implementar uma característica de tipo, precisa do suporte do seu compilador, portanto, escrever um modelo para ele não parece viável.

Eu já estendi a enumeração com uma tag específica para indicar que é contínua e imediatamente fornece o tamanho: construtor de classe enum c ++, como passar um valor específico?

Como alternativa, você pode escrever sua própria característica:

 template<T> struct IsContiguous : std::false_type {};

Isso precisa ser especializado sempre que você define uma enumeração contígua na qual deseja usá-la. Infelizmente, isso requer alguma manutenção e atenção se o enum for alterado.

Todos os enum são contínuos. 0 é sempre permitido; o maior valor permitido é o maior enumerador arredondado para o próximo1<<N -1 (todos os bits um) e todos os valores intermediários também são permitidos. ([dcl.enum] 9.7.1 / 5). Se houver enumeradores negativos definidos, o valor mais baixo permitido é definido da mesma forma, arredondando para baixo o enumerador mais baixo.

Os enumeradores definidos em enumsão expressões constantes com um valor no intervalo e o tipo correto, mas você pode definir constantes adicionais fora das enumquais têm as mesmas propriedades:

constexpr enum class Types_Discontinuous = static_cast<Types_Discontinuous>(2)