Enum liên tục C ++ 11

Có cách nào để kiểm tra C ++ 11 nếu enum liên tục không?

Nó hoàn toàn hợp lệ để đưa ra một giá trị enum không. Có thể có một tính năng như một đặc điểm loại trong C ++ 14, C ++ 17 hoặc có thể C ++ 20 để kiểm tra là enum có liên tục không? Điều này sẽ được sử dụng trong static_assert.

Một ví dụ nhỏ sau:

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

Đối với một số enums, bạn có thể hack theo cách này bằng thư viện Magic Enum . Ví dụ:

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

Lưu ý rằng đây thực sự là, như tên thư viện ngụ ý, "ma thuật" - chức năng thư viện trên một số bản hack dành riêng cho trình biên dịch. Vì vậy, nó không thực sự đáp ứng yêu cầu của bạn về "C ++ thuần túy", nhưng có lẽ tốt như chúng ta có thể nhận được cho đến khi chúng ta có các phương tiện phản ánh trong ngôn ngữ.

Điều này là không thể trong C ++ thuần túy, bởi vì không có cách nào để liệt kê các giá trị enum hoặc khám phá số lượng các giá trị và các giá trị tối thiểu và tối đa. Nhưng bạn có thể thử sử dụng sự trợ giúp của trình biên dịch để thực hiện một cái gì đó gần với những gì bạn muốn. Ví dụ: trong gcc có thể thực thi lỗi biên dịch nếu một switchcâu lệnh không xử lý tất cả các giá trị của enum:

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

Rõ ràng, điều này là chuyên biệt cho một enum nhất định, nhưng định nghĩa về các chức năng như vậy có thể được tự động hóa với bộ tiền xử lý.

Tôi muốn thấy một câu trả lời về điều này. Tôi cũng đang cần nó.

Thật không may, tôi không nghĩ rằng điều này là có thể bằng cách sử dụng các tiện ích hiện có. Nếu bạn muốn triển khai một đặc điểm loại này, bạn cần hỗ trợ từ trình biên dịch của mình, vì vậy việc viết một mẫu cho nó không có vẻ khả thi.

Tôi đã mở rộng phép liệt kê với một thẻ cụ thể để chỉ ra nó liền kề và ngay lập tức cung cấp cho bạn kích thước: enum class constructor c ++, làm thế nào để vượt qua giá trị cụ thể?

Ngoài ra, bạn có thể viết đặc điểm của riêng bạn:

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

Điều này cần phải được chuyên môn bất cứ khi nào bạn xác định một enum liền kề nơi bạn muốn sử dụng này. Thật không may, điều này đòi hỏi một số bảo trì và sự chú ý nếu enum bị thay đổi.

Tất cả enum là liên tục. 0 luôn được cho phép; giá trị cao nhất được phép là điều tra viên cao nhất được làm tròn đến tiếp theo 1<<N -1(tất cả các bit một) và tất cả các giá trị ở giữa cũng được cho phép. ([dcl.enum] 9.7.1 / 5). Nếu có các liệt kê âm được xác định, giá trị thấp nhất được phép cũng được xác định tương tự bằng cách làm tròn số liệt kê thấp nhất.

Các liệt kê được định nghĩa trong các enumbiểu thức không đổi có giá trị trong phạm vi và loại chính xác, nhưng bạn có thể xác định các hằng số bổ sung bên ngoài enumcó các thuộc tính giống nhau:

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