文章目录
🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑
一: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
*/
> 总结:整数家族与浮点数家族在内存中的存储方式不同,从内存中取出的方式也不同。