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

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

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

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

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

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

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

这里有一个有趣的讨论。

从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.

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

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。