【C语言复习（十七）】多维数组和多维指针

1、指向指针的指针

指针变量在内存中会占用一定的空间，既然占用空间，那么就有地址，即是可以定义另外一个指针来保存当前指针的地址值；

#include <stdio.h>
int main()
{
    int a=50;
    int* p=NULL;
    int** pp=NULL;
    pp=&p;
    *pp=&a;
    
    return 0;
}

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

指针在本质上也是变量；

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

示例：

#include <stdio.h>
#include <malloc.h>
 
//指针采用传值操作
//形参pstr直接指向了只读存储区的"Hello"字符串
char* reset_value(const char* pstr,const int size,const int new_size)
{
    //按照新大小重新分配空间
    char *p=(char*)malloc(sizeof(char)*new_size);
    int i=0;
 
    if(p && pstr && new_size>0)
    {
        //获得较小的空间大小
        int s=size > new_size ? new_size : size;
        for(i=0;i<s;i++)
        {
            *(p+i)=*(pstr+i);
        }
        *(p+i)='\0';
    }
    else
    {
        free(p);
        p=NULL;
        printf("出问题了！");
    }
    return p;
}
 
//指针采用传址操作，可以直接操作实参，因此不需要返回值
//形参pstr指向了实参p，要通过p才能操作只读存储区的"Hello"字符串
void reset_address(char** pstr,int size,int new_size)
{
    //按照新大小重新分配空间
    char *p=(char*)malloc(sizeof(char)*new_size);
    int i=0;
 
    //判断重新分配的空间有没有成功
    //判断形参pstr中保存的实参p的地址是否为空
    //判断*pstr即实参p中保存的地址是否为空
    //判断新空间大小是否大于0
    if(p && pstr && *pstr && new_size>0)
    {
        //获得较小的空间大小
        int s=size > new_size ? new_size : size;
        for(i=0;i<s;i++)
        {
            //由于pstr变量中保存的是实参p的地址，因此要使用*pstr来获得实参p中的地址值
            *(p+i)=*(*pstr+i);
        }
        *(p+i)='\0';
    }
    else
    {
        free(p);
        p=NULL;
        printf("出问题了！");
    }
    *pstr=p;
}
 
 
int main()
{
    char* p=(char*)malloc(sizeof(char)*10);
    p="Hello";
    reset_address(&p,10,3);
    printf("%s\n",p);
 
 
    return 0;
}

2、二维数组与二级指针

2.1 二维数组基础

在前面【C语言复习（十五）】数组指针和指针数组中已经介绍过二维数组一些基础的东西，这里不再重复，只做一个简单的总结：

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

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

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

二维数组的数组名可以看作常量指针；

 

2.2 以一维的方式遍历二维数组

#include <stdio.h>
 
#define DIM(array)   (sizeof(array)/sizeof(**array))
int main()
{
    int matrix[3][3]={{1,2,3},{4,5,6},{7,8,9}};
    //下面等价于  int* p=&matrix[0][0];
    int* p=&(*(*(matrix)));//p指向第0行0列元素
    int i=0;
    for(i=0;i<DIM(matrix);i++)
    {
        printf("%d\t",*(p+i));
    }
    return 0;
}

或者

#include <stdio.h>
 
#define DIM(array)   (sizeof(array)/sizeof(**array))
//以一维数组的方式遍历二维数组
void printfA(int *p,int size)
{
    int i=0;
    if(p && size>0)
    {
        for(i=0;i<size;i++)
            {
                printf("%d\t",*(p+i));
            }
    }
}
 
int main()
{
    int matrix[3][3]={{1,2,3},{4,5,6},{7,8,9}};
    //下面等价于  int* p=&matrix[0][0];
    int* p=&(*(*(matrix)));//p指向第0行0列元素
    printfA(p,DIM(matrix));
 
    return 0;
}

此程序原理就是二维数组在内存中是以一维的方式顺序排布的；

 

2.3 数组名

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

int a[5]  ==> a的类型为：int*；

二维数组名也代表数组首元素地址：

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

 

小结：

二维数组名可以看作是指向数组首元素的常量指针；

二维数组可以看作是由一维数组组成的；

二维数组中的每个元素都是同类型的一维数组（层层嵌套）；

 

2.4 使用指针遍历二维数组

#include <stdio.h>

int main()
{
    int row=0;
    int col=0;
    int matrix[3][3]={{1,2,3},{4,5,6},{7,8,9}};
    for(row=0;row<3;row++)
    {
        for(col=0;col<3;col++)
        {
            printf("%d\t",*(*(matrix+row)+col));
        }
    }
    return 0;
}

2.5 一个面试题

分析下列程序的输出：

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

 

初看，可能会觉得输出会是0，因为从程序中可以看到，a为5*5的二维数组名，然后定义了一个数组指针，且有4个元素，接着把a的值赋给了p；初看，觉得这里a为二维数组名，那么它代表数组首元素地址，即是0行这个一维数组的起始地址，所以这里的赋值合法，似乎一切都没问题，输出应该是0！！

可是运行程序后，看到的输出却为-4；这是怎么回事？？

实际上，这里数组名a确实代表二维数组首元素地址，而这个首元素是一个5元素的一维数组，因此类型应该为：int (*)[5]；而我们定义的p数组指针类型却是:int (*)[4];

因此在访问p[4][2]时，实际上编译器会认为p所指向的数组每一行只有4个元素，因此它&p[4][2]得到是a数组中第：4*4+2=18个元素的地址，而对于a[4][2]来说，编译器知道它每一行有5个元素，因此&a[4][2]得到的是第：4*5+2=22个元素，又因为指针的减法运算必须要指向同一个数组才有意义，这里满足条件，那么得到的差值是两个对应元素的下标差，因此这里的值为：18-22=-4！

即是说，这里的本质愿意是p的类型和a的类型不相同造成的！

 

2.6 以二维指针模拟动态申请二维数组空间

实现思路：

代码：

#include <stdio.h>
#include <malloc.h>

int** malloc2d(int row, int col)
{
	if (row <= 0 || col <= 0)
	{
		return NULL;
	}
	//分配空间存放int型元素，得到这段内存起始地址
	int* p = (int*)malloc(sizeof(int)*row*col);
	int** a = (int**)malloc(sizeof(int*)*row);
	int i = 0;
	if (p && a)
	{
		for (i = 0; i<row; i++)
		{
			*(a + i) = p + i*col;
		}
	}
	else
	{
		free(p);
		free(a);
		p = NULL;
		a = NULL;
	}
	return a;
}

int main()
{
	int** p = malloc2d(3, 3);
	int i = 0, j = 0;
	for (i = 0; i<3; i++)
	{
		for (j = 0; j<3; j++)
		{
			*(*(p + i) + j) = i + j;
		}
	}

	for (i = 0; i<3; i++)
	{
		for (j = 0; j<3; j++)
		{
			printf("%d\t", *(*(p + i) + j));
		}
	}

	return 0;
}

 

3、小结

• C语言中只有一维数组，多维数组都是由它组合嵌套而成，数组大小必须在编译期就作为常数确定；
• C语言中的数组元素可以是任何数据类型，即数组的元素可以是另一个数组；
• C语言中只有数组的大小和数组首元素的地址是编译器直接确定的；