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语言中只有数组的大小和数组首元素的地址是编译器直接确定的;