C语言进阶(1)-深度剖析数据在内存中的存储

前言：数据在计算机中的存储

CPU -  Central Processing Unit

数据在计算机中的存储位置不同，但大致可以分为以下几个空间。

今天讲解的是数据在内存中的存储，而数据在内存中的存储可以分为三个部分，如下：

今天的重点讲解在栈区中的存放。

1024	512	256	128	64	32	16	8	4	2	1
2^10	2^9	2^8	2^7	2^6	2^5	2^4	2^3	2^2	2^1	2^0

1.数据类型的介绍

我们已经学过C语言的基本内置数据类型，这些数据类型给都是C语言规定好的，具有不可改动性。

char            //字符数据类型        1byte

short          //短整型                   2byte

int              //整形                       4byte

long            //长整型                   4byte

long long   //更长的整形            8byte

float            //单精度浮点数        4byte

double        //双精度浮点数        8byte

long double

//C 语言有没有字符串类型？

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

注意：C语言规定：sizeof(long) >= sizeof(int);

类型的意义：

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

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

//C99中引入了布尔类型

//专门用来判断真假的

#include<stdio.h>
#include<stdbool.h>
int main()
{
	_Bool flag = true;//false
	if (flag)
	{
		printf("hehe\n");
	}
	return 0;
}

1.1 类型的基本归类：

整型家族：

char        （字符在内存中的存储是以其ASCll码值存放的，所以归类为整形）

                unsigned char      //无符号整形(中没有负数) - 8bit  (0~255)

                signed char          //有符号整形  - 8bit  (-128~127)

short

                unsigned short [ int ]

                signed short [ int ]   //16bit  (-32768 ~ 32767)

int

                unsigned int

                signed int              //32bit  (-2147483647-1 ~ 2147483647)

long

                unsigned long [ int ]

                signed long [ int ]

int     ->    signed int   (等价于)

short ->    signed short

long  ->    signed long

char 到底是signed char 还是unsigned char 是取决于编译器的实现的。

常见的编译器下，char就是signed char.

浮点数家族：

float

double         //对精度要求高

构造类型：(构造类型也叫自定义类型)(需要人为的创建，初始化)

> 数组类型

> 结构体类型   struct

> 枚举类型   enum

> 联合类型   union

指针类型

char*  pc ;  short* ci;

int * pi ;      long* d;

float* pf ;   double* di;

void* pv ;

空类型：

void 表示空类型（无类型）

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

(可以理解为void 类型的存在使我们的代码更加规范)

比如：在函数传参时我们不需要传递参数，添加一个void就代表了不需要传参。

补充：在整形数据中我们不仅要了解其分类，还需要了解每个数据类型对应的数据范围(<limits.t>头文件可以查看)，以下深入了解char类型的无有符号数对应的范围：

signed char  有符号，代表有正负，其补码首位是符号位，其它位是数值位。

1byte - 8bit  范围：-128 ~ 127

00000000   =   0

00000001   =   1 

00000010   =   2  

00000011   =   3

................

0111 1111   =   2^7-1  = 127

10000000   =  128

10000001   =  -127

...............

1111 1110   =  -2

1111 1111   = -1

................

.

1000 0001 -> 原码 1111 1111 -> -127

1000 0000 -> 此值不能按照补码-反码-原码的方式来计算，直接解析为-128.

1000 0000 规定为-128；

unsigned char   无符号，所有位都是数值位

1byte - 8bit   范围： 0~255

00000000   =   0

00000001   =   1

00000010   =   2

00000011   =   3

................

0111 1111   =   127

10000000   =   128

10000001   =   129

...............

11111110    =    254

11111111    =    255

.

补充：对于char类型的变量来说，C语言中没有明确的规定单独一个char是有符号的还是无符号类型的，不同的编译器有不同的情况，在VS默认是signed char.

如图表示：

2.整形在内存中的存储

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

那接下来谈谈数据再所开辟内存中到底是如何存储的？

比如：

int a = 20;

int b = -10;

我们知道为 a 分配四个字节的空间。

那如何存储？

下来了解下面的概念：

2.1 整形数据在内存中的存储： 原码、反码、补码

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

三种表示方法均有 符号位 和 数值位 两部分，符号位都是用 0 表示 “ 正 ” ，用 1 表示 “ 负 ” ，而数值位

负整数的三种表示方法各不相同。

原码

直接将二进制按照正负数的形式翻译成二进制就可以。

反码

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

补码

反码+1就得到补码。

正数的原、反、补码都相同。

对于整形来说：数据存放内存中其实存放的是补码。

举例说明：一个负数的原反补码，在内存中把补码打印出来。

原码：一个数对应的二进制序列  如：-15

>10000000 00000000 00000000 00000111

反码：原码除符号位外其他位按位取反，如：-15的反码：

>11111111 11111111 11111111 11111000

补码：反码+1=补码  如：-15的补码:

>11111111 11111111 11111111 11111001

举例：

//获取一个整数的二进制序列
#include<stdio.h>
int main()
{
	int a = -15;
	unsigned int com = 1 << 31;
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		if (a & com)
			printf("1");
		else
			printf("0");
		com = com >> 1;
	}
	return 0;
}

结果如图所示： 

为什么要这样存储呢？

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

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

我们看看在内存中的存储：

 我们看到对于a和b分别存储的是补码。但是我们发现顺序有点不对劲。

这是什么原因呢？

2.2 大小端介绍

什么大端小端：

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

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

如图所示：

为什么有大端和小端：

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

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

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

例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为 高字节， 0x22 为低字节。

对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。

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

百度2015年系统工程师笔试题：

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

//代码1

#include<stdio.h>
int main()
{
	int a = 1;
	char* p = (char*)&a; //int*
	if (1 == *p)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

//代码2（使用函数）

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

原理都是一样的，只是写法不同，便于理解。

2.3 练习

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 ;

}

输出：a=-1,b=-1,c=255

解析：

-1

10000000 00000000 00000000 00000001  -  原码

11111111   11111111   11111111   11111110   -  反码

11111111   11111111   11111111   11111111   -   补码

a -> 11111111  （%d : 整形提升）

11111111 11111111 11111111 11111111  -  补码

11111111 11111111 11111111 11111110  -  反码

10000000 00000000 00000000 00000001 - 原码

b -> 11111111  （%d : 整形提升）

a 和 b 是一样的，结果为-1.

c -> 11111111  (%d : 整型提升)

00000000 00000000 00000000 11111111

c = 255

总结：关于什么时候使用截断思想

如果所给的数值在它的数据类型的数据范围之内，可直接写出对应的二进制序列；

如果所给的数值不在我的数据类型的数据范围之内，比如c中，-1并不在unsigned char的数据范围之内，这是可以先将他的补码求出，再利用截断思想。

同时，要了解整形提升以及整形提升的规则。

下面程序输出什么？

2.

#include <stdio.h>

int main ()

{

         char a = - 128 ;

//先想-128是否属于char类型的数据范围之内(-128~127)，属于

//直接写出二进制序列：1000 0000

//整型提升：11111111 11111111 11111111 10000000

//%u:是以无符号整形输出，数据范围是恒>=0,所以其原码=反码=补码。

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

         return 0 ;

}

//输出： 4294967168

3.

#include <stdio.h>

int main ()

{

        char a = 128 ;

//128不属于char类型的数据范围之内(-128~127)

//先写补码，再利用截断

//00000000 00000000 00000000 10000000

//截断：1000 0000 (和练习2中的a存储的数据相同，故答案相同)

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

         return 0 ;

}

//输出： 4294967168

4.

#include<stdio.h>

int main()

{

        int i  = - 20 ;

//10000000 00000000 00000000 00010100

//11111111   11111111   11111111   11101011

//11111111   11111111   11111111   11101100 -> -20的补码

        unsigned   int   j = 10 ;

//00000000 00000000 00000000 00001010-> 10的补码

//相加：

//11111111 11111111 11111111 11110110 - 补码

//11111111 11111111 11111111 11110101 - 反码

//10000000 00000000 00000000 00001010 - 原码

        printf ( "%d\n" , i + j );

}

// 按照补码的形式进行运算，最后格式化成为有符号整数

//输出结果为：-10

5.

#include<stdio.h>
#include<windows.h>
int main()
{
       unsigned int i;
       for (i = 9; i >= 0; i--)
       {
           printf("%u\n", i);
           Sleep(1000);
       }
       return 0;
}

//i=0 之后进行i--的操作，i= -1

//但是i是unsigned int 类型的，并不包括负数，所以要先写补码，在截断

//10000000 00000000 00000000 00000001

//11111111   11111111   11111111   11111110

//11111111   11111111   11111111   11111111 -> i 中存储的数据(注意首位并不是符号位，而是数值位)

//最后会出现死循环

i 是无符号数，不可能为负数，所以一直在循环。

//9 8 7 6 5 4 3 2 1 0  4294967295 4294967294

6.

int main ()

{

         char a [ 1000 ];

         int i ;

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

       {

             a [ i ] = - 1 - i ;

       }

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

        return 0 ;

}

//输出255

//char 的数据范围：-128~127

//-128 : 10000000 00000000 00000000 10000000

//-129 : 10000000 00000000 00000000 10000001

但char类型只占一个字节，所以发生截断

//-129 ：11111111 11111111 11111111 01111110 - 反

              11111111 11111111 11111111 01111111 - 补

截断：01111111 -> a[i] 中存储的数据是127

所以，在经过-128之后，a[i] 中的数据符合上面所讲的char 类型数据的范围，

-1, -2, -3, ....... ,-128, 127, 126, ......., 1, 0

而strlen求解的是字符串中\0之前的字符个数，\0的ASCLL码值为0.

所以有效长度为128+127=255；

7.

#include <stdio.h>

unsigned char i = 0 ;

int main ()

{

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

      {

            printf ( "hello world\n" );

      }

       return 0 ;

}

//死循环

//unsigned char数据类型的数据范围：0~255

//i 的任何值都不会大于255，所以此代码会循环打印hello world。

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

常见的浮点数：

3.14159

1E10        --->    (1.0*10^10)

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

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

limits.h  ---   整型家族

float.h   ---   浮点数家族

3.1 一个例子

浮点数存储的例子：

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

输出结果为：

此例证明了整数和浮点型存储方式不一样。

（%f, %lf, 默认小数点后都有6位）

3.2 浮点数存储规则

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

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

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

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

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

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

2^E表示指数位。

举例来说：

十进制的 5.0 ，写成二进制是 101.0 ，相当于 1.01×2^2 。

那么，按照上面 V 的格式，可以得出 s=0 ， M=1.01 ， E=2 。

十进制的 -5.0 ，写成二进制是 - 101.0 ，相当于 - 1.01×2^2 。那么， s=1 ， M=1.01 ， 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）；

好了，关于浮点数的表示规则，就说到这里。

解释前面的题目：

下面，让我们回到一开始的问题：为什么 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

S=0, E=0, M=0.xxx1001

V = (-1)^0 * 0.00xx 1001 * 2^(-126) = 0.00 

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

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

显然， 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 。

0 10000010 001 0000 0000 0000 0000 0000

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

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

本章完。