【C语言】——字符串函数的使用与模拟实现（上）

【C语言】——字符串函数

- 前言
- 一、 $s t r l e n$ 函数
- - 1.1、函数功能
  - 1.2、函数的使用
  - 1.3、函数的模拟实现
  - - （1）计数法
    - （2）递归法
    - （3）指针 - 指针
- 二、 $s t rc p y$ 函数
- - 2.1、函数功能
  - 2.2、函数的使用
  - 2.3、函数的模拟实现
- 三、 $s t rc n t$ 函数
- - 3.1、函数功能
  - 3.2、函数的使用
  - 3.3、函数的模拟实现
- 四、 $s t rc m p$ 函数
- - 4.1、函数功能
  - 4.2、函数的使用
  - 4.3、函数的模拟实现

前言

在我们学习 C语言 的过程中，对库函数的使用是必不可少的。其中，相信大家最熟悉的就是 $< s t d i o . h >$ 中的 $p r in t$ 和 $sc an f$ 函数了吧。
但是今天，我们不讲他们（太难了,呜呜呜），今天我们来讲与字符串相关的函数，也就是 < $s t r in g . h$ > 中的系列函数。
要知道，除了输入输出，我们对字符串的操作也是必不可少的，那么了解字符串相关的函数的重要性就不言而喻了，让我们开启接下来的学习吧。

一、 $s t r l e n$ 函数

1.1、函数功能

函数声明：size_t strlen(const char* str);
$s t r l e n$ 函数用于求字符串的长度，使用时必须包含头文件
基本原理是：从传递的指针变量开始，从前往后计算字符的个数，直到遇到 ‘\0’ 停止（ ‘\0’ 本身不计算），因此参数指向的字符串必须要以 ‘\0’ 结束。
返回值为字符串的长度，注意：返回值是 size_t 类型（易错）

1.2、函数的使用

$s t r l e n$ 函数的使用非常简单，这里就不过多介绍了，大家直接看代码

#include<string.h>
#include<stdio.h>

int main()
{
	char* a = "abcdef";
	int sz = strlen(a);
	printf("%d\n", sz);
	return 0;
}

运行结果：
在这里插入图片描述

1.3、函数的模拟实现

（1）计数法

首先，我们要知道指针存储的是字符串首字符的地址。该方法的思路是将传入的字符指针不断往后移，每移一次计数器加一，当指针指向 ‘\0’ 时，结束计数，并返回计数的值。

代码实现：

#include<assert.h>

size_t my_strlen(const char* str)
{
	//assert断言，防止传入空指针
	assert(str);
	int count = 0;
	
	//判断条件：指针指向的字符是否为0（'\0'）
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

（2）递归法

有没有办法在求出字符串长度的同时不创建临时变量呢？我们可以试试递归的思想

那用递归的思想来计算字符串的长度，解题思路是什么呢？

我们不妨想：比如要计算 “ $ab c$ ” 的长度，是不是可以将他看成 $1 +$ “ $b c$ ” 的长度，而 “ $b c$ ” 的长度，又可以将他看成是 1+“ $c$ ” 的长度。

怎么样，你想到了吗？

代码实现：

#include<assert.h>
size_t my_strlen(const char* str)
{
	assert(str);
	
	if (!*str)//逻辑取反，当*str为0时为假，逻辑取反为真
		return 0;
		
	else
		return 1 + my_strlen(str + 1);
}

（3）指针 - 指针

还有一个方法就是指针 - 指针，首先我们知道，指针 - 指针，代表的是两指针之间的元素个数（详情请看：【C语言】—— 指针一：初识指针（上））

我们可以利用这个思想，创建一个指针变量，让他不断移动，直至指向 '\0' ，再通过两个指针相减，得到字符串的长度。

代码实现：

#include<assert.h>

size_t my_strlen(const char* str)
{
	assert(str);
	char* p = str;

	while (*p++)
	{
		;
	}

	return p - str - 1;
}

代码解析：

while (*arr++);可能这句代码有些小伙伴不太了解，没关系，我们一起来看看

*arr++：这里有两个操作符： $*$ 和后置++。虽然后置++ 的优先级比 $*$ 高，但是他是后置的，所以先进行解引用
解引用完成后，结果为真则进入循环，为假退出循环
无论 * $a rr$ 结果为真为假，接下来 $a rr$ 进行自增操作。注：++ 操作数是 $a rr$ ，而非 * $a rr$ ，如果想让 * $a rr$ 自增，应写为：*(arr)++
因为循环不需要再执行任何操作，因此放置空语句
return arr - str - 1;因为前面循环的判断条件不论真假， $a rr$ 都会自增，即指针指向 ‘\0’ 后依然会往后移动一位，此时如果直接arr - str，则把 ‘\0’ 也计算在内，而 $s t r l e n$ 是不计算
‘\0’ 的，因此最终要 - 1

二、 $s t rc p y$ 函数

2.1、函数功能

功能： $s t rc p y$ 函数实现的是字符串的拷贝，将 $so u rce$ 指针指向的字符串(源字符串) 拷贝到 $d es t ina t i o n$ 指针指向的字符串(目标字符串) 中。

源字符串必须以 ‘\0’ 结束
该函数会将 ‘\0’ 拷贝到目标空间
目标空间必须足够大，以确保能存放源字符串，否则会出现越界访问的情况
目标空间必须是可修改的
函数的返回值为指向目标空间的指针

可能会有小伙伴说，字符串的拷贝哪有那么麻烦，还要用函数，不就是直接赋值吗？

int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = { 0 };
	arr2 = arr1;
	return 0;
}

这样可以吗？当然是不可以的。为什么呢？

别忘了 $a rr 1$ 和 $a rr 2$ 是两个数组首元素的地址，地址是一个常量值并不是变量，就像：5 = 3;，可以把 3 赋值给 5 吗？肯定是不行的。因此字符串的赋值并没有那么简单哦。

2.2、函数的使用

#include<stdio.h>
#include<string.h>

int main()
{
	char src[20] = "good good study";
	char dest[40] = { 0 };
	char* s = strcpy(dest, src);
	printf("%s\n", s);
	return 0;
}

运行结果：
在这里插入图片描述

2.3、函数的模拟实现

要模拟实现 $s t rc p y$ 函数，其实思路很简单，只需将字符串的中的每个字符依次拷贝过去即可，当拷贝完源字符串的 '\0' ，拷贝结束。

我们来尝试写下代码：

char* my_strcpy(char* dest, const char* src)
{
    //要返回目标空间的地址
	char* ret = dest;
	
	//不能传入空指针
	assert(dest != NULL);
	assert(src != NULL);
	
	//拷贝'\0'之前的内容
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	//拷贝'\0'
	*dest = *src;
	return ret;
}

上述代码基本上是没问题的，但大家发现没有，该代码有点繁琐：*dest = *src;就出现了两次，有什么改进方法呢？我们来看下面的代码：

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);

	while (*dest++ = *src++)
	{
		;
	}

	return ret;
}

这里，我们重点来讲解一下while (*dest++ = *src++);语句

虽然两个后置++ 的优先级最高，但是因为是后置：先使用，后++
首先执行的是两个解引用操作
解引用完成后，将 * $src$ 的值赋给 * $d es t$
赋值完成后进行循环的条件判断，* $d es t$ == ‘\0’ 则退出循环，否则执行循环
最后 $d se t$ 和 $src$ 两个指针执行++，即自增

怎么样，这段代码是不是很巧妙呢

三、 $s t rc n t$ 函数

3.1、函数功能

功能： $s t rc a t$ 函数的功能是实现字符创的追加，将源字符串的内容追加到目标字符串的结尾。

源字符串必须以 ‘\0’ 结束
追加会将目标空间原来的 ‘\0’ 覆盖
目标字符串结尾也要有 ‘\0’，否则不知从哪开始追加
目标空间必须足够大，能容下追加源字符串之后的内容
目标空间必须可修改
返回的是目标空间的起始地址
目标空间与源字符串不能重叠，即不能自己给自己追加

3.2、函数的使用

#include<stdio.h>
#include<string.h>
int main()
{
	char src[20] = "day day up!";
	char dest[40] = "good good study! ";
	char* s = strcat(dest, src);
	printf("%s\n", s);
	return 0;
}

运行结果：
在这里插入图片描述

3.3、函数的模拟实现

$s t rc a t$ 函数怎么模拟实现呢？大家不妨想一想，追加不也是一种拷贝吗，它的实现方法与 $s t rc p y$ 函数的实现很像，只是 $s t rc p y$ 是从头开始拷贝，而 $s t rc a t$ 是从目标字符串的末尾开始拷贝。

参考代码：

char* mu_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
    
    //找到目标空间的末尾
	while (*dest)
	{
		dest++;
	}
	
    //进行追加（拷贝）
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

四、 $s t rc m p$ 函数

4.1、函数功能

功能：比较两个字符串的大小
$s t r 1$ > $s t r 2$ ，返回 $> 0$ 的数字
$s t r 1$ = $s t r 2$ ，返回 $0$
$s t r 1$ < $s t r 2$ ，返回 $< 0$ 的数字

比较方式：

$s t rc m p$ 函数比较字符串中对应位置上两个字符的 ASCII码值的大小来比较两个字符串大小

$s t rc m p$ 会逐一比较两个字符串中相应位置的各个字符，从第一个字符开始比较，若相等，则比较下位字符
直至比出大小或遇到其中一个字符串的 '\0'，比较结束，先遇到'\0'的字符串较小，可以理解成 ‘\0’ 的ASCII码值为 0，任何字符的 ASCII码值都比它大。

4.2、函数的使用

#inlcude<stdio.h>
int main()
{
	char str1[] = "abcd";
	char str2[] = "Abcd";
	char str3[] = "abcd";
	char str4[] = "bbcd";
	int ret1 = strcmp(str1, str2);//比较str1与str2
	int ret2 = strcmp(str1, str3);//比较str1与str3
	int ret3 = strcmp(str1, str4);//比较str1与str4
	printf("%d %d %d\n", ret1, ret2, ret3);
	return 0;
}

运行结果：
在这里插入图片描述

4.3、函数的模拟实现

int my_strcmp(const char* str1, const char* str2)
{
    //接下来要对指针进行解引用，因此不能传入空指针
	assert(str1 && str2);
    
    //相同位上两个字符相等，进入循环
	while (*str1 == *str2)
	{
	
	    //当两个字符都为'\0'时，也进入了循环，遇到'\0'表示字符串结束
	    //因为相等才能进入循环，判断语句因此只用写一个
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
        str2++;
	}
	
    //不相等，返回两个字符的ASCII码的差值
	return *str1 - *str2;
}