指针是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就是指向函数指针数组的指针

指针数组 
首先从名字就可以知道这是一个数组，是存放指针的数组。
先看几种指针数组：
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++;               // 指向第二行

    

一、指针数组与数组指针先看两行代码，猜猜哪个是数组，哪个是指针
                                            int *p[5];
int (*p)[5];
有没有很简单，但是有很多初学者很是分不清楚；第一个是指针数组，第二个是数组指针。且看小僧给大家捋一捋，首先要明白符号优先级问题，“[ ]”的优先级高于“*”，所以p先和谁结合就表示谁。"int *p[5]" p先和[ ]结合，理所当然是数组了，只不过数组元素为 int * 型；"int (*p)[5]" “（）”的优先级高于“[ ]”,p先和“*”结合，理所当然是指针，只不过该指针指向 int 型数组的内容，是不是搜一贼。
指针数组:首先他是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。
数组指针:首先他是一个指针，他指向一个数组。是不是很难懂，且看下图
希望你们看了不会太晕
二、函数指针，函数指针数组
     函数指针，看到这里你肯定会照猫画虎，（首先他是一个指针，他指向一个函数）很对，就是这样的。接下来我们细细研究，先看张图
来几片代码瞧一瞧
(1) char *(*fun1)(char *p1,char *p2);(2) char * *fun2(char p1,char p2);
有没有很复杂的样子，第一题看起来像函数，其实他是函数指针，fun1是指针变量，他指向一个函数。这个函数有两个指针类型的参数，返回值为 char * 型;第二题看起来像指针，其实他是一个函数，fun2是函数名，参数为两个指针，返回值为 char 型二级指针。 函数指针也很简单吧，其实他和普通指针一样，我们使用他的好处在于，可以将实现同一功能的多个模块统一起来标识，这样可以使函数的接口与实现分开。
三、函数指针数组，函数指针数组指针（有了上面了的基础我们很容易掌握这两个）
函数指针数组:首先它是一个数组，数组元素为函数指针。（不干说，还是来个栗子:char *(* a[4])(char *p);它是一个数组，数组名为 a ，数组内有四个指向函数的指针；这个指针指向一些返回值类型为指向字符的指针，参数为指向字符的指针的函数。)
函数指针数组指针:首先它是一个指针，这个指针指向数组，这个数组里面存的都是指向函数的指针。（不怕，来个栗子就好了:char (*(* a)[4])(char *p); 这个指针指向包含了4个元素的数组；这个数组里面存的是指向函数的指针；这个指针指向一些返回值类型为指向字符的指针，参数为指向字符的指针的函数。）
来个例子看看他们的威力:
#include <stdio.h>
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;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*p[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 <= 4 && input >= 1))
			{
				printf( "输入操作数：" );
				scanf( "%d %d", &x, &y);
				ret = (*p[input])(x, y);
			}
			else
				printf( "输入有误\n" );
			printf( "ret = %d\n", ret);
		}
		return 0;
}
这计算器还可以吧，看看运算结果如何



四、叨叨几句，不要看起来很复杂，其实学起来也复杂，但是学懂了会很有赶脚。
好好学习，天天向上
初学者欢迎大家指正