dxx-rebirth/Documentation/c++std.markdown

Required C++11 features

DXX-Rebirth code uses C++11 and C++14 features present in >=clang-9.0 and >=gcc-7.5. Some of these features are probed in the SConf tests so that an error can be reported if the feature is missing. However, since these are considered the minimum supported compiler versions, and existing SConf tests reject older compilers, some C++14 features that are new in gcc-7.5 may be used without a corresponding test in SConf.

These C++11 features are required to build DXX-Rebirth:

• Rvalue references (void a(A &&);)
• Variadic templates (template <typename... T> class A{};)
• auto-typed variables (auto a = f();)
  • Trailing function return type (auto f() -> int;)
• Lambdas (f([]{ return 1; });)
• decltype() (typedef decltype(a()) b;)
• Alias templates (using A = B; template <typename T> using C = D<T, T>;)
• Null pointer constant nullptr (int *i = nullptr;)
• Strongly-typed enums (enum class E { ... };)
• Forward declaration for enums (enum E; ...; enum E { ... };)
• Generalized constant expressions (constexpr int a = 0;)
• Explicit conversion operators (explicit operator bool();)
• Defaulted and deleted functions (void a(int b) = delete;)
• Unique pointer template std::unique_ptr<T> (std::unique_ptr<int> i; std::unique_ptr<int[]> j;)
• Static assertions

Required C++14 features

• std::index_sequence is a compile-time sequence of integers.

Optional C++11/C++14 features

DXX-Rebirth code may use C++11 or C++14 features not present in the minimum supported compiler if the feature can be emulated easily (C++11: inheriting constructors, Range-based for; C++14: std::exchange, std::make_unique) or if the feature can be removed by a macro and the removal does not change the correctness of the program (C++11: rvalue-qualified member methods).

Optional C++11 features

Emulated if absent

• Inheriting constructors are wrapped by the macro DXX_INHERIT_CONSTRUCTORS. If inherited constructors are supported, then DXX_INHERIT_CONSTRUCTORS expands to a using declaration. If inherited constructors are not supported, then DXX_INHERIT_CONSTRUCTORS defines a variadic template constructor to forward arguments to the base class.
• Range-based for is wrapped by the macro range_for. This feature is present in the current minimum supported compiler versions. It was first used when >=gcc-4.5 was the minimum. Use of the range_for macro continues because it improves readability.

Preprocessed out if absent

• Reference-qualified methods check that an rvalue which may or may not hold a valid pointer is not used in a context where the caller assumes the rvalue holds a valid pointer. When the rvalue may or may not hold a valid pointer, it must be saved to an lvalue, tested for a valid pointer, and used only if a valid pointer is found.

Optional C++14 features

• std::exchange is a convenience utility function. If std::exchange is available, then common/include/compiler-exchange.h uses using std::exchange; to bring exchange into the global namespace. If std::exchange is not available, then common/include/compiler-exchange.h provides a simple implementation of exchange in the global namespace.

• std::make_unique is a convenience utility function. If std::make_unique is available, then common/include/compiler-make_unique.h uses using std::make_unique; to bring make_unique into the global namespace. If std::make_unique is not available, then common/include/compiler-make_unique.h provides a simple implementation of make_unique in the global namespace.