Fortlaufende Aufzählung C ++ 11

Gibt es eine Möglichkeit, in C ++ 11 zu überprüfen, ob eine Aufzählung fortlaufend ist ?

Es ist voll gültig, eine Aufzählung anzugeben, die nicht sind. Gibt es möglicherweise eine Funktion wie ein Typmerkmal in C ++ 14, C ++ 17 oder C ++ 20, um zu überprüfen, ob die Aufzählung fortlaufend ist? Dies soll in einem static_assert verwendet werden.

Es folgt ein kleines Beispiel:

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

Für eine Reihe von enums können Sie sich wahrscheinlich mithilfe der Magic Enum- Bibliothek durch diese Sache hacken . Zum Beispiel:

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

Beachten Sie, dass dies tatsächlich, wie der Name der Bibliothek andeutet, "Magie" ist - die Bibliothek funktioniert bei einer Reihe von compilerspezifischen Hacks. Als solches erfüllt es nicht wirklich Ihre Anforderungen an "reines C ++", ist aber wahrscheinlich so gut wie möglich, bis wir Reflexionsmöglichkeiten in der Sprache haben.

Dies ist in reinem C ++ nicht möglich, da es keine Möglichkeit gibt, die Aufzählungswerte aufzulisten oder die Anzahl der Werte sowie die Minimal- und Maximalwerte zu ermitteln. Sie können jedoch versuchen, mithilfe Ihres Compilers etwas zu implementieren, das Ihren Wünschen entspricht. In gcc ist es beispielsweise möglich, einen Kompilierungsfehler zu erzwingen, wenn eine switchAnweisung nicht alle Werte einer Aufzählung verarbeitet:

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

Dies ist natürlich auf eine bestimmte Aufzählung spezialisiert, aber die Definition solcher Funktionen kann mit einem Präprozessor automatisiert werden.

Ich würde gerne eine Antwort darauf sehen. Ich habe es auch gebraucht.

Leider glaube ich nicht, dass dies mit den vorhandenen Dienstprogrammen möglich ist. Wenn Sie hierfür ein Typmerkmal implementieren möchten, benötigen Sie Unterstützung von Ihrem Compiler, sodass das Schreiben einer Vorlage dafür nicht möglich klingt.

Ich habe die Aufzählung bereits um ein bestimmtes Tag erweitert, um anzuzeigen, dass sie zusammenhängend ist, und gibt Ihnen sofort die Größe: Enum-Klassenkonstruktor c ++, wie kann ein bestimmter Wert übergeben werden?

Alternativ können Sie Ihr eigenes Merkmal schreiben:

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

Dies muss immer dann spezialisiert werden, wenn Sie eine zusammenhängende Aufzählung definieren, in der Sie diese verwenden möchten. Leider erfordert dies einige Wartung und Aufmerksamkeit, wenn die Aufzählung geändert wird.

Alle Aufzählungen sind fortlaufend. 0 ist immer erlaubt; Der höchste zulässige Wert ist der höchste auf den nächsten aufgerundete Enumerator 1<<N -1(alle Bits eins), und alle dazwischen liegenden Werte sind ebenfalls zulässig. ([dcl.enum] 9.7.1 / 5). Wenn negative Enumeratoren definiert sind, wird der niedrigste zulässige Wert auf ähnliche Weise definiert, indem der niedrigste Enumerator abgerundet wird.

Die in definierten Enumeratoren enumsind konstante Ausdrücke mit einem Wert im Bereich und dem richtigen Typ. Sie können jedoch zusätzliche Konstanten außerhalb der definieren, enumdie dieselben Eigenschaften haben:

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