从c++ 11开始，枚举的前向声明是可能的。以前，枚举类型不能前向声明的原因是枚举的大小取决于它的内容。只要应用程序指定了枚举的大小，它就可以被前向声明:

enum Enum1;                     // Illegal in C++03 and C++11; no size is explicitly specified.
enum Enum2 : unsigned int;      // Legal in C++11.
enum class Enum3;               // Legal in C++11, because enum class declarations have a default type of "int".
enum class Enum4: unsigned int; // Legal C++11.
enum Enum2 : unsigned short;    // Illegal in C++11, because Enum2 was previously declared with a different type.

因为这个被撞了(某种程度上)，所以有一些不同意见，所以这里有一些来自标准的相关比特。研究表明，该标准并没有真正定义前向声明，也没有明确说明枚举可以或不可以前向声明。

首先，从dcl。Enum，第7.2节:

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.

因此枚举的底层类型是由实现定义的，有一个较小的限制。

接下来，我们翻到关于“不完整类型”的章节(3.9)，这是关于前向声明的最接近的标准:

A class that has been declared but not defined, or an array of unknown size or of incomplete element type, is an incompletely-defined object type. A class type (such as "class X") might be incomplete at one point in a translation unit and complete later on; the type "class X" is the same type at both points. The declared type of an array object might be an array of incomplete class type and therefore incomplete; if the class type is completed later on in the translation unit, the array type becomes complete; the array type at those two points is the same type. The declared type of an array object might be an array of unknown size and therefore be incomplete at one point in a translation unit and complete later on; the array types at those two points ("array of unknown bound of T" and "array of N T") are different types. The type of a pointer to array of unknown size, or of a type defined by a typedef declaration to be an array of unknown size, cannot be completed.

在这里，标准列出了可以前向声明的类型。Enum不存在，因此编译器作者通常认为标准不允许前向声明，因为其底层类型的大小是可变的。

这也说得通。枚举通常在按值的情况下引用，编译器确实需要知道这些情况下的存储大小。由于存储大小是实现定义的，许多编译器可能只选择为每个枚举的底层类型使用32位值，这时就可以转发声明它们。

一个有趣的实验可能是尝试在Visual Studio中向前声明枚举，然后强制它使用大于sizeof(int)的底层类型，看看会发生什么。

[我的答案是错误的，但我把它留在这里，因为评论很有用]。

前向声明枚举是非标准的，因为指向不同枚举类型的指针不能保证大小相同。编译器可能需要查看定义才能知道该类型可以使用哪些大小指针。

实际上，至少在所有流行的编译器上，指向枚举的指针的大小是一致的。例如，枚举的前向声明是由Visual c++作为语言扩展提供的。

因为枚举可以是不同大小的整型(编译器决定给定枚举的大小)，所以指向枚举的指针也可以是不同大小的，因为它是整型类型(例如，在某些平台上字符的指针大小不同)。

所以编译器甚至不能让你前向声明枚举并使用指向它的指针，因为即使在那里，它也需要枚举的大小。

在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的一部分。

源

如果您真的不希望枚举出现在头文件中，并确保它只被私有方法使用，那么一种解决方案是遵循PIMPL原则。

这是一种确保在头文件中隐藏类内部信息的技术，只需声明:

class A
{
public:
    ...
private:
    void* pImpl;
};

然后在实现文件(.cpp)中声明一个类，该类将作为内部结构的表示。

class AImpl
{
public:
    AImpl(A* pThis): m_pThis(pThis) {}

    ... all private methods here ...
private:
    A* m_pThis;
};

你必须在类构造函数中动态创建实现，并在析构函数中删除它，当实现公共方法时，你必须使用:

((AImpl*)pImpl)->PrivateMethod();

使用PIMPL有优点。一个是它将类头与其实现解耦，并且在更改一个类实现时不需要重新编译其他类。另一个原因是加快了你的编译时间，因为你的头文件太简单了。

但它使用起来很痛苦，所以你应该问问自己，仅仅在头文件中将枚举声明为private是否有那么大的麻烦。