我对指针的理解

指针就是地址，指针变量存放地址
指针的类型决定了指针向前或者向后走一步的大小

                int a = 10；
                int *pi = &a;
                char * pc = &a;
                pi + 1;//地址加4(int)
                pc + 1；//地址加1(char)

二级指针

    int a = 1；
    int* p = &a;
    int** pp = &p;

这里的二级指针为什么要用 int** pp = &p？

    int a =1;
    int* p= &a;
    int* pp =&p;

比如像这种为什么不可以，在我的理解中，指针变量就是用来存放地址的，那定义一个指针变量int* pp来存放p的地址&p一样合乎情理。这样写在语法上并没有错误，但是在使用上就会存在问题，当我想要用*pp来访问a的内容-时问题就来了。

    int b = 10;
    int* p = &b;
    int* pp = &p;
    printf("%d\n", **pp);

这里会有一个报错 error:"*"的操作数必须是指针，因为这里定义二级指针变量时用是 int * p；所以当*p解引用之后就是一个地址，再次解引用就*地址，也就是对地址这个常量解引用。所以二级指针必须是 int** p

在同一块内存空间，指针+-指针的结果是指针之间元素的个数

    int arr[10] = { 0 };
    int* p1 = &arr[9];
    int* p2 = &arr[0];
    printf("p1= %p p2= %p %d\n",p1,p2, p1 - p2);
    //p1= 006FFD28 p2= 006FFD04 9

    int arr[10] = { 0 };
    short* p1 = &arr[9];
    short* p2 = &arr[0];
    printf("p1= %p p2= %p %d\n",p1,p2, p1 - p2);

    //p1= 005DFD40 p2= 005DFD1C 18

a+1 ,a[0]+1,&a+1 的区别

定义一个二维数组a[3][2]

    # include <stdio.h>
    int main()
    {
        int a[3][2] = { 1, 2, 3, 4, 5, 6 };
        printf("%d  %d  %d  \n", *(a + 1), *(a[0] + 1), *(&a + 1));//这里用%d只是为了看*(a[0]+1)的值
        printf("%p  %p  %p %p \n", a, (a + 1), (a[0] + 1), (&a + 1));
        return 0;
    }

a+1：元素加一，a[0]+1：首元素的首地址加一，&a+1：整个数组加一，跳过整个数组

---

* 指针数组
* 数组指针
* 函数指针
* 函数指针数组
* 指向函数指针数组的指针

区别这几个量首先看最后两个字，不管名字多么复杂，最后两个字是什么它就是什么，函数指针数组数组就是数组，指向函数指针数组的指针它就是指针

指针数组

是数组，是一个存放指针的数组
如：

    char* arr1[10];
    int* arr2[4];
    char* *arr3[5];

---

    int main ()
    {   
        char arr1[] = "han";
        char* arr2 = "jian";
        char *arr[2] = { arr1,arr2};
        int i = 0;
        for (i = 0; i < 2; i++)
        {
            printf("%s ", arr[i]);
        }
    }

    //han jian 
    //请按任意键继续. . .

数组指针

是指针，是一个指向数组的指针

    int (*p)[10];

---

    int main()
    {
        char arr1[] = "jian";
        char(*ar)[5] = &arr1;
        printf("%s\n", ar);
    }

    //jian
    //请按任意键继续. . .

在区分到底是指针数组还是数组指针时，看优先级，p先和谁结合就是什么，由于[ ]的优先级比的优先级高，int *p[10]中p先和[ ]结合，所以p是数组，如果加上括号，int (*p)[10]中p先和结合，那么它p就是指针。

函数指针

是指针，是一个指向函数的指针。

    void (*pf)();

---

    # include <stdio.h>
    void add(int a,int b)
    {
        printf("hello Jan\n");
    }
    int main()
    {
        int x = 3;
        int y = 7;
        void (*p)(int x ,int y) = add;
        (*p)(x, y);
    }

    //hello Jan
    //请按任意键继续. . .

函数指针数组

把函数地址存到数组中，这个数组就叫函数指针数组

    # include <stdio.h>
    int sad(int z)
    {
        printf("%can is not happy\n",z);
        return 0;
    }
    int happy(int a)
    {
        printf("Jan is so h%cppy \n",a);
        return 0;
    }
    int main()
    {
        int a = 97;
        int b = 74;
        int(*p[3])(x) = { happy ,sad};
        (*p[0])(a);
        (*p[1])(b);
    }

    //Jan is so happy
    //Jan is not happy
    //请按任意键继续. . .

函数指针数组的指针

指针指向一个数组，数组的元素是函数的指针

    # include <stdio.h>
    int sad(int z)
    {
        printf("%can is not happy\n",z);
        return 0;
    }
    int happy(int a)
    {
        printf("Jan is so h%cppy \n",a);
        return 0;
    }
    int main()
    {
        int a = 97;
        int b = 74;
        int(*p[3])(x) = { happy ,sad};
        int(*(*pp)[3])(x) = &p;
        (*pp)[1](b);
    }
    //Jan is not happy
    //请按任意键继续. . .