Непрерывное перечисление C ++ 11

Есть ли способ проверить в C ++ 11, является ли перечисление непрерывным ?

Полностью допустимо указывать значения enum, которых нет. Есть ли такая особенность, как черта типа в C ++ 14, C ++ 17 или, может быть, C ++ 20, чтобы проверить, является ли enum непрерывным? Это будет использоваться в static_assert.

Вот небольшой пример:

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

В течение нескольких enumсекунд вы, вероятно, сможете прорваться через это, используя библиотеку Magic Enum . Например:

#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;
    }
}

Обратите внимание, что это действительно, как следует из названия библиотеки, «магия» - библиотека функционирует в ряде хаков, специфичных для компилятора. Как таковой, он на самом деле не соответствует вашему требованию «чистого C ++», но, вероятно, настолько хорош, насколько мы сможем получить, пока у нас не появятся средства отражения в языке.

Это невозможно в чистом C ++, потому что нет способа перечислить значения перечисления или определить количество значений, а также минимальное и максимальное значения. Но вы можете попытаться использовать помощь вашего компилятора, чтобы реализовать что-то близкое к тому, что вы хотите. Например, в gcc можно применить ошибку компиляции, если switchинструкция не обрабатывает все значения перечисления:

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

Очевидно, что это специализировано для данного перечисления, но определение таких функций может быть автоматизировано с помощью препроцессора.

Я хотел бы увидеть ответ на этот вопрос. Мне это тоже нужно.

К сожалению, я не думаю, что это возможно с использованием существующих утилит. Если вы хотите реализовать черту типа в этом, вам нужна поддержка вашего компилятора, поэтому написание шаблона для него не представляется возможным.

Я уже расширил перечисление специальным тегом, чтобы указать, что он является смежным, и сразу же дает вам конструктор класса enum c ++, как передать конкретное значение?

Кроме того, вы можете написать свою собственную черту:

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

Это должно быть специализированным всякий раз, когда вы определяете непрерывное перечисление, где вы хотите использовать это. К сожалению, это требует некоторого обслуживания и внимания, если перечисление изменяется.

Все перечисления непрерывны. 0 всегда разрешено; самое высокое допустимое значение - это самый высокий перечислитель, округленный до следующего 1<<N -1(все биты один), и все значения между ними также разрешены. ([dcl.enum] 9.7.1 / 5). Если определены отрицательные перечислители, то самое низкое допустимое значение аналогично определяется округлением в меньшую сторону перечислителя.

Перечисленные в enumвыражениях перечислители являются константными выражениями со значением в диапазоне и правильным типом, но вы можете определить дополнительные константы, enumкоторые имеют те же свойства:

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