[C语言进阶] 之重点字符函数和字符串函数的介绍及模拟实现(strlen,strcmp....)

目录

1.strlen

1.1 strlen模拟实现

2.strcpy

2.2 strcpy模拟实现

3.strcat

3.2 strcat模拟实现

4.strcmp

 4.2 strcmp模拟实现

5.strstr

5.2strstr模拟实现

6.memcpy

6.1memcpy模拟实现：

7.memmove

7.1memmove模拟实现

---

前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串 中或者 字符数组中。字符串常量适用于那些对它不做修改的字符串函数。

1.strlen

头文件： #include

作用：字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
 

注意要点：

1、参数指向的字符串必须要以 '\0' 结束。
2、注意函数的返回值为size_t，是无符号的（ 易错 ）。

练习：

#include 
//int main()
//{
//	int len = strlen("abcdef");
//	printf("%d\n", len);
//	return 0;
//}

运行结果：6

1.1 strlen模拟实现

#include 
int my_strlen(const char* str)
{
	assert(str);
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);
	return 0;
}

运行结果： 6

注：模拟实现strlen有多种方法，这里的方法是最简单的计数器方法。

1.计数器的方法
2.递归的方法
3.指针-指针
4.调试

2.strcpy

头文件：#include

作用：将源字符串拷贝到目标空间中。

注意要点：

1、源字符串必须以 '\0' 结束。
2、会将源字符串中的 '\0' 拷贝到目标空间。
3、目标空间必须足够大，以确保能存放源字符串。
4、目标空间必须可变。

练习:

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

结果：abcdef

2.2 strcpy模拟实现
 

char* my_strcpy(char* dest,const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = "XXXXXXXXXX";
	my_strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

运行结果：abcdef

3.strcat

头文件：#include

作用：将源字符串追加到目标字符串后

注意要点：

1、源字符串必须以 '\0' 结束。
2、目标空间必须有足够的大，能容纳下源字符串的内容。
3、目标空间必须可修改
 

练习：

int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

运行结果：helloworld

3.2 strcat模拟实现

char* my_strcat(char* dest,const char* src)
{
	char ret = dest;
	assert(dest && src);
	//目标空间的\0
	while (*dest != '\0')
	{
		dest++;
	}
	//追加内容到目标空间
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

运行结果：helloworld

4.strcmp

头文件：#include

作用：比较两个字符串的大小(注意：这个大小不是长短，是指的是对应字符的ASCII码值的大小)

标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

 练习：

int main()
{
	//比较的是对应位置上的字符大小
	char arr1[]= "abcdef";
	char arr2[] = "abq";
	//a和a相比 相等 往后走
	//返回 >1 相等0  <-1
	int ret = strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

运行结果：-1 

比较过程：arr1 和 arr2的前两个字符相同，比较第三个字符，arr1中的字符c对应的ASCII码值小于arr2中的字符q对应的ASCII码值，因此返回负数。之所以返回-1，这是库函数的规定。

附：ASCII码值表

 4.2 strcmp模拟实现

模拟实现
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;
}
int main()
{
	//比较的是对应位置上的字符大小
	char arr1[] = "abcdef";
	char arr2[] = "abq";
	int ret =my_strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

运行结果：-1

5.strstr

头文件：#include

作用：在目标字符串中查找源字符串，如果找到，则返回目标字符串中第一次包含源字符串之后的所以字符串，若未找到，则返回NULL

练习：

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "bcd";
	char* ret = strstr(arr1, arr2);
	if (NULL == ret)
	{
		printf("没找到\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

运行结果：bcdef

5.2strstr模拟实现

char* my_strstr(const char* str,const char* substr)
{
	const char* s1 = str;
	const char* s2 = substr;
	char* cur = str;

	assert(str && substr);
	if (*substr == '\0')
	{
		return str;
	}
	while (*cur)
	{
		s1 = cur;
		s2 = substr;
		while (*s1 && *s2 &&*s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cur;
		}
		cur++;
	}
	return NULL;

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

运行结果：bbcdef

注意：

char arr1[] = "abbbcdef";

 char arr2[] = "bbc";

arr2在arr1存在，但是要比较多次，并且需要改变位置，因此引入cur来记录实时arr1的位置，s1,s2分别表示arr1和arr2挪动到的字符。

6.memcpy

头文件：#include

作用：函数memcpy从开始的位置开始向后复制num个字节的数据到目标的内存位置。

注意要点：

1、这个函数在遇到 '\0' 的时候并不会停下来。
2、如果source和destination有任何的重叠，复制的结果都是未定义的。
练习：

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

运行结果：1 2 3 4 5

6.1memcpy模拟实现：

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[5] = { 0 };
	my_memcpy(arr2, arr1, 20);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

运行结果：1 2 3 4 5

7.memmove

头文件：#include

作用：与memcpy相似。和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。如果源空间和目标空间出现重叠，就得使用memmove函数处理。
 

7.1memmove模拟实现

//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, 20);
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		printf("%d\n", arr[i]);
//	}
//	return 0;
//}

memmove可以操作可重叠空间，因此之后编程过程中，如果不重叠拷贝内存，就是用memcpy,否则使用memmove。

 (本篇完)