内存函数以及数据在内存中的存储

1. memcpy使⽤和模拟实现

void * memcpy ( void * destination, const void * source, size_t num );

1️⃣函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。

2️⃣这个函数在遇到 '\0' 的时候并不会停下来。

3️⃣如果source和destination有任何的重叠，复制的结果都是未定义的。

4️⃣memcpy函数处理的是不重叠的两块内存数据的拷贝。

#include <stdio.h>
#include <string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
memcpy(arr2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
//输出结果为:1 2 3 4 5 0 0 0 0 0

//memcpy函数的模拟实现
void * memcpy ( void * dst, const void * src, size_t count)
{
void * ret = dst;
assert(dst);
assert(src);
while (count--) 
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return(ret);
}

2. memmove使⽤和模拟实现

void * memmove ( void * destination, const void * source, size_t num );

和memcpy的差别就是memmove函数处理的源内存块和⽬标内存块是可以重叠的。

如果源空间和⽬标空间出现重叠，就得使⽤memmove函数处理。

#include <stdio.h>
#include <string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1+2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
 return 0;
}
 //输出的结果:1 2 1 2 3 4 5 8 9 10

 //memmove的模拟实现
 void * memmove ( void * dst, const void * src, size_t count)
 {
 void * ret = dst;
 if (dst <= src || (char *)dst >= ((char *)src + count)) {
 while (count--) {
 *(char *)dst = *(char *)src;
 dst = (char *)dst + 1;
 src = (char *)src + 1;
 }
 }
 else {
 dst = (char *)dst + count - 1;
 src = (char *)src + count - 1;
 while (count--) {
 *(char *)dst = *(char *)src;
 dst = (char *)dst - 1;
 src = (char *)src - 1;
 }
 }
 return(ret);
 }

3. memset函数的使⽤

void * memset ( void * ptr, int value, size_t num );

memset是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容。

#include <stdio.h>
#include <string.h>
int main ()
{
char str[] = "hello world";
memset (str,'a',6);
printf(str);
return 0;
}
//输出的结果:aaaaaaworld

4. memcmp函数的使⽤

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

⽐较从ptr1和ptr2指针指向的位置开始，向后的num个字节

返回值：返回一个整数值，用于指示内存块内容之间的关系：

 #include <stdio.h>
 #include <string.h>
 int main()
 {
 char buffer1[] = "DWgaOtP12df0";
 char buffer2[] = "DWGAOTP12DF0";
 int n;
 n = memcmp(buffer1, buffer2, sizeof(buffer1));
 if (n > 0)
 printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
 else if (n < 0)
 printf("'%s' is less than '%s'.\n", buffer1, buffer2);
 else
 printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
 return 0;
 }
//输出的结果:'DWgaOtP12df0' is greater than 'DWGAOTP12DF0'

5. 整数在内存中的存储

在介绍操作符的时候，我就介绍了下⾯的内容：

整数的2进制表⽰⽅法有三种，即 原码、反码和补码

有符号的整数，三种表⽰⽅法均有符号位和数值位两部分，符号位都是⽤0表⽰“正”，⽤1表

⽰“负”，最⾼位的⼀位是被当做符号位，剩余的都是数值位。

1️⃣正整数的原、反、补码都相同。

2️⃣负整数的三种表⽰⽅法各不相同。

3️⃣原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。

4️⃣反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。

5️⃣补码：反码+1就得到补码。

对于整形来说：数据存放内存中其实存放的是⼆进制的补码。为什么呢？

在计算机系统中，数值⼀律⽤补码来表⽰和存储。

原因在于，使⽤补码，可以将符号位和数值域统⼀处理；

同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是

相同的，不需要额外的硬件电路。

6. ⼤⼩端字节序和字节序判断

当我们了解了整数在内存中存储后，我通过调试来观察⼀个细节：

#include <stdio.h>
 int main()
 {
 int a = 0x11223344;
 return 0;
 }

调试的时候，我们可以看到在a中的 0x11223344 这个数字是按照字节为单位，倒着存储的。这是为什么呢？

6.1 什么是⼤⼩端？

其实超过⼀个字节的数据在内存中存储的时候，就有存储顺序的问题，按照不同的存储顺序，我们分为⼤端字节序存储和⼩端字节序存储，下⾯是具体的概念：

1️⃣⼤端（存储）模式：

是指数据的低位字节内容保存在内存的⾼地址处,⽽数据的⾼位字节内容,保存在内存的低地址处。

2️⃣⼩端（存储）模式：

是指数据的低位字节内容保存在内存的低地址处,⽽数据的⾼位字节内容,保存在内存的⾼地址处。

6.2 为什么有⼤⼩端?

为什么会有⼤⼩端模式之分呢？

这是因为在计算机系统中,我们是以字节为单位的,每个地址单元都对应着⼀个字节,⼀个字节为8bit 位,但是在C语⾔中除了8 bit 的char 之外,还有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处理器还可以由硬件来选择是⼤端模式还是⼩端模式。

6.3 练习

6.3.1 练习1(百度笔试题)

请简述⼤端字节序和⼩端字节序的概念,设计⼀个⼩程序来判断当前机器的字节序 .

#include <stdio.h>
 int check_sys()
 {
 int i = 1;
 return (*(char *)&i);
 }
 int main()
 {
 int ret = check_sys();
 if(ret == 1)
 {
 printf("⼩端\n");
 }
 else
 {
 printf("⼤端\n");
 }
 return 0;
 }

6.3.2 练习2

#include <stdio.h>
int main()
{
char a= -1;//char是有符号还是无符号？这个取决于编译器的实现
signed char b=-1;
unsigned char c=-1;
printf("a=%d,b=%d,c=%d",a,b,c);//%d以10进制的形式打印有符号的整数
return 0;
}

6.3.3 练习3

#include <stdio.h>
int main()
{
char a = -128;
printf("%u\n",a);//%u以10进制的形式打印无符号的整数
return 0;
}

#include <stdio.h>
int main()
{
char a = 128;
printf("%u\n",a);
return 0;
}

6.3.4 练习4

#include <stdio.h>
#include <string.h>
int main()
{
char a[1000];
int i;
for(i=0; i<1000; i++)
{
a[i] = -1-i;
}
printf("%d",strlen(a));//strlen求的是字符串的长度，统计的是\0之前的字符个数
return 0;
}

6.3.5 练习5

#include <stdio.h>
unsigned char i = 0;
int main()
{
for(i = 0;i<=255;i++)
{
printf("hello world\n");
}
return 0;
}//死循环打印helloworld

#include <stdio.h>
int main()
{
unsigned int i;
for(i = 9; i >= 0; i--)
{
printf("%u\n",i);
}
return 0;
}//无限打印数值

6.3.6 练习6

#include <stdio.h>//X86环境 ⼩端字节序
int main()
{
int a[4] = { 1, 2, 3, 4 };
int *ptr1 = (int *)(&a + 1);
int *ptr2 = (int *)((int)a + 1);
printf("%x,%x", ptr1[-1], *ptr2);
return 0;
}

7. 浮点数在内存中的存储

常⻅的浮点数：3.14159、1E10等，浮点数家族包括： float、double、long double 类型。

浮点数表⽰的范围： float.h 中定义

7.1 练习

#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;
}

7.2 浮点数的存储

上⾯的代码中,n 和 *pFloat 在内存中明明是同⼀个数,为什么浮点数和整数的解读结果会差别这

么⼤？要理解这个结果，⼀定要搞懂浮点数在计算机内部的表⽰⽅法。

根据国际标准IEEE（电⽓和电⼦⼯程协会）754,任意⼀个⼆进制浮点数V可以表⽰成下⾯的形式：V = 

(-1)^s

*M*

2^E

1️⃣

(-1)^s

表⽰符号位，当S=0，V为正数；当S=1，V为负数

2️⃣M 表⽰有效数字，M是⼤于等于1，⼩于2的

3️⃣

2^E

表⽰指数位

举例来说：

⼗进制的5.5，写成⼆进制是 101.1 ，相当于 1.011×

2^2

。那么，按照上⾯V的格式，可以得出S=0，M=1.011，E=2。

⼗进制的-5.5，写成⼆进制是 -101.1 ，相当于 -1.01×

2^2

 。那么，S=1，M=1.011，E=2。

IEEE 754规定：

1️⃣对于32位的浮点数(float)，最⾼的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字M

2️⃣对于64位的浮点数(double)，最⾼的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效数字M

7.2.1 浮点数存的过程

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位,它的取值范围为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.

7.2.2 浮点数取的过程

指数E从内存中取出还可以再分成三种情况：

1️⃣E不全为0或不全为1（常规情况）

这时,浮点数就采⽤下⾯的规则表⽰,即指数E的计算值减去127（或1023）,得到真实值,再将有效数字M前加上第⼀位的1。

⽐如：0.5 的⼆进制形式为0.1,由于规定正数部分必须为1,即将⼩数点右移1位,则为1.0*2^(-1),其

阶码为-1+127(中间值)=126，表⽰为01111110，⽽尾数1.0去掉整数部分为0，补⻬0到23位

00000000000000000000000，则其⼆进制表⽰形式为:

0 01111110 00000000000000000000000

2️⃣E全为0

这时,浮点数的指数E等于1-127（或者1-1023）即为真实值,有效数字M不再加上第⼀位的1,⽽是还原为0.xxxxxx的⼩数。这样做是为了表⽰±0,以及接近于0的很⼩的数字。

 0 00000000 00100000000000000000000

3️⃣E全为1

这时,如果有效数字M全为0,表⽰±⽆穷⼤（正负取决于符号位s）；

0 11111111 00010000000000000000000

7.3 题⽬详细解析

下⾯,让我们回到⼀开始的练习

先看第1环节,为什么 9 还原成浮点数就成了 0.000000 ？

9以整型的形式存储在内存中，得到如下⼆进制序列：

0000 0000 0000 0000 0000 0000 0000 1001

⾸先,将 9 的⼆进制序列按照浮点数的形式拆分,得到第⼀位符号位s=0,后⾯8位的指数

E=00000000,最后23位的有效数字M=000 0000 0000 0000 0000 1001。

由于指数E全为0，所以符合E为全0的情况。因此，浮点数V就写成：

V=(-1)^0 × 0.00000000000000000001001×2^(-126)=1.001×2^(-146)

显然,V是⼀个很⼩的接近于0的正数,所以⽤⼗进制⼩数表⽰就是0.000000。

再看第2环节,浮点数9.0,为什么整数打印是 1091567616

⾸先,浮点数9.0 等于⼆进制的1001.0,即换算成科学计数法是：1.001×2^3

所以:9.0  = (−1) 0 ∗ (1.001) ∗ 2 3 ，

那么,第⼀位的符号位S=0,有效数字M等于001后⾯再加20个0,凑满23位,指数E等于3+127=130，

即10000010所以，写成⼆进制形式，应该是S+E+M，即

0 10000010 001 0000 0000 0000 0000 0000

这个32位的⼆进制数,被当做整数来解析的时候,就是整数在内存中的补码,原码正是1091567616 。

以上就是今天的博客内容了，希望能够帮助到读者朋友们！

我们一起继续加油努力💪！

本篇完结，点赞收藏加关注，找到小编不迷路，感谢大家🙏🤝！