两个辅助指针变量挖字符串(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;
}