原文首发于同名微信公号「Allen5G」，每天分享编程，算法知识，欢迎大家搜索关注，欢迎转发！

指向指针的指针

• 指针的本质是变量
• 指针会占用一定的内存空间
• 可以定义指针的指针来保存指针变量的地址值

int main()
{
	int i = 0;
	int* p = NULL;
	int** pp = NULL;
	
	pp = &p;
	
	*pp = &i;
	
	return 0;
}

可能会有疑问：问什么需要指向指针的指针？

• 指针在本质上也是变量
• 对于指针也同样存在传值调用与传址调用

实例1：重置动态空间大小

#include <stdio.h>
#include <malloc.h>
int reset(char**p, int size, int new_size) //定义的二维指针
{
 int ret = 1;
 int i = 0;
 int len = 0;
 char* pt = NULL;
 char* tmp = NULL;
 char* pp = *p;
 
 if( (p != NULL) && (new_size > 0) ) //安全性检测
 {
 pt = (char*)malloc(new_size); //动态申请一段内存空间
 
 tmp = pt;
 
 len = (size < new_size) ? size : new_size; //判断新分配的空间与之前的比较大小
 
 for(i=0; i<len; i++)
 {
 *tmp++ = *pp++; 
 }
 
 free(*p);
 *p = pt; //改变内存地址
 }
 else
 {
 ret = 0;
 }
 
 return ret;
}
int main()
{
 char* p = (char*)malloc(5);
 
 printf("%p\n", p); //这是打印重新分配前地址值
 
 if( reset(&p, 5, 3) ) //假设申请的空间用不完，可以再次改变，使用reset函数，将p对应的内存空间又5变为3
 {
 printf("%p\n", p); //实际发现变化了----就是指针的传址调用
 }
 free(p); //释放内存
 
 return 0;
}

二维数组和二维指针

• 二维数组在内存中是以一维的方式排布的
• 二维数组的第一维是一维数组
• 二维数组的第二维是具体的值
• 二维数组可以看做常量指针

如图所示：

?

实例2：遍历二维数组

#include <stdio.h>
#include <malloc.h>
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];
 
 int i = 0;
 int j = 0;
 
 for(i=0; i<3; i++)
 {
 for(j=0; j<3; j++)
 {
 printf("%d, ", *(*(a+i) + j)); //*（a+i） ==> a[i] ,*(a[i]+j) ==> a[i][j] 数组可读性好
 }
 
 printf("\n");
 }
 
 printf("\n");
 
 printArray(p, 9);
 
 return 0;
}

数组：

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

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

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

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

结论：

1. 二维数组名可以看做指向数组的常量指针
2. 二维数组可以看做是一维数组
3. 二维数组中的每一个元素都是同类型的一维数组

实例3：申请动态二维数组

#include <stdio.h>
#include <malloc.h>
int** malloc2d(int row, int col) //二维指针
{
 int** ret = NULL;
 
 if( (row > 0) && (col > 0) )
 {
 int* p = NULL;
 
 ret = (int**)malloc(row * sizeof(int*)); //先申请一个一维数组
 p = (int*)malloc(row * col * sizeof(int)); //这个之前是 p = (int*)malloc(row * col); 会造成内存越界的情况
 
 if( (ret != NULL) && (p != NULL) ) //安全检查
 {
 int i = 0;
 
 for(i=0; i<row; i++)
 {
 ret[i] = p + i * col;
 }
 }
 else
 {
 free(ret);
 free(p);
 
 ret = NULL;
 }
 
 }
 
 return ret;
}
void free2d(int** p)
{
 if( *p != NULL )
 {
 free(*p); //释放
 }
 
 free(p);
}
int main()
{
 int** a = malloc2d(3, 3); //得到一个2*3的二维数组
 int i = 0;
 int j = 0;
 
 for(i=0; i<3; i++)
 {
 for(j=0; j<3; j++)
 {
 printf("%d, ", a[i][j]); 
 }
 
 printf("\n");
 }
 
 free2d(a);
 
 return 0;
}

小结：

• 1.C语言其实只支持一维数组
• 2.C语言中的数组大小必须在编译器就作为常数确定
• 3.C语言的数组元素可是任何类型的数据
• 4.C语言的数组的元素可以是另一个数组