Правило строгих псевдонимов (strict aliasing rule) в C++: что это и как избежать UB?

Что такое Strict Aliasing Rule (правило строгих псевдонимов)?

Это правило языка C/C++, которое говорит компилятору: вы не можете обращаться к одному и тому же участку памяти через указатели разных типов (за исключением нескольких специальных случаев). Формально в стандарте C++ (basic.lval) сказано, что вы можете читать/писать объект только через:

• Его собственный тип (например, int* для int)
• const или volatile версию его типа
• unsigned char, std::byte или char (для просмотра байтов)
• Базовый класс (для наследования)
• Тип, совместимый по знаковости (например, signed int и unsigned int)

Ваш пример reinterpret_cast<int*>(&value) нарушает правило, потому что вы обращаетесь к объекту типа float через указатель на int. Это undefined behavior (UB).

Почему компилятор так строг?

Представьте, что компилятор видит такой код:

float f = 3.14f;
int* p = (int*)&f;
// Компилятор может решить, что p и f не указывают на одну память (по правилу aliasing)
// И переупорядочить операции, сломав вашу логику

Строгие псевдонимы позволяют компилятору агрессивно оптимизировать код. Например:

void process(float* a, int* b) {
    *a = 1.0f;
    *b = 42;    // Компилятор считает, что a и b не пересекаются
    *a = 2.0f;  // Может удалить первую запись, т.к. *b не мог изменить *a
}

Если бы вы передали один и тот же адрес как float* и int*, компилятор выдал бы UB.

Как правильно "заглянуть" в байты float?

Есть три безопасных способа:

1. Через memcpy (рекомендуемый):

float value = 3.14f;
int result;
std::memcpy(&result, &value, sizeof(value));
// Теперь result содержит битовое представление value как int
// Это 100% валидный C++

2. Через std::bit_cast (C++20):

float value = 3.14f;
int result = std::bit_cast<int>(value);
// Самый современный и безопасный способ

3. Через unsigned char* (исключение из правила):

float value = 3.14f;
unsigned char* bytes = reinterpret_cast<unsigned char*>(&value);
for (size_t i = 0; i < sizeof(float); ++i) {
    std::cout << static_cast<int>(bytes[i]) << " ";
}
// Это разрешено: char/unsigned char/std::byte могут алиасить любой тип

Почему ваш код работает в Debug, но не в Release?

В Debug-режиме оптимизации отключены, и компилятор генерирует "наивный" код, который выполняет то, что написано. В Release с -O2 или -O3 компилятор применяет правило строгих псевдонимов для оптимизации. Он может:

• Кэшировать значение value в регистре
• Переупорядочить операции
• Игнорировать запись через int*, посчитав её не влияющей на float

Важные исключения из правила

• char*, unsigned char*, std::byte* — могут алиасить любой тип (только для чтения/записи байтов)
• Типы с одинаковым представлением (например, int и unsigned int)
• Агрегатные типы и их элементы

Золотое правило: Если вы хотите интерпретировать память одного типа как другой — используйте memcpy или bit_cast. Компилятор оптимизирует их в простой регистровый move, и вы получите и скорость, и безопасность.

union FloatInt {
    float f;
    int i;
};

FloatInt u;
u.f = 3.14f;
std::cout << u.i; // UB в C++ (хотя многие компиляторы это поддерживают)