四川盐亭网站制作公司

”神仙修炼“之C的数据存储-创新互联

一、内功之数据在内存中的存储
本章内容重点：
1.数据类型的不同类型
2.整型在内存中的存储方式
3.大小端字节序存储
4.浮点数在内存中的存储方式
1.不同数据类型的介绍

我们先前已经了解到的基本类型（内置类型）如：

成都创新互联是一家专注于成都网站设计、成都网站建设与策划设计,漠河网站建设哪家好?成都创新互联做网站,专注于网站建设十多年,网设计领域的专业建站公司;建站业务涵盖:漠河等地区。漠河做网站价格咨询:18980820575
char    //字符型，所占存储空间为1字节
int     //基本整形，所占存储空间为4字节
unsigned int     //无符号整型，所占存储空间为4字节
long (int)       //长整型，所占存储空间为4/8字节
unsigned long    //无符号长整型，所占存储空间为4/8字节
long long (int)  //长长整型，所占存储空间为8字节
short (int)      //短整型，所占存储空间为2字节
unsigned short   //无符号短整型，所占存储空间为2字节
float            //单精度浮点型，所占存储空间为4字节
double           //双精度浮点型，所占存储空间为8字节
long double      //长双精度浮点型

类型存在的意义：

1.使用不同数据类型为内存开辟不同的空间大小

2.不同数据所能表示的取值范围不同，可以参与的运算也不同

1.1🌜数据类型的分类🌛
    • 整型家族👪
char-----unsigned char
signed char
short----unsigned short
signed short
int-------unsigned int
signed int
long-----unsigned long
signed long
为什么char也在整型家族呢？
因为字符是以ASCII存储在内存中，ASCLII是整数，所以char属于整型合情合理 👀（解决某些人的小疑问）。但是这里要注意 ❗：在我们编程过程中，char具体表示的是signed char还是unsigned char是要根据编译器决定的，常见的编译器认为char 是signed char。
    • 浮点数家族👪
float
double
    • 构造类型（自定义类型）👪
数组类型（因为数组元素个数可以发生改变）
结构体类型struct
枚举类型enum
共用体（联合）类型union
    • 指针类型👪
int* pa
char* pb
float* pc
void *pd
    • 空类型👪
void表示空类型（无类型）
通常用于函数的返回类型，函数的参数，指针类型。
2.🌜整型在内存中的存储🌛

由于一个变量在内存中存储需要开辟内存的存储单元，而不同的类型所开辟的空间大小有所不同，那么接下深刻理解一下整型 数据在内存中的存储👀

首先，我们要提前具备以下知识点：

有符号整数和无符号整数
整数的原码、反码、补码
2.1有符号整型和无符号整型（从二进制来看）

有符号整数和无符号整数的区别在于如何理解整数最高位

  1. 对于无符号整数：整数的最高位被编译器理解为数据位。

  1. 对于有符号整数：整数的最高位被编译器理解为符号位。若最高位（符号位）为0则表示正数，若符号位为1则表示负数。

  1. 可见对于相同字节数的整型数而言：由于有符号整数的数据位数比无符号整数的数据位数少1位，而这1位恰好是最高位，因此有符号整数表示的大整数的绝对值只有无符号整数的一半

//举个栗子：我们可以查到char(signed char)和unsigned char的取值范围
//char占1个字节
char--->-128~127
unsigned char--->0~255

在内存中的存储形式如上图

2.2整数的原码、反码和补码

计算机中整数的三种表示方法：原码、反码和补码。三种方法都存在符号位和数据位之分。

由于正数的原码反码补码相同，而负数的原码反码补码不同，规则如下：

原码：将二进制按照正负数直接翻译即可
反码：原码的符号位不变，其他位依次按位取反
补码：在反码的基础上+1得到补码
注意：
1.通过对补码按“符号位不变，其他位依次取反”后“+1”可得到原码。
2.同样，对补码先“-1”后，再“符号位不变，其他位依次取反”可得到原码。
//例如：
int a=20;
//20是正数，最高位是符号位0，整形占四个字节32个比特位
//正数的原码反码补码：0000 0000 0000 0000 0000 0000 0001 0100
//转换为十六进制：0x 00 00 00 16
int b=-10;
//-10是负数，最高位是符号位1
//原码：1000 0000 0000 0000 0000 0000 0000 1010
//反码：1111 1111 1111 1111 1111 1111 1111 0101
//补码：1111 1111 1111 1111 1111 1111 1111 0110
//转换为十六进制：0xff ff ff f6

对于整型而言：在屏幕上显示的是该数的原码，在内存中存储的是该数的补码，这是为什么呢？😧

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统
一处理；
同时， 加法和减法也可以统一处理（ CPU只有加法器）此外，补码与原码相互转换，其运算过程
是相同的，不需要额外的硬件电路。
//举个栗子解释一下：当我们计算2-1的时候【相当于2+(-1)】
2
//由于正数的原码、反码、补码相同：
0000 0000 0000 0000 0000 0000 0000 0010
-1
//32位机器上-1的原码：由于是负数，最高位为符号位1
1000 0000 0000 0000 0000 0000 0000 0001
//-1的反码：原码符号位不变，其他位按位依次取反
1111 1111 1111 1111 1111 1111 1111 1110
//-1的补码：反码+1
1111 1111 1111 1111 1111 1111 1111 1111
2-1//相当于2+（-1）：如果不使用补码，用原码计算
0000 0000 0000 0000 0000 0000 0000 0010
1000 0000 0000 0000 0000 0000 0000 0001
//
1000 0000 0000 0000 0000 0000 0000 0011
//得出结果：-3，可见2-1=-3是错误的

//当我们使用-1的补码计算的时候
0000 0000 0000 0000 0000 0000 0000 0010
1111 1111 1111 1111 1111 1111 1111 1111
//得出结果：1 0000 0000 0000 0000 0000 0000 0000 0000 0001
//由于只有32位，最前面的1舍掉得出：0000 0000 0000 0000 0000 0000 0000 0000 0001
//也就是1，2-1=1结果是正确的

通过在计算机内存中负数用补码来表示，就可以将减法运算也转化为加法运算来处理。😁

2.3❗大小端字节序存储❗

在了解大小端存储之前，我们看一下在VS编译器中数据在内存中存储是什么样子的?

在VS编译器中：按住Ctrl+F10进行调试，打开软件上面调试选项，点击窗口下的内存即可打开
int a=20;
//20的原码、反码、补码都相同：
//0000 0000 0000 0000 0000 0000 0001 0100 
int b=-10;
//-10是负数
//原码：1000 0000 0000 0000 0000 0000 0000 1010
//反码:符号位不变，其他位依次按位取反
//反码：1111 1111 1111 1111 1111 1111 1111 0101
//补码：反码+1
//补码：1111 1111 1111 1111 1111 1111 1111 0110
在内存中是以十六进制显示的(二进制和十六进制的转换)
//20以十六进制显示：00 00 00 14
//-10以十六进制显示：ff ff ff f6 
//在内存中以补码形式存储数据

为什么在内存中存储方式和图片显示不符合呢？接下来正式引入功法！💣

1.什么是大端小端？
大端字节序存储模式：数据的低位保存在内存的高地址处，数据的高位保存在内存的低地址处。
小端字节序存储模式：数据的低位保存在内存的低地址处，数据的高位保存在内存的高地址处。
2.为什么有大端小端存储呢？
为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元
都对应着一个字节，一个字节为8bit。但是在C语言中除了8 bit的char之外，还有16 bit的short型，32 bit的long型（要看具体的编译器），另外，对于位数大于8位
的处理器，例如 16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如
何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为
高字节， 0x22 为低字节。对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。
小端模式，刚好相反。我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
3.解释图片中的问题
int a=20;
int b=-10;
//20以十六进制显示：00 00 00 14
//-10以十六进制显示：ff ff ff f6

可见在VS的内存存储方式为小端字节序存储

4.面见笔试题
百度2015年系统工程师笔试题：
请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。
//功能：设计一个小程序来判断当前机器的字节序。
//思路：判断大小端存储，假如数据int a=20,在内存中十六进制表示是00 00 00 16，
//设计程序判断第一个字节是00还是16，若是00表示是大端，反之为小端
//要点：根据不同类型指针实现对数据内存的访问多大的空间
int main()
{
    int a = 20;
    int result = *((char*)&a);
    //char*指针表示对内存访问一个字节的空间
    //解引用为对应一个字节的值
    if (result)
    {
        printf("机器是小端存储");
    }
    else
    {
        printf("机器是大端存储");
    }
    return 0;
}
//函数实现：
int check()
{
    int a = 20;
    return (*(char*)&a);
}
int main()
{
    int result =check();
    //char*指针表示对内存访问一个字节的空间
    //解引用为对应一个字节的值
    if (result)
    {
        printf("机器是小端存储");
    }
    else
    {
        printf("机器是大端存储");
    }
    return 0;
}
2.4🎓练习题🎓 1.第一题+解析😶
//输出什么？
#includeint main()
{
    char a= -1;
    signed char b=-1;
    unsigned char c=-1;
    printf("a=%d,b=%d,c=%d",a,b,c);
    return 0;
}
//char取值范围是：0~255
//char a在内存中的二进制为：（负数）
//原码：1000 0000 0000 0000 0000 0000 0000 0001
//反码：1111 1111 1111 1111 1111 1111 1111 1110
//补码：1111 1111 1111 1111 1111 1111 1111 1111
//由于是char类型占一个字节，需要整型提升：取后八位
//1111 1111，整型提升原则：前面与补符号位相同的
//1111 1111 1111 1111 1111 1111 1111 1111为整型提升后的补码
//打印格式为%d有符号整型数据：
//原码：补码取反（符号位不变）+1
//1000 0000 0000 0000 0000 0000 0000 0001：-1
//signed char b=-1和char a=-1结果是一样的--->-1

unsigned char c=-1;
//参考上面可知且unsigned表示不区分符号位，统一按数值位看，全为正数
//原码：1000 0000 0000 0000 0000 0000 0000 0001
//反码：1111 1111 1111 1111 1111 1111 1111 1110
//补码：1111 1111 1111 1111 1111 1111 1111 1111
//由于是char类型占一个字节，需要整型提升：取后八位
//1111 1111，整型提升原则：由于是无符号，不区分负数，所以前面补0
//0000 0000 0000 0000 0000 0000 1111 1111：2^8-1=255

最终结果：a=-1,b=-1,c=255

🌞补充一张“轮回转生”🌞

正确理解char的取值范围

2.第二题+解析😶
2.
#includeint main()
{
    char a = -128;
    printf("%u\n",a);
    return 0;
}
char a=-128;//a是负数
//a的原码：1000 0000 0000 0000 0000 0000 1000 0000
//a的反码：1111 1111 1111 1111 1111 1111 0111 1111
//a的补码：1111 1111 1111 1111 1111 1111 1000 0000
//由于是char类型占一个字节，需要整型提升：取后八位
//1000 0000，整型提升原则：补符号位1
//1111 1111 1111 1111 1111 1111 1000 0000为整型提升后的结果
//打印格式为：无符号整型,最前面的符号位看作数据位
//1111 1111 1111 1111 1111 1111 1000 0000=4294967168

最终结果：4294967168

3.第三题+解析😶
3.
#includeint main()
{
    char a = 128;
    printf("%u\n",a);
    return 0;
}
//a是正数，原码反码补码相同
//a的原码：0000 0000 0000 0000 0000 0000 1000 0000
//a的补码：0000 0000 0000 0000 0000 0000 1000 0000
//由于是char类型占一个字节，需要整型提升：取后八位
//1000 0000，整型提升原则：补符号位1
//1111 1111 1111 1111 1111 1111  1000 0000为整型提升后的补码
//打印格式为：无符号整型,最前面的符号位看作数据位
//1111 1111 1111 1111 1111 1111  1000 0000=4,294,967,168
4.第四题+解析😶
int main()
{
    int i = -20;
    unsigned int j = 10;
    printf("%d\n", i + j);
    //按照补码的形式进行运算，最后格式化成为有符号整数
    return 0;
}
//i为负数：符号位为1
//原码：1000 0000 0000 0000 0000 0000 0001 0100
//反码：1111 1111 1111 1111 1111 1111 1110 1011
//补码：1111 1111 1111 1111 1111 1111 1110 1100
//j为无符号整数
//原码=补码：0000 0000 0000 0000 0000 0000 0000 1010
//i+j
//1111 1111 1111 1111 1111 1111 1110 1100
//0000 0000 0000 0000 0000 0000 0000 1010
//补码结果：1111 1111 1111 1111 1111 1111 1111 0110
//原码：补码按位取反+1
//1000 0000 0000 0000 0000 0000 0000 1010=-10

计算结果为：-10

5.第五题+解析😶
   unsigned int i;
    for(i = 9; i >= 0; i--)
    {
    printf("%u\n",i);
    }
由于int i是无符号整型，所以取值不可能小于（<）0.
所以程序中的i>=0判断条件，不论i--恒成立，输出结果会发生死循环
6.第六题+解析😶
int main()
{
    char a[1000];//字符型数组
    int i;
    for(i=0; i<1000; i++)
    {
        a[i] = -1-i;//分别对数组的每一个元素赋值
        //-1 -2 ...-128 127 126 ...0 1...
    }
    printf("%d",strlen(a));
    //strlen读取字符串长度，直到\0才停止，\0的ASCII值为0.也就是说strlen统计的是0之前有多少个元素
    //从-1到-128到0一共有255个元素
    return 0;
}
因为char的取值范围在-128~127之间，对数组赋值到char数组中不可能超出这个范围
所以计算结果为：255
7.第七题+解析😶
unsigned char i = 0;
int main()
{
    for(i = 0;i<=255;i++)
    {
        printf("hello world\n");
    }
    return 0;
}
同理，i<=255判断条件不论i++恒为真，程序会不断打印陷入死循环

注意：特别关注题目中以及编程过程中遇到unsigned，可能会发生bug👾

3.🌜浮点型数据在内存中的存储🌛

常见的浮点数有哪些呢？

比如：
3.1415926
1E10：E+数字表示10的数字次方
浮点数家族：float double等等
浮点数的范围：需要在float.h中查看
--->使用evenrything 这个软件搜索limits.h和float.h可以查看在C语言中double和float的取值范围。
3.1抛砖引玉💡

我们先看下面这个例子

int main()
{
    int n = 9;
    float *pFloat = (float *)&n;
    printf("n的值为：%d\n",n);
    printf("*pFloat的值为：%f\n",*pFloat);
    *pFloat = 9.0;
    printf("num的值为：%d\n",n);
    printf("*pFloat的值为：%f\n",*pFloat);
    return 0;
}

接下来解释一下输出的结果：

int n = 9;
//n的值为整型
float *pFloat = (float *)&n;
//取n的地址强制类型转换为浮点型指针类型，将取到的地址放到变量pFloat中，变量pFloat的类型是浮点型指针
printf("n的值为：%d\n",n);
//此时以整型打印整型n的值：结果为9
printf("*pFloat的值为：%f\n",*pFloat);
//对pFloat浮点型指针进行解引用操作，以浮点型打印整型n的结果：为0.0000000
*pFloat = 9.0;
//间接修改n的值为9.0浮点型
printf("num的值为：%d\n",n);
//以整型打印浮点数n的值：9.0000000
 printf("*pFloat的值为：%f\n",*pFloat);
//对pFloat浮点型指针进行解引用操作，以浮点型打印整型n的结果：为9.000000

也就是说：整型数据用整型输出，用浮点型输出结果会发生变化，说明在内存中浮点型数据和整形数据的存储方式不同。接下来详细介绍：

3.2浮点数的存储规则
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：
1. (-1)^S * M * 2^E
2. (-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。
3. M表示有效数字，大于等于1，小于2。
4. 2^E表示指数位。
//举例说明
float num=5.0
//在内存中十进制转换为二进制存储的方式可以写成：
101.0
//又可以表示成：
1.010*2^2
//对应：(-1)^S * M * 2^E,可以表示为：
(-1)^0*1.010*2^2
//计算得出：
S=0;M=1.010;E=2
IEEE 754规定：
对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。

在32位机器下，内存中的存储格式

对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M

在64位机器下，内存中的存储格式

对于指数M的特别规定：

IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的
xxxxxx部分。比如保存1.01的时
候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位
浮点数为例，留给M只有23位，
将第一位的1舍去以后，等于可以保存24位有效数字。
//也就是说，上面的举例中：这样做可以提高保存在内存中的数据的精度
M=0.010

对于指数E的特别规定：

首先，E为一个无符号整数（unsigned int）
这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们
知道，科学计数法中的E是可以出
现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数
是127；对于11位的E，这个中间
数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即
10001001。
指数E从内存中取出还可以再分成三种情况：
E不全为0或不全为1
这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将
有效数字M前加上第一位的1。（因为之前M存储的是0.xxxxx，需要再把1补回来）
比如：
0.5（1/2）的二进制形式为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.3解释抛砖引玉的结果
//在32位平台下
int main()
{
    int n = 9;
    //n为正数，原码反码补码相同：0000 0000 0000 0000 0000 0000 0000 1001
    float *pFloat = (float *)&n;
    printf("n的值为：%d\n",n);
    printf("*pFloat的值为：%f\n",*pFloat);
    //将整数9按照浮点数存储规则进行会出现如下结果：
    0 00000000 00000000000000000001001
    S=0;E=00000000；M=00000000000000000001001//符合E全为0的情况
    //也就是：(-1)^0*0*2^(-118)
    打印结果为：0.000000
    *pFloat = 9.0;
    //此时n看作是浮点数
    printf("num的值为：%d\n",n);
    //以整型的方式打印浮点数：需要先将浮点数在内存中取出.我们先看9.0存入内存的方式
    //9.0用二进制表示为：
    1001.0
    //进一步用浮点数表示为：
    (-1)*0*1.001*2^3
    //此时S=0,M=1.001,E=3
    //存储在内存时：S=0,M=0.001,E=3+127=130
    用二进制表示为：0 10000010 00100000000000000000000
    //以整型方式显示：01000001000100000000000000000000
    //通过二进制转十进制的方式得出：
    1,091,567,616
    printf("*pFloat的值为：%f\n",*pFloat);
    //以浮点数形式打印浮点数9.0，结果为：
    9.000000
    return 0;
}

注意：

  1. 浮点数举例避免举小数点太复杂的例子，因为得出指数E+127很难用二进制表示，理解即可👌

2.解释了为什么我们在编程时有些数据用float和double 时输入数据相同，输出数据有稍微差异，因为在内存中存储时M占的位数有所不同，也就是说：浮点型数据存入内存和取出内存会有精度缺失的现象。

3.4浮点数的相关术语字典

  1. 定点数：指的是小数点位置是固定的，小数点位于符号位和第一个数值位之间，它表示的是纯小数。

  1. 浮点数：实数N可统一表示为：N=S*r^j，其中：S为尾数，规定用纯小数表示；j为阶码（正负均可，但必须为整数）；r是基数，对二进制而言，r=2。例如：10.0111=10100111*2^10

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧


新闻标题：”神仙修炼“之C的数据存储-创新互联
文章网址：http://scyanting.com/article/dhpooe.html

其他资讯