Do you ask for a c++11 checkbox?

I believe it is possible to define compilation standard by default, but avoid using parts of language and standard library which were not supported or fully implemented. For example, libstdc++ states full support of memory_resource since version 9.1 (https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#status.iso.2017), but older compiler, like GCC 7.5.0 (Ubuntu 18.04) already supported --std=c++17 option. We can avoid using memory_resource and remain compatible with older compilers with partial C++17 support.

Compiler versions in some Linux OSes:

• Ubuntu 18.04 - GCC 7.5, Clang 6.0 (EOL Apr 2023)
• Ubuntu 20.04 - GCC 9.4, Clang 10
• Ubuntu 22.04 - GCC 11.4 Clang 14
• Debian 10 - GCC 8.3, Clang 7
• Rocky Linux 8 (CentOS?, RHEL) - GCC 8.5, Clang 16
• NVIDIA Jetson Linux - GCC 9.3 (?)

So we can target C++17, but also check build on Ubuntu 18.04 to make sure older toolchains with incomplete standard support can build OpenCV. Additionally, modern modules can require more features or higher C++ standard and turn themselves off automatically if compiler does not satisfy their requirements. Example: https://github.com/opencv/opencv_contrib/blob/4.x/modules/cvv/CMakeLists.txt#L1

It would be nice to see examples of older toolchains/platforms which are currently used by people to buld OpenCV to take them in account too.

@fspindle Is there a reason that an old compiler is combined with the latest version of OpenCV on these devices? Would it be an option to simply continue using OpenCV 4 there? To be honest, I am very skeptical that the combination of an extremely old compiler and top current libraries will really be used productively anywhere.

@mshabunin I think it would be better to set complete C++17 as the lower limit. If certain features are not allowed to be used, then it becomes very difficult for the developers to decide what exactly they are allowed to use and what not.

@bebuch Certainly, continuing to use OpenCV 4 when older compilers are needed is an interesting option that could be considered. I agree that enabling/disabling features, whether available or not, is a pain for developers. Targetting C++17 becomes a good compromise.

I think it would be better to set complete C++17 as the lower limit.

In this case we would need to explicitly forbid compilers/libraries older than some specific version. According to GCC/libstdc++ documentation it would be GCC 12. And Microsoft documentation states Visual Studio 2019 16.4. It would mean that we won't support even Ubuntu 22 (GCC 11). I believe these are too strong requirements.

I thought we would set baseline compiler versions to something like GCC 9 and VS 2017 15.3 and would check these builds on CI. Perhaps also emit a warning in cmake when building with older versions of mainstream compilers.

it becomes very difficult for the developers to decide what exactly they are allowed to use and what not

I wouldn't say so. Algorithm for using some feature would be as follows:

• is this feature already used in OpenCV?
• is this feature part of C++17 standard?
• is this feature supported by minimal compiler versions set by OpenCV? (can be checked in the Compiler Explorer or locally in container/VM)
• does your (preliminary) patch pass OpenCV CI?

Even then, some more advanced features can still be used in optional cases (e.g. in samples) under conditional compilation.

@sabudilovskiy, sorry, we only offer to choose from the feasible for us options :) C++ 20 introduces a lot of great stuff, and some of it we could definitely use, like "modules", but not all of the features, including modules, are properly implemented in all mainstream compilers. Many of the features are implemented, but require quite fresh versions of compilers that users may not have installed by default, see the detailed post above.

For example, GCC, the default C++ compiler for Linux distributions, currently declares full support of C++ 17 (whereas C++ 20 support is still partial and is described as "experimental") and the default standard is "gnu++17" (C++ 17 with GCC extensions) since GCC 11: https://gcc.gnu.org/projects/cxx-status.html. C++ 14 (well, gnu++14) has been the default standard from GCC 6 till GCC 10.x inclusive (but, as Maksim pointed out, starting from GCC 8.x it's quite safe to use C++ 17 except for a few missing libstdc++ features).

Let's wait for a few years while compilers and distro's will catch up. Maybe then we will make another leapfrog straight to C++ 23 (or even C++ 26).

Is there a reason that an outdated compiler is combined with the latest version of OpenCV on these devices? Would it be an option to simply continue using OpenCV 4 there?

Some ARM architecture servers used for AI program . The dnn module used very frequently.I use dnn module in opencv4 now. With other Edge devices with low computing power,I can use opencv3 or opencv4.This is why.

The support for C++20 is still not complete for all major compilers and standard libraries. Additionally we should support the latest 2 or 3 versions of every compiler so it works by default for the most Linux distributions that are still in support cycle.