掌握字符与字符串：C语言中的神奇函数解析(三）-六虎

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

养成好习惯，先赞后看哦~

所属专栏：C言语学习
贝蒂的主页：Betty‘s blog

1. 简介

除了字符函数和字符串函数，<string.h>中还有一类内存操作函数，如memset()，memcmp()等函数，他们在功能和某些字符串函数很像，但效果规模更广，除了效果于字符串外，还可以效果于int ，double等内置类型，但由于是以字节为单位改动，所以约束也很大。下面就让咱们来看看吧

2. memset()函数

2.1 用法

声明：void *memset(void *str, int c, size_t n)

str — 指向要填充的内存块。

c — 要被设置的值。该值以 int 方式传递，可是函数在填充内存块时是使用该值的无符号字符方式。

n — 要被设置为该值的字符数。

效果：仿制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。

回来值：该值回来一个指向存储区 str 的指针。

memset()函数常用于初始化

2.2 实例

#include <stdio.h>
#include <string.h>
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 <string.h>
#include<assert.h>
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;
}

3. memcmp()函数

3.1 用法

声明：int memcmp(const void *str1, const void *str2, size_t n)

str1 — 指向内存块的指针。

str2 — 指向内存块的指针。

n — 要被比较的字节数。

效果：把存储区 str1 和存储区 str2 的前 n 个字节进行比较。

回来值：

假如回来值 < 0，则表明 str1 小于 str2。

假如回来值 > 0，则表明 str1 大于 str2。

假如回来值 = 0，则表明 str1 等于 str2。

3.2 实例

#include <stdio.h>
#include <string.h>
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<stdio.h>
#include<assert.h>
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 == '')
		{
			return 0;
		}
		p1  ;
		p2  ;
	}
	return *p1 - *p2;
}

memcmp()函数也是以字节比较，所以约束也很大

3.4 strcmp，strncmp，memcmp之间的差异

memcmp是比较两个存储空间的前n个字节，即使字符串现已完毕，依然要比较剩余的空间，直到比较完n个字节。

strcmp比较的是两个字符串，任一字符串完毕，则比较完毕。

strncmp在strcmp的基础上添加比较个数，其完毕条件包括任一字符串完毕和比较完n个字节。

strcmp比较的字符串，而memcmp比较的是内存块，strcmp需求时刻查看是否遇到了字符串完毕的字符，而memcmp则彻底不必担心这个问题，所以memcmp的效率要高于strcmp

4. memcpy()函数

4.1 用法

声明：void *memcpy(void *str1, const void *str2, size_t n)

str1 — 指向用于存储仿制内容的方针数组，类型强制转化为 void* 指针。

str2 — 指向要仿制的数据源，类型强制转化为 void* 指针。

n — 要被仿制的字节数。

效果：从存储区 str2 仿制 n 个字节到存储区 str1。

回来值：该函数回来一个指向方针存储区 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.4 strcpy，strncpy，memcpy之间的差异

memcpy是从源存储空间仿制到方针存储空间；而strcpy，strncpy是从源字符串仿制到方针字符串。

memcpy仿制时是按照参数n作为完毕标志的，即仿制n个字节就完毕；strncpy是以参数n或者**‘’**为完毕标志；strcpy是判断‘’为完毕标志。

5. memmove()函数

5.1 用法

咱们上面说过memcpy()无法对自己进行仿制，那有没有能对自己仿制的函数呢，当然有啦，就是咱们的memmove()函数。

声明：void *memmove(void *str1, const void *str2, size_t n)

str1 — 指向用于存储仿制内容的方针数组，类型强制转化为 void* 指针。

str2 — 指向要仿制的数据源，类型强制转化为 void* 指针。

n — 要被仿制的字节数。

效果：从 str2 仿制 n 个字符到 str1，可是在堆叠内存块这方面，memmove() 是比 memcpy() 更安全的办法。假如方针区域和源区域有堆叠的话，memmove() 可以保证源串在被掩盖之前将堆叠区域的字节仿制到方针区域中，仿制后源区域的内容会被更改。假如方针区域与源区域没有堆叠，则和 memcpy() 函数功能相同。

回来值：该函数回来一个指向方针存储区 str1 的指针。

5.2 实例

#include <stdio.h>
#include <string.h>
int main() 
{
    char str[] = "Hello, World!";
    printf("Original string: %sn", str);
    // 将字符串前6个字符移动到字符串的结尾
    memmove(str, str   7, 6);
    printf("Modified string: %sn", 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);

假定咱们从3的方位开端仿制，3-1,4-2,5-3，仿制成功。
假定咱们从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);

假定咱们从3的方位开端仿制，3-5,4-6,3-7，仿制失利。
假如咱们从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);

假定从6开端仿制，6-2,7-3,8-4，仿制成功。
假定从8开端仿制，8-4,7-3,6-2，仿制成功。

假定从2开端仿制，2-6,3-7,4-9，仿制成功。
假定从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;
}

结束撒花

掌握字符与字符串：C语言中的神奇函数解析(三）