关于 double 和 float 在内存中的布局(c#语言描述)

     其实不论是float还是double在存储方式上都是遵从IEEE的规范 的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。

     无论是单精度还是双精度在存储中都分为三个部分：

1. 符号位(Sign) : 0代表正，1代表为负
2. 指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
3. 尾数部分（Mantissa）：尾数部分

      我们知道,浮点数在内存中是以科学记数法存储的,只不过我们用的是10进制,而计算机用的是2进制,例如 123456789.4321

  

关于指数,他们的表示方式是一个偏移量,float的为127,double的为1023,所以实际在指数位存储的值为 指数 + 1023

下面是我写的一个测试程序:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleViewer
{
    class Program
    {
        static void Main(string[] args)
        {
            double val = 123456789.4321;
            int offset = 1023; 
            long value = GetMemoryValue(val);
            int sign = (int)(((ulong)value & 0x8000000000000000)>>63);
            int e = (int)((value & 0x7FF0000000000000)>>52)-offset;
            long d = (value & 0xFFFFFFFFFFFFF);
            Console.WriteLine("123456789.4321 在内存内的布局方式:\r\n\r\n{0}\r\n", GetBinary(val));
            double b = GetBaseNumber(d);
            Console.WriteLine("符号位:{0}",sign);
            Console.WriteLine("指数:{0}",e);
            Console.WriteLine("底数小数部分(十进制):{0}",d);
            Console.WriteLine("底数小数部分(二进制):\r\n{0}", GetBinary(d));
            Console.WriteLine("十进制底数:{0}",b);
            Console.WriteLine("验算:{0} * 2^{1} = {2}",b,e,b*Math.Pow(2,e));
            Console.ReadLine();
        }

        static double GetBaseNumber(long value)
        {
            double result = 0.0, u = 0x10000000000000;
            long d = 0x1;
            for (int i = 0; i < 52; i++)
            {
                result += ((value & d) >> i) / u;
                d <<= 1;
                u /= 2;
            }
            return 1 + result;
        }

        static unsafe long GetMemoryValue(double value)
        {
            return (*((long*)(&value)));
        }

        static unsafe string GetBinary(double val)
        {
            char[] chars = new char[64];
            ulong d = 1;
            ulong value = *(ulong*)(&val);
            for (int i = 0; i < 64; i++)
            {
                chars[63-i] = ((char)((char)((d & value)>>i) + '0'));
                d <<= 1;
            }
            return new string(chars,0,64);
        }

        static unsafe string GetBinary(long val)
        {
            char[] chars = new char[64];
            ulong d = 1;
            ulong value = *(ulong*)(&val);
            for (int i = 0; i < 64; i++)
            {
                chars[63 - i] = ((char)((char)((d & value) >> i) + '0'));
                d <<= 1;
            }
            return new string(chars, 0, 64);
        }
    }
}

上面的代码的运行结果见上图!