大端存储和小端存储的区别

类型转换字符%f的使用。
 
#include <stdio.h>

int main()
{
    float  f=123.456;
    double d1,d2;
    d1=1111111111111.111111111;
    d2=2222222222222.222222222;
    printf("%f\n%12f\n%12.2f\n%-12.2f\n%.2f\n",f,f,f,f,f);
    printf("d1+d2=%f\n",d1+d2);
   
   return 0;
}   
 
运行结果：
 C语言在线编辑+运行
 
 
本案例程序的输出结果中：
 数据123.456001和3333333333333.333010中的001和010都是无意义的，因为它们超出了有效数字的范围。
 
为什么这么说？
 
1.什么是有效数字？
 从一个数的左边第一个非0数字起，到末位数字止，所有的数字都是这个数的有效数字。
 如：0.0109，前面两个0不是有效数字，后面的109均为有效数字（注意，中间的0也算）。
 再如：3.109，3 1 0 9为有效数字。
 ——————————————————————————————————————————————————————————
 2.在C语言中如何使用有效数字的？
 %f 输出7位有效数字，%.Nf 最多也就16位有效数字。
 也就是说一个浮点型【float】变量只能保证有效数字是7位，整体只有前7位是准确数字【或者说有效数字，有意义的数字】，超出的数是没有意义的。不同的编程工具显示的结果（指的是无意义的数字）也是有可能不相同的。
 %f 默认保存6位小数，不够用0来补。
 
3.什么是有意义的数字？
 你想啊，你定义的数字比如 f1=123.456，那么有意义的参与运算的数字就是123.456。只不过叫它为6位有效数字而已。
 其他的输出除去123.456的部分都是无意义的。因为123.456是有效数字，所以它是有意义的。
 
案例演示：目的是为了f1=123.456打印为什么是123.456001而不是123.456000。
 图片：
 
 
#include <stdio.h>

int main()
{  
    float f1 = 123.456,f2 = 123.4567,f3 = 123.45678;
    printf("f1=%f\nf2=%f\nf3=%f\n",f1,f2,f3);
    return 0;
}
 
解读：
 因为%f 输出7位有效数字，所以f1和f2都在有效范围之内，f3故意超出一位。
 输出结果：
 f1=123.456001
 其中001这个随机数字是编程工具加上去的，它不是我们定义的格式控制符认为合法的有效数字，故无意义。
 输出结果：
 f2=123.456703
 其中03这个随机数字也是编程工具加上去的，它也不是我们定义的格式控制符认为合法的有效数字，故无意义。
 输出结果：
 f3=123.456779 而我们定义的是123.45678，
 因为%f 输出7位有效数字，f3故意超出一位，所有后面的79这个随机数字也是编程工具加上去的，它也不是我们定义的格式控制符认为合法的有效数字，故无意义。
 
到这里，你应该懂了：
 拿%f格式控制符的有效数字来说，只要你定义的有效数字在7位之内，可以打印出来，但6位小数位缺少的会是编程工具产生的无意义的随机数。即使你的有效数字是8位，也只展示正确的前7位，余下的也是编程工具产生的随机数。
 
案例演示：什么时候补0
 首先要搞清楚为什么会有补0这个说法？
 为了使输出的数字有意义，如果都是0。那就变成整型了。所以为了控制这种误差，会补0确定精度。
 结果：
 
 一步一步加点东西，变得复杂一点的：
 
 关键词： %f 有效数字 默认补0 【关键词的作用就是减少说话篇幅，压缩信息，你自己能脑补信息解压信息】
 输出结果：
 f0=987.000000
 为了标识它是浮点类型，补了6个0；
 
输出结果：
 f1=1.123000
 f2=2.123400
 f3=3.123450
 f4=4.123456
 f1,f2,f3都在有效数字范围之内，小数位数补了0是编辑器加上的，不同的数补的不一样比如 123.456 补的是 123.456001。
 f4满打满算，7个有效数字正好，什么都不用加。
 
输出结果f5:
 f5=5.234568
 f5超出了有效数字，也超出了默认支持6位小数，触发了四舍五入的机制，所以：
 最终 有效数字 + 四舍五入 双剑合一，得出最终结果：
 f5=5.234568
 
输出结果：
 f6=56.123322
 实际定义的：
 f6=56.123321
 你应该懂了，【学习能力】，
 结合 有效数字就可以明白，编程工具只展示 56.12332 这7个有效数字，后面那个2是无意义的，所以展示的是一个随机值。
 假设把f6=56.123321 最后的1删了会怎么样？
 定义成 f6=56.12332，
 输出成 f6=56.123322
 
 定义成 f6=56.12332，
 输出成 f6=56.123322
 结果又是多了随机值2，这是编辑器帮我们干的事情。不同的编辑器随机值可能相同，也可能不同。
 
其实，这就是一个%f格式控制符，在7位有效数字合法范围之内的编辑器展示结果的分析，有的时候还会触发四舍五入的机制，有的时候是整数会默认补0。
 这个不是单一的情况你搜一下就能明白，你得自己列举多个情况并自己调试，让结果说话，别人说的可能是错的。
 
代码如下：
 
#include <stdio.h>

int main()
{  
	float f0 = 987,f1 = 1.123,f2 = 2.1234,f3 = 3.12345,
	f4=4.123456,f5=5.2345678,f6=56.123321;
	printf("f0=%f\nf1=%f\nf2=%f\nf3=%f\nf4=%f\nf5=%f\nf6=%f",f0,f1,f2,f3,f4,f5,f6);
	return 0;
}
 
——————————————————————————————————————————————————————————
 现在再说为什么 数据123.456001和3333333333333.333010中的001和010都是无意义的，因为它们超出了有效数字的范围。【分别是7和16】
 
总结成一句话：
 浮点型变量直接送7位有效数字，具体的有效数字就是你定义了多少就是多少，如果编译器展示的值的位数有偏差，那有偏差的尾巴是无意义的。记住这句话就行。
 
有效数字就是你定义的数字，【想想数学要你保留3位有效数字，这3位有效数字当然是你自己写的定义】，
 后面的尾巴001是编辑器随机加上的。
 
联系生活，那些做实验，经常会说在误差运行范围之内，因为计算机算的时候就存在误差，没有绝对的精确。
 
——————————————————————————————————————————————————————————
 可以忽略的相关信息：【没有代码演示实操，建议忽略不看，只做了解内容】
 对于实数，也可使用格式符%e，以标准指数形式输出：尾数中的整数部分大于等于1、小于10，小数点占一位，尾数中的小数部分占5位；指数部分占4位（如e-03），其中e占一位，指数符号占一位，指数占2位，共计11位。
 也可使用格式符%g，让系统根据数值的大小，自动选择%f或%e格式、且不输出无意义的零。

 
 
点击上方“大鱼机器人”，选择“置顶/星标公众号”
 
福利干货，第一时间送达！
 
编排 | strongerHuang
 
微信公众号 | 嵌入式专栏
 
我们学过数学，都知道有理数和无理数，然后在有理数中有一类叫浮点数的数字，不知道大家对这些还有没有印象？
 
在软件编程的时候，我们也会用到浮点数，一种既包含小数又包含整数的数据类型。
 
下面就来讲讲关于浮点数中，单精度、双精度、多精度和混合精度计算的区别。
 
嵌入式专栏
 
1
 
关于圆周率 π
 
我们提到圆周率 π 的时候，它有很多种表达方式，既可以用数学常数3.14159表示，也可以用一长串1和0的二进制长串表示。
 
圆周率 π 是个无理数，既小数位无限且不循环。因此，在使用圆周率进行计算时，人和计算机都必须根据精度需要将小数点后的数字四舍五入。
 
在小学的时候，小学生们可能只会用手算的方式计算数学题目，圆周率的数值也只能计算到小数点后两位——3.14；而高中生使用图形计算器可能会使圆周率数值排到小数点后10位，更加精确地表示圆周率。在计算机科学中，这被称为精度，它通常以二进制数字来衡量，而非小数。
 
对于复杂的科学模拟，开发人员长期以来一直都依靠高精度数学来研究诸如宇宙大爆炸，或是预测数百万个原子之间的相互作用。
 
数字位数越高，或是小数点后位数越多，意味着科学家可以在更大范围内的数值内体现两个数值的变化。借此，科学家可以对最大的星系，或是最小的粒子进行精确计算。
 
但是，计算精度越高，意味着所需的计算资源、数据传输和内存存储就越多。其成本也会更大，同时也会消耗更多的功率。
 
由于并非每个工作负载都需要高精度，因此 AI 和 HPC 研究人员可以通过混合或匹配不同级别的精度的方式进行运算，从而使效益最大化。NVIDIA Tensor Core GPU 支持多精度和混合精度技术，能够让开发者优化计算资源并加快 AI 应用程序及其推理功能的训练。
 
嵌入式专栏
 
2
 
单精度、双精度和半精度浮点格式之间的区别
 
 
IEEE 浮点算术标准是用来衡量计算机上以二进制所表示数字精度的通用约定。在双精度格式中，每个数字占用64位，单精度格式占用32位，而半精度仅16位。
 
要了解其中工作原理，我们可以拿圆周率举例。在传统科学记数法中，圆周率表示为3.14 x100。但是计算机将这些信息以二进制形式存储为浮点，即一系列的1和0，它们代表一个数字及其对应的指数，在这种情况下圆周率则表示为1.1001001 x 21。
 
在单精度32位格式中，1位用于指示数字为正数还是负数。指数保留了8位，这是因为它为二进制，将2进到高位。其余23位用于表示组成该数字的数字，称为有效数字。
 
而在双精度下，指数保留11位，有效位数为52位，从而极大地扩展了它可以表示的数字范围和大小。半精度则是表示范围更小，其指数只有5位，有效位数只有10位。
 
圆周率在每个精度级别表现如下：
 
 
嵌入式专栏
 
3
 
多精度和混合精度计算的差异
 
多精度计算意味着使用能够以不同精度进行计算的处理器，在需要使用高精度进行计算的部分使用双精度，并在应用程序的其他部分使用半精度或单精度算法。
 
混合精度（也称为超精度）计算则是在单个操作中使用不同的精度级别，从而在不牺牲精度的情况下实现计算效率。
 
在混合精度中，计算从半精度值开始，以进行快速矩阵数学运算。但是随着数字的计算，机器会以更高的精度存储结果。例如，如果将两个16位矩阵相乘，则结果为32位大小。
 
使用这种方法，在应用程序结束计算时，其累积得到结果，在准确度上可与使用双精度算法运算得到的结果相媲美。
 
这项技术可以将传统的双精度应用程序加速多达25倍，同时减少了运行所需的内存、时间和功耗。它可用于 AI 和模拟 HPC 工作负载。
 
随着混合精度算法在现代超级计算应用程序中的普及，HPC 专家 Jack Dongarra 提出了一个新的基准，即 HPL-AI，以评估超级计算机在混合精度计算上的性能。
 
混合精度计算主要用于现在很火人工智能领域，感兴趣的读者可以上网搜索更多关于混合精度计算的内容。
 
-END-
 
| 整理文章为传播相关技术，版权归原作者所有 |

 
| 如有侵权，请联系删除 |
 
往期好文合集
 
搞懂C语言指针，看这篇就够了！

 
聊聊指针

 
「2020年电赛」电源题详细技术方案，立即收藏！

 
  最 后  
 
 
若觉得文章不错，转发分享，也是我们继续更新的动力。
 
5T资源大放送！包括但不限于：C/C++，Linux，Python，Java，PHP，人工智能，PCB、FPGA、DSP、labview、单片机、等等！
 
在公众号内回复「更多资源」，即可免费获取，期待你的关注~
 
 

计算机中float, double类型数据分别占据4，8个字节，其中float类型和double可以表示的小数位数不同，导致了精度不同。double的精度更高。
 
计算机中数据的表示由：符号位， 指数位，尾数位组成。比如一个float类型数字的二进制由左到右依次是符号位，指数位，尾数位。
 
类型
符号位
指数位
尾数位
总位数（bit)
float
1
8
23
32
double
1
11
52
64
数字1.4在计算机中的存储转换如下：
 
先将整数和小数都变二进制表示：1.0110 0110 0110 0110 0110 011，然后整数部分不需要右移，所以float的指数位=2*7-1+0=127；double的指数位=2*10-1+0=1023。各个部分的二进制表示如下。
 
  
1.4的不同存储
符号位
指数位
尾数位
16进制表示
float
0
01111111
0110 0110 0110 0110 0110 011
3FB33333
double
0
01111111111
0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110
3FF6666666666666

  
 
在c++单精度和双精度的运算结合如下两个test示例理解如下：
 
#include <iostream>

float f1 =1.4;
float f2 = 5.0;
float f3 = 7.0;
int i = 7;
using namespace std;

void test1()
{
	printf("test %f %f %f\n", f1 * f2, f1 * 5.0, f3 / f1);
    cout << (f1 * f2 == i) << '\t' << (f1 * f2 == f3) << endl;
    cout << (f1 * 5.0f == f3) << '\t' << (f1 * f2 == f1 * 5.0f) << endl;
    cout << (f3 / f1 == 5.0) << '\t' << (f3 / f1 == f2);
}

void test2()
{
	printf("test %f %f %f\n", f1 * f2, f1 * 5.0, f3 / f1);
    cout << (f1 * f2 == i) << '\t' << (f1 * f2 == f3) << endl;
    cout << (f1 * 5.0 == f3) << '\t' << (f1 * f2 == f1 * 5.0) << endl;
    cout << (f3 / f1 == 5.0) << '\t' << (f3 / f1 == f2);
}
int main(void)
{
	cout<<"test1"<<endl;
	test1();
	cout<<endl<<"test2"<<endl;
	test2();
	
	cout<<endl<<endl<<"验证输出"<<endl;
	double f11=1.4;
	cout<<"sizeof(5.0)="<<sizeof(5.0)<<", sizeof(f1*f2)=" <<sizeof(f1*f2)<<", sizeof(f3/f1)=" <<sizeof(f3/f1)<<endl;
	cout.precision(20);
	cout<<"1.4的单精度 f1="<<f1<<endl<<"1.4的双精度 f11="<<f11<<endl;
	cout<<"双精度转单精度 double2float: "<<float(f11)<<endl;
	cout<<"单精度转双精度 float2double: "<<double(f1)<<endl;

    cout<<"单精度*单精度 f1*5.0f="<<f1*5.0f<<", 单精度*双精度 f1*5.0="<<f1*5.0<<", 双精度*双精度 f11*5.0="<<f11*5.0<<endl;
    cout<<"当单精度*单精度结果有小数时候："<<endl; 
    cout<<"单精度*单精度 f1*6.0f="<<f1*6.0f<<", 单精度*双精度 f1*6.0="<<f1*6.0<<", 双精度*双精度 f11*6.0="<<f11*6.0<<endl;
    
    cout<<endl<<"i.和j. 的验证："<<endl;
    cout<<"f3/f2==1.4 =>"<< (f3/f2==1.4)<<",  f3/f2==f1 =>"<<(f3/f2==f1)<<endl;
    
    cout<<endl<<"d.的假设验证："<<endl;
    cout<<"float(f1*5.0)==i =>"<<(float(f1*5.0)==i)<<endl;
    f1=0.125;
    cout<<"f1 * 56.0 == i =>"<< (f1 * 56.0 == i)<<endl;
	return 0;


}
 
test1和test2的两段代码涉及的是float类型和double类型数据在计算机中的存储问题。
 
用到的基础知识：
 
1， C++中默认5.0是一个double类型，5.0f表示指定这是一个float类型的数字。
 
2， 精度（float*double)=> double*double=精度（double), 精度(float*float)=精度(float), 精度(double*double)=精度(double)
 
3,  float类型用4个字节表示，double类型用8个字节表示，double可以用更多的位表示小数点部分（这部分知识可以参考数字在计算机中的表示，https://blog.csdn.net/ultrakang/article/details/39322275），所以有小数的情况下，double比float精度更高。而float转double精度不变，double转float精度降低。
 
4，float和double转换中精度降低的情况只作用在存在小数位情况。且只存在于小数位的非0尾数大于23bit情况下（因为float尾数是23个bit, double尾数是52个bit)。
 
 
 
再来看本例中给定的数据 f1=1.4; f2=5.0; f3=7.0; i=7。共进行了如下的运算结果比对，跟着对应的结果分析。
 
a.  f1 * f2 == i       =》1，左边 f1*f2 等效于 float*float，结果仍然是float，恰好是整数，所以f1 * f2 == i 成立。
 
b.  f1 * f2 == f3     =》1，左边 同 a. ，右边f3是float类型，不涉及数据类型转换，精度不变，所以f1 * f2 == f3 成立。
 
c.  f1 * 5.0f == i    =》1，左边 f1*5.0f 等效于float*float，其它同a. ，所以f1 * 5.0f == i  成立 。
 
d.  f1 * 5.0 == i    =》0，左边 f1*5.0等效于double*double, f1=1.4，1.4作为float和double两种类型在计算机存储的精度是不同的，并且结果也是double类型，精度更高，所以f1 * 5.0 == i 不成立，如果将f1*5.0转换成float类型则成立，即：float(f1*5.0)==i 成立。或者将本例中f1=1.4换成f1=0.125（即一个小数点位数可在23bit之内表示的数 , 则f1 * 56.0 == i 成立，因为0.125值的float和double类型在计算机存储中是一样的。
 
e.  f1 * f2 == f1 * 5.0f   =》1，右边f1 * 5.0f是float*float，不涉及类型转换问题，同b. 所以f1 * f2 == f1 * 5.0f 成立。
 
f.   f1 * f2 == f1 * 5.0   =》0，右边同d. 1.4在计算机中作为float和double表示的精度不同，f1*5.0是double*double=double，比f1*f2的float*float=float精度更高，所以f1 * f2 == f1 * 5.0不成立。
 
g.  f3 / f1 == 5.0     =》1,  左边float/foat=float，结果用float类型表示，小数位尾数为0，右边double类型的5.0的小数位尾数也都是0，所以f3 / f1 == 5.0 成立。可以结合下面的 i. 来理解。
 
h.  f3 / f1 == f2      =》1， 左边和右边都是float类型，精度不变，所以 f3 / f1 == f2成立。可以结合下面的j. 来理解。
 
补充：
 
i.  f3 / f2 == 1.4   =》0, 左边结果float类型，右边1.4是double类型，精度不同，所以f3 / f2 == 1.4不成立。
 
j. f3 / f2 == f1   =》1，右边类型是float，1.4用float表示，不涉及精度降低问题，所以f3 / f2 == f1 成立。
 
cout默认打印出7位有效数字，所以第一行打印的结果都一样。
 
上面的验证结果如图：