贝蒂详解＜string.h＞（下）
✨✨欢迎大家来到贝蒂大讲堂✨✨
养成好习惯，先赞后看哦~
所属专栏：C语言学习
贝蒂的主页：Betty‘s blog
目录
1. 简介
2. memset()函数
2.1用法
2.2实例
2.3 实现memset()
3. memcmp()函数
3.1用法
3.2 实例
3.3 实现memcmp()
3.4strcmp，strncmp，memcmp之间的区别
4. memcpy()函数
4.1用法
4.2 实例
4.3实现memcpy()
4.4strcpy，strncpy，memcpy之间的区别
5. memmove()函数
5.1用法
5.2实例
5.3实现memmove()
1. 简介
除了字符函数和字符串函数，
2. memset()函数
2.1用法
1. 声明：void *memset(void *str, int c, size_t n)
- str -- 指向要填充的内存块。
- c -- 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
- n -- 要被设置为该值的字符数。
2. 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
3. 返回值：该值返回一个指向存储区 str 的指针。
2.2实例
#include
#include
int main()
{
char str[] = "hello world";
memset(str, 'x', 6);//以字节为单位
printf(str);
return 0;
} 输出结果：xxxxxxworld
int main()
{
int arr[4] = { 1,2,3,4 };
memset(arr, 1, sizeof(arr));
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d ", arr[i]);
}
return 0;
}输出结果：16843009 16843009 16843009 16843009
贝蒂说：“虽然memset可以作用于int，float等类型，但是memset设置是以字节为单位，容易造成不符合我们预期的情况哦~”
2.3 实现memset()
思路：memset()函数和strcpy()函数有点像，都是替换，但是内在实现也有区别，因为memset()函数还可以用于不同数据类型，所以要先强制类型为(char*)，再以字节为单位替换。
代码实现：
#include
#include
void* my_memset(void*str, int c, size_t n)
{
assert(str);//防止str为空指针
char* tmp= (char*)str;//以字节为单位改变
while (n--)
{
*tmp = c;
tmp++;
}
return str;
}
int main()
{
char str[] = "hello world";
my_memset(str, 'x', 6);//以字节为单位
printf(str);
return 0;
} 贝蒂说：“memset()函数常用于初始化哦~”
3. memcmp()函数
3.1用法
1. 声明：int memcmp(const void *str1, const void *str2, size_t n)
- str1 -- 指向内存块的指针。
- str2 -- 指向内存块的指针。
- n -- 要被比较的字节数。
2. 作用：把存储区 str1 和存储区 str2 的前 n 个字节进行比较。
3. 返回值：
- 如果返回值 < 0，则表示 str1 小于 str2。
- 如果返回值 > 0，则表示 str1 大于 str2。
- 如果返回值 = 0，则表示 str1 等于 str2。
3.2 实例
#include
#include
int main()
{
char str1[] = "Hello, World!";
char str2[] = "Hello, World!";
char str3[] = "Hello, Betty!";
// 比较相同的字符串
if (memcmp(str1, str2, strlen(str1)) == 0)
{
printf("str1 和 str2 相同。\n");
}
// 比较不同的字符串
if (memcmp(str1, str3, strlen(str1)) != 0)
{
printf("str1 和 str3 不同。\n");
}
return 0;
} 输出：
str1 和 str2 相同。
str1 和 str3 不同。
3.3 实现memcmp()
思路：总体思路与strncmp差不多，只是也需要先强制类型转换
#include
#include
int my_memcmp(const void* str1, const void* str2, size_t n)
{
assert(str1 && str2);//
char* p1 = (char*)str1;
char* p2 = (char*)str2;
while (n--&&(*p1==*p2))
{
if (*p1 == '\0')
{
return 0;
}
p1++;
p2++;
}
return *p1 - *p2;
} 贝蒂说：“memcmp()函数也是以字节比较，所以限制也很大哦~”
3.4strcmp，strncmp，memcmp之间的区别
- memcmp是比较两个存储空间的前n个字节，即使字符串已经结束，仍然要比较剩余的空间，直到比较完n个字节。
- strcmp比较的是两个字符串，任一字符串结束，则比较结束。
- strncmp在strcmp的基础上增加比较个数，其结束条件包括任一字符串结束和比较完n个字节。
- strcmp比较的字符串，而memcmp比较的是内存块，strcmp需要时刻检查是否遇到了字符串结束的 /0 字符，而memcmp则完全不用担心这个问题，所以memcmp的效率要高于strcmp
4. memcpy()函数
4.1用法
1. 声明：void *memcpy(void *str1, const void *str2, size_t n)
- str1 -- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
- str2 -- 指向要复制的数据源，类型强制转换为 void* 指针。
- n -- 要被复制的字节数。
2. 作用：从存储区 str2 复制 n 个字节到存储区 str1。
3. 返回值：该函数返回一个指向目标存储区 str1 的指针。
4.2 实例
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
4.3实现memcpy()
思路：自然也是和strcpy()差不多啦，嘻嘻
void* my_memcpy(void* dest, const void* src, size_t n)
{
assert(dest && src);//防止空指针
void* ret = dest;
while (n--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}贝蒂说：“因为memcpy()函数实现机制，所以不能自己对自己进行拷贝哦~”
4.4strcpy，strncpy，memcpy之间的区别
- memcpy是从源存储空间拷贝到目标存储空间；而strcpy，strncpy是从源字符串拷贝到目标字符串。
- memcpy拷贝时是按照参数n作为结束标志的，即拷贝n个字节就结束；strncpy是以参数n或者‘\0’为结束标志；strcpy是判断‘\0’为结束标志。
5. memmove()函数
5.1用法
我们上面说过memcpy()无法对自己进行拷贝，那有没有能对自己拷贝的函数呢，当然有啦，就是我们的memmove()函数。
1. 声明：void *memmove(void *str1, const void *str2, size_t n)
- str1 -- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
- str2 -- 指向要复制的数据源，类型强制转换为 void* 指针。
- n -- 要被复制的字节数。
2. 作用：从 str2 复制 n 个字符到 str1，但是在重叠内存块这方面，memmove() 是比 memcpy() 更安全的方法。如果目标区域和源区域有重叠的话，memmove() 能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，复制后源区域的内容会被更改。如果目标区域与源区域没有重叠，则和 memcpy() 函数功能相同。
3. 返回值：该函数返回一个指向目标存储区 str1 的指针。
5.2实例
#include
#include
int main()
{
char str[] = "Hello, World!";
printf("Original string: %s\n", str);
// 将字符串前6个字符移动到字符串的末尾
memmove(str, str + 7, 6);
printf("Modified string: %s\n", str);
return 0;
} 输出结果：
Original string: Hello, World!
Modified string: World! World!
5.3实现memmove()
分析如下：
情况1：
//假设需要拷贝以下场景
int arr1[9] = { 1,2,3,4,5,6,7,8,9 };
my_memmove(arr1, arr1 + 2, 12);
1. 假设我们从3的位置开始拷贝，3-1,4-2,5-3，拷贝成功。
2. 假设我们从5的位置开始拷贝，5-3,4-2,5-1，拷贝失败。
情况2：
//假设我们要拷贝的情况如下
int arr1[9] = { 1,2,3,4,5,6,7,8,9 };
my_memmove(arr1+4, arr1 + 2, 12);
1. 假设我们从3的位置开始拷贝，3-5,4-6,3-7，拷贝失败。
2. 如果我们从5的位置开始拷贝，:5-7,4-6,3-5，拷贝成功。
情况3：
int arr1[9] = { 1,2,3,4,5,6,7,8,9 };
my_memmove(arr1+1, arr1 + 5, 12);
my_memmove(arr1 + 5, arr1 + 1, 12);
1. 假设从6开始拷贝，6-2,7-3,8-4，拷贝成功。
2. 假设从8开始拷贝，8-4,7-3,6-2，拷贝成功。
1. 假设从2开始拷贝，2-6,3-7,4-9，拷贝成功。
2. 假设从4开始拷贝，4-8,3-7,2-6，拷贝成功。
总结：如果dest字符串在src的字符左边，则从首元素拷贝。如果dest字符串在src右边，则从末尾元素开始拷贝。
代码实现:
void* my_memmove(void* dest, const void* src, size_t n)
{
assert(dest && src);//防止空指针
void* ret = dest;
if (dest <= src)//dest在src左侧
{
while (n--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else//dest在src的右侧
{
dest = (char*)dest + n - 1;//指向末尾
src = (char*)src + n - 1;//指向末尾
while (n--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest - 1;
src = (char*)src - 1;
}
}
return ret;
}完结撒花
完结撒花