Преобразование целого числа в вещественное число

Ниже представлена программа C4, в которой функция IntFloat( ) определяет порядок целого числа и формирует мантиссу и порядок числа типа float. В некотором смысле предстоит выполнить обратные действия предыдущей программы C3 и ее функции FloatInt( ).

// Program C4

//Преобразование целого типа в вещественный тип float

#include <stdio.h> // printf

#include <conio.h> // getch

#include "BinaryInt.h" // BinaryInt

#include "BinaryFloat.h" // BinaryFloat

float IntFloat( int n )

{ unsigned int k = n & 0x80000000 ? ~n + 1 : n;

if( k == 0 ) return 0.0; // число 0

BinaryInt( "k = ", k ); // бинарный вид k

unsigned int b = 0x80000000; // 1 в бите 31

int p; // порядок числа - 1

for( p = 31; p >= 0; p-- ) // цикл номеров бит

{ if( k & b ) break; // старший бит найден

b >>= 1; // сдвинуть 1 в соседний бит справа

}

printf( "\np = %d", p ); // монитор

unsigned int t = p + 127;// порядок в стиле Intel

BinaryInt( "t = ", t ); // бинарный вид порядка

unsigned int m = k << ( 32 - p ) >> 9;// мантисса

BinaryInt( "m = ", m ); // монитор

m |= t << 23; // модуль вещественного числа

BinaryInt( "m = ", m ); // бинарный вид числа

m |= n & 0x80000000; // знак числа

BinaryInt( "m = ", m ); // монитор

union

{ unsigned int d; // целое поле

float f; // вещественное поле

} u; // объект объединения

u.d = m;

return u.f; // вернуть результат преобразования

}

//---------------------------------------------------

void main ( void )

{ int n; // 4-байтная целая переменная

printf( "n = " ); scanf( "%d", &n );//ввод числа

BinaryInt( "n = ", n ); // бинарный вид числа

float f = IntFloat( n);//преобразование int-float

printf( "\nf = %f", f ); // монитор

BinaryFloat( "f = ", f ); // бинарный вид числа

getch(); // просмотр результата

}

Если при выполнении программы C4 ввести произвольное число, например, -6, то следующие строки появляются на мониторе

n = -6

n = 11111111111111111111111111111010

k = 00000000000000000000000000000110

p = 2

t = 00000000000000000000000100000001

m = 00000000010000000000000000000000

m = 01000000110000000000000000000000

m = 11000000110000000000000000000000

f = -6.000000

f = 11000000110000000000000000000000

Функция IntFloat( ) возвращает вещественное число типа float. Конструкция объявления параметров содержит исходное целое число int n. В теле функции IntFloat( ) создается модуль k исходного числа unsigned int k = n & 0x80000000 ? ~n + 1 : n. Если число 0, то возвращается вещественный ноль if( k == 0 ) return 0.0. Для визуального контроля модуль k выводится на монитор BinaryInt( "k = ", k ).

Далее определяется номер старшего бита в модуле. Для этого устанавливается 1 в бите 31 рабочей переменной unsigned int b = 0x80000000. Номер старшего бита будет находиться в переменной int p. Поиск старшего бита осуществляется под управлением заголовка цикла for( p = 31; p >= 0; p-- ). В теле цикла битовая конъюнкция обнаруживает старший бит числа if( k & b ) break и прерывает цикл. Если просмотр битов слева на право не обнаруживает 1, то в рабочей переменной b выделяющая 1 сдвигается на один бит влево b >>= 1. Когда цикл заканчивается, номер старшего бита выводится на монитор printf( "\np = %d", p ). Этот номер на 1 меньше математического порядка исходного числа. Порядок вещественного числа типа float вычисляется в переменной unsigned int t = p + 127. Для контроля он также выводится на монитор BinaryInt( "t = ", t ).

Мантисса вещественного числа создается с помощью сдвигов с учетом спрятанной единицы unsigned int m = k << ( 32 - p ) >> 9 и выводом на монитор BinaryInt( "m = ", m ). С помощью левого сдвига и дизъюнкции подготовленный порядок t присоединяется к мантиссе m |= t << 23, образуя модуль вещественного числа BinaryInt( "m = ", m ). Осталось поставить знак числа m |= n & 0x80000000. Битовый вариант вещественного числа сформирован BinaryInt( "m = ", m ).

Что вернуть результат создается объект объединения u, в поле u.d загружается бинарный вид числа u.d = m. В последней инструкции return u.f функция IntFloat( ) возвращает результат преобразования.