devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深层次理解浮点型在内存中的存储_decimal_dig

作者：凡人多烦事01 | 2024-03-24 13:55:03

赞

踩

decimal_dig

目录

1.什么是浮点数

2.计算机中的浮点数

1.在编译器中对于浮点数的声明以及定义        

2.内存中对于浮点数的真正存储

3.浮点数存储规则于标准

4.IEEE浮点数标准

 3.解决题目

1.什么是浮点数

        人们对于浮点数的理解大多是偏向于“小数”，但是这并不能解释浮点数这个名字。浮点数，顾名思义就是漂浮不定的，那怎么理解这个浮动的概念呢？

        其实，浮点数是采用科学计数法的方式来表示的，例如十进制小数 1.234，用科学计数法表示，可以有多种方式：

        1.234 == 0.1234*10^1
        1.234 == 1.234*10^0
        1.234 == 12.34*10^(-1)
        1.234 == 123.4*10^(-2)

        我们可以看见，小数点在整数值表达式中的是漂浮不动的，因此我们称之为浮点数。但是在计算机中，数值是以二进制存储的，那在计算机中的浮点数，又是如何存储的呢？

2.计算机中的浮点数

        对于我们程序员来说，说到浮点数，大多想到的是float，double，long double等浮点数类型，为什么要设置不同的精度来表示浮点数呢，他们在内存中的存储是有什么不同吗，以上就是我们今天需要探讨的内容

1.在编译器中对于浮点数的声明以及定义        

        对于浮点数中不同的类型，我们可以在编译器中打开相应的头文件查看定义，以下笔者以VS2022编译器举例，如下图打开定义

 打开后我们就可以看见下面的代码以及相关注释

  1. // float.h
  2. //
  3. //      Copyright (c) Microsoft Corporation. All rights reserved.
  4. //
  5. // Implementation-defined values commonly used by sophisticated numerical
  6. // (floating point) programs.
  7. //
  8. #pragma once
  9. #ifndef _INC_FLOAT // include guard for 3rd party interop
  10. #define _INC_FLOAT
  11.  
  12. #include <corecrt.h>
  13.  
  14. #pragma warning(push)
  15. #pragma warning(disable: _UCRT_DISABLED_WARNINGS)
  16. _UCRT_DISABLE_CLANG_WARNINGS
  17.  
  18. _CRT_BEGIN_C_HEADER
  19.  
  20.  
  21.  
  22. #ifndef _CRT_MANAGED_FP_DEPRECATE
  23.     #ifdef _CRT_MANAGED_FP_NO_DEPRECATE
  24.         #define _CRT_MANAGED_FP_DEPRECATE
  25.     #else
  26.         #ifdef _M_CEE
  27.             #define _CRT_MANAGED_FP_DEPRECATE _CRT_DEPRECATE_TEXT("Direct floating point control is not supported or reliable from within managed code. ")
  28.         #else
  29.             #define _CRT_MANAGED_FP_DEPRECATE
  30.         #endif
  31.     #endif
  32. #endif
  33.  
  34.  
  35. // Define the floating point precision used.
  36. //
  37. // For x86, results are in double precision (unless /arch:sse2 is used, in which
  38. // case results are in source precision.
  39. //
  40. // For x64 and ARM, results are in source precision.
  41. //
  42. // If the compiler is invoked with /fp:fast, the compiler is allowed to use the
  43. // fastest precision and even mix within a single function, so precision is
  44. // indeterminable.
  45. //
  46. // Note that manipulating the floating point behavior using the float_control/
  47. // fenv_access/fp_contract #pragmas may alter the actual floating point evaluation
  48. // method, which may in turn invalidate the value of FLT_EVAL_METHOD.
  49. #ifdef _M_FP_FAST
  50.     #define FLT_EVAL_METHOD -1
  51. #else
  52.     #ifdef _M_IX86
  53.         #if _M_IX86_FP >= 2
  54.             #define FLT_EVAL_METHOD 0
  55.         #else
  56.             #define FLT_EVAL_METHOD 2
  57.         #endif
  58.     #else
  59.         #define FLT_EVAL_METHOD 0
  60.     #endif
  61. #endif

        然后我们下滑可以找到具体的不同类型的申明和定义，其中对于float，double，long double等的最大值，最小值以及相关参数都做出了明确的说明

  1. //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  2. //
  3. // Constants
  4. //
  5. //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  6. #define DBL_DECIMAL_DIG  17                      // # of decimal digits of rounding precision
  7. #define DBL_DIG          15                      // # of decimal digits of precision
  8. #define DBL_EPSILON      2.2204460492503131e-016 // smallest such that 1.0+DBL_EPSILON != 1.0
  9. #define DBL_HAS_SUBNORM  1                       // type does support subnormal numbers
  10. #define DBL_MANT_DIG     53                      // # of bits in mantissa
  11. #define DBL_MAX          1.7976931348623158e+308 // max value
  12. #define DBL_MAX_10_EXP   308                     // max decimal exponent
  13. #define DBL_MAX_EXP      1024                    // max binary exponent
  14. #define DBL_MIN          2.2250738585072014e-308 // min positive value
  15. #define DBL_MIN_10_EXP   (-307)                  // min decimal exponent
  16. #define DBL_MIN_EXP      (-1021)                 // min binary exponent
  17. #define _DBL_RADIX       2                       // exponent radix
  18. #define DBL_TRUE_MIN     4.9406564584124654e-324 // min positive value
  19.  
  20. #define FLT_DECIMAL_DIG  9                       // # of decimal digits of rounding precision
  21. #define FLT_DIG          6                       // # of decimal digits of precision
  22. #define FLT_EPSILON      1.192092896e-07F        // smallest such that 1.0+FLT_EPSILON != 1.0
  23. #define FLT_HAS_SUBNORM  1                       // type does support subnormal numbers
  24. #define FLT_GUARD        0
  25. #define FLT_MANT_DIG     24                      // # of bits in mantissa
  26. #define FLT_MAX          3.402823466e+38F        // max value
  27. #define FLT_MAX_10_EXP   38                      // max decimal exponent
  28. #define FLT_MAX_EXP      128                     // max binary exponent
  29. #define FLT_MIN          1.175494351e-38F        // min normalized positive value
  30. #define FLT_MIN_10_EXP   (-37)                   // min decimal exponent
  31. #define FLT_MIN_EXP      (-125)                  // min binary exponent
  32. #define FLT_NORMALIZE    0
  33. #define FLT_RADIX        2                       // exponent radix
  34. #define FLT_TRUE_MIN     1.401298464e-45F        // min positive value
  35.  
  36. #define LDBL_DIG         DBL_DIG                 // # of decimal digits of precision
  37. #define LDBL_EPSILON     DBL_EPSILON             // smallest such that 1.0+LDBL_EPSILON != 1.0
  38. #define LDBL_HAS_SUBNORM DBL_HAS_SUBNORM         // type does support subnormal numbers
  39. #define LDBL_MANT_DIG    DBL_MANT_DIG            // # of bits in mantissa
  40. #define LDBL_MAX         DBL_MAX                 // max value
  41. #define LDBL_MAX_10_EXP  DBL_MAX_10_EXP          // max decimal exponent
  42. #define LDBL_MAX_EXP     DBL_MAX_EXP             // max binary exponent
  43. #define LDBL_MIN         DBL_MIN                 // min normalized positive value
  44. #define LDBL_MIN_10_EXP  DBL_MIN_10_EXP          // min decimal exponent
  45. #define LDBL_MIN_EXP     DBL_MIN_EXP             // min binary exponent
  46. #define _LDBL_RADIX      _DBL_RADIX              // exponent radix
  47. #define LDBL_TRUE_MIN    DBL_TRUE_MIN            // min positive value
  48.  
  49. #define DECIMAL_DIG      DBL_DECIMAL_DIG

2.内存中对于浮点数的真正存储

我们接下来可以来看一段非常有意思的代码：

        对于下面的代码，很多初学者刚拿到手可能还是有点懵的，程序一共有4个打印，第一个是非常常规的对于整形9的打印，第二个是在使用指针解引用的方式打印，第三个好像是在用整形打印一个被浮点型指针修改过的值，最后一个好像和第二个没什么区别，那难道4个打印打印出来的全都是9？或者是整数9加上3个小数9？猜测过后，我们不妨运行起来试一试到底是怎么样的打印结果。

  1. int main()
  2. {
  3. 	int n = 9;
  4.  
  5. 	float* pFloat = (float*)&n;
  6. 	printf("n的值为：%d\n", n);
  7. 	printf("*pFloat的值为：%f\n", *pFloat);
  8.  
  9. 	*pFloat = 9.0;
  10. 	printf("num的值为：%d\n", n);
  11. 	printf("*pFloat的值为：%f\n", *pFloat);
  12.  
  13. 	return 0;
  14. }

        程序运行结果如下，结果非常的出人意料啊

        第一个和最后一个很好理解，用%d打印整形9，结果肯定是9。最后一个用%f打印9.0，结果肯定是浮点型的9.000000。

        那中间俩个数是为什么呢，看起来根本无迹可寻啊。 ​​

        num 和 *pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？ 要理解这个结果，就一定要搞懂浮点数在计算机内部的表示方法

3.浮点数存储规则于标准

我们已经知道，浮点数是采用科学计数法来表示一个数字的，它的格式可以写成这样：

V = (-1)^S * M * R^E
S：符号位，取值 0 或 1，决定一个数字的符号，0 表示正，1 表示负

M：尾数，用小数表示，例如前面所看到的 1.234 * 10^0，1.234 就是尾数

R：基数，表示十进制数 R 就是 10，表示二进制数 R 就是 2

E：指数，用整数表示，例如前面看到的 10^-1，-1 即是指数

举例来说：
十进制的  5.0 ，写成二进制是 101.0 ，相当于 1.01×2^2 。
那么，按照上面 V 的格式，可以得出 S=0 ， M=1.01 ， E=2 。
十进制的 -5.0 ，写成二进制是 - 101.0 ，相当于 - 1.01×2^2 。
那么， S=1 ， M=1.01 ， E=2 。

4.IEEE浮点数标准

        直到1985年，IEEE 组织推出了浮点数标准，就是我们经常听到的 IEEE754 浮点数标准，这个标准统一了浮点数的表示形式，并提供了 2 种浮点格式：

单精度浮点数 float：32 位，符号位 S 占 1 bit，指数 E 占 8 bit，尾数 M 占 23 bit

双精度浮点数 float：64 位，符号位 S 占 1 bit，指数 E 占 11 bit，尾数 M 占 52 bit

为了使其表示的数字范围、精度最大化，浮点数标准还对指数和尾数进行了规定：

        尾数 M 的第一位总是 1（因为 1 <= M < 2），因此这个 1 可以省略不写，它是个隐藏位，这样单精度 23 位尾数可以表示了 24 位有效数字，双精度 52 位尾数可以表示 53 位有效数字

        指数 E 是个无符号整数，表示 float 时，一共占 8 bit，所以它的取值范围为 0 ~ 255。但因为指数可以是负的，所以规定在存入 E 时在它原本的值加上一个中间数 127，这样 E 的取值范围为 -127 ~ 128。表示 double 时，一共占 11 bit，存入 E 时加上中间数 1023，这样取值范围为 -1023 ~ 1024。

然后，指数E从内存中取出还可以再分成三种情况： 

E 不全为 0 或不全为 1

         这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将 有效数字M前加上第一位的1。
比如：
0.5的二进制形式为0.1

由于规定正数部分必须为1，即将小数点右移1位，则为1.0*2^(-1)。其阶码为-1+127=126，表示为01111110，而尾数1.0去掉整数部分为0，补齐0到23位00000000000000000000000

则其二进制表示形式为:

0 01111110 00000000000000000000000

E全为0

         这时，浮点数的指数E等于1-127（或者1-1023）即为真实值， 有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于 0的很小的数字。

 E全为1

这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）

 3.解决题目

        在进行了以上部分的学习后，我们就可以完美的解决上面的程序运行结果和我们设想的不同的问题了，我们这里再一次拿到程序

  1. int main()
  2. {
  3. 	int n = 9;
  4.  
  5. 	float* pFloat = (float*)&n;
  6. 	printf("n的值为：%d\n", n);
  7. 	printf("*pFloat的值为：%f\n", *pFloat);
  8.  
  9. 	*pFloat = 9.0;
  10. 	printf("num的值为：%d\n", n);
  11. 	printf("*pFloat的值为：%f\n", *pFloat);
  12.  
  13. 	return 0;
  14. }

我们先来看第二个输出，我们定义的 n 为整形，所以分析如下 

我们写出 9 的二进制码：

00000000 00000000 00000000 00001001

用IEEE浮点数标准划分后：

0  00000000  00000000000000000001001

那么此时，我们使用 %f 浮点数的方式打印

S = 0

E = -126

M = 0.00000000000000000001001

n =  (-1)^0 * 0.00000000000000000001001 * 2^（-126）

也就是非常接近0的一个很小的数字，在屏幕上输出自然就是0.000000

 我们接下来看第三个输出，我们是使用 9.0 进行的赋值，所以是浮点数的赋值方法

我们写出 9.0 的二进制码

1001.0

用IEEE规定表示

(-1)^0 * 1.001 * 2^3 

因为9.0是正数，所以S = 0, 这里的 3 是十进制，转化为二进制就是 10000010， M 就是在001后再补20个比特位（0）

此时数据在内存中的存储：

0 10000010 00100000000000000000000

此时我们使用 %d 的整形打印，电脑会认为我们存储的 是整形的补码，然后进行打印

01000001000100000000000000000000 —— 补码

01000001000100000000000000000000 —— 反码

01000001000100000000000000000000 —— 源码

我们将源码转换为10进制的数字

可以看到 1091567616 正好是我们第三个输出的结果

 综上分析，输出如下：

        以上便是本篇文章的全部内容，在这个程序判断题目中也非常好的锻炼了我们对于理解浮点数内存存储知识的能力，希望能给您带来收获，如有不对，请多多指正。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号