数据的储存

原创已于 2023-03-24 19:54:38 修改 · 236 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#c语言

于 2023-01-09 21:12:52 首次发布

C语言专栏收录该内容

5 篇文章

订阅专栏

👋 👋 欢迎来到布谷的博客~
📡 博客主页：布谷的首页
📋 所属专栏：明解C语言
💁 感谢你的点赞 👍 评论 💇 收藏 📚 关注 💓

一.整形在内存中的存储

原码，反码，补码

计算机中整数有三种二进制的表示方法，原码，反码，补码。

整数的原反补码是相同的，而负数三者互不相同。

整数在内存中以补码存储。

反码：原码符号位不变，其他位按位取反。
补码：反码加一。

补码转化为原码，也是取反加一。

大小端

什么是大端小端？

大端模式，是指将数据的低位保存在内存的高地址中，数据的高位保存在内存的低地址中。

小端模式，是指将数据的高位保存在内存的高地址中，数据的低位保存在内存的低地址中。

下面以 int b = 0x11223344为例

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

上面这张图就是小端存储，44是高位，他存储在了内存的低地址，11是数据的低位，存储在内存的高地址处。

那么，如何来测试我们当前机器的字节序呢？

首先，我们可以先存一个数字，观察大小端存储的不同。就拿数字1来说，

他在小端是这样存储的

大端

很明显，只需要拿出第一个字节的内容，就可以得知了，那如何才能只拿出一个字节的内容呢，我们知道，指针的类型决定了指针的步长，int*指针的步长是四字节，char*指针的步长是一字节，所以我们可以用char*指针拿出第一个字节。

int b=1;
char*p=(char*)&b;
if(*p==1)
    printf("小端");
else
    printf("小端");

char类型的存储

我们知道char类型分为两种，一种signed char，一种unsigned char。

signed char储存数据的范围是-128~127

unsigned char的范围是0~255

char c=-1;

-1是一个整数,32个bit位
原：10000000000000000000000000000001
反：11111111111111111111111111111110
补：11111111111111111111111111111111
在内存中以补码方式存储
放到char类型内发生截断，因为char类型只有8个bit位
11111111

char c=-128;

-128是一个整数,32个bit位
原：10000000000000000000000010000000
反：11111111111111111111111101111111
补：11111111111111111111111110000000
放到char类型内发生截断，
10000000

char c=-127

-127是一个整数,32个bit位
原：10000000000000000000000001111111
反：11111111111111111111111110000000
补：11111111111111111111111110000001
放到char类型内发生截断，
10000001

所以，char类型从0~127

00000000，00000001，……，01111111

-128~-1

10000000，10000001，……，11111111

用一个圆来表示

unsigned char 没有符号位

unsigned char c=128;

00000000 00000000 00000000 10000000
截断：10000000

unsigned char c=129

00000000 00000000 00000000 10000001
截断：10000001

unsigned char c=256

00000000 00000000 00000001 00000000
截断：00000000
0

unsigned char c=-1;

原码：10000000 00000000 00000000 00000001
反码：11111111 11111111 11111111 11111110
补码：11111111 11111111 11111111 11111111
截断：11111111
255

所以，unsigned char类型从0~255

00000000，00000001，……，11111110，11111111

用图片表示

学习了这些，我们来做几个练习吧：

1.
//输出什么？
#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;
}

2.
#include <stdio.h>
int main()
{
    char a = -128;
    printf("%u\n",a);
    return 0;
}

3.
#include <stdio.h>
int main()
{
    char a = 128;
    printf("%u\n",a);
    return 0;
}

4.
int i= -20;
unsigned  int  j = 10;
printf("%d\n", i+j); 
//按照补码的形式进行运算，最后格式化成为有符号整数

5.
unsigned int i;
for(i = 9; i >= 0; i--)
{
    printf("%u\n",i);
}

6.
int main()
{
    char a[1000];
    int i;
    for(i=0; i<1000; i++)
   {
        a[i] = -1-i;
   }
    printf("%d",strlen(a));
    return 0;
}

7.
#include <stdio.h>
unsigned char i = 0;
int main()
{
    for(i = 0;i<=255;i++)
   {
        printf("hello world\n");
   }
    return 0;
}

1.
显而易见，a和b都输出-1，上面我们说过，unsigned char c=-1，他存进去的是11111111
用%d打印，%d是打印有符号的整数，对c整型提升，整型提升使用符号位来补齐
c无符号数，用0补齐
00000000000000000000000011111111
很明显，是数字255
所以最终答案为 -1，-1，255

2.
-128
原码：10000000 00000000 00000000 10000000
反码：11111111 11111111 11111111 01111111
补码：11111111 11111111 11111111 10000000
截断存入char
10000000
a先进行整型提升，用原来的符号位来补齐
11111111 11111111 11111111 10000000，
因为%u打印无符号整形，所以最高位不按符号位，
结果是4,294,967,168

3.
char a=128
10000000
按符号位整型提升
11111111 11111111 11111111 10000000
因为%u打印无符号整形，所以最高位不按符号位，
结果是4,294,967,168

4.
i: 原：10000000 00000000 00000000 00010100
反：11111111 11111111 11111111 11101011
补：11111111 11111111 11111111 11101100
j： 00000000 00000000 00000000 00001010
i+j： 11111111 11111111 11111111 11110110
补->原：10000000 00000000 00000000 00001010
%d是打印有符号的整数
结果是-10。

5.
因为i是无符号整型，所以i一定>=0
所以，会无限循环

6.
strlen在遇到0的时候停止，所以关键是思考什么时候会出现0
a[i]的变化：-1，-2，……，-128，127，……，1，0
所以，结果为255。

7.
如果i++变成了256，
那么unsigned char i=0
unsigned char的范围是0~255，
所以他一直满足for循环的条件
所以会一直循环

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

根据国际标准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表示指数位。

举个例子，十进制的5.0，写成二进制就是101.0，也就是(-1)^0*1.01*2^2。

S=0, M=1.01, E=2

如果是-5.0，那么S=1。

再举个例子

float f=5.5f;

他写成二进制就是101.1，小数点后的二进制位的权重是2^-1,2^-2,2^-3……

也就是(-1)^0*1.011*2^2

指数E和十进制一样，小数点向左移动n位就是2^n，小数点向右移动n位，就是2^(-n)。

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的计算值为0的话，拿他的真实值是-127，一个1.xx的数乘上2^-127是一个很小的数，趋近于零
这时我们就规定，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于 0的很小的数字。

E全为1

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

欧克，学完了这些，上例子

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