对于vc++，下面是关于前向声明和指定底层类型的测试:

下面的代码编译成功。

    typedef int myint;
    enum T ;
    void foo(T * tp )
    {
        * tp = (T)0x12345678;
    }
    enum T : char
    {
        A
    };

但是我得到了/W4的警告(/W3不招致这个警告)

使用非标准扩展名:为枚举“T”指定底层类型

vc++ (Microsoft (R) 32位C/ c++优化编译器版本15.00.30729.01 for 80x86)在上述情况下看起来有bug:

当看到枚举T时;VC假设枚举类型T使用默认的4字节int作为底层类型，因此生成的程序集代码为:

    ?foo@@YAXPAW4T@@@Z PROC                    ; foo
    ; File e:\work\c_cpp\cpp_snippet.cpp
    ; Line 13
        push    ebp
        mov    ebp, esp
    ; Line 14
        mov    eax, DWORD PTR _tp$[ebp]
        mov    DWORD PTR [eax], 305419896        ; 12345678H
    ; Line 15
        pop    ebp
        ret    0
    ?foo@@YAXPAW4T@@@Z ENDP                    ; foo

上面的汇编代码是从/Fatest中提取的。这不是我个人的猜测。

你看到了吗

mov DWORD PTR[eax], 305419896        ; 12345678H

行吗?

下面的代码片段证明了这一点:

    int main(int argc, char *argv)
    {
        union {
            char ca[4];
            T t;
        }a;
        a.ca[0] = a.ca[1] = a.[ca[2] = a.ca[3] = 1;
        foo( &a.t) ;
        printf("%#x, %#x, %#x, %#x\n",  a.ca[0], a.ca[1], a.ca[2], a.ca[3] );
        return 0;
    }

结果是:

0x78, 0x56, 0x34, 0x12

删除枚举T的前向声明，并将函数foo的定义移动到枚举T的定义之后:结果为OK:

上面的键指令变成:

mov BYTE PTR [eax]， 120;00000078 h

最终结果为:

0x78, 0x1, 0x1, 0x1

注意，该值没有被覆盖。

因此，在vc++中使用前向声明enum被认为是有害的。

顺便说一句，毫不奇怪，底层类型的声明语法与c#中的相同。在实践中，我发现在与内存有限的嵌入式系统通信时，通过将底层类型指定为char来节省三个字节是值得的。

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

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

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

事实上，没有所谓的提前宣布全体会议。由于枚举的定义不包含任何可能依赖于使用该枚举的其他代码的代码，因此在第一次声明枚举时完全定义它通常不是问题。

如果枚举的唯一用途是私有成员函数，则可以通过将枚举本身作为该类的私有成员来实现封装。枚举仍然必须在声明时完全定义，即在类定义中。然而，与在那里声明私有成员函数相比，这并不是一个更大的问题，也没有比这更糟糕的实现内部公开了。

如果您需要对实现细节进行更深层次的隐藏，您可以将其分解为一个抽象接口(仅由纯虚函数组成)和一个具体的、完全隐藏的实现(继承)接口的类。类实例的创建可以由工厂或接口的静态成员函数处理。这样，即使是真正的类名也不会被暴露，更不用说它的私有函数了。

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

首先，从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)的底层类型，看看会发生什么。

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)的建议

这样我们就可以forward declare enum

enum A: int;

详情请参阅连结。