可以将枚举包装在结构体中，添加一些构造函数和类型转换，然后前向声明结构体。

#define ENUM_CLASS(NAME, TYPE, VALUES...) \
struct NAME { \
    enum e { VALUES }; \
    explicit NAME(TYPE v) : val(v) {} \
    NAME(e v) : val(v) {} \
    operator e() const { return e(val); } \
    private:\
        TYPE val; \
}

这似乎是有效的: http://ideone.com/TYtP2

在c++中向前声明是非常有用的，因为它极大地加快了编译时间。你可以在c++中前向声明一些东西，包括:结构，类，函数，等等…

但是你能在c++中前向声明一个枚举吗?

不，你不能。

但为什么不允许呢?如果允许的话，你可以在头文件中定义枚举类型，在源文件中定义枚举值。听起来应该是允许的，对吧?

错了。

在c++中，没有像c# (int)中那样的enum默认类型。在c++中，你的枚举类型将由编译器决定为适合你的枚举值范围的任何类型。

这是什么意思?

这意味着在定义了枚举的所有值之前，不能完全确定枚举的底层类型。这意味着您不能将枚举的声明和定义分开。因此，在c++中不能前向声明枚举。

ISO c++标准S7.2.5:

The underlying type of an enumeration is an integral type that can represent all the enumerator values defined in the enumeration. It is implementation-defined which integral type is used as the underlying type for an enumeration except that the underlying type shall not be larger than int unless the value of an enumerator cannot fit in an int or unsigned int. If the enumerator-list is empty, the underlying type is as if the enumeration had a single enumerator with value 0. The value of sizeof() applied to an enumeration type, an object of enumeration type, or an enumerator, is the value of sizeof() applied to the underlying type.

在c++中，可以使用sizeof操作符确定枚举类型的大小。枚举类型的大小是其基础类型的大小。通过这种方式，您可以猜测编译器正在为枚举使用哪种类型。

如果你像这样显式地指定枚举的类型会怎样:

enum Color : char { Red=0, Green=1, Blue=2};
assert(sizeof Color == 1);

然后你可以向前声明你的枚举吗?

不。但为什么不呢?

指定枚举的类型实际上不是当前c++标准的一部分。它是一个vc++扩展。不过，它将成为c++ 0x的一部分。

源

enum不能被前向声明的原因是，如果不知道值，编译器就不能知道enum变量所需的存储空间。c++编译器可以根据包含所有指定值所需的大小指定实际存储空间。如果所有可见的都是前向声明，那么翻译单元就不能知道所选择的存储大小是什么——它可能是char型、int型或其他类型。

ISO c++标准第7.2.5节:

The underlying type of an enumeration is an integral type that can represent all the enumerator values defined in the enumeration. It is implementation-defined which integral type is used as the underlying type for an enumeration except that the underlying type shall not be larger than int unless the value of an enumerator cannot fit in an int or unsigned int. If the enumerator-list is empty, the underlying type is as if the enumeration had a single enumerator with value 0. The value of sizeof() applied to an enumeration type, an object of enumeration type, or an enumerator, is the value of sizeof() applied to the underlying type.

由于函数的调用者必须知道参数的大小才能正确地设置调用堆栈，因此枚举列表中的枚举数必须在函数原型之前知道。

更新:

在c++ 0X中，已经提出并接受了向前声明enum类型的语法。你可参阅前向申报枚举数(修订版3)的建议

可以将枚举包装在结构体中，添加一些构造函数和类型转换，然后前向声明结构体。

#define ENUM_CLASS(NAME, TYPE, VALUES...) \
struct NAME { \
    enum e { VALUES }; \
    explicit NAME(TYPE v) : val(v) {} \
    NAME(e v) : val(v) {} \
    operator e() const { return e(val); } \
    private:\
        TYPE val; \
}

这似乎是有效的: http://ideone.com/TYtP2

我只是注意到，原因实际上是，在向前声明后，enum的大小还不知道。你使用一个结构的前向声明来传递一个指针，或者从一个在前向声明的结构定义本身中引用的地方引用一个对象。

向前声明枚举不是很有用，因为人们希望能够按值传递枚举。你甚至不能有指向它的指针，因为我最近被告知一些平台使用不同大小的指针用于char和int或long。所以这一切都取决于枚举的内容。

当前的c++标准明确禁止这样做

enum X;

(在7.1.5.3/1)。但下一个c++标准将于明年发布，允许以下功能，这让我确信问题实际上与底层类型有关:

enum X : int;

它被称为“不透明”枚举声明。您甚至可以在以下代码中按值使用X。并且它的枚举数可以稍后在枚举的重新声明中定义。参见当前工作草案中的7.2。

我对你问题的解决方案是:

1 -使用int代替enums:在CPP文件的匿名命名空间中声明你的int(而不是在头文件中):

namespace
{
   const int FUNCTIONALITY_NORMAL = 0 ;
   const int FUNCTIONALITY_RESTRICTED = 1 ;
   const int FUNCTIONALITY_FOR_PROJECT_X = 2 ;
}

因为你的方法是私有的，所以没有人会乱动数据。你甚至可以进一步测试是否有人发送了无效的数据:

namespace
{
   const int FUNCTIONALITY_begin = 0 ;
   const int FUNCTIONALITY_NORMAL = 0 ;
   const int FUNCTIONALITY_RESTRICTED = 1 ;
   const int FUNCTIONALITY_FOR_PROJECT_X = 2 ;
   const int FUNCTIONALITY_end = 3 ;

   bool isFunctionalityCorrect(int i)
   {
      return (i >= FUNCTIONALITY_begin) && (i < FUNCTIONALITY_end) ;
   }
}

2:像在Java中那样，用有限的const实例化创建一个完整的类。向前声明类，然后在CPP文件中定义它，并只实例化类似枚举的值。我在c++中做了类似的事情，结果并不像预期的那样令人满意，因为它需要一些代码来模拟枚举(复制构造，operator =等)。

3:如前所述，使用私有声明的enum。尽管用户将看到它的完整定义，但它不能使用它，也不能使用私有方法。因此，您通常可以修改枚举和现有方法的内容，而不需要使用您的类重新编译代码。

我猜答案不是3就是1。