• 库函数的使用和模拟实现

    目录

    一、strlen

    1、介绍：

    2、使用：

    3、模拟实现：

    二、strcpy

    1、介绍：

    2、使用：

    3、模拟实现：

    三、strcat

    1、介绍：

    2、使用：

    3、模拟实现：

    四、strstr

    1、介绍：

    2、使用：

    3、模拟实现：

    五、strcmp

    1、介绍：

    2、使用：

    3、模拟实现：

    六、memcpy

    1、介绍：

    2、使用：

    3、模拟实现：

    七、memmove

    1、介绍：

    2、使用：

    3、模拟实现：

    一、strlen

    1、介绍：strlen是获取字符串长度的库函数

    size_t  strlen ( const char * str );

    字符串str的长度由 '\0' 确定：指针从str中第一个字符开始遍历，当遇到str中的首个 '\0' 时，函数返回字符串  str 的长度。

    2、使用：

    1. int main()
    2. {
    3. 	char arr[] = "abc\0defg";
    4.     printf("%d\n", strlen(arr));
    5.  
    6. 	//char arr[] = { 'a','b','c' };	//error，因为没有'\0'，所以长度随机，直到'\0'出现函数停止     
    7.  
    8. 	return 0;
    9. }

    注： 函数返回值是size_t ，是无符号的！！！

    1. int main()
    2. {
    3. 	if(strlen("abc")-strlen("abcdef")>0)   //strlen()返回的是无符号整形，所以输出的始终是正数
    4. 		printf(">0\n");
    5. 	else
    6. 		printf("<0\n");
    7.  
    8. 	return 0;
    9. }

    3、模拟实现：

    1. #include<stdio.h>
    2. #include<assert.h>
    3.  
    4. size_t my_strlen(const char* str)
    5. {
    6. 	assert(str);
    7. 	const char* start = str;
    8. 	const char* end = str;
    9. 	while (*end != '\0')
    10. 	{
    11. 		end++;
    12. 	}
    13. 	return end - start;
    14. }
    15.  
    16. int main()
    17. {
    18. 	char arr[] = "abcdef";
    19. 	int len = my_strlen(arr);
    20. 	printf("%d", len);
    21.  
    22. 	return 0;
    23. }

    二、strcpy

    1、介绍：strcpy是拷贝字符串的库函数

    char * strcpy ( char * destination, const char * source );


    将源字符串复制到目标字符串中，当遍历到源字符串中的'\0'时停止复制

    2、使用：

    1. int main()
    2. {
    3. 	char arr1[10] = "xxxxxxxxxx";
    4. 	const char* p = "abcdef";
    5. 	strcpy(arr1, p);
    6.     printf("%s",arr1);
    7.  
    8. 	char arr2[] = { 'b','c','d','\0','c','c' };
    9. 	strcpy(arr1, arr2);
    10. 	printf("%s\n", arr1);
    11.  
    12. 	return 0;
    13. }

    注：目标字符串大小应足够长以避免溢出，并且不应在内存中与源字符串重叠。

    1. int main()
    2. {
    3. 	char arr1[3] = { 0 };
    4. 	char arr2[] = "abcdef";
    5. 	strcpy(arr1, arr2);		//error!!! 目标字符串arr1的空间小于源字符串arr2的
    6. 	printf("%s\n", arr1);
    7. 	return 0;
    8. }

    3、模拟实现：

    1. #include<stdio.h>
    2. #include<assert.h>
    3. char* my_strcpy(char* dest, const char* src)
    4. {
    5. 	assert(dest);
    6. 	assert(src);
    7. 	char* ret = dest;
    8. 	while (*dest++ = *src++)
    9. 	{
    10. 		;
    11. 	}
    12. 	return ret;
    13. }
    14. int main()
    15. {
    16. 	char arr1[20] = "abc";
    17. 	char arr2[] = "hello world";
    18. 	printf("%s\n", my_strcpy(arr1, arr2));
    19. 	return 0;
    20. }

    三、strcat

    1、介绍：strcat是连接字符串的库函数

     char * strcat ( char * destination, const char * source );

    连接字符串将源字符串的副本追加到目标字符串。目标字符串的 '\0' 被源字符串的第一个字符覆盖，并且空字符包含在由目标中两者的串联组成的新字符串的末尾。
    注：目的地和源不得重叠，当源字符串遍历到 '\0' 时停止

    2、使用：

    1. int main()
    2. {
    3.     char arr1[20]="hello";
    4.     char arr2[]=" world";
    5.     strcat(arr1,arr2);
    6.     printf("%s",arr1);
    7.     return 0;
    8. }

    3、模拟实现：

    1. char* my_strcat(char* dest, const char* src)
    2. {
    3. 	//1.找目标空间中的\0
    4. 	char* cur = dest;
    5. 	while (*cur)
    6. 	{
    7. 		cur++;
    8. 	}
    9. 	//2.拷贝源头数据到\0之后的空间
    10. 	while (*cur++ = *src++)
    11. 	{
    12. 		;
    13. 	}
    14. 	return dest;
    15. }
    16. int main()
    17. {
    18. 	//char arr1[20] = "bit";
    19. 	//my_strcat(arr1, arr1);
    20. 	//error  不可以对自身进行字符串添加
    21.  
    22. 	char arr1[20] = "hello ";
    23. 	char arr2[] = "world";
    24. 	printf("%s\n", my_strcat(arr1, arr2));
    25. 	return 0;
    26. }

    四、strstr

    1、介绍：strstr是在一个字符串中查找另一个字符串的库函数

    const char * strstr ( const char * str1, const char * str2 );

    定位子字符串返回指向 str1 中第一次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回空指针。
    匹配过程不包括 '\0' ，但它在那里停止。

    2、使用：

    1. int main()
    2. {
    3. 	char arr1[] = "abcdef";
    4. 	char arr2[] = "cde";
    5.  
    6. 	char* p = strstr(arr1, arr2);
    7. 	if (p == NULL)
    8. 		printf("不存在\n");
    9. 	else
    10. 		printf("%s\n", p);
    11. 	return 0;
    12. }

     3、模拟实现：

    1. #include<stdio.h>
    2. char* my_strstr(const char* str1, const char* str2)
    3. {
    4. 	const char* s1 = str1;
    5. 	const char* s2 = str2;
    6. 	const char* p = str1;
    7. 	if (*str2 == '\0')
    8. 		return str1;
    9. 	while (*p)
    10. 	{
    11. 		s1 = p;
    12. 		s2 = str2;
    13. 		while (*s1 != '\0' && *s2 != '\0' && (*s1 == *s2))
    14. 		{
    15. 			s1++;
    16. 			s2++;
    17. 		}
    18. 		if (*s2 == '\0')
    19. 			return(char*)p;
    20. 		p++;
    21. 	}
    22. 	return NULL;
    23. }
    24. int main()
    25. {
    26. 	char arr1[] = "abcdef";
    27. 	char arr2[] = "cde";
    28.  
    29. 	char* p = my_strstr(arr1, arr2);
    30. 	if (p == NULL)
    31. 		printf("不存在\n");
    32. 	else
    33. 		printf("%s\n", p);
    34. 	return 0;
    35. }

    五、strcmp

    1、介绍：strcmp是一个比较字符串大小（ascll码值）的库函数

    int strcmp ( const char * str1, const char * str2 );


    函数比较每个字符串的每一个字符。如果它们彼此相等，则继续执行比较的操作，直到字符不同或达到终止空字符。
    第一个字符串大于第二个字符串时返回1，第一个字符串等于第二个字符串时返回0，第一个字符串小于第二个字符串时返回1

    2、使用：

    1. int main()
    2. {
    3. 	char arr1[] = "abc";
    4. 	char arr2[] = "abcde";
    5.  
    6. 	int ret = strcmp(arr1, arr2);
    7.     if (ret < 0)
    8. 		printf("arr1);
    9. 	else if(ret>0)
    10. 		printf("arr1>arr2\n");
    11. 	else
    12. 		printf("arr1==arr2\n");
    13.  
    14. 	printf("%d\n", ret);
    15. 	return 0;
    16. }

    3、模拟实现：

    1. #include<stdio.h>
    2. #include<assert.h>
    3. int my_strcmp(const char* s1, const char* s2)
    4. {
    5. 	assert(s1 && s2);
    6. 	while(*s1 == *s2)
    7. 	{
    8. 		if (*s1 == 0)
    9. 			return 0;
    10. 		s1++;
    11. 		s2++;
    12. 	}
    13. 	return s1 - s2;
    14. }
    15. int main()
    16. {
    17. 	char arr1[] = "abc";
    18. 	char arr2[] = "abc";
    19.  
    20. 	int ret = my_strcmp(arr1, arr2);
    21.     if (ret < 0)
    22. 		printf("arr1);
    23. 	else if(ret>0)
    24. 		printf("arr1>arr2\n");
    25. 	else
    26. 		printf("arr1==arr2\n");
    27.  
    28. 	printf("%d\n", ret);
    29. 	return 0;
    30. }

    六、memcpy

    1、介绍：memcpy是一个复制内存的库函数

    void * memcpy ( void * destination, const void * source, size_t num );

    复制内存块将数字字节的值从源指向的位置直接复制到目标所指向的内存块。
    为避免溢出，目标和源参数所指向的数组大小应至少为数字字节，并且不应重叠（对于重叠的内存块，复制后与预期不符）

    2、使用：

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

    注：内存折叠无法拷贝

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

    3、模拟实现：

    1. #include<string.h>
    2. #include<assert.h>
    3. void* my_memcpy(void* dest, void* src, size_t num)
    4. {
    5. 	void* ret = dest;
    6. 	assert(dest);
    7. 	assert(src);
    8. 	while (num--)
    9. 	{
    10. 		*(char*)dest = *(char*)src;
    11. 		dest = (char*)dest + 1;
    12. 		src = (char*)src + 1;
    13. 	}
    14. 	return ret;
    15. }
    16. int main()
    17. {
    18. 	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    19. 	int arr2[10] = { 0 };
    20. 	my_memcpy(arr2, arr1, 20);
    21. 	for (int i = 0; i < 10; i++)
    22. 	{
    23. 		printf("%d ", arr2[i]);
    24.     }
    25.     return 0
    26. }

    七、memmove

    1、介绍：memmove是一个移动内存的库函数

    void * memmove ( void * destination, const void * source, size_t num );

    移动内存块将数字字节的值从源指向的位置复制到目标所指向的内存块。复制就像使用了中间缓冲区一样进行，从而允许目标和源重叠。
    源指针和目标指针所指向的对象的基础类型与此函数无关;
    该函数不检查源代码中的任何终止空字符 - 它始终精确复制数字字节。
    为避免溢出，目标和源参数所指向的数组大小应至少为数字字节。

    注：memmove相比于memcpy，可以出现空间重叠

    2、使用：

    1. int main()
    2. {
    3.     int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    4. 	memmove(arr1 + 4, arr1, 20);
    5. 	for (int i = 0; i < 10; i++)
    6. 	{
    7. 		printf("%d ", arr1[i]);
    8. 	}
    9. 	//内存折叠仍可以拷贝
    10. }

    3、模拟实现：

     

    1. #include<stdio.h>
    2. #include<assert.h>
    3. void* my_memmove(void* dest, void* src, size_t num)
    4. {
    5. 	void* ret = dest;
    6. 	assert(dest);
    7. 	assert(src);
    8. 	while (num--)
    9. 	{
    10. 		if (dest < num)	//1. 前->后
    11. 		{
    12. 			*(char*)dest = *(char*)src;
    13. 			dest = (char*)dest + 1;
    14. 			src = (char*)src + 1;
    15. 		}
    16. 		else	//2. 后->前
    17. 		{
    18. 			*((char*)dest + num )= *((char*)src + num);
    19. 		}
    20. 	}
    21. 	return ret;
    22. }
    23. int main()
    24. {
    25.     int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    26.     int arr2[10] = { 0 };
    27.     my_memcpy(arr2, arr1, 20);
    28.     for (int i = 0; i < 10; i++)
    29.     {
    30.     	printf("%d ", arr2[i]);
    31.     }
    32.     return 0;
    33. }

  • 相关阅读:
    linux安装activemq
    【云原生】学习K8s，读完这篇就够了
    els 长条碰撞变形判断
    试用信号灯实现如图所示的进程同步关系
    【JVM调优实战100例】03——JVM堆调优四例
    位运算的一些经典题目
    Python 自动化脚本系列：第3集
    Excel_VBA编程
    ElasticSearch（九）【SpringBoot整合】
    【进阶篇】Java 实际开发中积累的几个小技巧（一）
  • 原文地址：https://blog.csdn.net/xh1605004242/article/details/126841786