Question

在我的项目中，我正在使用多个枚举类，我需要根据我需要使用它们的方式轻松地进行转换。它们基本上描述了相同的东西，但命名方式不同，以使代码更容易使用。以下是枚举类：

enum class tetroType {
    None, I, O, T, J, L, S, Z
};

enum class gridBlock {
    Empty, Blue, Green, Orange, Purple, Red, Teal, Yellow
};

tetroType中的每个值对应于gridBlock中的值（fe tetroType :: I = gridBlock :: Teal），但第一个值包含有关tetronimo形状的信息（在tetronimo类中），第二个值包含有关颜色的信息。块（在网格类中）。我知道我可以使用一个枚举，但这样你就不会丢失任何信息。如果可能的话，我还需要把它转换成字符串。这就是我想用它的方式：

gridBlock grid = (gridBlock)tetroType::I;
string texture = (string)grid;

现在，我设置它的方式是这样的。每当我需要将一个枚举转换为另一个枚举或转换为字符串时，我就会在其他方法的中间使用此开关：

switch (type) {
case tetroType::I:
    block = gridBlock::Teal;
    break;
case tetroType::O:
    block = gridBlock::Yellow;
    break;
case tetroType::T:
    block = gridBlock::Purple;
    break;
case tetroType::J:
    block = gridBlock::Blue;
    break;
case tetroType::L:
    block = gridBlock::Orange;
    break;
case tetroType::S:
    block = gridBlock::Green;
    break;
case tetroType::Z:
    block = gridBlock::Red;
    break;
case tetroType::None:
    block = gridBlock::Empty;
}

Answer 1

您应该考虑将enum类作为整数重载（这是C ++ 11的功能）。

enum class tetroType : int {
    I = 1, O = 2, T = 3, J = 4, L = 5, S = 6, Z = 7, NONE
};

enum class gridBlock : int {
    Blue = 1, Green = 2, Orange = 3, Purple = 4, Red = 5, Teal = 6, Yellow = 9, EMPTY
};

您可以在此处使用ether C样式类型转换或static_cast编写基本转换

gridBlock ConvertTetro(tetroType type){
    return static_cast<gridBlock>(static_cast<int>(type));
}

gridBlock ConvertTetro(tetroType type){
    return (gridBlock)((int)((type)));
}

这将使任何网格块匹配相同的四字符型，如果没有匹配的类型，则默认为gridBlock :: EMPTY。如果需要，此功能应该很容易弄清楚如何进行其他选择。从这里开始，您需要在两个之间匹配int值。

您还可以使用

将char值用作char文字（'A'，'b'，'！'）

enum class enumName : char

只要两个基本类型都可以使用

Answer 2

简单回答：不要使用enum class，而是使用普通enum，它们可以隐式转换为基础类型（默认int）。

在C ++ 11中，enum class是一个强大的别名， HAS 可以从中进行投放。

Answer 3

如果您接受这样一个事实，即您必须将两个枚举中的一个的定义与另一个保持一致，以便每个gridBlock从tetroType获取一个值，那么您可以覆盖operator==在比较中无缝地使用它们并覆盖不同的运算符（例如<<=）以模仿不同类型之间的赋值。

这样的事情：

#include <iostream>
#include <type_traits>
#include <cassert>

using namespace std;

enum class tetroType {
    None, I, O, T, J, L, S, Z
};

enum class gridBlock {
    Empty = static_cast<std::underlying_type<tetroType>::type>(tetroType::None), 
    Blue = static_cast<std::underlying_type<tetroType>::type>(tetroType::I), 
    Green = static_cast<std::underlying_type<tetroType>::type>(tetroType::O), 
    Orange = static_cast<std::underlying_type<tetroType>::type>(tetroType::T), 
    Purple = static_cast<std::underlying_type<tetroType>::type>(tetroType::J), 
    Red = static_cast<std::underlying_type<tetroType>::type>(tetroType::L), 
    Teal = static_cast<std::underlying_type<tetroType>::type>(tetroType::S), 
    Yellow = static_cast<std::underlying_type<tetroType>::type>(tetroType::Z)
};

bool operator==(const tetroType& t, const gridBlock& g) { return static_cast<gridBlock>(t) == g; }
bool operator==(const gridBlock& g, const tetroType& t) { return static_cast<gridBlock>(t) == g; }

bool operator!=(const tetroType& t, const gridBlock& g) { return static_cast<gridBlock>(t) != g; }
bool operator!=(const gridBlock& g, const tetroType& t) { return static_cast<gridBlock>(t) != g; }

gridBlock& operator<<=(gridBlock& g, tetroType t) { g = static_cast<gridBlock>(t); return g; }
tetroType& operator<<=(tetroType& t, gridBlock g) { t = static_cast<tetroType>(g); return t; }

int main() {
  tetroType t1 = tetroType::I, t2 = tetroType::O;
  gridBlock g1 = gridBlock::Blue, g2 = gridBlock::Green;

  gridBlock g3;
  g3 <<= t1;
  tetroType t3;
  t3 <<= g2;


  assert(t1 == g1);
  assert(t1 != g2);
  assert(g3 == t1);
  assert(t3 == g2);

    return 0;
}

虽然这个解决方案很简洁，但它非常神秘而且模糊不清，所以你最好清楚地记录这个行为。但总的来说，enum class覆盖operator<<=之类的运算符是非常安全的，因为它们在任何情况下都没有定义。

请注意，您可以在值之间使用自定义映射，但如果您不需要它们，因为您可以使用另一个值初始化一个值，则无需手动映射它们。

为枚举类重载强制转换运算符

3 个答案: