【C语言进阶】-- 重点字符串函数内存函数及其模拟实现(strlen,strcmp,strcat...memcpy,memmove)

╰半橙微兮° 2023-09-27 17:55 130阅读 0赞

**目录**

1、strlen

1.1 strlen的模拟实现

2、strcpy

2.1 strcpy的模拟实现

3、strcat

3.1 strcat的模拟实现

4、strcmp

4.1 strcmp的模拟实现

5、strstr

5.1 strstr的模拟实现

6、memcpy

6.1 memcpy的模拟实现

7、memmove

7.1 memmove的模拟实现

--------------------

**前言**

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串 中或者 字符数组中。字符串常量适用于那些对它不做修改的字符串函数。

## 1、strlen ##

> 头文件：\#include <string.h>
> 
> 作用：字符串以 '\\0' 作为结束标志，strlen 函数返回的是在字符串中 '\\0' 前面出现的字符个数（不包含 '\\0'）。

**注意：**

1、参数指向的字符串必须要以 '\\0' 结束。

2、函数的返回值是size\_t，是无符号的（易错）。

**测试：**

#include <stdio.h>
    #include <string.h>
    int main()
    {
    	int len = strlen("abc");
    	printf("%d\n", len);
    	return 0;
    }

运行结果：3

### 1.1 strlen的模拟实现 ###

#include <stdio.h>
    #include <assert.h>
    //计数器实现
    //int my_strlen(const char* str)//我们只是用这个字符串，不修改，因此使用const修饰
    //{
    //	assert(str);
    //
    //	int count = 0;
    //
    //	while (*str != '\0')
    //	{
    //		count++;
    //		str++;
    //	}
    //	return count;
    //}
    //递归实现
    int my_strlen(const char* str)//我们只是用这个字符串，不修改，因此使用const修饰
    {
    	if (*str != '\0')
    		return 1 + my_strlen(str + 1);
    	else
    		return 0;
    }
    int main()
    {
    	char arr[] = "abc";
    	int len = my_strlen(arr);
    	printf("%d\n", len);
    	return 0;
    }

运行结果：3

strlen 的模拟可以有多种方法：

1.计数器（此方式可以做到不创建临时变量计算字符串长度）

2.递归

3.指针 - 指针

我们这里是用的计数器与递归两种方法写的。

## 2、strcpy ##

> 头文件：\#include <string.h>
> 
> 作用：将源字符串中的 '\\0' 之前的字符拷贝到目标空间，包含 '\\0'。

**注意：**

1、源字符串必须要以 '\\0' 结束。

2、会将源字符串中的 '\\0' 拷贝到目标空间。

3、目标空间必须足够大，以确保能存放源字符串。

4、目标空间必须可变（注意：目标字符串必须是有足够空间的，不能是一个常量字符串的指针）。

**测试：**

#include <string.h>
    #include <stdio.h>
    
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[20] = { 0 };
    	strcpy(arr2, arr1)
    	printf("%s\n", arr2);
    	return 0;
    }

结果：abcdef

### 2.1 strcpy的模拟实现 ###

#include <string.h>
    #include <assert.h>
    #include <stdio.h>
    char* my_strcpy(char* dest, const char* src)
    {
    	assert(dest && src);//只要有一个是空指针就报错
    	char* head = dest;
        
    	while (*dest++ = *src++)//这里做到了既拷贝，又能在遇到'\0'停止
    	{
    		;
    	}
    	return head;
    }
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[20] = { 0 };
    
        //my_strcpy(arr2, arr1);
        //printf("%s\n", arr2);
    	printf("%s\n", my_strcpy(arr2, arr1));
    	return 0;
    }

结果：abcdef

## 3、strcat ##

> 头文件：\#include <string.h>
> 
> 作用：将源字符串追加到目标字符串后。
> 
> 自己不能追加自己，这样会陷入死循环。

**注意：**

1、源字符串与目标字符串必须以 '\\0' 结束。  
2、目标空间必须有足够的大，能容纳下源字符串的内容。  
3、目标空间必须可修改（注意：目标字符串必须是有足够空间的，不能是一个常量字符串的指针）。

**测试：**

#include <string.h>
    #include <stdio.h>
    int main()
    {
    	char arr1[20] = "hello ";
    	char arr2[] = "world";
    
    	strcat(arr1, arr2);
    	printf("%s", arr1);
    	return 0;
    }

运行结果：hello world

### 3.1 strcat的模拟实现 ###

#include <assert.h>
    #include <string.h>
    #include <stdio.h>
    char* my_strcat(char* dest, const char* src)
    {
    	assert(dest && src);
    	char* head = dest;
    
    	while (*dest != '\0')
    	{
    		dest++;//调整必须在这写，不能在判断条件里写。因为会走到'\0'后一位
    	}
    	while (*dest++ = *src++)
    	{
    		;
    	}
    	return head;
    }
    int main()
    {
    	char arr1[20] = "hello ";
    	char arr2[] = "world";
    
    	my_strcat(arr1, arr2);
    	printf("%s", arr1);
    	return 0;
    }

运行结果：hello world

## 4、strcmp ##

> 头文件：\#include <string.h>
> 
> 作用：比较两个字符串的大小(注意：这里比的不是字符串的长度，比的是对应位置字符的ASCII码值的大小)。

标准规定：

第一个字符串大于第二个字符串，返回大于 0 的数字

第一个字符串等于第二个字符串，返回 0

第一个字符串小于第二个字符串，返回小于 0 的数字

![f60f73f703cb000a88e73ab7944dd76a.png][]

**测试：**

#include <string.h>
    #include <stdio.h>
    int main()
    {
    	char arr1[] = "abcd";
    	char arr2[] = "abcc";
    
    	printf("%d\n", strcmp(arr1, arr2));//最后一个字符分别是 d与c ，d的ASCII值大于c的ASCII值
    	return 0;
    }

运行结果：大于 0 的数字。

### 4.1 strcmp的模拟实现 ###

#include <assert.h>
    #include <string.h>
    #include <stdio.h>
    int my_strcmp(const char* str1, const char* str2)
    {
    	assert(str1 && str2);
    
    	while (*str1 == *str2)
    	{
            if ('\0' == *str1)
    			return 0;
    		str1++;
    		str2++;
    	}
    	return *str1 - *str2;
    }
    int main()
    {
    	char arr1[] = "abcd";
    	char arr2[] = "abcc";
    
    	int ret = my_strcmp(arr1, arr2);
    	printf("%d\n", ret);
    	return 0;
    }

运行结果：大于 0 的数字。

## 5、strstr ##

> 头文件：\#include <string.h>
> 
> 作用：在目标字符串中查找源字符串，如果找到，则返回目标字符串中第一次包含源字符串之后的所有字符串，若未找到，则返回NULL。

**测试：**

#include <string.h>
    #include <stdio.h>
    
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "cd";
    
    	char* p = strstr(arr1, arr2);
    	if (NULL == p)
    		printf("找不到！\n");
    	else
    		printf("%s\n", p);
    	return 0;
    }

运行结果：cdef。

### 5.1 strstr的模拟实现 ###

#include <assert.h>
    #include <string.h>
    #include <stdio.h>
    
    char* my_strstr(const char* str1, const char* str2)
    {
    	assert(str1 && str2);
    	char* s1 = NULL;
    	char* s2 = NULL;
    	char* cp = (char*)str1;//const修饰的str1直接给会报警告
    	
    	while (*cp)
    	{
    		s1 = cp;
    		s2 = (char*)str2;
    		while (*s1 && *s2 && *s1 == *s2)
    		{
    			s1++;
    			s2++;
    		}
    		if (*s2 == '\0')
    			return cp;
    		cp++;
    	}
    	return NULL;
    }
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "cd";
    
    	char* p = my_strstr(arr1, arr2);
    	if (NULL == p)
    		printf("找不到！\n");
    	else
    		printf("%s\n", p);
    	return 0;
    }

运行结果：cdef。

**注意：我们这里用到的 cp 指针在不断记录每次开始比较的 str1 更新后的位置。**

## 6、memcpy ##

> 头文件：\#include <string.h>
> 
> 作用：函数memcpy从开始的位置开始向后复制num个字节的数据到目标的内存位置。

![e6dc091c8d3b1027c27f0472f7ef47f1.png][]

**注意：**

1、这个函数在遇到 '\\0' 的时候并不会停下来。  
2、如果source和destination有任何的重叠，复制的结果都是未定义的。

**测试：**

#include <string.h>
    #include <stdio.h>
    int main()
    {
    	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int arr2[8] = { 0 };
    	memcpy(arr2, arr1, 20);//拷贝20字节的数据
    
    	for (int i = 0; i < 8; i++)
    	{
    		printf("%d ", arr2[i]);
    	}
    	return 0;
    }

运行结果：1 2 3 4 5 0 0 0

### 6.1 memcpy的模拟实现 ###

#include <assert.h>
    #include <string.h>
    #include <stdio.h>
    //memcpy函数返回的是目标空间的其实地址
    void* my_memcpy(void* dest, const void* src, size_t num)
    {
    	assert(dest && src);
    	void* ret = dest;
    
    	while (num--)
    	{
    		*(char*)dest = *(char*)src;
    		dest = (char*)dest+1;//dest不能直接+-操作，得强转。强转是临时的，所以先强转再赋值回去
    		src = (char*)src+1;
    	}
    
    	return ret;
    }
    int main()
    {
    	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int arr2[8] = { 0 };
    	my_memcpy(arr2, arr1, 20);
    
    	for (int i = 0; i < 8; i++)
    	{
    		printf("%d ", arr2[i]);
    	}
    	return 0;
    }

运行结果：1 2 3 4 5 0 0 0

## 7、memmove ##

> 头文件：\#include <string.h>
> 
> 作用：与memcpy相似。和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。如果源空间和目标空间出现重叠，就得使用memmove函数处理。

**测试：**

#include <string.h>
    #include <stdio.h>
    int main()
    {
    	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    	memmove(arr1+2, arr1, 20);
    
    	for (int i = 0; i < sizeof(arr1)/sizeof(arr1[0]); i++)
    	{
    		printf("%d ", arr1[i]);
    	}
    	return 0;
    }

运行结果：1 2 1 2 3 4 5 6 7 8 9 10

### 7.1 memmove的模拟实现 ###

#include <assert.h>
    #include <string.h>
    #include <stdio.h>
    void* my_memmove(void* dest, const void* src, size_t num)
    {
    	assert(dest && src);
    	char* ret = dest;
    
    	//目标在前源头在后，前->后
    	if (dest < src)
    	{
    		while (num--)
    		{
    			*(char*)dest = *(char*)src;
    			dest = (char*)dest + 1;
    			src = (char*)src + 1;
    		}
    	}
    	//其他情况，后->前
    	else
    	{
    		while (num--)
    		{
    			*((char*)dest + num) = *((char*)src + num);
    		}
    	}
    	return ret;
    }
    int main()
    {
    	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    	my_memmove(arr1+2, arr1, 20);
    
    	for (int i = 0; i < sizeof(arr1)/sizeof(arr1[0]); i++)
    	{
    		printf("%d ", arr1[i]);
    	}
    	return 0;
    }

运行结果：1 2 1 2 3 4 5 6 7 8 9 10

**结论：**

memmove可以操作可重叠空间，如果不重叠拷贝内存，就是用memcpy，存在重叠就使用memmove。

[f60f73f703cb000a88e73ab7944dd76a.png]: https://img-blog.csdnimg.cn/img_convert/f60f73f703cb000a88e73ab7944dd76a.png
[e6dc091c8d3b1027c27f0472f7ef47f1.png]: https://img-blog.csdnimg.cn/img_convert/e6dc091c8d3b1027c27f0472f7ef47f1.png