3

我知道您可以将枚举的一部分用作函数的参数。我的问题是你可以使用整个枚举作为参数吗？

对于枚举：

enum exampleEnum {ONE,TWO,THREE}

通过部分枚举，我指的是：

function example(exampleEnum value){}

function example(ONE);

整个枚举是：

function example(enum value){}

function example(exampleEnum);

我想我要问的是我可以像传递数组一样传递枚举。至少这是我想我要问的。

编辑

我想要达到的效果是在多个类和子类之间共享一个枚举，而不是在我希望使用它的每个类/子类中重新定义它。我希望传递这些值而不是使用某种形式的全局变量。

编辑的编辑

更具体地说...我将枚举值用作关联数组的一种形式。

enum attribute{STR,DEX,CON,INT,WIS,CHA};
short int charAttributes[6];

charAttributes[STR] = sumValue;
charAttributes[DEX] = sumValue;
charAttributes[CON] = sumValue;
charAttributes[INT] = sumValue;
charAttributes[WIS] = sumValue;
charAttributes[CHA] = sumValue;

我想要的是传递枚举的完整名称、值以及要作为参数传递的所有内容。我想传递枚举以保留枚举名称和值以继续使用它们。

4

5 回答 5

5

exampleEnum 是一个类型，而不是一个值。将类型传递给函数的 C++ 方法是使用模板：

#include <iostream>
#include <ostream>
#include <typeinfo>
using namespace std;

enum exampleEnum {ONE,TWO,THREE};

template<typename T>
void example()
{
    cout << typeid(T).name() << endl;
}

int main()
{
    example<exampleEnum>();
    return 0;
}
于 2012-10-27T00:17:05.613 回答
1

如果您正确构造枚举值，则可以将值与按|位or运算符组合。

enum exampleEnum {One=0x01, TWO=0x02, THREE=0x04, FOUR=0x08}; // one bit set in each

example(ONE | TWO | FOUR);

在您的函数中，您需要单独测试每个值：

if (value & ONE) // ONE was passed
if (value & TWO) // TWO was passed, etc.
于 2012-10-27T00:13:48.050 回答
1

如果您的枚举是连续的（或者，如果您从未在枚举的定义中使用 =），那么有一个简单的技巧就是遍历枚举。

从这个开始：

enum /*class*/ Bob // class optional
{
  BeginBob,
  ONE = BeginBob, // the first entry needs an = Begin clause.
  TWO,
  THREE,
  EndBob
};

现在，您可以以与传递迭代器范围类似的方式传递一系列枚举值。

void doWork( Bob b );
void doWork( Bob begin, Bob end )
{
  for (Bob i = begin; i != end; i=ststic_cast<Bob>(i+1) )
    doWork( i );
}

开始和结束枚举值描述了一个半开范围，就像迭代器一样。因此，您可以像这样在整个枚举范围内调用 doWork：

void doWork( BeginBob, EndBob );

或者，您可以在所有内容上调用它，但不包括这样的三个：

void doWork( BeginBob, THREE );

它在 ONE 和 TWO 上调用 doWork。

于 2012-10-27T00:18:35.130 回答
1

我想要达到的效果是在多个类和子类之间共享一个枚举，而不是在我希望使用它的每个类/子类中重新定义它。我希望传递这些值而不是使用某种形式的全局变量。

嗯，你不必重新定义它。只需将枚举定义放在这些类之外。当你想在某个类中使用枚举值时，只需在该枚举中包含标题。

enum exampleEnum {ONE,TWO,THREE};

class Class1
{
   void foo()
   {
       exampleEnum t=TWO; // use enum values here
   }
};

class Class2
{
   void bar()
   {
       exampleEnum t=ONE; // and here
   }
};

class Class3
{
   void some()
   {
       exampleEnum t=THREE; // and even here
   }
};

编辑：

通过这样做，我将在我的类中添加一个我试图避免的依赖项。最好给班级一些东西，然后让班级接受一些东西。虽然我不能完全摆脱依赖，但我希望我能做到。

在这种情况下，您可以使用模板：

enum exampleEnum {ONE,TWO,THREE};
enum exampleEnumOther {RAZ,DVA,TRI};

template<typename Enum>
class Class1
{
   Enum member;
public:
   void foo(Enum p)
   {
       member=p;
   }
   template<typename OtherEnum>
   void bar(OtherEnum val)
   {
        OtherEnum use=val;
   }
};

int main()
{
    Class1<exampleEnum> t;
    t.foo(ONE);
    t.bar(TWO);
    t.bar(RAZ);
}

Class1 不依赖于任何特定的枚举。

于 2012-10-27T02:31:21.437 回答
0

您可以template <typename T> example在几个不同的枚举上制作和专门化它，允许您example(ONE)调用特定于exampleEnum然后的代码（假设enum otherEnum { EINS, ZWEI, DREI }您可以调用example(EINS)以获取特定于otherEnum.

于 2012-10-27T00:17:46.293 回答