字符串函数和内存操作函数的功能，使用方法，注意事项及模拟实现（strlen、strcpy、strcat、strcmp、strstr、strerror、memcpy、memmove、memcmp等）

1. 前言

本篇博客会给大家介绍常见的字符串函数和内存函数的功能，用法，并模拟实现这些函数。
如果对大家有帮助的话，请大家点赞收藏关注，支持一下博主，谢谢大家。

2. 正文

2.1 字符串函数

C语言中对字符和字符串的处理很频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数。
字符串函数又分为，长度不受限制的字符串函数和长度受限制的字符串函数，下面我们来分类讨论。

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

2.2.1 strlen函数

功能：求字符串长度
定义：size_t strlen(const char* str);
注意事项：
参数必须是一个地址。
字符串以\0作为结束标志，strlen函数返回的是字符串中\0前面出现的字符个数，不包括\0。
参数指向的字符串必须以\0结束。
函数的返回值是size_t，是一个无符号值，使用前需要强制类型转换。

使用方法：

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

模拟实现：

//方法1：计数器实现
size_t my_strlen(const char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

//方法2：递归
size_t my_strlen(const char* str)
{
	if (*str == '\0')
	{
		return 0;
	}
	else
	{
		return 1 + my_strlen(str + 1);
	}
}

//方法3：指针-指针
size_t my_strlen(const char* str)
{
	char* p = str;
	while (*p != '\0')
	{
		p++;
	}
	return p - str;
}

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

2.2.2 strcpy函数

功能：字符串拷贝
定义：char* strcpy(char* destination, const char* source);
注意事项：
把源字符串的内容拷贝到目标字符串。
源字符串必须以\0结尾，此函数会同时将源字符串中的\0拷贝到目标字符串中。
目标空间必须足够大，确保能够存放源字符串，目标空间也必须可变。
strcpy等函数返回的是目标空间的起始地址，返回类型的设置是为了实现链式访问。

使用方法：

int main()
{
	char arr1[20] = {0};
	char arr2[] = "666";
	printf("%s\n", strcpy(arr1, arr2));
	return 0;
}

模拟实现：

char* my_strcpy(char* destination, const char* source)
{
	assert(destination && source);
	char* p = destination;
	while ((*destination++ = *source++))
	{
		;
	}
	return p;
}

int main()
{
	char arr1[20] = {0};
	char arr2[] = "666";
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}

2.2.3 strcat函数

功能：字符串追加
定义：char* strcat(char* destination, const char* source);
注意事项：
把源字符串的内容追加到目标字符串后面，从目标字符串的\0处开始追加。
源字符串必须以\0结尾。
目标空间必须足够大，确保能够存放源字符串，目标空间也必须可变。

使用方法：

int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "666";
	printf("%s\n", strcat(arr1, arr2));
	return 0;
}

模拟实现：

char* my_strcat(char* destination, const char* source)
{
	assert(destination && source);
	char* p = destination;
	while (*destination != '\0')
	{
		destination++;
	}
	while ((*destination++ = *source++))
	{
		;
	}
	return p;
}

int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "666";
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;
}

2.2.4 strcmp函数

功能：比较两个字符串的大小，比的不是字符串的长度，而是对应位置上的字符ASCII值的大小。
定义：int strcmp(const char* str1, const char* str2);
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字。
第一个字符串等于第二个字符串，则返回0。
第一个字符串小于第二个字符串，则返回小于0的数字。

使用方法：

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdeg";
	int i = strcmp(arr1, arr2);
	if (i > 0)
	{
		printf("arr1 > arr2");
	}
	else if (i < 0)
	{
		printf("arr1 < arr2");
	}
	else
	{
		printf("arr1 = arr2");
	}
	return 0;
}

模拟实现：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	return (*str1 - *str2);
}

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdeg";
	int i = my_strcmp(arr1, arr2);
	if (i > 0)
	{
		printf("arr1 > arr2");
	}
	else if (i < 0)
	{
		printf("arr1 < arr2");
	}
	else
	{
		printf("arr1 = arr2");
	}
	return 0;
}

2.3 长度受限制的字符串函数

此类函数与长度不受限制的字符串函数的使用方法、注意事项及模拟实现非常相似，故不再展示。

2.3.1 strncpy函数

定义：char* strncpy(char* destination, const char* source, size_t num);
注意事项：拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

2.3.2 strncat函数

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

2.3.3 strncmp函数

定义：int strncmp(const char* str1, const char* str2, size_t num);
注意事项：
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

2.4 字符串查找函数

2.4.1 strstr函数

功能：在母串中寻找字串第一次出现的位置。
定义：char* strstr(const char* str1, const char* str2);
注意事项：
在str1中查找匹配str2，即寻找子串在母串中第一次出现的位置。
返回值是str1中第一次匹配成功的地址。
匹配失败则返回NULL。

使用方法：

int main()
{
	char arr1[] = "abbbcdbbcefg";
	char arr2[] = "bbc";
	printf("%s\n", strstr(arr1, arr2));
	return 0;
}

模拟实现：

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

int main()
{
	char arr1[] = "abbbcdbbcefg";
	char arr2[] = "bbc";
	printf("%s\n", my_strstr(arr1, arr2));
	return 0;
}

2.4.2 strtok函数

功能：字符串切割
定义：char* strtok(char* str, const char* sep);
注意事项：
sep参数是个字符串，定义了用作分隔符的字符集合。
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。
（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

使用方法：

int main()
{
	char arr1[30] = "abc@def#ghi jkl";
	char arr2[] = "@# ";
	//printf("%s\n", strtok(arr1, arr2));//只找第一个标记
	//printf("%s\n", strtok(NULL, arr2));//从保存好的位置继续往后找
	char* p = arr1;
	char* s = NULL;
	for (s = strtok(p, arr2); s != NULL; s = strtok(NULL, arr2))
	{
		printf("%s\n", s);
	}
	return 0;
}

2.5 其他类型函数

2.5.1 strerror函数

功能：报告错误信息
定义：char* strerror(int errnum);
注意事项：
将对应的错误码转换成对应的错误信息。
返回的是该错误信息字符串的起始地址。

2.5.2 字符分类函数

此类型函数使用方法基本一致：如果函数的参数符合条件就返回真。

头文件 - ctype.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 - 任何可打印字符，包括图形字符和空白字符

2.5.3 字符转换函数

int tolower(int c);
将该字母转换为对应的小写字母。
int toupper(int c);
将该字母转换为对应的大写字母。

2.6 内存操作函数

2.6.1 memcpy函数

功能：内存拷贝
定义void* memcpy(void* destination, const void* source, size_t num);
注意事项：
memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置，一个字节一个字节复制。
遇到\0不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

使用方法：

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

模拟实现：

void* my_memcpy(void* destination, const void* source, size_t num)
{
	assert(destination && source);
	void* p = destination;
	while (num--)
	{
		*(char*)destination = *(char*)source;
		destination = (char*)destination + 1;
		source = (char*)source + 1;
	}
	return p;
}

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

2.6.2 memmove函数

功能：基本同memcpy
定义：void* memmove(void* destination, const void* source, size_t num);
注意事项：
和memcpy的差别是memmove函数处理的源内存块和目标内存块是可以重叠的。

使用方法：

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

模拟实现：

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

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

2.6.3 memcmp函数

功能：内容比较
定义：int memcmp(const void* ptr1, const void* ptr2, size_t num);
注意事项：
比较从ptr1和ptr2指针开始的num个字节,一个字节一个字节比较。
当ptr1 当ptr1=ptr2时，返回值=0
当ptr1>ptr2时，返回值>0

3.结尾

本篇博客展示出大部分常见、常用的字符串函数和内存函数的功能，用法，以及他们的模拟实现。如果大家看完觉得对自己有帮助的话，可以点赞收藏关注一波，以后还会有更多的技术博客发布，如果有什么问题或者本博客有什么错误的地方欢迎评论区留言讨论。