C++20

C++20 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++20 replaced the prior version of the C++ standard, called C++17, and was later replaced by C++23. The standard was technically finalized by WG21 at the meeting in Prague in February 2020, had its final draft version announced in March 2020, was approved on 4 September 2020, and published as ISO/IEC 14882:2020 in December 2020.

Features

C++20 adds more new major features than C++14 or C++17. Changes that have been accepted into C++20 include:

Language

  • concepts, with terse syntax
  • modules; these reintroduce the export keyword, and introduce import and module as identifiers with special meaning
  • designated initializers (based on the C99 feature, and common g++ extension)
  • [=, this] as a lambda capture
  • template parameter lists on lambdas
  • three-way comparison using the "spaceship operator", operator<=>
  • initialization of an additional variable within a range-based for statement
  • lambdas in unevaluated contexts
  • default constructible and assignable stateless lambdas
  • allow pack expansions in lambda init-capture
  • class types in non-type template parameters, also allowing string literals as template parameters
  • removing the need for typename in certain circumstances
  • new standard attributes [[no_unique_address]], [[likely]] and [[unlikely]]
  • conditional explicit, allowing the explicit modifier to be contingent on a Boolean expression
  • expanded constexpr: virtual functions, union, try and catch, dynamic_cast and typeid, std::pointer_traits
  • immediate functions using the new consteval keyword
  • signed integers are now defined to be represented using two's complement (signed integer overflow remains undefined behavior)
  • a revised memory model
  • various improvements to structured bindings (interaction with lambda captures, static and thread_local storage duration)
  • coroutines, which are coloured according to return type
  • using on scoped enums
  • constinit keyword

Library

  • ranges (The One Ranges Proposal)
  • std::make_shared and std::allocate_shared for arrays
  • atomic smart pointers (such as std::atomic<shared_ptr<T>> and std::atomic<weak_ptr<T>>)
  • std::to_address to convert a pointer to a raw pointer
  • calendar and time-zone additions to <chrono>
  • std::span, providing a view to a contiguous array (analogous to std::string_view but span can mutate the referenced sequence)
  • std::erase and std::erase_if, simplifying element erasure for most standard containers
  • <version> header, providing feature test macros
  • std::bit_cast<> for type casting of object representations, with less verbosity than memcpy() and more ability to exploit compiler internals
  • various constexpr library bits
  • std::construct_at(), for calling a constructor at a specified memory location. This allows constexpr context usage for std::vector and std::string. Although this does necessarily allow declaring constexpr instances of std::string and std::vector (as their constructors are not constexpr), it does allow for these types to appear in constant evaluation contexts.
  • smart pointer creation with default initialization
  • contains()-method for associative containers
  • prefix and suffix checking for strings
  • bit operations, such as leading/trailing zero/one count, and log2 operations
  • std::bind_front
  • std::atomic::wait, std::atomic::notify_one, andstd::atomic::notify_all were added, giving the standard library futex-like capabilities

New and changed keywords

Eight new keywords added (plus the new "spaceship operator", operator<=>), such as concept, constinit, consteval, requires (as well as reintroducing the export keyword), and char8_t (for UTF-8 support); of the eight new these three co_await, co_return, co_yield, are only for the new coroutine support (additionally six previously existing keywords have changed or new meaning added); explicit can take an expression since C++20. Most of the uses of the volatile keyword have been deprecated.

The coroutine keywords had to use a 'co_' prefix, because coroutines in C++ are coloured not by a async keyword (like in C#), but rather by return type. There was historically a proposal to instead colour according to a async keyword and use await and yield as keywords.

In addition to keywords, there are identifiers with special meaning (effectively keywords in certain contexts), including new import and module.

New attributes in C++20: [[likely]], [[unlikely]], and [[no_unique_address]]

Removed and deprecated

Removed features:

  • The C-derived headers <ccomplex>, <ciso646>, <cstdalign>, <cstdbool> and <ctgmath> were removed, as they serve no purpose in C++. (The corresponding <*.h> headers remain, for compatibility with C.)
  • The use of throw clauses was removed, and are completely superseded by noexcept clauses.
  • Some previously deprecated library features were removed, including std::uncaught_exception, std::raw_storage_iterator, std::is_literal_type, std::is_literal_type_v, std::result_of and std::result_of_t.

Deprecated features:

  • Use of comma operator in subscript expressions has been deprecated
  • (most of) volatile has been deprecated

Published as Technical Specifications

Deferred to a later standard

Compiler support

Full support

The following compilers provide full support:

  • Visual Studio 2019 supports all C++20 features through its /std:c++latest option, as of version 16.10.0. An option /std:c++20 to enable C++20 mode is added in version 16.11.0.

Microsoft's compiler supports not only Windows but also Linux, Android, and iOS. However, for Linux development, it requires the "Visual C++ for Linux Development" extension.

Partial

  • Clang has partial C++20 support that can be enabled with the option -std=c++20 (version 10 and later) or -std=c++2a (version 9 and earlier).
  • EDG started implementing C++20 features in version 5.0 and as of version 6.1 supports most C++20 core language features.
  • GCC added partial, experimental C++20 support in 2017 in version 8 through the option -std=c++2a. Like Clang, GCC replaced this option with -std=c++20 in version 10. It also has an option to enable GNU extensions in addition to C++20 support, -std=gnu++20.

History

Changes applied to the C++20 working draft in July 2017 (Toronto) include:

Changes applied to the C++20 working draft in the fall meeting in November 2017 (Albuquerque) include:

Changes applied to the C++20 working draft in March 2018 (Jacksonville) include:

Changes applied to the C++20 working draft in the summer meeting in June 2018 (Rapperswil) include:

Changes applied to the C++20 working draft in the fall meeting in November 2018 (San Diego) include:

Changes applied to the C++20 working draft in the winter meeting in February 2019 (Kona) include:

Changes applied to the C++20 working draft in the summer meeting in July 2019 (Cologne) include:

Changes applied during the NB comment resolution in the fall meeting in November 2019 (Belfast) include: