Kompilatorvarning (nivå 4) C4471

"uppräkning": en forward-deklaration av en oinskränkt uppräkning måste ha en underliggande typ (int antas)

Anmärkningar

En framåtriktad deklaration av en uppräkning utan scope hittades utan en typbeteckning för den underliggande typen. Visual C++ förutsätter int som standard att det är den underliggande typen för en uppräkning. Detta kan orsaka problem om en annan typ används i uppräkningsdefinitionen, till exempel om en annan explicit typ har angetts, eller om en annan typ implicit anges av en initialiserare. Du kan också ha problem med portabiliteten; andra kompilatorer antar inte att int är den underliggande typen av en uppräkning.

Den här varningen är inaktiverad som standard. du kan använda /Wall eller /wN4471 för att aktivera den på kommandoraden eller använda #pragma varning i källfilen.

Examples

I vissa fall är varningen falsk. Om en fördeklaration för en uppräkning kommer efter definitionen kan denna varning utlösas. Den här koden är till exempel giltig, även om den kan orsaka C4471:

// C4471a.cpp
// Compile with: cl /c /w14471 C4471a.cpp
enum Example { item = 0x80000000UL };
enum Example;    // Spurious C4471
// ...

I allmänhet är det säkert att använda den fullständiga definitionen för en oskopad uppräkning i stället för en framåtdeklaration. Du kan placera definitionen i en rubrikfil och inkludera den i källfiler som refererar till den. Detta fungerar i kod som skrivits för C++98 och senare. Vi rekommenderar den här lösningen för portabilitet och enkelt underhåll.

// C4471b.cpp
// Compile with: cl /c /w14471 C4471b.cpp
enum Example;    // C4471
// To fix, replace the line above with the enumeration definition:
// enum Example { item = 0x80000000UL };
// ...

I C++11 kan du lägga till en explicit typ till en oavgränsad uppräkning och dess framåtriktad deklaration. Vi rekommenderar den här lösningen endast om komplex logik för rubrikinkludering förhindrar användning av definitionen i stället för en framåtdeklaration. Den här lösningen kan leda till ett underhållsproblem: om du ändrar den underliggande typen som används för uppräkningsdefinitionen måste du också ändra alla framåtdeklarationer så att de matchar, eller så kan du ha tysta fel i koden. Du kan lägga forward-deklarationen i en headerfil för att minimera det här problemet.

Källfil C4471c.cpp:

// C4471c.cpp
// Client code for enumeration defined in C4471d.cpp
// Compile with: cl /c /w14471 C4471c.cpp C4471d.cpp
enum Example;    // C4471, int assumed
// To fix, replace the lines above with the forward declarations:
// enum Example : unsigned;
// ...

Källfil C4471d.cpp:

// C4471d.cpp
// Definition for enumeration used in C4471c.cpp
// Compile with: cl /c /w14471 C4471c.cpp C4471d.cpp
enum Example : unsigned { item = 0x80000000 }; // explicit type
// ...

Om du anger en explicit typ för en uppräkning rekommenderar vi att du även aktiverar varning C4369, som är aktiverad som standard. Detta identifierar fall där ett uppräkningsobjekt kräver en annan typ än den uttryckligen angivna typen.

Du kan ändra koden så att den använder en scoped enum, en funktionell egenskap som är ny i C++11. Både definitionen och all klientkod som använder uppräkningstypen måste ändras för att använda en avgränsad uppräkning. Vi rekommenderar att du använder en begränsad uppräkning om du har problem med namnområdesföroreningar, eftersom namnen på definierade uppräkningsobjekt är begränsade till uppräkningens omfattning. En annan funktion i en begränsad uppräkning är att dess medlemmar inte implicit kan konverteras till en annan integral- eller uppräkningstyp, vilket kan vara en källa till subtila buggar.

Källfil C4471e.cpp:

// C4471e.cpp
// Client code for scoped enumeration defined in C4471f.cpp
// Compile with: cl /c /w14471 C4471e.cpp C4471f.cpp
enum Example;    // C4471
// To fix, replace the line above with the forward declaration:
// enum class Example;
// ...

Källfil C4471f.cpp:

// C4471f.cpp
// Definition for scoped enumeration used in C4471e.cpp
// Compile with: cl /c /w14471 C4471e.cpp C4471f.cpp
enum class Example { item = 0 };
// ...