【C语言进阶】带你深度剖析那些常见的--字符函数（一）

前言

在C语言的学习中，C语言中对字符和字符串的处理很是频繁，所以今天本文是针对有关字符串的函数进行深度剖析，下面我会介绍函数的功能，如何使用，参数，模拟实现等方面来进行讲述，希望本文对你有所帮助。

1.长度不受限制的字符串函数

1.1strlen

strlen函数使用介绍

size_t strlen ( const char * str );

返回值+函数名+参数构成函数声明

strlen计算的是字符串的长度，字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
参数指向的字符串必须要以 ‘\0’ 结束。
注意函数的返回值为size_t，是无符号的（ 易错 ）

代码演示

#include
#include
int main()
{
	char arr[] = "abcdef";
	int ret = strlen(arr);
	printf("%d\n", ret);
	return 0;
}

1
2
3
4
5
6
7
8
9
10

strlen函数模拟实现

#include
int my_strlen(const char* str)
{
	assert(str);//防止传过来的指针为空指针
	const char* start = str;
	const char* end = str;
	while (*end != '\0')
	{
		end++;
	}
	return end - start;//指针-指针
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	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

1.2 strcpy

strcpy函数使用介绍

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

strcpy功能：
将源头空间（source）的字符串拷贝到目的地空间（destination）中
源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可修改，注意常量字符串不可修改
参数
destination:指向要在其中复制内容的目标数组的指针
source:要拷贝的源头字符串。

返回值
返回目标空间中字符串起始地址

代码演示

#include
#include
int main()
{
	char arr[10] = "xxxxxxxxxx";//目标空间
	const char* p = "abcdef";//要拷贝的字符串
	strcpy(arr, p);//使用函数进行拷贝
	printf("%s\n", arr);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

strcpy函数模拟实现

#include
char* my_strcpy(char* dest, const char* src)
{
	assert(dest);//防止dest和src为空指针
	assert(src);
	char* ret = dest;//将dest的起始地址放在ret中
	while (*dest++ = *src++)
	{
		;
	}
	return ret;//返回目标空间的起始地址
}
int main()
{
	char arr[20] = "abc";
	char arr2[] = "hello world";
	my_strcpy(arr, arr2);
	printf("%s\n", arr);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.3 strcat

strcat函数使用介绍

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

功能
将源空间中的字符串追加到目的地空间中，源空间的字符串从目的空间字符串的\0的位置开始追加
比如char arr1[10]=“hello” char arr2[]=“world”,将arr2的字符串追加到arr1中，最终为"hello world",在什么时候追加呢，在arr1的’\0’的位置开始进行追加
源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
参数
destination：目标空间
source：源头空间
返回值
返回目标空间中字符串起始地址

代码演示

#include
#include
int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

strcat函数模拟实现

#include
#include
char* my_strcat(char* dest, const char* src)
{
	assert(dest);
	assert(src);
	//找到目标空间的\0
	char* ret = dest;
	while (*dest != '\0')
	{
		dest++;
	}
	//在将源空间的字符串拷贝到\0以后的空间中
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "hello \0xxxxxxxxx";
	char arr2[] = "world";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	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

1.4 strcmp

strcmp函数使用介绍

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

功能
将 字符串 str1 与 字符串 str2 进行比较,比较对应位置的字符大小。
函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对操作，直到字符不同或达到终止空字符。

参数
str1：要比较的 C字符串str1
str2：要比较的 C字符串str2

返回值
返回一个整数值，该值指示字符串之间的关系：

如果str1中的值低于str2，返回一个小于0的数，str1>str2，返回一个大于0的数，相等就返回0.

代码演示

#include
#include
int main()
{
	char arr1[] = "abcdef";//第三个字符'c'小于arr2中的'd'
	char arr2[] = "abd";//所以返回一个小于0的数字
	int ret=strcmp(arr1, arr2);
	printf("%d\n", ret);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

strcmp函数模拟实现

#include
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1);
	assert(str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')//这个判断表明前面字符比较都是相同的
		{
			return 0;
		}
		str1++;
		str2++;
	}
	return *str1 - *str2;
}
int main()
{
	char arr1[] = "abc";
	char arr2[] = "abd";
	int ret = my_strcmp(arr1, arr2);
	if (ret < 0)
		printf("arr1);
	else if (ret > 0)
		printf("arr1>arr2\n");
	else
		printf("arr1=arr2\n");
	printf("%d\n", ret);
	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

2.长度受限制的字符串函数

2.1strncpy

strncpy函数使用介绍

char * strncpy ( char * destination, const char * source, size_t num );

功能
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个，前提是要保证目标空间可以存放。

参数
destination：指向要在其中复制内容的目标数组的指针
source：要拷贝的源头字符
size_t num:要从源复制的最大字符数。size_t是无符号整数类型。

返回值
返回目标空间中字符串起始地址

代码演示

#include
#include
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "xxxxx";
	strncpy(arr1, arr2, 4);
	printf("%s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

strncpy函数模拟实现

#include
char* my_strncpy(char* dest, const char* src, int num)
{
	assert(dest && src);
	char* ret = dest;
	while (num&&(*dest++ = *src++)!='\0')
	{
		num--;
	}
	while (num)
	{
		num--;
		*dest++ = '\0';
	}
	return ret;
}
int main()
{
	char arr1[20] = "abcdefg";
	char arr2[] = "xxxxx";
	my_strncpy(arr1, arr2, 5);
	printf("%s\n", arr1);
	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

2.2 strncat

strncat函数使用介绍

char * strncat ( char * destination, const char * source, size_t num );

功能
将源头空间的前 num 个字符追加到目标，从目标空间的\0开始追加，外加一个终止空字符\0。
如果源头中 C 字符串的长度小于 num，则仅复制到终止空字符之前的内容。
参数
destination：指向要在其中复制内容的目标数组的指针
source：要追加的源头字符
size_t num:要从源头追加的最大字符数。size_t是无符号整数类型。

返回值
返回目标空间中字符串起始地址

代码演示

#include
#include
int main()
{
	char arr1[20] = "abcdefd\0xxxxx";
	char arr2[] = "xyz";
	strncat(arr1, arr2, 2);
	printf("%s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

strncat函数模拟实现

#include
#include
char *my_strncat(char* dest, const char* src, int num)
{
	assert(dest&& src);
	char* ret = dest;
	//找到目标空间的\0
	while (*dest != '\0')
	{
		dest++;
	}
	while (num&&(*dest++ = *src++)!='\0')
	{
		num--;
	}
	*dest = '\0';
	return ret;

}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "xxxx";
	my_strncat(arr1, arr2, 2);
	printf("%s\n", arr1);
	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

2.3 strncmp

strncmp函数使用介绍

int strncmp ( const char * str1, const char * str2, size_t num );

功能

将 字符串 str1 与 字符串 str2前num个字符进行比较,比较对应位置的字符大小。
函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对操作，直到执行完num个字符
参数
str1：要比较的字符串str1
str2：要比较的字符串str2
size_t num：要比较的最大字符数，size_t是无符号整数类型。

返回值
返回一个整数值，该值指示字符串之间的关系：

如果str1中的值低于str2，返回一个小于0的数，str1>str2，返回一个大于0的数，相等就返回0.

代码演示

#include
#include
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "abd";
	int ret = strncmp(arr1, arr2, 3);
	printf("%d\n", ret);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

我们只需要比较两个字符串的前三个字符的大小，明显从c字符

strncmp函数模拟实现

#include
#include
int my_strncmp(const char* str1, const char* str2, int num)
{
	assert(str1 && str2);
	while (num && (*str1 == *str2))
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
		num--;
	}
	return *str1 - *str2;
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "abd";
	int ret = my_strncmp(arr1, arr2, 3);
	printf("%d\n", ret);
	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.字符串查找

3.1 strstr

strstr函数使用介绍

char * strstr ( char * str1, const char * str2 );

功能
找一个字符串在另一个字符串中是否存在
如果存在，返回子串第一次出现的位置的地址，不存在返回NULL

参数
str1：要扫描的 C 字符串
str2：包含要匹配的字符序列的 C 字符串

返回值
指向 str2 中指定的整个字符序列中 str1 中第一个出现的指针，如果 str1 中不存在该序列，则为空指针。

代码演示

#include
#include
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "bc";
	char* p = strstr(arr1, arr2);
	if (p == NULL)
	{
		printf("不存在");
	}
	else
	{
		printf("%s\n", p);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

strstr函数模拟实现

#include
#include
char* my_strstr(char* str1, const char* str2)
{

	//先找到字符标记号
	char* cp = str1;
	char* s1, * s2;
	if (!*str2)
	{
		return((char*)str1);
	}

	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s2 && !(*s1 - *s2))
		{
			s1++, s2++;
		}
		if (!*s2)
		{
			return(cp);
		}
		cp++;
	}
	return(NULL);
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "bc";
	char* p = my_strstr(arr1, arr2);
	if (p == NULL)
	{
		printf("不存在");
	}
	else
	{
		printf("%s\n", p);
	}
	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
41
42
43
44

3.2 strtok

strtok函数使用介绍

char * strtok ( char * str, const char * delimiters );

功能
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容
并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串
中的位置。
第二次调用strtok函数时，第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标
记。如果字符串中不存在更多的标记，则返回 NULL 指针。

参数
str：第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标
记。
delimiters：delimiters参数是个字符串，定义了用作分隔符的字符标记集合

返回值
如果找到分隔符，则返回为指向该字符串开头的指针。否则，为空指针。
当在扫描的字符串中达到字符串的末尾（即空字符）时，始终返回空指针。

代码演示

#include
#include
int main()
{
	char arr[20] = "sjjjjska@biid.com";
	char buf[200] = { 0 };
	strcpy(buf, arr);//将arr的字符串拷贝到buf中

	const char* p = "@.";//标记字符串

	char* str = strtok(buf, p);//第一个参数是非NULL，
	//函数将找到buf中第一个标记@，将其用\0覆盖，strtok函数将保存@在字符串中的位置。
	//然后strtok返回sjjjjska的首字符地址，存放在str中，%s打印出
	printf("%s\n", str);

	str = strtok(NULL, p);//第二次调用strtok时，第一个参数是NULL
	//strtok函数将在上一次保存的位置处，继续查找，将其标记符用\0进行覆盖，又将保存标记字符的地址
	//返回biil首字符的地址。
	printf("%s\n", str);

	str = strtok(NULL, p);//在上一次位置再次进行查找
	printf("%s\n", str);
	//如果再次调用strtok函数时，返回空指针
	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

1

4.错误信息查找

4.1strerror

strerror函数使用介绍

char * strerror ( int errnum );

功能
把错误码转换成错误信息
参数
errnum：错误号,会把错误码记录到相应的错误号中
返回值
指向描述错误错误的错误字符串的指针。
代码演示

#include
#include
int main()
{
	printf("%s\n", strerror(0));//0,1,2,3,4就是错误码
	printf("%s\n", strerror(1));//
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	printf("%s\n", strerror(4));
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12

错误码会记录到错误码的变量中，比如错误码变量errno
errno的头文件为#include

代码演示

#include
#include
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//读文件
	fclose(pf);
	pf = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

当没有这个文件是，就会把错误码记录到错误变量中，在打印出来

5.字符分类函数

此类函数不做详细介绍，感兴趣的小伙伴可以自己了解一下
如何可以知道库函数的用法点击这里
里面有库函数的用法，参数和返回值的讲解，还有代码演示

代码演示

#include
#include
int main()
{
	char ch = 'w';//判断是否是数字字符
	int ret = isdigit(ch);//如果是非数字字符返回0
	printf("%d\n", ret);
}
1
2
3
4
5
6
7
8