特色栏目： python 批处理 net编程 Javascript Php Asp Css Html5 Android seo centos

【C语言】C语言常见字符串函数深度解析

来源：互联网收集：自由互联发布时间：2023-09-03

前言常见的字符串函数在一定程度上可以让我们在写代码，或者是在刷某些有关字符串的题目时事半功倍，并且常见字符串函数的功能非常常用，因此我们应该熟练使用这些字符串函数

前言

常见的字符串函数在一定程度上可以让我们在写代码，或者是在刷某些有关字符串的题目时事半功倍，并且常见字符串函数的功能非常常用，因此我们应该熟练使用这些字符串函数，以及部分函数要能自我实现。

字符串函数都要引入一个库函数：string(#include <string.h>)

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

`strlen`

strlen函数是求字符串长度的，遇到 \0 停止（计算\0之前有多少个字符），如果有多个\0，则只计算第一个\0前面的字符个数。

在这里插入图片描述

`strlen`的使用：

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

int main()
{
	char arr[] = "abcdef";

	printf("%d\n", strlen(arr));

	return 0;
}

运行结果：6

arr有6个字符，所以所得为6，值得注意的是，strlen函数的返回值是 size_t(unsigned int),size_t表示无符号整型，但是这里我们用%d形式打印也是没有问题的。

为什么strlen函数的返回值要弄size_t 呢？因为长度是没有负数之说的，所以size_t符合实际，但是size_t又难免会出现一些问题，例如：

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

int main()
{
	char a1[] = "abc"; // 3
	char a2[] = "abcdef";  // 6

	if (strlen(a1) - strlen(a2) < 0)
	{
		printf("a1 < a2\n");
	}
	else
	{
		printf("a1 > a2\n");
	}

	return 0;
}

猜这里输出的结果是什么呢？

正常来说应该输出a1 < a2才对，可是这里的输出是a1 > a2,那么就说明strlen(a1) - strlen(a2) > 0,这是为什么呢？

strlen(a1)返回一个size_t的数3，strlen(a2)返回一个size_t的数6，3 - 6 = -3，此时-3也是一个size_t类型，所以当-3作为一个无符号数来看待的话，那将是一个很大的整数，自然也就大于零输出第一个printf了。

所以库函数中strlen返回值为size_t可以说有利也有弊，需细心使用，接下来我对字符串函数的实现，如果是返回整型的话，我都会采用返回int的。

`strlen`的自我实现

这里我的strlen实现有三种方式：计数，指针减指针，递归，他们分别对应my_strlen1, my_strlen2, my_strlen3。

#include <stdio.h>
#include <assert.h>

int my_strlen1(const char* s)
{
	assert(s);

	int count = 0;

	while (*s)
	{
		++count;   // *s 不是 \0 就加一
		++s;
	}

	return count;
}

int my_strlen2(const char* s)
{
	assert(s);

	const char* cur = s;
	while (*cur)
	{
		cur++;
	}

	return (int)(cur - s); // 用 cur 指针找到 \0 ,再用 cur 减去 s 得到之间字符的个数 6
}

int my_strlen3(const char* s)
{
	assert(s);

	if (*s != '\0')
		return 1 + my_strlen3(s + 1);
	else
		return 0;
}

int main()
{
	char a[] = "abcdef";

	printf("%d\n", my_strlen1(a));  // 6
	printf("%d\n", my_strlen2(a));  // 6
	printf("%d\n", my_strlen3(a));  // 6

	return 0;
}

`strcpy`

strcpy的功能是字符串拷贝，将源头（src）字符串拷贝到目的地（dest）字符串当中，并且是从头开始拷贝，src中的\0也要拷贝过去。 注意：dest 的字符串长度要大于等于 src ，不然 src 拷贝过去会出现非法访问的错误。

在这里插入图片描述

strcpy函数返回目的地字符串（被拷贝后）首元素地址。

`strcpy`的使用

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

int main()
{
	char arr1[] = "xxxxxxxxxx";
	char arr2[] = "abcdef";

	printf("%s\n", strcpy(arr1, arr2));

	return 0;
}

运行结果为：abcdef

在这里插入图片描述

`strcpy`的自我实现

上图实际上就是整个拷贝的过程，*dest++ = *src++是整个代码实现核心。

实现代码如下：

#include <stdio.h>
#include <assert.h>

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

	char* ret = dest;  // 先要记住dest的起始位置

	while (*dest++ = *src++)  // 先运算*dest = *src，再判断*dest，再分别++
	{
		;
	}

	return ret; // 返回dest起始位置
}

int main()
{
	char arr1[] = "xxxxxxxxxx";
	char arr2[] = "abcdef";

	printf("%s\n", my_strcpy(arr1, arr2));

	return 0;
}

`strcat`

该函数的功能是在目的地字符串末尾追加源字符串（连接），目的地字符串的末尾不包括\0,也就是说\0将会被追加的字符串覆盖。

注意：源字符串必须以 \0 结束。目标空间必须足够的大，能容纳下追加后目的地字符串的所有内容。目标空间必须可修改。

在这里插入图片描述

`strcat`的使用

1.正常的追加在这里插入图片描述

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

int main()
{
	char arr1[20] = "xxxxx";
	char arr2[] = "abc";

	printf("%s\n", strcat(arr1, arr2));

	return 0;
}

运行结果为：xxxxxabc

2.目的地字符串中存在\0

在这里插入图片描述

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

int main()
{
	char arr1[20] = "xxx\0xxxxxxxx";
	char arr2[] = "abcdef";

	printf("%s\n", strcat(arr1, arr2));

	return 0;
}

运行结果为：xxxabcdef

要注意：

strcat不能追加自己，因为再追加自己的同时，末尾的\0在追加的时候被修改了，这时就会死循环，因为要追加的字符串也找不到\0了，此时程序会崩溃。如果要追加自己，可以用下面要讲解的strnpy函数。

`strcat`的自我实现

通过上面的解析可以知道，我们首先要让一个指针找到dest（目的地字符串）的\0，再进行追加（连接），而追加的功能类似于拷贝（*dest++ = *src++）。

代码实现：

#include <stdio.h>
#include <assert.h>

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);

	char* ret = dest; 
	
	// 先找到 dest 的第一个 \0
	while (*dest)
	{
		dest++;
	}

	while (*dest++ = *src++) // 追加
	{
		;
	}

	return ret;
}

int main()
{
	char arr1[20] = "xxxxx";  // 大小为 20 ，为了能够承受住 arr2 的追加
	char arr2[] = "abcdef";

	printf("%s\n", my_strcat(arr1, arr2));

	return 0;
}

运行结果为：xxxxxabcdef

`strcmp`

该函数的功能是比较两个字符串，看相等，小于，还是大于，是小于还是大于是根据字符的ASCLL码值来比较的。而字符的比较是两个字符串一对一对字符的比。

在这里插入图片描述

如果str1 < str2 返回一个小于0的数，如果str1 == str2返回0，如果str1 > str2返回一个大于0的数。
例如”abc“与“ac”比较，a == a ，b != c，又b的ASCLL码值``小于``c的ASCLL码值，所以返回一个小于零的数。

`strcmp`的使用

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

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdq";
	char arr3[] = "abcd";

	printf("%d\n", strcmp(arr1, arr2));
	printf("%d\n", strcmp(arr1, arr3));

	return 0;
}

运行结果为：-1 1 这是因为vs的strcmp如果小返回-1，大返回1，相等返回0，而标准就是上面所说。

`strcmp`的自我实现

这里按标准的返回值来实现

#include <stdio.h>
#include <assert.h>

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);

	while (*str1 != '\0' || *str2 != '\0')
	{
		if (*str1 - *str2)
		{
			return *str1 - *str2;
		}
		str1++;
		str2++;
	}

	return 0;
}

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdq";

	printf("%d\n", my_strcmp(arr1, arr2));

	return 0;
}

运行结果为：-12

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

`strncpy`

该函数的功能是指定拷贝几个字符，与strcpy不同的是，strncpy多了一个确定拷贝字符个数的参数，这也就限制了长度，让使用者更能精确的拷贝自己想要的字符。

同样要注意的是： 1.源字符串拷贝到目的地字符串时不能超出目的地字符串的空间大小； 2.如果拷贝个数小于源字符串的长度，这时不会拷贝\0，也就是“abcdef”，如果拷贝4个，则只拷贝“abcd”过去; 3.如果拷贝个数大于源字符串的长度 + 1（因为后面还有一个\0）,则多出来的拷贝放\0。

该函数的函数参数：在这里插入图片描述

`strncpy`的使用

1.正常拷贝：

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

int main()
{
	char arr1[] = "xxxxxxxxxxxxxxxx";
	char arr2[] = "abcdef";

	printf("%s\n", strncpy(arr1, arr2, 5));  // 拷贝5个

	return 0;
}

运行结果为：abcdexxxxxxxxxxx

2.拷贝个数等于源字符串的长度 + 1：

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

int main()
{
	char arr1[] = "xxxxxxxxxxxxxxxx";
	char arr2[] = "abcdef";

	printf("%s\n", strncpy(arr1, arr2, 7)); // 拷贝7个，该字符串的长度为6

	return 0;
}

运行结果为：abcdef

3.拷贝个数大于源字符串的长度 + 1:

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

int main()
{
	char arr1[] = "xxxxxxxxxxxxxxxx";
	char arr2[] = "abcdef";

	printf("%s\n", strncpy(arr1, arr2, 10)); // 拷贝10个，arr2不够，后面拷贝\0

	return 0;
}

在这里插入图片描述

运行结果为：abcdef

`strncpy`的自我实现

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

char* my_strncpy(char* dest, const char* src, int n)
{
	assert(dest && src);

	char* ret = dest;
	// 这里求src的长度是为了解决拷贝个数大于源字符串的长度 + 1的情况
	// 每拷贝一个lenSrc--，当 lenSrc == 0，而 n != 0,此时应该在后面拷贝\0直至n == 0；
	// 因为字符串后面还有一个\0,要把他算在内，所以lenSrc要等于长度 + 1；
	int lenSrc = (int)strlen(src) + 1;

	while (n--)
	{
		if (!lenSrc) // 当lenSrc为0时，!lenSrc为真，后面拷贝\0直至 n == 0；
		{
			*dest++ = '\0';
		}
		else
		{
			*dest++ = *src++;
			lenSrc--;  // 每拷贝一次源字符串的内容，lenSrc--；
		}
	}

	return ret;
}

int main()
{
	char arr1[20] = "xxxxxxxxxxxxxxxx";
	char arr2[] = "abcdef";

	printf("%s\n", my_strncpy(arr1, arr2, 5));

	return 0;
}

`strncat`

该函数的功能就是指定在目的地字符串后面追加（连接）源字符串的几个字符，其注意事项与strcat差不多，由于长度受限制，所以追加的形式与strcat也会不同。

在这里插入图片描述

`strncat`的使用

1.目的地字符串只有末尾有\0：

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

int main()
{
	char a1[20] = "xxxxxxxxxxx";
	char a2[] = "abcdef";

	printf("%s\n", strncat(a1, a2, 4));

	return 0;
}

运行结果为：xxxxxxxxxxxabcd

2.目的地字符串中间也有\0：

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

int main()
{
	char a1[20] = "xxx\0xxxxxxx";
	char a2[] = "abcdef";

	printf("%s\n", strncat(a1, a2, 5));

	return 0;
}

运行结果为：xxxabcde

可以发现，当追加完所定个数的字符后，会在此的后面自动追加一个\0（打印的时候遇到\0停止可确定）。

3.当追加的个数大于源字符串的长度时，将源字符串追加过去后便停止追加：

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

int main()
{
	char a1[20] = "xxxx";
	char a2[] = "abcdef";

	printf("%s\n", strncat(a1, a2, 8));

	return 0;
}

在这里插入图片描述

运行结果为：xxxxabcdef

`strncat`的自我实现

了解到上面函数的功能后，接下来就将这些功能实现成strncat函数

核心功能： 1.追加完后自动再追加一个\0; 2.目的地字符串先找\0; 3.源字符串整个追加完后停止追加； 4.追加的代码；

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

char* my_strncat(char* dest, const char* src, int n)
{
	assert(dest && src);

	char* ret = dest;
	int lenSrc = (int)strlen(src);

	// 目的地字符串先找\0
	while (*dest)
	{
		dest++;
	}

	while (n)
	{
		// 如果整个源字符串追加完了此时 n != 0，在后面追加一个\0,停止追加
		if (!lenSrc)
		{
			*dest++ = '\0';
			break;
		}
		else
		{
			*dest++ = *src++;
			lenSrc--;
		}
		n--;
	}

	// 如果n == 0也就是说要追加的追加完了，在后面再追加一个\0
	if (n == 0)
		*dest = '\0';

	return ret;
}

int main()
{
	char a1[20] = "xxxxxxx";
	char a2[] = "abcdef";

	printf("%s\n", my_strncat(a1, a2, 8));

	return 0;
}

`strncmp`

该函数功能是指定两个字符串多少对字符进行对比，对比的方式与strcmp函数相同。

在这里插入图片描述

`strncmp`的使用

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

int main()
{
	char a1[] = "abcdef";
	char a2[] = "abcdq";

	printf("%d\n", strncmp(a1, a2, 5));

	return 0;
}

当比对到e和q时 e的ASCLL码值小于q的ASCLL码值，所以打印小于零的数，如果第三个参数为4，则返回0，也就要打印0。

`strncmp`的自我实现

这里是按照vs的标准来实现的，也就是比对小于返回-1，比对大于返回1，等于返回0；

#include <stdio.h>
#include <assert.h>

int my_strncmp(const char* str1, const char* str2, int n)
{
	assert(str1 && str2);

	while (n--)
	{
		if (*str1 - *str2)
		{
			if (*str1 < *str2)
				return -1;
			else
				return 1;
		}
		str1++;
		str2++;
	}

    // n个都比对完了，而前面没有返回（比对都相同），说明这n个相等
	return 0;
}

int main()
{
	char a1[20] = "abc";
	char a2[] = "abcgdef";

	printf("%d\n", my_strncmp(a1, a2, 3));
	// 1:a1 > a2
	// 0:a1 == a2
	// -1:a1 < a2

	return 0;
}

3.字符串查找

`strstr`

该函数功能实际上是判断一个字符串是否是另一个字符串的子串，例如字符串s1 = “iou”，字符串s2 = “youioume?”,s2中间出现了iou这样的子串，所以该函数返回i的地址，打印出来也就是ioume?。

在这里插入图片描述

返回指向 str2中指定的整个字符序列在 str1 中首次出现的指针，如果字符序列str2在 str1中不存在，则返回 null指针。

`strstr`的使用

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

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "bcde";
	char arr3[] = "bcb";

	printf("%s\n", strstr(arr1, arr2));
	printf("%s\n", strstr(arr1, arr3));

	return 0;
}

运行结果为： bcdef （null）

在这里插入图片描述

`strstr`的自我实现

strstr的自我实现相对较难，这里我用暴力解法。

定义三个指针cur ，s1，s2，cur为开始匹配的位置（匹配成功好返回），s1与s2是比对指针。

什么时候停止匹配返回NULL呢？ 1.当*cur为\0时停止 2.当从cur位置开始后面的字符个数小于str2的字符个数时停止（strlen（cur）< strlen（str2））；

在这里插入图片描述代码实现：

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

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);

	if (*str2 == '\0')
		return (char*)str1;

	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* cur = str1;

	while (*cur)
	{
		s1 = cur;
		s2 = str2;

		while (!(*s1 - *s2) && *s1 && *s2)
		{
			s1++;
			s2++;
		}

		if (!*s2)  // 如果上面的循环停止是因为*s2 == \0,那么匹配成功
			return (char*)cur;
		if ((int)strlen(cur) < (int)strlen(str2))
			return NULL;

		cur++;
	}

	return NULL;
}

int main()
{
	char arr1[] = "abbbce";
	char arr2[] = "bbc";

	printf("%s\n", my_strstr(arr1, arr2));

	return 0;
}

运行结果为：bbce

`strtok`

这个函数的功能通俗来说是分割字符串，在一个字符串内输入需要在此字符分割的字符，例如“@.”,也就是说在另一个字符串里，要找到@和.并在此字符的位置对该字符串进行分割。

函数参数介绍：

在这里插入图片描述

`strtok`的使用

当我们第一次传参时，将要分割的字符串和确定分割的字符的字符串传过去，第一次分割好后，strtok函数会自动记住分割的位置，下一次我们要继续调用这个函数，不过函数第一个参数要传NULL（因为strtok自动记住了第一次分割的位置），直到要分割的字符串中没有要分割的字符，此时返回一个 NULL，停止分割。

这里我们可以用一个fou循环来进行分割，当最后返回一个NULL的时候表示分割结束，循环结束。

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

int main()
{
	char a1[] = "I@love.you";
	char a2[] = "@.";

	char* ret = NULL;
	for (ret = strtok(a1, a2); ret != NULL; ret = strtok(NULL, a2))
	{
		printf("%s\n", ret);
	}

	return 0;
}

在这里插入图片描述

4.错误信息报告

`strerror`

该函数的功能相当于是报错误，如果我们在实现某个功能的时候，怕这个程序出现问题，这时我们可以if（如果怎么怎么样），就报一个错误（用strerror），当然学习这个函数还要认识另一个函数，那就是errno（对应头文件为（errno.h））

errno：C语言的库函数在运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量> 是：errno，这时我们用strerror将其输出，就可以得到错误信息。

当然有一些错误码是一些数字：1 2 3 4 5 我们也可以将这些数字作为strerror函数的参数输出，这时需要将错误码翻译成错误信息然后再输出。

`strerror`的使用

1.数字错误码：

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

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;
}

在这里插入图片描述

2.errno对应的使用：

这里开开辟一个巨大的空间，如果开辟失败，就会返回NULL，然后就会输出对应的错误信息（为什么开辟失败）。

#include <stdio.h>
#include <string.h>
#include <errno.h> // 使用errno所需头文件
#include <stdlib.h>

int main()
{
	int* tmp = (int*)malloc(sizeof(int) * 12345678910);
	if (tmp == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		printf("开辟成功！\n");
	}

	free(tmp);
	tmp = NULL;

	return 0;
}

在这里插入图片描述

写在最后

常用字符串函数的熟练使用可以在某些地方大大提升写代码效率，因此一定要好好掌握，最好能够自我实现，吃透这些函数的运行逻辑，以便更精确更融洽的使用。

感谢阅读本小白的博客，错误的地方请严厉指出噢！

上一篇：萌新入门qt-搭建环境
下一篇：没有了

【C语言】C语言常见字符串函数深度解析

前言

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

strlen

strlen的使用：

strlen的自我实现

strcpy

strcpy的使用

strcpy的自我实现

strcat

strcat的使用

strcat的自我实现

strcmp

strcmp的使用

strcmp的自我实现

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

strncpy

strncpy的使用

strncpy的自我实现

strncat

strncat的使用

strncat的自我实现

strncmp

strncmp的使用

strncmp的自我实现

3.字符串查找

strstr

strstr的使用

strstr的自我实现

strtok

strtok的使用

4.错误信息报告

strerror

strerror的使用

写在最后

相关文章

`strlen`

`strlen`的使用：

`strlen`的自我实现

`strcpy`

`strcpy`的使用

`strcpy`的自我实现

`strcat`

`strcat`的使用

`strcat`的自我实现

`strcmp`

`strcmp`的使用

`strcmp`的自我实现

`strncpy`

`strncpy`的使用

`strncpy`的自我实现

`strncat`

`strncat`的使用

`strncat`的自我实现

`strncmp`

`strncmp`的使用

`strncmp`的自我实现

`strstr`

`strstr`的使用

`strstr`的自我实现

`strtok`

`strtok`的使用

`strerror`

`strerror`的使用