一. 整型

1. C语言内置整型家族

类型的意义：

2.整型在内存如何存储的呢？

3. 原码，反码，补码

原码

反码

补码

4. 当整型遇上unsigned 会发生什么呢？

1. unsigned 与 signed 解析

2. printf 输出有无符号数解析

3. 小试牛刀

二. 浮点型

1. 浮点型与整型在存储上的区别

2. 常见的浮点类型

1. 浮点数——存

（1） S区

（2）M区

（3） E区将会复杂一些

2. 浮点数——取

（1. E 不全为 1 或 0

（2. E 全为 1

（3. E 全为 0

3. 让我们回到浮点型小节开头的题目

三. 数据计算（简述）

四.大小端字节序存储

1. 什么是大小端？

2. 为什么有大端和小端

3. 通过函数判断机器大小端

结语

一. 整型

1. C语言内置整型家族

char 1Byte

int 4Byte或2Byte

long 4个Byte或8Byte

long long 更长整型

类型的意义：

1. 使用这个类型开辟内存空间的大小（大小决定了使用范围）。

2. 如何看待内存空间的视角

2.整型在内存如何存储的呢？

我们知道类型决定了开辟内存的大小，计算机为 a 分配四个字节的空间。那如何存储？

int a = 10;
int b = -20;

3. 原码，反码，补码

计算机中所有的数据都是由二进制存储，其中符号数有三种表示方法，即原码、反码和补码。三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位三种表示方法各不相同。

原码

直接将二进制按照正负数的形式翻译成二进制就可以。

反码

将原码的符号位不变，其他位依次按位取反就可以得到了。

补码

反码+1就得到补码。

***正数的原、反、补码都相同。

对于整形来说：数据存放内存中其实存放的是补码。

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，操作简单。

（计算机补码相加，若超出类型范围，结果可能由正数变为负数，负数变正数，原因是：

计算机会保留低位，高位保留）。

比如完成char 类型 1 - 1

...
 char a = 1;
 char b = -1;
printf("%d", a + b);

内部逻辑：先将1转化为补码（原，反，补一样）形式保存到内存中，-1转化为补码存至内存。然后以补码形式完成计算，最后将结果转化回原码，并以有符号整型，输出数据。

4. 当整型遇上unsigned 会发生什么呢？

1. unsigned 与 signed 解析

这里用char 举例，我们知道char 等价于 signed char, 原码中首位是符号位，当char被unsigned修饰, 首位就不再是符号位，而是可以表示数据了，那么表示正数的个数扩大一倍。

有符号：

无符号：

2. printf 输出有无符号数解析

#include<stdio.h>

int main()
{
    unsigned int b = -10;
    printf("%u\n", b); // 4294967286
  // 输出时，计算机认定是无符号型，把补码直接解析(正数，原 = 反 = 补码)。
    printf("%d", b);   // -10
  // 输出时，计算机认定是有符号型，先要判断正负，负则需要转化，所以结果为-10。
    return 0;

结果：

3. 小试牛刀

//输出什么？
#include <stdio.h>
int main()
{
    char a= -1;
    signed char b=-1;
    unsigned char c=-1;
    printf("a=%d,b=%d,c=%d",a,b,c);// 输出是-1，-1，255
    return 0;
}

解析一下结果-1：（char 等价于 unsigned)

结果255的解析：

逻辑总结：

首先将数据转为补码，然后给变量，如果输出以更大位输出，这是需要位提升（这个取决于保存的类型和输出形式）。

二. 浮点型

1. 浮点型与整型在存储上的区别

浮点型没有整型的原码，反码，补码概念
浮点型对数据进行分区存储。

2. 常见的浮点类型

float // 单精度

double // 双精度

long double

当我们需要知道浮点型范围我们可以，调用头文件 float.h （整型范围在 limits.h头文件中）

关于浮点型存储，先让一个例子开头：

int main() 
{ 
 int n = 9; 
 float *pFloat = (float *)&n; 
 printf("n的值为：%d\n",n);  //      结果： 9
 printf("*pFloat的值为：%f\n",*pFloat);//  0.000000

 *pFloat = 9.0; 
 printf("num的值为：%d\n",n);          //  1091567616
 printf("*pFloat的值为：%f\n",*pFloat);//  9.000000
 return 0; 
}

不知道大家是否答对？下面让我们了解浮点型存储方式

1. 浮点数——存

根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：

(-1)^S * M * 2^E
(-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。
M表示有效数字，大于等于1，小于2。
2^E表示指数位。

举例来说：

十进制的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

对于float的32位类型，存储图如下

double的64位，图如下：

（1） S区

存储符号位（-1）^ S，如 1.3，-1.0，所以最S分别是 0， 1。

（2）M区

我们知道根据IEEE的规定，浮点数转为二进制后，1<M<2，将会化为1.XXXXXX类型，于是科学家们决定不保存1，只保存.XXXXXXX，如：101.1->1.011* 2^2,M保存.011,这样提高了数据的精度，可以保存24位，53位的有效数字。

（3） E区将会复杂一些

E区存储为无符号整型（unsigned int），这意味8位的范围是0~255, 11位范围是 0~ 2047,但我们知道E也存在负数形式，那怎么保存呢？ IEEE规定E原始数需要加上一个中间数再保存，8位E，加上127；11位的E加上1023，如：10 + 127 = 137，E = 1000 1001。

2. 浮点数——取

（1. E 不全为 1 或 0

这时，浮点数就采用下面的规则表示，即

指数E的计算值减去127（或1023），得到真实值。
再将有效数字M前加上第一位的1。

比如： 0.5（1/2）的二进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位，则为1.0*2^(-1)，其阶码为-1+127=126，E表示为01111110，S 为 0，M为00000000000000000000000 ，则其二进制表示形式为:

0 01111110 00000000000000000000000

（2. E 全为 1

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

（3. E 全为 0

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

3. 让我们回到浮点型小节开头的题目

int main() 
{ 
 int n = 9; 
 float *pFloat = (float *)&n; 
 printf("n的值为：%d\n",n);  //      结果： 9
 printf("*pFloat的值为：%f\n",*pFloat);//  0.000000

 *pFloat = 9.0; 
 printf("num的值为：%d\n",n);          //  1091567616
 printf("*pFloat的值为：%f\n",*pFloat);//  9.000000
 return 0; 
}

解析如下

int main()
{
    int n = 9;
    float* pFloat = (float*)&n;
    printf("n的值为：%d\n", n);  //      结果： 9
    // 整型补码  0000 0000 0000 0000 0000 0000 0000 1001
    printf("*pFloat的值为：%f\n", *pFloat);//  0.000000
    // 以浮点型存储视角来看
    // 0 00000000 00000000000000000001001
    //->  (-1)^(0) * 0.00000000000000000001001 * 2 *(-126)

    *pFloat = 9.0;
    // 9.0二进制 1001.0->  S = 0, E = 3, M = .001
    // 所以其浮点数二进制为 0 10000010 00100000000000000000000  然后给 n 
    printf("num的值为：%d\n", n);          //  1091567616
    // 将n内的数据以有符号整型输出(说白了就是以整型输出法则输出数据)
    // 所以就是这么大的数
    printf("*pFloat的值为：%f\n", *pFloat);//  9.000000
    // 数据本身是以浮点型存储，然后以浮点型方式取出，E = 130 - 127,M 的头添上个一
    // (-1)^(0) * (1.001) * 2^(3) 所以结果为 9.000000(float类型默认保存小数点后6位)
    return 0;
}

结论：计算机整型数据以浮点型输出可能会发生错误，浮点型数据以整型数据输出也会发生错误。

三. 数据计算（简述）

但，你存储跟我计算有毛子事？！

计算机在对待不同数据类型时，会首先将数据自动转化，保证数据为同一类型，再进行计算，由于只是完成本次运算，因此转化只是临时数据（强制转化也是），不改变原始数据类型；

计算机为了保证数据精度，所以只会由低位向高位自动转化，如图：

可以自动进行的类型转换一般风险较低，不会对程序带来严重的后果，例如，int 到 double 没有什么缺点，float 到 int 顶多是数值失真。只能强制进行的类型转换一般风险较高，或者行为匪夷所思，

例如，char * 到 int * 就是很奇怪的一种转换，这会导致取得的值也很奇怪，再如，int 到 char * 就是风险极高的一种转换，一般会导致程序崩溃。（一般验证某些算法，内存调试）

使用强制类型转换时，程序员自己要意识到潜在的风险。

关于数据计算这里不做太多讲解。

四.大小端字节序存储

1. 什么是大小端？

大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；

小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地址中。

不多说上图：

2. 为什么有大端和小端

为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。

例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为高字节， 0x22为低字节。

大端模式: 就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。

小端模式: 刚好相反。我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式

3. 通过函数判断机器大小端

思路：通过取的第一个字节的内容，如果为1则为小端，为0则为大端。

#include<stdio.h>
int main()
{
    int a = 1;
    if (*(char *)&a) // char类型占一个字节，将a地址抢转为char类型指针，
//然后解引用得出里面的值要么为1，要么为0.
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    return 0;
}