• C进阶--字符函数和字符串函数介绍

    ✨ 更多细节参考 cplusplus.com/reference/cstring/

    使用方式：

    ⭕ 求字符串长度

    🖌   strlen

    函数原型：

    size_t strlen ( const char * str );

    作用：

    获取字符串长度

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

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

    strlen函数的使用

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char buffer[256];
    7.   printf ("Enter a sentence: ");
    8.   gets (buffer);
    9.   printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
    10.   return 0;
    11. }

    运行结果：

    strlen函数模拟实现

    🔪 方法一：计数器

    1. size_t my_strlen(const char* str)
    2. {
    3. 	int count = 0;
    4. 	assert(str != NULL);
    5. 	while (*str != '\0')
    6. 	{
    7. 		count++;
    8. 		str++;
    9. 	}
    10. 	return count;
    11. }

    🔪 方法二：递归

    1. size_t my_strlen(const char* str)
    2. {
    3. 	if (*str == '\0')
    4. 		return 0;
    5. 	else
    6. 		return my_strlen(str + 1) + 1;
    7. }

    🔪 方法三：指针-指针

    1. size_t my_strlen(const char* str)
    2. {
    3. 	const char* p = str;
    4. 	while (*str != '\0')
    5. 		str++;
    6. 	return str - p;
    7. }

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

    🖌   strcpy

    函数原型：

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

    函数功能：

    将源指向的 C 字符串复制到目标指向的数组中

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char str1[]="Sample string";
    7.   char str2[40];
    8.   char str3[40];
    9.   strcpy (str2,str1);
    10.   strcpy (str3,"copy successful");
    11.   printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
    12.   return 0;
    13. }
    ✨有源字符串必须以 '\0' 结束。
    ✨会将源字符串中的 '\0' 拷贝到目标空间。
    ✨目标空间必须足够大，以确保能存放源字符串。
    ✨目标空间必须可变。

    ✨strcpy函数返回的是目标空间的起始地址
    ✨strcpy函数的返回类型的设置是为了实现链式访问

    模拟实现：

    1. char* my_strcpy(char*dest, const char* src)
    2. {
    3. 	char* ret = dest;
    4. 	while(*dest++ = *src++)
    5. 		;
    6. 	return ret;
    7. }

    🖌  strcat

    函数原型：

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

    函数功能：

    将源字符串的副本追加到目标字符串。目标中的终止空字符被源的第一个字符覆盖，并且在目标中由两者串联形成的新字符串的末尾包含一个空字符。

    目的地和来源不得重叠。

    ⭐ 目标空间必须有足够的大，能容纳下源字符串的内容。
    ⭐ 目标空间必须可修改。

    函数使用：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include 
    5.  
    6. int main()
    7. {
    8. 	char str[80];
    9. 	strcpy(str, "these ");
    10. 	strcat(str, "strings ");
    11. 	strcat(str, "are ");
    12. 	strcat(str, "concatenated.");
    13. 	puts(str);
    14. 	return 0;
    15. }

    目的地和来源不得重叠。所以不可以自己给自己追加喔（strcat（s,s);绝对不可以喔。🙅‍♀️）

    模拟实现：

    1. char* my_strcat(char* dest, char* src)
    2. {
    3. 	assert(dest && src);
    4. 	char* ret = dest;
    5. 	//找目标空间中的\0
    6. 	while (*dest)
    7. 		dest++;
    8. 	//拷贝
    9. 	while (*dest++ = *src++)
    10. 		;
    11. 	
    12. 	return ret;
    13. }

    🖌   strcmp

    函数原型：

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

    函数功能：

    此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续以下对，直到字符不同或达到终止空字符。

    ps:此函数执行字符的二进制比较。有关考虑特定于区域设置的规则的函数，请参阅 strcoll。

    ✨ 返回值：
    第一个字符串大于第二个字符串，则返回大于 0 的数字
    第一个字符串等于第二个字符串，则返回 0
    第一个字符串小于第二个字符串，则返回小于 0 的数字

    函数使用：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7.     char key[] = "apple";
    8.     char buffer[80];
    9.     do {
    10.         printf("Guess my favorite fruit? ");
    11.         fflush(stdout);//刷新输出缓冲区
    12.         scanf("%79s", buffer);
    13.     } while (strcmp(key, buffer) != 0);
    14.     puts("Correct answer!");
    15.     return 0;
    16. }

      fflush(stdout);作用：刷新输出缓冲区--更多欢迎进入主页查看文件系统与inode编号 有更详细的介绍

    模拟实现：

    ✍ 代码实现：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include 
    5.  
    6.  
    7. int my_strcmp(const char* s1, const char* s2)
    8. {
    9. 	assert(s1 && s2);
    10. 	while (*s1 == *s2)
    11. 	{
    12. 		if (*s1 == '\0')
    13. 		{
    14. 			return 0;//相等
    15. 		}
    16.  
    17. 		s1++;
    18. 		s2++;
    19. 	}
    20. 	//不相等
    21. 	return *s1 - *s2;
    22. }
    23. int main()
    24. {
    25. 	char * s1 = "abcde";
    26. 	char * s2 = "acbde";
    27. 	char * s3 = "abcde";
    28. 	char * s4 = "abbbbb";
    29. 	printf("s1 vs s2 %d\n", my_strcmp(s1, s2));
    30. 	printf("s1 vs s3 %d\n", my_strcmp(s1, s3));
    31. 	printf("s1 vs s4 %d\n", my_strcmp(s1, s4));
    32. 	return 0;
    33. }

    📕 运行结果：

    ⭕ 长度受限制的字符串函数介绍

    🖌  strncpy

    函数原型：

    char * strncpy ( char * destination, const char * source, size_t num );

    函数功能：

    将源的第一个字符数复制到目标。如果在复制 num 个字符之前找到源 C 字符串的末尾（由 null 字符表示），则目标将填充零，直到总共写入 num 个字符为止。

    ⭐ 如果源长度超过 num，则不会在目标末尾隐式附加空字符。因此，在这种情况下，不应将目标视为以空结尾的 C 字符串（这样读取它会溢出）。

    ⭐ 目的地和来源不得重叠 

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char str1[]= "To be or not to be";
    7.   char str2[40];
    8.   char str3[40];
    9.  
    10.   /* copy to sized buffer (overflow safe): */
    11.   strncpy ( str2, str1, sizeof(str2) );
    12.  
    13.   /* partial copy (only 5 chars): */
    14.   strncpy ( str3, str2, 5 );
    15.   str3[5] = '\0';   /* null character manually added */
    16.  
    17.   puts (str1);
    18.   puts (str2);
    19.   puts (str3);
    20.  
    21.   return 0;
    22. }

    运行结果：

    模拟实现：

    1. char* my_strncpy(char* destination, const char* source, size_t n)
    2. {
    3. 	char* cp = destination;
    4. 	int i = 0;
    5. 	while (*source && i < n)
    6. 	{
    7. 		*cp++ = *source++;
    8. 		i++;
    9. 	}
    10. 	for (int j = i; j < n; j++)
    11. 	{
    12. 		*cp++ = 0;
    13. 	}
    14. 	return destination;
    15. }

    🖌  strncat

    函数原型：

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

    函数功能：

    将源的第一个数字字符追加到目标，外加一个终止空字符。

    如果源中 C 字符串的长度小于 num，则仅复制终止空字符之前的内容。

    函数使用：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include 
    3. #include 
    4.  
    5. int main ()
    6. {
    7.   char str1[20];
    8.   char str2[20];
    9.   strcpy (str1,"To be ");
    10.   strcpy (str2,"or not to be");
    11.   strncat (str1, str2, 6);
    12.   puts (str1);
    13.   return 0;
    14. }

    运行结果：

    ❓  字符串自己给自己追加，如何？
    对于strncat函数，它可以在目标字符串中追加源字符串的一部分内容，但不能直接将源字符串追加到自身。

    模拟实现：

    代码实现：

    1. #include
    2. #include
    3. #include
    4.  
    5. char* my_strncat(char* dest, const char* src, size_t num) {
    6. 	assert(dest && src);
    7. 	char* ret = dest;
    8. 	/*while (num--) {
    9. 		*dest++ = *src++;
    10. 	}*/
    11. 	while (*dest != '\0') {
    12. 		dest++;
    13. 	}
    14. 	size_t i = 0;
    15. 	for (; src != 0 && i < num; i++) {
    16. 		dest[i] = src[i];
    17. 	}
    18. 	return ret;
    19. }
    20. int main() {
    21. 	char dest[20] = "hahaha";
    22. 	char src[10] = "yyyyyy";
    23. 	my_strncat(dest, src, 2);
    24. 	printf("%s\n", dest);
    25. 	return 0;
    26. }

    运行结果：

    🖌 strncmp

    函数原型：

    int strncmp ( const char * str1, const char * str2, size_t num );

    函数功能：

    比较两个字符串的字符
    将 C 字符串 str1 的字符数与 C 字符串 str2 的字符数进行比较。
    此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续使用以下对，直到字符不同，直到达到终止的空字符，或者直到两个字符串中的 num 字符匹配，以先发生者为准。

    ✨ 返回值：
    第一个字符串大于第二个字符串，则返回大于 0 的数字
    第一个字符串等于第二个字符串，则返回 0
    第一个字符串小于第二个字符串，则返回小于 0 的数字

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
    7.   int n;
    8.   puts ("Looking for R2 astromech droids...");
    9.   for (n=0 ; n<3 ; n++)
    10.     if (strncmp (str[n],"R2xx",2) == 0)
    11.     {
    12.       printf ("found %s\n",str[n]);
    13.     }
    14.   return 0;
    15. }

    模拟实现：

    1. int my_strncmp(const char *str1, const char *str2, int n)
    2. {
    3. 	assert(str1 != NULL&&str2 != NULL);
    4. 	while(n--&&*str1 == *str2)
    5. 	{
    6. 			str1++;
    7. 			str2++;
    8. 	}
    9. 	return *str1 - *str2;
    10. }

    ⭕ 字符串查找

    🖌 strstr

    函数原型：

    1. const char * strstr ( const char * str1, const char * str2 );
    2. char * strstr (char * str1, const char * str2 );

    函数功能：查找子字符串

    返回指向 str1 中第一次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。

    匹配过程不包括终止空字符，但它到此为止。

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6. //查找出错误的sample并替换为正确的
    7.   char str[] ="This is a simple string";
    8.   char * pch;
    9.   pch = strstr (str,"simple");
    10.   if (pch != NULL)
    11.     strncpy (pch,"sample",6);
    12.   puts (str);
    13.   return 0;
    14. }

    运行结果：

    模拟实现：

    1. char* my_strstr(const char* str1, const char* str2)
    2. {
    3. 	assert(str1 && str2);
    4.  
    5. 	const char* s1 = str1;
    6. 	const char* s2 = str2;
    7.  
    8. 	const char* cur = str1;
    9. 	while (*cur)
    10. 	{
    11. 		s1 = cur;
    12. 		s2 = str2;
    13.  
    14. 		while (*s1 && *s2 && (*s1 == *s2))
    15. 		{
    16. 			s1++;
    17. 			s2++;
    18. 		}
    19. 		if (*s2 == '\0')
    20. 		{
    21. 			return (char*)cur;
    22. 		}
    23. 		cur++;
    24. 	}
    25.  
    26. 	return NULL;//找不到
    27. }

    🖌   strtok

    函数原型：

    char * strtok ( char * str, const char * delimiters );

    函数功能：

    将字符串拆分为以标记分开的字符串。
    此函数的一系列调用将 str 拆分为标记，这些标记是由分隔符中的任何字符分隔的连续字符序列。

    ⭐ 在第一次调用时，该函数需要一个 C 字符串作为 str 的参数，其第一个字符用作扫描令牌的起始位置。在后续调用中，该函数需要一个空指针，并使用最后一个令牌末尾之后的位置作为扫描的新起始位置。

    ⭐ 为了确定标记的开头和结尾，该函数首先从起始位置扫描分隔符中未包含的第一个字符（该字符将成为标记的开头）。然后从令牌的开头开始扫描分隔符中包含的第一个字符，该字符将成为令牌的末尾。如果找到终止空字符，扫描也会停止。

    ⭐ 令牌的此结尾将自动替换为空字符，并且令牌的开头由函数返回。

    一旦在对 strtok 的调用中找到 str 的终止空字符，则对此函数的所有后续调用（以空指针作为第一个参数）都将返回空指针。

    ⭐找到最后一个令牌的点由要在下一次调用中使用的函数在内部保留（不需要特定的库实现来避免数据争用）。

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char str[] ="- This, a sample string.";
    7.   char * pch;
    8.   printf ("Splitting string \"%s\" into tokens:\n",str);
    9.   pch = strtok (str," ,.-");
    10.   while (pch != NULL)
    11.   {
    12.     printf ("%s\n",pch);
    13.     pch = strtok (NULL, " ,.-");
    14.   }
    15.   return 0;
    16. }

    模拟实现：

    1. char* my_strtok(char* strToken, const char* strDelimit)
    2. {
    3. 	char* str1 = strToken;
    4. 	char* temp = NULL;
    5. 	char* str2 = (char*)strDelimit;
    6. 	static char* pos = NULL;
    7.  
    8. 	if (str1 != NULL)
    9. 	{
    10. 		while (*str1)
    11. 		{
    12. 			str2 = (char*)strDelimit;
    13. 			while (*str2 != '\0')
    14. 			{
    15. 				if ((*str1 == *str2))
    16. 				{
    17. 					if (*(str1 + 1) == '\0')
    18. 						pos = NULL;
    19. 					else
    20. 						pos = str1;
    21. 					*str1 = '\0';
    22. 					return strToken;
    23. 				}
    24. 				str2++;
    25. 			}
    26. 			str1++;
    27. 		}
    28. 	}
    29. 	else
    30. 	{
    31. 		if (pos != NULL)
    32. 		{
    33. 			str1 = pos + 1;
    34. 			temp = pos + 1;
    35. 			while (*str1)
    36. 			{
    37. 				str2 = (char*)strDelimit;
    38. 				while (*str2 != '\0')
    39. 				{
    40. 					if ((*str1 == *str2))
    41. 					{
    42. 						pos = str1;
    43. 						*str1 = '\0';
    44. 						return temp;
    45. 					}
    46. 					str2++;
    47. 				}
    48. 				str1++;
    49. 			}
    50. 			pos = NULL;
    51. 			return temp;
    52. 		}	
    53. 	}
    54. 	return NULL;
    55. }

    ⭕ 错误信息报告

    🖌  strerror

    函数原型：

    char * strerror ( int errnum );

    函数功能：获得一个指向错误信息字符串的字符指针

    ⭐ 解释 errnum 的值，生成一个字符串，其中包含描述错误条件的消息，就像由库的函数设置为 errno 一样。

    ⭐ 返回的指针指向静态分配的字符串，程序不应修改该字符串。对此函数的进一步调用可能会覆盖其内容（不需要特定的库实现来避免数据争用）。

    ⭐ strerror 生成的错误字符串可能特定于每个系统和库实现。

    函数使用：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. int main ()
    6. {
    7.   FILE * pFile;
    8.   pFile = fopen ("unexist.ent","r");
    9.   if (pFile == NULL)
    10.     printf ("Error opening file unexist.ent: %s\n",strerror(errno));
    11.   return 0;
    12. }

     ⭕ 内存操作函数

     🖌 memcpy

    函数原型：

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


    函数功能：复制内存块

    将字节数的值从源指向的位置直接复制到目标指向的内存块。

    ⭐ 源指针和目标指针指向的对象的基础类型与此函数无关;结果是数据的二进制副本。

    ⭐ 该函数不检查源中的任何终止空字符 - 它总是准确地复制字节数。

    ⭐ 为避免溢出，目标和源参数指向的数组大小应至少为字节数，并且不应重叠（对于重叠的内存块，memmove 是一种更安全的方法）。

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. struct {
    5.   char name[40];
    6.   int age;
    7. } person, person_copy;
    8.  
    9. int main ()
    10. {
    11.   char myname[] = "Pierre de Fermat";
    12.  
    13.   /* using memcpy to copy string: */
    14.   memcpy ( person.name, myname, strlen(myname)+1 );
    15.   person.age = 46;
    16.  
    17.   /* using memcpy to copy structure: */
    18.   memcpy ( &person_copy, &person, sizeof(person) );
    19.  
    20.   printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );
    21.  
    22.   return 0;
    23. }


    模拟实现：

    1. void* my_memcpy(void* dest, const void* src, size_t count)
    2. {
    3. 	assert(dest && src);
    4. 	void* ret = dest;
    5. 	while (count--)
    6. 	{
    7. 		*(char*)dest = *(char*)src;
    8. 		dest = (char*)dest + 1;
    9. 		src = (char*)src + 1;
    10. 	}
    11.  
    12. 	return ret;
    13. }

     🖌  memmove

    函数原型：

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


    函数功能：

    移动内存块
    将字节数的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样，允许目标和源重叠。

    ⭐ 源指针和目标指针指向的对象的基础类型与此函数无关;结果是数据的二进制副本。

    ⭐ 该函数不检查源中的任何终止空字符 - 它总是准确地复制字节数。

    ⭐ 为避免溢出，目标参数和源参数指向的数组的大小应至少为字节数。

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char str[] = "memmove can be very useful......";
    7.   memmove (str+20,str+15,11);
    8.   puts (str);
    9.   return 0;
    10. }


    模拟实现：

    1. void* my_memmove(void* dest, const void*src, size_t count)
    2. {
    3. 	assert(dest && src);
    4. 	void* ret = dest;
    5. 	//1
    6. 	if (dest < src)
    7. 	{
    8. 		//前->后
    9. 		while (count--)
    10. 		{
    11. 			*(char*)dest = *(char*)(src);
    12. 			dest = (char*)dest + 1;
    13. 			src = (char*)src + 1;
    14. 		}
    15. 	}
    16. 	else
    17. 	{
    18. 		//后->前
    19. 		while (count--)
    20. 		{
    21. 			*((char*)dest+count) = *((char*)src + count);
    22. 		}
    23. 	}
    24.  
    25. 	return ret;
    26. }

     🖌  memcmp

    函数原型：

    int memcmp ( const void * ptr1, const void * ptr2, size_t num );


    函数功能：比较两个内存块

    将 ptr1 指向的内存块的前 num 字节数与 ptr2 指向的第一个字节数进行比较，如果它们都匹配，则返回零，如果不匹配，则返回一个不同于零的值，表示哪个更大。

    ✴ 请注意，与 strcmp 不同，该函数在找到空字符后不会停止比较。

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char buffer1[] = "DWgaOtP12df0";
    7.   char buffer2[] = "DWGAOTP12DF0";
    8.  
    9.   int n;
    10.  
    11.   n=memcmp ( buffer1, buffer2, sizeof(buffer1) );
    12.  
    13.   if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
    14.   else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
    15.   else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
    16.  
    17.   return 0;
    18. }


    模拟实现：

    🔪 方式一：

    1. int my_memcmp1(const void* p1, const void* p2, size_t count)//方法1
    2. {
    3.     assert(p1);
    4.     assert(p2);
    5.     char* dest = (char*)p1;
    6.     char* src = (char*)p2;
    7.     while (count && (*dest == *src))
    8.     {
    9.         count--;
    10.         dest++;
    11.         src++;
    12.     }
    13.     if (count == 0)
    14.         return 0;
    15.     return *dest - *src;
    16. }

    🔪 方式二：

    1. int my_memcmp2(const void* p1, const void* p2, size_t count)//方法2
    2. {
    3.     assert(p1);
    4.     assert(p2);
    5.     int ret = 0;
    6.     char* dest = (char*)p1;
    7.     char* src = (char*)p2;
    8.     while (count && (!(ret = (*dest - *src))))
    9.     {
    10.         dest++;
    11.         src++;
    12.         count--;
    13.     }
    14.     if (ret > 0)
    15.     {
    16.         return 1;
    17.     }
    18.     else if (ret < 0)
    19.     {
    20.         return -1;
    21.     }
    22.     return 0;
    23.  
    24. }

     🖌   memset

    函数原型：

    void * memset ( void * ptr, int value, size_t num );


    函数功能：填充内存块

    将 ptr 指向的内存块的第一个字节数设置为指定值（解释为无符号字符）。

    函数使用：

    1. #include 
    2. #include 
    3.  
    4. int main ()
    5. {
    6.   char str[] = "almost every programmer should know memset!";
    7.   memset (str,'-',6);
    8.   puts (str);
    9.   return 0;
    10. }

     

  • 相关阅读:
    【大数据】常见的数据抽取方法
    在Overleaf或LaTeX软件中使用citavi插入参考文献
    Lambda 表达式怎么用?
    实时数据监控，三防平板在工业领域的应用解析
    【关于Linux中----文件接口、描述符、重定向、系统调用和缓冲区】
    oracle varchar2类型如何转化为date类型
    综述 | 关于点云配准的全面综述（一）
    Spring Retry教程(3)-模板方式的实现
    《最新出炉》系列初窥篇-Python+Playwright自动化测试-17-处理鼠标悬停
    strcpy的基本用法详解以及模拟实现strcpy
  • 原文地址：https://blog.csdn.net/qq_59293418/article/details/133454482