内存函数
1.memcpy--内存拷贝--使用和模拟实现//memcpy基本格式：
// 目标空间地址 原空间地址 被拷贝的字节个数
//void *memcpy(void * destination, const void * source,size_t num);
//因为内存拷贝拷贝的数据有：整型数据、结构体数据、结构体数据。那么我们就要用到void*进行接收任意类型的数据
//void*指针可以接收任意空间
//size_t num这个是要被拷贝的字节个数
//
//返回的是目标空间的起始地址
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2 = { 0 };
memcpy(arr2, arr1 + 2, 20);//因为我们要拷贝的是3~7，那么就是5个整型，20个字节
```
//因为我们要从3开始进行拷贝
//恰好因为数组名是首元素的地址，那么3的地址就是arr+2
//将arr1中的3 4 5 6 7拷贝放到arr2中
for (int i = 0; i < 20; i++)
{
printf("%d ", arr2);
}
return 0;
```
}
//我们要满足目标空间能进行修改
//目标空间足够大
//这个memcpy函数是不会考虑\0的，我让他拷贝多少个字节他就拷贝多少个字节
函数memcpy从source的位置开始复制num个字节的数据到destination指向的内存位置。
1.这个函数在遇到\0的时候并不会停下来
2.如果source和destination有任何的重叠，复制的结果都是未定义的
memcpy函数最终返回的是目标空间的起始地址
//函数的一种写法：
这个函数最终返回的是目标空间的起始地址
//void* my_memcpy(void *dest, const void*src, size_t num)//目标空间是要进行修改的，但是源头是不能被修改的，所以我们加上const
//{
// assert(src && dest);//防止两个指针是空指针
// void* ret = dest;//我们需要先创建一个指针存放最开始的dest，通过ret我们可以找到dest指向的数组
// //这里的src指向的是数组中3的位置
// //dest指向的是arr2数组的首元素的位置
// //拷贝20个字节
// //void*的指针不能进行直接计算，void*的指针是无具体类型的指针
// for (int i = 0; i < num; i++)//一对字节一对字节
// {
// *(char*)dest = *(char*)src;//强制类型转换再进行解引用就将那一对字节进行交换
// dest = (char*)dest + 1;//先将dest强制类型转换，在进行+1操作，因为上面的强制类型转换只是暂时的，为了能让dest进行++操作，我们就这样操作
// src = (char*)src + 1;
// }
// return ret;
//}
//函数的另一种写法：
//函数的一种写法：
//这个函数最终返回的是目标空间的起始地址
void* my_memcpy(void *dest, const void*src, size_t num)
{
assert(src && dest);
void* ret = dest;
while (num--)//也是循环num次
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2 = { 0 };
int *p=my_memcpy(arr2, arr1 + 2, 20);//这个函数的作用就是我们在arr1中选择的那部分粘贴在arr2中
for (int i = 0; i < 20; i++)
{
printf("%d ", p);
}
return 0;
}
//memcpy函数不负责重叠内存的拷贝，非要使用，结果就是未定义的
//只负责不重叠的内存
函数的返回值是void*类型的数据
这个memcpy函数有三个数据
2.memmove--内存移动--使用和模拟实现
2.memmove--内存移动--使用和模拟实现
int main()
{
//将123456拷贝放到34567上面
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1 + 2, arr1, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1);
}//输出结果是1 2 1 2 3 4 5 8 9 10
return 0;
}
//memmove就是用来处理这些重叠内存的拷贝
代码语言：javascript代码运行次数：0
运行
AI代码解释
void* my_memmove(void *dest, const void*src, size_t num)
{
void* ret = dest;//将目标空间起始地址记录下来
```
assert(dest && src);//保证指针的有效性
//最开始的dest指向的是3，src指向的是1，字节是20
if (dest < src)//前-->后
//目标空间的首元素<拷贝的起始元素--就相当与我们把34567拷贝到12345
//那么12的位置就是dest<src的位置
{
while (num--)//总共拷贝num个字节，那么就是num--,等所有字节拷贝完循环就停止了
{
*(char*)dest = *(char*)src;
//拷贝完一对字节就往后走，进行+1操作
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else//后-->前剩下的区域---dest > src
{
while (num--)
{
//进入循环的时候，num 已经是19了
//*((char*)dest + num)---找到最后一个字节的位置
*((char*)dest + num) = *((char*)src + num);
//目标的最后一个位置的字节------ 起源空间的最后一个位置
//将起源的最后一个字节先开始挪动，从最后一个位置依次挪动
//就是将我们要挪动的那块区域，我们从最右边开始挪动
}
}
return ret;
```
}
int main()
{
//将123456拷贝放到34567上面
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr1 + 2, arr1, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1);//1 2 1 2 3 4 5 8 9 10
}
return 0;
}
//总之：这个拷贝是分三块区域的，最前面的一块区域满足dest<src
//我们只能从前往后进行拷贝，不然会出错误
//而剩下的两块区域可以同时从后往前进行拷贝，那么我们就将这两块区域放在一起
在C语言标准中，明确规定了memcpy只要能实现不重叠的拷贝就行，重叠的拷贝交给memmove
我们发现vs上面的库函数memcpy函数也能实现重叠内存的拷贝
我们在以后的拷贝中，我们可以用memmove，因为不管是重叠的还是不重叠的都能搞定
3.memset--内存设置--函数的使用
memset是用来设置内存的，将内存中的值以字节单位设置为想要的内容
基本格式：
void memset (void ptr,int value,size_t num )
ptr就是指向要被填充的内存块的指针
value就是我们想要设置的值是什么
num是设置的字节的大小
代码语言：javascript代码运行次数：0
运行
AI代码解释
int main()
{
char arr[] = "hello world";
//将world改成5个x
memset(arr + 6, 'x', 5);//数组首元素的地址+6就是指向的是w
printf("%s\n", arr);
return 0;
}
4.memcmp--内存比较--函数的使用
4.memcmp--内存比较--函数的使用
内存的比较
什么类型的都能进行比较
代码语言：javascript代码运行次数：0
运行
AI代码解释
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,6,5 };
int ret=memcmp(arr1, arr2, 16);
printf("%d\n", ret);//输出的数据就是-1
//就是说明arr1<arr2
return 0;
}
学习一下 在使用memcpy函数时，如果目标内存区域的大小不 全局变量占用的内存在整个程序生命周期中都存在，容易导致内存浪费。尽量使用局部变量和动态分配的内存。 单片机的堆（Heap）通常较小（如 STM32 默认堆仅几 KB），频繁调用 malloc/free 易导致内存碎片。 当处理大量数据时，内存函数的性能会受到影响。如果需要处理的数据量非常大，可能会导致单片机运行变慢甚至死机。此时可以考虑分块处理数据，以减少单次操作的数据量。 尽量减少全局变量的使用，以节省内存空间和提高代码的模块化。 通过malloc()、calloc()、realloc()等函数来动态分配内存，适用于运行时需要根据条件调整大小的情况。然而，在资源有限的单片机中，应谨慎使用动态内存分配，因为它可能导致内存碎片化，并增加系统的复杂性。 栈空间用于存储局部变量和函数调用信息。避免在栈上声明过大的数组或结构体，以防止栈溢出。 部分内存函数（如memcpy）在处理重叠的内存区域时可能会产生未定义行为。当源内存区域和目标内存区域有重叠时，数据可能会被意外覆盖。 如果单片机支持内存保护单元（MPU），可以使用它来限制对特定内存区域的访问，提高系统的安全性。 使用编译器的优化选项（如 -O2）可以提高代码的效率，减少内存使用。 对数组和指针的访问不超过其边界，避免缓冲区溢出和未定义行为。
页:
[1]