两个辅助指针变量挖字符串(4种实现方式)

最新推荐文章于 2024-09-02 22:46:49 发布
原创 最新推荐文章于 2024-09-02 22:46:49 发布 · 961 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
C语言提高

当前文章被收录于：

C语言提高
42 篇文章 0 人学习
订阅专栏 查看详情
本文探讨了如何利用两个辅助指针在字符串处理中进行操作，结合内存模型图，介绍了4种不同的实现方式，重点讲解了在主调函数分配内存的情况。

两个辅助指针挖字符串

内存模型图


1) 使用第二种内存模型 主调函数分配内存

    #include<stdio.h>  
    #include<stdlib.h>  
    #include <string.h>  
    #include <ctype.h>  
    /*函数功能 根据字符c来分割字符串str*/  
    int splitStr(const char *str,char c ,char buf[10][20],int *num)  
    {  
        char* p = NULL,*pTmp = NULL;//两个辅助指针变量  
        int tmpcount = 0,len;  
        p = str;  
        pTmp = str;  
        do   
        {  
            p = strchr(p,c);  
              
            if (p!=NULL)  
            {  
                if (p-pTmp>0)  
                {  
                    strncpy(buf[tmpcount],pTmp,p-pTmp);  
                    buf[tmpcount][p-pTmp] = '\0';  
                    //printf("%s\n",buf[tmpcount]);  
                    tmpcount++;  
                    pTmp = p = p+1;  
                    len = strlen(p);//用来保存最后一个字符串的长度  
                }     
            }  
            else  
            {  
                //拷贝最后一个分割的字符串包括\0  
                strncpy(buf[tmpcount],pTmp,len+1);  
                break;  
            }  
              
        } while (*p!='\0');  
        *num=tmpcount+1;  
        return 0;  
    }  
    /*函数功能 打印二维数组*/  
      
    void printArr(char a[10][20],int n)  
    {  
        int i;  
        for (i=0;i<n;i++)  
        {  
            printf("%s\n",*(a+i));  
        }  
    }  
      
    int main()  
    {  
        char *input="abcdefg,hjkln,sssss,kkk,hhh,j";  
        char ctemp = ',';  
        char myArr[10][20]={0};  
        char *tmp;  
          
        int ret;  
        int n,i;  
          
        ret = splitStr(input,ctemp,myArr,&n);  
        if (ret!=0)  
        {  
            printf("error\n");  
        }  
        printArr(myArr,n);  
          
        system("pause");  
        return 0;  
    }
2)使用第三种内存模型 主调函数分配内存 

    #include<stdio.h>  
    #include<stdlib.h>  
    #include <string.h>  
    #include <ctype.h>  
      
    /*第三种内存模型*/  
    int splitStr(const char *str,char c,char **buf,int *count)  
    {  
      
        char* p = NULL,*pTmp = NULL;//两个辅助指针变量  
        int tmpcount = 0,len;  
        p = str;  
        pTmp = str;  
        do   
        {  
            p = strchr(p,c);  
      
            if (p!=NULL)  
            {  
                if (p-pTmp>0)  
                {  
                    strncpy(buf[tmpcount],pTmp,p-pTmp);  
                    buf[tmpcount][p-pTmp] = '\0';  
                    //printf("%s\n",buf[tmpcount]);  
                    tmpcount++;  
                    pTmp = p = p+1;  
                    len = strlen(p);//用来保存最后一个字符串的长度  
                }     
            }  
            else  
            {  
                //拷贝最后一个分割的字符串包括\0  
                strncpy(buf[tmpcount],pTmp,len+1);  
                break;  
            }     
        } while (*p!='\0');  
        *count=tmpcount+1;  
        return 0;  
    }  
      
    int main()  
    {  
        char *input="abcdefg,hjkln,sssss,kkk,hhh,j";  
        char ctemp = ',';  
        char **p = NULL;  
        int ret;  
        int n,i;  
        p=(char**)malloc(10*sizeof(char*));  
        if (p==NULL)  
        {  
            return;  
        }  
        for (i=0;i<10;i++)  
        {  
            p[i] = (char *)malloc(20*sizeof(char));  
        }  
        ret = splitStr(input,ctemp,p,&n);  
        if (ret!=0)  
        {  
            printf("error\n");  
        }  
        for (i=0;i<n;i++)  
        {  
            printf("%s\n",*(p+i));  
        }  
             //释放内存  
        system("pause");  
        return 0;  
    }

3）使用第三种内存模型 被调函数分配内存 通过return返回

    #include<stdio.h>  
    #include<stdlib.h>  
    #include <string.h>  
    #include <ctype.h>  
    /*第三种内存模型 被调函数分配内存 通过return返回*/  
    char** splitStr2(char *str,char c,int *count)  
    {  
        char* p = NULL,*pTmp = NULL;//两个辅助指针变量  
        int tmpcount = 0,len,len2;  
        char**buf;  
        p = str;  
        pTmp = str;  
          
        //第一遍扫描 开辟第一维空间  
        do   
        {  
            p = strchr(p,c);  
            if (p!=NULL)  
            {  
                if (p-pTmp>0)  
                {     
                    tmpcount++;  
                    pTmp = p = p+1;  
                }     
            }  
            else  
            {  
                break;  
            }     
        } while (*p!='\0');  
        *count=tmpcount+1;  
        buf = (char**)malloc((tmpcount+1)*sizeof(char*));  
        //printf("tmpcount:%d\n",tmpcount);  
        if(buf==NULL)  
        {  
            return NULL;  
        }  
      
        //第二遍扫描 根据分割的字符串的长度，开辟第二维空间并拷贝字符串  
        tmpcount = 0;  
        p = str;  
        pTmp = str;  
        do   
        {  
            p = strchr(p,c);  
            if (p!=NULL)  
            {  
                if (p-pTmp>0)  
                {     
                    len = p-pTmp+1;  
                    buf[tmpcount] = (char*)malloc(len*sizeof(char));  
                    if (buf[tmpcount] == NULL)  
                    {  
                        free(buf);  
                        return ;  
                    }  
                    strncpy(buf[tmpcount],pTmp,p-pTmp);  
                    buf[tmpcount][p-pTmp] = '\0';  
                    tmpcount++;  
                    pTmp = p = p+1;  
                    len2 = strlen(p);//用来保存最后一个字符串的长度  
                }     
            }  
            else  
            {  
                //printf("tmpcount:%d\n",tmpcount);  
                //printf("len2:%d\n",len2);  
                buf[tmpcount] = (char*)malloc((len2+1)*sizeof(char));  
                if (buf[tmpcount] == NULL)  
                {  
                    free(buf);  
                    return ;  
                }  
                //拷贝最后一个分割的字符串包括\0  
                strncpy(buf[tmpcount],pTmp,len2+1);  
                break;  
            }     
        } while (*p!='\0');  
        return buf;  
    }  
      
    int main()  
    {  
        char *input="abcdefg,hjkln,sssss,kkk,hhh,j";  
        char ctemp = ',';  
        char **p = NULL;  
        int ret;  
        int n,i;  
        p = splitStr2(input,ctemp,&n);  
        printf("n:%d\n",n);  
        for (i=0;i<n;i++)  
        {  
            printf("%s\n",*(p+i));  
          
        }  
         //释放内存空间  
         system("pause");  
        return 0;  
    }

4）使用第三种内存模型 被调函数分配内存 通过函数参数返回 

#include<stdlib.h>  
#include <string.h>  
#include <ctype.h>  
/*第三种内存模型 被调函数分配内存 通过tmpbuf返回*/  
 int splitStr3(char *str,char c,char*** tmpbuf,int *count)  
{  
    char* p = NULL,*pTmp = NULL;//两个辅助指针变量  
    int tmpcount = 0,len,len2;  
    char**buf;  
    p = str;  
    pTmp = str;  
  
    //第一遍扫描 开辟第一维空间  
    do   
    {  
        p = strchr(p,c);  
        if (p!=NULL)  
        {  
            if (p-pTmp>0)  
            {      
                tmpcount++;  
                pTmp = p = p+1;  
            }      
        }  
        else  
        {  
            break;  
        }      
    } while (*p!='\0');  
    *count=tmpcount+1;  
    buf = (char**)malloc((tmpcount+1)*sizeof(char*));  
    //printf("tmpcount:%d\n",tmpcount);  
    if(buf==NULL)  
    {  
        return -1;  
    }  
  
    //第二遍扫描 根据分割的字符串的长度，开辟第二维空间并拷贝字符串  
    tmpcount = 0;  
    p = str;  
    pTmp = str;  
    do   
    {  
        p = strchr(p,c);  
        if (p!=NULL)  
        {  
            if (p-pTmp>0)  
            {      
                len = p-pTmp+1;  
                buf[tmpcount] = (char*)malloc(len*sizeof(char));  
                if (buf[tmpcount] == NULL)  
                {  
                    free(buf);  
                    return -2;  
                }  
                strncpy(buf[tmpcount],pTmp,p-pTmp);  
                buf[tmpcount][p-pTmp] = '\0';  
                tmpcount++;  
                pTmp = p = p+1;  
                len2 = strlen(p);//用来保存最后一个字符串的长度  
            }      
        }  
        else  
        {  
            //printf("tmpcount:%d\n",tmpcount);  
            //printf("len2:%d\n",len2);  
            buf[tmpcount] = (char*)malloc((len2+1)*sizeof(char));  
            if (buf[tmpcount] == NULL)  
            {  
                free(buf);  
                return -2;  
            }  
            //拷贝最后一个分割的字符串包括\0  
            strncpy(buf[tmpcount],pTmp,len2+1);  
            break;  
        }      
    } while (*p!='\0');  
    *tmpbuf = buf;  
    return 0;  
}  
 //释放内存空间  
 void freeMem(char**p,int count)  
 {  
     int i =0;  
     if (p == NULL)  
     {  
         return ;  
     }  
     for (i=0;i<count;i++)  
     {  
         if (p[i]!=NULL)  
         {  
             free(p[i]);  
         }  
     }  
     if (p!=NULL)  
     {  
         free(p);  
     }  
 }  
int main()  
{  
    char *input="abcdefg,hjkln,sssss,kkk,hhh,j";  
    char ctemp = ',';  
    char **p = NULL;  
    int ret;  
    int n,i;  
    ret = splitStr3(input,ctemp,&p,&n);  
    if (ret!= 0)  
    {  
        printf("error");  
        return -1;  
    }  
    //printf("n:%d\n",n);  
    for (i=0;i<n;i++)  
    {  
        printf("%s\n",*(p+i));  
      
    }  
    //释放内存  
    freeMem(p,n);  
    system("pause");  
    return 0;  
}



操作和辅助指针变量逻辑关系
08-15
操作和辅助指针变量逻辑关系　自己看的
pagehelper插件，踩坑笔记
木辰風的博客
07-20 4015
在使用过程中，pagehelper插件在复杂的sql查询count时，会自动生成select count(0) from (需要分页的sql) tmp_count，有时也会把排序字段放进去，导致count查询时间很长。 如，生成的分页sql： SELECT t.*, ( SELECT x.NAME FROM tb_jd_token x WHERE ( x.ID = t.MALL_FLAG ) ) AS mall_name, ( SELECT `NAME`
mysql分页tmp_count_Mysql分页查询获取totalCount大幅提升性能的办法总结
weixin_35280108的博客
02-08 2746
做分页查询中，一般情况下需要两个sql，查当前页数据 和 查记录总条数；但后者的查询结果变化有时候并不大，而且count还占用了很大一部分的查询时间；主要是想用一种省时简便的方法查询符合条件的记录总数，查询数据使用的sql为：SELECT SUBSTRING_INDEX(`url`,'/',3)AS host,COUNT(*)AS count FROM`tab`WHERE`type`=4GROUP...
C++智能指针的使用
gjg244的博客
02-14 316
C++智能指针使用
两个辅助指针变量挖取字符串
汤小萌的博客
08-08 687
两个辅助指针变量挖取字符串 方法一:在主调函数中分配内存 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> int splitSpring(const char *buf1, char c, char **myp /* in *...
实现一个函数，使用指针连接两个字符串。
weixin_49324123的博客
08-29 6828
#include<stdio.h> #include<Windows.h> #include<iostream> #include<string.h> /* 实现一个函数，使用指针连接两个字符串。 函数输入： 两个源字符串的指针，目的字符串的指针 */ void connect(char *p1,char *p2,char *p) //这里不需要再用p=p1 因为这样p就会指向p1而不指向main函数中的p数组了 char *p1p=p1; char
C语言_字符串的地址以及指向字符串的指针变量的定义
sk_girl的博客
09-17 1万+
一、字符串的地址以及指向字符串的指针变量的定义。 1. 字符常量：用单引号括起来的一个字符。 2. 字符串常量：用双引号括起来的一串字符。 3. 注意：由于变量只能存放一个字符，所以字符串只能存储在数组当中。 4. 用一维字符数组存放字符串:char str[] = “hello”; 5. 注意：字符数组可以没有’\0’，但字符串数组必须有’\0’ 二、字符串的赋值： 1. 可以在定义字符指针变量的同时，将一个字符串赋值指针变量。例如：char *ps1 = “form one” 把存放字符串
c语言指针赋值指针变量赋值吗,C语言_指针变量的赋值与运算，很详细
热门推荐
weixin_42471237的博客
05-18 1万+
指针变量的赋值指针变量同普通变量一样，使用之前不仅要定义说明， 而且必须赋予具体的值。未经赋值的指针变量不能使用， 否则将造成系统混乱，甚至死机。指针变量的赋值只能赋予地址， 决不能赋予任何其它数据，否则将引起错误。在Ｃ语言中， 变量的地址是由编译系统分配的，对用户完全透明，用户不知道变量的具体地址。 Ｃ语言中提供了地址运算符&来表示变量的地址。其一般形式为： & 变量名； 如&a...
【C语言提高29】两个辅助指针变量挖字符串
坚持！！
12-06 681
#include #include #include #include int spitString(char*buf1,char c,char buf2[10][30],int*count) { //strcpy(buf2[0], "aaaaa"); //strcpy(buf2[1], "bbbbbb"); char *p = NULL, *pTmp = NULL; int tmpco
引用为参数实现两个字符串变量的交换
helena84的专栏
03-31 6088
如题所示，通过调用传递引用的参数，实现两个字符串变量的交换，例如：char * ap="hello";char * bp="how are you";交换的结果使得ap和bp指向的内容分别为：char * ap="how are you"; ="hello";char * bp="hello";好的，下面开始代码：#include void swapstring(c
指针和指针变量
cai88453626的博客
05-02 7419
如果不初始化，p由可能指向任何地方，这种指针称之为野指针，通过野指针去改变指向的不确定的地址的行为是很危险的。对于使用钥匙打开房间A和房间B的效果是一致的，但是内容的交换要比钥匙的交换开销要大得多！①可以进行的算术运算，只有以下几种：px±n，px++/++px，px–/–px，px-py。指针变量pnum的值就是变量num的地址，指针与指针变量的区别，就是变量值与变量的区别。所以在定义指针变量的时候，如果暂时没有明确的指向，对其一般初始化为NULL（空指针）对没有指向的指针变量进行操作，是很危险的事情。
为什么字符串可以赋值给字符指针变量
weixin_43387480的博客
07-09 3651
本文系转载，对原文的主要几点进行了提炼，想看更详细的内容，请看原帖： https://blog.csdn.net/yichu5074/article/details/81701850?utm_source=app char* p = “How are you?”; 这里双引号做了3件事：1.申请了空间（在常量区），存放字符串。2.在字符串尾加了‘\0’。3.返回地址。 指针p接收的就是字符串的地址，而不是字符串本身。似乎问题到这里就解决了，但原文做了更多的扩展解和释，我这里做了提炼（必有不足之处）： 1.为
【c++】指针：指针和指针变量、指针数组、字符串
gogo小Sa的专栏
05-05 1551
    【c++】指针     一.  指针的概念     二.  指针和指针变量     三.  指针和数组     四．指针和字符串参考：《c++从入门到精通》 人民邮电出版社深度长文教你彻底掌握C++/C指针 https://blog.csdn.net/xierhacker/article/details/52516742C++指针：指针变量、数组指针、字符串指针、函数指针（西电）http:...
字符串地指针表示方式
最新发布
2301_81280642的博客
09-02 1562
C++的数组指针的表示陷阱
8.4 通过指针引用字符串
tang7mj的博客
05-22 997
通过指针引用字符串的方法在 C 语言编程中具有重要意义。它不仅提高了代码的灵活性和可读性，还增强了字符串处理的效率。在实际编程中，可以根据具体需求选择合适的方法引用和操作字符串，以达到最佳效果。用字符指针作为函数参数时，实参与形参的类型有以下几种对应关系，如表 8.3 所示。表 8.3 调用函数时实参与形参的对应关系实参形参字符数组名字符数组名字符数组名字符指针变量字符指针变量字符数组名字符指针变量字符指针变量。
C语言 指针实现两个字符串的交换
为学日益 为道日损
01-28 1万+
void jiaohuan(char * s1,char * s2){ char ch; int i = 0; while(*(s1+i)!='\0'){ ch = *(s1+i); *(s1+i) = *(s2+i); *(s2+i) = ch; i++; } } int main(){ char str[2][10]; gets...
两个辅助指针变量截取字符串
asdfghjkl978564的博客
04-18 342
如题：有一个字符串符合以下特征(”abcdef,acccd,eeee,aaaa,e3eeeee,sssss,";) 思路：用一个二维数组来存储截取后的字符串，以' ，'作为分隔符，截取完一个字符串后，更新当前的位置。直到' \0 '. 代码： 1 #include <stdlib.h> 2 #include <string.h> 3 ...
用指针函数将两个字符串拼接
YuJar的专栏
04-14 1万+
# include # include char *str(char *p1, char *p2){ char *p = p1; //将目标遗产地址赋给指针变量p;将数组s1的首地址赋给指针变量p, while(*p1++); //指针p1移到s1的串尾；当*p的值不是\0时, p就向后位移 直到*p为\0。 p1--; //因为p1现在的位置在\0,所以应向前移一个位置 while(*p1++
C语言指针操作（一）地址，指针，指针变量是什么
伯努利
02-26 5503
地址，指针，指针变量是什么？他们的区别？符号（*）在不同位置的解释？指针是C语言中的一个重要概念，也是C语言的一个重要特色；使用指针，可以使程序简洁、紧凑、高效。不掌握指针，就没有掌握C语言的精华。
[day03]两头堵挖字符串、字符串反转、一级指针(char )易错模型分析、作业换一种做法、const简单讲解、二维指针三种内存模型、怎么理解（多级）指针做函数参数、两个辅助指针变量挖字符串...
aqgapja0504的博客
12-28 257
1.两头堵 自己写的两头堵挖字符串 #include <stdio.h> //一般情况下不要修改输入内存块的值 int trimSpace(const char *inbuf, char *outbuf) { int ret = 0; char *bgnp = inbuf; char *end...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值