{"id":498,"date":"2023-06-27T22:22:44","date_gmt":"2023-06-27T22:22:44","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=498"},"modified":"2023-08-23T16:21:26","modified_gmt":"2023-08-23T16:21:26","slug":"cpp-20-std-bit_cast","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/","title":{"rendered":"Making Use of C++20’s std::bit_cast"},"content":{"rendered":"\n

C++ is a language that’s continually evolving, introducing new features with each release that empower developers to write code that’s more efficient, safer, and simpler to understand. One of the most notable updates has been the C++20 standard, offering a slew of features that greatly enhances the language’s power and flexibility. It comes with a host of additions and modifications, all designed to make coding in C++ more enjoyable and more efficient. Some of these additions include concepts, coroutines, ranges, improved concurrency, and of course, the std::bit_cast<\/strong><\/code> function we’re going to discuss today.<\/p>\n\n\n\n

Among the various additions and improvements, std::bit_cast stands as an exciting innovation. This function is part of the <bit> header and is primarily used for safely reinterpreting an object representation from one type to another. It has made type punning in C++, which was a risky endeavor, safer and more manageable.<\/p>\n\n\n\n

Previously, developers had to rely on constructs like union or reinterpret_cast for type punning, which had their own set of challenges and risks. With std::bit_cast, the C++ language now has a safer and more reliable option to perform such operations.<\/p>\n\n\n\n

For C++ developers, especially those involved in performance-critical or low-level programming, understanding and utilizing std::bit_cast can be an essential skill. By ensuring safer type punning, it can help avoid undefined behavior and hard-to-debug issues, leading to more robust and reliable code. Therefore, mastering std::bit_cast not only enhances your technical skills but also sets you apart in the industry by demonstrating your proficiency in modern C++ standards.<\/p>\n\n\n\n

In this article, our goal is to provide you with a practical understanding of std::bit_cast. We will delve into the syntax, semantics, and requirements of std::bit_cast, offer practical code examples, discuss its advantages, and highlight potential pitfalls. By the end, we aim to equip you with the knowledge and confidence to effectively use std::bit_cast in your C++ projects.<\/p>\n\n\n\n

Understanding std::bit_cast<\/h2>\n\n\n\n

At its core, std::bit_cast<\/code> is a function template that reinterprets the object representation of a value from one type to another. Part of the <bit><\/code> header in C++20, it facilitates ‘safe type punning’ in the language. So, what does this mean?<\/p>\n\n\n\n

Type punning is a common technique in C++ that involves treating an object of one type as if it were an object of another type, effectively allowing the manipulation of the underlying bit pattern. Previously, this was done using constructs like unions or the reinterpret_cast<\/code> operator. However, both had their challenges and potential pitfalls.<\/p>\n\n\n\n

Enter std::bit_cast<\/code>. It offers a safer and more reliable way to perform type punning. Unlike reinterpret_cast<\/code>, it does not violate strict aliasing rules, thereby avoiding undefined behavior.<\/p>\n\n\n\n

Consider a situation where you want to inspect the binary representation of a floating-point number, or perhaps convert a sequence of bytes into a meaningful structure. In these scenarios, std::bit_cast<\/code> comes in handy, allowing you to reinterpret bits between types without violating the type aliasing rules.<\/p>\n\n\n\n

But how does it differ from reinterpret_cast<\/code>?<\/p>\n\n\n\n

std::bit_cast vs. reinterpret_cast<\/h3>\n\n\n\n

In simple terms, std::bit_cast<\/code> does what many developers have been attempting to achieve with reinterpret_cast<\/code>, but in a safer manner. The reinterpret_cast<\/code> operator provides a low-level mechanism for reinterpreting the bit pattern of an object. However, it comes with risks, especially when it comes to type aliasing.<\/p>\n\n\n\n

The type aliasing rules in C++ stipulate that an object should only be accessed through its own type, or certain allowed types. Violating these rules leads to undefined behavior. Unfortunately, reinterpret_cast<\/code> often leads to such violations.<\/p>\n\n\n\n

On the other hand, std::bit_cast<\/code> is designed to avoid violating the aliasing rules. It copies the bits from the source object to the destination object, effectively creating a new object. This makes std::bit_cast<\/code> a safer alternative for type punning, reducing the risk of undefined behavior.<\/p>\n\n\n\n

However, it’s important to note that std::bit_cast<\/code> does have its limitations. The source and destination types must be the same size, and both must be trivially copyable. These restrictions ensure the safety of the bit copying operation.<\/p>\n\n\n\n

A Deep Dive into std::bit_cast<\/h2>\n\n\n\n

Delving deeper into std::bit_cast<\/code>, it’s crucial to understand its syntax and semantics. At its essence, the syntax of std::bit_cast<\/code> is quite straightforward. It takes the form of a single function template:<\/p>\n\n\n

template<\/span> <class<\/span> To<\/span>, class<\/span> From<\/span>>\r\nconstexpr<\/span> To<\/span> bit_cast<\/span>(const<\/span> From<\/span>& from<\/span>) noexcept<\/span>;<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
Here, To<\/code> and From<\/code> represent the destination type and the source type, respectively. The bit_cast<\/code> function returns a value of the destination type To<\/code> that has the same bit pattern as the input value from<\/code>.<\/p>\n\n\n\n
Underneath the hood, std::bit_cast<\/code> reinterprets the bit pattern of the source object into the type of the destination object. It does so by creating a bitwise copy of the source object representation into the destination object, without changing the bit pattern.<\/p>\n\n\n\n
Requirements and Constraints<\/h3>\n\n\n\n
While std::bit_cast<\/code> is an incredibly useful tool, there are certain requirements and constraints associated with its use:<\/p>\n\n\n\n
    \n
  1. Same Size:<\/strong> Both the source and destination types must have the same size. This requirement ensures a one-to-one correspondence between the bits in the source and destination objects.<\/li>\n\n\n\n
  2. Trivially Copyable:<\/strong> Both the source and destination types must be trivially copyable. This means they can be copied with the same semantics as a raw memory copy, without any special copy or move constructors, or any destructors.<\/li>\n\n\n\n
  3. Constant Expression:<\/strong> std::bit_cast<\/code> can be used in constant expressions, as the function itself is constexpr<\/code>. This means that it can produce compile-time constants given constant inputs, which can be useful in template metaprogramming or when defining constants at namespace scope.<\/li>\n<\/ol>\n\n\n\n
    Safety Aspects<\/h3>\n\n\n\n
    From a safety perspective, std::bit_cast<\/code> is a significant upgrade from techniques like reinterpret_cast<\/code> for type punning. It provides a mechanism to reinterpret the bits of an object that is more constrained, thereby reducing the risk of undefined behavior.<\/p>\n\n\n\n
    The requirements of having the same size and being trivially copyable for both the source and destination types ensure that no unexpected bit patterns are introduced during the casting process. This safety mechanism helps avoid potential runtime errors and hard-to-debug issues.<\/p>\n\n\n\n
    Moreover, since std::bit_cast<\/code> creates a new object instead of merely providing a different view of the same memory (like reinterpret_cast<\/code>), it does not violate the strict aliasing rules, avoiding another common source of undefined behavior.<\/p>\n\n\n\n
    Practical Examples of Using std::bit_cast<\/h2>\n\n\n\n
    Let’s explore some practical examples of std::bit_cast<\/code> to understand its utility better. We’ll walk through some code snippets and dissect what’s happening step-by-step.<\/p>\n\n\n\n
    Example 1: Float to Int Conversion<\/h3>\n\n\n\n
    Consider a scenario where you have a floating-point number and you need to examine its binary representation. In C++20, this can be achieved using std::bit_cast<\/code>.<\/p>\n\n\n
    #include<\/span> <bit><\/span><\/span>\r\n#include<\/span> <iostream><\/span><\/span>\r\n\r\nint<\/span> main<\/span>()<\/span> <\/span>{\r\n    float<\/span> f = 23.45f<\/span>;\r\n    auto<\/span> i = std<\/span>::bit_cast<int<\/span>>(f);\r\n\r\n    std<\/span>::cout<\/span> << \"Integer representation of the float is: \"<\/span> << i << '\\n'<\/span>;\r\n    return<\/span> 0<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this code snippet, we’re converting a float to its integer representation using std::bit_cast<\/code>. The result will be the integer that has the same bit pattern as our float f<\/code>. The output might seem like a random number, but it’s simply the integer representation of the bit pattern of f<\/code>.<\/p>\n\n\n\n
    Example 2: RGB Color to Uint32 Conversion<\/h3>\n\n\n\n
    Imagine you have an RGB color and you want to pack it into a uint32_t<\/code> for efficient storage or manipulation. std::bit_cast<\/code> can help here.<\/p>\n\n\n
    #include<\/span> <bit><\/span><\/span>\r\n#include<\/span> <cstdint><\/span><\/span>\r\n#include<\/span> <iostream><\/span><\/span>\r\n\r\nstruct<\/span> Color<\/span> {<\/span>\r\n    uint8_t<\/span> r, g, b, a;\r\n};\r\n\r\nint<\/span> main<\/span>()<\/span> <\/span>{\r\n    Color color = {255<\/span>, 128<\/span>, 64<\/span>, 255<\/span>};\r\n    auto<\/span> packedColor = std<\/span>::bit_cast<uint32_t<\/span>>(color);\r\n\r\n    std<\/span>::cout<\/span> << \"Packed color value is: \"<\/span> << packedColor << '\\n'<\/span>;\r\n    return<\/span> 0<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, std::bit_cast<\/code> is used to convert a Color<\/code> struct into a uint32_t<\/code>. The resulting value is a 32-bit integer that packs the RGBA values into its bit pattern.<\/p>\n\n\n\n
    Example 3: From Bytes to Struct<\/h3>\n\n\n\n
    Now, let’s reverse the process and convert a sequence of bytes into a meaningful structure.<\/p>\n\n\n
    #include<\/span> <bit><\/span><\/span>\r\n#include<\/span> <cstdint><\/span><\/span>\r\n#include<\/span> <iostream><\/span><\/span>\r\n#include<\/span> <array><\/span><\/span>\r\n\r\nstruct<\/span> Point<\/span> {<\/span>\r\n    float<\/span> x, y, z;\r\n};\r\n\r\nint<\/span> main<\/span>()<\/span> <\/span>{\r\n    std<\/span>::array<\/span><uint8_t<\/span>, 12> bytes = { \/* ... some bytes ... *\/<\/span> };\r\n    auto<\/span> point = std<\/span>::bit_cast<Point>(bytes);\r\n\r\n    std<\/span>::cout<\/span> << \"Point coordinates are: (\"<\/span> << point.x << \", \"<\/span> << point.y << \", \"<\/span> << point.z << \")\\n\"<\/span>;\r\n    return<\/span> 0<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this case, we have an array of bytes that we know represents a Point<\/code> struct, and we use std::bit_cast<\/code> to convert it back to its original form.<\/p>\n\n\n\n
    In all of these examples, std::bit_cast<\/code> is necessary because we are manipulating the bit representation of objects. Without std::bit_cast<\/code>, we would have to use riskier techniques like reinterpret_cast<\/code> or unions, which could potentially lead to undefined behavior. std::bit_cast<\/code> offers a safer and more straightforward way to achieve the same goal.<\/p>\n\n\n\n
    Advantages of Using std::bit_cast over Other Alternatives<\/h2>\n\n\n\n
    Using std::bit_cast<\/code> for type punning in C++20 offers significant advantages over traditional methods like reinterpret_cast<\/code> or union. Let’s take a look at these benefits in detail.<\/p>\n\n\n\n
    Safety<\/h3>\n\n\n\n
    The most prominent advantage of std::bit_cast<\/code> is its safety. Traditional methods such as reinterpret_cast<\/code> and union could easily lead to undefined behavior, primarily due to violations of strict aliasing rules. In contrast, std::bit_cast<\/code> creates a new object with the same bit representation, thus avoiding any potential aliasing issues.<\/p>\n\n\n\n
    For example, using reinterpret_cast<\/code> to convert a float to an int could potentially lead to problems.<\/p>\n\n\n
    float<\/span> f = 23.45f<\/span>;\r\nint<\/span> i = *reinterpret_cast<\/span><int<\/span>*>(&f);  \/\/ Risky! Could lead to undefined behavior<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    With std::bit_cast<\/code>, the same operation is safer and more reliable.<\/p>\n\n\n
    float<\/span> f = 23.45f<\/span>;\r\nint<\/span> i = std<\/span>::bit_cast<int<\/span>>(f);  \/\/ Safe and reliable<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    Predictability<\/h3>\n\n\n\n
    std::bit_cast<\/code> is more predictable than alternatives like union or reinterpret_cast<\/code>. It operates under well-defined constraints – the source and destination types must be the same size and trivially copyable. These rules ensure a consistent behavior, reducing the potential for errors and unexpected results.<\/p>\n\n\n\n
    For instance, if you attempt to use a union to perform type punning between types of different sizes or non-trivially copyable types, the behavior is undefined.<\/p>\n\n\n
    union<\/span> {\r\n    float<\/span> f;\r\n    int<\/span> i;\r\n} u;\r\n\r\nu.f = 23.45f<\/span>;\r\nint<\/span> i = u.i;  \/\/ Undefined behavior if float and int are not the same size<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    On the contrary, using std::bit_cast<\/code> for the same purpose would result in a compile-time error if the sizes are not the same, allowing the problem to be caught much earlier.<\/p>\n\n\n\n
    Efficiency<\/h3>\n\n\n\n
    std::bit_cast<\/code> can also offer efficiency benefits. Since it operates by creating a bitwise copy, it often boils down to a single move instruction at the assembly level, ensuring a fast and efficient operation. This low-level efficiency makes std::bit_cast<\/code> an attractive option for performance-critical applications.<\/p>\n\n\n\n
    For example, imagine a scenario where you’re packing RGB values into a single integer for efficient processing in a graphics application. Using a union or reinterpret_cast might be less efficient due to potential aliasing issues, whereas std::bit_cast<\/code> would likely compile down to a single instruction.<\/p>\n\n\n
    Color color = {255<\/span>, 128<\/span>, 64<\/span>, 255<\/span>};\r\nuint32_t<\/span> packedColor = std<\/span>::bit_cast<uint32_t<\/span>>(color);  \/\/ Likely a single instruction<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    In a nutshell, std::bit_cast<\/code> provides a safer, more predictable, and potentially more efficient alternative to traditional methods for type punning. It significantly reduces the risk of undefined behavior, making your C++ code more robust and reliable. If you’re dealing with bit-level manipulations, std::bit_cast<\/code> is an indispensable tool to have in your C++20 arsenal.<\/p>\n\n\n\n
    Limitations and Potential Pitfalls of std::bit_cast<\/h2>\n\n\n\n
    While std::bit_cast<\/code> is a significant improvement over traditional methods for type punning, it does come with certain limitations and potential pitfalls that developers need to be aware of.<\/p>\n\n\n\n
    Same Size Requirement<\/h3>\n\n\n\n
    One of the primary limitations of std::bit_cast<\/code> is that it requires the source and destination types to have the same size. If you attempt to use std::bit_cast<\/code> with types of different sizes, you’ll encounter a compile-time error. While this constraint safeguards against many types of errors, it does limit the utility of std::bit_cast<\/code> in some scenarios.<\/p>\n\n\n\n
    Trivially Copyable Requirement<\/h3>\n\n\n\n
    Another constraint is that both the source and destination types must be trivially copyable. This means they can’t have custom copy or move constructors, destructors, or similar special member functions. Types with such features can’t be safely copied via std::bit_cast<\/code>.<\/p>\n\n\n\n
    Beware of Platform Specifics<\/h3>\n\n\n\n
    Although std::bit_cast<\/code> guarantees safe bit-wise copying, it doesn’t abstract away platform-specific details. For example, the endianess of the system (little-endian vs. big-endian) or the representation of certain types (like floating-point numbers) can still affect the results of std::bit_cast<\/code>. Thus, code that uses std::bit_cast<\/code> might not be perfectly portable between different systems.<\/p>\n\n\n\n
    Avoid Misinterpretation<\/h3>\n\n\n\n
    A common mistake when using std::bit_cast<\/code> is misinterpretation of the bit pattern. It’s crucial to remember that std::bit_cast<\/code> only provides a different view of the same bit pattern; it doesn’t convert values between different types. For example, using std::bit_cast<\/code> to view a float as an int doesn’t provide the integer equivalent of the float value, but rather an integer with the same bit pattern.<\/p>\n\n\n\n
    Best Practices for Using std::bit_cast<\/h2>\n\n\n\n
    std::bit_cast<\/code> is a powerful feature introduced in C++20. To use it effectively and safely, here are some best practices:<\/p>\n\n\n\n
      \n
    1. Understand the requirements:<\/strong> Remember that the source and destination types of std::bit_cast<\/code> must be of the same size and trivially copyable. Always ensure these conditions are met before using std::bit_cast<\/code>.<\/li>\n\n\n\n
    2. Beware of platform specifics:<\/strong> Even though std::bit_cast<\/code> provides a safe way to view one type as another, the underlying bit representation can still depend on the platform. Be aware of potential issues, such as differences in endianess or floating-point representation, when writing code that’s intended to be portable.<\/li>\n\n\n\n
    3. Avoid misinterpretation:<\/strong> std::bit_cast<\/code> does not perform type conversion; it only changes the interpretation of a bit pattern. Avoid mistakes by remembering that the numerical values of bit_casted types may not correspond in any meaningful way.<\/li>\n\n\n\n
    4. Use for specific needs:<\/strong> While std::bit_cast<\/code> is safer than traditional methods for type punning, it should not be used frivolously. Reserve it for situations where you specifically need to manipulate or inspect the bit patterns of objects.<\/li>\n\n\n\n
    5. Upgrade to C++20:<\/strong> If you haven’t already, upgrade your code to C++20 to take advantage of std::bit_cast<\/code> and other modern features. They provide safer, more expressive, and more efficient ways to write C++ code.<\/li>\n<\/ol>\n\n\n\n
      By following these practices, you can ensure that you’re using std::bit_cast<\/code> effectively and safely, helping you to write robust and efficient C++ code.<\/p>\n","protected":false},"excerpt":{"rendered":"
      C++ is a language that’s continually evolving, introducing new features with each release that empower developers to write code that’s more efficient, safer, and simpler to understand. One of the most notable updates has been the C++20 standard, offering a slew of features that greatly enhances the language’s power and flexibility. It comes with a […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[9,4],"tags":[],"class_list":["post-498","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nMaking Use of C++20's std::bit_cast<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Making Use of C++20's std::bit_cast\" \/>\n<meta property=\"og:description\" content=\"C++ is a language that’s continually evolving, introducing new features with each release that empower developers to write code that’s more efficient, safer, and simpler to understand. One of the most notable updates has been the C++20 standard, offering a slew of features that greatly enhances the language’s power and flexibility. It comes with a […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-06-27T22:22:44+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-23T16:21:26+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Making Use of C++20’s std::bit_cast\",\"datePublished\":\"2023-06-27T22:22:44+00:00\",\"dateModified\":\"2023-08-23T16:21:26+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/\"},\"wordCount\":2098,\"commentCount\":0,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/\",\"name\":\"Making Use of C++20's std::bit_cast\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-06-27T22:22:44+00:00\",\"dateModified\":\"2023-08-23T16:21:26+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-20-std-bit_cast\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"C++\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/cplusplus\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Making Use of C++20’s std::bit_cast\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781957457\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781957457\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781957457\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Making Use of C++20's std::bit_cast","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/","og_locale":"en_US","og_type":"article","og_title":"Making Use of C++20's std::bit_cast","og_description":"C++ is a language that’s continually evolving, introducing new features with each release that empower developers to write code that’s more efficient, safer, and simpler to understand. One of the most notable updates has been the C++20 standard, offering a slew of features that greatly enhances the language’s power and flexibility. It comes with a […]","og_url":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/","article_published_time":"2023-06-27T22:22:44+00:00","article_modified_time":"2023-08-23T16:21:26+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Making Use of C++20’s std::bit_cast","datePublished":"2023-06-27T22:22:44+00:00","dateModified":"2023-08-23T16:21:26+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/"},"wordCount":2098,"commentCount":0,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/","url":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/","name":"Making Use of C++20's std::bit_cast","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-06-27T22:22:44+00:00","dateModified":"2023-08-23T16:21:26+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/cpp-20-std-bit_cast\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"C++","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/cplusplus\/"},{"@type":"ListItem","position":4,"name":"Making Use of C++20’s std::bit_cast"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781957457","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781957457","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781957457","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/498","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=498"}],"version-history":[{"count":5,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/498\/revisions"}],"predecessor-version":[{"id":503,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/498\/revisions\/503"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=498"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=498"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=498"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}