c语言：摆脱对指针的恐惧【4】

  在上一期指针我们讲到了二级指针是的作用是存放一级指针的地址，还讲了指针数组是一个可以存放若干个指针变量的数组，这里我们再复习一下，下面指针数组是什么意思？

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

上面三行代码都分别定义了一个数组，第一行代码的arr1数组存放了10个int类型的指针变量 ，第二行代码的arr2数组存放了4个字符类型的指针变量，第三行代码的arr3数组存放了三个二级字符类型的变量，复习完上一期学过的内容，我们马上开始这一期内容的学习吧。

数组指针

数组指针是指针还是数组呢，答案是，它是一个指针，一个指向数组的指针。

我们已经熟悉：  

整形指针： int * pint; 能够指向整形数据的指针。

浮点型指针： float * pf ; 能够指向浮点型数据的指针。

那数组指针应该是：能够指向数组的指针。

下面代码哪个是数组指针？

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？

解释：

int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指
向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

&数组名vs数组名 

假设我们定义一个数组：

int arr[10];

我们知道，arr表示这个数组的首元素地址，通常用于函数调用时的传址调用和把它赋给指针变量，以便指针可以访问该数组，那&arr是什么意思呢，也是首元素的地址吗？我们来看一段代码：

#include <stdio.h>
int main()
{
 int arr[10] = {0};
 printf("%p\n", arr);
 printf("%p\n", &arr);
 return 0;
}

运行结果如下：

从次代码的运行结果来看它们似乎是一样的，难道它们真的一样吗？再看一段代码：

在不进行任何运算时，它们的结果是一样的，然而在进行加一也就是向前走一步时，它们的结果却不一样，且整整相差了 40个字节，所以我们也能发现，虽然arr和&arr虽然值时一样的，但是它们表示的一样却是不同的。

实际上： &arr 表示的是 数组的地址 ，而不是数组首元素的地址。（细细体会一下）

本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型

数组的地址 +1 ，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是 40。

数组指针的使用

那么数组指针是怎么使用的呢？

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

看代码：

#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,0};
 int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
 //但是我们一般很少这样写代码
 return 0;
}

一个数组指针的使用：

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
 int i = 0;
 int j = 0;
 for(i=0; i<row; i++)
 {
 for(j=0; j<col; j++)
 {
 printf("%d ", arr[i][j]);
 }
 printf("\n");
 }
}
void print_arr2(int (*arr)[5], int row, int col)
{
 int i = 0;
 int j = 0;
 for(i=0; i<row; i++)
 {
 for(j=0; j<col; j++)
 {
 printf("%d ", arr[i][j]);
 }
 printf("\n");
 }
}
int main()
{
 int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
 print_arr1(arr, 3, 5);
 //数组名arr，表示首元素的地址
 //但是二维数组的首元素是二维数组的第一行
 //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
 //可以数组指针来接收
 print_arr2(arr, 3, 5);
 return 0;
}

我们想让程序输出arr中的所有元素，常见的方法是创建一个函数，用一个数组来接收，完成打印，而在我们学到数组指针优以后我们发现数组指针也可以完成二维数组的接收和打印，所以两个函数打印的是相同的内容，让我们运行程序试试：

结果完全相同，学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];

数组指针、指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

一维数组传参

#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int *arr)//ok?
{}
void test2(int *arr[20])//ok?
{}
void test2(int **arr)//ok?
{}
int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};
 test(arr);
 test2(arr2);
}

上面的几种函数参数设计都可以吗，是的，我们可以用数组接收数组首元素地址，也可以用指针接收数组首元素地址，我们可以用指针数组来接收指针数组首元素的地址，也可以用二级指针来接收指针数组首元素的地址，因为指针数组的首元素是一个一级指针，而一级指针的地址就必须用二级指针来储存，所以以上test函数的参数设计都是可以的。

二位数组传参

void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一列多少元素。
//这样才方便运算。
void test(int *arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int (*arr)[5])//ok？
{}
void test(int **arr)//ok？
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

一级指针传参

#include <stdio.h>
void print(int *p, int sz)
{
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d\n", *(p+i));
 }
}
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9};
 int *p = arr;
 int sz = sizeof(arr)/sizeof(arr[0]);
 //一级指针p，传给函数
 print(p, sz);
   return 0;
}

思考：当一个函数的参数部分为指针时，函数能接收什么样的参数？

比如：

void test1(int *p)
{}
//test1函数能接收什么参数？
void test2(char* p)
{}
//test2函数能接收什么参数？

答案是：test1可以接收一个int类型数组的首元素地址，也可以接收一个int类型变量的地址，同样，test2可以接收一个char类型数组的首元素地址，也可以接收一个char类型变量的地址。

二级指针传参

#include <stdio.h>
void test(int** ptr)
{
 printf("num = %d\n", **ptr); 
}
int main()
{
 int n = 10;
 int*p = &n;
 int **pp = &p;
 test(pp);
 test(&p);
  return 0;
}

思考：当函数的参数为二级指针的时候，可以接收什么参数？

void test(char **p)
{
 
}
int main()
{
 char c = 'b';
 char*pc = &c;
 char**ppc = &pc;
 char* arr[10];
 test(&pc);
 test(ppc);
 test(arr);//Ok?
  return 0;
}

答案是：当函数的参数为二级指针时，可以接收一个一级指针的地址，也可以接收一个指针数组的首元素地址。

函数指针

首先看一段代码：

#include <stdio.h>
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("%p\n", test);
 printf("%p\n", &test);
 return 0;
}

输出的结果：

当我们把一个函数名test和&test分别打印时。

输出的是两个地址，这两个地址是 test 函数的地址。 那我们的函数的地址要想保存起来，怎么保存？ 下面我们

看代码：

void test()
{
 printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，能存储地址，就要求pfun1或pfun2是指针，那哪个是指针呢？答案是：

pfun1 可以存放。 pfun1 先和 * 结合，说明 pfun1 是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

未完待续。。。。。。