Forward declaring an enum in C headers used in C++ code

Question

You can't forward declare an enum in C++, but you can in C.

For a C code-base that uses some C++ code, is there a way to use a forward declared enum in C that doesn't cause errors when that header is used in C++ (within an extern "C" {..} block)?

Example:

extern "C" {
    enum MyEnum;
}
int main() { return 0; }

GCC gives the error:

error: use of enum ‘MyEnum’ without previous declaration
  enum MyEnum;
       ^~~~~~

Clang also fails with:

error: ISO C++ forbids forward references to 'enum' types
        enum MyEnum;

To give some context, this is a mainly C code-base where a small C++ module happens to include a header for C code. I can do some hack to make C++ ignore the enum, but I would like to know if its possible for C++ to use C headers in this case.

Update: It's been noted the official C specification doesn't support this. However, it seems this is a de facto standard among some of the most widely used compilers: GCC, Clang, and Microsoft Visual C++.

This might be of help? https://stackoverflow.com/questions/71416/forward-declaring-an-enum-in-c — Omid CompSCI, Aug 24 '17 at 02:57
@omid-compsci - I saw this (infact linked to this in the question already). Which answer would help for C headers in C++? — ideasman42, Aug 24 '17 at 03:03
What kind of errors are you getting? Please provide a [mcve] and show the actual error messages — Remy Lebeau, Aug 24 '17 at 03:25
sounds like all you need is `enum MyEnum : int` or do you *need* it to to be compile-able as C? If that's the case, then you could use a macro to help you out — kmdreko, Aug 24 '17 at 03:39
Added some context as note at the bottom, it needs to compile as C, but some ifdef'ing could workaround I suppose. — ideasman42, Aug 24 '17 at 03:41
What? You cannot forward declare an enumeration in C. Only in C++. — StoryTeller - Unslander Monica, Aug 24 '17 at 05:29
@storyteller - its working here in C11, afaik it works in older C versions too. — ideasman42, Aug 24 '17 at 05:44
@ideasman42 - No it doesn't. You are using a compiler extension. http://coliru.stacked-crooked.com/a/fc2dcf239693e2df — StoryTeller - Unslander Monica, Aug 24 '17 at 05:48
@storyteller ah you're correct of course, it's just supported by gcc/clang/msvc so it's a more or less a de facto standard, noted in question. — ideasman42, Aug 24 '17 at 06:11
@ideasman42 - Until it's not. And there is no guarantee the interoperability with C++ is the same for every compiler. There is no standard C solution. "De-facto" standards mean nothing when cross compiling. — StoryTeller - Unslander Monica, Aug 24 '17 at 06:13

Vasiliy Galkin · Answer 1 · 2017-08-24T03:54:59.220

5

You can forward-declare enum in C++ starting from C++11. It's called "opaque declaration" rather than "forward declaration" because technically it results in a bit different effect: the size of the enum is known after its opaque declaration, while with the forward-declared types that's not the case.

However, from the daily perspective it's the same idea: you can just declare your enum and use it further in the code. From cppreference:

enum-key attr(optional) nested-name-specifier(optional) identifier enum-base(optional) ;(2) (since C++11)

2) Opaque enum declaration: defines the enumeration type but not its enumerators: after this declaration, the type is a complete type and its size is known. Note: an explicit specialization declaration of a scoped enumeration member of a class template is the only case where nested-name-specifier appears before identifier (since C++14)

edited Aug 24 '17 at 03:54

answered Aug 24 '17 at 03:46

Vasiliy Galkin

1,894
1
14
25

@ideasman42 Since header already contains #ifdef __cplusplus it just means that 2 different forward declarations should be present in the header - one inside if using C+ syntaxt - one inside #else using C syntax... – Artemy Vysotsky Aug 24 '17 at 04:23
@ArtemyVysotsky there's of course no guarantee that the C++ opaque declaration is compatibe with the quasi-C forward declaration. – n. m. could be an AI Aug 24 '17 at 06:34
@n.m - agree, This could be a problem during linkage – Artemy Vysotsky Aug 24 '17 at 07:02

score 5 · Answer 2 · edited Mar 10 '21 at 16:32

Forward declaration of enums in C just makes no sense. Enums in C only introduce integral enumeration constants. They don't introduce any types you would want to use. Each enum type is an unspecified integral type, compatible with all other integral types, so there isn't any type safety at all.

typedef enum e12 { ONE, TWO } e12;
typedef enum e34 { THREE, FOUR } e34;
int main () {
    e12 one = ONE;
    e34 three = THREE;
    one = three;
    three = ONE;
    return one + three;
}

This C program compiles cleanly with GCC on -Wall -Wextra -Wpedantic (it won't work as a C++ program of course).

So a useful portable cross-language solution would be

#ifdef __cplusplus
   enum MyEnum : int;
#else
   typedef int MyEnum; // 'enum MyEnum' would give no improvement over this
#endif

There is some advantage in using enums over ints - with GCC/Clang there are enum-aware warnings (`-Wenum-compare`, `-Wswitch-enum`), address sanitizer has `-fsanitize=enum` - while not guarantees, they can be used to uncover real errors in the code which you wouldn't detect using regular ints. — ideasman42, Aug 24 '17 at 11:29

score 1 · Answer 3 · answered Aug 24 '17 at 05:01

This can be done in C++11, (see @vasiliy-galkin's answer), an example of how this can work for shared C/C++ headers.

C header forward declaring MyEnum.

#ifdef __cplusplus
extern "C" {
#endif

enum MyEnum
#ifdef __cplusplus
: int
#endif
;

#ifdef __cplusplus
}
#endif

Forward declaring an enum in C headers used in C++ code

3 Answers3

Linked