C++23 is the latest iteration of the C++ standard which is now available. It brings a multitude of exciting features and improvements to the language. This article looks into these new features, explores their benefits and how developers can leverage them to write more efficient, expressive, and maintainable C++ code. This new C++ standard is also called the “Pandemic Edition”.

Table of Contents

Modern “Hello, World!” C++ Program

After all the library changes are applied to the C++ working draft, the new “Hello, world!” program will be as below. This will compile 10 times faster than the old version using #include <iostream>.

1. Concepts: Enhancing Type Safety and Expressiveness

One of the most significant additions in C++23 is the concept feature. Concepts act as compile-time constraints on template parameters which allow developers to define the specific requirements to be used within a template. This enhances type safety by ensuring that only compatible types are used. This prevents errors and improves code clarity.

Concepts also improve code expressiveness by allowing developers to write more concise and readable template definitions. Instead of specifying long lists of type requirements, concepts enable developers to express their intent in a clear and concise manner.

2. std::span: A Modern Approach to String Views

C++23 introduces the std::span type, a powerful tool for working with string views. Unlike traditional std::string, which stores its own data, std::span provides a lightweight way to access and manipulate a substring without copying the underlying data. This can significantly improve performance, especially when dealing with large strings.

std::span also offers various benefits over traditional pointers, such as automatic bounds checking and member functions for common string operations. This makes it a safer and more convenient alternative for working with string views.

3. Constexpr Functions: Taking Efficiency to the Next Level

C++23 expands the capabilities of constexpr functions, allowing them to perform more complex operations at compile time. This allows developers to express certain computations directly within the code, improving compile-time performance and reducing runtime overhead.

With constexpr functions, developers can write more efficient code for tasks like template metaprogramming, initialization of static data members, and calculations within constant expressions.

4. Improved String Handling: New Features for Convenience and Performance

C++23 introduces several improvements to string handling, enhancing both convenience and performance. These include:

  • std::string::resize_and_overwrite: This new member function allows developers to resize a string and overwrite its contents in a single operation, improving performance compared to using resize and assign separately.
  • <spanstream> header: This new header provides a stream class based on std::span, allowing developers to efficiently work with strings without allocating memory for the data.
  • String literals improvements: C++23 introduces several new string literal formats, including binary literals, user-defined literals, and custom delimiters, providing developers with more flexibility and expressiveness when working with strings.

5. Enhanced Standard Library and Utilities

C++23 comes with various enhancements to the standard library and utilities, including:

  • Use import std; You can directly import the standard library with import std;, or apply the C++20 format string in std::print and std::println.
  • std::format improvements: New features like formatted string literals and automatic argument deduction make std::format even more powerful and convenient for formatting output.
  • New and improved algorithms and containers: C++23 introduces new algorithms like std::span_copy and std::span_fill specifically designed to work efficiently with std::span. Additionally, existing algorithms and containers like std::variant and std::any receive improvements for better performance and usability.
  • Memory Management Enhancements: C++23 introduces new smart pointer types like std::out_ptr and std::inout_ptr to facilitate interoperability with C APIs that use pointers.

6. New Preprocessor Directives

C++23 introduces new preprocessor directives such as: #elifdef, #elifndef, #warning and #embed.  The C++ 23 standard introduces these two preprocessor directives #elifdef and #elifndef to further make the conditional compilation more powerful.

These are just a few of the exciting new features in C++23. By exploring and implementing these features you can unlock greater efficiency, expressiveness, and safety in their C++ code. This article serves as a starting point for further exploration, encouraging you to delve deeper into the world of C++23 and discover its potential for building powerful and innovative software solutions.

C++23 compiler support is still under development, but the following compilers have already implemented some or all of the C++23 features: GCC, CLang and MSVC 2023.