«Небезопасная» функция С# — *(с плавающей запятой*)(&результат) против (с плавающей запятой)(результат)

В .NET float представляется с помощью бинарного32 IEEE числа одинарной точности с плавающей запятой, хранящегося с использованием 32 биты. Очевидно, код создает это число, собирая биты в int, а затем преобразуя его в float, используя unsafe. Приведение - это то, что в терминах C++ называется reinterpret_cast, где при выполнении приведения не выполняется преобразование - биты просто переинтерпретируются как новый тип.

Собранное число равно 4019999A в шестнадцатеричном формате или 01000000 00011001 10011001 10011010 в двоичном:

• Знаковый бит равен 0 (это положительное число).
• Биты показателя степени равны 10000000 (или 128), в результате чего показатель степени 128 - 127 = 1 (дробь умножается на 2^1 = 2).
• Биты дроби — это 00110011001100110011010, которые, по крайней мере, имеют почти узнаваемую структуру нулей и единиц.

Возвращаемое число с плавающей запятой имеет те же самые биты, что и 2.4, преобразованные в число с плавающей запятой, и всю функцию можно просто заменить литералом 2.4f.

Последний ноль, который как бы «разрывает битовый шаблон» дроби, возможно, существует для того, чтобы число с плавающей запятой соответствовало чему-то, что можно записать с использованием литерала с плавающей запятой?

Так в чем же разница между обычным броском и этим странным «небезопасным броском»?

Предположим, следующий код:

int result = 0x4019999A // 1075419546
float normalCast = (float) result;
float unsafeCast = *(float*) &result; // Only possible in an unsafe context

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

Второй бросок более зловещий (и может выполняться только в небезопасном контексте). &result берет адрес result, возвращая указатель на место, где хранится целое число 1075419546. Затем можно использовать оператор разыменования указателя * для извлечения значения, на которое указывает указатель. Использование *&result извлечет целое число, хранящееся в ячейке, однако при первом приведении указателя к float* (указатель на float) вместо этого из ячейки памяти извлекается число с плавающей запятой, в результате чего число с плавающей запятой 2.4f назначается unsafeCast. Таким образом, описание *(float*) &result таково: дайте мне указатель на result и предположите, что указатель является указателем на float, и извлеките значение, на которое указывает указатель.

В отличие от первого приведения, второе приведение не требует никаких вычислений. Он просто помещает 32-битное значение, хранящееся в result, в unsafeCast (которое, к счастью, также является 32-битным).

В целом выполнение подобного приведения может привести к сбою во многих отношениях, но, используя unsafe, вы сообщаете компилятору, что знаете, что делаете.

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

public static float sample() {    
   int result = 154 + (153 << 8) + (25 << 16) + (64 << 24);

   byte[] data = BitConverter.GetBytes(result);
   return BitConverter.ToSingle(data, 0);
}

Как уже было сказано, он интерпретирует значение int как float.

Это похоже на попытку оптимизации. Вместо выполнения вычислений с плавающей запятой вы выполняете целочисленные вычисления для целочисленного представления числа с плавающей запятой.

Помните, что числа с плавающей запятой хранятся как двоичные значения, как и целые.

После завершения вычисления вы используете указатели и приведение типов для преобразования целого числа в значение с плавающей запятой.

Это не то же самое, что приведение значения к типу с плавающей запятой. Это превратит значение int 1 в число с плавающей запятой 1.0. В этом случае вы превращаете значение int в число с плавающей запятой, описываемое двоичным значением, хранящимся в int.

Объяснить нормально довольно сложно. поищу пример. :-)

Изменить: посмотрите здесь: http://en.wikipedia.org/wiki/Fast_inverse_square_root

Ваш код в основном делает то же самое, что описано в этой статье.

Re: Что делает?

Он принимает значение байтов, хранящихся в int, и вместо этого интерпретирует эти байты как число с плавающей запятой (без преобразования).

К счастью, числа с плавающей запятой и целые имеют одинаковый размер данных из 4 байт.

Поскольку сержант Борш спросил, вот эквивалент «Союза»:

[StructLayout(LayoutKind.Explicit)]
struct ByteFloatUnion {
  [FieldOffset(0)] internal byte byte0;
  [FieldOffset(1)] internal byte byte1;
  [FieldOffset(2)] internal byte byte2;
  [FieldOffset(3)] internal byte byte3;
  [FieldOffset(0)] internal float single;
}

public static float sample() {
   ByteFloatUnion result;
   result.single = 0f;
   result.byte0 = 154;
   result.byte1 = 153;
   result.byte2 = 25;
   result.byte3 = 64;

   return result.single;
}

Как уже описывали другие, он обрабатывает байты int, как если бы они были числами с плавающей запятой.

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

public static float sample()
{
    int result = 154 + (153 << 8) + (25 << 16) + (64 << 24);
    return BitConverter.ToSingle(BitConverter.GetBytes(result), 0);
}

Но тогда это уже не будет очень быстро, и вы могли бы также использовать float/double и математические функции.