Sürekli numaralandırma C ++ 11

Bir enum sürekli olup olmadığını C ++ 11 denetlemek için bir yolu var mı ?

Olmayan bir enum değerleri vermek tamamen geçerlidir. Enum sürekli olup olmadığını kontrol etmek için C ++ 14, C ++ 17 veya belki C ++ 20'de bir tür özelliği gibi bir özellik var mı? Bu, static_assert içinde kullanılacak.

Küçük bir örnek şöyle:

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

Bir kaç enums için Magic Enum kütüphanesini kullanarak bunu hackleyebilirsiniz . Örneğin:

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

Bunun kütüphane adından da anlaşılacağı gibi, "sihirli" olduğuna dikkat edin - kütüphane, derleyiciye özgü bir dizi saldırı üzerinde çalışır. Bu yüzden gerçekten "saf C ++" gereksiniminizi karşılamıyor, ancak dilde yansıma olanaklarımız olana kadar alabileceğimiz kadar iyi.

Saf C ++ 'da bu mümkün değildir, çünkü enum değerlerini numaralandırmanın veya değerlerin sayısını ve minimum ve maksimum değerleri keşfetmenin bir yolu yoktur. Ancak istediğiniz şeye yakın bir şey uygulamak için derleyicinizin yardımını kullanmayı deneyebilirsiniz. Örneğin, gcc'de bir switchdeyim bir numaralandırmanın tüm değerlerini işlemezse bir derleme hatası uygulamak mümkündür :

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

Açıkçası, bu belirli bir numaralandırma için uzmanlaşmıştır, ancak bu tür işlevlerin tanımı önişlemci ile otomatikleştirilebilir.

Bu konuda bir cevap görmek isterim. Ben de buna ihtiyacım var.

Ne yazık ki, bunun mevcut yardımcı programları kullanarak mümkün olduğunu düşünmüyorum. Bunun üzerine bir tür özelliği uygulamak istiyorsanız, derleyicinizden desteğe ihtiyacınız vardır, bu nedenle bunun için bir şablon yazmak kulağa mantıklı gelmez.

Zaten bitişik olduğunu göstermek için belirli bir etiketi ile numaralandırma zaten genişletilmiş ve hemen size boyutu verir: enum sınıfı yapıcı c ++, nasıl belirli bir değer geçmek için?

Alternatif olarak kendi özelliğinizi de yazabilirsiniz:

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

Bunu kullanmak istediğiniz bitişik bir enum tanımladığınızda bunun uzman olması gerekir. Ne yazık ki, enum değiştirilirse bu biraz bakım ve dikkat gerektirir.

Tüm numaralar süreklidir. 0'a her zaman izin verilir; izin verilen en yüksek değer, bir sonrakine yuvarlanan en yüksek numaralandırıcıdır 1<<N -1(tümü bir bit) ve aradaki tüm değerlere de izin verilir. ([dcl.enum] 9.7.1 / 5). Tanımlanmış negatif numaralandırıcılar varsa, izin verilen en düşük değer benzer şekilde en düşük numaralandırıcının yuvarlanmasıyla tanımlanır.

İçinde tanımlanan numaralandırıcılar enum, aralık ve doğru türde bir değere sahip sabit ifadelerdir, ancak dışında enumaynı özelliklere sahip ek sabitler tanımlayabilirsiniz :

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