{"id":3967,"date":"2020-08-10T13:31:08","date_gmt":"2020-08-10T11:31:08","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=3967"},"modified":"2021-03-30T21:15:05","modified_gmt":"2021-03-30T19:15:05","slug":"no-more-plain-old-data","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2020\/08\/10\/no-more-plain-old-data\/","title":{"rendered":"No more plain old data"},"content":{"rendered":"\n

When working in C++, you often hear about POD types<\/em> (which stands for Plain Old Data<\/em>). PODs are useful for communicating with code written in other programming languages (such as C or .NET languages). They can also be copied using memcpy<\/code> (which is important because this is a fast, low-level function that provides performance benefits), and have other characteristics that are key for some scenarios. However, the new C++20 standard has deprecated the concept of POD types in favor of two more refined categories, which are trivial<\/em> and standard-layout<\/em> types. In this post, I will discuss what these categories are and when to use instead of POD.<\/p>\n\n\n\n

Let’s start with a simple example:<\/p>\n\n\n\n

struct A\n{\n   int    a;\n   double b;\n};\n\nstruct B\n{\nprivate:\n   int a;\npublic:\n   double b;\n};\n\nstruct C\n{\n   int    a;\n   double b;\n   C(int const x, double const y) :a{ x }, b{ y }\n   {}\n};<\/pre>\n\n\n\n
The question is, which of these is a POD type? To answer the question, we can use the type traits available in the standard library since C++11:<\/p>\n\n\n\n
Type trait (since C++11)<\/th>Variable template (since C++17)<\/th>Description<\/th><\/tr><\/thead>
std::is_pod<T><\/code><\/td>std::is_pod_v<T><\/code><\/td>If\u00a0T<\/code>\u00a0is a POD type, then the constant member\u00a0value<\/code>\u00a0is true; otherwise it is false<\/td><\/tr>
std::is_trivial<T><\/code><\/td>std::is_trivial_v<T><\/code><\/td>If\u00a0T<\/code>\u00a0is a trivial type, then the constant member\u00a0value<\/code>\u00a0is true; otherwise it is false<\/td><\/tr>
std::is_standard_layout<T><\/code><\/td>std::is_standard_layout_v<T><\/code><\/td>If\u00a0T<\/code>\u00a0is a standard type, then the constant member\u00a0value<\/code>\u00a0is true; otherwise it is false<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Using these type traits, provides the following answer:<\/p>\n\n\n\n
Type<\/th>Trivial<\/th>Standard layout<\/th>POD<\/th><\/tr><\/thead>
A<\/code><\/td>\"\u2714\"<\/td>\"\u2714\"<\/td>\"\u2714\"<\/td><\/tr>
B<\/code><\/td>\"\u2714\"<\/td>\u274c<\/td>\u274c<\/td><\/tr>
C<\/code><\/td>\u274c<\/td>\"\u2714\"<\/td>\u274c<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
We can see from this table that B<\/code> is trivial, C<\/code> is standard-layout, and A<\/code> is trivial, standard-layout, and POD. And this leads us to the definition of a POD type:<\/p>\n\n\n\n
A POD type is a type that is both trivial and standard-layout. This definition must hold recursively for all its non-static data members.<\/p>\n\n\n\n
Or, in standardese:<\/p>\n\n\n\n
A POD class is a class that is both a trivial class and a standard-layout class, and has no non-static data members of type non-POD class (or array thereof). A POD type is a scalar type, a POD class, an array of such a type, or a cv-qualified version of one of these types.<\/p><\/blockquote>\n\n\n\n
\n
\n
This definition refers to scalar types, so for completeness, a scalar type is any of the following:<\/p>\n\n\n\n