1.整数在内存中的存储
对整数来说：数据存放内存中其实存放的是二进制的补码
正整数的原反补码都相同
负数就不一样了
计算的使用的是内存中存放的二进制，计算使用的就是补码
2.大小端字节和字节序判断
其实超过一个字节的数据在内存中存的时候，就有存储顺序的问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储
以字节为单位讨论顺序的
大端字节序存储
将一个数据的低位字节序的内容存放在内存的高地址处
将高位字节的内容存放在低地址处
11 22 33 44
从左到右逐渐变大就是大端
小端字节序存储
将一个数据的低位字节内容存放在低地址处
高位字节存放在高地址处
44 33 22 11
从左到右逐渐变小就是小端
为什么会有大小端呢？
由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节按排的问题。因此就导致了大端存储模式和小端存储模式
如何判断当前机器是大端存储还是小端存储呢？
代码语言：javascript复制//简述大端字节序和小端字节序的概念。设计一个小程序来判断当前机器的字节序
//大端肯定是00 00 00 01
//小端肯定是01 00 00 00
//第一个字节拿出来的是0就是大端，是1就是小端
int check_sys(int a)
{
/*if (*(char*)&a == 1)//int*类型的地址,所以我们需要将a的地址取出来然后强制类型转换为char*类型的，
//然后进行解引用，就能得a的二进制开头的到那一个字节
{
return 1;
}
else
{
return 0;
}*/
//*(char*)&a因为这个代码只有两种情况，那么我们直接进行返回就行了
return *(char*)&a;//这个返回值恰好是我们想要的
//返回1是小端，返回0是大端
}
int main()
{
int a = 1;//4个字节
//我们现在只需要取出这4个字节内的第一个字节
if (check_sys(a) == 1)
{
printf("小端n");
}
else
{
printf("大端n");
}
//if (*(char*)&a==1)//int*类型的地址,所以我们需要将a的地址取出来然后强制类型转换为char*类型的，
// //然后进行解引用，就能得a的二进制开头的到那一个字节
//{
// printf("小端n");
//}
//else
//{
// printf("大端n");
//}
return 0;
}
//输出的结果就是小端#include <stdio.h>
int main()
{
//char是有符号还是无符号的呢？
//这个 不确定，取决于编译器
//但是大部分编译器上面，char==signed char--有符号的
//-1
//1000000000000000000000000001--原
//1111111111111111111111111110--反
//1111111111111111111111111111--补
//因为a是char类型的，只有1个字节，
//a
// 因为-1是整型，那么a就得整型提升
//1111111111111111111111111111--a--补码
//1000000000000000000000000000--a--反码
//1000000000000000000000000001--a--原码
//补码取反 1得到的就是原码
//那么a打印出来就是-1
char a = -1;//char是一个字节8个比特位
signed char b = -1;
//-1
//1111111111111111111111111111--补码
//因为-1的补码存在c中只能存8个比特位
//11111111
//因为我们要打印整型，那么我们就需要对c进行整型提升了
//如果是有符号的话，我们是按照符号位进行提升的
//但是如果是无符号的话，高位补0
//0000000000000000000011111111--补码
//因为内存中的是有符号数，开头是0，是正数，那么反码补码原码都相同
//0000000000000000000011111111--原码---得到的就是255
unsigned char c = -1;
printf("a=%d,b=%d,c=%d", a, b, c);//a=-1,b=-1,c=255
//%d是打印有符号的整数--打印的原码
//%u是打印无符号的整数
//因为%d是打印有符号数的，那么我们就会认为内存中存的是有符号数
return 0;
}#include <stdio.h>
int main()
{
char a = -128;
printf("%un", a);//4294967168
//%u是无符号整数，&u的角度，他认为内存中存储的是无符号整数
//那么a就得进行整型提升的操作了
//
// 10000000000000000000000010000000--- -128的原码
// 11111111111111111111111101111111--- -128的反码
// 11111111111111111111111110000000--- -128的补码
//
// 补码要放到a里面去，因为a是char a，所以只能放8个比特位
// 10000000--a
// 因为char a 是一个有符号的char ,那么我们进行整型提升就要根据符号位进行提升
//
// 因为符号位是1，那么我们就补1
//
// 因为%u认为这是一个无符号的数，并且是整数，那么我们进行整型提升
// 整型提升看的是a，因为char是有符号的，所有他认为高位的那一位是有符号的char
// 那么我们在进行整型提升的时候就根据符号位进行高位补1的操作了
// 提升后的结果：
// 11111111111111111111111110000000---内存中的补码
//
// 因为我们认为是无符号整数，那么就是没有符号位的，最高位不是符号位，那么我们就是原码反码补码是相同的
//
// 那么我们直接将这个数字打印出来
//
//
return 0;
}
// 如果是有符号的话，我们是按照符号位进行提升的
// //但是如果是无符号的话，高位补0
//我们在整型提升的时候还是要根据数据的本身类型来说//
//#include <stdio.h>
//int main()
//{
// char a = 128;
//
// //00000000000000000000000010000000--- 128原码
// //128和-128截断之后是一样的
// //10000000--因为a是1个字节的，我们只能取8个比特位
// //
// //我们需要进行整型提升才能进行打印
//
// //因为a的类型是有符号的char
// //
// //那么我们就补符号位1
// //11111111111111111111111111111000
// //因为我们使用%u进行打印的，无符号数，那么就是说原码反码补码相同
//
// //11111111111111111111111111111000那么这个数就是要打印出来的数
// printf("%un", a);
// return 0;
//}
//char类型的取值范围是-128~127
//char占一个字节---8个比特位/*内存中
* 有符号的char
*
00000000---0
00000001---1
00000010---2
00000011---3
………………
01000000
………………
01111110---126
01111111---127
10000000--- -128
10000001----取反 1得到的就是-127
………………
11111110
11111111 -1----因为这个是补码，换场原码大小就是-1了
*/
//回头看char a =128;其实放不进去的
/*
w
无符号的char----范围是0~255
00000000---0
00000001---1
00000010---2
00000011---3
………………
01000000
………………
01111110---126
01111111---127
10000000--- 128----因为没有符号位
10000001----129
………………
11111110
11111111------255
*/
//16个比特位
//signed short
//short
/*
0000000000000000---0
0000000000000001---1
………………………………
0111111111111111----有符号的short的最大值---32767
1000000000000000---- 变成-32768
………………………………
1111111111111110---- -2
1111111111111111---- -1
*/
//signed 和unsigned都在内存中开辟着大小一样的空间
//唯一的区别就是signed认为数的二进制位的最高位是符号位
//unsigned认为最高位不是符号位
int main()
{
//unsigned int num = -10;不管这个是signed还是unsigned,结果都是一样的
unsigned int num = -10;
printf("%dn", num);//-10
//%d打印的就是有符号的数，与之匹配
printf("%un", num);//4294967286
//
return 0;
}
//最终的答案还是取决于我们打印的形式
//是%d还是%u
//我们在写代码的时候，signed int ---有符号的数，那么我们就应该用%d与之进行配对#include <stdio.h>
int main()
{
char a[1000];
int i;
for (i = 0; i < 1000; i )
{
a[i] = -1 - i;
}
printf("%d", strlen(a));//255
return 0;
}
/*
因为这是一个char类型的数组，取值范围是-128~127的
-1 -2 -3 -4 ……………………-128 127 ……3 2 1 0 -1 -2 -3
-1到128是128个人元素，127到1是127个元素
那么总共就是255个元素了
因为strlen统计的是字符串中元素的个数，
并且检查的是' '之前的数
所以这个字符串数组内存在255个元素
*/#include <stdio.h>
unsigned char i = 0;//全局变量
//因为这个char是unsigned char，无符号的char类型
int main()
{
for (i = 0; i <= 255; i )
{
printf("hello worldn");//打印无限个
}
return 0;
}
//因为前面有一个全局变量范围是0~255
//而循环的范围是i<=255，那么这个循环的条件恒成立，可以一直循环
//那么对于打印来说就是无限进行打印操作
//无限循环#include <stdio.h>
int main()
{
unsigned int i;//无符号整型，最小值是0
//对于这个循环来说,i>=0就恒成立了，这个循环就一直进行
for (i = 9; i >= 0; i--)
{
printf("%un", i);
Sleep(100);
}
return 0;
}
/*
9
8
7
6
5
4
3
2
1
0
----------
0-1就变成-1了，-1被%u打印的时候将是一个非常大的数字
4294967295
…………………………下面就是非常大的数字了
*/#include <stdio.h>
//X86环境 ⼩端字节序
int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a 1);
//&a 1就是跳过一整个数组，指向这个数组的末尾
//
// 将这个地址强制类型转换为int*赋值给ptr1,那么ptr1指向的就是这个数组的末尾
// ptr1[-1]---->*(ptr1-1)
// 因为ptr1是整型指针，那么-1就是指向了4的位置，那么解引用得到的就是4
//
// 那么4用16进制打印得到的还是4
//
int* ptr2 = (int*)((int)a 1);
/*
这里的a是数组首元素的地址，那么被强制类型转换为整数类型，
那么(int)a 1就是 1
a是占4个字节的，但是被转换为整型了并且 1，那么现在就离开始的位置相差1个字节了
所以ptr2指向就是离首元素地址差1个字节的地址的位置
因为ptr2是整型指针，那么就是4个字节，从那个位置开始向后访问4个字节
01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00
所以就是从第2个00开始访问到02
00 00 00 02--因为这个地址在内存中是小端存在的，
所以原始的就是02 00 00 00
换成16进制的就是0x02 00 00 00
所以打印出来的就是2000000，最前面的0x0是不打印的
*/
printf("%x,%x", ptr1[-1], *ptr2);//4,2000000
//%x是16进制的形式打印的
return 0;
}3.浮点数在内存中的存储
代码语言：javascript复制#include <stdio.h>
int main()
{
int n = 9;//原反补相同
//00000000 00000000 00000000 00001001-----9
//
//
float* pFloat = (float*)&n;
//取出n的地址并强制类型转换为float*类型的指针
//再赋值给pFloat,那么pFloat指向的就是二进制的起始位置
printf("n的值为：%dn", n);//9
printf("*pFloat的值为：%fn", *pFloat);//0.000000
//这个pFloat是浮点型指针，
//站在*pFloat的角度上看，他会认为内存中存的是浮点数
// 那么这次就是以浮点数的形式取出这个值
// 因为整数和浮点数在内存中的存储形式不同
// 所以我们将二进制转换为S M E类型的进行读
// 0 00000000 00000000000000000001001
// S E M
// 他会认为这个数是以S E M类型存在的
//E为全0的时候，那么是E 127=0，所以E就是-127
//那么这个数最后算出来就是一个正负无穷接近于0的数字
//那么打印出来的数是0.000000
*pFloat = 9.0;
//1001.0---小数点向左移动3位，所以下面的科学计数法就是乘2的3次方
// 加上正负的处理的话(-1)^0
//科学计数法的形式:(-1)^0 * 1.001 * 2^3
//
// S=0
// M=1.001
// E=3
// S=0 E=127 3=130 M--小数点后面的是001，还要满23个比特位，所以补上20个0
// 0 10000010 00100000000000000000000
// 所以9.0在内存中的二进制序列是01000001000100000000000000000000
// 其实是放到n的位置空间内了，因为pFloat指向的是n的起始位置
//
/*
站在n的角度上，我们得到的科学计数法的数是补码
那么我们就要把原码算出来
因为高位是0，所以是正数，正数的原码补码反码相同
所以这个二进制换算的十进制的数就是1091567616
*/
printf("num的值为：%dn", n);//1091567616
printf("*pFloat的值为：%fn", *pFloat);//9.000000
return 0;
}
/*
我们要清楚我们是以什么形式放进去的，怎么形式取出来的，
我以整数的形式放进去的，我以整数的视角取出来，那么就按照整数的视角计算原反补
我以浮点数的形式放进去的，我以浮点数的视角取出来，那么我们就按S M E相关的东西进行计算
不理解就看代码
*/
/*
总之，就是浮点数和整数在内存中的存储方式是不同的
浮点数是S M E
我们可以利用二进制序列来得到这三个数据，进而得到我们浮点数在内存中的存储形式
*/常见的浮点数：3.14159、1E10--科学计数法
浮点数家族包括：float、double、long 、double类型
浮点数表示的范围：float.h中定义
整数和浮点数在内存中的存储方式是有区别的
10进制：5.5
2进制：101.1
5.5=（-1）^011.011*2^2
S=0
M=1.011
E=2
E是无符号的数
小数点后面的1就是表示2的负几次方，从-1开始
浮点数的存储，存储的就是S、M、E相关的值
对于32位的浮点数，最高的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字M
对于64位的浮点数，最高的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效数字M
1<M<2
在计算机内部保存M的时候，默认这个数的第一位总是1，因此可以被舍去，只保留后面的xxxx部分，xxxx部分表示小数部分
所以我们在存M的时候，一般存的都是小数点后面的位
10进制的0.5
2进制的0.1
科学计数法：1.0*2^-1
在存储E的时候还会添加中间值.float添加127
double添加1023
再将得到的值存在E的内存中
之前已经说过浮点数的存储，存储的就是S、M、E相关的值
取出来的三种情况：
1.正常存E的时候是E 中间值（127/1023），那么将这个取出来减去中间值就得到了E，对于M，将M取出 1就是我们要的M----这里的E不全为0或者不全为1
2.E为全0，那么取出来的E为-127，表示的就是正负无穷接近于0的数字
3.E为全1，如果全是1的话，那么刚好8个比特位，就是8个1，就是255
E 中间值（127）=255，那么E就是128
那么这个数也是一个正负无穷大的数字
代码语言：javascript复制int main()
{
float f = 5.5f;
//S=0;
//E=2
//M=1.011
//0 10000001 01100000000000000000000
//S E--129=(127 2) M--存的是小数点后面的-总共有23个比特位，那么剩下的20位补0
//0100 0000 1011 0000 0000 0000 0000 0000
// 11在16进制就是b
// 4 0 b 0 0 0 0 0
// 0x40b00000--最后得到的数据--浮点数5.5在内存中得到的形式
//得到的二进制数每4个二进制位就能换一个16进制数
return 0;
}
