二级指针作为输入的三种内存模型_char * p[2]; char tmp[4] = {鈥檃aa鈥榼; p=tmp;-CSDN博客

本文链接：https://blog.csdn.net/zhanghuaichao/article/details/108920514

在讲解具体的模型之前，我们一定要理解这样的一个关系：

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;

}

内存结构布局如下：