指针是c语言的灵魂所在，然而因为其过于灵活，在使用的过程中难免出错。接下来我们简单分析一下常见的指针运用。
指针:
     1  一级指针
         char *p1 =  “abcdef”；
      2  二级指针
         char **p2 = &p1;
指针数组:
     1 char *arr[5] ;  (在数组中存放5个char* 指针)
指针数组指针
     1 char* arr[5];
        char * (*parr)[5] = &arr;
       parr就是指向指针数组arr的指针 （即parr为指针数组的指针）
数组指针:
     1   int   arr[5] = {1,2,3,4,5};
          int  (*p)[5] = &arr ;          p即为指向数组的指针，又称数组指针。
数组指针的数组:
      int arr1[3] = {1,2,3};
      int arr2[3] = {4,5,6};
      int (*parr[2])[3]={arr1,arr2};


函数指针:
  先写一个简单的函数
        int add(int x, int y)
         {
            return x+y;
         }
    int  (*pfun)(int, int)；
            pfun = add;
这样一来  pfun就是指向函数add的指针（即函数add的指针）。
下面是定义一个函数指针的方法：




指向函数指针数组的指针:
           函数指针数组也是指针数组，在这个数组中存放的是函数的指针
    eg: 我们先写加减乘除四个子函数。
         
        int (*pfunarr[4])(int, int) = {add, sub, mul, div};//这个数组就是函数指针数组      pfunarr就是指向函数指针数组的指针

文章目录
前言
一、指针数组
二、数组指针
三、函数指针
四、函数指针的数组
五、指向函数指针数组的指针
总结


前言
本文为学习C语言过程中关于指针问题的笔记，对于指针数组、数组指针、函数指针、函数指针数组以及指向函数指针数组的指针等易混淆的概念进行阐述，以便以后复习查阅
一、指针数组
  指针数组，顾名思义即数组元素全都为指针的数组。

一维指针数组的定义形式为：“指针类型 * 数组名[数组长度]”

例如，一个一维指针数组：
int* parr[10]; //存放整型指针的数组
char* pch[5];//存放字符型指针的数组 


由于数组元素均为指针，因此arr[i]是指数组第i+1个元素的指针

关于二维指针数组的定义为：
char* parr[][3] = {{"111", "5678", "9878"}, {"abhs", "jjsh", "fjsk"}, {"dksj", "sjcn", "kdsk"}};


二维数组中的元素亦可以表示为"*(*(parr+i))"。又因为"()"的优先级较"*"高，且"*"是右结合的，因此可以写作**(parr+i)，表示第'i+1'行的第一个元素。*(*(parr+i)+j)表示第i+1行第j+1个元素。
二、数组指针
 数组指针实质上是一个指针，它指向数组，存放的是数组的地址。

一维数组指针的定义形式为：“指针类型(*指针变量名)[数组长度]”

例如：
int *p1[10];//指针数组
int (*p2)[10];//数组指针
此处p2先于*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型
的数组。所以p是一个指针，指向一个数组，叫数组指针
这里要注意：[]的优先级高于*号，所以必须加上()来保证p先与*结合
int (*parr3[10])[5]//数组指针的数组 
parr3是一个数组，该数组有10个元素，每个元素是一个数组指针，每个数组指针
指向的数组有5个元素，每个元素是int型

三、函数指针
 函数指针是指向函数的指针，它是存放函数地址的一个指针，本身是一个指针变量，只不过该指针指向函数。

其声明形式为：函数返回值类型(*指针变量名)(函数参数类型)

例如：
int ADD(int x, int y)
{
int z = x + y;
return z;
}
int main()
{
int a = 10;
int b = 20;
int(*pa)(int, int) = ADD;//函数指针
printf("%d\n", (*pa)(2, 3));
return 0;
}

void print(char*str)
{
   printf("%s\n", str);
}
int main()
{
   void (*p) (char*)= print;
   (*p)("hello world");
   return 0;
}

四、函数指针的数组
 函数指针数组，就是一个存放函数指针的数组，该数组的每一个元素都是函数指针。

它的声明形式一般为：

函数返回值类型(*数组名[数组长度])(函数参数类型)

应用：
double Add(double x, double y)
{
   return x + y;
}
double Sub(double x, double y)
{
   return x - y;
}
double Mul(double x, double y)
{
   return x * y;
}
double Div(double x, double y)
{
   return x / y;
}
int main()
{
   //指针数组
   double* arr[5];
   //需要一个数组，这个数组可以存放四个函数的地址 - 函数指针的数组
   //double(*pa) (double, double) = Add;//Sub/Mul/Div
   double(*parr[4]) (double, double) = {Add,Sub,Mul,Div};
   //函数指针的数组
   int i = 0;
   for (i = 0; i < 4; i++)
   {
   	printf("%lf\n", parr[i](2,3));
   }
   return 0;
}

  
函数指针数组的用途：转移表；
使用函数指针数组可以简化switch case语句的使用，可以对之前编写的简单计算器添加计算功能时进行简化。
五、指向函数指针数组的指针
  
理所当然地，函数指针数组也可以使用指针指向，叫做指向函数指针数组的指针。这个指针指向一个数组，这个数组叫做函数指针数组，数组里面的每个元素存放的是函数的指针，这些函数的指针，分别指向函数。
例如：
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int arr[10] = { 0 };
	int(*p)[10] = &arr;//取出数组的地址
	int(*pf)(int, int);//函数指针
	int(*pfArr[4])(int, int);//pfArr是一个数组 - 函数指针的数组
	//指向函数指针数组的指针，指针指向一个数组，数组的元素都是函数指针
	//ppfArr是一个指向[函数指针数组]的指针
	int (*(*ppfArr)[4])(int,int) = &pfArr;
	//ppfArr是一个数组指针，指针指向的数组有4个元素
	//指向数组的每个元素类型是一个函数指针int(*)(int,int)
	return 0;
}

总结
指针数组、数组指针、函数指针、函数指针数组以及指向函数指针数组的指针十分易混淆，要多多回顾，勤加练习。

指针数组 
首先从名字就可以知道这是一个数组，是存放指针的数组。
先看几种指针数组：
int *arr1[10];
char *arr2[5];
char **arr3[6];
因为 [ ] 的优先级是高于 * 的，所以数组名会先于 [ ] 相结合组成数组。 再于 int * / char *类型结合，组成存放该类型的数组。






指针数组因为存放的都是指针所以不管是 int *   char * 还是 char ** 其大小都是四个字节。



数组指针 
从名字看就知道是指针，是指向一个数组的指针。

int (*p)[10];
char (*p)[10];
由数组指针知道 [ ] 的优先级是高于 *  的，所以用（）来提升指针先结合。


int (*p)[10];  //  是一个指向10个整形的一维数组的指针
char (*p)[10]; //  是一个指向10个字符型的一维数组的指针

数组的存储方式


因为指向的是一个数组，所以大小由数组决定


函数指针
指向函数的指针，通俗的说也就是函数的地址
void(*pfun)();
pfun 先和*结合，说明pfun是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void
也就是说 其可以保存函数的地址







函数指针数组
int (*parr[3])();
parr先与 [ ]结合，说明是一个数组，再与*结合，说明数组存放的是指针，指针都指向的是函数
函数指针数组的使用（转移表）
例子：计算器
#include<stdio.h>

int add( x, y)
{
	return x + y;
}
int sub(x,y)
{
	return x - y;
}
int mul(x,y)
{
	return x * y;
}
int div(x,y)
{
	return x / y;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*parr[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
	while (input)
	{
		printf("*******************************\n");
		printf("***** 1.add         2.sub *****\n");
		printf("***** 3.mul         4.div *****\n");
		printf("*******************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input > 0 && input < 5))
		{
			printf("输入你要计算的数：\n");
			scanf("%d  %d", &x, &y);
			ret = (*parr[input])(x, y);
		}
		else
			printf("输入有误！\n");
		printf("%d\n", ret);
	}
	return 0;
}
输出结果：




指向函数指针数组的指针 
这是一个指针，指向一个数组，这个数组是一个函数指针数组，数组中的元素都是函数指针
定义方式：

#include<stdio.h>
void test(const char *str)
{
	printf("%s\n", str);
}
int main()
{
	void (*pfun)(const char*) = test;
	//函数指针pfun
	void (*pfunArr[5])(const char* str);
	//函数指针的数组pfunArr
	void (*(*ppfunArr)[10])(const char* str) = &pfunArr;
	//指向函数指针数组pfunArr的指针ppfunArr
	return 0;
}

指针与数组：

    指针与一维数组：

       int arrInt[] = {1,2,3,4,5};

       int* pa = arrInt;

       *pa <==> arrInt[0];

       *(pa+1) <==> arrInt[1];

       *(pa+2)=6; <==> arrInt[2]=6;


   void func(int*);
   void func(int arr[]); // 与void func(int*); 形式是一样的
   void func(int arr[4]); // 只接收元素个数为4的整形数组


函数指针：

    void func1();

    void func2(int);

    void func3(int, double);

    int* func4();

  声明函数指针：

    void (*pf1)();              // pf1表示返回值void，没有参数的函数。

    void (*pf2)(int);           // pf2表示返回值void，参数只有一个int的函数。

    void (*pf3)(int, double);   // pf3表示返回值void，参数顺序为int、double的函数。

    int* (*pf4)();              // pf4表示返回值int*，无参的函数。

  函数指针赋值：(函数名就是一个内存地址)

    pf1 = func1;

    pf2 = func2;

    pf3 = func3;

    pf4 = func4;

  函数指针调用：

    (*pf1)(); 调用func1

    (*pf2)(1); 调用func2

    (*pf3)(1, 1.3); 调用func3

    (*p4)();    调用func4



函数指针数组：

    void (*pf[3])(); 声明3个指向void func();函数的指针



指针函数：

    返回值为指针的函数形似int* func();



指针数组：(存放指针的数组)

    int *pa[3]; // []优先级高于*，[]先与int结合组成数组，再由int*声明数组元素为指针。

    int a,b,c;

    pa[0] = &a;

    pa[1] = &b;

    pa[2] = &c;

数组指针：(指向数组的指针,也叫行指针)

    int (*pa)[3]; // ()、[]优先级一样高，从左到右结合，首先是()强调pa是指针，然后是[3]pa指向有三个元素的一维数组。

    int arrInt[3] = {1,2,3};

    pa = arrInt;

    pa++; //跨越一个数组长度，越界操作。



    数组指针通常与二维数组联用：

    int arrDoubleInt[4][3];

    pa = arrDoubleInt[0]; // 指向第一行

    pa[0][1] == *(*(pa+0)+1) == 第一行第二列数据。

    pa++;               // 指向第二行