int i;
int *pi;
int **pii;
pi=&a;
pii=π
//通过以上赋值语句，可以使下列三条赋值语句等价
i='a';
*pi='a';
**pii='a';

int *f;//将*f声明为整数，因此f为指向整型的指针
int *f();//函数调用操作符的优先级高于间接访问操作符，所以先执行函数调用，因此返回值为int*
int (*f)()//函数指针，先执行小括号，函数指针的基本类型为 void (*变量名)()
int* (*f)()//依然为函数指针，只不过上一个返回类型为int，而这一个为int*
int  f[ ]//整型数组f
int  *f[ ]//数组名为f，数组类型为指向整型的指针
int  f()[ ]//这个声明是不合法，因为f会与()相结合形成函数，那么其返回类型为整型数组，是非法的
int  f[ ]()//[ ]和()的结合性从左向右，所以这是一个数组，类型为返回类型为整型的函数，但是这个声明是非法，因为数组元素的长度            必须相等，而不同的函数的长度显然不相等
int (*f[ ])()//这个与上一个的目的类似，但是说这一次的数组类型为函数指针，尽管不同函数的长度可能不同，但是其指针长度是一致的
int* (*f[ ])()//这个与上一个函数的目的类似，只是这一函数采用了返回指向整数的指针的方法，也就是说这一次的数组类型为函数指针 //展示两个例子
int (*f)(int,float)
int* (*g[])(int,float)

int f(int);
int (*pf)(int);
pf=&f;//实际上这里的&操作符是可选的，因为f函数名的本质是函数指针，指针指向函数代码区域的起始部分
//以下是三种调用方式
f(1);//直接调用
(*pf)(1);//间接访问
pf(1);//实际上函数调用时，函数名会隐式转换为函数指针，而此表达式则将此过程显式表达了

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
typedef struct node{
    int a;
    struct node* b;
}node;
//不使用函数回调的情况
//node* search_(node* a1, int const val)
//{
//    while (a1 != NULL)
//    {
//        if (a1->a == val)
//            break;
//        a1 = a1->b;
//    }
//    return a1;
//}
//使用函数回调的情况
int compare(void const* a, void const* b)
{
    if (*(int*)a == *(int*)b)
        return 0;
    else
        return 1;
}
node* search_(node* a1, int const val,int (*abx)(void const*a1,void const *val))
{
    while (a1 != NULL)
    {
        if (abx(&a1->a,&val)==0)
            break;
        a1 = a1->b;
    }
    return a1;
}
int main()
{
    node c, d, e, f, g;
    node* head;
    c.a = 1;
    d.a = 2;
    e.a = 3;
    f.a = 4;
    g.a = 5;
    head = &c;
    c.b = &d;
    d.b = &e;
    e.b = &f;
    f.b = &g;
    node* phead = head;
    int (*abx)(void const*, void const*) = &compare;
    phead = search_(head, 3,abx);
    printf("%d", phead->a);
    return 0;
}

"xyz"+1//y
*"xyz"//x
"xyz"[2]//z
putchar("0123456789ABCDEF"[values%16])//简洁实现二进制变字符，values为源数