多维数组和多维指针

指向指针的指针

指针变量在内存中会占用一定的空间

可以定义指针来保存指针变量的地址

int main()
{
	int a = 0;
	int* p = NULL;
	int** pp = NULL;
	
	pp = &p;   //把指针变量p的地址赋给指针变量pp
	*pp = &a;  //解引用pp可以把a的地址赋给p
	
	return 0;
}

int** pp本质上还是指针，只是两个**告诉你这是一个指向指针的指针

char** p = NULL;

char* p2; 

p = &p2;

给p赋值没有问题，但怎么使用p 呢？这就需要我们前面多次提到的钥匙（*） 
    第一步：根据 p 这个变量，取出它里面存的地址。 
    第二步：找到这个地址所在的内存。 
    第三步：用钥匙打开这块内存，取出它里面的地址，*p 的值。 
    第四步：找到第二次取出的这个地址。 
    第五步：用钥匙打开这块内存，取出它里面的内容，这就是我们真正的数据，**p 的值。 
    我们在这里用了两次钥匙（“*”）才最终取出了真正的数据。也就是说要取出二级指针所真正指向的数据，需要使用两次两次钥匙（“*”）。 
    至于超过二维的数组和超过二维的指针一般使用比较少，而且按照上面的分析方法同样也可以很轻松的分析明白，这里就不再详细讨论。

为什么需要指向指针的指针？

        .指针本质上也是变量

        .对于指针也同样存在传值调用与传址调用

二维数组与二级指针

二维数组在内存中以一维的方式排布

二维数组中的第一维是一维数组

二维数组中的第二维才是具体的值

二维数组的数组名可看做常量指针

例1：

以一维下标的方式遍历二维数组

void printArray(int a[], int size)
{
    int i = 0;
    
    printf("printArray: %d\n", sizeof(a));

    for(i=0; i<size; i++)
    {
        printf("%d\n", a[i]);
    }
}

int main()
{
    int a[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
    int* p = &a[0][0];
    
    printArray(p, 9);
    
    return 0;
}

运行

数组名

一维数组名代表数组首元素的地址

           int a[5]   -->  a的类型为int*

二维数组名同样代表数组首元素的地址

       int m[2][5]  -->  m的类型为int(*)[5]

1.二维数组名可以看做是指向数组的常量指针

2.二维数组可以看做是一维数组

3.二维数组中每个元素都是同类型的一维数组

例2：

#include <stdio.h>
int main()
{
    int a[5][5];  //a的类型是int(*)[5]
    int(*p)[4];   //p的类型是int(*)[4]
    
    p = a;
    
    printf("%d\n", &p[4][2] - &a[4][2]);
}

编译警告： 类型不匹配

运行结果：

       当数组名a 作为右值时，代表的是数组首元素的首地址。这里的a 为二维数组，我们把数组a 看作是包含5 个int 类型元素的一维数组,里面再存储了一个一维数组。如此，则a 在这里代表的是a[0] 的首地址。a+1 表示的是一维数组a 的第二个元素。a[4]表示的是一维数组a 的第5 个元素，而这个元素里又存了一个一维数组。所以&a[4][2]表示的是&a[0][0]+4*5*sizeof(int) + 2*sizeof(int) 。 
    根据定义，p 是指向一个包含4 个元素的数组的指针。也就是说p+1表示的是指针p 向后移动了一个“包含4 个int 类型元素的数组”。这里1 的单位是p 所指向的空间，即 4*sizeof(int) 。所以，p[4]相对于p[0]来说是向后移动了4 个“包含4 个int 类型元素的数组”，即&p[4]表示的是&p[0]+4*4*sizeof(int) 。由于p 被初始化为&a[0] ，那么&p[4][2]表示的是&a[0][0]+4*4*sizeof(int)+2* sizeof(int) 。 
    再由上面的讲述，&p[4][2]  和 &a[4][2] 的值相差4 个int 类型的元素。现在，上面测试出来的结果也可以理解了吧？其实我们最简单的办法就是画内存布局图： 
                              

    这里最重要的一点就是明白数组指针p 所指向的内存到底是什么。解决这类问题的最好办法就是画内存布局图。 

例3：

以指针的方式遍历二维数组

#include <stdio.h>
int main(int argc, char* argv[], char* env[])
{
    int a[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
    int i = 0;
    int j = 0;  
    for(i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            printf("%d\n", *(*(a+i) + j)); // <==> *(a[i] + j) <==> a[i][j]
        }
    }
}

例4：

动态申请二维数组（以二维指针模拟）

int** malloc2d(int row,int col)
{
	int** ret = (int**)malloc(sizeof(int*) * row);
	int* p = (int*)malloc(sizeof(int) * row * col);
	
	int i = 0;
	
	if(ret && p)
	{
		for(i=0; i<row; i++)
		{
			ret[i] = (p + i * col);
		}
	}
	else
	{
		free(ret);
		free(p);
		
		ret = NULL;
	}
	
	return ret;
}
void free2d(int** a)
{
	free(a[0]);
	free(a);
}

小结： 

C语言中只有一维数组，而且数组大小必须在编译期就作为常数确定

C语言中的数组元素可以是任何类型的数据，即数组的元素可以是另一个数组

C原因呢中只有数组的大小和数组首元素的地址是编译器直接确定的