C 由于类型转换，二进制值到浮点值的转换不起作用

在这里，我添加了代码中的函数，该函数用于根据给定的二进制数生成浮点数

代码： 在输出中，您可以看到temp:0，r:1.000000，表示temp1=0，这是长1.000000的类型转换

---

有人能解释一下为什么这种类型转换不起作用吗？

temp1

是用

%ld

标志来打印的，它是

长int

，而

r

是用

%lf

标志来打印的，因此后面的

0

s。

OP:“temp:0，r:1.000000表示temp1=0，即长1.000000的类型转换。”
答：

double

到

long

的转换正在工作，因为

double

小于1.0

Code打印的是双精度的四舍五入值，而不是其精确值，该值略小于1.0。（长）一些略小于1的数字是0。请尝试以更高的精度打印双精度的“%.20le”，而不是“%lf”

给定典型的IEEE二进制64浮点，当代码以

1010.001100

的

double

开始时，代码实际上是以

1010.0010999999995125108开始的

至于为什么
10.617188
的答案是错误的，我怀疑未列出的代码
binary_decimal（）；


代码有错误：

// floatFract = floatFract + (double) temp1 / (double) i;
floatFract = floatFract + (double) temp1 / (double) k;
...
// wrong result of 10.61718750000000000000
// correct result follows
10.00109989999999982047....
// or to 6 decimal places
10.001100


次要：请注意，以下代码仅适用于
LONG\u MIN
至
LONG\u MAX
范围内的
double f

integral = (long)f;

这里是我提出的，它不能完全工作。有长数据类型的限制，所以我们不能在这个程序中输入大于这个范围的数字，而不是程序正常工作

代码：
double binary\u float（double f）/*函数，用于将二进制转换为浮点*/
{
长积分=0，浮点整数=0；
双浮点数分数=0，分数=0，浮点数总数=0；
//从浮点变量中分离整数值
积分=（长）f；
//从变量中分离分数值
分数=f-（长）f；
//二进制到十进制的转换
floatInt=二进制\十进制（整数）；
//将浮点值从二进制转换为浮点值
floatFract=二进制浮点数浮点数（分数）；
//结合整数和分数二进制值。
floatTotal=floatInt+floatFract；
总回报率；
}
long binary_decimal（long n）/*函数，用于将二进制转换为十进制*/
{
长十进制=0，i=0，rem；
而（n！=0）
{
rem=n%10；
n/=10；
十进制+=rem*pow（2，i）；
++一,；
}
返回小数；
}
双二进制浮点数（双分数）
{
长temp1=0，k=1，i=1；
双浮点数=0；
//用于将二进制值转换为小数的循环
而（k<100000000&&分数！=（双）0）
{
k=k*10；
i=i*2；
temp1=（长）（分数*k）；
//如果值大于1，则表示.001100表示为.00109994。。。。
//这是最后一个数字，所以我们可以从那个点开始打破循环
如果（temp1>1）
{
temp1=1；
floatFract=floatFract+（双）temp1/（双）i；
打破
}
floatFract=floatFract+（双）temp1/（双）i；
分数=分数-（双）温度1/（双）k；
}
返回浮点数；
}

任何有更好的想法和更好的方法从二进制数中查找浮点值的人，请分享。
问题不是尾随0秒。问题是类型转换不起作用。printf（“temp:%ld，r:%lf\n”，（double）（分数*k），（分数*k））；将给您相同的输出。这不是转换不起作用。也可以尝试printf（“temp:%lf，r:%lf\n”，（长）（分数*k），（分数*k））.PS：不应使用错误的标志，这会导致未定义的行为。请查看代码并查看变量的类型，我只是为了理解目的而打印。如果您看到一行与其他行分开，那么您就得到了确切的问题。因此，我遇到了问题。但我如何解决此问题？发布
binary\u decimal（）
会有帮助。
// floatFract = floatFract + (double) temp1 / (double) i;
floatFract = floatFract + (double) temp1 / (double) k;
...
// wrong result of 10.61718750000000000000
// correct result follows
10.00109989999999982047....
// or to 6 decimal places
10.001100

integral = (long)f;

double binary_float(double f) /* Function to convert binary to float.*/
{
   long     integral = 0, floatInt = 0;
   double   floatFract = 0, fractional = 0, floatTotal = 0;

   //Separating the integral value from the floating point variable
   integral = (long)f;
   //Separating the fractional value from the variable
   fractional = f - (long)f;

   //Converting binary to decimal
   floatInt = binary_decimal(integral);
   //Converting float value from binary to float value
   floatFract = binary_float_float(fractional);

   //Combining both the integral and fractional binary value.
   floatTotal = floatInt + floatFract;

   return floatTotal;
}

long binary_decimal(long n) /* Function to convert binary to decimal.*/
{
   long decimal=0, i=0, rem;
   while (n!=0)
   {
      rem = n%10;
      n/=10;
      decimal += rem*pow(2,i);
      ++i;
   }
   return decimal;
}

double binary_float_float(double fractional)
{
   long     temp1 = 0, k = 1, i = 1;
   double   floatFract = 0;

   //Loop for converting binary to Fractional value
   while( k < 1000000000 && fractional != (double)0 )
   {
      k = k * 10;
      i = i * 2;
      temp1 = (long)(fractional * k);
      //If value is larger then 1 it means .001100 is represented as .00109994....
      //So it's last digit and so we can break loop from that point
      if (temp1 > 1)
      {
         temp1 = 1;
         floatFract = floatFract + (double)temp1/(double)i;
         break;
      }

      floatFract = floatFract + (double)temp1/(double)i;
      fractional = fractional - (double)temp1/(double)k;
   }

   return floatFract;
}