Examples of many C++
language features added in C++20
. Click on any header for more details.
Aggregate initialization is no longer allowed for structs with explicitly defaulted or deleted constructors. examples
Allows conversions from an array of known bounds to a reference to an array of unknown bounds. When doing overload resolution, arrays with matching bounds are selected over arrays of unknown or non-matching sizes. examples
The size of newed arrays is now deduced, in the same way that arrays on the stack have deduced sizes. examples
Addition of several new attributes, including [[likely]], [[unlikely]] and [[no_unique_address]]. examples
A new syntax for initializing bitfields without using constructors. examples
Addition of a new type named char8_t
. examples
Concepts are a new language feature that constrain template types and the properties that template types may (and many not) have. examples
Constructors can now be conditionally explicit. examples
Consteval functions can be called where all of their arguments are constant expressions, but not if any of the arguments are non-constant. They are called 'immediate functions': every call to a consteval function must produce a compile-time constant expression. Variables cannot be declared consteval. examples
Not all class members need to be initialized by constexpr constructors, but reading (using) uninitialized members in constexpr contexts in an error. examples
Initialize variables at compiletime. examples
Functions that can suspend exection (storing their state in a object on the heap) and be resumed later. examples
Allows structured bindings for custom classes and structs, not just for pairs and tuples. examples
Comma operators in subscript expressions are deprecated. examples
Deprecates some uses of volatile, and some uses of volatile variables. examples
A new syntax for named initializers for struct, class and union members. examples
Many macros have been added which test for C++
features. examples
The keyword 'typename' is no longer required in many cases, including in the default value of a template parameter, in the return type of a function declaration or definition, in class scoped function definitions and class-scoped typedefs, among others. examples
Lambda functions can now be used in default-initialized class members. examples
Moves, rather than copies, are used more often. examples
Prefer the copy constructor when initializing a variable with an initializer list if the list consists of a single element compatible with the deduced type. examples
In some use cases (but not all), ::std::is_constant_evaluated evaluates to true if the enclosing function is constant-evaluated. examples
Addition of generic lambda functions (using auto parameters), lambda functions with template parameters, concept-constrained template parameters and variadic templates. examples
Declaring a typedef of a stateless lambda is allowed, lambdas can now be default-constructed, and a stateless lambda can be default-constructed and copy assigned. examples
::std::make_shared
supports array types. examples
Adds functions for:
*. The midpoint of two integers/floats/doubles (::std::midpoint
in );
- A point along the linear interpolation of two values (
::std::lerp
in ); to_array
, to convert raw arrays to::std::array
objects;make_shared
an array;::std::string
has new member functions to test whether it begins or ends with another expression.
Modules are an alternative to #include
. #included
files are pasted into the main translation unit as text and then parsed. Modules, on the other hand, are #imported
as binary entities.
The inline
keyword is now allowed to appear in nested namespace definitions. Functions in inline
namespaces are referenced as if they were declared in the nearest upward non-inlined namespace. examples
Some additional non-type template parameters are now allowed. examples
An alternative overload for class member delete
. If the
overload exists then it is responsible for calling the class destructor. examples
Conversions from pointer (or nullptr) to bool
are now narrowing. examples
Prior to C++20
, const&
-qualified member functions could not be used as function pointers on rvalue objects. examples
Private subtypes (subclasses) can be used to partly or fully specialize class templates. examples
Free begin()/end() functions are now preferred to member begin/end functions if at least one of the latter does not exist. examples
An additional variable is allowed in range-based for loops. examples
Ranges is "STL v2". It is a drop-in replacement for many of the components of the STL library.
There are major differences between ranges and pre-ranges code. These include (but are not limited to):
- Ranges use
C++20
concepts to enforce conditions. This greatly improves the clarity of error messages in template code. - A range is itself a concept: it is a type that supports
::std::ranges::begin(object)
and::std::ranges::end(object)
. The type of the end iterator need not be the same as the iterator type returned bybegin()
- they need only be comparable. This allows, among other things, for infinite ranges: use::std::unreachable_sentinel
for an iterator that never compares positively with another range iterator. - Many algorithms, eg.
::std::ranges::sort
, accept a reference to a range container, not just a pair ofbegin
/end
iterators.
Addition of atomic shared pointers. examples
Adds the function ::std::source_location::current()
which contains information about the source line, column and enclosing function at the call site. examples
The "spaceship operator", <=>
, is a class-based comparison operator that, for objects A
and B
, determines whether A < B
, A == B
or A > B
. The spaceship operator works in much the same way as strcmp
: < 0
means "A < B
", == 0
means "A == B
" and > 0
means "A > B
". examples
Spans are objects that reference contiguous sequences of objects. Spans have constant copy/move time complexity and do not own the data that they point to. You can modify the underlying data via a span. examples
Structured bindings can be captured by lambdas by value and by reference. examples
Template parameter deduction works even if the type is an alias of another template type. examples
Addition of using enum
. Enum values do not need to be prefixed with the enum class name in the same block as this instruction. examples
All of the code in this repository (including in documentation and in README.md files) is licensed under the GNU General Public License, version 3. See https://www.gnu.org/licenses/.