在讲解具体的模型之前，我们一定要理解这样 的一个关系：
1、传参规则：
a.当二级指针作为函数形参时，能作为函数实参的是二级指针，指针数组，一级指针的地址 b.当数组指针作为函数形参时，能作为函数实参的是二维数组，数组指针 c.当二维数组作为函数形参时，能作为函数实参的是二维数组，数组指针 d.当指针数组作为函数形参时，能作为函数实参的是指针数组，二级指针,一级指针的地址
2.需要解释
2.1 指针数组 char *p[4];//本质上是一个数组，数组中的内容是一个个指针,数组有5个元素，每个元素都是一个指针
2.2 数组指针 char (*p)[30];//本质上是一个指针，这个指针指向了一个一维数组，注意这个指针的步长是一维数组中元素的个数
2.3 二级指针 char**p 和指针数组char *p[4]等价
2.4 二维数组 char[4][30] 和数组指针char (*p)[30]等价（一定要注意这个，因为数组名作为函数参数的时候就会退化为指针，然后注意步长问题，指针的本质就是步长问题，然后导致指针所指向的内存空间的数据类不一样）
2.5 关于二维数组中的地址以及步长问题，我会下面再讲第二种内存模型的时候进行详细的介绍
3.二级指针作为输入的三种内存模型
3.1 指针数组模型 char *p[4]
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
//二维指针的第一种内存模型
//添加函数
void printarray(char **p)
{
for (int m = 0; m < 4; m++)
{
printf("%s\n", p[m]);
}
}
void sortarray(char **p)
{
int i, j = 0;
char *tmp = NULL;
for (i = 0; i < 4; i++)
{
for (j = i + 1; j < 4; j++)
{
if (strcmp(p[i], p[j])>0)
{
tmp = p[i];
p[i] = p[j];
p[j] = tmp;
}
}
}
}
int main()
{
char *array[4] = { "aaaaaa", "bbbbbb", "111111", "000000" };
//先进行打印
printf("排序前\n");
printarray(array);
//再进行排序，进行交换指针的值
sortarray(array);
printf("排序后\n");
printarray(array);
return 0;
}
出入结果如下：
3.2 指向由m个元素组成的一维数组的指针变量 char (*p)[m] 一般对应的二维数组是char[n][m]
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
//指针数组 数组指针的区别一个是数组，一个是指针也其本质
//char **p对应的是 char *p[]//指针数组
//char p[][]对应的是 char (*p)[]//数组指针
void printMyArray02(char (*myArray)[30], int num)
{
int i = 0;
for (i = 0; i<num; i++)
{
printf("%s \n", myArray[i]);
//printf("%s \n", *(myArray + i)); //
}
}
//交换的是内存块。。。。。。。。
void sortMyArray02(char myArray[10][30], int num)
{
int i, j = 0;
char tmpBuf[30];
for (i = 0; i<num; i++)
{
for (j = i + 1; j<num; j++)
{
if (strcmp(myArray[i], myArray[j]) > 0)
{
strcpy(tmpBuf, myArray[i]); //交换的是内存块
strcpy(myArray[i], myArray[j]);
strcpy(myArray[j], tmpBuf);
}
}
}
}
//打印 排序
//封装成函数
void main()
{
int i = 0, j = 0;
int num = 4;
char myArray[10][30] = { "aaaaaa", "ccccc", "bbbbbbb", "1111111111111" };
//打印
printf("排序之前\n");
printMyArray02(myArray, num);
sortMyArray02(myArray, num);
//打印
printf("排序之后\n");
printMyArray02(myArray, num);
system("pause");
return;
}
输出结果如下：
我们重点关注下一个输出函数：然后顺便把一些原理做下进一步的解释和总结：
void printMyArray02(char (*myArray)[30], int num) { int i = 0; for (i = 0; i<num; i++) { printf("%s \n", myArray[i]); //printf("%s \n", *(myArray + i); //和上面一样 } }
传进来的是一个一维数组指针，那么他的步长是一维数组中元素的个数，也就是是步长是原来的实参char myArray[10][30]的列数30，因为二维数组中每一个元素是char占用一个字节，那么myArray的地址是2000的话，myArray+1的地址就是2032，但是这里你感觉有点奇怪了，我代码里写的是 *(myArray + i)，而我解释的是myArray+i,是的，他俩的地址是一个，因为我要%s输出内容，所以只要得到首地址就可以了，剩下的就会输出到'\0'结束，所以只要首地址相同就可了。
那就是总结到最后了，对于二维数组char myArray[10][30]
myArray+i 与 *(myArray+i)的值都是一样的，都是代表一个地址，但是二者的步长不一样
myArray是二维数组名，我们都知道二维数组名代表首元素的地址，但是要看下元素的单位是啥，这个二维数组是由三个一维数组组成，每个一维数组里有30个元素，myArray代表首元素一维数组为地址，也就是以一维数组为步长。
所以myArray 地址是2000, 则 myArray+1地址是2000+30 =2030
而*(myArray+i)=myArray[i],以myArray[0]为例子，这个相当于一维数组的数组名，代表一维数组首元素的地址，但是这个步长是一个元素，也就是是一个字节，myArray[0]与myArray[1]相差一个字节，myArray[0]地址也是2000和myArray相同，但是同样加1后不一样了，myArray[0]+1 是2001,代表第0行，第一个元素的地址 &a[0][1]
我们可以修改下代码，然后输出一个元素的值，如下：
void printMyArray02(char (*myArray)[30], int num) { int i = 0; for (i = 0; i<num; i++) { printf("%c\n", *（myArray[i]+0）); } }
输出结果如下：
3.3 自己构造二级指针内存结构
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
void getmemory(char ***array)
{
char**p = NULL;
p = (char**)malloc(sizeof(char*)* 100);
for (int i = 0; i < 3; i++)
{
p[i] = (char*)malloc(100);
sprintf(p[i], "%d%d%d", i + 1, i + 1, i + 1);
}
*array = p;
}
void freememory(char ***array1)
{
char **tmp = NULL;
tmp = *array1;
for (int i = 0; i < 3; i++)
{
if (tmp[i] != NULL)
{
free(tmp[i]);
tmp[i] = NULL;
}
}
if (tmp != NULL)
{
free(tmp);
tmp = NULL;
}
*array1 = NULL;
}
//二维指针的第三种内存模型 自己处理内存空间
int main()
{
char **array1 = NULL;
printf("排序前\n");
getmemory(&array1);
//把二级指针进行赋值
for (int i = 0; i < 3; i++)
{
printf("%s\n", array1[i]);
}
//开始排序
char *tmarray = NULL;
for (int i = 0; i < 3; i++)
{
for (int j = i+1; j < 3; j++)
{
if (strcmp(array1[i], array1[j]) < 0)
{
tmarray = array1[i];
array1[i] = array1[j];
array1[j] = tmarray;
}
}
}
printf("排序后\n");
for (int i = 0; i < 3; i++)
{
printf("%s\n", array1[i]);
}
//要进行内存的释放
//malloc两次要释放两次
freememory(&array1);
return 0;
}
内存结构布局如下：
程序输出结果如下：
我们可以看出不依赖C/C++编译器的能力，我们自己也可以构造成二级指针，这个二级指针就是相当于第一种的内存模型。
