Ну, що ж раз просять, то будемо оживляти розділ по С++. Вирішив трохи поговорити про доволі тривіальну задачу, з дуже не тривіальним її вирішенням. Так, мова йтиме про переносиму/портабельну версію type punning або про щось дуже схоже на нього.

Трохи про те, що це таке, якщо перекладати дослівно то,  "pun" - це жарт, що має кілька значень або звучить як інше слово. Тобто, це деяка гра слів, яка використовує різні значення терміна або схожих за звучанням слів. Ну, а власне "type" - це тип, думаю тут зрозуміло. Тобто, якщо переводити на комп'ютерний сленг, то це є деякий хак, який обходить типову (від слова "type") систему, щоб досягти ефекту, який було б важко або неможливо досягти в межах правил мови програмування.

Якщо говорити ще більш конкретно в рамках С/С++, то ми інколи хочемо перетворити об'єкт типу T в об'єкт типу U, тобто зробити приведення між непов'язаними типами. В С та і загалом в С++, зазвичай це досягається шляхом використання union’ів, а саме записом в одне поле, а читанням з іншого.

Ця практика є настільки популярною, що її використання можна знайти майже у будь-якому більш менш великому проєкті, де потрібно було отримати так хоч теж банальне бітове представлення числа. Часте використання type punning можна зустріти, наприклад, в ядрі Лінукса або у source-кодах Apple, проте це все мова про С, де така штука як type punning загалом well-defined. У С++ же type punning спричиняє невизначену поведінку.
І на цьому можна було б розійтися але, що якщо мені потрібно зробити це, невже нічого з цим не зробити, як говориться hold on. На С++ можна знайти багато прикладів використання type punning, по аналогії з С і не лише на SO, але і у кодах доволі великих проєктів написаних уже на С++ , наприклад у гуглівському фреймворку для юніт тестування GTEST.  У них є такий макрос як ASSERT_DOUBLE_EQ, який порівнює числа з рухомою комою і якщо подивитися як він реалізований можна побачити таке:

// Я прибрав все лишнє для простоти.
template <typename RawType>
class FloatingPoint 
{
    ...
    static RawType ReinterpretBits(const Bits bits)
    {
        FloatingPoint fp(0);
      fp.u_.bits_ = bits;    
        return fp.u_.value_;   // <--- осьо
    }
    ...
    private:
        union FloatingPointUnion 
        {
            RawType value_;  
            Bits bits_;      
        };
    ...
    FloatingPointUnion u_;
};

В даному випадку згідно стандарту це UB чистої води, не можна читати з неактивного поля union’а в С++. Вся справа у strict aliasing'y, невже хлопці з гугл цього не знають?

З усім тим, як ми бачимо ця "техніка" є доволі потрібною не дивлячись нінащо. Можливо тоді все ж існує яке рішення, невже немає ніяких виходів? Звернімось з цим питання до інтернету, зайшовши на кілька перших посилань на SO, можна дійсно побачити як приклади з union’ами, так і з використанням memcpy - мовляв через memcpy це не UB, та чи дійсно це так?
Подивімось, що каже стандарт:

Тут напрошується доволі чіткий висновок, про те, що, якщо ми хочемо скопіювати два об'єкти (underlying bytes), то ми це можемо зробити тільки тоді, коли вони мають the same trivially copyable type T. Звідси, той же punning між int і float навіть через memcpy - UB? Чи ні? Якщо зайти в документацію і почитати опис memcpy, то можна помітити одну цікаву річ:

Гм, то все ж це не UB? Адже memcpy інтерпретує об'єкти як масив чарів отже вони зводяться до одного типу, тобто все ОК? Загалом так, але з точки зору стандарту це виглядає трохи дивно, адже сам стандарт нічого такого не обіцяє. Тобто всі ці штуки з інтерпретацією, які робить memcpy залежать від реалізації, тобто це все ж ходіння по краю леза, якщо ми хочемо мати  якусь портабельну версію type punning'a.

То невже немає ніякого рішення? Якщо ми говоримо про С++17, то, напевне ні, немає. Загалом, якщо не стоїть питання про написання саме portable версії, яка має працювати завжди і всюди, то все не так погано. Тоді можна скористатися і memcpy, іякщо ви добре знаєте як цю ситуацію обробляють компілятори з якими ви працюєте, то можете навіть користуватися версією з union’ами. Зазвичай, якщо ваш компілятор підтримує С, то швидше за все і в С++ у вас не буде проблем з type punning'ом через union, ба більше компілятори добре розуміють, що ви хочете зробити і швидше за все згенерують однаковий вихлоп, що для версії з використанням memcpy, що з union’ами. Бо розробники компіляторів теж не ідіоти і не стануть спеціально вставляти палки в колеса, принаймні більшість з них (цікаво чи хлопці з гугл це перевірили?)

Проте, якщо вже говорити про свіжий С++20 то там з'явився новий вид перетворення під назвою bit_cast, який покликаний зробити за нас все те, що ми хотіли

А що ви думаєте з цього приводу? Як ви викручується з ситуації, діліться