文章目录
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
一：release版本会进行代码的优化
int main()
{
int i=0;
int arr[10]={1,2,3,4,5,6,7,8,9,10};
for(int i=0;i<12;i++)
{
arr[i]=0;
printf("hehe\n");
}
return 0;
}
/*
在debug版本下，打印的结果是：hehe的无限循环；
在release版本下，打印的结果是：12个hehe;
*/
debug:
在这个版本下，因为代码上来是先i 后arr
数组，所以先把I放在高地址处，之后再把ARR数组放在低地址处，又因为数组中的元素是从低地址到高地址排的，即如图：
数组越界的时候会影响到 i 。
release：
在这个版本下，先把I放在低地址处，之后再把ARR数组放在高地址处，
数组越界的时候不会影响到 i 。
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
二：类型的意义：
使用这个类型开辟内存空间的大小（大小决定了使用范围）。
如何看待内存空间的视角。
-> 都是4个字节的内存，但是int类型的只能存放整形，float类型的只能存放单精度 浮点型。
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
三：类型的基本归类
| 整形家族： | char（1） short（2） int（4） long（4/8） longlong（8） |
|---|---|
| 浮点数家族： | float（4） double（8） |
| 构造类型： | struct， 数组 ， 枚举（enum）， 联合类型 union |
| 指针类型 | int* float* char* |
| 空类型： | 通常应用于函数的返回类型、函数的参数、指针类型。 |
整形家族
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
四：整形在内存中的存储
计算机中的整数有三种表示方法，即原码、反码和补码。
三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，
负整数的三种表示方法各不相同，正数的原、反、补码都相同。对于整形来说：数据存放内存中其实存放的是补码
为什么呢？*
*在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
如图：先是1+（-1）的原码进行计算是错误的，之后用补码进行计算是正确的
补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路–>>
原码转化为补码：原码先符号位不变，数值位按位取反，然后再加1；
补码转化为原码：补码先符号位不变，数值位按位取反，然后再加1；
数值有不同的表示形式：二进制，八进制，十进制，十六进制，同时整形的数值的二进制又有三种表示形式：原码，反码，补码
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
五：大小端介绍
我们可以看到对于a和b分别存储的是补码。但是我们发现顺序有点不对劲。这是又为什么？
什么大端小端：
大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址 中；
小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地 址中。
为什么有大端和小端：
为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元
都对应着一个字节，一个字节为8bit。但是在C语言中除了8 bit的char之外(char 类型占1个字节，没有大小端之分)，还有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处理器还可以由硬件来选择是大端模式还是小端模式。
内存的存储单位是字节，一个数据要以字节为单位进行存储，比如说一个数据大小是4个字节，即32bit，那么他就要被存储到4个字节的内存单元中。但存储是有顺序的，其实按什么顺序都可以，只要遵循按什么顺序存的，取得时候就按什么顺序取即可，（即存进去的内容==取出来的内容），为了方便起见，我们采用大端字节序存储和小端字节序存储。
| 0x 11 22 33 44 | |
|---|---|
| 0b 00010001 00100010 00110011 01000100 | |
| 1个字节 1个字节 1个字节 1个字节 | |
| 高位 --------------------------------------------->>>>>> 低位 |
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
六：整形在内存中存储练习题：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
练习1：
///1：设计一个小程序来判断当前机器的字节序。
/*
1：00000000 00000000 00000000 00000001
0x: 00 00 00 01（大）
低地址 高地址
01 00 00 00 （小）
*/
#include <stdio.h>;
void func()
{
int a = 1;
if (*(char*)&a == 1)
{
printf("小端字节序存储");
}
else if (*(char*)&a == 0)
{
printf("大端字节序存储");
}
}
int main()
{
func();
return 0;
}
/*
精华：
int a = 1 ;
&a : 取出第一个字节（低地址处字节）的地址，类型是int*
*&a : 从第一个字节开始，往后四个字节的内容输出出来，
*(char*)&a : 从第一个字节开始，往后1个字节的内容输出出来，(第一个字节的内容)
*/
补充：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
练习2：
//下面输出的是什么
#include <stdio.h>
int main()
{
char a = -128;
printf("%u\n",a);
return 0;
}
/*
分析：
-128是一个int类型的
-128：10000000 00000000 00000000 10000000（原码）
11111111 11111111 11111111 01111111（反码）
11111111 11111111 11111111 10000000（补码）
char a: 发生截断 10000000
最后以无符号整形类型打印a : char a-->int 因为a是有符号的char ,所以 根据符号位来补；
11111111 11111111 11111111 10000000
再以无符号整形类型打印 ：4294967168
*/
练习3：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
//下面输出的是什么
#include <stdio.h>
int main()
{
char a = 128;
printf("%u\n",a);
return 0;
}
/*
分析：
128是一个int类型的；
128：00000000 00000000 00000000 10000000（原码==反码==补码）
char a: 发生截断：10000000
最后以无符号整形类型打印a : char a-->int 因为a是有符号的char ,所以根据符号位来补，所以整形提升为；
11111111 11111111 11111111 10000000
再以无符号整形类型打印 ：4294967168
*/
练习4：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
int i= -20;
unsigned int j = 10;
printf("%d\n", i+j);
//按照补码的形式进行运算，最后格式化成为有符号整数
/*
分析：
i:-20：10000000 00000000 00000000 00010100（原码）
11111111 11111111 11111111 11101011（反码）
11111111 11111111 11111111 11101100（补码）
j: 10: 00000000 00000000 00000000 00001010（原码==反码==补码）
最后将i+j以有符号整形形式打印出来：
i+j：11111111 11111111 11111111 11101100
00000000 00000000 00000000 00001010
11111111 11111111 11111111 11110110（补码）
10000000 00000000 00000000 00001001（反码）
10000000 00000000 00000000 00001010（原码）-> -10
*/
练习5：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
unsigned int i;
for(i = 9; i >= 0; i--)
{
printf("%u\n",i);
}
/*
9: 00000000 00000000 00000000 00001001
4294964762
*/
练习6：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
#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;
}
/*
分析：
-1：是整形：10000000 00000000 00000000 00000001（原码）
11111111 11111111 11111111 11111110（反码）
11111111 11111111 11111111 11111111（补码）
char a: 出现截断：11111111
signed char b: 11111111
unsighed char c= 11111111;
最后 a b c 以有符号整形类型输出：所以整形提升后再输出
a:因为a是有符号的char所以整形提升为：11111111 11111111 11111111 11111111
b:因为b是有符号的char所以整形提升为：11111111 11111111 11111111 11111111
c:因为c是无符号的char所以整形提升为：00000000 00000000 00000000 11111111
最后 a b c 以有符号整形类型输出：
a:11111111 11111111 11111111 11111111(原码)
10000000 00000000 00000000 00000000（反码）
10000000 00000000 00000000 00000001（补码）
-1
b:-1
c:00000000 00000000 00000000 11111111
255
*/
练习7：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
unsigned int i;
for(i = 9; i >= 0; i--)
{
printf("%u\n",i);
}
/*
输出的结果是：
9
8
7
6
5
4
3
2
1
0
4294967295
4294967294
4294967293
4294967292
.
.
.
.
.
*/
/*
分析：9是有符号整数赋值给无符号整数i，以为9是正整数，所以原码==反码==补码，所以站在无符号角度看还是9，所以以无符号整数的形式打印出来还是9，同理，打印出8 7 6 5 4 3 2 1 0，
打印完0之后执行i=i-1，i-1== -1,-1的补码：111111111 111111111 11111111 11111111，然后赋值给i
因为i是无符号整数，所以站在无符号整形的角度看，i==4294967295,大于0，打印出来,{因为补码（111111111 111111111 11111111 11111111）表示的是4294967295，从无符号整数角度看没有负数，原反补都一样，补码当成原码使}。
依次往后，出现死循环。
*/
练习8：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
#include <stdio.h>
int main()
{
char a[1000];
int i;
for (i=0;i<1000;i++)
{
a[i] = -1 - i;
}
printf("%d",strlen(a));
return 0;
}
//答案：255
分析：
strlen：求字符串长度，关注的是字符’\0’(数字0)之前有多少个字符，返回值是unsigned int类型。
难道：a[i]: -1 -2 -3 -4 -5 -6 -------- -1000
因为数组a是一个char类型的数组，里面每一个元素都是char类型，有符号的char类型的取值范围是：-128到127；
不管是多大的数字只要存在char类型空间中，都是在-128到127的范围内。（存在截取）所以：-1 -2 -3 -4 ----- -128 127 126 125 — 5 4 3 2 1 0 -1
-2 -3 -1 -2 -3 -4 ----- -128 127 126 125 — 5 4 3
2 1 0 共 255
练习9：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
#include<stdio.h>
unsigned char i = 0;
int main()
{
for (i=0;i<=255;i++)
{
printf("hello world \n");
}
return 0;
}
//死循环打印
/*
分析：256：0001 0000 0000 --> 截取以后 ：00000000 即0
*/
练习10：
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
#include<stdio.h>
#include<string.h>
int main()
{
if (strlen ("abc")-strlen ("abcdef")>=0)
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}
// >
分析：
strlen 函数的返回值是：size-t 即unsigned int 类型，strlen (“abc”)-strlen
(“abcdef”)，即两个unsigned int 类型的数字进行相减，得到的还是unsigned int 类型的数字。
#include <stdio.h>
int main()
{
unsigned int i = 3;
unsigned int j = 6;
printf("%u",i-j);
printf("%d",i-j);
// 00000000 00000000 00000000 00000011 3（补码=原）
//
// 10000000 00000000 00000000 00000110 -6
// 11111111 11111111 11111111 11111001
// 11111111 11111111 11111111 11111010（补码）
//
// 00000000 00000000 00000000 00000011（补码）3
// 11111111 11111111 11111111 11111010（补码）-6
// 11111111 11111111 11111111 11111101（补码）3+（-6）
//11111111 11111111 11111111 11111101 --> 4,294,967,293 以%u打印
//11111111 11111111 11111111 11111101（补码）
//10000000 00000000 00000000 00000010（反码）
//10000000 00000000 00000000 00000011（原码）---> -3 以%d打印
return 0;
}
// 4,294,967,293
// -3
注意：算数转换：相同类型的操作数才可以进行计算与操作，所以不同类型操作数进行计算时，要进行类型的转换。
long double
double
float
unsigned long int
long int
unsigned int
int
转换为另外一个操作数的类型后执行运 算。
从高位转换成低位时，可能会丢失精度。
总结：
不管是无符号整形还是有符号整形，在计算机内部进行计算的都是数据的补码，最后得到的结果也是补码，
当以有符号整形进行打印时，将最后结果的补码形式转换成原码形式打印出来，
当以无符号整形进行打印时，将最后结果的补码形式看成原码形式打印出来。
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
七：浮点数在内存中的存储
常见的浮点数：
3.14159
1E10—>1*10^10
浮点数家族包括： float、double、long double 类型。
浮点数表示的范围：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;
}
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉
浮点数在计算机内部的表示方法
如何存进去
根据国际标准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位的浮点数(float)，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。
对于64位的浮点数(double)，最高的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位，它的取值范围为0255；如果E为11位，它的取值范围为02047。但是，我们
知道，科学计数法中的E是可以出
现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数
是127；对于11位的E，这个中间数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即
10001001。
//注意：8位的E，中间值是127；而8位unsigned int取值范围是：0–255，也就是说E的真实值的取值范围是：-127—128
11位的E，中间值是1023；而11位unsigned
int取值范围是：0–2047，也就是说E的真实值的取值范围是：-1023—1024
如何取出来
指数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）； 好了，关于浮点数的表示规则，就说到这里。
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
练习
int main()
{
int n = 9;
//00000000 00000000 00000000 00001001 (原=补)
float *pFloat = (float *)&n;
printf("n的值为：%d\n",n);
printf("*pFloat的值为：%f\n",*pFloat);
//以float类型的视角进行打印：
//0 00000000 0000000 00000000 00001001
//G==0 E==-126 M=0.0000000 0000000000001001
//无限接近于0的数字
*pFloat = 9.0;
//1001
//1.001*2^3
//0 10000010 00100000000000000000000
printf("num的值为：%d\n",n);
//0 10000010 00100000000000000000000(原 反 补相同) --->> 1,091,567,616
printf("*pFloat的值为：%f\n",*pFloat);
return 0;
}
/*
n的值为：9
*pFloat的值为：0.000000
num的值为：1091567616
*pFloat的值为：9.000000
*/
总结：整数家族与浮点数家族在内存中的存储方式不同，从内存中取出的方式也不同。
int main()
{
int n = 9;
//00000000 00000000 00000000 00001001 (原=补)
float *pFloat = (float *)&n;
printf("n的值为：%d\n",n);
printf("*pFloat的值为：%f\n",*pFloat);
//以float类型的视角进行打印：
//0 00000000 0000000 00000000 00001001
//G==0 E==-126 M=0.0000000 0000000000001001
//无限接近于0的数字
*pFloat = 9.0;
//1001
//1.001*2^3
//0 10000010 00100000000000000000000
printf("num的值为：%d\n",n);
//0 10000010 00100000000000000000000(原 反 补相同) --->> 1,091,567,616
printf("*pFloat的值为：%f\n",*pFloat);
return 0;
}
/*
n的值为：9
*pFloat的值为：0.000000
num的值为：1091567616
*pFloat的值为：9.000000
*/
> 总结：整数家族与浮点数家族在内存中的存储方式不同，从内存中取出的方式也不同。
270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
