C语言字符串库函数详解&模拟实现（strlen、strcpy、strcat、strcmp）+字符操作函数+字符转换函数_strlen strcmp 实现

注：本文介绍函数都需包含指定头文件

一、无字符串长度限制的字符串函数

1. strlen 计算字符串长度函数

1.参数：

size_t strlen ( const char * str );
1

• strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
• strlen 的函数返回值是size_t，无符号整形
• strlen 的参数指向的字符串的结尾必须包含’\0’
• 注意： strlen(“abc”)-strlen(“abcde”) 结果是>0 （-2存到无符号数里 是很大的正数）因此最好用比较，不要相减

2.使用方法：

#include<string.h>
int main()
{
	char arr[] = { "abcde" };
	int n = strlen(arr);
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%c ", arr[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

3.模拟实现：（此处为计数器办法，还可以用1.指针-指针 2.递归的方式）

size_t mysrtlen(const char* str)
{
	size_t cnt = 0;
	assert(str);
	while (*str != '0')
	{
		cnt++;
		str++;
	}
}
int main()
{
	char arr[] = "abcdef";
	size_t n = my_strlen(arr);
	printf("%u\n", n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. strcpy 字符串拷贝函数

1.参数：

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

• strcpy 拷贝时保证原数据要有’\0’ 所以不能用arr[]={‘c’,‘a’,‘r’,‘o’,‘l’},同时防止数组放不下，越界访问
• strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间中
• 拷贝的目标空间必须足够大
• 不能拷贝到常量字符串里（char *p=“abc”)

2.使用方法：
strcpy 里的第一个参数是拷贝的目标空间，第二个参数是拷贝的内容

int main()
{
	char arr[20] = { "xxxxxxxxxxxxxxxxxxxx" };
	char x[] = { "hello china" };
	strcpy(arr, x);
	printf("%s", arr);
	return 0;
}
1
2
3
4
5
6
7
8

3.模拟实现

void my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest; //记录一下初始位置
	while (*src)
		*dest++ = *src++;
	return ret;
}
int main(){
	char arr1[] = "abcdef";
	char arr2[20]={0};
	my_strcpy(arr2,arr1);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. strcat 字符串追加函数

1.参数：

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

• strcat 的源字符串必须以 \0 为结束标志
• strcat 的被追加的空间必须能够存放的下追加的字符串
• strcat 的源字符串必须是可改变的，不能是常量字符串
• 注意：自己追加自己会怎样？–陷入死循环，因为会把\0覆盖掉，破坏原数据
  

2.使用方法：

int main()
{
	char arr[20] = { "hello " };
	char arr2[] = "china";
	strcat(arr, arr2);
	printf("%s\n", arr);

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

strcat 函数追加会把 arr2 的所有字符串拷贝到arr1里，包括\0

3.模拟实现

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	//1.找到目标空间的末尾\0
	while (*dest != '\0')
	{
		dest++;
	}
	//2.拷贝
	while (*dest++ = *src++)
		;
	return ret;
}
int main()
{
	char arr1[] = "hello ";
	my_strcat(arr1, "world");
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4. strcmp 字符串比较函数

1.参数：

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

• strcmp函数判定规则：
  第一个大于第二个，返回大于0的数字
  第一个等于第二个，则返回0
  第一个小于第二个，则返回小于0的数字

• strcmp 是比较每个字符串的第一个字符， 如果相等，
  则继续比较下一对字符，直到字符不相等或遇到’\0’

2.使用方法：

int main()
{
	char arr[] = { "abcdefg" };
	char str[] = { "abg" };
	int ret = strcmp(arr, str);
	if (ret > 0)
	    printf("arr > str");
	else if (ret < 0)
		printf("arr < str");
	else
		printf("arr == str");

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

3.模拟实现

int my_strcmp(const char* str1,const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)  //相等就找下一个
	{
		if (*str1 == '\0') return 0;  //相等
		str1++;
		str2++;
	}
	if (*str1 > *str2) return 1; 
	else return -1;
	//上述if - else可简化为 return(*str1 - *str2);

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

---

二、 有字符串长度限制的字符串函数

1. strncpy 字符串拷贝函数

1.参数：

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

• strncpy 和 strcpy 函数的使用方法相似，只是多了一个参数 size_t num
• 多出来的参数是来限制字符串拷贝的长度，增加了安全性
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加\0，直到num个

2.使用方法：

int main()
{
	char arr1[25] = { "hello world!" };
	char arr2[] = { "For a better tomorrow!########" };
	strncpy(arr1, arr2, 22);
	printf("%s\n", arr);
	return 0;
}
1
2
3
4
5
6
7
8

2. strncat 字符串追加函数

1.参数：

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

• 和 strcat 函数使用的方法和规则类似，在arr1的后面追加arr2的内容，并会在末尾自动加上\0。只是多了一个参数 size_t num
• num 这个参数代表需要追加几个字符

2.使用方法：

int main()
{
	char arr[20] = "hello ";
	char* str = "world! For a better tomorrow!";
	strncat(arr, str, 6);
	printf("%s\n", arr);

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

3. strncmp 字符串比较函数

1.参数：

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

• 规则和 strcmp 一样
• 多出来的一个参数是用来要比较字符串的个数

2.使用方法：比较前3个字符大小

int main()
{
	char arr[] = { "abgefg" };
	char str[] = { "abgaaaa" };
	int ret = strncmp(arr, str,3);
	if (ret > 0)
	    printf("arr > str");
	else if (ret < 0)
		printf("arr < str");
	else
		printf("arr == str");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4. strstr 在字符串中查找另一字符串

1.参数：

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

• 作用：在A 字符串中查找是否包含 B字符串
• 如果 A 中包含 B ，则返回 B 在 A 中首次出现的的地址。否则返回空指针。
  因为返回的是地址，所以要用指针变量来接收

2.使用方法：

int main()
{
	char arr[] = { "abcdefg" };
	char str[] = { "cde" };
	char* ret = strstr(arr, str);
	if (ret == NULL)
		printf("没有找到\n");
	else
		printf("%s\n", ret);

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

5. strtok 切割字符串函数

1.参数：

char * strtok ( char * str, const char * sep );
1

• sep参数是个字符串，定义了用作分隔符的字符集合第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
• 如果字符串中不存在更多的标记（找不到），则返回 NULL 指针 （输出(null)）。
  总结：第一次调用传第一个变量首地址，后面几次传NULL就行（怎么记录的？用static保存）
  

2.使用方法：

---

三、两个错误码函数

1. strerror 解析错误码函数

1.参数：

char * strerror ( int errnum );
1

注：需包含头文件<errno.h>

• 在使用库函数的时候，调用库函数失败时，都会设置错误码
• C语言中有一个全局变量叫 errno，只要调用库函数发生错误，就会把错误码放到errno里
• strerror函数会把错误码翻译成对应的错误信息

2.效果展示：

int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	printf("%s\n", strerror(4));
	printf("%s\n", strerror(5));
	return 0;
}
1
2
3
4
5
6
7
8
9
10

3.使用方法：
一般是 strerror 里放 errno，errno 里存放的是错误码

int main()
{
	FILE* pFile;
	pFile = fopen("test.txt", "r");//打开test.txt,以读的形式打开文件
	if (pFile == NULL) // 打开失败就是空指针
		printf("%s\n", strerror(errno));
		//错误码自动保存在 errno 变量当中
	return 0;
}
1
2
3
4
5
6
7
8
9

2.perror 解析错误码，打印信息

1.参数：

void perror(const char* str);
1

注：需包含头文件<stdio.h>

• perror 和 strerror 作用都是一样的，不过strerror 没有打印的效果
• perror 是把错误码转换成错误信息，再打印

2.使用方法：

int main()
{
	//1. 打开文件失败时，返回NULL
	FILE* pd = fopen("test.txt", "r"); 
	if (pd == NULL)
	{
		perror("错误信息");
		return 1;
	}

	// 2. 读文件
	// .....
	//3. 关闭文件
	fclose(pd);
	pd = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

字符操作函数

注：以上函数需要头文件<ctype.h>

---

字符转换函数

1.tolower

使用：

#include<ctype.h>
int main()
{
	char arr[20] = { 0 };
	scanf("%s", &arr);
	int i = 0;
	while (arr[i] != '\0')
	{
		if (isupper(arr[i])) //判断是否是大写字母
		{
			arr[i] = tolower(arr[i]);
		}
		printf("%c ", arr[i]);
		i++;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.toupper

使用：

int main()
{
	char arr[20] = { 0 };
	scanf("%s", &arr);
	int i = 0;
	while (arr[i] != '\0')
	{
		if (islower(arr[i])) //判断是否是小写字母
		{
			arr[i] = toupper(arr[i]); //转换成大写字符
		}
		printf("%c ", arr[i]);
		i++;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

总结

注意头文件的使用，使用字符串相关函数都要有<string.h>，两个报错函数不同头文件，字符操作函数和转换函数需要<ctype.h>。
一般使用有字符串长度限制的字符串函数，防止越界报错，提高安全性。
注意思考这些字符串函数自己作用于自己时的情况，结合’\0’考虑。