详解C语言二级指针三种内存模型

二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别

第一种内存模型char *arr[]

若有如下定义

char*arr[]={"abc","def","ghi"};

这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组（char * []），数组的每个元素都是一个地址。

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为

char*tmp=NULL;

如果要打印这个数组，那么可以使用以下函数

intprintAarray(char**pArray,intnum)
{
inti=0;
if(pArray==NULL)
{
return-1;
}
for(i=0;i<num;i++)
{
printf("%s\n",pArray[i]);
}
return0;
}

第二种内存模型char arr[][]

若有如下定义

chararr[3][5]={"abc","def","ghi"};

这种模型为二级指针的第二种内存模型，在理解的时候应该这样理解：定义了一个二维数组，有3个（5个char）空间的存储变量。

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为

chartmp[5]={0};

如果要打印这个数组，那么可以使用以下函数

ntprintAarray(charpArray[][5],intnum)
{
inti=0;
if(pArray==NULL)
{
return-1;
}
for(i=0;i<num;i++)
{
printf("%s\n",pArray[i]);
}
return0;
}

第三种内存模型char **arr

若有如下定义

char**arr=(char*)malloc(100*sizeof(char*));//chararr[400]
arr[0]=(char*)malloc(100*sizeof(char));//charbuf[100]
arr[1]=(char*)malloc(100*sizeof(char));
arr[2]=(char*)malloc(100*sizeof(char));
strcpy(arr[0],"abc");
strcpy(arr[1],"def");
strcpy(arr[2],"ghi");
···
for(inti=0;i<3;i++)
if(arr[i]!=NULL)
free(arr[i]);
free(arr);

这种模型为二级指针的第二种内存模型，在理解的时候应该这样理解：定义了一个二级指针，二级指针就是指向指针的指针，其实就是开辟了100个指针空间，存放了100个地址。这种写法是第一种的简化写法

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为

char*tmp=NULL

如果要打印这个数组，那么可以使用以下函数

{
inti=0;
if(pArray==NULL)
{
return-1;
}
for(i=0;i<num;i++)
{
printf("%s\n",pArray[i]);
}
return0;
}

例子

把第一种内存模型的数据排序,运算结果放到第三种内存模型中

#include"stdio.h"
#include"string.h"
#include"stdlib.h"

char**SortArrayAndGen3Mem(constchar**constmyArray1,intnum,char*str,int*myNum)
{
char**p=NULL;
p=(char**)malloc(num*sizeof(char*));
if(myArray1==NULL||str==NULL||myNum==NULL)
{
printf("传入参数错误\n");
p=NULL;
gotoEND;
}
*myNum=num;
for(inti=0;i<num;i++)
{
p[i]=NULL;
p[i]=(char)malloc(50*sizeof(char));
memset(p[i],0,sizeof(p[i]));
if(p[i]==NULL)
{
printf("内存分配错误！\n");
gotoEND;
}
strcpy(p[i],myArray1[i]);
}
char*tmp;
for(inti=0;i<num;i++)
{
for(intj=i+1;j<num;j++)
{
if(strcmp(p[i],p[j])>0)
{
char*tmp=p[i];
p[i]=p[j];
p[j]=tmp;
}
}
}
for(inti=0;i<num;i++)
{
printf("%s\n",myArray1[i]);
}

END:
returnp;
}

//释放内存函数

voidmain()
{
inti=0;
char**myArray3=NULL;
intnum3=0;
//第一种内存模型
char*myArray[]={"bbbbb","aaaaa","cccccc"};
char*myp="111111111111";

myArray3=SortArrayAndGen3Mem(myArray,3,myp,num3);

for(i=0;i<num3;i++)
{
printf("%s\n",myArray3[i]);
}

system("pause");
}
#include"stdio.h"
#include"stdlib.h"
#include"string.h"

char**SortArrayAndGet3Mem(constchar*constmyArray1,intnum,char*str,int*myNum);
intgetArray(char***newp,intnum);
intfreeArray(char***newpfree,intnum);
intsortTArray(char*p,intnum);

voidmain()
{
char**myArray3=NULL;
intnum3=0;
char*myArray[]={"bbbb","aaa","cccc"};
char*myp="111111111";
myArray3=SortArrayAndGet3Mem(myArray,3,myp,num3);
system("pause");
}


char**SortArrayAndGet3Mem(constchar**constmyArray1,intnum,char*str,int*myNum)
{
intret=0;
char**p=NULL;
inti=0;
char**p1=NULL;
p1=(char**)myArray1;
ret=getArray(p,num+1);
for(i=0;i<num;i++)
{
strcpy(p[i],p1[i]);
}
strcpy(p[i],str);
ret=sortTArray(p,num+1);
for(i=0;i<num+1;i++)
{
printf("%s\n",p[i]);
}
ret=freeArray(p,num+1);
*myNum=num+1;
returnp;
}

intgetArray(char***newp,intnum)
{
inti=0;
intret=0;
char**tmp=NULL;
tmp=(char**)malloc(num*sizeof(char*));
for(i=0;i<num;i++)
{
tmp[i]=(char*)malloc(sizeof(char)*100);
}
*newp=tmp;//
return0;
}

//
intfreeArray(char***newpfree,intnum)
{
char**p=NULL;
inti=0;
intret=0;
p=*newpfree;
for(i=0;i<num;i++)
{
free(p[i]);
}
free(p);
*newpfree=NULL;//
returnret;
}

//intsortTArray(char***Arraystr,intnum)
intsortTArray(char**Arraystr,intnum)
{
inti,j=0;
for(i=0;i<num;i++)
{
for(j=i+1;j<num;j++)
{
if(strcmp((Arraystr)[i],(Arraystr)[j])>0)
{
chartmp[100];
strcpy(tmp,(Arraystr)[i]);
strcpy((Arraystr)[i],(Arraystr)[j]);
strcpy((Arraystr)[j],tmp);
}
}
}
for(i=0;i<num;i++)
{
printf("%s\n",(Arraystr)[i]);
}
return0;
}