C语言字符与字符串库函数的使用以及模拟实现（下）

超烦豆先森
410 阅读8分钟

上篇：​juejin.cn/post/712185…

一、字符串查找

strstr ：是一个查找子串的函数，就是在一个字符串中查找了一个字符串存不存在。

1.strstr 如何使用呢？

​

        这个函数有两个参数，第一个参数是比较长的串，第二个是子串；函数的目的是要在这个比较长的串中查找子串是否存在。如果找到了子串会返回子串在长串的起始位置，找不到则返回一个空指针

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

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "cde";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("子串不存在\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

 子串如果存在，代码会打印从子串起始位置到 \0 的字符。

strstr 的头文件：

代码结果：

​

2.strstr 模拟实现

可能遇到的两种情况：

情况1

这一种情况是最简单的。

情况2

       值得注意的是，当s2全都对比过后还没有查找到，而且s1还有字符为对比过，则就要把s2重置到起始位置，把s1重置到第一次与s2相等的后面的字符，然后从这里开始对比，直到结束。 

代码实现：

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

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* p = str1;
	const char* s1 = str1;
	const char* s2 = str2;
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)p;
		}
		p++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "cde";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("子串不存在\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

3.strtok 字符串切割函数

字符串切割函数，把你想要的内容给切割出来。

这个函数有两个参数，返回类型是 char* ，

  • sep 参数是是个字符串，定义了用作分隔符的字符集合。

这一点是什么意思呢？

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

int main()
{
	//假设是这个字符串：abcdefg@lilong.com
	char* sep = "@.";//@ 和 . 就是分隔符
	return 0;
}
  • 第一个参数指定一个字符串，它包含了 0 个或者多个由 sep 字符串中的一个或者多个分隔符分割的标记。
  • strtok函数找到str中的下一个，并蒋用大学结，的课指向这个标记的指针。 (注：strtok 函数会改变被操作的字符串，所以在使用 strtok 函数切分的字符串一般都是临时拷贝的内容并且可修改。)

这一点是什么意思呢？

​

 会返回 \0 之前的字符串。

  • strtok 函数的第一个参数不为 NULL，函数将找到str中第一个标记，strtok 函数将保存它在字符串中的位置。
  • strtok 函数的第一个参数为 NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
  • 如果字符串中不存在更多的标记，则返回NULL指针。

头文件是 <string.h>

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

int main()
{
	//假设是这个字符串：abcdefg@lilong.com
	const char* sep = "@.";//@ 和 . 就是分隔符
	char str[] = "abcdefg@lilong.com";
	char cp[30] = { 0 };
	strcpy(cp, str);

	char* ret = NULL;
	for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

 代码结果：

​

 二、错误信息报告

strerror ：错误信息报告函数，返回错误码，所对应的信息。

函数的参数及返回类型

​

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

//errno - 是C语言设置的一个全局的错误码存放的变量
int main()
{
    //"r" - 以读的形式打开 "test.txt" 这个文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		printf("%s\n", strerror(errno));
        //使用errno是需要引用头文件<errno.h>
		return 1;
	}
	else
	{
		printf("haha\n");
	}
	return 0;
}

  因为文件不存在，所以strerror 函数会返回一个错误信息。

代码结果：

三、字符操作

字符分类函数

iscntrl：如何控制字符

isspace：空白字符：空格' '、换页'\f'、换行'\n'、回车'\r'、制表符'\t'或者垂直制表符'\v'

isdigit：十进制数字 0~9

isxdigit：十六进制数字，不搜阔所以十进制数字，小写字母 af、大写字母 AF

islower：小写字母 a~z

isupper：大写字母 A~Z

isalpha：字母a-z 或者 A~Z

isalnum：字母或者数字，a-z、A-Z、0~9

ispunct：标点符号，任何不属于数字或者字母的图形字符（可打印）

isgraph：任何图形字符

isprint：任何可打印字符，包括图形字符和空白字符

因为这些函数使用起来比较简单，这里就不一一介绍了。大家可以去 cplusplus.com 这个网站查看；也可以使用 MSDN 来查看。

字符转换函数：

int tolower(int c);

int toupper(int c);

#include<stdio.h>
#include<ctype.h>

int main()
{
	printf("%c\n", tolower('A'));
    //将大写字母转化为小写
	return 0;
}

代码结果：

​

tolower 只有大写字母才会转化为小写字母，如果是其他的则不变。 

四、内存操作函数

1.memcpy内存拷贝函数如何使用呢？

memcpy： 内存拷贝函数

        当不确定要拷贝内容的类型是什么的时候。可以把内存拷贝过去，这样不管是什么类型都可以拷贝。不用 strcpy 是因为它是字符串的拷贝函数，只能用来拷贝字符串。

 num 表示要拷贝多少个字节的内容，source 表示源空间，destination 表示目标空间。

代码结果：  

 src 里的内容拷贝成功！

为什么这个函数的参数和返回类型是 void 呢？*

因为 void* 是一个泛型指针，它的通用高，当不确定是什么类型的时候使用它更加方便快捷。

2.模拟实现 memcpy

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

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

int main()
{
	int src[] = { 5,6,7,8,9 };
	int dest[10] = { 0 };
	my_memcpy(dest, src, sizeof(src));
	return 0;
}

拷贝的数据是 int 类型的，但是这里为什么要使用 char* 来强制类型转换呢？

一个整形4个字节，如果强转为 int* 只能一次性拷贝4个字节，但如果要拷贝3个、11个或者是21个的（4的倍数）时候 int* 明显不合适，这个时候就可以使用最细致的 char* ，一次拷贝一个字节，通用型更强。

memcpy 是不用来处理重叠的内存之间的数据拷贝的

​

3.重叠内存之间的数据拷贝

memmove ：也是一个内存拷贝函数，但是可以拷贝重叠内存之间的数据。

这是他的返回类型、参数和头文件

​

值得注意的是它与 ，memcpy 的参数一样 。都是目标空间、源空间、和要拷贝的字节数。说明它的用法也是一样的。

下面的代码目的是将 1、2、3、4、5 拷贝到 3、4、5、6、7 上去，但是实际的结果是什么呢？

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

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

void test1()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	int dest[20] = { 0 };
	my_memcpy(dest, src, 20);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", dest[i]);
	}
}

void test2()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memcpy(src + 2, src, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", src[i]);
	}
}

int main()
{
	test2();
	return 0;
}

 代码结果：

如果拷贝成功了，代码的结果应该是：

1 2 1 2 3 4 5 8 9 10 

那为什么会出错呢？

是因为 memcpy 不能拷贝重叠内存之间的数据，要使用memmove来拷贝

 

memmove 库函数的使用方法：

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

void test2()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(src + 2, src, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", src[i]);
	}
}

int main()
{
	test2();
	return 0;
}

 代码结果：

这次拷贝成功了。 

​

 4.memmove 模拟实现

在实现 memmove 会出现三种情况。

第一种：从前往后处理数据

​

 当 src 的起始地址在 dest 的起始地址左边的时候，就要采用从前往后处理数据的方式（先拷贝4，最后拷贝8）来避免数据重叠而带来的错误。

第二种：从后往前处理数据

​

 在 dest 的起始位置在 src 的范围内的时候，就要采用从后往前处理数据的方式（先拷贝5，最后拷贝1）来避免数据重叠而带来的错误。

​

第三种：前往后，后往前任意

​

  在 dest 的起始位置不在 src 的范围内的时候，采用前往后，后往前任意

如果是第一种情况就采用 前往后， 如果是第二、三两种情况就采用 后往前。

代码实现：

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

void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	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;
}

void test()
{
	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(src + 2, src, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", src[i]);
	}
}

int main()
{
	test();
	return 0;
}

​

5.内存比较

memcmp ：内存比较函数

参数、返回类型和头文件：

buf1 和 buf2 指向两块空间，count 表示向后在 count 个字节内部比较。

 如果要比较两块内存里的数据是否相同，就可以使用 memcmp

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

int main()
{
	int arr1[] = { 1,2,3 };
	int arr2[] = { 1,3,2 };
	int ret = memcmp(arr1, arr2, 12);
	printf("%d\n", ret);
	return 0;
}

如果第一块内存大于第二块内存，返回一个大于0的数字； 如果第一块内存等于第二块内存，返回数字0； 如果第一块内存小于第二块内存，返回一个小于0的数字； 

memcmp 也是一对一对比较的。

arr1：01 00 00 00 02 00 00 00 03 00 00 00
arr2：01 00 00 00 03 00 00 00 02 00 00 00

一对比可以很明显的看出 arr1 小于 arr2 ，所以返回小于0的数字。

代码结果：

注意：

  • memcmp 可以比较字符串也可以比较任意类型的数据。
  • memcmp 只有当参数中所有的字节都比较完后才会结束。

​

6.内存设置

memset ：内存设置函数

参数、返回类型和头文件：

 如果有一份数据等待着对他初始化，就可以使用 memset 。

dest 参数是设置的填充空间，c 参数是要设置的值，count 参数是要设置的值的字节数

例1：

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

int main()
{
	char arr[] = "hello world";
	memset(arr, 'x', 5);
	printf("%s\n", arr);
	return 0;
}

代码的含义是将arr数组中的前5个字节的内容设置为字符x。

代码结果：

​

例2：

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

int main()
{
	char arr[] = "hello world";
	memset(arr + 6, 'x', 5);
	printf("%s\n", arr);
	return 0;

代码结果： ​

avatar
文章
阅读
粉丝