C语言中常用的字符串处理函数（strlen、strcpy、strcat、strcmp）

写在前面

本篇文章介绍了C语言中常用的字符串处理函数，包括strlen、strcpy、strcat和strcmp。文章中，对这几个函数进行了详细的解释和示例演示，并进行了模拟实现。

1. strlen

1.1 函数介绍

函数原型：

size_t strlen ( const char * str );
1

• str：要计算长度的字符串的指针。

strlen函数是一个用于计算字符串长度的函数，它从指定的字符串起始位置开始，逐个字符地计算，直到遇到字符串结尾的 \0 为止。它返回的是字符串中\0之前的字符个数，不包括\0。
关于strlen需要注意以下几点：

• 参数指向的字符串必须要以 \0结束，否则strlen求得的结果是未知的。
• 注意函数的返回值为size_t，是无符号的（ 易错）。

以下代码，展示了如何使用 strlen 函数来计算字符串的长度：

#include 
#include 

int main() {
    const char* str = "Hello World!";
    size_t len = strlen(str);
    
    printf("字符串长度：%d\n", len);
    return 0;
}
1
2
3
4
5
6
7
8
9
10

1.2 模拟实现

strlen函数的模拟实现(3种方法)：

1. 递归求字符串长度。

#include 
#include 

size_t my_strlen(const char* str)
{
	assert(str);
	if (*str == '\0')
	{
		return 0;
	}
	return 1 + my_strlen(str+1);	
}

int main() {
    const char* str = "Hello World!";
    size_t len = my_strlen(str);
    
    printf("字符串长度：%d\n", len);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2. 计数器方法求字符串长度。

#include 
#include 

size_t my_strlen(const char* str)
{
	assert(str);
	size_t count = 0;
	while (*str++)
	{
		count++;
	}
	return count;
}

int main() {
    const char* str = "Hello World!";
    size_t len = my_strlen(str);
    
    printf("字符串长度：%d\n", len);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3. 指针 - 指针求字符串长度。

#include 
#include 

size_t my_strlen(const char* str)
{
	assert(str);
	const char* _str = str;
	while (*str)
	{
		str++;
	}
	return str - _str;
}

int main() {
    const char* str = "Hello World!";
    size_t len = my_strlen(str);
    
    printf("字符串长度：%d\n", len);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. strcpy

2.1 函数介绍

函数原型：

char * strcpy ( char * destination, const char * source );
1

• destination：目标字符串的指针，即将源字符串的内容复制到这个字符串中。
• source：源字符串的指针，即要复制的字符串。

strcpy是一个用于完成字符串拷贝的函数，函数将源字符串的内容复制到目标字符串中，直到遇到源字符串的结尾的 \0 为止。复制完成后，函数返回目标字符串的起始地址。
关于strcpy需要注意以下几点：

• 源字符串必须以 ‘\0’ 结束。
• 会将源字符串中的 ‘\0’ 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变

以下代码，展示了如何使用 strcpy 函数来完成字符串拷贝：

#include 
#include 

int main()
{
	char dest[20];//目标字符串数组
	const char* src = "hello word!";//源字符串

	//使用strcpy函数,将源字符串拷贝到目标字符串
	strcpy(dest, src);

	printf("目标字符串:%s\n", dest);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.2 模拟实现

strcpy模拟实现：

• 使用循环遍历 src 字符串中的每个字符。
• 在循环中，将 src 字符串的每个字符复制到 dest 字符串的对应位置，包括结尾的 \0。
• 循环直到遇到 src 字符串的 \0，然后结束循环。
• 返回 dest字符串的起始地址，表示复制完成。

#include 
#include 
//模拟实现
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	//保留目标字符串起始地址
	char* _dest = dest;
	//逐个字符进行拷贝
	while (*dest++ = *src++)
	{
		;
	}
	return _dest;
}
int main()
{
	char dest[20];
	const char* src = "hello word!";

	my_strcpy(dest, src);
	printf("目标字符串:%s\n", dest);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3. strcat

3.1 函数介绍

函数原型：

char * strcat ( char * destination, const char * source );
1

• destination：目标字符串的指针，即要将源字符串追加到这个字符串的末尾。
• source：源字符串的指针，即要追加到目标字符串末尾的字符串。

strcat是一个用于完成字符串追加的函数，它将源字符串的内容追加到目标字符串的末尾，直到遇到源字符串的 \0 为止。追加完成后，函数返回目标字符串的起始地址，并且目标字符串将包含原始内容以及追加内容，且以结尾\0 结束。
关于strcat需要注意以下几点：

• 源字符串必须以 ‘\0’ 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。

以下代码，展示了如何使用 strcat 函数来追加字符串：

#include 
#include 

int main() {
    char dest[20] = "Hello, ";
    const char* src = "World!";  // 源字符串
    
    // 使用 strcat 追加源字符串到目标字符串
    strcat(dest, src);
    
    printf("目标字符串：%s\n", dest);
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.2 模拟实现

strcat模拟实现：
实现思路：

• 使用循环找到 dest字符串中 \0 的位置。
• 使用循环，将 src字符串的每个字符从dest字符串\0的位置依次往后追加（包括src中\0），直到遇到 src 字符串中的 \0。
• 返回 dest字符串的起始地址，表示追加完成。

#include 
#include 
//模拟实现
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* _dest = dest;
	//找末尾\0
	while (*dest)
	{
		dest++;
	}
	//从目标字符串\0位置开始往后追加
	while (*dest++ = *src++)
	{
		;
	}
	return _dest; 
}

int main()
{
	const char* src = "word!";// 源字符串
	char dest[30] = "hello ";
	
	my_strcat(dest, src);

	printf("%s\n", dest);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4. strcmp

4.1 函数介绍

函数原型：

int strcmp ( const char * str1, const char * str2 );
1

• str1：要比较的第一个字符串的指针。
• str2：要比较的第二个字符串的指针。

strcmp 是一个字符串比较函数，用于比较两个字符串的内容。该函数返回一个整数值，表示比较的结果。
标准规定：

• 第一个字符串大于第二个字符串，则返回大于0的数字。
• 第一个字符串等于第二个字符串，则返回0。
• 第一个字符串小于第二个字符串，则返回小于0的数字。

关于strcmp需要注意以下几点：

• strcmp 函数是区分大小写的，因此大写字母和小写字母被认为是不同的字符。
• 在比较字符串时，要确保字符串以\0 结尾，否则可能会导致未定义行为。

以下代码，展示了如何使用 strcmp 函数来进行字符串比较：

#include 
#include 

int main() {
    const char *str1 = "abcdef";
    const char *str2 = "abcdeg";
    
    int res = strcmp(str1, str2);
    
    if (res < 0) 
    {
        printf("%s 小于 %s\n", str1, str2);
    } 
    else if (res == 0)
    {
        printf("%s 等于 %s\n", str1, str2);
    } 
    else {
        printf("%s 大于 %s\n", str1, str2);
    }
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.2 模拟实现

strcmp模拟实现：
实现思路：

• 使用循环遍历 str1 和 str2 字符串中的每个字符，同时比较它们的对应字符。如果同时遍历到\0的位置循环都没结束，表示两个字符串相等，返回0。
• 在循环中，如果发现字符不相等，则返回它们的差值（ASCII码值之差）。

#include 
#include 
//模拟实现
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	//使用循环遍历 str1 和 str2,同时比较它们的对应字符
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	//发现字符不相等，则返回它们的差值
	return *str1 - *str2;
}

int main() {
	const char *str1 = "abcdeg";
	const char *str2 = "abcdef";

	int res = my_strcmp(str1, str2);

	if (res < 0)
	{
		printf("%s 小于 %s\n", str1, str2);
	}
	else if (res == 0)
	{
		printf("%s 等于 %s\n", str1, str2);
	}
	else {
		printf("%s 大于 %s\n", str1, str2);
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

至此，本片文章就结束了，若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。
创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！
如果本篇博客有任何错误，请批评指教，不胜感激 ！