Question

在我的代码中，我有一个这样的结构：

enum myEnum{ e1, e2, e3};

std::vector myVector<myEnum>;

...

myVector.push_back(e1);
...
myVector.push_back(e2);
...

我需要做的是，我必须定义另外两个枚举，如

enum myEnum2{ e4, e5, e6};
enum myEnum3{ e7, e8, e9};

我必须找到一种方法将所有这三个枚举存储在同一个向量中，让我使用这个向量，如：

myVector.push_back(e1); //element of myEnum
...
myVector.push_back(e4); //element of myEnum2
...

我生成的软件是一个中间件，我将在一个运行时中仅推回一种类型枚举的元素。

基本上我想要实现的是让我的矢量能够在里面存储三种不同类型的枚举，但是矢量的名称不会改变。我为什么要这个？因为代码中存在流分离并且基于分离，我不知道在每个运行时开始时将需要哪个枚举。

这是可能的，如果是这样，我怎么能实现这个目标？

编辑：谢谢大家的关注和答复，对不起，我忘了提供重要细节。我的工作代码中的枚举不可编辑。它们是由框架生成的，我不允许触摸它们。

提前致谢...

Answer 1

你可以这样做：

vector<variant<MyEnum1, MyEnum2>>

但是既然你说你在每次跑步中只有一种类型，那就更好了：

variant<vector<MyEnum1>, vector<MyEnum2>>

这更有效，更清楚地表达您的实际要求。但是，你也可以选择更简单的方法：

vector<int>

根据需要施放。

如果你想要一些最大类型安全且不使用C ++ 17的东西，你可以自己实现它：

struct EnumVector {
    enum Type { type1, type2 };
    EnumVector(Type type) : _type(type)
    void push_back(MyEnum1 val) {
        assert(_type == type1);
        _storage.push_back(val);
    }
    void push_back(MyEnum2 val) {
        assert(_type == type2);
        _storage.push_back(val);
    }
private:
    Type _type;
    std::vector<int> _storage;
};

Answer 2

每个枚举器都可以转换为整数值，并且可以存储该值。您还必须消除值中的重叠。所以：

enum myEnum { e1, e2, e3 };
enum myEnum2 { e4 = e3 + 1, e5, e6 };
enum myEnum3 { e7 = e6 + 1, e8, e9 };

std::vector<int> myVector;
myVector.push_back((int)e1);

当然，转换值并恢复它的细节应该封装在一个类中，而不是像push_back这里那样调用。

Answer 3

最类型安全的方法是声明一个C ++ 17 std::variant s的向量：

std::vector<std::variant<myEnum1, myEnum2, myEnum3>> myVector;

有关详细信息，请参阅std::variant。在C ++ 17之前，Boost提供equivalent template。

Answer 4

这是不可能的。

例如e1和e4和e7都具有相同的值，因此无法区分。

如果你可以逃避写作

enum myEnum2{ e4 = 3, e5, e6};

和

enum myEnum3{ e7 = 6, e8, e9};

然后至少然后枚举的值都不同，你可以使用std::vector<int>。但这并不完全令人满意，因为enum需要彼此“了解”，如果你理解了我的意思。

否则，您必须将类型灌输到您推送到矢量的每个元素中。

在同一向量中存储不同类型的枚举 - C ++

4 个答案: