CMake knows std 20, but g++9 doesn't

I have a project, which cannot be compiled by a fellow, due to an unknown call to a method from the std library.
I suspect that it's due to the fellow's g++ version (9.4.2) because the function was added in the std 20 standard. To test if that is the case I installed g++-9 (Version 9.5.0) and pointed the /usr/bin/g++ symbolic link to g++-9 and stumbled upon another issue (the question).

When I run

$ g++-9 -std=c++20
g++-9: error: unrecognized command line option ‘-std=20’; did you mean ‘-std=c2x’?
g++-9: fatal error: no input files
compilation terminated.

I get an error stating, that the std standard version 20 is unknown.
But when I try to generate the build files for an cmake project with the following line in the CMakeLists.txt:

target_compile_features(${PROJECT_NAME}
    PUBLIC
        cxx_std_20
)

I get no error. But when replacing the 20 with a 23:

target_compile_features(${PROJECT_NAME}
    PUBLIC
        cxx_std_23
)

I get the error

CMake Error at CMakeLists.txt:74 (target_compile_features):
  target_compile_features The compiler feature "cxx_std_23" is not known to
  CXX compiler

  "GNU"

  version 9.5.0.

Why is the C++20 standard unknown to g++, but known, when generating build files with cmake?

This is some sort of follow up Question:

When I try to compile my project I get the error:

error: ‘std::stringstream’ {aka ‘class std::__cxx11::basic_stringstream<char>’} has no member named ‘view’

and view was added in c++20. Can it be, that view was jet not added in c++2a?

Well... if your compiler is GCC 9.5.0, the reason why CMake says your compiler doesn't know about C++23 is because... it doesn't?

https://en.cppreference.com/w/cpp/compiler_support

The only thing that cppreference.com's compiler support table says that GCC v9 "knows" about C++23 is "Narrowing contextual conversions in static_assert and constexpr if"

And the reason why you get "g++-9: error: unrecognized command line option ‘-std=20’; did you mean ‘-std=c2x’?" for GCC 9.5.0 is probably just because C++20 support wasn't fully implemented yet. Again, look at the compiler support table in cppreference.com. There are lots of core language features and library features for C++20 that GCC didn't implement until version 10 (some even in version 9-13 Ex. "Atomic Compare-And-Exchange with padding bits")

So just do what it told you to do and take what you get, accepting that not all of the C++20 features will be available in GCC 9.5.0.

Or upgrade you compiler

The reason why it works with CMake's target_compile_features(... cxx_std_20) is because... CMake handles it.

See Modules/Compiler/GNU-C.cmake:

> cmake
> if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 9.1)
> set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x")
> set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
> endif()
>

and Modules/Compiler/GNU-CXX.cmake:

> cmake
> elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0)
> set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
> set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
> endif()
>

The name of the option for standard C++20 up to GCC 9 is -std=c++2a. According to man gcc:
> c++2a
>
> The next revision of the ISO C++ standard, planned for 2020. Support is highly experimental, and will almost certainly change in incompatible ways in future releases.

So not all features can be expected to be in there.

GCC has a tradition of providing aliases for the not yet released standards or those with incomplete support. GCC 9 only knows c++2a and that became an alias for c++20 with GCC 10.

CMake can handle this. When in doubt what CMake uses as standard (or any other option), take a look in the build directory in flags.make or build.ninja (depending on which generator you're using).