目录
1.前言
C语言为我们提供了许多库函数，除了之前的字符函数和字符串函数外，还有内存函数和动态内存函数，其中动态内存函数尤为重要。下面，就由我来介绍这些函数。
2.内存函数
在使用这些库函数的时候，都要引用头文件string.h。
2.1 memcpy
memcpy 链接: link
函数原型：
void * memcpy ( void * destination, const void * source, size_t num );
作用：将num字节的值从源所指向的位置直接复制到目标所指向的内存块
要点：
1.函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
2.若source和destination有任何的重叠，复制的结果都是未定义的。
使用 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.memcpy 函数将arr1中占20个字节的内容拷贝到 arr2 中去，即将1，2，3，4，5这5个整型数字，拷贝到 arr2 中去；
2.打印结果为：1，2，3，4，5，0，0，0，0，0；若不想打印后面的0，可以调整 for 循环中的判断表达式。
3.num 的单位是字节
前面提到，memcpy 函数不能处理源内存区域和目标内存区域存在重叠的情况，但是将该代码复制到 VS 编译器中去运行，可以发现 memcpy 是能够处理的，这是 VS 编译器它自身的某些原因。
尝试模拟实现 memcpy 函数
要模拟实现该函数，就要知道它是怎么拷贝的，尤其要注意，它是一个字节一个字节拷贝的。
#include <stdio.h>
#include <assert.h>
void* simulate_memcpy(void* dest, const void* src, int num)
{
assert(dest && src);
while (num--)
{
*dest++ = *src++;
}
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
simulate_memcpy(arr2, arr1, 20);
return 0;
}
以上代码正确吗？其实不然，我们注意到 dest 和 src 的类型都是 void* 类型，是范型，范型是不可以直接进行加减运算的。要想能够实现加减运算，就得强制类型转化成其它类型。
那么，要转换成哪种类型的呢？有的人认为拷贝20个字节大小的内容，而又都是int类型，而int类型又都是4个字节的大小，直接强制类型转换为 int* 类型的不就行了吗？那么有没有考虑过，当将 num 参数的20改为17又该怎么办呢？所以说，将 void* 类型强制转换为 int* 类型是不行的，鉴于之前提出改为 17 个字节的问题，我们可以考虑将其强制类型转换为 char* 类型。
正确代码实现如下所示：
#include <stdio.h>
void* simulate_memcpy(void* dest, const void* src, int num)
{
assert(dest && src);
void* ret = dest;
while (num--)
{
*((char*)dest)++ = *((char*)src)++;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
simulate_memcpy(arr2, arr1, 20);
return 0;
}
关于为什么 while 循环中的表达式要加这么多的括号，那是因为：
1.最里层的括号是强制类型转换操作符；
2.从里向外的括号，将 (char*)dest 括起来是因为强制类型转换是临时的，要想改变这一点就要用括号将整个语句括起来；
3.将 (char*)dest 看作整体，再解引用。
2.2 memmove
memmove 链接: link
函数原型：
void * memmove ( void * destination, const void * source, size_t num );
作用：与memcpy的作用类似，可以处理源内存区域和目标内存区域存在重叠的情况，避免了 memcpy 可能出现的未定义行为
要点：
1.与memcpy的差别是memmove函数处理的源内存块和目标内存块是可以重叠的
2.若源空间和目标空间出现重叠，就得使用memmove函数处理
使用 memmove 函数编写一段程序：
#include <stdio.h>
#include <string.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr, arr + 2, 20);
return 0;
}
arr+2 后指向的是3，拷贝大小为20个字节，也就是说将3，4，5，6，7拷贝到 arr 中去，也可以理解为将3,4,5,6,7替换1,2,3,4,5，事实是非如此？通过监视窗口观察 arr 的变化：
从上图可以看到，确实将3,4,5,6,7拷贝到了arr中。
模拟实现memmove函数：
#include <stdio.h>
#include <assert.h>
void* simulate_memmove(void* dest, const void* src, int num)
{
assert(dest && src);
void* ret = dest;
while (num--)
{
*((char*)dest)++ = *((char*)src)++;
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
simulate_memmove(arr, arr + 2, 20);
return 0;
}
从模拟实现的代码可以看出与 memcpy 函数的模拟实现一模一样。程序运行的结果如下所示：
与之前的结果一致，那么我们模拟实现的代码是正确的吗？
当将 simulate_memmove(arr, arr + 2, 20) 修改为 simulate_memmove(arr + 2, arr, 20)，再进行编译，结果会是什么？会是1,2,1,2,3,4,5,8,9,10吗？
与我们预期的结果不一样，使用库函数 memmove 来运行这段代码，对比自己实现的结果：
与我们模拟实现的函数的结果不一样，那么表明模拟实现的函数是有误的，到底是哪里出错了呢，又将怎么修改呢？
我们来分析这两段代码：
memmove(arr, arr + 2, 20);
若 src 从前向后拷贝到 dest 中，那么结果如下图所示：
memmove(arr + 2, arr, 20);
若 src 从前向后拷贝到 dest 中，那么结果如下：
很明显与我们的想要的结果不一样，那若 src 从后向前拷贝到 dest 中，结果会是怎样？
src 从后向前拷贝到 dest 中，就能达到我们的目的。
从以上两种情况可以得出，在不同的情况下，拷贝到顺序也不一样。
那么什么时候从前往后，什么时候从后往前呢？下面来分析：
由此我们可以得出一个规律：
我们可以分成两种选择：
- 1,3区域从后向前，2区域从前向后
- 1区域从后向前，2,3区域从前向后
我们可以观察到：
当 dest>src 时，就是从后向前；当 dest<src 时，就是从前向后。
模拟实现 memmove 函数：
#include <stdio.h>
#include <assert.h>
void* simulate_memmove(void* dest, const void* src, int num)
{
assert(dest && src);
void* ret = dest;
//从前向后
if (dest < src)
{
while (num--)
{
*((char*)dest)++ = *((char*)src)++;
}
}
//从后向前
else
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
simulate_memmove(arr + 2, arr, 20);
return 0;
}
实现从前向后拷贝的代码，与 memcpy 函数的一模一样；
实现从后向前拷贝到代码，首先要找到 src 和 dest 末尾的地址，只需要加上 num 即可，并且在 num-- 的同时也实现了 src 和 dest 的移动，要注意的是这里也要强制类型转换。
2.3 memset
memset 链接: link
函数原型：
void * memset ( void * ptr, int value, size_t num );
作用：将一段内存区域设置为指定的值。
要点：
- 以字节为单位设置成想要的内容
- 什么类型都可以
使用 memset 函数编写代码：
#include <string.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
memset(arr, 1, 10);
return 0;
}
以上代码是要将arr中10个字节的内容替换成1
arr中的内容在内存中是这样的：
01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
06 00 00 00 07 00 00 00 08 00 00 00 09 00 00 00
又因为是以字节为单位设置成想要的内容，所以会将10个字节大小的内容替换成1，那么结果为：
01 01 01 01 01 01 01 01 01 01 00 00 04 00 00 00 05 00 00 00
06 00 00 00 07 00 00 00 08 00 00 00 09 00 00 00
那我们在内存中看看是否与我们的推断一致：
确实与我们的推断一致。刚才的是int类型，下面用char类型。【但是我们注意到，memset的第二个参数的类型是int类型，为什么可以传char类型的参数呢？这是因为字符会被看成它相对应ASCII码值】：
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "watergraphically@gmail.com";
memset(arr + 2, '*', 10);
printf("%s", arr);
return 0;
}
运行结果：
有10个字节大小的内容被替换成 ‘*’ 。
2.4 memcmp
memcmp 链接: link
函数原型：
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
作用：用于比较两块内存区域的内容。
要点：
- 比较从ptr1和pter2指针指向的位置开始，向后的num个字节
- 若 ptr1 指针指向的内容的数字的大小或者字符相应的 ASCII 码值的大小大于 ptr2 的，那么就返回大于0的值；若小于，则返回小于0的值；若等于，则返回0
使用 memcmo 函数编写代码：
#include <stdio.h>
#incldue <string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7 };
int arr2[] = { 1,2,3,4,5,6,8,9,11 };
char arr3[] = "watergraphically";
char arr4[] = "watergeographliy";
int ret1 = memcmp(arr1, arr2, 28);
int ret2 = memcmp(arr3, arr4, 7);
if (ret1 > 0)
{
printf("arr1 > arr2\n");
}
else if (ret1 < 0)
{
printf("arr1 < arr2\n");
}
else
{
printf("arr1 == arr2\n");
}
if (ret2 > 0)
{
printf("ret3 > ret4\n");
}
else if (ret2 < 0)
{
printf("ret3 < ret4\n");
}
else
{
printf("ret3 == ret4\n");
}
return 0;
}
3.动态内存函数
使用动态内存函数可以实现动态内存的开辟，让程序员可以自己申请和释放空间；
在使用这些库函数的时候，要引用头文件：stdlib.h
3.1 malloc
malloc 链接: link
函数原型：
void* malloc (size_t size);
要点：
- malloc函数向内存申请一块连续可用的空间，并且返回指向这块空间地址的指针
- 若内存开辟成功，则返回一个指向开辟好空间的指针
- 若开辟失败，则返回一个NUUL指针，所以malloc的返回值一定要做检查
- 返回值的类型为void*类型，故malloc函数并不知道开辟空间的类型，具体在使用时程序员自己决定
使用 malloc 函数：
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟空间
int* p = (int*)malloc(10*sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用空间
int i = 0;
for (i = 0; i < 10; i++)
{
p[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
return 0;
}
3.2 calloc
calloc链接: link
函数原型：
void* calloc (size_t num, size_t size);
要点：
- calloc函数也能用来动态内存分配
- calloc函数可以为num个大小的元素开辟一块空间，并且把空间的每个字节初始化为0
从 malloc 函数和 calloc 函数的要点来看，malloc 和 calloc 函数的区别在于，
calloc 会在返回地址之前把申请的空间的每个字节初始化为0，也可以理解为：calloc = 初始化为0 + malloc。
使用 calloc 函数：
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟内存
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
//使用内存
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
return 0;
}
3.3 realloc
relloc 链接: link
函数原型：
void* realloc (void* ptr, size_t size);
要点：
- realloc可以说是对动态内存函数中的动态进行了诠释，它的出现让动态内存管理更加灵活；
为什么这么说？因为realloc函数可以做到对动态开辟内存大小的调整- 在函数原型中的参数ptr是要调整的内存地址，size是调整后内存空间的大小
- 返回值为调整后的内存起始地址
- realloc函数在调整内存空间时存在两种情况：
（1）原有的空间后有足够大的空间
(2)原有空间之后没有足够大的空间
若是没有足够空间的情况下，realloc函数在调整原内存空间大小的基础上，将原来内存空间的数据移动到新空间中。
使用 realloc 函数：
#include <stdlib.h>
int main()
{
//开辟内存
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用内存
int i = 0;
for (i = 0; i < 10; i++)
{
p[i] = i;
}
//增容
int* tmp = (int*)realloc(p, 10 * sizeof(int));
if (tmp == NULL)
{
perror("realloc");
return 1;
}
p = tmp;
return 0;
}
3.4 free
free 链接: link
函数原型：
void free (void* ptr);
要点：
- free 函数是专门用来作动态内存的释放和回收的
- 若参数 ptr 指向的内存空间不是动态内存开辟的，那 free 函数的行为是未定义的
- 若参数 ptr 是 NULL 指针，则函数什么事都不做
在开辟完内存后，要及时用 free 函数释放我们所向系统申请的内存，避免造成内存泄漏，并且在释放完内存空间后，要将指向被释放的内存的地址的指针赋为 NULL 。
运用 free 函数：
#include <stdlib.h>
int main()
{
//开辟内存
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用内存
int i = 0;
for (i = 0; i < 10; i++)
{
p[i] = i;
}
//释放内存
free(p);
p = NULL;
return 0;
}
扫一扫
4552
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
