{"id":9898,"date":"2024-08-26T08:09:47","date_gmt":"2024-08-26T08:09:47","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=9898"},"modified":"2025-07-03T16:23:56","modified_gmt":"2025-07-03T16:23:56","slug":"an-overview-of-c26-core-language","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/an-overview-of-c26-core-language\/","title":{"rendered":"An Overview of C++26: Core Language"},"content":{"rendered":"\n

C++26 has a lot to offer. Let me directly jump in and give you an overview.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

This image gives you the first idea of what’s inside or outside C++26. Writing a blog post about the future is always challenging because the design freeze of C++26 is in the first quarter of 2025.<\/p>\n\n\n\n

Fishing in Murky Waters<\/h2>\n\n\n\n

This image should only give you the first idea of what’s inside or outside C++26. I will adapt the image while writing the next months about C++26 if necessary. For example, the three powerful features reflection, contracts, and std::execution<\/code> made a big step towards their standardization. On the contrary, I intentionally ignore pattern matching on the image.<\/p>\n\n\n\n

Very impactful features such as reflection or contracts implement the agile idea of the minimum viable product. “A minimum viable product (MVP)<\/strong> is a version of a product with just enough features to be usable by early customers who can then provide feedback for future product development.<\/em>” (https:\/\/en.wikipedia.org\/wiki\/Minimum_viable_product<\/a>). This means C++26 is only the starting point for features such as reflection or contracts.<\/p>\n\n\n\n

If possible, I show you the feature in action. Many features are already implemented in the brand-new C++ compilers<\/a>. For the rest, I hope for prototype implementations.<\/p>\n\n\n\n

Let me start with the core language.<\/p>\n\n\n\n

Core Language<\/h2>\n\n\n\n

Reflection<\/h3>\n\n\n\n

Reflection <\/strong>is the ability of a program to examine, introspect, and modify its structure and behavior. This makes compile-time programming in C++ much more powerful.<\/p>\n\n\n\n

I don’t want to annoy you with too much theory in this overview post. Therefore, I will show you my favorite example from the reflection proposal P2996R5<\/a>.<\/p>\n\n\n\n

A question I often have to answer in my classes is: How could I convert an enumerator to a string? <\/p>\n\n\n\n

\/\/ enumString.cpp<\/span>

#include <iostream><\/span>
#include <experimental\/meta><\/span>
#include <string><\/span>
#include <type_traits><\/span>

\/\/ start 'expand' definition<\/span>
namespace<\/span> __impl {
  template<\/span><<\/span>auto<\/span>... vals><\/span>
  struct<\/span> replicator_type {
    template<\/span><<\/span>typename<\/span> F><\/span>
      constexpr void<\/span> operator<\/span>>><\/span>(F body) const<\/span> {
        (body.template<\/span> operator<\/span>()<<\/span>vals><\/span>(), ...);
      }
  };

  template<\/span><<\/span>auto<\/span>... vals><\/span>
  replicator_type<<\/span>vals...><\/span> replicator =<\/span> {};
}

template<\/span><<\/span>typename<\/span> R><\/span>
consteval auto<\/span> expand(R range) {
  std::<\/span>vector<<\/span>std::<\/span>meta::<\/span>info><\/span> args;
  for<\/span> (auto<\/span> r :<\/span> range) {
    args.push_back(std::<\/span>meta::<\/span>reflect_value(r));
  }
  return<\/span> substitute(^<\/span>__impl::<\/span>replicator, args);
}
\/\/ end 'expand' definition<\/span>

template<\/span><<\/span>typename<\/span> E><\/span>
  requires std::<\/span>is_enum_v<<\/span>E><\/span>                      \/\/ (1)<\/span>
constexpr std::<\/span>string enum_to_string(E value) {
  std::<\/span>string result =<\/span> \"<unnamed>\"<\/span>;
  [:<\/span>expand(std::<\/span>meta::<\/span>enumerators_of(^<\/span>E)):<\/span>] >><\/span>    \/\/ (2)<\/span>
  [&<\/span>]<<\/span>auto<\/span> e><\/span>{
    if<\/span> (value ==<\/span> [:<\/span>e:<\/span>]) {
      result =<\/span> std::<\/span>meta::<\/span>identifier_of(e);       \/\/ (3)<\/span>
    }
  };
  return<\/span> result;
}


int<\/span> main() {

    std::<\/span>cout <<<\/span> '\\n'<\/span>;

    enum<\/span> Color { red, green, blue };
    std::<\/span>cout <<<\/span> \"enum_to_string(Color::red): \"<\/span> <<<\/span> enum_to_string(Color::<\/span>red) <<<\/span> '\\n'<\/span>;
    \/\/ std::cout << \"enum_to_string(42): \" << enum_to_string(42) << '\\n'; <\/span>

    std::<\/span>cout <<<\/span> '\\n'<\/span>;

}
<\/pre><\/div>\n\n\n\n
This example uses the experimental features (std::meta<\/code>) of the standard. <\/p>\n\n\n\n
Here’s the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Let me say a few words about the function, template enum_to_string<\/code>. The function expand <\/code>is a workaround. The function call enum_to_string(Color(42))<\/code> breaks because the function requires an enum.: requires std::is_enum_v<E><\/code> (line 1).<\/p>\n\n\n\n
Line (1) applies a reflection operator (^E<\/code>) and calls the meta function enum_to_std::meta::enumerators_of(^E))<\/code>. Finally, the so-called splicer <\/em>([: ref<\/code>l :]<\/code>) produces in line (2) grammatical elements for reflection. The second meta function in line (3) creates the string:std:meta::identifier_of(e))<\/code>. The consteval <\/code>meta functions are executed at compile time, and so is the reflection.<\/p>\n\n\n\n
Contracts<\/h3>\n\n\n\n
A contract <\/strong>specifies interfaces for software components precisely and checkably. These software components are functions that fulfill preconditions, postconditions, and invariants.<\/p>\n\n\n\n
Here’s a straightforward example from the proposal P2900<\/strong><\/a>.<\/p>\n\n\n\n
int f<\/span>(const<\/span> int<\/span> x)
  pre (x !=<\/span> 1<\/span>) \/\/ a precondition assertion<\/span>
  post(r :<\/span> r !=<\/span> 2<\/span>) \/\/ a postcondition assertion; r refers to the return value of f<\/span>
{
  contract_assert (x !=<\/span> 3<\/span>); \/\/ an assertion statement<\/span>
  return<\/span> x;
}
<\/pre><\/div>\n\n\n\n
The function f has a precondition, postcondition, and invariant. The precondition is checked before the function invocation, the postcondition after the function invocation, and the invariant precisely at the point of its invocation.<\/p>\n\n\n\n
Invoking the function with arguments 1, 2, or 3 causes a contract violation. There are different ways to react to a contract violation.<\/p>\n\n\n\n
void<\/span> g<\/span>()
{
  f(0<\/span>); \/\/ no contract violation<\/span>
  f(1<\/span>); \/\/ violates precondition assertion of f<\/span>
  f(2<\/span>); \/\/ violates postcondition assertion of f<\/span>
  f(3<\/span>); \/\/ violates assertion statement within f<\/span>
  f(4<\/span>); \/\/ no contract violation<\/span>
}
<\/pre><\/div>\n\n\n\n
The core language of C++26 offers more than just reflection and contracts. Let me name them and present a code snippet from the corresponding proposals.<\/p>\n\n\n\n
    \n
  • Placeholder and extended character set<\/strong><\/li>\n<\/ul>\n\n\n\n
    auto<\/span> [x, y, _] =<\/span> f();\n<\/pre><\/div>\n\n\n\n
    The _ stands for I don’t care and it can be used more than once.<\/p>\n\n\n\n
      \n
    • static_assert <\/code>extension<\/strong><\/li>\n<\/ul>\n\n\n\n
      static_assert(sizeof<\/span>(S) ==<\/span> 1<\/span>,\nstd::<\/span>format("Unexpected sizeof: expected 1, got {}"<\/span>, sizeof<\/span>(S))\n<\/pre><\/div>\n\n\n\n
        \n
      • Template improvements<\/strong><\/li>\n<\/ul>\n\n\n\n
        There are many template improvements in C++26. My favorite one is pack indexing:<\/p>\n\n\n\n
        template<\/span> <<\/span>typename<\/span>... T><\/span>\nconstexpr auto<\/span> first_plus_last(T... values) -><\/span> T...[0<\/span>] {\n  return<\/span> T...[0<\/span>](values...[0<\/span>] +<\/span> values...[sizeof<\/span>...(values)-<\/span>1<\/span>]);\n}\n\nint<\/span> main() {\n  \/\/first_plus_last(); \/\/ ill formed<\/span>\n  static_assert(first_plus_last(1<\/span>, 2<\/span>, 10<\/span>) ==<\/span> 11<\/span>);\n}\n<\/pre><\/div>\n\n\n\n
          \n
        • delete <\/code>with reason<\/strong><\/li>\n<\/ul>\n\n\n\n
          delete<\/span>("Should have a reason"<\/span>);\n<\/pre><\/div>\n\n\n\n
          What’s Next?<\/h2>\n\n\n\n
          In my next post, I will provide an overview of the C++26 library.<\/p>\n\n\n\n
          <\/p>\n","protected":false},"excerpt":{"rendered":"
          C++26 has a lot to offer. Let me directly jump in and give you an overview. This image gives you the first idea of what’s inside or outside C++26. Writing a blog post about the future is always challenging because the design freeze of C++26 is in the first quarter of 2025. Fishing in Murky […]<\/p>\n","protected":false},"author":21,"featured_media":9901,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":"[]"},"categories":[559],"tags":[],"class_list":["post-9898","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9898","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=9898"}],"version-history":[{"count":39,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9898\/revisions"}],"predecessor-version":[{"id":10852,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9898\/revisions\/10852"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/9901"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=9898"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=9898"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=9898"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}