C语言——数据在内存中的存储-阿里云开发者社区

目录·：

我们在这篇博文（第二节第1个内容：关键字详解）已经介绍了数据类型，为了更加深刻去理解数据类型，我写了这篇博客。相信大家看完这篇文章，肯定会对数据有更深层次的理解。

一、数据类型分类

1.1 整型家族（可声明头文件limits.h查看表示范围）：

char（字符型，字符存储的时候是ASCII码值，是整型，所以归类的时候放在整型家族里）：

unsigned char（无符号字符型）

signed char（有符号字符型）

short（短整型）：

unsigned short [int]

signed short [int]

int（整型）:

unsigned intt

signed int

long（长整型）：

unsigned long [int]

signed long [int]

1.2 浮点型家族（可声明头文件float.h查看表示范围）：

float（单精度浮点数）

double（双精度浮点数）

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

数组类型：

int arr1[10]它的数组类型是 int [10]

结构体类型

枚举类型

联合类型

1.4 指针类型：

int* p

char* p1

float* p2

void* p3

1.5 空类型：

void表示空类型（无类型）

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

二、整型在内存中的存储

一个变量的创建是要在内存中开辟空间的，空间的大小是根据不同类型而决定的。

2.1 原码、反码、补码

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

三种表示方法都有符号位和数值位两部分，符号位为‘0’表示真，符号位为‘1’表示假，且数值为正数时，原、反、补码都相同。

数值为负数时三种表示方法各不相同：

原码

直接将数值按照正负数的形式转换为二进制，就可以得到原码。

反码

将原码的符号位不变，其它位依次按位取反可得到反码。

补码

在反码的基础上+1，就可以得到补码

对于整型来说：数据在内存中存放的是二进制补码

图示:

扩展：为什么数值用补码的形式进行存储？

因为在计算机系统中，使用补码，可以使符号位和数值位统一处理；同时，加法和减法也可以统一处理（cpu只有加法器）；此外，补码和原码可以相互转换，其运算过程是相同的，不需要额外的硬件电路。（本质上存储的是二进制，但在vs上为了更好的展示，显示的是十六进制）

2.2 大小端介绍

什么是大小端：

1）字节序—以字节为单位，确定存储顺序。

2）

小端字节序存储：把一个数据的低字节的内容，存放在低地址处，高字节的内容，存放到高地址处。

大端字节序存储：把一个数据的低字节的内容，存放到高地址处，高字节的内容，存放到低地址处。

如图：

为什么有大小端之分？

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

例如:一个16bit的short型x，在内存中的地址为0x0010，x 的值为0x1122，那么0x11为高字节，0x22 为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22 放在高地址中，即0x0011中。小端模式，刚好相反。

小端模式：我们常用的x86结构是小端模式；ARM，DSP也是小端模式。

大端模式：KEIL 、C51，有些ARM处理器还可以由硬件来选择是大端模式。

如何判断当前机器的字节序：

思路：先取一个整数变量的地址，然后强制类型转换为char*，在解引用，就可以取出内存中低地址的内容。然后判断大小端。

#include<stdio.h>
int diagnose()
{
    int m = 1;
    return *(char*)&m;//不管是大端还是小端，强制类型转换都是低地址内容
}
int main()
{
    int n = diagnose();
    if (n == 1)
        printf("小端字节序\n");
    else
        printf("大端字节序\n");
    return 0;
}

案例1：

//输出什么?
#include <stdio.h>
int main()
{
    char a = -1;
    //10000000 00000000 00000000 00000001原码
    //11111111 11111111 11111111 11111110反码
    //11111111 11111111 11111111 11111111补码
    //11111111 截断
    signed char b = -1;
    //10000000 00000000 00000000 00000001原码
   //11111111 11111111 11111111 11111110反码
   //11111111 11111111 11111111 11111111补码
   //11111111 截断
    unsigned char c = -1;
    //10000000 00000000 00000000 00000001原码
   //11111111 11111111 11111111 11111110反码
   //11111111 11111111 11111111 11111111补码
   //11111111 截断
    printf("a=%d,b=%d,c=%d\n", a, b, c);//打印a=-1,b=-1,c=255
    //因为要输出，a，b，c；
    //按原类型的符号位整型提升
    //a:11111111 11111111 11111111 11111111补码
    //10000000 00000000 00000000 00000001原码
    //b:11111111 11111111 11111111 11111111补码
    //10000000 00000000 00000000 00000001原码
    //c:00000000 00000000 00000000 11111111补码
    return 0;
}

可以看出-1先以四个字节的二进制的形式表示，然后进行原、反、补转换，然后截断赋值给变量a，打印的时候，先按照原来的类型的符号位进行整型提升，然后根据打印的格式进行原、反、补转换。

测试：

案例2：

#include <stdio.h>
int main()
{
    char a = -128;
  //  10000000 00000000 00000000 10000000原码
    //11111111 11111111 11111111 01111111反码
    //11111111 11111111 11111111 10000000补码
    //10000000截断
    printf("%u\n", a);//打印结果4294967168
    //按原符号位整型提升：
    //11111111 11111111 11111111 10000000补码
    //无符号整数打印：
    //11111111 11111111 11111111 10000000补码
    //11111111 11111111 11111111 10000000原码
    return 0;
}

测试：

案例3：

#include <stdio.h>
int main()
{
    char a = 128;
    //  00000000 00000000 00000000 10000000原码
    //  00000000 00000000 00000000 10000000补码
      //10000000截断
    printf("%u\n", a);//打印结果4294967168
    //按原符号位整型提升：
    //11111111 11111111 11111111 10000000补码
    //无符号整数打印：
    //11111111 11111111 11111111 10000000补码
    //11111111 11111111 11111111 10000000原码
    return 0;
}

测试：

总结：不难看出在打印的时候，按照原类型的符号进行整型提升，然后根据打印的格式进行打印

案例4：

#include <stdio.h>
int main()
{
    int i = -20;
    //10000000 00000000 00000000 00010100原码
    //11111111 11111111 11111111 11101011反码
    //11111111 11111111 11111111 11101100补码
    unsigned int j = 10;
    //00000000 00000000 00000000 00001010原码
    //00000000 00000000 00000000 00001010补码
    printf("%d\n", i + j);//按照补码的形式进行运算，最后格式化成为有符号整数，打印-10
    //11111111 11111111 11111111 11101100补码i
    //00000000 00000000 00000000 00001010补码j
    //11111111 11111111 11111111 11110110i+j补码
    //11111111 11111111 11111111 11110101反码
    //10000000 00000000 00000000 00001010原码
    return 0;
}

测试：

案例5：

#include <stdio.h>
#include <string.h>
int main()
{
    char a[1000];
    int i = 0;
    for (i = 0; i < 1000; i++)
    {
        a[i] = -1 - i;
    }
    /*/*i为0,1,2,3,4，5，……，9999时
    a[i]的值为-1，-2，-3，-4.…，-127，-128,127,126，……，1,0,-1，-2，直到放进去1000组数值
    */
    printf("%d\n", strlen(a));//strlen计算字符串长度，遇到‘\0’结束，不加'\0',所以打印255
    return 0;
}

测试：

三、浮点型在内存中的存储

3.1 浮点数

常见的浮点数：

3.1415

1E10

浮点数家族包括：

float、double、long double

如：

1234.56

可以写成1.23456*10^3

小数点可以浮动，所以叫浮点数

整数的数值在内存中存进去之后，以整型形式和浮点型形式从内存中取出的结果不一样

整型的存，那么就整型的取

浮点型的存，那么就浮点型的取

3.2 浮点数的存储规则

3.2.1 详细解读

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

（-1）^S * M *2^E

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

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

2^E表示指数位

如：

浮点数5.5

V=5.5

二进制形式;101.1

科学计数法：（-1）^0 *1.011 *2 ^2

S=0;M=1.011;E=2

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

65位的浮点数，最高的1位是符号位S，接着的11位是指数位E，剩下的是有效位M。

3.2.2 浮点数的存取（IEEE 754规定）

以32位浮点数为例：

1）有效数字M

1≤M<2，也就是说，M可以写成1. xxxxx的形式，其中xxxxx表示小数部分。在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。等到读取的时候，再把第一位的1加上去。这样做的目的，可以节省1位有效数字。留给M的有23个有效位，将第一位舍去，就可以保存24位有效位

2）指数位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从内存中取出还可以再分成三种情况：

不全为0或不全为1

这时，浮点数就采用下面的规则表示，即指数E的计算值减去127(或1023)，得到真实值，有效数字M加1.

E全为0

这时，浮点数的指数E等于1-127 (或者1-1023) 即为真实值，

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

E全为1

这时，有效数字M全为1，表示-无穷大和+无穷大（正负取决于符号位S）。

剖析案例

#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("n的值：%d\n", n);
    printf("&pfloat的值：%f\n", *pfloat);
    return 0;
}

打印的结果：

分析：

#include <stdio.h>
int main()
{
int n = 9;
//00000000 00000000 00000000 00001001补码
float * pfloat = (float*)&n;
printf(“n的值为：%d\n”, n);
printf(" * pfloat的值为：%f\n", * pfloat);
//S=0,E=00000000,M=00000000000000000001001
// 科学计数法表示
//因为指数E全为0，所以浮点数V就写成：
// （-1） ^0 * 0.00000000 00000000 0001001 * 2 ^( -126)=1.001*2^(-146)无限趋于0的一个数字
*pfloat = 9.0;
//9.0转化为二进制：1001.0，转换为科学计数法形式：（-1） ^ 0 * 1.001 * 2 ^ 3
//其中S=0,M=1.001,E=3
//存入到内存：0 10000010 00100000000000000000000
printf(“n的值：%d\n”, n);
//01000001 00010000 00000000 00000000打印的时候是个非常大的数字
printf(“&pfloat的值：%f\n”, *pfloat);
return 0;
}

C语言——数据在内存中的存储

目录·：

一、数据类型分类

1.1 整型家族（可声明头文件limits.h查看表示范围）：

1.2 浮点型家族（可声明头文件float.h查看表示范围）：

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

1.4 指针类型：

1.5 空类型：

二、整型在内存中的存储

2.1 原码、反码、补码

2.2 大小端介绍

三、浮点型在内存中的存储

3.1 浮点数

3.2 浮点数的存储规则

3.2.1 详细解读

3.2.2 浮点数的存取（IEEE 754规定）

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C语言——数据在内存中的存储

目录·：

一、数据类型分类

1.1 整型家族（可声明头文件limits.h查看表示范围）：

1.2 浮点型家族（可声明头文件float.h查看表示范围）：

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

1.4 指针类型：

1.5 空类型：

二、整型在内存中的存储

2.1 原码、反码、补码

2.2 大小端介绍

三、浮点型在内存中的存储

3.1 浮点数

3.2 浮点数的存储规则

3.2.1 详细解读

3.2.2 浮点数的存取（IEEE 754规定）

热门文章

最新文章

相关课程

相关电子书