C语言 将字符串按照指定字符分离并且反转(三级指针)列子

简介: C语言 将字符串分离并且反转(三级指针) 本程序完成功能 1、将输入的字符串按照指定字符分离为子字符串 2、将子字符串进行反转 使用方法 在栈空间分配一个三级指针,指向堆内存空间的指针数组的位置,每个指针数组成员又指向一个字符串,必须明确如下的 内存四区图这里只画最为复杂的分离字符函数,而不画反转函数,因为反转函数模型非常简单,而且画太多太麻烦。
C语言 将字符串分离并且反转(三级指针)


本程序完成功能
1、将输入的字符串按照指定字符分离为子字符串
2、将子字符串进行反转
使用方法
在栈空间分配一个三级指针,指向堆内存空间的指针数组的位置,每个指针数组成员又指向一个字符串,必须明确如下的
内存四区图这里只画最为复杂的分离字符函数,而不画反转函数,因为反转函数模型非常简单,而且画太多太麻烦。
在图中反应出strsplrev中的int len和 char** str为输出变量,也就是说str用来接受malloc出来的二级指针的值,那么我们应该
将三级指针传入,另外argv输入的字符串放到了全局区,这个区域是不能更改的,所以用一个堆instr将他接收过来,这也是典
型的场景下图(图中将i m p3个栈变量放到了一起),重点在于堆中的内存理解问题。

程序输出如下:
gaopeng@bogon:~/stepup/3rd$ ./splitstr oracle-mysql-mongodb -
----len is 3
oracle
mysql
mongodb
----reverse now!
elcaro
lqsym
bdognom
----free mem!

四区图如下:





最后给出实现代码:

点击(此处)折叠或打开

  1. 接口头文件:
  2. /*************************************************************************
  3.     > File Name: fun.h
  4.     > Author: gaopeng QQ:22389860 all right reserved
  5.     > Mail: gaopp_200217@163.com
  6.     > Created Time: Tue 24 Jan 2017 03:50:07 PM CST
  7.  ************************************************************************/


  8. int strsplt(const char* instrt/*in*/,const char* spchar/*in*/,char** *outp/*out*/,int* len/*out*/);
  9. int strrevs(char* instrt/*in out*/);
  10. int strsplrev(char *p1,char *p2);

  11. 接口实现文件:
  12. /*************************************************************************
  13.   > File Name: fun.c
  14.   > Author: gaopeng QQ:22389860 all right reserved
  15.   > Mail: gaopp_200217@163.com
  16.   > Created Time: Tue 24 Jan 2017 02:02:20 PM CST
  17.  ************************************************************************/

  18. #include<stdio.h>
  19. #include<stdlib.h>
  20. #include<string.h>

  21. int mfree(char** *freep,int len)
  22. {
  23.         int i=0;
  24.         if(*freep==NULL)
  25.         {
  26.                 return 0;
  27.         }
  28.         for(i=0;i<len;i++)
  29.         {
  30.                 if(*(*freep+i) !=NULL)
  31.                 {
  32.                         printf("%d ",i);
  33.                         free(*(*freep+i));
  34.                         *(*freep+i)=NULL;
  35.                 }
  36.         }
  37.         free(*freep);
  38.         freep = NULL;
  39.         return 0;
  40. }


  41. /*-1 flase 0 ture*/
  42. int strsplt( char* instr,const char* spchar,char** *outp,int* len )
  43. {
  44.         char** temp=NULL;
  45.         int i=0,m=0,p=0;
  46.         int templen=0;
  47.         char* tempsrc=NULL;

  48.         if(instr==NULL||spchar==NULL||outp==NULL||len==NULL)
  49.         {
  50.                 printf("strsplt error:instr==NULL||spchar==NULL||outp==NULL||len==NULL\n");
  51.                 goto err;
  52.         }
  53.         p = 1;
  54.         for(i=0;i<strlen(instr);i++)
  55.         {
  56.                 if(instr[i]==spchar[0])
  57.                 {
  58.                         if (i == strlen(instr)-1)
  59.                         {
  60.                                 printf("strsplt error:last char is spchar \n");
  61.                                 goto err;
  62.                         }
  63.                         if(instr[i+1]==spchar[0])
  64.                         {
  65.                                 printf("strsplt error:two or more spchar \n");
  66.                                 goto err;
  67.                         }

  68.                         p++;
  69.                 }
  70.         }

  71.         *len = p;
  72.         templen = p;//used mfree fun

  73.         if((temp=(char**)calloc(1,p*sizeof(char*)))==NULL)
  74.         {
  75.                 printf("strsplt error:mem calloc error\n");
  76.                 goto err;
  77.         }
  78.         *outp=temp;
  79.         for(i=0,p=0,m=0;i<strlen(instr);i++)//i is step p is step of pointer m is len of substr
  80.         {
  81.                 if(instr[i]==spchar[0])
  82.                 {
  83.                         tempsrc=instr+m;
  84.                         if( (*(temp+p)= (char*)calloc(1,i-m+1))==NULL)
  85.                         {
  86.                                 printf("strsplt error:mem calloc error\n");
  87.                                 goto err;
  88.                         }
  89.                         strncpy(*(temp+p),tempsrc,i-m);
  90.                         p++;
  91.                         m=i+1;
  92.                 }
  93.         }
  94.         //last copy
  95.         tempsrc=instr+m;
  96.         if( (*(temp+p)= (char*)calloc(1,i-m+1)) == NULL)
  97.         {
  98.                 printf("strsplt error:mem calloc error\n");
  99.                 goto err;
  100.         }
  101.         strncpy(*(temp+p),tempsrc,i-m);
  102.         return 0;

  103.         err:
  104.         mfree(&temp,templen);
  105.         return -1;

  106. }

  107. /* -1 false 0 true*/
  108. int strrevs(char* instrt)
  109. {
  110.         int templ=0;
  111.         int i=0,j=0;
  112.         char tempc=0;
  113.         templ = strlen(instrt);
  114.         if(instrt == NULL || templ==0)
  115.         {
  116.                 printf("strrevs error:instrt == NULL || templ=0\n");
  117.                 return -1;
  118.         }
  119.         for(i=0,j=templ-1;i<j;i++,j--)
  120.         {
  121.                 tempc=instrt[j];
  122.                 instrt[j]=instrt[i];
  123.                 instrt[i]=tempc;
  124.         }
  125.         return 0;
  126. }

  127. int strsplrev(char *p1,char *p2)
  128. {

  129.         char* *str=NULL;
  130.         int slen=0;
  131.         int i=0;

  132.         if(strsplt(p1,p2,&str,&slen) == 0)
  133.         {
  134.                 printf("----len is %d\n",slen);
  135.                 for(i=0;i<slen;i++)
  136.                 {
  137.                         printf("%s\n",*(str+i));
  138.                 }
  139.         }
  140.         else
  141.         {
  142.                 printf("error!\n");
  143.                 return 3;
  144.         }

  145.         printf("----reverse now!\n");
  146.         for(i=0;i<slen;i++)
  147.         {

  148.                 if(strrevs(*(str+i)) !=0)
  149.                 {

  150.                         printf("error!\n");
  151.                         return 4;
  152.                 }
  153.                 else
  154.                 {

  155.                         printf("%s\n",*(str+i));
  156.                 }
  157.         }
  158.         printf("----free mem!\n");
  159.         mfree(&str,slen);
  160.         return 0;
  161. }

  162. main调用文件:
  163. /*************************************************************************
  164.   > File Name: main.c
  165.   > Author: gaopeng QQ:22389860 all right reserved
  166.   > Mail: gaopp_200217@163.com
  167.   > Created Time: Tue 24 Jan 2017 02:02:09 PM CST
  168.  ************************************************************************/

  169. #include<stdio.h>
  170. #include<stdlib.h>
  171. #include<string.h>
  172. #include"fun.h"


  173. int main(int argc,char* argv[])
  174. {

  175.         if(argc!=3||strcmp(argv[1],"--help")==0)
  176.         {
  177.                 printf("usage ./tool str spchar \n");
  178.                 return 1;
  179.         }

  180.         if(strlen(argv[2]) !=1)
  181.         {
  182.                 printf("par2 split char only one char\n");
  183.                 return 2;
  184.         }

  185.         strsplrev(argv[1],argv[2]);
  186.         return 0;


  187. }







目录
打赏
0
0
0
0
91
分享
相关文章
一文轻松拿捏C语言的指针的基础使用
本文介绍了C语言中的指针概念,包括直接访问和间接访问内存的方式、指针变量的定义与使用、取址运算符`&`和取值运算符`*`的应用,帮助读者深入理解指针这一C语言的核心概念。君志所向,一往无前!
17 0
【C语言】指针的神秘探险:从入门到精通的奇幻之旅 !
指针是一个变量,它存储另一个变量的内存地址。换句话说,指针“指向”存储在内存中的某个数据。
129 3
【C语言】指针的神秘探险:从入门到精通的奇幻之旅 !
【C语言】字符常量详解
字符常量是C语言中处理字符数据的重要工具。通过单引号括起一个字符,我们可以方便地使用字符常量进行字符判断、字符运算和字符串处理等操作。理解字符常量的表示方法、使用场景和ASCII码对应关系,对于编写高效的C语言程序至关重要。
235 11
【C语言】字符串操作函数详解
这些字符串操作函数在C语言中提供了强大的功能,帮助开发者有效地处理字符串数据。通过对每个函数的详细讲解、示例代码和表格说明,可以更好地理解如何使用这些函数进行各种字符串操作。如果在实际编程中遇到特定的字符串处理需求,可以参考这些函数和示例,灵活运用。
104 10
【C语言】指针大小知多少 ?一场探寻C语言深处的冒险 !
在C语言中,指针的大小(即指针变量占用的内存大小)是由计算机的体系结构(例如32位还是64位)和编译器决定的。
268 9
【C语言】指针的爱恨纠葛:常量指针vs指向常量的指针
在C语言中,“常量指针”和“指向常量的指针”是两个重要的指针概念。它们在控制指针的行为和数据的可修改性方面发挥着关键作用。理解这两个概念有助于编写更安全、有效的代码。本文将深入探讨这两个概念,包括定义、语法、实际应用、复杂示例、最佳实践以及常见问题。
74 7
【C语言】格式化输出占位符及其标志字符详解(基于ISO/IEC 9899:2024)
在C语言中,格式化输出通过 `printf` 函数等格式化输出函数来实现。格式说明符(占位符)定义了数据的输出方式,标准ISO/IEC 9899:2024(C23)对这些格式说明符进行了详细规定。本文将详细讲解格式说明符的组成部分,包括标志字符、宽度、精度、长度修饰符和类型字符,并适当增加表格说明。
85 6
C语言如何使用结构体和指针来操作动态分配的内存
在C语言中,通过定义结构体并使用指向该结构体的指针,可以对动态分配的内存进行操作。首先利用 `malloc` 或 `calloc` 分配内存,然后通过指针访问和修改结构体成员,最后用 `free` 释放内存,实现资源的有效管理。
328 13
C语言中常见的字符串处理技巧,包括字符串的定义、初始化、输入输出、长度计算、比较、查找与替换、拼接、截取、转换、遍历及注意事项
本文深入探讨了C语言中常见的字符串处理技巧,包括字符串的定义、初始化、输入输出、长度计算、比较、查找与替换、拼接、截取、转换、遍历及注意事项,并通过案例分析展示了实际应用,旨在帮助读者提高编程效率和代码质量。
200 4
C 语言指针与内存管理
C语言中的指针与内存管理是编程的核心概念。指针用于存储变量的内存地址,实现数据的间接访问和操作;内存管理涉及动态分配(如malloc、free函数)和释放内存,确保程序高效运行并避免内存泄漏。掌握这两者对于编写高质量的C语言程序至关重要。
105 11

热门文章

最新文章