Visual studio 2010 unscoped opaque-enum-declarartion with omitted base - c++

Question

In the following code there are no errors or warnings at compile/link-time
enum E;
enum E;
int _tmain(int argc, _TCHAR* argv[]){ }
Is it VS2010 bug?

Answer 1

Your code compiles with VC++ 2010 and later by virtue of MS language extensions
that you can disable with the compiler flag /Za.
At first sight,
enum E;
enum E;
looks just like two forward declarations of enum E. In that light, the duplication does not appear
relevant. N forward declarations of something are no more or less legal than one, so the effect of
enabling the MS extensions (/Ze) would appear to include enabling forward enum declarations,
which are illegal per C++03 or C++11.
But that appearance is misleading, as the following program shows:
#include <iostream>
enum E;
//enum E;
enum E e;
int main()
{
std::cout << (e == 0) << std::endl;
return e;
}
This also compiles clean with VC++ 2010 or later, proving that
the compiler parses enum E; not as forward declaration of E but as a definition.
The language extension here is that enum E;, on first sight, is equated with enum E {}.
If we uncomment //enum E; in the program, it still compiles clean, showing that on second sight
and subsequently, enum E; is not again parsed as a definition, just as a redeclaration of E.
VC++ 2013 supports the C++11 concepts of scoped and based enums. With extensions disabled,
it will compile and reject declarations as indicated by this piece of code:
enum UnscopedBasedEnum : int; // :)
enum UnscopedBasedEnum : int; // :)
UnscopedBasedEnum ube; // :)
enum struct ScopedBaselessEnum; // :)
enum struct ScopedBaselessEnum; // :)
ScopedBaselessEnum sbe;
//enum UnscopedBaseLessEnum; // :(
all of which is C++11 compliant.
The declarations of ube and sbe prove, however, that none of the
declarations here is a forward declaration, if foward declaration has the customary meaning
of declaration of an incomplete type. If UnscopedBasedEnum|ScopedBaselessEnum
was an incomplete type in these declarations then the declaration of ube|sbe would
would declare an object of incomplete type, and would not compile. Per C++11, the declarations
of UnscopedBasedEnum and ScopedBaselessEnum are opaque enum declarations, meaning
that no enumerator-list is present or implied. But they nevertheless declare complete
types: p 7.2.3
An opaque-enum-declaration is either a redeclaration of an enumeration in the current scope or a declaration
of a new enumeration. [ Note: An enumeration declared by an opaque-enum-declaration has fixed underlying
type and is a complete type. The list of enumerators can be provided in a later redeclaration with an enum-specifier.
—end note ]

Answer 2

What you are doing here is enum forward declaration. Some compilers (like VS) provide language extensions which enable this behaviour for pre-C++11 standard. You can verify this by disabling the language extensions in your project settings which will result in a compiler error. G++ does not have such extensions but it should compile your code with -std=c++11 after adding size specifiers or when using enum class instead.
Valid in Visual Studio with compiler extensions enabled
enum E;
enum E;
Valid in all compilers supporting C++11
enum class E;
enum class E;
// or
enum E : short;
enum E : short;