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

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

🎈🎈养成好习惯,先赞后看哦~🎈🎈

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

1. 简介

除了字符函数和字符串函数,<string.h>中还有一类内存操作函数,如memset(),memcmp()等函数,他们在功能和某些字符串函数很像,但作用范围更广,除了作用于字符串外,还可以作用于int ,double等内置类型,但因为是以字节为单位改变,所以限制也很大。下面就让我们来看看吧

2. memset()函数

2.1 用法

  1. 声明:void *memset(void *str, int c, size_t n)

    • str -- 指向要填充的内存块。
    • c -- 要被设置的值。该值以 int 形式传递,但是函数在填充内存块时是使用该值的无符号字符形式。
    • n -- 要被设置为该值的字符数。
  2. 作用:复制字符 c(一个无符号字符)到参数 str 所指向的字符串的前 n 个字符。

  3. 返回值:该值返回一个指向存储区 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 用法

  1. 声明:int memcmp(const void *str1, const void *str2, size_t n)
  • str1 -- 指向内存块的指针。
  • str2 -- 指向内存块的指针。
  • n -- 要被比较的字节数。
  1. 作用:把存储区 str1 和存储区 str2 的前 n 个字节进行比较。

  2. 返回值:

  • 如果返回值 < 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 == '\0')
		{
			return 0;
		}
		p1++;
		p2++;
	}
	return *p1 - *p2;
}
  • memcmp()函数也是以字节比较,所以限制也很大

3.4 strcmp,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 -- 要被复制的字节数。
  1. 作用:从存储区 str2 复制 n 个字节到存储区 str1

  2. 返回值:该函数返回一个指向目标存储区 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之间的区别

  1. memcpy是从源存储空间拷贝到目标存储空间;而strcpy,strncpy是从源字符串拷贝到目标字符串
  2. 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 -- 要被复制的字节数。
  1. 作用:从 str2 复制 n 个字符到 str1,但是在重叠内存块这方面,memmove() 是比 memcpy() 更安全的方法。如果目标区域和源区域有重叠的话,memmove() 能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中,复制后源区域的内容会被更改。如果目标区域与源区域没有重叠,则和 memcpy() 函数功能相同。

  2. 返回值:该函数返回一个指向目标存储区 str1 的指针。

5.2 实例

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

​ 🎈🎈完结撒花🎈🎈

​ 🎈🎈完结撒花🎈🎈

本文由博客一文多发平台 OpenWrite 发布!

热门相关:奈何老公太宠我   惊艳人生   资本大唐   抗战老兵之不死传奇   最牛兵王