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

一、整数在内存中的存储1.1、整数的存储方式1.2、大小端字节序（1）大小端字节序的定义（2）判断大小端

1.3、整型练习

二、浮点数在内存中的存储2.1、引言2.2、浮点数的存储规则2.3、浮点数的存储过程2.4、题目解析

一、整数在内存中的存储

1.1、整数的存储方式

我们知道，整形分为有符号整形和无符号整形。对于无符号整型来说，他<code>所有位均为数值位；而有符号整形，他的最高位代表符号位，其余位为数值位，符号位用0表示正，1表示负。

注：

c

h

a

r

char

char类型虽然是存储字符，但本质是存其ASCII值，因此也可以看作是整形。

注：有符号和无符号只针对整型，不包括浮点型等

在【C语言】——详原解操作符（上）中，我曾提到，整数在内存中的存储有三种方式：原码、反码、补码。下面，让我们简单回顾一下。

原码：直接将数值按他的正负数形式翻译成二进制得到的就是原码反码：源码的符号位不变，数值位按位取反即为反码补码：将反码加一，得到的就是补码

在内存中，整数的存储和运算都是以补码的形式，只有显示给用户时，才是原码的形式。

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。

原因在于：使用补码，可以将数值位和符号位统一进行处理

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

1.2、大小端字节序

（1）大小端字节序的定义

不知大家在平时调试代码时，大家有没有发现一个奇怪的现象：<code>整型在内存中好像是倒着存的。

如图：

上图显示的是整型变量

a

a

a 在内存中的存储情况，按我们的习惯不应该是：00 00 00 01 吗？为什么是 01 00 00 00 呢？

上面这种存储方式叫小端字节序存储

首先，我们来看看什么是大小端。

在内存中，数据是<code>以内存为单位进行存储的，那么，超过一个字节大小的数据的存储就不可避免的涉及到存储顺序问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储，下面是具体概念。

小端字节序存储：指数据的低位字节内容保存在内存中的低地址处，而数据的高字节内容保存在内存的高地址处。大端字节序存储：指数据的高位字节内容保存在内存的低地址处，而数据的低字节内容保存在内存的高地址处。

数据是大端还是小端存储并不由编译器决定，而是取决于硬件设备。

为什么会分大小端呢？

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8 个

b

i

t

bit

bit 位，但是在 C语言 中除了 8

b

i

t

bit

bit 的

c

h

a

r

char

char 之外，还有 16

b

i

t

bit

bit 的

s

h

o

r

t

short

short

类型，32

b

i

t

bit

bit 的

l

o

n

g

long

long 类型（要看具体的编译器），另外，对于位数大于 8 位的处理器，例如 16 位或者 32 位的处理器，由于寄存器宽度大于一个字节，那么就必然存在着如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。

例如：一个 16

b

i

t

bit

bit 的

s

h

o

r

t

short

short 类型

x

x

x ，在内存中的地址为

0

x

0010

0x0010

0x0010，

x

x

x 的值为

0

x

1122

0x1122

0x1122 ，那么

0

x

11

0x11

0x11 为高字节，

0

x

22

0x22

0x22 为低字节。对于大端模式，就将

0

x

11

0x11

0x11 放在低地址中，即

0

x

0010

0x0010

0x0010 中，

022

022

022 放在高地址中，即放在

0

x

0011

0x0011

0x0011 中。而小端模式，刚好相反。

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

（2）判断大小端

既然知道了计算机分为大端和小端存储，那有没有办法通过代码来判断自己的设备是大端还是小端呢？

我们不妨这样想，往一个整形中存放数据，再想办法只读取他第一个字节内容，根据该字节存储的内容来判断是大端还是小端。

int check_sys()

{

int i = 1;

return (*(char*)&i);

}

int main()

{

int ret = check_sys();

if (ret == 1)

{

printf("小端\n");

}

else

{

printf("大端\n");

}

return 0;

}

我们来分析return (*(char*)&i);这句代码：

我们取出变量

i

i

i 的地址，因为

c

h

a

r

char

char* 型指针只会访问一个字节的内容，所以将其强制类型转换成

c

h

a

r

char

char* 类型，再对其进行解引用。同时我们还知道：一个变量的地址，是其所有字节的地址中，地址最小的字节的地址。因此解引用得到的是

i

i

i 中最小字节地址所存储的内容，如果存储值为 1，则为小端存储，如果为 0，则为大端存储

当然，，我们还可以用联合体来判断

int check_sys()

{

union

{

int i;

char c;

}un;

un.i = 1;

return un.c;

}

关于联合体的知识，我们放到后面去讲

1.3、整型练习

练习一：

#include<stdio.h>

int main()

{

char a = -1;

signed char b = -1;

unsigned char c = -1;

printf("a=%d, b=%d, c=%d\n", a, b, c);

return 0;

}

首先我们来看char a = -1;：

c

h

a

r

char

char 类型是

（

s

i

g

n

e

d

）

c

h

a

r

（signed）char

（signed）char 还是

（

u

n

s

i

g

n

e

d

c

h

a

r

）

（unsigned char）

（unsignedchar） 取决于具体编译器的实现，但大部分是（signed）char。-1 的补码是 11111111 11111111 11111111 11111111（整数默认4个字节），因为

c

h

a

r

char

char 只有一个字节大小，发生截断，

a

a

a 中放的是 11111111。同理char b=-1中

b

b

b 中放的也是11111111。接下来，我们来看unsigned char c = -1;：

c

c

c 中存放的也是 11111111，虽然 -1 是负数，但是存还是照样存的（先把数据存进去再说）虽然

a

b

c

abc

abc 里存的都是 8 个 1 ，但以什么方式看待这 8 个 1 是不同的，对

a

b

ab

ab 来说，他们认为 8 个 1 是 -1，而对

c

c

c 来说，他认为 8 个 1 是 255。再来看最后一句，首先，我们要知道％d是以有符号整型来打印，打印

a

b

c

abc

abc 时，他们要先发生整形提升（详情请看【C语言】——详解操作符（下））。

对

a

b

ab

ab 来说他们是有符号类型，整形提升按他们的符号位进行提升，即 11111111 11111111 11111111 11111111，补码转为源码，打印的结果是 -1。

而对于

c

c

c 来说他是无符号类型，整形提升高位补 0，即 00000000 00000000 00000000 11111111，因为首位是 0，被认为是正数，正数的原反补码相同，结果为 255。

答案：-1、-1、255

练习二：

#include<stdio.h>

int main()

{

char a = -128;

char b = 128;

printf("a=%u, b=%u\n", a, b);

return 0;

}

我们先来看

a

a

a

首先，我们来看 -128 的原码 反码 补码

原码：10000000 00000000 00000000 10000000

反码：11111111 11111111 11111111 0111111

补码：11111111 11111111 11111111 10000000

a

a

a 存储时，发生截断，存后面 8 个

b

i

t

bit

bit 位，即 10000000％u是以无符号整型来打印数据，打印前，

a

a

a 先发生整形提升，因为

c

h

a

r

char

char 为有符号类型，整型提升按符号位提升，即 11111111 11111111 11111111 1000000，而％u认为他是无符号数，因此打印的是一个很大的数。同理，

b

b

b 也是类似的分析方法

答案：a=4294967168, b=4294967168

练习三：

#include<stdio.h>

#include<string.h>

int main()

{

char a[1000];

int i;

for (i = 0; i < 1000; i++)

{

a[i] = -1 - i;

}

printf("%d", strlen(a));

return 0;

}

让我们一起来分析这道题

数组

a

a

a 中存放的是

c

h

a

r

char

char类型 的数据，通过

f

o

r

for

for 循环，依次放入 -1，-2，-3 ······ 等数据，循环 1000 次。而因为

a

a

a 中元素是

c

h

a

r

char

char类型，范围是 -128至127，因此放入的数据会周期循环。而题目要求打印的是strlen(a)的值，我们知

s

t

r

l

e

n

strlen

strlen函数 是计算字符串的长度，遇到 ‘\0’ 停止计算，而 ‘\0’ 的本质是 0，因此这题的核心思路就是：计算第一次放入0，是第几个数放入，再减去一，即可知道前面翻入几个数，即字符串长度。

答案：255

练习四：

<code>#include<stdio.h>

int main()

{

unsigned char i = 0;

for (i = 0; i <= 255; i++)

{

printf("hello world\n");

}

return 0;

}

该代码会打印多少个

"

h

e

l

l

o

w

o

r

l

d

"

"hello world"

"helloworld" 呢？是

256

256

256 个吗？

答案是：死循环

因为

i

i

i 是

u

n

s

i

g

n

e

d

c

h

a

r

unsigned char

unsignedchar 类型，他的数据范围是 0-255，当值为 255 即 11111111 时，加 1 为 100000000，因为只能存 8 比特位，发生截断，即 00000000，再不断加一，如此往复，永远跳不出循环。

<code>#include<stdio.h>

int main()

{

unsigned int i;

for (i = 9; i >= 0; i--)

{

printf("%u\n", i);

}

return 0;

}

同理，这段代码也是如此，一样是死循环

练习五：

#include<stdio.h>

int main()

{

int a[4] = { 1,2,3,4 };

int* ptr1 = (int*)(&a + 1);

int* ptr2 = (int*)((int)a + 1);

printf("%x, %x", ptr1[-1], *ptr2);

return 0;

}

首先我们来看

p

t

r

1

ptr1

ptr1：&

a

a

a 取出的是整个数组的地址，+1 则是跳过了整个数组，之后将该地址强制类型转换成

i

n

t

int

int * 类型。％x 是以十六进制的方式打印数据，

p

t

r

1

[

−

1

]

ptr1[-1]

ptr1[−1] 等价于 *

（

p

t

r

−

1

）

（ptr -1）

（ptr−1），由于

p

t

r

1

ptr1

ptr1 是整型指针，-1 后退 4 个字节指向元素 4

图示：

接着我们来看

p

t

r

2

ptr2

ptr2，首先

a

a

a 是数组首元素的地址，取出后将其强制类型转换成整型变量，后面 +1，即数学上的+1，指针向后移动一位。再将该整数强制类型转换成整型指针，最后，以十六进制打印

p

t

r

2

ptr2

ptr2 解引用的值，因为强转成

i

n

t

int

int* 指针，所以访问权限为 4 个字节。

因为为小端存储，所以取出的数实际为 02 00 00 00

答案：4 2000000

二、浮点数在内存中的存储

2.1、引言

像 3.14159、1E10 等数被称为浮点数。

首先我来问问大家，浮点数为什么叫浮点数呢？

我们来看个例子：

123.45

123.45

123.45 =

12.345

∗

1

0

1

12.345*10^1

12.345∗101 =

1.2345

∗

1

0

2

1.2345 * 10^2

1.2345∗102

可以看到，该数的小数点是可以左右浮动的，因此被称为浮点数。

浮点数家族包括

f

l

o

a

t

float

float、

d

o

u

b

l

e

double

double、

l

o

n

g

d

o

u

b

l

e

long double

longdouble 等类型，浮点数的表示范围，在 <code><float.h>中定义

接下来，让我们看一道习题，开启接下来的浮点数学习之旅。

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

}

输出结果：

为什么会这样呢？按我们之前的知识，四个答案应该是：9、9.0、9、9.0 。但现在，只有两个正确，为什么呢？

我们先粗略分析一下原因

我们以整型形式放，以浮点型形式取出，有问题我们以浮点型的形式放，以整型的形式取出，也有问题

我们不妨做一个大胆的猜测：<code>整型和浮点型在内存中的存储有很大差异。

那到底是不是这样呢？我们一起来学习浮点型在内存中的存储。

2.2、浮点数的存储规则

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

举例来说：

十进制的

5.0

5.0

5.0，用二进制表示是

101.0

101.0

101.0，可写成

1.01

∗

2

2

1.01*2^2

1.01∗22。 那么，按上面 V 的形式，他的 S=0、 M=1.01、 E=2

十进制的

−

5.0

-5.0

−5.0，用二进制表示是

−

101.0

-101.0

−101.0，可写成

−

1.01

∗

2

2

-1.01*2^2

−1.01∗22 那么，按上面 V 的形式，它的 S=1、 M=1.01、 E=2

IEEE 754 规定：

对于 32 位（

f

l

o

a

t

float

float） 的浮点数，<code>最高的一位存储的是符号位 S，接着 8 位存储指数位 E，剩下的 23 位存储有效数字 M

而对于 64 位（

d

o

u

b

l

e

double

double） 的浮点数，<code>最高的一位存储的是符号位S，接着11位存储指数位E，剩下的52位存储有效数字M

2.3、浮点数的存储过程

IEEE 754 对有效 数字 M 和 指数 E 还有一些特别规定

我们前面说过，M 的取值

1

<

=

M

<

2

1<=M<2

1<=M<2 ，也就是写成

1.

x

x

x

x

x

1.xxxxx

1.xxxxx 的形式，其中 xxxxx 是小数部分。IEEE 754 中规定，计算机那边存储 M 时，默认这个数的第一位总是 1 ，因此<code>1可以被舍去，只保留后面的小数部分，比如保存 1.01 时，只存储 01。等到读取的时候，再把第一位的 1 加上去。这样做的目的是可以节省一位有效数字的空间

至于指数E，则更为复杂一些：

首先，规定 E 是一个无符号整数。这样，如果 E 为 8 位，他的存储范围是 0～255 ，如果 E 为 11 位，他的存储范围则是 0～2047。但是，我们知道，指数位是可以有负数的，所以 IEEE 754 规定，存入内存时 E 的真实值必须再加上一个中间值，对于 8位 的 E，这个中间值是 127 ，对 11位 的E这个中间值是 1023。比如：

2

10

2^{10}

210 ，他的 E 为 10，所以存储为 32 位浮点数时，必须保存成 10+127=137，即 10001001。

指数E从内存中取出还可以再分成三种情况

E不全为 0 或不全为 1

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

比如：0.5 的二进制形式为 0.1，由于规定整数部分必须为 1，即小数点右移1位，为

1.0

∗

2

−

1

1.0*2^{-1}

1.0∗2−1 ，其阶码(E) 为 -1+127(中间值) = 126，表示为 01111110，而尾数 1.0去掉整数部分为 0，补齐 0 到 23 位

0 01111110 00000000000000000000000

E全为0

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

0 00000000 00100000000000000000000

E全为1

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

0 11111111 00010000000000000000000

2.4、题目解析

现在，让我们回到一开始的题目

先来看第一个环节：

int n = 9;：我们以整型的形式存储 9，此时9在内存中表示为：

00000000 00000000 00000000 00001001printf("n的值为：%d\n", n);：这句代码以整型的形式打印，打印出 9，没有问题printf("*pFloat的值为：%f\n", *pFloat);：这句代码以浮点型的形式打印在 *

p

F

l

o

a

t

pFloat

pFloat 眼里，它指向的数据是这样的：

0 00000000 00000000000000000001001

即S = 0， E = 0， M = 1001

由于指数为 0 符合 E 为全 0 的情况。因此浮点数 V 写成：

V =

(

−

1

)

0

(-1)^0

(−1)0

∗

*

∗ 0.00000000000000000001001

∗

*

∗

2

−

126

2^{-126}

2−126 = 1.001

∗

*

∗

2

−

146

2^{-146}

2−146显然，V是一个很小且非常接近 0 的数，用十进制小数表示就是 0.000000

再看第二个环节：

放进浮点数 9.0

首先 9.0 用二进制表示 1001.0，换算成科学技术法是：

1.001

∗

2

−

3

1.001 * 2^{-3}

1.001∗2−3。所以

9.0

9.0

9.0 =

(

−

1

)

0

∗

(

1.001

)

∗

2

3

(-1)^0 * (1.001)*2^3

(−1)0∗(1.001)∗23即S = 0，E = 3 + 127 = 130，M = 001 后面补 20 个 0

9.0

9.0

9.0 在内存中的存储为：

0 10000010 00100000000000000000000这个 32 位数。以整数的形式取出，就是整数在内存中的补码，因为为正数，原反补三码相同，十进制表示，正是1091567616

---

好啦，本期关于数据在内存中的存储就介绍到这里啦，希望本期博客能对你有所帮助。同时，如果有错误的地方请多多指正，让我们在C语言的学习路上一起进步！