转发声明C ++中的枚举

我正在尝试执行以下操作：

enum E;

void Foo(E e);

enum E {A, B, C};

编译器拒绝。我对Google进行了快速浏览，共识似乎是“您无法做到”，但我不明白为什么。谁能解释？

澄清2：之所以这样做，是因为我在使用所述枚举的类中有私有方法，并且我不希望公开枚举的值-因此，例如，我不希望任何人知道E定义为

enum E {
    FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X
}

因为X项目不是我希望用户知道的东西。

因此，我想转发声明该枚举，以便将私有方法放在头文件中，在cpp内部声明该枚举，然后将构建的库文件和头分发给其他人。

至于编译器-它是GCC。

无法向前声明enum的原因是，在不知道值的情况下，编译器无法知道enum变量所需的存储空间。允许C ++编译器根据包含所有指定值所需的大小来指定实际存储空间。如果仅可见的是前向声明，则转换单元将无法知道将选择什么存储大小-它可以是char或int或其他类型。

根据ISO C ++标准的7.2.5节：

枚举的基础类型是整数类型，可以表示枚举中定义的所有枚举器值。由实现方式定义，哪种整数类型用作枚举的基础类型，int除非基础类型不得大于，除非枚举器的值不能适合intor unsigned int。如果枚举数列表为空，则基础类型就像枚举有一个值为0的单个枚举数。sizeof()应用于枚举类型，枚举类型的对象或枚举类型的值就是sizeof()应用于枚举类型的值。基础类型。

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

更新：在C ++ 0X中，已经提出并接受了用于声明枚举类型的语法。您可以在http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf上看到该提案。

从C ++ 11开始，可以向前声明枚举。以前，无法向前声明枚举类型的原因是因为枚举的大小取决于其内容。只要应用程序指定了枚举的大小，就可以向前声明：

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

鉴于最近的发展，我在这里添加最新的答案。

您可以在C ++ 11中向前声明一个枚举，只要您同时声明其存储类型即可。语法如下所示：

enum E : short;
void foo(E e);

....

enum E : short
{
    VALUE_1,
    VALUE_2,
    ....
}

实际上，如果函数从不引用枚举的值，则此时根本不需要完整的声明。

G ++ 4.6及更高版本（-std=c++0x或-std=c++11更高版本）支持此功能。Visual C ++ 2013支持此功能；在较早的版本中，它具有某种我尚未弄清楚的非标准支持-我发现一些建议，即简单的正向声明是合法的，但YMMV。

在C ++中进行正向声明非常有用，因为它可以大大加快编译时间。您可以向前声明用C几件事情++包括：struct，class，function，等...

但是您可以enum在C ++中向前声明一个吗？

不，你不能。

但是为什么不允许它呢？如果允许，则可以enum在头文件中定义类型，并enum在源文件中定义值。听起来应该允许吧？

错误。

在C ++中，没有默认类型，enum例如C＃（int）。在C ++中enum，编译器会将您的类型确定为适合您的值范围的任何类型enum。

那是什么意思？

这意味着，enum直到您拥有已enum定义的所有值，才能完全确定其基础类型。您无法区分哪个人的声明和定义enum。因此，您不能enum在C ++中转发声明。

ISO C ++标准S7.2.5：

枚举的基础类型是整数类型，可以表示枚举中定义的所有枚举器值。由实现方式定义，哪种整数类型用作枚举的基础类型，int除非基础类型不得大于，除非枚举器的值不能适合intor unsigned int。如果枚举数列表为空，则基础类型就像枚举有一个值为0的单个枚举数。sizeof()应用于枚举类型，枚举类型的对象或枚举类型的值就是sizeof()应用于枚举类型的值。基础类型。

您可以使用sizeof运算符确定C ++中枚举类型的大小。枚举类型的大小是其基础类型的大小。这样，您就可以猜出编译器正在使用哪种类型enum。

如果您这样明确指定类型，该怎么办enum：

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

然后，您可以转发声明您的enum吗？

不，为什么不呢？

指定an的类型enum实际上不是当前C ++标准的一部分。它是VC ++扩展。不过它将成为C ++ 0x的一部分。

资源

[我的回答是错误的，但由于评论有用，所以将其留在此处]。

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

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

确实没有向前枚举的声明。由于枚举的定义不包含任何可能依赖于使用该枚举的其他代码的代码，因此在首次声明枚举时，完全定义枚举通常不是问题。

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

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

只是指出原因实际上是在向前声明后还不知道枚举的大小。好吧，您可以使用结构的前向声明来传递指针或从前向声明的结构定义本身所引用的位置引用对象。

前向声明枚举不会太有用，因为人们希望能够传递枚举值。您甚至都没有指向它的指针，因为最近我被告知某些平台对char使用与int或long不同的大小的指针。因此，这完全取决于枚举的内容。

当前的C ++标准明确禁止做类似的事情

enum X;

（在中7.1.5.3/1）。但接下来的C ++标准，由于明年允许以下，这使我确信实际问题具有与基本型的事：

enum X : int;

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

我会这样：

[在公共标题中]

typedef unsigned long E;

void Foo(E e);

[在内部标题中]

enum Econtent { FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X,
  FORCE_32BIT = 0xFFFFFFFF };

通过添加FORCE_32BIT，我们确保Econtent编译为long，因此它可以与E互换。

如果您确实不希望枚举出现在头文件中并确保仅由私有方法使用，则一种解决方案是采用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有很多优点，其中之一是它可以将类头与实现分离，而在更改一个类的实现时无需重新编译其他类。另一个是因为头很简单，所以可以加快编译时间。

但是使用起来很痛苦，因此您应该真正问自己，是否只是在标头中将枚举声明为私有会带来很多麻烦。

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

#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

似乎无法在GCC中预先声明！

这里有趣的讨论

自从出现这种情况以来，存在一些异议（因此），因此这是标准中的一些相关内容。研究表明，该标准并未真正定义前向声明，也未明确声明枚举可以或不能被前向声明。

首先，来自dcl.enum，第7.2节：

枚举的基础类型是整数类型，可以表示枚举中定义的所有枚举器值。由实现定义的，哪种整数类型用作枚举的基础类型，除非该基础类型不得大于int，除非枚举器的值不能适合int或unsigned int。如果枚举数列表为空，则基础类型就像枚举有一个值为0的单个枚举数。应用于枚举类型，枚举类型的对象或枚举数的sizeof（）的值是的值。 sizeof（）应用于基础类型。

因此，枚举的基本类型是实现定义的，只有一个小限制。

接下来，我们转到关于“不完整类型”（3.9）的部分，该部分与关于前向声明的任何标准都差不多：

已声明但尚未定义的类，或者大小未知或元素类型不完整的数组是未完全定义的对象类型。

类类型（例如“类X”）在翻译单元中可能在某一时刻不完整，并在以后完成。类型“ X类”在两点上都是相同的类型。数组对象的声明类型可能是类类型不完整的数组，因此不完整。如果类类型稍后在翻译单元中完成，则数组类型变为完整；这两个点的数组类型是相同的类型。数组对象的声明类型可能是大小未知的数组，因此在翻译单元中的某个点上是不完整的，并在以后完成。这两个点的数组类型（“ T的未知边界数组”和“ N T的数组”）是不同的类型。指向未知大小的数组的指针的类型，或由typedef声明定义为未知大小的数组的类型，

因此，该标准几乎列出了可以向前声明的类型。枚举不存在，因此编译器作者通常将前向声明视为该标准所不允许的，因为其基础类型的大小可变。

这也是有道理的。通常在按值情况下引用枚举，并且在这些情况下，编译器确实确实需要知道存储大小。由于存储大小是由实现定义的，因此许多编译器可能只选择对每个枚举的基础类型使用32位值，此时可以向前声明它们。一个有趣的实验可能是尝试在Visual Studio中声明一个枚举，然后强迫它使用大于sizeof（int）的基础类型，如上所述，以查看发生了什么。

对于VC，这是关于前向声明和指定基础类型的测试：

1. 下面的代码编译正常。

    typedef int myint;
    枚举T;
    无效foo（T * tp）
    {
        * tp =（T）0x12345678;
    }
    枚举T：char
    {
        一个
    };

但是得到了/ W4的警告（/ W3不会引发此警告）

警告C4480：使用了非标准扩展名：为枚举“ T”指定基础类型

2. 在上述情况下，VC（Microsoft（R）32位C / C ++优化编译器版本15.00.30729.01（对于80x86））看起来有问题：

   • 当看到枚举T时；VC假定枚举类型T使用默认的4字节int作为基础类型，因此生成的汇编代码为：

    ？foo @@ YAXPAW4T @@@ Z PROC; 富
    ; 文件e：\ work \ c_cpp \ cpp_snippet.cpp
    ; 13号线
        推息
        mov ebp，esp
    ; 14号线
        mov eax，DWORD PTR _tp $ [ebp]
        mov DWORD PTR [eax]，305419896; 12345678H
    ; 15号线
        流行音乐
        ret 0
    ？foo @@ YAXPAW4T @@@ ZENDP; 富

上面的汇编代码是直接从/Fatest.asm中提取的，不是我个人的猜测。您看到mov DWORD PTR [eax]，305419896; 12345678H线？

以下代码片段证明了这一点：

    int main（int argc，char * argv）
    {
        工会{
            char ca [4];
            吨
        }一个;
        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]） ;
        返回0;
    }

结果是：0x78、0x56、0x34、0x12

• 在删除枚举T的前向声明并在枚举T的定义之后移动函数foo的定义之后：结果正常：

上面的关键说明变为：

mov BYTE PTR [eax]，120；00000078H

最终结果是：0x78、0x1、0x1、0x1

请注意该值不会被覆盖

因此，在VC中使用枚举的前向声明被认为是有害的。

顺便说一句，不足为奇的是，用于声明基础类型的语法与C＃中的语法相同。在实践中，我发现值得与嵌入式系统对话时将底层类型指定为char来节省3个字节，这是受内存限制的。

在我的项目中，我采用了命名空间绑定枚举技术来处理enum旧版和第三方组件中的。这是一个例子：

forward.h：

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

枚举

// 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.h：

#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）需要包含enum.h。

我对您的问题的解决方案是：

1-使用int代替枚举：在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：创建一个有限的const实例化的完整类，就像在Java中一样。转发声明该类，然后在CPP文件中定义它，并仅实例化枚举式值。我在C ++中做了类似的事情，结果却不尽如人意，因为它需要一些代码来模拟枚举（复制构造，运算符=等）。

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

我的猜测是解决方案3或1。

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

因此，编译器甚至不能让您向前声明枚举并向其指向用户，因为即使在那儿，它也需要枚举的大小。

您定义一个枚举以将类型的元素的可能值限制为一个有限的集合。此限制将在编译时强制执行。

在向前声明您稍后将使用“有限集”这一事实时，不会添加任何值：后续代码需要知道可能的值，以便从中受益。

虽然编译器被关注的枚举类型的大小，意图当你向前声明它枚举的丢失。