C语言：深入理解字符函数和字符串函数（2）

最新推荐文章于 2024-07-18 00:38:53 发布

蔡欣致

最新推荐文章于 2024-07-18 00:38:53 发布

阅读量449

点赞数 1

文章标签： c语言开发语言后端

本文链接：https://blog.csdn.net/Faith_cxz/article/details/122867268

版权

本文的参考资料均来自cplusplus网站：

cplusplus.com - The C++ Resources Networkhttp://www.cplusplus.com/

一、strstr字符串查找

有关strstr的资料：

下面通过一个strstr实现查找字符串的例子来引出模拟实现strstr：

//strstr字符串查找
#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

模拟实现strstr：

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

char* my_strstr(const char* arr1, const char* arr2)
{
	const char* s1 = arr1;
	const char* s2 = arr2;
	const char* s0 = arr1;
	assert(arr1 && arr2);
	if (*arr2 == '\0')
	{
		return (char*)arr1;
	}
	while (*s0)
	{
		s1 = s0;
		s2 = arr2;
		while (*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)s0;
		}
		s0++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s", ret);
	}
	return 0;
}

这里用的是BF算法，也叫做暴力算法，是普通的模式匹配算法。BF算法的思想就是将目标串的第一个字符与模式串的第一个字符进行匹配，若相等，则继续比较目标串的第二个字符与模式串的第二个字符；若不相等，则比较目标串的第二个字符与模式串的第一个字符，依次比较下去，直到得出最后的匹配结果。BF算法效率相对来说会比较低，下面会用图解的形式来理解这个模拟的my_strstr：

当然，我们通过这种常规的方法不难看出两个规律：当匹配不相等的时候，i会返回到主串下标为i-j+1的地方，j则返回到子串下标为0的地方；而当找到的时候，就可以直接将i返回到主串下标为i-j的地方，然后返回这个地址。通过这两个规律，我们就可以来对代码进行简单化处理，不用一直保存着上一次主串和子串指针的位置，修改之后的模拟实现strstr的代码如下（结合数组下标）：

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

char* my_strstr(const char* str, const char* sub)
{
	assert(str && sub);
	if (*sub == '\0')
	{
		return (char*)str;
	}
	int lenStr = strlen(str);
	int lenSub = strlen(sub);
	int i = 0;
	int j = 0;
	while (i < lenStr && j < lenSub)
	{
		if (str[i] == sub[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}
	}
	if (j >= lenSub)
	{
		return (char*)(str + i - j);
	}
	return NULL;
}

int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s", ret);
	}
	return 0;
}

因为BF算法要一个一个找，时间复杂度是主串和子串各自长度的乘积，花费的成本太高，所以后面还会单独地写一篇关于KMP算法的文章，效率相对来说会大大提高。

二、strtok字符串提取

有关strtok的资料：

strtok这个字符串函数理解起来比较难，通过一些资料可以总结出一些点：

1. delimiters参数是个字符串，定义了用作分隔符的字符集合

2. 第一个参数指定一个字符串，它包含了0个或者多个由delimiters字符串中一个或者多个分隔符分割的标记

3. strtok函数找到str中的下一个标记，并将其用'\0'结尾，返回一个指向这个标记的指针（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）

4. strtok函数的第一个参数不为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记

5. 如果字符串中不存在更多的标记，则返回NULL指针

总而言之，strtok函数最核心的就是：strtok函数找第一个标记的时候，函数的第一个参数不是NULL；strtok函数找非第一个参数的时候，函数的第一个参数是NULL。

接下来，先通过一个实现strtok的例子来进一步介绍strtok函数及使用方法：

//strtok字符串提取
#include <stdio.h>
#include <string.h>
int main()
{
	const char* p = "@.#";
	char arr[] = "abcd.ef#gh@cxz";
	char buf[50] = { 0 };
	strcpy(buf, arr);
	char* str = NULL;
	for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
	{
		printf("%s\n", str);
	}
	return 0;
}

这段例子代码需要注意的几点：

1. 在调用strtok函数的时候会对原字符串进行修改，所以arr要先提前拷贝一份buf来进行修改，这里就用到上次说到的strcpy字符串拷贝函数

2. 因为我们每找出一个标记就要调用一次strtok函数，在实际操作中会非常麻烦，所以这里使用了一个for循环来实现。这里非常巧妙地，因为strtok函数找第一个标记的时候，函数的第一个参数不是NULL，而strtok函数找非第一个参数的时候，函数的第一个参数是NULL，这里不难发现，只有找出第一个标记调用的strtok函数第一个参数是buf，其他接下来调用的时候第一个参数都是NULL，所以就可以定义一个初始指针str赋值为strtok(buf, p)，判断条件是不等于NULL，然后接下来的每次都是strtok(NULL, p)，直到strtok函数返回空指针（也就是str等于NULL）为止。

三、strerror错误信息报告

在C语言中规定了一些错误信息，这些错误信息有其对应的错误码，在程序出现不同错误的时候会返回不同的错误码，而strerror函数正好可以把错误码翻译成错误信息，方便快速看出代码错误原因。

还有一点，当库函数使用的时候，发生错误会把errno这个全局的错误变量设置为本次执行库函数产生的错误码，而errno是C语言提供的一个全局变量，可以直接使用，放在errno.h文件中的，所以我们在strerror函数中使用errno这个全局错误变量来进行打印报错信息的时候要引头文件<errno.h>。

四、字符分类函数

函数	如果参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格' '，换页'\f'，换行'\n'，回车'\r'，水平制表符'\t'或垂直制表符'\v'
isdigit	十进制数字0~9
isxdigit	十六进制数字，包括十进制数字，小写字母a~f，大写字母A~F
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z或A~Z
isalnum	字母或数字，a~z，A~Z，0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

以上的这些字符分类函数都是比较简单和比较常用的，要记住！

五、memcpy内存拷贝

有关memcpy的资料：

这里值得注意的点是：

1. 函数memcpy从soure的位置开始向后复制num个字节的数据到destination的内存位置

2. 这个函数遇到'\0'的时候并不会停下来

3. 如果source和destination有任何的重叠，复制的结果都是未定义的

4. 传址的时候需要将其类型转换成void*类型，具体原因在之前关于qsort排序算法的文章中有提到，这里不再做过多描述，如果还没了解可以先看这篇文章：

C语言：深入理解排序算法_Faith_cxz的博客-CSDN博客C语言：深入理解排序算法https://blog.csdn.net/Faith_cxz/article/details/122607698?spm=1001.2014.3001.5502接下来，通过一个memcpy内存拷贝的例子来引出模拟实现memcpy：

//memcpy内存拷贝
#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr1 + 5, 5);
	for (int i = 0; i < 2; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

模拟实现memcpy：

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

void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	my_memcpy(arr2, arr1 + 5, 5*sizeof(arr1[0]));
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

六、memmove内存拷贝

查到的有关memmove的资料基本和memcpy相似，唯一的区别就是：memcpy只能拷贝不重叠的字符串；而memmove能拷贝重叠的字符串，这是C语言要求规定的，所以可以说，memcpy是memmove的一个子集。

接下来通过memmove内存拷贝的一个例子来引出模拟实现memmove：

//memmove内存拷贝
#include <stdio.h>
#include <string.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr, arr + 2, 5 * sizeof(arr[0]));
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

模拟实现memmove：

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

void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr + 2, arr, 5 * sizeof(arr[0]));
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

接下来，通过一个图解来说明模拟实现memmove的思路：

七、memcmp内存比较

有关memcmp的资料：

接下来，通过memcmp的一个例子来引出模拟实现memcmp：

//memcmp内存比较
#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,4,6 };
	int ret = memcmp(arr1, arr2, 16);
	if (ret > 0)
	{
		printf("arr1>arr2");
	}
	else if (ret < 0)
	{
		printf("arr1<arr2");
	}
	else
	{
		printf("arr1=arr2");
	}
	return 0;
}

模拟实现memcmp：

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

int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
	assert(ptr1 && ptr2);
	while (num--)
	{
		if (*(char*)ptr1 == *(char*)ptr2)
		{
			if (num == 0)
			{
				return 0;
			}
			ptr1 = (char*)ptr1 + 1;
			ptr2 = (char*)ptr2 + 1;
		}
		else
		{
			return *(char*)ptr1 - *(char*)ptr2;
		}
	}
}

int main()
{
	int arr1[] = { 1,2,4 };
	int arr2[] = { 1,2,3 };
	int ret = my_memcmp(arr1, arr2, 9);
	if (ret > 0)
	{
		printf("arr1>arr2");
	}
	else if (ret < 0)
	{
		printf("arr1<arr2");
	}
	else
	{
		printf("arr1=arr2");
	}
	return 0;
}

这段模拟实现memcmp的代码值得注意的是：我们在判断返回0的时候，不能再像之前那样判断某个指针指向'\0'就结束并返回0，因为memcmp是对内存进行比较的，是以字节为单位，很有可能其中某一个字节值就是'\0'，可能会导致结束提前，进而导致运行结果错误，这里就要使用我们定义的num，当num减为0的时候，就说明全部都比较完成，才能返回0。

八、memset内存设置

有关memset的资料：

运用memset进行内存设置的一个例子：

//memset内存设置
#include <stdio.h>
#include <string.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memset(arr, 0, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}