【c语言】数据的存储

程序员婧子的博客

已于 2023-03-21 18:13:24 修改

阅读量203

点赞数

文章标签： c语言 Powered by 金山文档

于 2023-01-25 22:31:25 首次发布

本文链接：https://blog.csdn.net/2201_75368194/article/details/128757411

版权

1. 数据类型介绍

c语言的内置类型有很多，为什么会有这么多数据类型呢？

char //字符数据类型

short //短整型

int //整形

long //长整型

long long //更长的整形

float //单精度浮点数

double //双精度浮点数

类型的意义：

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

2. 如何看待内存空间的视角。同样是四个字节，如果是int就是整形数据，如果是float就是单精度浮点型数据，我认为内存中放的是什么。

1.1 类型的基本归类：

整形家族

char 字符在存储的时候是整形的ASCII值，所以字符属于整形家族

unsigned char 到底char有没有符号是取决于编译器的，并没有明确规定

signed char 常见的编译器char=signed char，其实并不完全等价

short

unsigned short [int]带括号 int可以省略

signed short [int] 默认有符号，等价的

int

unsigned int

signed int 默认有符号，等价的

long

unsigned long [int]

signed long [int] 默认有符号，等价的

long long

unsigned long long [int]

signed long long [int]

浮点型家族

float

double

构造类型=自定义类型=根据实际需求自己创造的

数组类型数组类型是int[10]，char[11]随着“数组元素”和“元素类型”的变化而变化

结构体类型 struct 定义一个学生的自定义类型

枚举类型 enum

联合类型 union

指针类型

int *pi;

char *pc;

float* pf;

void* pv; 无具体类型的指针

空类型

void 表示空类型（无类型）

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

2.整形在内存中的存储

2.1 原码反码、补码

1个int占4个字节=32个比特位

整形在内存中存储的是补码

为什么内存中要存补码？原码不行吗？反码不行吗？

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；计算加法无所谓最高位是不是符号位

同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

因为CPU没有减法器，所以1-1要转化成1+（-1）加法来计算。假设用原码来计算0000…0001+1000…0001=1000…0010结果是-2是错误的，用原码计算是会出问题的。

所以我们用补码计算1+（-1），-1的原码1000…0001，反码1111…1110，补码1111…1111，0000…0001+1111…1111=0000…0000进位上去丢掉了，发生了截断，所以补码可以计算减法，模拟成加法的方式来算

负数的原码反码补码

原码计算有问题，所以我们转化成补码去计算，同时也不会增加额外的硬件电路，所以补码能带来好处

2.2 大小端介绍

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

小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地址中。常用的x86就是倒着放的。

大端字节序存储模式，是以字节为单位来讨论他们的存储顺序的0x11 22 33 44，11是一个单位，地址从左边低地址，右边高地址，地址是增长的，我们也可以11 22 33 44，也可以44 33 22 11，也可以11 44 22 33，但是数据存储好我希望以后还可以拿出来还原数字，正着放，正着拿，乱着放乱着拿不可取，最后只剩下正序和逆序两种存储方式

因为0x11 22 33 44，44是低位字节数据，11是高位字节数据

整形在内存中就是一个字节为一个单位来存放的，负数是以补码的字节序来存放的

超过一个字节的就会有存储的顺序问题，浮点型也有大小端问题

为什么会有大小端模式之分呢？

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

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

请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。

我只对比第一个字节就非常明显，存储1，我只拿第一个字节，怎么拿？&a后强制类型转化存储起来，解引用访问第一个字节，函数check——sys判断大小端，还可以简化一下函数，直接解引用不要存起来地址了

// 设计一个小程序来判断当前机器的字节序
//存储1  小端01 00 00 00，大端00 00 00 01

check_sys()
{
    int a = 1;
    //char* p = (char*)&a;//强制类型转换，只访问第一个字节
    //return *p;
    return *(char*)&a;//不需要存储起来地址，直接解引用返回
}

int main()
{
    int ret = check_sys();//第一个字节是1，说明是倒序，第一个字节是0，说明正序
    if (ret == 1)
        printf("小端\n");
    else
        printf("大端\n");
    return 0;
}

2.3练习

首先一个整数是32比特位写出来原反补（char类型存放-128-127，unsigned char存放0-256）

再看这个整数要存储到什么类型的变量中，进行截断，只存储后面的位

以%d打印有符号的整数，要进行整型提升再打印，

以%u打印无符号的整数，要进行整型提升再打印

a的类型是无符号，高位补0

a的类型是有符号，高位补符号位

%u打印认为这个数没有符号位没有原反补直接打印

%d打印正数直接打印，负数要换成原码打印

1.
//输出什么？类型决定了如何看待内存中的值
#include <stdio.h>
int main()
{
//-1整数是32比特位原码1000…0001，反码1111…1110，补码1111…1111，
//-1存储到char类型1个字节=8个比特位，a里面放截断后面的8位11111111，
    char a= -1;
    signed char b=-1;//就是char
    unsigned char c=-1;//-1的存储过程是一样的，11111111以%d形式打印，
//最高位不是符号位，无符号数整型提升高位补0，正数的原反补相同，8个1就是255
    printf("a=%d,b=%d,c=%d",a,b,c);//-1 -1 225，
//%d是打印有符号的整数，他认为是有符号整数，对a进行提升后才可以打印，
//a符号位1，整形提升是按原来的符号位高位补1，再求原码打印
    return 0;
}

2.
#include <stdio.h>
int main()
{
    char a = -128;//2^7=128
//原码10000000 00000000 00000000 10000000
//反码11111111 11111111 11111111 01111111
//补码11111111 11111111 11111111 10000000
//a=10000000
//整型提升补符号位11111111 11111111 11111111 10000000
//%u认为内存中是无符号数不考虑原反补
    printf("%u\n",a);//4294967168
    return 0;
}

3.
#include <stdio.h>
int main()
{
    char a = 128;//2^7=128其实char类型不能存128的
//原反补00000000 00000000 00000000 10000000
//a=10000000
//整型提升char有符号补符号位11111111 11111111 11111111 10000000
//%u认为内存中是无符号整形不考虑原反补
    printf("%u\n",a);//4294967168
    return 0;
}

4.
int main()
{
    int i= -20;//16+4
//原码10000000 00000000 00000000 00010100
//反码11111111 11111111 11111111 11101011
//补码11111111 11111111 11111111 11101100
    unsigned  int  j = 10;//8+2
//原反补00000000 00000000 00000000 00001010
    printf("%d\n", i+j); //-10
//补码相加是补码 11111111 11111111 11111111 11110110
//理论上i+j是无符号数，但是%d使用打印决定了他到底有没有符号，看待他的视角
//符号位不变按位取反10000000 00000000 00000000 00001001
//+1得到原码  10000000 00000000 00000000 00001010  -10
    return 0;
}

//无符号数作为循环变量一定要小心，i>=0本来是来结束循环的，但站在无符号的角度这里恒成立
int main()
{
    unsigned int i;//负数会被当做无符号数来看，没有符号位取值远大于等于0
//9=8+1   00000000 00000000 00000000 00001001
//8       00000000 00000000 00000000 00001000
//……
//0
//-1原码      10000000 00000000 00000000 00000001
//-1补码      11111111 11111111 11111111 11111111存到i里面被当作无符号数来看是一个非常大的数
    for(i = 9; i >= 0; i--)
    {
        printf("%u\n",i);// 9 8 7 6 5 4 3 2 1 0 4294967295 4294967294 ……死循环
        Sleep(1000);
    }
    return 0;
}

6.
int main()
{
    char a[1000];
    int i;
    for(i=0; i<1000; i++)
   {
        a[i] = -1-i;//赋值初始化数组
//-1-0=-1
//-1-1=-2……-3，-4，-5……-128，127，126……3，2，1，0，-1，-2后面也会存储在数组中
   }
    printf("%d",strlen(a));//找'\0'就是找0，0之前有几个元素，128+127=255
    return 0;
}

7.
#include <stdio.h>
unsigned char i = 0;//取值范围0-255，小心循环变量是无符号数
int main()
{
    for(i = 0;i<=255;i++)//i<=255恒成立死循环，每创建一个i就会存到里面i不可能超过255
   {
        printf("hello world\n");
   }
    return 0;
}

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

常见的浮点数：

3.14159

1E10 1.0*10^10

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

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

（整形的取值范围在limits.h）

3.1一个现象

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
//n的角度是整数
     printf("*pFloat的值为：%f\n",*pFloat);//9.000000
//以浮点数存，浮点数拿确实是9.0
     return 0;
}

整形的形式放进去，只能以整形的形式拿出来，浮点数的形式放进去，只能以浮点数的形式往出拿，否则你拿到的结果是不对的。这个例子说明了浮点数和整数在内存中存储的形式是不一样的

3.2浮点数存储规则

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

(-1)^S * M * 2^E

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

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

2^E表示指数位。

十进制0.5

二进制0.1

因为1-M<2，所以科学计数法(-1)^0*1.0*（2^-1）指数可以为负数

一个十进制浮点数v=5.5

一个二进制浮点数v=101.1

小数点后的权重是2^-1,2^-2,其中2^-1就是0.5，只要有一个就够了

科学计数法小数点要向左移动两位1.011*2^2

正数的公式是(-1)^0*1.011*2^2

其中S=0，M=1.011，E=2，任何一个浮点数只有SME在发生变化，只存储SME就可以了

浮点数没有原反补概念，只有整数才有原反补

IEEE 754规定：

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

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

S

一个比特位，直接放进去

M

TEEE 754对有效数宇M和指数E，还有一些特别规定。

前面说过，1-M<2，也就是说，M可以写成 1xxxxxx 的形式，其中xxxxxx表示小数部分。

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

E

E是可能出现负数，但这里无符号数只能存正数，怎么办？

首先，E为一个无符号整数（unsigned int）

这意味着，如果E为8位，float它的取值范围为0~255；如果E为11位，double它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。比如，2^10的E真实的是10，所以保存成32位浮点数时，必须保存成10+127=137，即 10001001。这样我们就可以把他修正成一个正数，我们往出拿的时候也要减去127或者1023，怎么放就怎么拿，但往出取的时候也要分三种情况

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

因为-127+127=0，1.xxxxx*2^-127非常非常小了

这时，浮点数的指数E直接等于1-127=-126（或者1-1023）即为真实值

有效数字M不再加上第一位的1，而是直接还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于 0的很小的数字。

E全为1

(真实E)128+127=255全1，正负1.xxxxx*2^128，正负无穷大

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

float f = 5.5f;

一个十进制浮点数v=5.5

一个二进制浮点数v=101.1

正数的公式是(-1)^0*1.011*2^2

其中S=0，M=1.011，E=2

存到内存中的效果S=0

E= 2+127=129 10000001

M=只存小数点后面的011后面补0到23位

0100 0000 1011 0000 0000 0000 0000 0000 40 b0 00 00十六进制

往出拿：S=0表示正数，E不为全0也不为全1，129-127=2真实的E还原，M前面加1.011

给一个3.14，无法完全凑成0.14，浮点数在内存中无法精确保存，二进制无法还原小数点后面的数字，况且M的位数是有限的，9.0，5.5是可以精确算出来的，双精度浮点数更准确是相对的，不是完全的

int main()
{
     int n = 9;
//原反补00000000 00000000 00000000 00001001
     float *pFloat = (float *)&n;

     printf("n的值为：%d\n",n);//整数的形式拿出老打印9
     printf("*pFloat的值为：%f\n",*pFloat);//看这个值是float，他认为S=0，E=全0，M=0000…1001
//E=1-127=-126，还原（-1）^0 * 0.0000…1001*2^-126是一个无限接近0的数字0.000000

     *pFloat = 9.0;
//二进制1001.0
//（-1）^0 * 1.001 * 2^3
//S=0，E=3+127=130 10000010，M=001
//0 10000010 00100000000000000000000
     printf("num的值为：%d\n",n);//n认为是有符号数的原反补
     printf("*pFloat的值为：%f\n",*pFloat);
     return 0;
}