Question

我有几个enums定义如下：

enum class Suit {
    spades = 1, hearts, diamonds, clubs,
    first = spades, last = clubs
};

enum class Rank {
    six = 6, seven, eight, nine, ten, jack, queen, king, ace,
    first = six, last = ace
};

对于每个enums，我都使一些运算符超载了：

Suit operator++(Suit& r) { return r = (Suit)(static_cast<std::underlying_type_t<Suit>>(r) + 1); }
Rank operator++(Rank& r) { return r = (Rank)(static_cast<std::underlying_type_t<Rank>>(r) + 1); }
// more overloads ...

请注意，两种类型的运算符重载的实现方式都是相同的。 如何避免此代码重复？

我可以使用模板...

template<class T>
T operator++(T& r) { return r = (T)(static_cast<std::underlying_type_t<T>>(r) + 1); }

但是这些重载应该仅适用于我的自定义类型。

Answer 1

这是您以可扩展方式限制模板的方法。

#include <type_traits>

template <class> 
constexpr bool is_my_enum = false;       // most types are not my enums

enum class Suit {
    spades = 1, hearts, diamonds, clubs,
    first = spades, last = clubs
};
template<> 
constexpr bool is_my_enum<Suit> = true;  // this is my enum

enum class Rank {
    six = 6, seven, eight, nine, ten, jack, queen, king, ace,
    first = six, last = ace
};
template<> 
constexpr bool is_my_enum<Rank> = true;  // this one is mine too

enum class Moo { moo = 0 };              // but this one isn't



// define functions for my enums only
template<class T>
using for_my_enums = std::enable_if_t<is_my_enum<T>, T>;

template<class T> 
for_my_enums<T>                        
operator++(T& r) {return r = (T)(static_cast<std::underlying_type_t<T>>(r) + 1);}

template<class T> 
for_my_enums<T>                        
operator++(T& r, int) { 
    auto k = r; 
    r = (T)(static_cast<std::underlying_type_t<T>>(r) + 1); 
    return k;
}

// ... more functions ...


int main()
{
   Suit a = Suit::spades;
   ++a;                   // ok
   Moo b = Moo::moo;
   ++b;                   // compilation error, it's not my enum
}

Answer 2

您可以使用模板化版本将其限制为所需的枚举

template <class E, std::enable_if_t<
    std::is_same_v<E, Suit> ||
    std::is_same_v<E, Rank>, bool> = true>
E& operator++(E& r, int) {
    return r = (E)(static_cast<std::underlying_type_t<E>>(r) + 1);
}

如何重用不同类型的运算符重载？

2 个答案: