• C语言之字符函数&字符串函数篇（1）

    目录

    前言

    求字符串长度

     strlen

    strlen统计的是字符串\0之前的字符串长度

    字符指针

    strlen的返回值是无符号整型

    strlen的三种模拟实现 

    计数器

    函数递归 

    指针_指针

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

    strcpy

    strcpy会将源字符串中的 '\0' 拷贝到目标空间

    strcpy参数目标空间必须足够大且可变

    strcpy的模拟实现

    strcat

    strcat有将源头字符串的\0追加过去

    strcat字符串自己追加自己 

    strcat的模拟实现

    strcmp

    strcmp的返回值

    strcmp的模拟实现

    长度受限制的字符串函数

    strncpy

    num<

    无拷贝'\0'  

    num>

    strncat

    num<

    是追加'\0' 

    num> 

    strncmp

    >0

    <0

    =0

    总结

    接下来我们进入字符函数和字符串函数的讲解。中秋和国庆即将来临，终于要放假了回家了。

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

    我们重点讲解：字符串函数 字符函数 内存函数

    关于下面的字符串函数我们将从：作用  头文件  参数 返回值 等方面去介绍。

    前言

     printf打印字符串是打印\0之前的字符串。看到\0停止打印了

    1. #include
    2. int main()
    3. {
    4. 	char arr[10] = "abc\0def";
    5. 	printf("%s\n", arr);
    6. 	return 0;
    7. }

     

    需要用到的头文件

    1. #include
    2. #include
    3. #include
    4. //断言和const修饰的指针在调试讲过

    求字符串长度

     strlen

    strlen - C++ Reference

    • strlen是库函数，是用来求字符串长度的
    • strlen求字符串长度本质上统计的是字符串\0之前的字符串长度。
    • 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前的字符个数（不包含 '\0' )
    • strlen的头文件是#include
    • strlen的参数 是 const char *str （把字符串的首元素地址传给strlen)(const 是为了确保库函数strlen里的操作将主函数main的字符串改变了）
    • 参数指向的字符串必须要以 '\0' 结束。
    • strlen的返回值是 size_t 类型的，返回的数值是无符号的整型
    • strlen的模拟实现需要掌握（计数器  函数递归  指针_指针）

    strlen统计的是字符串\0之前的字符串长度

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	char arr1[] = "abcdef";
    6. 	size_t ret =strlen(arr1);
    7. 	char arr2[] = "abc\0def";//统计的是\0之前的字符串长度
    8. 	size_t r = strlen(arr2);
    9. 	printf("arr1=%d,arr1=%d", ret, r);
    10. 	return 0;
    11. }

     

    字符指针

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	char arr1[] = "abcdef";
    6. 	size_t ret =strlen(arr1);
    7. 	char* p = "abcdef";//这里p存储的就是字符串的首元素地址 起始地址
    8. 	size_t r = strlen(p);
    9. 	printf("ret=%d r=%d", ret, r);
    10. 	return 0;
    11. }

    strlen的返回值是无符号整型

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	//          3                 6       
    6. 	if (strlen("abc") - strlen("abcdef") > 0)//正数，3为无符号数是一个很大的数
    7. 	{
    8. 		printf(">\n");
    9. 	}
    10. 	else
    11. 	{
    12. 		printf("<\n");
    13. 	}
    14. 	return 0;
    15. }
    16.  
    17. 3为无符号整数的时候
    18. //00000000 00000000 00000000 00000011 原码
    19. //为无符号为所以没有符号位，所以全部取反加1
    20. //11111111 11111111 11111111 11111101 补码
    21. 6
    22. //00000000 00000000 00000000 00000110 原码
    23. //11111111 11111111 11111111 11111010 补码
    24.  
    25. //3>6

    strlen的三种模拟实现 

    计数器
    1. #include
    2. size_t my_strlen(char* p)
    3. {
    4. 	int count = 0;
    5. 	while (*p)
    6. 	{
    7. 		count++;
    8. 		p++;
    9. 	}
    10. 	return count;
    11. }
    12. int main()
    13. {
    14. 	char arr[] = "abcdef";
    15. 	size_t ret = my_strlen(arr);
    16. 	printf("%zd\n", ret);
    17. 	return 0;
    18. }
    19.  
    20.
    函数递归 
    1. #include
    2. size_t my_strlen(const char* p)
    3. {
    4. 	if (*p == '\0')
    5. 		return 0;
    6. 	else
    7. 	{
    8. 		return 1 + my_strlen(p+1);//切记不要p++,++p这种副作用的++
    9. 	}
    10. }
    11. int main()
    12. {
    13. 	char arr[] = "abcdef";
    14. 	size_t ret = my_strlen(arr);
    15. 	printf("%zd", ret);
    16. 	return 0;
    17. }
    指针_指针
    1. #include
    2. int my_strlen(char* p)
    3. {
    4. 	char* r = p;//起始地址
    5. 	while (*p != '\0')
    6. 	{
    7. 		p++;
    8. 	}
    9. 	return p - r;
    10. }
    11. int main()
    12. {
    13. 	char arr[] = "abcdef";
    14. 	int ret=my_strlen(arr);
    15. 	printf("%d", ret);
    16. 	return 0;
    17. }

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

    下面我们介绍的是长度不受限制的字符串函数。

    strcpy

     strcpy - C++ Reference (cplusplus.com)

    • strcpy是库函数，是用来字符串拷贝的，会将源字符串中的 '\0' 拷贝到目标空间。
    • 本质就是 将源头字符串source（包括\0)  拷贝到 目的地空间中的字符串destination里
    • strcpy的头文件是 #include
    • strcpy的参数 一个是指向 源头字符串的首元素地址  指针变量source 
    • 源字符串必须以 '\0' 结束。
    • strcpy的另外一个参数是指向 目的地空间字符串的首元素地址 指针变量destination 
    • 目标空间必须足够大，以确保能存放源字符串。
    • 目标空间必须可变。
    • strcpy函数的返回值是 目标空间的起始地址
    • strcpy的模拟实现
    • 链式访问和assert

    strcpy会将源字符串中的 '\0' 拷贝到目标空间

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "xxxxxxxxxxxxx";
    5. 	printf("%s\n", arr1);
    6. 	char arr2[] = "abcdef";//会将\0拷贝过去，所以不会有xxxxx
    7. 	strcpy(arr1, arr2);
    8. 	printf("%s", arr1);
    9. 	return 0;
    10. }

    strcpy参数目标空间必须足够大且可变

    1. #include
    2. int main()
    3. {
    4. 	char arr1[1] = { 0 };//不够大
    5. 	char arr2[] = "abcdef";
    6. 	strcpy(arr1, arr2);
    7. 	printf("%s", arr1);
    8. 	return 0;
    9. }
    10.  
    11. #include
    12. int main()
    13. {
    14. 	char arr1[1] = "hijklem";//常量字符串
    15. 	char arr2[] = "abcdef";
    16. 	strcpy(arr1, arr2);
    17. 	printf("%s", arr1);
    18. 	return 0;
    19. }

    strcpy的模拟实现

    1. //逻辑关系
    2. //
    3. {
    4. ;
    5. }
    6. //操作符的优先级
    7. //画图最重要

    1. //模拟实现strcpy
    2. #include
    3. #include
    4. char* my_strcpy( char*dest,  const char* src)
    5. {
    6. 	char* ret = dest;//为了返回目标空间字符串的起始地址，需要先存储起来
    7. 	assert(dest && src);//断言
    8.  
    9. 	while (*dest++ = *src++)//赋值和等于
    10. 	{
    11. 		;
    12. 	}
    13. 	return ret;
    14. }
    15. int main()
    16. {
    17. 	char arr1[20] = {0};
    18. 	char arr2[] = "abcdef";
    19. 	my_strcpy(arr1, arr2);
    20. 	printf("%s\n", arr1);
    21. 	return 0;
    22. }
    23. //链式访问
    24. int main()
    25. {
    26. 	char arr1[20] = {0};
    27. 	char arr2[] = "abcdef";
    28. 	printf("%s\n", my_strcpy(arr1, arr2));//链式访问
    29. 	return 0;
    30. }
    31.  
    32. //换种写法❌的没有将\0拷贝过去
    33. #include
    34. #include
    35. char* my_strcpy(char* dest, const char* src)
    36. {
    37. 	char* ret = dest;//为了返回目标空间字符串的起始地址，需要先存储起来
    38. 	assert(dest && src);//断言
    39.  
    40. 	while (*src != '\0')
    41. 	{
    42. 		*dest = *src;//不是== 是赋值
    43. 		dest++;
    44. 		src++;
    45. 	}
    46. 	return ret;
    47. }

    strcat

    strcat - C++ Reference (cplusplus.com)

    • strcat是库函数，是用来字符串追加的
    • strcat是将 源头字符串 （包括\0)  追加到 目的地空间字符串 (覆盖\0) 的后面。
    • strcat的头文件是#include
    • strcat 的一个参数是 指向源头字符串的首元素地址 的指针变量 source
    • 源字符串必须以 '\0' 结束。
    • 在拷贝时，需要将源字符串中的'\0'拷贝过去
    • strcat 的另外一个参数是 指向目的地空间的字符串的首元素 的指针变量 destination
    • 目标空间必须有足够的大，能容纳下源字符串的内容。
    • 目标空间必须可修改
    • 目标空间必须得有'\0'（保证能找到目标空间的末尾）
    • strcat的返回值也是 目标空间的起始地址
    • strcat的模拟实现
    • 字符串自己给字节追加，可以吗？strncat

    strcat有将源头字符串的\0追加过去

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	char arr1[20] = "abc";
    6. 	char arr2[20] = "defg";
    7. 	strcat(arr1, arr2);
    8. 	printf("%s\n", arr1);
    9. 	return 0;
    10. }

    strcat字符串自己追加自己 

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "abc";
    5. 	strcat(arr1, arr1);
    6. 	printf("%s\n", arr1);
    7. 	return 0;
    8. }

    1. #include
    2. char* my_strcat(char* str1, const char* str2)
    3. {
    4. 	char* ret = str1;
    5. 	while (*str1)
    6. 	{
    7. 		str1++;
    8. 	}
    9. 	while (*str2 != '\0')
    10. 	{
    11. 		
    12. 			*str1++ = *str2++;
    13. 	}
    14. 	return ret;
    15. }
    16.  
    17. int main()
    18. {
    19. 	char arr1[20] = "abc";
    20. 	char arr2[20] = "defg";
    21. 	my_strcat(arr1, arr1);
    22. 	printf("%s\n", arr1);
    23. 	return 0;
    24. }

     

    字符串自己追加自己这种方式。在不同编译器上，有的可以，有的不行。编译器的厂商不同，相同的库函数是由不同程序员实现的，所以库函数内部实现是不同的。最好不要这样写 。后面介绍strncat可以实现这种情况。

    strcat的模拟实现

    1. //逻辑关系
    2. //
    3. {
    4. ;
    5. }
    6. //操作符的优先级
    7. //画图最重要

    1. #include
    2. #include
    3. #include
    4. char* my_strcat(char* str1, const char* str2)
    5. {
    6. 	assert(str1 && str2);//断言
    7. 	//strcat函数返回的是目标空间的起始地址
    8. 	char* ret = str1;
    9. 	//1，找到目标空间的末尾
    10. 	while (*str1 != '\0')
    11. 		//	while (*str1++)❌?????????????
    12. 		//后置++ 先使用  再*
    13. 	{
    14. 		str1++;
    15. 	}
    16. 	//2。数据追加
    17. 	while (*str1++ = *str2++)
    18. 		//后置++的规则
    19. 	{
    20. 		;
    21. 	}
    22. 	return ret;
    23. }
    24.  
    25. int main()
    26. {
    27. 	char arr1[20] = "abc";
    28. 	char arr2[20] = "defg";
    29. 	my_strcat(arr1, arr2);
    30. 	printf("%s\n", arr1);
    31. 	return 0;
    32. }

    strcmp

     strcmp - C++ Reference (cplusplus.com)

    strcmp的返回值如下： 

    •  strcmp是库函数，是用来字符串比较的
    •  本质上：不是比较长度，而是比较对应位置上的字符的大小，用ASCII码值来比较
    •  strcmp的头文件是 #include
    •  strcmp 的两个参数 是指向 两个需要比较的字符串 的指针变量str1 和 str2
    •  const修饰指针变量，为了确保strcmp库函数里的操作将主函数main里的字符串改变
    •  strcmp的返回值由上图解释就是：
    1. 第一个字符串 大于 第二个字符串，则返回大于0的数字
    2. 第一个字符串 等于 第二个字符串，则返回0
    3. 第一个字符串 小于 第二个字符串，则返回小于0的数字
    • strcpy的模拟实现 

    strcmp的返回值

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	char arr1[] = "abz";
    6. 	char arr2[] = "abq";
    7. 	if (strcmp(arr1, arr2) > 0)
    8. 	{
    9. 		printf(">\n");
    10. 	}
    11. 	else if(strcmp(arr1, arr2) < 0)
    12. 	{
    13. 		printf("<\n");
    14. 	}
    15. 	else
    16. 	{
    17. 		printf("=\n");
    18. 	}
    19. 	printf("%d", strcmp(arr1, arr2));//不同编译器下的值不同，但是都是以><=0的范围。
    20. 	return 0;
    21. }

    strcmp的模拟实现

    1. #include
    2. #include
    3. #include
    4. int my_strcmp( const char* p1, const char* p2)
    5. {
    6. 	assert(p1 && p2);
    7. 	while (*p1 == *p2)
    8. 	{
    9. 		if (*p1 == '\0')
    10. 			return 0;
    11. 		p1++;
    12. 		p2++;
    13. 	}
    14. 	//!=
    15. 	if (*p1 > *p2)
    16. 		return 1;
    17. 	else
    18. 		return -1;
    19. }
    20. int main()
    21. {
    22. 	char arr1[] = "abz";
    23. 	char arr2[] = "abq";
    24. 	if (my_strcmp(arr1, arr2) > 0)
    25. 	{
    26. 		printf(">\n");
    27. 	}
    28. 	else if (my_strcmp(arr1, arr2) < 0)
    29. 	{
    30. 		printf("<\n");
    31. 	}
    32. 	else
    33. 	{
    34. 		printf("=\n");
    35. 	}
    36. 	printf("%d", my_strcmp(arr1, arr2));//不同编译器下的值不同，但是都是以><=0的范围。
    37. 	return 0;
    38. }
    39. //或者
    40. #include
    41. #include
    42. #include
    43. int my_strcmp( const char* p1, const char* p2)
    44. {
    45. 	assert(p1 && p2);
    46. 	while (*p1 == *p2)
    47. 	{
    48. 		if (*p1 == '\0')
    49. 			return 0;
    50. 		p1++;
    51. 		p2++;
    52. 	}
    53. 	//!=
    54. 	return *p1 - *p2;
    55. }
    56. int main()
    57. {
    58. 	char arr1[] = "abz";
    59. 	char arr2[] = "abq";
    60. 	if (my_strcmp(arr1, arr2) > 0)
    61. 	{
    62. 		printf(">\n");
    63. 	}
    64. 	else if (my_strcmp(arr1, arr2) < 0)
    65. 	{
    66. 		printf("<\n");
    67. 	}
    68. 	else
    69. 	{
    70. 		printf("=\n");
    71. 	}
    72. 	printf("%d", my_strcmp(arr1, arr2));//不同编译器下的值不同，但是都是以><=0的范围。
    73. 	return 0;
    74. }
    1. int my_strcmp(char* p1, char* p2)
    2. {
    3. 	while (*p1 == *p2)
    4. 	{
    5. 		if (*p1 == '\0')
    6. 			return 0;
    7. 		p1++;
    8. 		p2++;
    9. 	}
    10. 	//!=
    11. 		return (*p1-*p2);
    12. }

    长度受限制的字符串函数

    接下来，我们介绍的是在上面函数的基础上，长度受限制的字符串函数 

    关于上面的解释过的点，我们将不在介绍，下面我们重点介绍受限制n的差别，和注意点 

    对比上面长度不受限制的字符串函数，我们发现多了一个size_t num的参数 ，相对安全一些

    strncpy

     strncpy - C++ Reference (cplusplus.com)

    • 拷贝num个字符从源字符串到目标空间。
    • 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个 
    • 不会将'\0'拷贝过去 

    num<

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "xxxxxxxxxxxxxx";
    5. 	char arr2[] = "abcdef";
    6. 	strncpy(arr1, arr2,3);
    7. 	printf("%s", arr1);
    8. 	return 0;
    9. }

    无拷贝'\0'  

     那请问是否将'\0'拷贝过去了呢？答案是：没有哦

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "xxxxxxxxxxxxxx";
    5. 	char arr2[] = "abcdef";
    6. 	strncpy(arr1, arr2,3);
    7. 	printf("%s\n", arr1);
    8. 	strcpy(arr1, arr2);
    9. 	printf("%s", arr1);
    10. 	return 0;
    11. }
    12.  
    13. 对比一下：就只知道'\0'有没有拷贝过去
    14. #include
    15. int main()
    16. {
    17. 	char arr1[20] = "xxxxxxxxxxxxx";
    18. 	printf("%s\n", arr1);
    19. 	char arr2[] = "abcdef";//会将\0拷贝过去，所以不会有xxxxx
    20. 	strcpy(arr1, arr2);
    21. 	printf("%s", arr1);
    22. 	return 0;
    23. }

    调式过后，我们可以发现，当我们num是几，我们就拷贝几个字符过去，并不会将'\0'拷贝  

    num>

    那当我们的num超过了被拷贝的字符串的字符个数，会发生什么呢？ 

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "xxxxxxxxxxxxxx";
    5. 	char arr2[] = "abc";
    6. 	strncpy(arr1, arr2, 6);
    7. 	printf("%s\n", arr1);
    8. 	return 0;
    9. }

    当我们调试发现，即便我们没有num超出了被拷贝字符串的字符个数。但是strnpy仍然会达到num的个数。那就是用'\0'去填补缺少的num的个数，必须满足num的字符个数拷贝过去方可。 

    strncat

    strncat - C++ Reference (cplusplus.com)

    • 追加num个字符从源字符串到目标空间。
    • 如果源字符串的长度小于num，则追加完源num字符串之后，不会再追加了
    • 会将'\0'追加过去 

    num<

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "abc";
    5. 	char arr2[] = "defghi";
    6. 	strncat(arr1, arr2, 3);
    7. 	printf("%s\n", arr1);
    8. 	return 0;
    9. }

    是追加'\0' 

    那我们的strncat函数是否追加字符串的同时将'\0'追加过去呢？答案是：有。

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "abc\0xxxxxxxxxx";
    5. 	char arr2[] = "defghi";
    6. 	strncat(arr1, arr2, 3);
    7. 	printf("%s\n", arr1);
    8. 	return 0;
    9. }
    10. //如果追加了'\0'，那么打印abcdef
    11. //如果没有追加'\0',那么打印abcdefxxxxxxx

     

     

    经过调试，我们发现在将源字符串追加到目的地空间字符串的后面时，我们把num的字符追加过去之后，同时会将'\0'追加过去。

    num> 

     那当我们的num超过了被追加的字符串的字符个数，会发生什么呢？ 

    1. #include
    2. int main()
    3. {
    4. 	char arr1[20] = "abc\0xxxxxxxxxx";
    5. 	char arr2[] = "defghi";
    6. 	strncat(arr1, arr2, 10);
    7. 	printf("%s\n", arr1);
    8. 	return 0;
    9. }

     

    当我们调试发现，当num超过源字符串里的元素个数，strncat的源字符串有多少字符元素就追加多少字符元素，并不会用'\0'去弥补空缺。

    strncmp

    strcmp - C++ Reference (cplusplus.com)

    • 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。 

    >0

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	char arr1[] = "abczef";
    6. 	char arr2[] = "abcqw";
    7. 	int ret = strncmp(arr1, arr2, 4);
    8. 	printf("%s\n", ret);
    9. 	return 0;
    10. }

    <0

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	char arr1[] = "abcdef";
    6. 	char arr2[] = "abcqw";
    7. 	int ret = strncmp(arr1, arr2, 4);
    8. 	printf("%s\n", ret);
    9. 	return 0;
    10. }

    =0

    1. #include
    2. int main()
    3. {
    4. 	char arr1[] = "abcdef";
    5. 	char arr2[] = "abcdef";
    6. 	int ret = strncmp(arr1, arr2, 3);
    7. 	printf("%s\n", ret);
    8. 	return 0;
    9. }

    这里留下几个任务就是动动小手我们写一写在原来的基础上模拟实现strnpy strncat strncmp,下篇博文讲。🙂🙂🙂🙂🙂

    总结

    • 作用会包含'\0'的字符串函数：strcpy strcat strncat
    • 不会作用会包含'\0'的字符串函数：strncpy 
    • 需要作用包括\0的字符串函数像追加/拷贝，会覆盖掉目的地空间字符串的\0，必须带上\0
    • 不需要是因为即便拷贝过去，目的地函数里原本就有多余的\0，不需要拷贝例如strnpy
    • 各个字符串函数的模拟实现要掌握

    ✔✔✔✔✔最后，感谢大家的阅读，若有错误和不足，欢迎指正！下篇博文我们继续字符函数。🆗

    当然今天有很开心的事情就是，以为我不能考英语四级了，结果候补有位置了，真的很开心！当然也提醒大家抢四级报名不要慌，也不要一直刷新和操作，这样会和我一样强制下线的┭┮﹏┭┮

    代码------→【gitee:唐棣棣 (TSQXG) - Gitee.com】

    联系------→【邮箱：2784139418@qq.com】

  • 相关阅读:
    true js
    Hive 表 DML 操作——Hive 表 DML 操作——第1关：将文件中的数据导入（Load）到 Hive 表中
    技术栈 业务架构 插件库
    MILP(混合整数线性规划)
    尚硅谷前端框架vue语法(二)
    idea启动与jar包启动中使用resource资源文件路径问题总结
    3dMax全球学习资源、资源文件和教程 ！
    JavaWeb在线问题.分析实例
    MybatisPlus拦截器+注解实现数据权限
    论文学习：RT-DETR
  • 原文地址：https://blog.csdn.net/m0_74841364/article/details/133040543