Строгий aliasing в C++: что это и как не отстрелить себе ногу

Что такое strict aliasing rule и почему ваш C++ код может внезапно сломаться?

Вы когда-нибудь писали, казалось бы, совершенно правильный код на C++, а компилятор на высоких уровнях оптимизации (-O2 или -O3) превращал его в нечто нерабочее? Добро пожаловать в мир строгого алиасинга (strict aliasing rule). Это одно из самых коварных правил языка, которое может превратить отладку в настоящий квест. На PythonLib мы любим разбираться в сложных темах простым языком, и сегодняшняя статья — не исключение.

Давайте представим: у вас есть два указателя разных типов, указывающих на одну и ту же область памяти. Компилятор, следуя strict aliasing rule, имеет полное право решить, что они не могут ссылаться на один объект. И если вы нарушите это правило — ждите неопределенного поведения (UB). Программа может работать, может упасть, а может показать неверные результаты. Звучит страшно? Давайте разбираться.

Суть правила: почему компилятор такой «строгий»?

Strict aliasing rule в C++ (и C) гласит: обращаться к объекту через указатель или ссылку несовместимого типа — это UB. Исключения есть только для char, unsigned char и std::byte. Зачем это нужно? Ответ прост: оптимизация. Если компилятор уверен, что два указателя разных типов не могут указывать на одну память, он может смело переставлять операции, кэшировать значения в регистрах и агрессивно оптимизировать код. Без этого правила производительность многих программ упала бы в разы.

Но есть и обратная сторона: разработчики, которые пытаются сделать type punning (интерпретацию одних и тех же байтов как разных типов), часто нарываются на грабли. Классический пример — попытка быстро проверить, является ли число с плавающей точкой NaN, через reinterpret_cast к int. Компилятор может «сломать» такой код.

Как выглядит нарушение strict aliasing? Примеры кода

Рассмотрим самый популярный пример, который кочует из одного Stack Overflow в другой:

#include <iostream>
#include <cstdint>

int main() {
    float f = 3.14f;
    // Нарушение strict aliasing: читаем float как int
    int* pi = reinterpret_cast<int*>(&f);
    std::cout << *pi; // UB!
    return 0;
}

На первый взгляд — обычный трюк для просмотра битового представления float. Но стандарт C++ говорит: float и int — несовместимые типы. Компилятор может оптимизировать этот код так, что вы получите мусор. С включенными оптимизациями GCC, например, может просто вернуть какое-то заведомо известное значение или вообще убрать код.

Другой пример — работа с массивами байтов:

struct Point { int x, y; };
char buffer[sizeof(Point)];
// Заполняем buffer...
Point* p = reinterpret_cast<Point*>(buffer);
p->x = 42; // UB, если buffer не был создан как Point

Здесь нарушение происходит потому, что buffer — это массив char, а мы обращаемся к нему как к Point. Хотя char* может указывать на любой объект, обратное неверно: Point* не может указывать на char[], если только память не была выделена как Point.

Сравнение подходов: как обойти strict aliasing безопасно?

Существует несколько способов легально выполнять type punning в C++. Мы сравним три основных подхода: memcpy, union и std::bit_cast (C++20). Каждый имеет свои плюсы и минусы.

1. memcpy — старый добрый способ

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

#include <cstring>
#include <iostream>

float f = 3.14f;
int i;
std::memcpy(&i, &f, sizeof(f));
std::cout << i; // OK, нет UB

Плюсы: полностью соответствует стандарту, работает везде, легко читается. Минусы: нужно быть аккуратным с размерами, не подходит для константных выражений.

2. union — ловкий, но с оговорками

В C++ использование union для type punning долгое время было спорным. В C это разрешено, но C++ долго считал это UB. Начиная с C++17, стандарт явно разрешает чтение неактивного члена union при определенных условиях (если оба члена — стандартной компоновки). Однако на практике это работает во всех основных компиляторах:

union FloatInt {
    float f;
    int i;
};

FloatInt u;
u.f = 3.14f;
std::cout << u.i; // Работает, но будьте осторожны с нестандартными типами

Плюсы: кратко, читаемо. Минусы: не все компиляторы трактуют одинаково, не подходит для сложных типов с конструкторами.

3. std::bit_cast — современный стандарт (C++20)

Идеальное решение для C++20 и новее. std::bit_cast — это безопасная обертка над memcpy, которая работает на этапе компиляции и не нарушает strict aliasing:

#include <bit>
#include <iostream>

float f = 3.14f;
int i = std::bit_cast<int>(f);
std::cout << i; // OK, C++20

Плюсы: безопасно, читаемо, константное выражение. Минусы: требует C++20 и поддержки компилятора.

Практический пример: как strict aliasing ломает наивный код

Представьте, что вы пишете свою реализацию std::vector и решили использовать reinterpret_cast для доступа к элементам:

template<typename T>
class MyVector {
    char* data;
public:
    T& operator[](size_t idx) {
        return *reinterpret_cast<T*>(data + idx * sizeof(T));
    }
};

MyVector<int> v; // data указывает на char[]
v[0] = 42; // UB!

Этот код нарушает strict aliasing, и компилятор может его «оптимизировать» до неузнаваемости. Правильный подход — использовать std::aligned_storage или placement new:

template<typename T>
class MyVector {
    alignas(T) char data[sizeof(T)];
public:
    T& operator