typedef'ing an enum does not make the enum-values visible

Question

I have a class in which I have an enumeration, defined like this:

class X
   {
   public:
      enum Direction {DIR_LEFT, DIR_RIGHT};
   };

Now I want this enumeration to be reused in another class, like this:

class Y
   {
   public:
      typedef X::Direction Direction;
   };

As expected, using Y::Direction works correctly, e.g.:

void myFunction (Y::Direction dir)
{
}

But the values within the enumeration does not seem to be 'copied' together with the typedef. If I write the following, I get compilation errors:

myFunction (Y::DIR_LEFT);

Instead, I have to refer to the original place of the enumeration again, like this:

myFunction (X::DIR_LEFT);

Which defeats my purpose of typdefing the enumeration.

The only solution I see is to move the enumeration out of class X, and putting it in another class (e.g. MyEnums), so it can be reused by X and Y (although they should still use MyEnums::DIR_LEFT and MyEnums::DIR_RIGHT), but at least the code does not depend on class X anymore.

Why are the enumeration values itself no exposed via the typedef?

Are there any other patterns to manage enumerations in different classes?

Answer 1

Unfortunately C++ doesn't introduce a new scope with an enum although C++0x is improving things.

Practically this means that you can't typedef an enum and get the enumerated values as well.

What you can do is use a nested struct with the name you want for the enum and typedef THAT.

class X
{
public:
    struct Direction { enum EnumType {LEFT, RIGHT}; };
};

class Y
{
public:
    typedef X::Direction Direction;
};

Now you can do: myFunction (Y::Direction::LEFT);

The purpose of the nested struct is to create a "fake" scope to holld both the enum name and its values.