数据在内存中的存储
数据类型
C基本的内置类型：
char //字符型数据类型（1）
short //短整型 （2）
int //整型 （4）
long //长整型 （4）
long long //更长的整型 （8）
float //单精度浮点数 （4）
double //双精度浮点数 （8）
后面的括号中的数值表示该类型定义出来的变量在存储空间中所占的字节数（32位windows平台下）
类型的意义：
1、使用这个类型开辟内存空间的大小（大小决定了适用范围）
2、如何看待内存视角
类型的基本归类
整型：
char
---- unsigned char
---- signed char
short
---- unsigned short
---- signed short
int
---- unsigned int
---- signed int
long
---- unsigned long
---- signed long
浮点数：
float
double
构造类型
数组类型
结构体类型 struct
枚举类型 enum
联合类型 union
指针类型
int *pi;
char *pc;
float *pf;
void *pv;
空类型
void表示空类型（无类型）
通常应用于函数的返回类型、函数的参数、指针类型
注意：
1、void不能直接定义变量，但void * 可以直接定义变量，在32位平台下它定义的变量占4个字节
2、void * 可以接受任意类型（通常用来接收任意指针类型）
整型在内存中的存储
此前，我们知道，变量的创建需要在内存中开辟空间，空间的大小由不同的类型决定。
接下来我们谈谈数据在 多开辟内存中是如何存储的相关问题！
1、先简单回顾一下原反补码的问题：
计算机中有符号数有三种表示方法：原码，反码，补码
三种方法均有符号位和数值位两部分，符号位用'0’表示“正”，'1’表示“负”，而数值位三种表示方法各不相同
原码： 直接将二进制按照正负数的形式翻译成二进制
反码：原码的符号位不变，其他位按位取反
补码：反码+1
——————————————
注意：
正数的原反补码都相同
对于整型来说，数据在内存中是以补码的形式存储的
为什么呢？
在计算机系统中，数据一律以补码来表示和存储。使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理（CPU只有加法器）。此外，补码和原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
2、大小端问题
大端（存储）模式：数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中
小端（存储）模式：数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中
为什么会有大小端之分？
这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
关于大小端具体的理解和分析，请参考详解大端模式和小端模式【转】
【题】设计一个程序来判断当前机器的字节序
#include<stdio.h> #include<Windows.h> /* 原理： 令整型变量中存储的数据为1，其十六进制序列为：00 00 00 01（32位平台16进制） 设法将其四字节中的最低字节中存储的数据得到，看是00还是01（十六进制），即是0还是1（十进制） */ //方法1： int check_sys() { int i = 1; return (*(char *)&i); //对int类型的变量强制类型转换为char *类型，取原变量空间中的最低字节，观察是0还是1 } int main() { int ret = check_sys(); if (ret == 1){ printf('小端\n'); } else{ printf('大端\n'); } system('pause'); return 0; } /* //方法2： int check_sys() { union{ //联合体，其内部所有成员大小共用空间，开辟的空间至少是内部成员中字节数最大的 int i; char c; }un; un.i = 1; return un.c; //内部成员共用空间，即共用空间中其他成员的数据（在自己寻址范围之内） } */
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
【题】求下面各程序的输出
1、
#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;
}
1234567891011
1234567891011
解题步骤：
1)、先看-1的二进制形式
2)、存储数据时，需要看数据自身，a,b,c由于是用char类型定义的变量，所以开辟出的变量空间大小是一个字节，在存储的过程中势必会发生截断，取32位二进制码中的最低的8位进行存储，所以a,b,c中存储的内容都是1111 1111
3)、在读取数据的时候，先看变量自身的类型，a和b都是有符号char类型(1个字节)，c是无符号char类型(1个字节)，且要求以%d的格式输出，即以有符号整形的十进制输出(4个字节)，所以会发生整形提升：
负数发生整形提升时，高位补符号位1
正数发生整形提升时，高位补符号位0
无符号数发生整形提升时，高位补0
4)、发生整形后，a和b中存储的内容为32个1：1111 1111 1111 1111 1111 1111 1111 1111
c中存储的内容为：0000 0000 0000 0000 0000 0000 1111 1111
5)、计算机中以补码形式存储，将其以源码形式输出后，a和b都为-1，c为255
2、
#include<stdio.h> int main() { char a = -128; char b = 128; printf('%u\n', a); printf('%u\n', b); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
解题步骤：
1)、-128的二进制表示 ：
128的二进制表示：
2)、存储数据时，取最低的八位存入变量空间中，即a和b中存储的内容都是 1000 0000
3)、读取数据时，先看变量自身的类型为有符号char类型(1字节)，且要求以%u输出，即以无符号整形十进制输出(4字节)，故发生整形提升，将char变量空间中的最高位看作符号位，在a和b前面同时补充符号位1
4)、所以a整形提升后的内容为1111 1111 1111 1111 1111 1111 1000 0000
b整形提升后的内容为1111 1111 1111 1111 1111 1111 1000 0000
5)、在输出时，%u是以无符号整型输出，所以，系统默认a和b中的数据为无符号类型，补码与原码相等，所以最后的结果就是a和b中的内容的十进制都是4294967168
3、
int i = -20;
unsigned int j = 10;
printf('%d\n', i + j);
//按照补码的形式进行运算，最后格式化成为有符号整数
1234
1234
解题步骤：
4、
unsigned int i; for(i = 9; i >= 0; i--){ printf('%u\n', i); }- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
解题思路：
注意：定义变量i为无符号整数类型，同时以%u无符号整数类型输出
前十个输出结果如猜想中的一样，从10到1倒序输出，执行 i-- 之后 i = -1 ，从题一中的 i 的补码可知，i 在计算机中存储的补码为32个1（32位平台下），而在输出时，以无符号类型输出，系统默认将最高位的符号位看做数值位，此时 i 为全1的二进制所表示的十进制数，即32位所能表示的最大数，接下来，从该数开始倒序逐个输出，直到为0，然后又i–成为该最大数，继续循环输出…如此，程序完美的陷入了死循环之中…
输出结果如下：
5、
#include<stdio.h>
int main()
{
char a[1000];
int i;
for (i = 0; i < 1000; i++){
a[i] = -1 - i;
}
printf('%d\n', strlen(a));
return 0;
}
12345678910111213
12345678910111213
解题：
既然已经熟悉了数据的读取和调用时候的变化形式，那么此处不再赘述，结果为255，附上解题过程
-1 - 0 = -1 -1 - 1 = -2 -1 - 2 = -3 ... -1 - 127 = -128 //此后需要注意数组为有符号char类型，变量空间大小为 一个字节8位，会发生截断，且有符号数，即将8位中的最高位的数值位作为符号位 -1 - 128 = -129 = 127 -1 - 129 = -130 = 126 -1 - 130 = -131 = 125 ... -1 - 254 = -255 = 1 -1 - 255 = -256 = 0 // 0 = '\0' strlen()函数遇到'\0'就会停止，所以此处为输出的数组大小，其实，在for循环中给数组开辟的整个空间中都进行过了赋值 -1 - 256 = -257 = -127 -1 - 257 = -258 = -126 ... ... -1 - 999 = -1000 = 24- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
6、
#include<stdio.h>
unsigned char i = 0;
int main()
{
for (i = 0; i <= 255; i++){
printf('hello world%d\n',i);
Sleep(100);
}
return 0;
}
123456789101112
123456789101112
解题：
无符号char类型一个字节8个bit，取值范围为0-255，所以当 i = 255 时，i++ 执行后 i 会发生溢出，舍弃最高位，又从0开始循环，所以显而易见，这道题运行结果会陷入死循环，由0-255的死循环
浮点型在内存中的存储
浮点数家族包括：float, double, long double类型
根据国际标准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 X 2^2 ，那么，按照上述V的格式，可以得出S=0，M=1.01,E=2
十进制的-5.0，写成二进制是-101.0，相当于 -1.01 X 2^2，那么，S=1,M=1.01,E=2
浮点数的存储本质上是对S,M,E的存储
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为一个无符号整数，这意味着，如果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，表示±无穷大（正负取决于符号位）；
以上，就是关于浮点数的表示规则
题：求输出结果
#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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
先看结果截图：
关于此题疑问有两点：
1、为什么0x00000009还原成浮点数，就成了0.000000？首先，将0x00000009拆分，得到第一位符号位S=0，后面的8位指数位E=00000000，最后的23位有效数字位M=0000000000000000000000/*00 0000 0000 0000 0000 1001
由于指数E全为0，所以符合上述E的三种情况中的第二种，因此，浮点数V就写成;
V=（-1）^ 0 x 0.00000000000000000001001 x 2 ^ (-126) = 1.001 x 2 ^ (-146)
显然，V是一个很小的接近0的正数，所以用十进制小数表示就是0.000000
2、 浮点数9.0，如何用二进制表示？还原成十进制又是多少？
首先，浮点数9.0等于二进制的1001.0，即1.001 x 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.所以，写成二进制形式，应该是S+E=M，即
0 10000010 001 0000 0000 0000 0000 0000 0000
这个32位的二进制数，还原成十进制，正是1091567616