{"id":10150,"date":"2024-10-14T09:42:42","date_gmt":"2024-10-14T09:42:42","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10150"},"modified":"2025-07-04T14:04:07","modified_gmt":"2025-07-04T14:04:07","slug":"reflection-in-c26-determine-the-layout","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/reflection-in-c26-determine-the-layout\/","title":{"rendered":"Reflection in C++26: Determine the Layout"},"content":{"rendered":"\n

Thanks to reflection, you can determine the layout of types.<\/p>\n\n\n\n

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

My examples are based on the reflection proposal P2996R5<\/a>.<\/p>\n\n\n\n

Class Layout<\/h2>\n\n\n\n

The following program determines the class layout of a few members.<\/p>\n\n\n\n

\/\/ classLayout.cpp<\/span>\n\n#include <experimental\/meta><\/span>\n#include <iostream><\/span>\n#include <utility><\/span>\n#include <vector><\/span>\n#include <array><\/span>\n\nstruct<\/span> member_descriptor\n{\n  std::<\/span>size_t<\/span> offset;\n  std::<\/span>size_t<\/span> size;\n  bool<\/span> operator<\/span>==<\/span>(member_descriptor const<\/span>&<\/span>) const<\/span> =<\/span> default<\/span>;\n};\n\n\/\/ returns std::array<member_descriptor, N> The company's biggest funding.<\/span>\ntemplate<\/span> <<\/span>typename<\/span> S><\/span>\nconsteval auto<\/span> get_layout() {\n  constexpr size_t<\/span> N =<\/span> []() consteval {\n    return<\/span> nonstatic_data_members_of(^<\/span>S).size();\n  }();\n\n  std::<\/span>array<<\/span>member_descriptor, N><\/span> layout;\n  [:<\/span> expand(nonstatic_data_members_of(^<\/span>S)) :<\/span>] >><\/span> [&<\/span>, i=<\/span>0<\/span>]<<\/span>auto<\/span> e><\/span>() mutable<\/span> {\n    layout[i] =<\/span> {.offset=<\/span>offset_of(e), .size=<\/span>size_of(e)};\n    ++<\/span>i;\n  };\n  return<\/span> layout;\n}\n\nstruct<\/span> X\n{\n    char<\/span> a;\n    int<\/span> b;\n    double<\/span> c;\n};\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    constexpr auto<\/span> layout =<\/span> get_layout<<\/span>X><\/span>();\n\n    std::<\/span>cout <<<\/span> "Layout of struct X:<\/span>\\n<\/span>"<\/span>;\n    for<\/span> (const<\/span> auto<\/span>&<\/span> member :<\/span> layout) {\n        std::<\/span>cout <<<\/span> "Offset: "<\/span> <<<\/span> member.offset <<<\/span> ", Size: "<\/span> <<<\/span> member.size <<<\/span> '\\n'<\/span>;\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
The C++ program reflects on the layout of a struct’s data members. The main goal of this code is to determine and print the memory offsets and sizes of each member within a struct.<\/p>\n\n\n\n
The first part of the code defines a std::array<\/code> named layout<\/code>, which is intended to store descriptors for each member of the struct. These descriptors include the offset and size of each member. The [: expand(nonstatic_data_members_of(^S)) :]<\/code> construct is a placeholder for a metaprogramming construct that iterates over the non-static data members of the struct S<\/code>. This construct is only a temporary workaround and is followed by a lambda function that captures the current state by reference (&<\/code>) and initializes an index variable i<\/code> to zero. The lambda function is then applied to each data member, storing the offset and size of each member in the layout<\/code> array and incrementing the index i<\/code>.<\/p>\n\n\n\n
The struct X<\/code> is defined with three data members: a char<\/code> named a<\/code>, an int<\/code> named b<\/code>, and a double<\/code> named c<\/code>. These members are used to demonstrate the reflection mechanism.<\/p>\n\n\n\n
In the main<\/code> calls a function get_layout<X>()<\/code>, which returns the layout<\/code> array filled with the offsets and sizes of the members of struct X<\/code>. The program then prints the layout of struct <\/code>X<\/code><\/a> by iterating over the layout<\/code> array and printing the offset and size of each member.<\/p>\n\n\n\n
This code reflects on the memory layout of a struct’s data members in C++, which can be useful for understanding memory alignment and optimizing data structures.<\/p>\n\n\n\n
Finally, he has the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
You can store reflections in a container or apply an algorithm to them.<\/p>\n\n\n\n
Size<\/h2>\n\n\n\n
The following program determines the size of a few built-in types.<\/p>\n\n\n\n
\/\/ getSize.cpp<\/span>\n\n#include <experimental\/meta><\/span>\n#include <array><\/span>\n#include <iostream><\/span>\n#include <ranges><\/span>\n#include <algorithm> <\/span>\n\nconstexpr std::<\/span>array types =<\/span> {^<\/span>int<\/span>, ^<\/span>float<\/span>, ^<\/span>double<\/span>};\nconstexpr std::<\/span>array sizes =<\/span> []{\n  std::<\/span>array<<\/span>std::<\/span>size_t<\/span>, types.size()><\/span> r;\n  std::<\/span>ranges::<\/span>transform(types, r.begin(), std::<\/span>meta::<\/span>size_of);\n  return<\/span> r;\n}();\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>cout <<<\/span> "Types and their sizes:<\/span>\\n<\/span>"<\/span>;\n    for<\/span> (std::<\/span>size_t<\/span> i =<\/span> 0<\/span>; i <<\/span> types.size(); ++<\/span>i) {\n        std::<\/span>cout <<<\/span> "Size: "<\/span> <<<\/span> sizes[i] <<<\/span> " bytes<\/span>\\n<\/span>"<\/span>;\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n}\n<\/pre><\/div>\n\n\n\n
The program begins by including several headers: <experimental\/meta><\/code> for reflection capabilities, <array><\/code> for fixed-size array support, <iostream><\/code> for input\/output operations, <ranges><\/code> for range-based algorithms, and <algorithm><\/code> for general algorithms.<\/p>\n\n\n\n
The constexpr std::array types<\/code> declaration creates a compile-time array containing reflections for int<\/code>, float<\/code>, and double<\/code>. These reflections are represented using the reflection operator ^<\/code>.<\/p>\n\n\n\n
Next, the constexpr std::array sizes<\/code> declaration defines another compile-time array that will hold the sizes of the types specified in the types<\/code> array. This array is initialized using a lambda function that creates an array r<\/code> of the same size as types<\/code>. The std::ranges::transform<\/code> function is then used to populate r<\/code> by applying the std::meta::size_of<\/code> operation to each reflection value in types<\/code>. The std::meta::size_of<\/code> operation is a metafunction that returns the size of a type at compile time.<\/p>\n\n\n\n
The main<\/code> function begins by entering a loop that iterates over the indices of the types<\/code> array. For each index, it prints the size of the corresponding type from the sizes<\/code> array in bytes.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Instead of the ranges function std::ranges::transform<\/code>,  you could also use the classical transform algorithm; <\/p>\n\n\n\n
std::<\/span>transform(types.begin(), types.end(), r.begin(), std::<\/span>meta::<\/span>size_of);\n<\/pre><\/div>\n\n\n\n
 What’s Next? <\/h2>\n\n\n\n
This was my first dive into reflection in C++26. A deeper dive will follow. In my next post, I will focus on contracts. <\/p>\n","protected":false},"excerpt":{"rendered":"
Thanks to reflection, you can determine the layout of types. My examples are based on the reflection proposal P2996R5. Class Layout The following program determines the class layout of a few members. \/\/ classLayout.cpp #include <experimental\/meta> #include <iostream> #include <utility> #include <vector> #include <array> struct member_descriptor { std::size_t offset; std::size_t size; bool operator==(member_descriptor const&) const […]<\/p>\n","protected":false},"author":21,"featured_media":10083,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[559],"tags":[560],"class_list":["post-10150","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog","tag-reflection"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10150","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=10150"}],"version-history":[{"count":13,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10150\/revisions"}],"predecessor-version":[{"id":10221,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10150\/revisions\/10221"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/10083"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=10150"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=10150"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=10150"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}