18

C++11 范围内的枚举器（enum class语法）不会转换为整数，因此它们不能直接用作数组索引。

以这种方式使用它们时，获得作用域优势的最佳方法是什么？

我提供了几个答案，但请添加更多想法！

4

5 回答 5

16

解决方案1：运算符重载。

这是我目前的最爱。重载一元operator+并operator++分别显式转换为整数类型和枚举类型内的增量。

使用enumeration_traits模板，可以激活重载而不是复制样板代码。但样板只是一对夫妇。

库代码（模板，非模板替代方案见下文）：

template< typename e >
struct enumeration_traits;

struct enumeration_trait_indexing {
    static constexpr bool does_index = true;
};

template< typename e >
constexpr
typename std::enable_if< enumeration_traits< e >::does_index,
    typename std::underlying_type< e >::type >::type
operator + ( e val )
    { return static_cast< typename std::underlying_type< e >::type >( val ); }

template< typename e >
typename std::enable_if< enumeration_traits< e >::does_index,
    e & >::type
operator ++ ( e &val )
    { return val = static_cast< e >( + val + 1 ); }

用户代码：

enum class ducks { huey, dewey, louie, count };
template<> struct enumeration_traits< ducks >
    : enumeration_trait_indexing {};

double duck_height[ + ducks::count ];

样板代码（如果不使用库，请遵循enum定义）：

int operator + ( ducks val )
    { return static_cast< int >( val ); }

ducks &operator ++ ( ducks &val )
    { return val = static_cast< ducks >( + val + 1 ); }

解决方案 2：手动范围。

范围枚举器语法也适用于无范围（非enum class）枚举，它们会隐式转换为int. 将枚举隐藏在类或命名空间中，并将其导入typedef或using使其成为伪作用域。

但是如果多个枚举进入同一个命名空间，枚举器名称可能会发生冲突，所以你不妨使用一个类（或多个命名空间）。

struct ducks_enum {
    enum ducks { huey, dewey, louie, count };
};
typedef ducks_enum::ducks ducks;

double duck_height[ ducks::count ]; // C++11
double duck_weight[ ducks_enum::count ]; // C++03

这有一些好处。它适用于 C++03，但仅适用于 syntax ducks_enum::count。枚举器在结构内部是无作用域的，它可以用作任何频繁使用枚举器的类的基础。

于 2012-10-17T05:53:38.113 回答
9

如果您的枚举是连续的，为什么要让它比需要的更难？

enum class days
{
        monday,
        tuesday,
        wednesday,
        thursday,
        friday,
        saturday,
        sunday,
        count
};

....

const auto buffer_size = static_cast< std::size_t >( days::count );
char buffer[ buffer_size ];
buffer[ static_cast< std::size_t >( days::monday ) ] = 'M';

或者，如果您必须使用模板函数...

template< class enumeration >
constexpr std::size_t enum_count() noexcept
{
        static_assert( std::is_enum< enumeration >::value, "Not an enum" );
        return static_cast< std::size_t >( enumeration::count );
}

template< class enumeration >
constexpr std::size_t enum_index( const enumeration value ) noexcept
{
     static_assert( std::is_enum< enumeration >::value, "Not an enum" );
     return static_cast< std::size_t >( value )
}

...

char buffer[ enum_count< days >() ];
buffer[ enum_index( days::monday ) ] = 'M';
于 2012-10-18T06:31:51.460 回答
7

与使用枚举作为数组索引有关的原始问题。与其尝试将枚举转换为数组的索引，不如构建一个接受枚举作为其索引的数组：

template <typename ValueType, typename Enumeration,
          Enumeration largest_enum = Enumeration::Count,
          int largest = static_cast <int> (largest_enum)>
class EnumeratedArray {
    ValueType underlying [static_cast <int> (largest_enum)];
public:
    using value_type = ValueType;
    using enumeration_type = Enumeration;
    EnumeratedArray () {
        for (int i = 0; i < largest; i++) {
            underlying [i] = ValueType {};
        }
    }
    inline ValueType &operator[] (const Enumeration index) {
        assert (static_cast <int> (index) >= 0 && static_cast <int> (index) < largest);
        return underlying [static_cast <const int> (index)];
    }
    inline const ValueType &operator[] (const Enumeration index) const {
        assert (static_cast <int> (index) >= 0 && static_cast <int> (index) < largest);
        return underlying [static_cast <const int> (index)];
    }
};

所以现在，以前面的鸭子为例：

enum class ducks { huey, dewey, louie, count };
EnumeratedArray<double, ducks, ducks::count> duck_height;
duck_height [ducks::huey] = 42.0;

如果鸭子值的大小写不同，大小可能会默认：

enum class Ducks { Huey, Dewey, Louie, Count };
EnumeratedArray<double, Ducks> duck_height;
duck_height [Ducks::Huey] = 42.0;

除了避免枚举扭曲之外，由于在实现中隐藏了到索引转换，因此枚举不会在代码中的其他点错误地成为整数，也不会无意中通过整数索引数组。

EnumeratedArray 用于钢琴 src/common 中的 pianod2。更广泛的版本包括仅显式默认初始化普通旧数据类型的模板魔术、将所有元素初始化为指定值的构造函数和文档注释。

于 2016-02-03T20:02:48.000 回答
1

我正在实施 DrTwox 的解决方案加上 Potatoswatter 解决方案的类型安全的组合。枚举类必须明确定义以允许索引，同时还定义了 size()：

#include <iostream>

template< typename T >
class EnumClassTraits;

struct EnumClassTraitIndexing {
    static constexpr bool does_index = true;
};

template<typename T>
constexpr
typename std::enable_if<EnumClassTraits<T>::does_index,
                        typename std::underlying_type<T>::type>::type enum_size() noexcept {
  return EnumClassTraits<T>::size();
}

template<typename T>
typename std::enable_if<EnumClassTraits<T>::does_index,
                        typename std::underlying_type<T>::type>::type enum_index(T enum_key) noexcept {
  return static_cast<typename std::underlying_type<T>::type>(enum_key);
}

enum class Days {Mon, Tue, Wed, Thu, Fri, Sat, Sun};

template<>
struct EnumClassTraits<Days> : EnumClassTraitIndexing {
  static constexpr std::underlying_type<Days>::type size() {
    return static_cast<std::underlying_type<Days>::type>(Days::Sun)+1;
  }
};

int main(int argc, char* argv[]) {
  Days days[enum_size<Days>()] = {Days::Mon, Days::Tue, Days::Wed, Days::Thu, Days::Fri, Days::Sat, Days::Sun};
  const char* days_to_string[enum_size<Days>()] = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
  for (auto day : days) {
    std::cout << days_to_string[enum_index(day)] << std::endl;
  }
}
于 2013-10-25T03:35:08.763 回答
1

或者，您可以用 a 替换您array的map，这也意味着您可以摆脱最大枚举，例如count：

enum class days
{
    monday,
    tuesday,
    wednesday,
    thursday,
    friday,
    saturday,
    sunday
};


int main(int argc, char* argv[])
{
    std::map<days, const char*> days_to_string =
        {{days::monday, "Monday"},
        {days::tuesday, "Tuesday"},
        {days::wednesday, "Wednesday"},
        {days::thursday, "Thursday"},
        {days::friday, "Friday"}};

    for (auto day : days)
    {
        std::cout << days_to_string[day] << std::endl;
    }
}
于 2017-02-19T04:43:37.343 回答