C语言----数据在内存中的存储

1.整数在内存中的存储

对整数来说:数据存放内存中其实存放的是二进制的补码

正整数的原反补码都相同

负数就不一样了

计算的使用的是内存中存放的二进制,计算使用的就是补码

2.大小端字节和字节序判断

其实超过一个字节的数据在内存中存的时候,就有存储顺序的问题,按照不同的存储顺序,我们分为大端字节序存储和小端字节序存储

以字节为单位讨论顺序的

大端字节序存储

将一个数据的低位字节序的内容存放在内存的高地址处

将高位字节的内容存放在低地址处

11 22 33 44

从左到右逐渐变大就是大端

小端字节序存储

将一个数据的低位字节内容存放在低地址处

高位字节存放在高地址处

44 33 22 11

从左到右逐渐变小就是小端

为什么会有大小端呢?

由于寄存器宽度大于一个字节,那么必然存在着一个如何将多个字节按排的问题。因此就导致了大端存储模式和小端存储模式

如何判断当前机器是大端存储还是小端存储呢?

//简述大端字节序和小端字节序的概念。设计一个小程序来判断当前机器的字节序

//大端肯定是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("%u\n", 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("%u\n", 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("%d\n", num);//-10
    //%d打印的就是有符号的数,与之匹配
    printf("%u\n", 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统计的是字符串中元素的个数,
并且检查的是'\0'之前的数
所以这个字符串数组内存在255个元素
*/

#include <stdio.h>
unsigned char i = 0;//全局变量
//因为这个char是unsigned char,无符号的char类型
int main()
{
    for (i = 0; i <= 255; i++)
    {
        printf("hello world\n");//打印无限个
    }
    return 0;
}
//因为前面有一个全局变量范围是0~255
//而循环的范围是i<=255,那么这个循环的条件恒成立,可以一直循环
//那么对于打印来说就是无限进行打印操作
//无限循环

#include <stdio.h>
int main()
{
    unsigned int i;//无符号整型,最小值是0
    //对于这个循环来说,i>=0就恒成立了,这个循环就一直进行
    for (i = 9; i >= 0; i--)
    {
        printf("%u\n", 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.浮点数在内存中的存储

#include <stdio.h>
int main()
{
    int n = 9;//原反补相同
    //00000000  00000000  00000000  00001001-----9
    //
    //
    float* pFloat = (float*)&n;
    //取出n的地址并强制类型转换为float*类型的指针
    //再赋值给pFloat,那么pFloat指向的就是二进制的起始位置



    printf("n的值为:%d\n", n);//9



    printf("*pFloat的值为:%f\n", *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的值为:%d\n", n);//1091567616
    printf("*pFloat的值为:%f\n", *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

那么这个数也是一个正负无穷大的数字

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;
}
相关推荐
远望清一色13 分钟前
基于MATLAB边缘检测博文
开发语言·算法·matlab
何曾参静谧21 分钟前
「Py」Python基础篇 之 Python都可以做哪些自动化?
开发语言·python·自动化
Prejudices25 分钟前
C++如何调用Python脚本
开发语言·c++·python
我狠狠地刷刷刷刷刷38 分钟前
中文分词模拟器
开发语言·python·算法
wyh要好好学习42 分钟前
C# WPF 记录DataGrid的表头顺序,下次打开界面时应用到表格中
开发语言·c#·wpf
AitTech42 分钟前
C#实现:电脑系统信息的全面获取与监控
开发语言·c#
qing_04060344 分钟前
C++——多态
开发语言·c++·多态
孙同学_44 分钟前
【C++】—掌握STL vector 类:“Vector简介:动态数组的高效应用”
开发语言·c++
froginwe111 小时前
XML 编辑器:功能、选择与使用技巧
开发语言
Jam-Young1 小时前
Python的装饰器
开发语言·python