数组指针，指针数组，函数指针，指针函数的分析

数组指针，指针数组，函数指针，指针函数的分析

一：数组指针
数组指针（也称行指针）定义：int(*p)[n]，是指针，指向数组的指针
（）的优先级高，首先说明p是一个指针，指向一个整形的一维数组，这个一维数组的长度为n，也可以说是p的步长，也就是说，当p执行p+1操作时，p要跨过n个整形数据的长度。

int main() {
 int a[5] = { 1,2,3,4,5 };
 int(*p)[5];
 //把数组a的地址赋给p，则p为数组a的地址，*p表示a本身
 p = &a;
 printf("%p\n", a);//输出数组名，一般用首元素的地址来表示一个数组，则输出首元素的地址
 printf("%p\n", p);//p为数组a的地址，则输出数组a的地址
 printf("%p\n", *p);//*p为数组a本身，一般用首元素的地址来标识数组
 printf("%p\n", &a[0]);//输出数组a首元素的地址
 printf("%p\n", p[0]);//输出数组a首元素的地址
 printf("%d\n", **p);//输出数组a首元素的值
 printf("%d\n", a[0]);//输出数组a首元素的值
 printf("%d\n", *p[0]);//输出数组a首元素的值
 system("pause");
 return 0;
}

如果要将一个二维数组赋给指针，应该这样赋值：
int a[3][4];
int (*p)[4] //该语句是定义一个数组指针，指向含4个元素的一维数组
p=a；//将该二位是数组的首地址赋给p，也就是a[0][0]
p++;//跨过a[0][]指向a[1][];
二：指针数组

指针数组 定义：int *p[n]
[]的优先级高，与p结合形成一个数组，再由int *说明这是一个整形指针，这里执行p+1是错误的，这样赋值也是错误的。

int main() {
 int a = 1;
 int b = 2;
 int* p[2];
 p[0] = &a;
 p[1] = &b;
 printf("%p\n", p[0]);
 printf("%p\n", &a);
 printf("%p\n", p[1]);
 printf("%p\n", &b);
 printf("%d\n", *p[0]);
 printf("%d\n", *p[1]);
 system("pause");
 return 0;
}

如要将二维数组赋给一指针数组:
int *p[3];
int a[3][4];
for(i=0;i<3;i++)
p[i]=a[i];
这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]
所以要分别赋值。

数组指针是一个指针变量，占有内存中一个指针的存储空间
指针数组是多个指针变量，以数组的形式存储在内存中，占有多个指针的存储空间

int main() {
 /*定义一个二维数组
  0 1 2
  3 4 5
  输出第一行第二列的值：5*/
 int a[2][3] = { {0,1,2},{3,4,5} };
 int(*p)[3];//数组指针，指向含有3个元素的一维数组
 int* q[2];//指针数组，一个数组内存中存放两个指针变量
 p = a;
 q[0] = a[0];
 q[1] = a[1];
 printf("%d\n", a[1][2]);
 printf("%d\n", *(p[1] + 2));
 printf("%d\n", *(*(p + 1) + 2));
 printf("%d\n", (*(p + 1))[2]);
 printf("%d\n", p[1][2]);
 printf("%d\n", *(q[1] + 2));
 printf("%d\n", *(*(q + 1) + 2));
 printf("%d\n", *(q + 1)[2]);
 printf("%d\n", q[1][2]);
 system("pause");
 return 0;
}

三：函数指针

函数具有可赋值给指针的内存地址，一个函数的函数名称就是一个指针，它指向函数的代码。也是调用函数的地址。函数的调用可以通过函数名，也可以通过指向函数的指针来调用，函数指针还允许将函数作为变元传递给其他函数。
我们知道数组名代表数组首元素的地址，同样，函数名代表函数的地址。

函数指针原型：
类型（*指针变量名）（参数列表）
例如：
int（*fun）（int int）
注意：函数指针，首先它是一个指针，它指向函数的地址

int Max(int a, int b) {
 return a > b ? a : b;
}
int Min(int a, int b) {
 return a < b ? a : b;
}
//声明指针函数
int(*fun)(int, int);
int main() {
 int i = 10;
 int j = 20;
 fun = &Max;//函数指针赋值
 cout << fun(i, j) << endl;
 fun = &Min;
 cout << fun(i, j) << endl;
 system("pause");
 return 0;
}

int Max(int a, int b) {
 return a > b ? a : b;
}
int(*fun)(int, int);
int getMax(int a, int b, int(*fun)(int, int)) {
 return fun(a, b);
}
int main() {
 int i = 10;
 int j = 20;
 cout << getMax(i, j, Max)<<endl;
 system("pause");
 return 0;
}

函数指针数组
函数指针数组，首先它是一个数组，数组元素是函数的地址。即把函数的地址保存在数组里。

int add(int a, int b) {
 return a + b;
}
int sub(int a, int b) {
 return a - b;
}
int mul(int a, int b) {
 return a * b;
}
int main() {
 int x, y;
 int input = 0;
 int ret=0;
 int(*p[4])(int x, int y) = { 0,add,sub,mul };
 cout << "选择操作（0~3）" << endl;
 cin >> input;
 cout << "请输入两个数" << endl;
 cin >>x>>y;
 ret = (*p[input])(x, y);
 cout << ret << endl;
 system("pause");
 return 0;
}

typedef函数指针
typedef是定义一种新类型，如下：

typedef int (*pFun)(int, int);//定义函数指针别名
int Max(int a, int b) {
 return a > b ? a : b;
}
int main() {
 pFun fun;                 //定义函数指针变量
 fun = Max;                //函数指针变量赋值
 cout << (*fun)(10, 20) << endl;
 system("pause");
 return 0;
}

#include<iostream>
using namespace std;
typedef int(*FP_CALC)(int, int);
int add(int a, int b) {
 return a + b;
}
int sub(int a, int b) {
 return a - b;
}
int mul(int a, int b) {
 return a * b;
}
int div(int a, int b) {
 return  a / b;
}
//根据操作符返回相应函数的地址
FP_CALC get_funAddr(char op) {
 switch (op) {
 case'+':
  return add;
 case'-':
  return sub;
 case'*':
  return mul;
 /*case'/':
  return div;*/
 default:
  return NULL;
 }
 return NULL;
}
int calc(int a, int b, char op) {
 FP_CALC fp = get_funAddr(op);
 if (fp) {
  return (*fp)(a, b);
 }
 else {
  return -1;
 }
}
 int main() {
  int a = 100, b = 20;
  cout << calc(a, b, '+')<<endl;
  cout <<  calc(a, b, '-')<<endl;
  cout <<  calc(a, b, '*')<<endl;
  cout << calc(a, b, '/')<<endl;
  return 0;
 }

注：函数指针的值表示程序将要跳转的地址，指针的类型表示程序的调用方式。

四：指针函数

指针函数本质是一个函数，该函数的返回值是一个指针。
声明格式：类型标识符*函数名（参数列表）
普通函数声明：

int fun(int x,int y)

指针函数声明：

int *fun(int x,int y)

其返回值是一个int类型的指针

//指针函数的声明
int* pfun(int* arr, int n);
//指针函数的定义
int* pfun(int* arr, int n) {
 int* p = arr;
 return p;
}
int main() {
 int arr[] = { 0,1,2,3 };
 int size = sizeof(arr) / sizeof(arr[0]);
 int* p;
 int i;
 //指针函数的调用
 p = pfun(arr, size);
 for (i = 0;i < size;i++) {
  cout <<  *(p + i) << endl;
 }
 return 0;
}

主函数中，把一个数组的首地址与数组长度作为实参传给指针函数pfun里，把指针函数的返回值（即指向数组的指针）赋给整形指针p。最后用指针p来遍历数组元素并打印输出。