C语言进阶⑩(数据的存储)数据类型_介绍+存储_大小端(知识点+笔试题)

GR鲸鱼

已于 2024-01-14 20:57:15 修改

阅读量362

点赞数 3

分类专栏： ②C语言知识点和练习文章标签： c语言开发语言数据存储智力题大小端

于 2023-02-03 13:11:29 首次发布

本文链接：https://blog.csdn.net/GRrtx/article/details/128847453

版权

②C语言知识点和练习专栏收录该内容

21 篇文章 11 订阅

订阅专栏

3.2 浮点数存储规则（IEEE754规定）

3.3解释前面的例子：

4.笔试题

4.1程序的执行结果为（）

4.2在32位大端模式处理器上变量b等于（）

本章重点

1. 数据类型详细介绍

2. 整形在内存中的存储：原码、反码、补码

3. 大小端字节序介绍及判断

4. 浮点型在内存中的存储解析

前面我们已经学习了基本的内置类型：

以及他们所占存储空间的大小。

1. 数据类型介绍

前面我们已经学习了基本的内置类型：

char //字符数据类型

short //短整型

int //整形

long //长整型

long long //更长的整形

float //单精度浮点数

double //双精度浮点数

类型的意义：

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

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

1.1 类型的基本归类：

整形家族：

为什么 char 算整型：
因为字符类型底层存储的是 ASCII 码值，而ASCII码值也是整数，
所以在归类的时候会把 char 类型归结到整型家族里去。（ ASCII码：美国信息交换标准代码）

浮点数家族：

构造类型：（自定义类型）

注意事项：如下面数组都是整型数组，但是它们的类型完全不一样


int arr1[10]; // 类型为：int[10]
int arr2[5]; // 类型为：int[5]

指针类型

空类型：

void 表示空类型（无类型）

通常应用于函数的返回类型、函数的参数、指针类型。

2.整形在内存中的存储

看看内存：

2.1原码、反码、补码

数据在内存中以2进制的形式存储：

① 对于整数来说，内存中存储的二进制有3种表示形式：原码、反码、补码。

② 正整数：原码、反码、补码相同。

③ 负整数：原码、反码、补码不同，要进行计算。

负整数原码：按照数据的数值直接写出的二进制序列就是原码

符号位：最高位1表示负数，最高位0表示正数

负整数反码：原码的符号位不变，其他位按位取反，即为反码

负整数补码：反码 +1，得到的就是补码

2.1.1 内存中为何存放补码

虽然整数的二进制表示形式有三种，但是内存中存储的是补码

为什么在内存中存的是补码呢：

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

2.2大小端介绍

再仔细观察下刚才内存中的存储，这次再添加一个 b = 10：

可以看到对于 a 和 b 分别存储的是补码，

但是发现顺序好像是倒过来的，为什么会这样呢？

大端小端存储问题，当一个数据的大小存储到内存空间大于1个字节时，
会存在一个存储顺序的问题，这个存储顺序的问题就有两种，一个为大端，一个为小端。

2.2.1大端模式

作用：把数据的低位保存在内存的高地址处，高位字节序的内容存放在低地址中（正着存）

总结：大端模式，低位放在高地址，高位放在低地址

2..2.2小端模式

作用：把数据的低位保存在内存的低地址处，高位字节序的内容存放在高地址中（倒着存）

总结：小端模式，低位放在低地址，高位放在高地址

2.2.3产生的原因

为什么会有大小端模式之分呢？这是因为在 计算机系统中，是以字节为单位的，
每个地址单元都对应着一个字节，一个字节为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处理器还可以由硬件来选择是大端模式还是小端模式。

2.2.4代码判断大小端

百度_系统工程师笔试题：请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。

直接放代码：


#include<stdio.h>
int check_sys()
{
    int i = 1;
    char* p = (char*)&i; // 取第一个字节
    return *p; // 返回1表示小端(01 00 00 00)，返回0表示大端(00 00 00 01)
}
int main()
{
    if (check_sys)
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    return 0;
}

2.3有符号数和无符号数

无符号数（unsigned），有符号数（signed）

2.3.1两种char的范围

有符号 char 的范围是： -128 ~ 127

无符号 char 的范围是： 0 ~ 255

signed char 解析：

2.3.2下面七个练习程序各输出什么？

（在下面的注释写解析了）

练习一


#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);
    return 0;
}
// a = -1, b = -1, c = 255
//解析：                                       
//存的都是11111111  以%d打印要整形提升  
//a和b都提升为11111111111111111111111111111111  为-1
//c不认为第一位的1是符号位所以整形提升为00000000000000000000000011111111  为255

练习二


#include <stdio.h>
int main()
{
    char a = -128;
    printf("%u\n",a);
    return 0;
}
//解析：
//-128原码为10000000000000000000000010000000
//    反码为01111111111111111111111101111111
//    补码为01111111111111111111111110000000
//计算机存的char a为后8位 10000000
//整形提升按照原来的符号来提升（高位补符号位），提升为11111111111111111111111110000000
//大部分编译器认为char 是有符号的char（标准没规定）
//但标准规定了int short都是有符号的
//
//%u无符号（原反补相同）打印为11111111111111111111111110000000为4294967168

练习三


#include <stdio.h>
int main()
{
    char a = 128;
    printf("%u\n",a);
    return 0;
}
//解析：
//128本来为00000000000000000000000010000000
//计算机存的char a取后8位  为10000000
//整形提升为11111111111111111111111110000000
//%u无符号（原反补相同）打印为11111111111111111111111110000000为4294967168

练习四


#include<stdio.h>
int main()
{
    int i = -20;
    unsigned int j = 10;
    printf("%d\n", i + j);
    return 0;
}
//解析：
//-20原码为    10000000000000000000000000010100
//   反码为    11111111111111111111111111101011
//   补码为    11111111111111111111111111101100
//当成无符号为  11111111111111111111111111101100   +
//10为        00000000000000000000000000001010   =
//            11111111111111111111111111110110   
//以%d有符号打印为（转化为原码）（符号位不变，其它按位取反后+1）
//            10000000000000000000000000001010  为-10 
//当代大学生：（-20）+10怎么能是-10呢   算麻了

练习五


#include<stdio.h>
int main()
{
    unsigned int i;
    for (i = 9; i >= 0; i--)
    {
        printf("%u\n", i);
    }
    return 0;
}
//解析：
//unsigned int>=0,所以i >= 0恒成立，死循环
//9
//8
//7
//6
//5
//4
//3
//2
//1
//0
//4294967295
//4294967294
//4294967293...........

练习六


#include<stdio.h>
int main()
{
    char a[1000];
    int i;
    for (i = 0; i < 1000; i++)
    {
        a[i] = -1 - i;
    }
    printf("%d", strlen(a));
    return 0;
}
//解析：
//127   01111111
//-128  10000000
//a的变化为：-1 -2 -3 ...-127 -128 127 126 .....1 0 -1 -2........
//strlen:找到\0  既0,0前面有128+127个数字 所以是255

练习七


#include <stdio.h>
unsigned char i = 0;
int main()
{
    for (i = 0;i <= 255;i++)
    {
        printf("hello world\n");
    }
    return 0;
}
//解析：
//unsigned char最大是11111111   255  （范围是[0,255]）
//死循环

3.浮点型在内存中的存储

常见的浮点数：

3.14159

1E10

浮点数家族包括： float、double、long double 类型。

浮点数表示的范围：float.h中定义。

3.1 一个例子

浮点数存储的例子：


#include<stdio.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;
}

请猜测下输入结果并去编译器验证，结果：

3.2 浮点数存储规则（IEEE754规定）

num 和 *pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？

要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。

详细解读：

根据国际标准IEEE（电器和电子工程协会）754 规定，任意一个二进制浮点数V可以表示成以下形式： (-1)^S * M * 2^E

① (-1)^s 表示符号位，当 s = 0，V为正数；当s = 1， v为负数

② M表示有效数字，大于等于1，小于2

③ 2^E 表示指数位

例子：

浮点数：5.5 ：10进制

二进制：101.1 → 1.011 * 2^2 → (-1) ^0 * 1.011 * 2^2

s=0 M=1.011 E=2

IEEE 754 规定：

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

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

IEEE 754对有效数字M和指数E，还有一些特别规定。前面说过， 1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中xxxxxx表示小数部分。

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

至于指数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。比如： 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解释前面的例子：

下面，让我们回到一开始的问题：为什么 0x00000009 还原成浮点数，就成了 0.000000 ？

首先，将 0x00000009 拆分，得到第一位符号位s=0，后面8位的指数 E=00000000 ，最后23位的有效数字M=000 0000 0000 0000 0000 1001。

9 -> 0000 0000 0000 0000 0000 0000 0000 1001

由于指数E全为0，所以符合上一节的第二种情况。因此，浮点数V就写成：

V=(-1)^0 × 0.00000000000000000001001×2^(-126)

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000。

再看例题的第二部分。

请问浮点数9.0，如何用二进制表示？还原成十进制又是多少？

首先，浮点数9.0等于二进制的1001.0，即1.001×2^3。

9.0 -> 1001.0 ->(-1)^01.0012^3 -> s=0, M=1.001,E=3+127=130

那么，第一位的符号位s=0，有效数字M等于001后面再加20个0，凑满23位，指数E等于3+127=130，

即10000010。

所以，写成二进制形式，应该是s+E+M，即

0 10000010 001 0000 0000 0000 0000 0000

这个32位的二进制数，还原成十进制，正是 1091567616 。

4.笔试题

4.1程序的执行结果为（）


#include<stdio.h>
int main()
{
    unsigned char a = 200;
    unsigned char b = 100;
    unsigned char c = 0;
    c = a + b;
    printf("%d %d", a + b, c);
    return 0;
}

A.300 300

B.44 44

C.300 44

D.44 300

解析：


#include<stdio.h>
int main()
{
    //二进制可以用计算机转化
    unsigned char a = 200;
    //200的二进制00000000000000000000000011001000
    //存的：11001000
    unsigned char b = 100;
    //100的二进制00000000000000000000000001100100
    //存的：01100100
    unsigned char c = 0;
    //相加不够int 要整形提升
    //00000000000000000000000011001000   +
    //00000000000000000000000001100100   =
    //00000000000000000000000100101100
    c = a + b;
    //存到c中c为（后8位）00101100为44
    //a+b不存到c中就是00000000000000000000000100101100为300
    printf("%d %d", a + b, c); //300 44
    return 0;
}

4.2在32位大端模式处理器上变量b等于（）


#include<stdio.h>
int main()
{
    unsigned int a = 0x1234; 
    unsigned char b = *(unsigned char*)&a;
    return 0;
}

A.0x00

B.0x12

C.0x34

D.0x1234

解析：


#include<stdio.h>
int main()
{
    unsigned int a = 0x1234; //int a是4个字节，存的是0x 00 00 12 34
                             //假设左边是低地址右边是高地址
                             //大端里存的就是          00 00 12 34
                             //小端里存的就是          34 12 00 00
    unsigned char b = *(unsigned char*)&a;
              //题目说大端，unsigned char*取出的是第一个字节的地址，为00 选A
    return 0;
}

4.3在屏幕上打印杨辉三角。

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

……

输入n，表示n行

解析：

由于此题要打印整个杨辉三角的数据而非取出某一项，所以不可避免的一定是要填出每一项，没有偷懒的余地，那就老老实实的根据规律填空即可。按照题设的场景，能发现数字规律为：d[i][j] = d[i - 1][j] + d[i - 1][j - 1]。所以只要按照这个方法填表即可。

法一：


#include<stdio.h>
void yang_hui_triangle(int n)
{
    int data[30][30] = { 1 }; //第一行直接填好，播下种子
    int i = 0, j = 0;

    for (i = 1; i < n; i++) //从第二行开始填
    {
        data[i][0] = 1; //每行的第一列都没有区别，直接给1，保证不会越界。
        for (j = 1; j <= i; j++) //从第二列开始填
        {
            data[i][j] = data[i - 1][j] + data[i - 1][j - 1]; //递推方程
        }
    }

    for (i = 0; i < n; i++) //填完打印
    {
        for (j = 0; j <= i; j++)
        {
            printf("%d ", data[i][j]);
        }
         printf("\n");
    }
}
int main()
{
    int n = 0;
    scanf("%d", &n);
    yang_hui_triangle(n);
    return 0;
}

法二：

由于在填第n行的杨辉三角时，只跟第n-1行的杨辉三角产生联系，不会跟之前的有联系，

所以没必要保存每一行的杨辉三角，填一行打一行就行了，这样能让空间复杂度从n^2降低到n。

（空间复杂度是数据结构的内容，现在可以先理解为数组开的空间）

但是在填数据的时候不能对之前的数据覆盖，所以需要从后向前填。

而填杨辉三角顺序对结果是没有影响的，所以可以实现。


#include<stdio.h>
void yang_hui_triangle(int n)
{
    int data[30] = { 1 };
    int i = 0, j = 0;
    printf("1\n"); //第一行就直接打印了
    for (i = 1; i < n; i++) //从第二行开始
    {
        for (j = i; j > 0; j--) //从后向前填，避免上一行的数据在使用前就被覆盖
        {
            data[j] += data[j - 1]; //公式同上，由于变成了一维，公式也变简单了。
        }

        for (j = 0; j <= i; j++) //这一行填完就直接打印了。
        {
            printf("%d ", data[j]);
        }
         printf("\n");
    }
}
int main()
{
    int n = 0;
    scanf("%d", &n);
    yang_hui_triangle(n);
    return 0;
}

※这种方法虽然降低了空间复杂度，但只能保存最后一行的数据，

不利于反复查询，两个填法各有各的适用场景。就本题而言，改进后的胜出。

4.4代码题猜凶手

日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。

以下为4个嫌疑犯的供词:

A说：不是我。

B说：是C。

C说：是D。

D说：C在胡说

已知3个人说了真话，1个人说的是假话。

现在请根据这些信息，写一个程序来确定到底谁是凶手。

直接在代码注释里写解析：


//分析：
//k表示凶手(killer)，0表示假话，1表示真话
//if k==A,a==0,b==0,c==0,d==1;
//if k==B,a==1,b==0,c==0,d==1;
//if k==C,a==1,b==1,c==0,d==1;
//if k==D,a==1,b==0,c==1,d==0;
//所以c是凶手，怎么用代码求出呢？
#include<stdio.h>
int main()
{
    char k = 0;
    for (k = 'A';k <= 'D';k++)
    {
        //把四句话用表达式表示出来，真为1，假为0
        if ((k != 'A') + (k == 'C') + (k == 'D') + (k != 'D') == 3)
        {
            printf("%c是凶手\n", k);
        }
    }
    return 0;
}

4.5代码题猜名次

5位运动员参加了10米台跳水比赛，有人让他们预测比赛结果：

A选手说：B第二，我第三；

B选手说：我第二，E第四；

C选手说：我第一，D第二；

D选手说：C最后，我第三；

E选手说：我第四，A第一；

比赛结束后，每位选手都说对了一半，请编程确定比赛的名次。

直接在代码注释里写解析：


//考虑到一共五个人，直接模拟推理有些太难，计算机最擅长的遍历此时就会派上用场，
//将每个人从第1到第5来一遍，则一共会产生5 ^ 5种可能性，这个只需要一个5层循环即可搞定。
//但是这样会导致一些不期望出现的结果出现，因为我并没有查重，所以会出现两个人抢名次的情况，
//也就是两个人或者更多的人名次相同的情况，例如两个第二，三个第三这样的，
//所以即使满足了条件，也要查看一下五个人的名次是否重复，
//这个交给一个函数来执行，只要五个人名次并列，那就返回0，否则返回1即可。
//有了这个思路，就能完成以下代码。
//往后面学习还会有更好的方法
#include <stdio.h>
int checkData(int* p)
{
    int tmp[7] = { 0 }; //标记表，实际是哈希表的思路。一开始每个元素都是0。

    for (int i = 0; i < 5; i++)
    {
        if (tmp[p[i]]) //如果这个位置的标记已经是1，则代表重复，直接返回0。
        {
            return 0;
        }
        tmp[p[i]] = 1; //如果不是，则给这个位置标记为1。
    }
    return 1; //全部标记完毕也没有出现重复的情况，代表OK。
}

int main()
{
    int p[5] = { 0 }; //0 1 2 3 4分别代表A B C D E
    for (p[0] = 1; p[0] <= 5; p[0]++)
    {
        for (p[1] = 1; p[1] <= 5; p[1]++)
        {
            for (p[2] = 1; p[2] <= 5; p[2]++)
            {
                for (p[3] = 1; p[3] <= 5; p[3]++)
                {
                    for (p[4] = 1; p[4] <= 5; p[4]++) //五层循环遍历
                    {
                        //这里是五个人的描述，由于比较表达式只有0和1两个结果，
                        //如果要两个条件有且只有一个为真，
                        //则可以用比较表达式的值总和为1的方式直接判定。
                        //别忘了还要判定不能并列。
                        if (
                            (p[1] == 2) + (p[0] == 3) == 1 && //B第二，我第三
                            (p[1] == 2) + (p[4] == 4) == 1 && //我第二，E第四
                            (p[2] == 1) + (p[3] == 2) == 1 && //我第一，D第二
                            (p[2] == 5) + (p[3] == 3) == 1 && //C最后，我第三
                            (p[4] == 4) + (p[0] == 1) == 1 && //我第四，A第一
                            checkData(p) //不能并列
                            )
                        {
                            for (int i = 0; i < 5; i++)
                            {
                                printf("%d ", p[i]);
                            }
                            printf("\n");
                        }
                    }
                }
            }
        }
    }
    return 0;
}

本章完（留一张关于智力题的图）

本篇完。

GR鲸鱼

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
C语言进阶⑩(数据的存储)数据类型_介绍+存储_大小端(知识点+笔试题)

C语言进阶⑩(数据的存储)(知识点+练习+作业)，加强内功，向看代码是内存的境界走。（开启智力题）把实际问题转化为代码求解。本专栏是一些C语言进阶的知识点和笔试题，零基础的建议先看上一专栏。
复制链接

扫一扫