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

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

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

在GCC中似乎不能前向声明!

这里有一个有趣的讨论。

在我的项目中，我采用了命名空间限定枚举技术来处理来自遗留组件和第三方组件的枚举。这里有一个例子:

forward.h:

namespace type
{
    class legacy_type;
    typedef const legacy_type& type;
}

enum.h:

// May be defined here or pulled in via #include.
namespace legacy
{
    enum evil { x , y, z };
}


namespace type
{
    using legacy::evil;

    class legacy_type
    {
    public:
        legacy_type(evil e)
            : e_(e)
        {}

        operator evil() const
        {
            return e_;
        }

    private:
        evil e_;
    };
}

foo。:

#include "forward.h"

class foo
{
public:
    void f(type::type t);
};

foo.cc:

#include "foo.h"

#include <iostream>
#include "enum.h"

void foo::f(type::type t)
{
    switch (t)
    {
        case legacy::x:
            std::cout << "x" << std::endl;
            break;
        case legacy::y:
            std::cout << "y" << std::endl;
            break;
        case legacy::z:
            std::cout << "z" << std::endl;
            break;
        default:
            std::cout << "default" << std::endl;
    }
}

main.cc:

#include "foo.h"
#include "enum.h"

int main()
{
    foo fu;
    fu.f(legacy::x);

    return 0;
}

注意foo.h头文件不需要知道任何关于legacy::evil的信息。只有使用遗留类型legacy::evil(这里:main.cc)的文件才需要包含枚举.h。

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

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

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

enum X;

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

enum X : int;

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

对于iOS/Mac/Xcode上面临这种情况的人，

如果你在XCode中用Objective-C集成C/ c++头文件时遇到这个问题，只需将文件扩展名从。mm更改为。m即可