Поплавковые биты и строгий псевдоним

Я пытаюсь извлечь биты из float без вызова поведения undefined. Вот моя первая попытка:

unsigned foo(float x)
{
    unsigned* u = (unsigned*)&x;
    return *u;
}

Как я понимаю, это не гарантирует работу из-за строгих правил псевдонимов, верно? Работает ли он, если требуется промежуточный шаг с указателем на символ?

unsigned bar(float x)
{
    char* c = (char*)&x;
    unsigned* u = (unsigned*)c;
    return *u;
}

Или мне нужно самостоятельно извлечь отдельные байты?

unsigned baz(float x)
{
    unsigned char* c = (unsigned char*)&x;
    return c[0] | c[1] << 8 | c[2] << 16 | c[3] << 24;
}

Конечно, это имеет недостаток в зависимости от сущности, но я мог бы жить с этим.

Сбой соединения, безусловно, undefined, правильно?

unsigned uni(float x)
{
    union { float f; unsigned u; };
    f = x;
    return u;
}

Просто для полноты, вот эталонная версия foo. Кроме того, поведение undefined, правильно?

unsigned ref(float x)
{
    return (unsigned&)x;
}

Итак, возможно ли извлечь биты из float (, предполагая, что оба имеют ширину 32 бит)?

EDIT: И вот версия memcpy, предложенная Goz. Поскольку многие компиляторы еще не поддерживают static_assert, я заменил static_assert на шаблонное метапрограммирование:

template <bool, typename T>
struct requirement;

template <typename T>
struct requirement<true, T>
{
    typedef T type;
};

unsigned bits(float x)
{
    requirement<sizeof(unsigned)==sizeof(float), unsigned>::type u;
    memcpy(&u, &x, sizeof u);
    return u;
}

Ответ 1

Об единственном способе по-настоящему избежать каких-либо проблем является memcpy.

unsigned int FloatToInt( float f )
{
   static_assert( sizeof( float ) == sizeof( unsigned int ), "Sizes must match" );
   unsigned int ret;
   memcpy( &ret, &f, sizeof( float ) );
   return ret;
}

Поскольку вы сохраняете фиксированную сумму, компилятор оптимизирует ее.

Тем не менее, метод union очень широко поддерживается.

Ответ 2

Сбой соединения, безусловно, undefined, правильно?

Да и нет. Согласно стандарту, это определенно поведение undefined. Но это такой часто используемый трюк, что GCC и MSVC, насколько я знаю, каждый другой популярный компилятор явно гарантирует, что он безопасен и будет работать как ожидалось.

Ответ 3

Следующее не нарушает правило псевдонимов, поскольку оно не использует lvalues, доступ к которым осуществляется в разных типах

template<typename B, typename A>
B noalias_cast(A a) { 
  union N { 
    A a; 
    B b; 
    N(A a):a(a) { }
  };
  return N(a).b;
}

unsigned bar(float x) {
  return noalias_cast<unsigned>(x);
}

Ответ 4

Если вы действительно хотите быть агностиком относительно размера типа float и просто возвращать необработанные биты, сделайте что-то вроде этого:

void float_to_bytes(char *buffer, float f) {
    union {
        float x;
        char b[sizeof(float)];
    };

    x = f;
    memcpy(buffer, b, sizeof(float));
}

Затем назовите его так:

float a = 12345.6789;
char buffer[sizeof(float)];

float_to_bytes(buffer, a);

Этот метод, конечно, будет производить выходные данные, специфичные для вашего байтового байтового заказа.