Что такое правило строгих алиасов (strict aliasing rule) в C++ и как оно ломает код?

Что такое strict aliasing rule и почему он существует?

Правило строгих алиасов (strict aliasing rule) — это одно из самых коварных правил в C и C++. Оно говорит компилятору: если у вас есть два указателя разных типов (за некоторыми исключениями), они не могут ссылаться на одну и ту же область памяти. Компилятор использует это правило для агрессивной оптимизации.

В вашем примере компилятор видит: foo(int* a, float* b). По правилу строгих алиасов, a и b не могут указывать на одну память, потому что это разные типы (int и float). Поэтому компилятор делает предположение: запись в *b никак не может повлиять на *a. Он переупорядочивает инструкции, читает *a до записи в *b или вообще заменяет *a на константу 42, не читая память повторно. Результат — UB (неопределённое поведение).

Исключения из правила (когда алиасить можно)

Стандарт разрешает алиасить (обращаться к одной памяти через указатели разных типов) в следующих случаях:

• char*, unsigned char*, std::byte* — они могут алиасить что угодно. Это "легальный" способ смотреть на битовое представление любого объекта.
• Один и тот же тип (игнорируя cv-квалификаторы: const, volatile).
• Базовый и производный класс (при определённых условиях).
• Тип, совместимый с агрегатом (например, доступ к члену структуры через указатель на этот член).

Как правильно делать type-punning (изменение интерпретации памяти)?

Есть три корректных способа, которые не нарушают strict aliasing:

Способ 1: через memcpy (рекомендуемый)

Самый безопасный и переносимый способ — скопировать байты через memcpy. Современные компиляторы оптимизируют это в ноль накладных расходов:

#include <iostream>
#include <cstring>

float int_to_float(int value) {
    float result;
    std::memcpy(&result, &value, sizeof(value));
    return result;
}

int main() {
    int x = 42;
    float f = int_to_float(x);
    std::cout << f; // выведет битовое представление 42 как float (очень маленькое число)
    return 0;
}

Способ 2: через union (легально в C99, но в C++ есть нюансы)

В C++ стандарт гарантирует, что чтение неактивного члена union — это UB (хотя на практике GCC/Clang это поддерживают с флагами). Лучше не использовать:

union {
    int i;
    float f;
} u;
u.i = 42;
// u.f; // UB в C++ (хотя часто работает)

Способ 3: через char*/std::byte* (законный, но опасный)

Вы можете преобразовать указатель к char* или std::byte*, но не к произвольному типу:

int x = 42;
char* bytes = reinterpret_cast<char*>(&x);
// Теперь bytes[0], bytes[1] и т.д. — это байты int'а.
// НО: обратное преобразование char* -> int* для чтения — это нарушение алиасинга!
// Не делайте так:
// int* p = reinterpret_cast<int*>(bytes); // UB!

Как исправить ваш пример?

Ваш исходный код — это классический UB. Если вам нужно хранить разные типы в одной памяти, используйте std::variant, std::any или явное копирование через memcpy. Если вы пишете низкоуровневый код (например, парсеры), используйте std::bit_cast из C++20:

#include <bit>
#include <iostream>

int main() {
    int x = 42;
    float f = std::bit_cast<float>(x); // безопасно, constexpr в C++20
    std::cout << f;
    return 0;
}

std::bit_cast — это современная альтернатива memcpy, которая гарантированно не нарушает strict aliasing, так как реализована как встроенная функция компилятора.

Резюме

• Правило строгих алиасов запрещает обращаться к одной памяти через указатели разных типов (кроме char* и std::byte*).
• Компилятор использует это правило для оптимизации, и ваш код может сломаться.
• Используйте memcpy, std::bit_cast или char* для чтения байтов, но не делайте reinterpret_cast между несвязанными типами.
• Включайте флаги -fstrict-aliasing -Wstrict-aliasing в GCC/Clang, чтобы ловить такие ошибки на этапе компиляции.

#include <cstddef>
#include <type_traits>

template<typename T>
T read_from_buffer(const std::byte* buffer) {
    T result;
    std::memcpy(&result, buffer, sizeof(T));
    return result;
}