• 字符串函数用指针定义

    一，字符串函数说明

    1，C语言里所有文字信息必须存储在一组连续的字符类型存储区里，所有文字信息必须以'\0'作为结尾，这个字符的ASCII码就是数字0，符合这两个特征的内容叫字符串。C语言里使用字符串记录文字信息，字符串里'\0'字符前面的内容才是有效字符，所有字符串一定可以使用字符指针表示。

    2，字符串字面值是表示字符串的一种方式，例如"abc","^%&"。编译器在编译的时候会自动在字符串字面值后加上'\0'字符，编译器会使用第一个字符所在存储区的地址替换掉字符串字面值，字符串字面值里的内容在程序执行过程中不可以改变。如果程序中使用多个内容一样的字符串字面值，它们其实是同一个，它们所占的内存一样。如果多个字符串字面值并列写在一起则编译器会把它们合并成一个字符串字面值

    3，字符数组也可以表示字符串。只有包含'\0'字符的字符数组才可以代表字符串，可以用字符串字面值对字符数组进行初始化，这个时候'\0'字符也会被初始化到字符数组里去。使用字符串字面值对字符数组初始化完以后它们的存储区之间就没有关系了。字符数组里字符串内容可以修改，可以在printf函数里使用%s作为占位符把字符串打印在屏幕上。不可以使用操作符对字符串进行操作。

    二，字符串函数：头文件string.h

    1，strlen     统计字符串里有效字符个数与sizeof完全不同

    2，strcat     合并两个字符串这个函数有可能造成数组越界，由此导致严重问题

          strncat    功能和strcat类似，但是可以避免出问题

    3，strcmp     用来比较两个字符串大小

    返回值为1表示前一个字符串大；返回值为-1表示后一个字符串大；返回值为0表示一样大。

    strncmp    比较两个字符串中前n个字符

    4，strcpy把一个字符串的内容复制到一个字符数组里这个函数也可能造成数组越界严重问题

    strncpy    可以只复制字符串中前n个字符

    5，memset     把字符数组里多个连续的存储区内容设置成同一个字符

    6，strstr     可以在一个字符串里查找一个小字符串的位置，返回值是找到的小字符串里第一个字符存储区的地址，如果没有找到则返回值是NULL。

    7，其他与字符串有关的函数

    sprintf   把多个数据按格式打印在字符数组里形成字符串

    sscanf    从字符串中获得多个数字并记录到变量存储区里

    8，其他和字符串有关的函数，为了使用这两个函数需要包含stdlib.h头文件

    atoi        可以把字符串里的整数转换成整数类型

    atof        可以把字符串里的浮点数转换成双精度浮点类型

    可以在scanf函数调用语句中使用%s作为占位符把键盘输入的字符串记录到字符数组里，这可能造 成严重错误。

    9，fgets函数也可以从键盘得到一个字符串并记录到数组里，这个函数可以避免scanf函数的问题，函数三个参数（1）.数组名称（2）数组里存储区个数（3）用stdin表示键盘。如果输入内容不能填满数组则会把最后输入的'\n'也放在数组里,如果输入内容过多则多余的内容留给下次读取。每次使用fgets函数从键盘得到字符串后都应该清理可能存在的垃圾数据，清理垃圾数据的语句应该放在一个分支里。

    10,strtok：分离分隔符

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

    例1

    1. #include
    2. #include
    3. int main()
    4. {
    5.    char str[20]="asdfghjkl";
    6.    printf("strlen(str)=%d,sizeof(str)=%d\n",strlen(str),sizeof(str));        
    7.    strcat(str,"rst");
    8.    printf("str=%s\n",str);
    9.    strncat(str,"hhhhhhhhhkkkkkkk",1);
    10.    printf("str=%s\n",str);
    11.  
    12.    printf("比较结果是%d\n", strcmp("abc", "abd"));
    13.    printf("str=%s\n", strcpy(str, "abcdxyz"));
    14.    printf("str=%s\n",strncpy(str,"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhkkkkkkk",18));
    15.    memset(str, 't', 10);
    16.    printf("str=%s\n",str);
    17.    printf("----------------------------\n");
    18.    printf("%s\n", strstr("abcdefxyz", "cde"));
    19.    printf("%d\n", strstr("abcdefxyz", "cdk"));
    20.    printf("%d\n", strstr("xyz", "cde"));
    21.    printf("%s\n", strstr("mmmxyz", "mmxyz"));
    22. }

    例2

    1. #include 
    2. #include 
    3. int main() 
    4. {
    5. 	char str[20] = {0};
    6. 	char ch = 0;
    7. 	int num = 0;
    8. 	float fnum = 0.0f;
    9. 	printf("%d %c %g\n", 34, 'u', 4.2f);
    10.  
    11.  
    12.         sprintf(str, "%d %c %g", 34, 'u', 4.2f);
    13. 	printf("%s\n", str);
    14.         printf("-------------------\n");
    15. 	sscanf(str, "%d %c %g", &num, &ch, &fnum);
    16. 	printf("ch是%c,num是%d,fnum是%g\n", ch, num, fnum);
    17. 	printf("%d\n", atoi("34sdg214"));
    18. 	printf("%lg\n", atof("34.23asd34"));
    19.          
    20.  
    21.         char my[40]="zhangsan 1998 85.5hhhkkk";
    22.         char name[14];
    23.         int birth;
    24.         double score;
    25.         sscanf(my, "%s %d %lg", &name, &birth, &score);
    26.         printf("name=%s,birth=%d,score=%lg\n",name,birth,score);
    27.  
    28.  	 printf("-------------------\n");
    29. 	  char arr[10]={0};
    30. 	  printf("input a data:\n");
    31. 	  //scanf("%s",arr);
    32. 	  fgets(arr,10,stdin);
    33. 	  if(strlen(arr)==9&&arr[8]!='\n')
    34. 	  {
    35. 			scanf("%*[^\n]");
    36. 			scanf("%*c");
    37. 	  }
    38. 	  printf("%s\n",arr);
    39. 	return 0;
    40. }

     三，使用指针实现字符串函数

    1，strtok

    1. #include 
    2. int strtok_public()
    3. {
    4.     char s[] = "ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z";
    5.     char *delim = "-: ";
    6.     char *p;
    7.     printf("%s ", strtok(s, delim));
    8.     while((p = strtok(NULL, delim)))
    9. 	{
    10.         printf("%s ", p);
    11. 	}
    12.         printf("\n");
    13.     return 0;
    14. }
    15. //执行结果为：ab cd ef;gh i jkl;mnop;qrs tu vwx y;z 。
    16.  
    17.  
    18.  
    19. //自己实现strtok函数：
    20. #include
    21. //该程序的关键点在于定义了一个静态的字符指针,该指针用来记录分割后的字符串的首地址
    22. //传入NULL,则表示继续处理静态指针指向的余下字符串
    23. char *strtok(char *str, const char *delim)
    24. {
    25.         static char *src=NULL;//记下上一次非分隔字符串字符的位置,详见图示
    26.         const char *indelim=delim; //对delim做一个备份
    27.         int flag=1,index=0;                                
    28.  //每一次调用strtok,flag标记都会使得程序只记录下第一个非分隔符的位置,以后出现非分隔符不再处理
    29.         char *temp=NULL;   //程序的返回值
    30.  
    31.         if(str==NULL)
    32.         {
    33.           str=src; //若str为NULL则表示该程序继续处理上一次余下的字符串
    34.         }
    35.         for(;*str;str++)
    36.         {
    37.            delim=indelim;
    38.           for(;*delim;delim++)
    39.            {
    40.                   if(*str==*delim)
    41.                   {
    42.                           *str='\0';//若找到delim中感兴趣的字符,将该字符置为NULL
    43.                           index=1; //用来标记已出现感兴趣字符
    44.                           break;
    45.                   }
    46.            }
    47.           if(*str != '\0' && flag==1)
    48.           {
    49.                   temp=str; //只记录下当前第一个非感兴趣字符的位置
    50.                   flag=0;  
    51.            }
    52.           if(*str != '\0' && flag==0 && index==1)
    53.           {
    54.                  src=str; //第二次出现非感兴趣字符的位置(之前一定出现过感兴趣字符)
    55.                  return temp;
    56.           }
    57.         }
    58.         src=str;//执行该句表明一直未出现过感兴趣字符,或者说在出现了感兴趣的字符后,就没再出现过非感兴趣字符
    59.         return temp;
    60. }
    61. int main()
    62. {
    63.     char s[] = "ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z";
    64.     char *delim = "-: ";
    65.     char *p;
    66.     printf("%s ", strtok(s, delim));
    67.     while((p = strtok(NULL, delim) ))
    68. 	{
    69. 		printf("%s ", p);
    70.         printf("\n");
    71. 	}       
    72.    return0;
    73. }

    2，strcpy

    1. //字符串练习:实现strcpy的拷贝功能char
    2. #include
    3. /*char *mystrcpy(char *p_dest,const char *p_src)
    4. {
    5. 	char *p_dest_m=p_dest;
    6. 	const char *p_src_m=p_src;
    7. 	while(*p_src_m)
    8. 	{
    9. 		*p_dest_m=*p_src_m;
    10. 		p_src_m++;
    11. 		p_dest_m++;
    12. 	}
    13. 	*p_dest_m=0;
    14. 	return p_dest;
    15. }*/
    16. char *mystrcpy(char *p_dest,const char *p_src)
    17. {
    18. 	while(*p_src)
    19. 	{
    20. 		*p_dest=*p_src;
    21. 		*p_dest++;
    22. 		*p_src++;
    23. 	}
    24. 	return p_dest;
    25. }
    26.  
    27. char* my_strncpy(char* str1, char* str2, size_t n)
    28. {
    29. 	char* ret = str1;
    30. 	while (n)
    31. 	{
    32. 		*str1 = *str2;
    33. 		str1++;
    34. 		str2++;
    35. 		n--;
    36. 	}
    37. 	return ret;
    38. }
    39. int main()
    40. {
    41. 	char str[10]={0};
    42. 	printf("%s\n",mystrcpy(str,"asdfgh") );
    43. 	printf("%s\n",str);
    44. }

    3，strlen

    1. #include 
    2. //利用循环来实现
    3. int my_strlen_cycle(char* str)
    4. {
    5. 	int count = 0;
    6. 	while (*str)
    7. 	{
    8. 		count++;
    9. 		str++;
    10. 	}
    11. 	return count;
    12. }
    13.  
    14. //利用递归来实现
    15. int my_strlen_digui(char* str)
    16. {
    17. 	if (*(str+1))
    18. 	{
    19. 		return 1 + my_strlen(str + 1);
    20. 	}
    21. 	else
    22. 	{
    23. 		return 1;
    24. 	}
    25. }
    26.  
    27. //利用指针实现
    28. int my_strlen_ptr(char* str)
    29. {
    30. 	char* left = str;
    31. 	char* right = str;
    32. 	while (*right)
    33. 	{
    34. 		right++;
    35. 	}
    36. 	return right - left;
    37. }
    38. int main() 
    39. {
    40.    	 char input[20]="abcdefghijklmn";
    41. 	 my_strlen_cycle(input);
    42. 	 printf("my_strlen_cycle=%s\n",input);
    43. 	 
    44. 	 my_strlen_digui(input);
    45. 	 printf("my_strlen_cycle=%s\n",input);
    46. 	 
    47. 	 my_strlen_ptr(input);
    48. 	 printf("my_strlen_ptr=%s\n",input);
    49. 	return 0;
    50. }

    4，strcmp

    1. #include 
    2. int my_strcmp(char* str1, char* str2)
    3. {
    4. 	while (*str1 == *str2)
    5. 	{
    6. 		if (!*str1)
    7. 		{
    8. 			return 0;
    9. 		}
    10. 		str1++;
    11. 		str2++;
    12. 	}
    13. 	if (*str1 > *str2)
    14. 		return 1;
    15. 	else
    16. 		return -1;
    17. }
    18.  
    19. int my_strncmp(char* str1, char* str2, size_t n)
    20. {
    21.     while (n--)
    22.     {
    23.         if (*str1 == *str2)
    24.         {
    25.             str1++;
    26.             str2++;
    27.             continue;
    28.         }
    29.         if (*str1 > *str2)
    30.             return 1;
    31.         else
    32.             return -1;
    33.     }
    34.     return 0;
    35. }
    36. int main() 
    37. {
    38.     char arr[10]="abcd";
    39. 	char brr[10]="abcf";
    40. 	int back=my_strcmp(arr,brr);
    41. 	printf("back=%d\n",back);
    42. 	return 0;
    43. }

    5，strcat

    1. #include 
    2. char* my_strcat(char* str1, char* str2)
    3. {
    4. 	char* ret = str1;
    5. 	while (*str1)
    6. 	{
    7. 		str1++;
    8. 	}
    9. 	while (*str1++ = *str2++)
    10. 	{
    11. 		;
    12. 	}
    13. 	return ret;
    14. }
    15.  
    16. char* my_strncat(char* str1, char* str2, size_t n)
    17. {
    18. 	char* ret = str1;
    19. 	while (*str1)
    20. 	{
    21. 		str1++;
    22. 	}
    23. 	while (n)
    24. 	{
    25. 		*str1++ = *str2++;
    26. 		n--;
    27. 	}
    28. 	return ret;
    29. }
    30. int main() 
    31. {
    32. char arr[10]="abcdef";
    33. char brr[10]="ghijkmn";
    34. char *p;
    35. p=my_strcat(arr,brr);
    36. while(p!=NULL)
    37. {
    38. 	printf("%c");
    39. }
    40. printf("\n");
    41. 	return 0;
    42. }

    6，strstr

    1. #include 
    2. #include
    3. char* my_strstr(char* ptr1, char* ptr2)
    4. {
    5. 	char* src = ptr1;
    6. 	while (*src)
    7. 	{
    8. 		char* s1 = src;
    9. 		char* s2 = ptr2;
    10. 		while (*s1 && *s2 && (*s1 == *s2))
    11. 		{
    12. 			s1++;
    13. 			s2++;
    14. 		}
    15. 		if (!*s2)
    16. 		{
    17. 			return src;
    18. 		}
    19. 		src++;
    20. 	}
    21. 	return NULL;
    22. }
    23. int main()
    24. {
    25. 	char arr1[] = "abcdef";
    26. 	char arr2[] = "def";
    27. 	printf("%s", my_strstr(arr1, arr2));
    28. 	return 0;
    29. }
    30.  
    31.

  • 相关阅读:
    Matlab地理信息绘图—研究区域绘制
    Apache Doris的架构讲解
    JVM复习总结2024.4.18（很重要）
    深入浅出Spring（25）
    如何实现一个安卓群控系统
    【多线程与高并发】- 线程基础与状态
    kafka如何保证消息不丢失
    Mybatis 简介（一）
    【网络安全】什么样的人适合学？该怎么学？
    【自动驾驶多传感器融合+多算法融合】
  • 原文地址：https://blog.csdn.net/wangjie36/article/details/126295200