C进阶语法（八）数据的存储

数据类型详细介绍

内置类型

char    //字符数据类型
short    //短整型
int     //整形
long    //长整型
long long  //更长的整形
float    //单精度浮点数
double   //双精度浮点数

int 和float都是占内存4个字节，但是在内存中存储形式不同

自定义类型（构造类型）—略，后面会讲。

类型的基本归类：

整形家族：

char//在内存中以Ascall码存储的
    unsigned char
    signed char
short
    unsigned short [int]
    signed short [int]
int
    unsigned int
    signed int
long
    unsigned long [int]
    signed long [int]

浮点型家族

float
double

构造类型：

> 数组类型
> 结构体类型 struct
> 枚举类型 enum
> 联合类型 union

例：

void test(void)//无类型，此时在main中输入100是错误的
{
        printf("hehe\n");
}
int main()
{
        test(100);
        return 0;
}

整形在内存中的存储：

原码、反码、补码

计算机中的整数（有符号数）有三种表示方法，即原码、反码和补码。

三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，

无符号数原码、反码、补码都相同

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

而数值位负数的三种表示方法各不相同。如下：

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

二进制与八进制、十六进制转化规则

十六进制与二进制转化规则：“8421”原则，即4个二进制位构成1个十六进制位，并按照“8421”原则转化

八进制与二进制转化规则：“421”原则，即3个二进制位构成1个八进制位，并按照“421”原则转化

例：

int main()
{
        int a = 20;//4个字节-32bit
        //00000000 00000000 00000000 00010100-原码
        //00000000 00000000 00000000 00010100-反码
        //00000000 00000000 00000000 00010100-补码
        //0X0014
        int b = -10;
        //10000000 00000000 00000000 00001010-原码
        //11111111 11111111 11111111 11110101-反码
        //11111111 11111111 11111111 11110110-补码
        //0XFFFFFFF6
        //内存中存的是整数的补码
}

大小端字节序介绍及判断

对于a和b分别存储的是补码。但是我们发现存储到内存后顺序有点不对劲

大小端介绍

什么大端小端：

大端正着存数据，小端倒着存数据。

编译器支持大端存储或者小端存储模式

**例：**写一段代码告诉我们当前机器的字节序是什么？

char类型访问一个字节的地址*

//指针类型的意义：

1.指针类型决定了指针解引用操作符能访问几个字节：char*能访问1个字节，int*能访问4个字节

2.指针类型决定了指针+1、-1，能加或者能减的是几个字节；char*p,p+1跳过1个字节；int*p,p+1:跳过4个字节

//返回1 小端存储
//返回0 大端存储
int check_sys()
{
    int a = 1;
    char*p=(char*)&a;//将&a类型从int*强制转换为char*,方便指针p调用
    return *p;
}

int main()
{
    int a = 1;
    int ret = check_sys();//将&a类型从int*强制转换为char*,方便指针p调用

    if (ret== 1)
    {
        printf("小端存储\n");
    }
    else
    {
        printf("大端存储\n");
    }
    return 0;
}

练习

例1：

#include <stdio.h>
int main()
{
    //-1-char类型 占1个字节即8个比特位
    //10000001-原码
    //11111110-反码
    //11111111-补码
    char a = -1;//char-字符类型 占1个字节
    //11111111-补码--->-1

    signed char b = -1;//signed符号数
    //11111111-补码--->-1


    unsigned char c = -1;//unsigned-无符号数
    //11111111-补码、原码----->255
    //类型提升：从有符号数(char)转换为无符号数(unsigned char)，最高位转为无符号位。
    //此时由于unsigned存在，整型直接将有符号位转换为无符号位

    printf("a=%d,b=%d,c=%d", a, b, c);//%d-整型，此时会发生类型提升
    //-1 -1 255
    return 0;
}

在这段代码中，变量c是一个无符号的char类型，其取值范围为0到255。当将有符号的-1赋给无符号的变量c时，由于无符号数不支持负数，编译器会先将-1转换为其对应的无符号整数表示方式，即将有符号数的补码转换为无符号数的值。

在8位(char)情况下，-1的补码为11111111，将其转换为无符号整数后，其值为2^8 - 1 = 255。因此，当用printf函数并指定格式化字符串为"%d"时，输出的结果为c=255，对应于二进制表示为11111111。

例2：

//类型提升：从有符号数(char)转换为无符号数（unsigned int)，补位须与最高位相同。

int main()
{
    char a = -128;
    //10000000-原码
    //11111111-反码
    //10000000-补码（8位）

    printf("%u\n", a);//%u-打印十进制的无符号数，
    //%u将a从有符号字符(char)转换为无符号数（unsigned int)，补位须与最高位相同。
    //11111111 11111111 11111111 10000000
    return 0; 
}

char类型确实只占8位，但在这段代码中，使用**%u格式说明符时将变量a强制转换为无符号整数(unsigned int)类型。通常情况下，unsigned int类型在大多数系统架构中都是占用32位的内存空间。**

因此，当a的值为-128时，其在内存中的二进制补码表示为10000000。**按照%u格式说明符进行输出时，编译器会先将其强制转换为一个32位的无符号整数(unsigned int)，补齐高位后输出其二进制表示。**因此输出的结果为11111111 11111111 11111111 10000000的二进制表示，对应于4294967168这个十进制无符号整数。

注：

signed char(有符号字符）类型范围是-128~127，超过127自动转化为-128直到转化到0，再从0开始累计

unsigned char(无符号字符)类型范围是0~225，超过225自动转化为0，再开始累计

例3：

//signed char（有符号字符）类型最大只能存入01111111（127）当超过之后，就会变成127+1变成-128了，不溢出。

int main()
 { char a = 128; 
   printf("%u\n", a); 
    return 0; 
}
//signed char（无符号字符）类型最大只能存入01111111（127）当超过之后，就会变成127+1变成-128了，不溢出。  

例4：

//有符号和无符号一起计算时，首先按照补码的形式进行运算，最后格式化成为有符号数

int main()
{
    int a = -20;
    //10000000 00000000 00000000 00010100
    //11111111 11111111 11111111 11101011
    //11111111 11111111 11111111 11101100-补码
                                
    unsigned int b = 10;
    //00000000 00000000 00000000 00001010

    printf("%d", a + b);
    //11111111 11111111 11111111 11101100-a
    //00000000 00000000 00000000 00001010-b
    //11111111 11111111 11111111 11110110-a+b--->-10
    return 0;
}

例5：

**// unsigned int i; 其中i为无符号数，无论i含不含负数，都认为是无符号数。此时会将其补码视为无符号数真实值，即i始终大于等于0 **下列代码中会陷入死循环。

#include<Windows.h>
int main()
{
    unsigned int i;
    for (i = 9; i >= 0; i--)
    {
        printf("%u\n", i);
        Sleep(1000);//睡眠代码
    }
    return 0;
}

例6：

signed **char(有符号字符）的范围是-128_{127，当char数组存入int元素时,会将其转换为char类型**，由此，下列代码中存入到char数组的元素经历了从-1}-128₁₂₇0转化，而char字符0表示的是‘\0’，故最终计算字符串长度为255.

注： //int类型占4个字节，不代表i会占4个字节！！！不要陷入误区。

int main()
{
    char a[1000];
    int i;//int类型占4个字节，不代表i会占4个字节！！！
    for(i=0; i<1000; i++)
    {
        a[i] = -1-i;
    }
    printf("%d",strlen(a));
    return 0;
}

例7:

**unsigned char(无符号字符）的范围是0~225，当超过225后自动转为0重新累计到225；**下列代码因此陷入死循环。

#include <stdio.h>
unsigned char i = 0;//0~225
int main()
{
    for(i = 0;i<=255;i++)
    {
        printf("hello world\n");
    }
    return 0;
}//陷入死循环

浮点型在内存中的存储

常见的浮点数：

3.14159
1E10
浮点数家族包括：float、double、long double类型。
浮点数表示的范围：float.h

一个例子

浮点数存储的例子：

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;
}

输出结果是：

浮点数存储规则

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

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

IEEE 754规定：

对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。

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

IEEE 754一些特别规定：

有效数字M情况：

**在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。

指数E情况：

E为一个无符号整数（unsigned int）如果E为8位，它的取值范围为0~225；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。

例：

int main()
{
    float f = 5.5;
    //5.5---101.1
    //(-1)^0*1.011*2^2
    //S=0;M=1.011;
    //E=2;
    //S  E+127    M
    //0 10000001  01100000000000000000000
    //0100 0000 1011 0000 0000 0000 0000 0000
    //0X40b00000
    return 0;
}//最终在内存里为小端存储

指数E从内存中取出分三种情况

1.E不全为0或不全为1

这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或double类型是1023），得到真实值，再将有效数字M前加上第一位的1。

2.E全为0(即为-127时)

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

3.E全为1

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

解释例子（看其中解释）：

int main()
{
  int n = 9;
  //00000000 00000000 00000000 00001001-补码

  float* pFloat = (float*)&n;//此时*pFloat可以指向int所占的4个字节空间，但是指针只能一个字节一个字节的访问空间
  printf("n的值：%d\n", n);//9
  printf("*pfloat的值为：%f\n", *pFloat);//此时*pFloat会认为其n为浮点数,会对其二进制按照浮点数来排列(S E+127 M)输出
  //首先，将9拆分，得到第一位符号位s=0，后面8位的指数E=00000000，最后23位的有效数字M = 000 0000 0000 0000 0000
  //由于指数E全为0，所以符合上一节的第二种情况。因此，浮点数V就写成：
  //(-1)^0 * 0.00000000000000000001001 * 2^-126
  //V是一个很小的接近于0的正数，所以用十进制小数表示打印出来0.000000

  *pFloat = 9.0;
  //1001.0--9.0的补码
  //1.001*2^3 #S=0 , M=1.001 , E=3---011
  //E+127---10000010
  // S      E+127         M(23bit)
  //(-1)^0 * 10000010 * 00100000000000000000000 ---浮点数在内存表现形式
  //0 10000010 00100000000000000000000 

  printf("num的值：%d\n", n);//此时n将*pFloat存进去认为是整数，会对其二进制按照整数来排列输出。即
  //01000001 00010000 00000000 00000000
  //0x41 10 00 00--十六进制
  //1091567616--十进制

  printf("*pFloat的值为：%f\n", *pFloat);
  return 0;
}