03-C语言进阶——模拟实现字符串操作函数

╰半橙微兮° 2022-12-24 01:51 242阅读 0赞

### 模拟实现字符串操作函数 ###

*  1.模拟实现strcat
 *  2.模拟实现strcmp
 *  3.模拟实现strcpy
 *  4.模拟实现strlen
 *   *  4.1 计数器方式
     *  4.2 不创建临时变量计数器(递归)
     *  4.3 指针-指针的方式
 *  5.模拟实现strstr

字符串操作函数的细节参看上一篇博客  
[03-C语言进阶——字符函数和字符串函数][03-C]  
Github源码下载地址：  
[https://github.com/Kyrie-leon/C\_Practice/tree/main/day7][https_github.com_Kyrie-leon_C_Practice_tree_main_day7]

# 1.模拟实现strcat #

//1.模拟实现strcat
    char * my_strcat(char *destination, const char * source)
    {
        
    	//首先定义一个指针指向destination起始地址，便于操作完成后返回原始字符串的首地址
    	char *dest = destination;
    	//判断两个字符串是否为空
    	assert(destination != NULL);
    	assert(source != NULL);
    
    	//第一轮循环让destination指向\0
    	while (*destination)
    	{
        
    		destination++;
    	}
    	//第二轮循环将source内容追加给destination
    	while ((*destination++ = *source++))
    	{
        
    		;
    	}
    	//返回dest起始地址
    	return dest;
    }

# 2.模拟实现strcmp #

//2.模拟实现strcmp
    int my_strcmp(const char *str1, const char *str2)
    {
        
    	//判断指针合法性
    	assert(str1 != NULL);
    	assert(str2 != NULL);
    	//两个字符串分别从第一个字符进行比较
    	while ( (*str1++) && (*str2++) )
    	{
        
    
    		if (*str1  > *str2)
    		{
        
    			return 1;
    		}
    		else if (*str1  < *str2)
    		{
        
    			return -1;
    		}
    		else
    		{
        
    			continue;
    		}
    	}
    	return 0;
    }

# 3.模拟实现strcpy #

//3.模拟实现strcpy
    char * my_strcpy(char * destination, const char *source)
    {
        
    	//判断指针合法性
    	assert(destination!=NULL);
    	assert(source!=NULL);
    
    	//先定义一个指针指向destination便于复制后返回首地址
    	char *ret = destination;
    	//将第二个字符串的每个字符依次复制到destination中
    	while ((*destination++ = *source++))
    	{
        
    		;
    	}
    	return ret;
    }

# 4.模拟实现strlen #

## 4.1 计数器方式 ##

//4.1计数器
    int my_strlen(const char *str)
    {
        
    	//定义一个计数器
    	int count = 0;
    	//循环扫描字符串直到'/0'
    	while (*str)
    	{
        
    		//计数器+1，字符串指针+1
    		count++;
    		str++;
    	}
    
    	return count;
    
    }

## 4.2 不创建临时变量计数器(递归) ##

//4.2不创建临时变量计数器，采用递归的方式
    int my_strlen2(const char *str)
    {
        
    
    	if (*str == '\0')
    	{
        
    		return 0;
    	}
    	else
    	{
        
    		return 1 + my_strlen2(str + 1);
    	}
    }

## 4.3 指针-指针的方式 ##

思路：采用双指针的方法  
**首先第一个指针指向字符串首地址（也就是传入形参字符串变量的首地址），第二个指针用于遍历到字符串结束，其次第二个指针值减去第一个指针值即为字符串长度**  
举个栗子：假设字符串“abcd”，a的起始地址为1，第一个指针s指向a，第二个指针遍历结束后指向d后面的‘\\0’，即s=1，p=5，p-s=4,就是字符串的长度。  
注意：由于使用双指针，因此定义形参**不能使用const**  
原因：形参const char \* str是一个**常量指针**，再定义一个**指针变量**char \*p，这时候char \*p=str就是错误的，因为str是常量指针，如果赋值给p就是让p的类型也变为常量指针，这种做法是错误的，**类型不匹配**。

//4.3 双指针
    //a.第一个指针指向字符串首地址，第二个指针遍历到字符串结束
    //b.第二个指针减去第一个指针即为字符串长度
    //注意：由于使用双指针，因此形参不能使用const
    int my_strlen3(char *str)
    {
        
    	//定义指针p用于遍历字符串
    	char *p = str;
    	//遍历字符串str
    	while (*p)
    	{
        
    		p++;
    	}
    
    	return p - str;
    }

# 5.模拟实现strstr #

strstr的优化可以参考以下博客  
[KMP算法][KMP]

//5.模拟实现strstr
    const char *my_strstr(const char* str, const char* sub_str)
    {
        
    	//判断指针合法性
    	assert(str != NULL);
    	assert(sub_str != NULL);
    
    	//双层循环实现字符串子串查找
    	//外层循环控制str起始位置，一直向后移动直到\0
    	while (*str)
    	{
        
    		//定义两个指针变量方便返回字符串起始地址
    		const char *p = str;
    		const char *q = sub_str;
    		//内层循环用于判断str字符串是否包含sub_str子串
    		while ((*p == *q)&&*p&&*q)
    		{
        
    
    			p++;
    			q++;
    		}
    		//如果sub_str扫描到\0说明在str中找到子串，返回str中的子串首字符的起始地址
    		if (*q == '\0')
    		{
        
    			return str;
    		}
    		str++;
    	}
    
    
    	return NULL;
    
    }

[03-C]: https://blog.csdn.net/qq_40076022/article/details/109893212
[https_github.com_Kyrie-leon_C_Practice_tree_main_day7]: https://github.com/Kyrie-leon/C_Practice/tree/main/day7
[KMP]: http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html