Будет ли это нарушение правила строгого сглаживания вести себя так, как я ожидаю?

В большинстве компиляторов он будет делать то, что вы ожидаете, пока оптимизатор не решит удалить мертвый код или переместить назначение в f.

Это делает практически невозможным проверить, будет ли тот или иной данный компилятор всегда делать то, что вы ожидаете — он может работать для одной конкретной программы, но затем несколько другая может дать сбой. Правило строгого псевдонима в основном просто говорит разработчику компилятора: «Вы можете довольно свободно переставлять и удалять эти вещи, предполагая, что они никогда не будут псевдонимами». Когда бесполезно делать что-то, что может привести к сбою этого кода, оптимизатор, вероятно, этого не сделает, так что вы не увидите проблемы.

Суть в том, что полезно говорить о том, «на каких компиляторах это будет иногда работать», поскольку в будущем он может внезапно перестать работать на любом из них, если что-то, казалось бы, не связанное с этим изменится.

float f = 1234.567;  /* Any value here */
unsigned int u = *(unsigned int *)&f;

Вот несколько вероятных причин, по которым это не сработает должным образом:

1. float и unsigned int не одного размера. (Я работал с системами, где int составляет 64 бита, а float — 32 бита. Я также работал с системами, где int и float являются 64-битными, поэтому ваше предположение о том, что копируются 4 байта, не оправдалось.)

2. float и unsigned int имеют разные требования к выравниванию. В частности, если unsigned int требует более строгого выравнивания, чем float, а f оказывается строго выровненным, чтение f как unsigned int может привести к плохим последствиям. (Это вероятно маловероятно, если int и float имеют одинаковый размер.)

3. Компилятор может распознать, что поведение кода не определено, и, например, оптимизировать присваивание. (У меня нет конкретного примера этого.)

Если вы хотите скопировать представление float в unsigned int, memcpy() безопаснее (и я бы сначала проверил, что они действительно имеют одинаковый размер). Если вы хотите изучить представление объекта float, канонический способ сделать это — скопировать его в массив unsigned char. Цитирование стандарта ISO C (6.2.6.1p4 в N1570 черновик):

Значения, хранящиеся в объектах без битовых полей любого другого типа объекта, состоят из n × CHAR_BIT бит, где n — размер объекта. этого типа в байтах. Значение может быть скопировано в объект типа unsigned char [ n ] (например, с помощью memcpy); результирующий набор байтов называется представлением объекта значения.

Вы вызываете неопределенное поведение без всякой причины.

Будет ли это нарушение правил строгого сглаживания вести себя так, как я ожидаю?

Нет. И вам не нужно ничего ожидать, потому что вы можете написать гораздо более красивый код.

Это определило поведение, которое вы хотели бы:

union {
  float f;
  uint32_t i;
} ufi_t;
assert(sizeof(float) == sizeof(uint32_t);

ufi_t u = { 123.456 };
uint32_t i = u.i;

Вы можете исключить это, приличные компиляторы не будут генерировать для него код:

inline uint32_t int_from_float(float f) {
  ufi_t u = { f };
  return u.i;
}

Вы также можете безопасно перевести из (*float) в (*ufi_t). Так:

float f = 123.456;
uint32_t i = ((ufi_t*)&f)->i;

Примечание: языковые юристы могут разъяснить мне последнее, но это то, что я делаю с C9899:201x 6.5 и так далее.