Compiler still not using C++20

[lefebvresam]

When you use typical C++20 features like:

typedef std::map<const char*, Widget*, decltype([](const char* str1, const char* str2){ return std::strcmp(str1, str2) < 0; }) > widget_level_map;

Then you get:

[build] /home/sam/git/hmipanel/source/widgets/widget.h:30:49: error: lambda-expression in unevaluated context only available with '-std=c++20' or '-std=gnu++20'

You have to do the 'old' way:

struct StrCompare : public std::less<bool(const char*, const char*)> {
    constexpr bool operator() (const char* str1, const char* str2) const {
        return std::strcmp(str1, str2) < 0;
    }
};
class Widget;
typedef std::map<const char*, Widget*, StrCompare> widget_level_map; // for each name a widget pointer

Another option is to use string objects instead of string literals, which compare the content of the string instead of the pointer address (which points to the same literal when used more than once in your code as a optimalization but does not allow dynamic update). However my feeling is that it works less efficiënt.

typedef std::map<std::string, Widget*> widget_level_map;

[JohnK1987]

Your probably need to look into profiles settings

mbed-os/tools/profiles/debug.json

Lines 2 to 17 in 2deef5a

	"GCC_ARM": {
	"common": ["-Wall", "-Wextra",
	"-Wno-unused-parameter", "-Wno-missing-field-initializers",
	"-fmessage-length=0", "-fno-exceptions",
	"-ffunction-sections", "-fdata-sections", "-funsigned-char",
	"-MMD",
	"-fomit-frame-pointer", "-Og", "-DMBED_DEBUG",
	"-DMBED_TRAP_ERRORS_ENABLED=1"],
	"asm": ["-c", "-g3", "-x", "assembler-with-cpp"],
	"c": ["-c", "-g3", "-std=gnu11"],
	"cxx": ["-c", "-g3", "-std=gnu++14", "-fno-rtti", "-Wvla"],
	"ld": ["-Wl,--gc-sections", "-Wl,--wrap,main", "-Wl,--wrap,_malloc_r",
	"-Wl,--wrap,_free_r", "-Wl,--wrap,_realloc_r", "-Wl,--wrap,_memalign_r",
	"-Wl,--wrap,_calloc_r", "-Wl,--wrap,exit", "-Wl,--wrap,atexit",
	"-Wl,-n"]
	},

However, the compiler will probably report many issues because MbedOS code base is compatible with older version i think.

[lefebvresam]

I think more issues will popup if I do the switch. As long as the whole project is not C++20 compliant, users are not encouraged to switch to the latstest standard because of these potential issues. I don't know if there are 'programming rules' in the CE to align programming efforts into a specific C++ revision?

[JojoS62]

In Mbed-os, the C++ standard was long time only C++11 and also not always using the current gcc. It was handled conservative because changes caused a lot of testing to ensure the correct functions. And Mbed-os had to maintain compatibility for GCC, IAR and Keil compilers, and not all where always at the same standard level. Also the C++ runtime libs differ and new features are usually later available in Cortex-M than in X86/64 architectures.
With Mbed-CE it is a little bit easier as it support is limited to GCC, so I would like also to have C++20 using the current gcc version. Newer GCC were also more picky about warnings, the current Mbed code base produces a lot and some clean up is also needed.

[multiplemonomials]

Hmm... I am a bit hesitant to change all of Mbed to C++20, because the Arduino IDE is using a very old GCC version that does not support it, so it would break Arduino support.

That said, you can enable C++20 for your own code, I believe, by doing something like

set_property(TARGET MyExecutable PROPERTY CXX_STANDARD 20)

That will enable C++20 support for a specific executable target (MyExecutable). Let me know if that's not working!

[lefebvresam]

I did not switched to C++20 because of all potential issues and warnings. I used the 'old way' practices. However this could be a discussion point for the whole community how and when to switch to a newer cpp version to make it feature proof. I don't know if there is already a topic created for it. I prefer using the 'out of the box' practices as much as possible.

[lefebvresam]

I tried several methods.

• Not working, setting one of these in main CMakeLists.txt after mbed_finalize_build():

# set_property(TARGET ${APP_TARGET} PROPERTY CXX_STANDARD 20)
# add_compile_options(${APP_TARGET} PRIVATE -std=c++20)
# list(APPEND cxx_compile_options "-std=c++20")
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20")
# add_compile_options(-std=c++20)
# set(CMAKE_CXX_FLAGS "-std=c++20")

To avoid a warning when passing a lambda:

/home/sam/git/hmipanel/source/display.h:67:55: warning: use of 'auto' in parameter declaration only available with '-std=c++20' or '-fconcepts'
   67 |         void setInteger(json& data, const char* name, auto functor);

Instead of (lower C++ versions):

template<typename Functor>
void Display::setInteger(json& data, const char* name, Functor functor) {
    ...
}

• If I put 'add_compile_options(-std=c++20)' just after 'project(${APP_TARGET})' I get a lot of :

cc1: warning: command-line option '-std=c++20' is valid for C++/ObjC++ but not for C

But the C++ is using 20 because the auto warning is away.

• If I put "-std=c++20" in GCC_ARM -> cxx of develop.json I get the same auto warning.

• If I set this line in mbed_toolchain.cmake:

set(cxx_compile_options "-std=c++20") # compile options only for CXX

Then -std=c++20 is added to CMAKE_CXX_FLAGS:STRING in CMakeCache.txt in the build folder but I still have the auto warning.
It looks like this line is ignored.

• For testing use something like:

void f(auto& functor) { functor(); }

void main() {
    const char* x = "test";
    auto l = [=] () {cout << x << endl;};
    f(l);
}

versus

template<typename Functor>
void f(Functor functor) { functor(); }

void main() {
    const char* x = "test";
    f([=] () {
        cout << x << endl;
    });
}

or

template<typename Functor>
void f(const char* a, Functor functor) { functor(a); }

void main() {
    f("test", [] (const char* x) {
        cout << x << endl;
    }); //pass lambda
}

So what should be the right way to enable c++20?

[multiplemonomials]

If I put 'add_compile_options(-std=c++20)' just after 'project(${APP_TARGET})' I get a lot of : "cc1: warning: command-line option '-std=c++20' is valid for C++/ObjC++ but not for C"

Oh, the way to fix that is to use

add_compile_options($<$<COMPILE_LANGUAGE:CXX>-std=c++20>)

This is a generator expression that will evaluate to "-std=c++20" when used in the flags for a C++ source file, but evaluate to "" in other locations. However, it really shouldn't have to be this compilicated... hmm...

[multiplemonomials]

So, the C++ standard is set here in app.cmake. I think that simply changing the value of CMAKE_CXX_STANDARD in your top-level CMakeLists should work, but you probably have to do it right after including app.cmake. Doing it at the end of the buildscript, after mbed_finalize_build(), probably won't work because I think it takes the value of that variable at the point where the target is created.

So you'd have something like:

include(mbed-os/tools/cmake/app.cmake)
set(CMAKE_CXX_STANDARD 20)

[lefebvresam]

• First works but you forgot a ':', otherwise you get:

CMake Error at CMakeLists.txt:16 (add_compile_options):
  Error evaluating generator expression:

    $<$<COMPILE_LANGUAGE:CXX>-std=c++20>

  Expression did not evaluate to a known generator expression

Should be:

add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-std=c++20>)

• Second seems to work, but:
  . Why all previous proposals don't work?
  . Is there a way to remove other compiler options like '-Wreorder' to get rid of specific warnings?
  . Is there a better way to know (or print) the C++ or compiler version used instead of checking if a C++20 option throws a warning?
  . Why CMAKE_CXX_STANDARD is not overwritten by mbed_finalize_build()?

[lefebvresam]

I have already some answers:

• Target specific: I have to set for each target where I include the header with C++20 stuff:

set_property(TARGET widgets PROPERTY CXX_STANDARD 20)
set_property(TARGET appfogger PROPERTY CXX_STANDARD 20)
set_property(TARGET apprunlight PROPERTY CXX_STANDARD 20)
set_property(TARGET appbutton PROPERTY CXX_STANDARD 20)
set_property(TARGET ${APP_TARGET} PROPERTY CXX_STANDARD 20)

• There is not such a thing like delete_compile_options, what works to supress reorder warnings is:

add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-reorder>)

[multiplemonomials]

Why all previous proposals don't work?

I think that the reason for a number of the methods you tried not working is, the value of CMAKE_CXX_STANDARD takes precedence over most global-scope compile options. So as long as CMAKE_CXX_STANDARD is set to 11, CMake will add --std=c++11 after the contents of CMAKE_CXX_FLAGS. So the solutions that work involve either adding --std=c++20 to compile flags that have higher precedence, or changing the value of CMAKE_CXX_FLAGS.