In C++: Is it possible to have a named enum be continued in a different file?

Question

For example:

Base class header file has:

enum FOO
{
FOO_A,
FOO_B,
FOO_C,
FOO_USERSTART
};

Then the derived class has:

enum FOO
{
FOO_USERA=FOO_USERSTART
FOO_USERB,
FOO_USERC
};

Just to be clear on my usage it is for having an event handler where the base class has events and then derived classes can add events. The derived classes event handler would check for it's events and if the event was not for it, then it would pass the event down to the base class.

class Base
{
public:
    virtual void HandleFoo(FOO event);
};

class Derived: public Base
{
public:
    void HandleFoo(FOO event);
};


void Base::HandleFoo(FOO event)
{
     switch(event)
     {
     case FOO_A:
       /* do stuff */
     break;
     case FOO_B:
       /* do stuff */
     break;
     case FOO_B:
       /* do stuff */
     break;
     }
 }

void Derived::HandleFoo(FOO event)
{
     switch(event)
     {
     case FOO_USERA:
       /* do stuff */
     break;
     case FOO_USERB:
       /* do stuff */
     break;
     case FOO_USERB:
       /* do stuff */
     break;
     default:
          /* not my event, must be for someone else */
          Base::HandleFoo(event);
     break;
     }
 }

Answer 1

Yes, as long as the enum's are both members of a class. If they weren't then they would be of the same type and the compiler would be very unhappy.

Answer 2

No. The compiler needs to be able to decide whether the enum fits in a char, short, int or long once it sees the }.

So if the base class header has

enum Foo {
  A,
  B,
  MAX = 1<<15
};

a compiler may decide the enum fits in 16 bits. It can then use that, e.g. when laying out the base class. If you were later able to add 1<<31 to the enum, the base class enum member would not be able to hold one of the enum values.

Answer 3

Yes, this works. To simplify your code a bit, I would suggest this, more common method of "extending" enums:

enum FOO // Base class's FOO
{
FOO_A,
FOO_B,
FOO_C,
FOO_BASE_MAX // Always keep this as the last value in the base class
};

enum FOO // Derived class's FOO
{
FOO_USERA=FOO_BASE_MAX+1, // Always keep this as the first value in the derived class
FOO_USERB,
FOO_USERC
};

You still need to watch out for "out of order" enums. (Example: FOO_A=15, FOO_B=11, etc.)