为什么我可以引用仅前向声明的枚举成员

Question

For example, given the following:

// enum.h
enum class TestEnum: int {
    ONE,
    TWO,
    THREE
};

// function.h
enum class TestEnum: int;
int TestFunction(TestEnum te = TestEnum::THREE);

// function.cpp
#include "enum.h"
#include "function.h"

int TestFunction(TestEnum te) { 
    return 5;
}

In my eyes this should not compile because in function.h, with TestEnum only being forward declared, the compiler cannot know that TestEnum::THREE (which is used as a default argument for TestFunction ) is a valid member of the enum. And yet it does.

If I forward declare a class, I cannot access its members, but with enums it seems I can. Why is that? And is this something "legal" as per the standard, or did it just happen to work because of the way the compilers I tried (clang and gcc) are implemented?

Answer 1

Header files are not compiled. Source files are.

Within your function.cpp file, you first include enum.h, which contains TestEnum, and then you include function.h.

From the compiler point of view, it copy paste the content of those header files on top of your source file, so you do have access to the scoped value of the enum when your compiler arrives on the function.cpp file.

However, this would not work if the order of inclusion was first function.h and finally enum.h because the compiler could not know the content (here the scoped value of the enum) of TestEnum. This is the same behavior when you fast forward a class and try to access its members.