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

一.指针数组

 

• 指针数组：顾名思义是“指针的数组”。首先它是个数组；其次数组中存放所有元素是指针类型，但强调的是数组，数组占多少个字节由数组本身决定，在32位系统中，指针占四个字节。
• 举例

char *str[4] ={"this","is","a","mmc"};
//str是定义的一个指针数组，有四个元素，每个元素是一个char *类型的指针，这些指针存放着其对应字符串的首地址

解释： [ ] 的优先级高于 * ，所以 str 先与 [] 结合，表示这是一个数组变量，有四个元素。 [ ] 的优先级高于 * ，所以 str 先与 [] 结合，表示这是一个数组变量，有四个元素。

 之后我们可以将 str[4] 去掉，就剩下了 char * ，表示这个数组中存放的是char * 类型的指针

二.数组指针

 

• 数组指针：即”数组的指针“。首先它是一个指针；其次”数组“修饰这个指针，意思是说这个指针存放着一个数组的首地址，或者说这个指针指向一个指针数组的首地址。
• 举例

char *str[4] = {"this","is","a","mmc"};
char *(*pstr)[4] = str;
//pstr是定义的一个数组指针，它存放着数组str的地址
//str数组有四个元素，每个元素是一个char *类型的指针，这些指针存放着其对应字符串的首地址

解释： [] 的优先级高于 * ，所以需要加上()来保证 pstr 先与 * 结合，表示这是一个指针变量，： [] 的优先级高于 * ，所以需要加上()来保证 pstr 先与 * 结合，表示这是一个指针变量，

它存放着数组str的地址。之后我们可以将 * pstr 去掉，就剩下了 char * [4] ，表示这个指针指向的是一个数组，

这个数组里面存放了四个char * 类型的指针

三.函数指针

 

• 函数指针：顾名思义是”函数的指针“。也就是指向函数地址的一个指针变量
• 举例

int Add(int x, int y)
{
    return x + y;
}

int main()
{
    int a = 1;
    int b = 2;
    int (*pfun)(int，int) = Add(a, b);
    //Add是一个简单的加法函数
    //pfun是定义的一个函数指针，它存放着函数Add的地址
    printf("%d\n", pfun);
    return 0;

}

解释： () 的优先级高于 * ，所以需要加上()来保证 pfun 先与 * 结合， () 的优先级高于 * ，所以需要加上()来保证 pfun 先与 * 结合，

表示这是一个指针变量，它存放着函数Add的地址。之后我们可以将 * pfun 去掉，就剩下了 int () ，

表示这个指针指向的是一个函数，这个函数有两个int型参数，它的返回值为int类型。

四.函数指针数组

 

• 函数指针数组：即为”函数指针的数组“。
• 函数指针的用途：转移表。
• 举例（计算器）

#include <stdio.h>

int Add(int x, int y)
{
    return x + y;
}

int Sub(int x, int y)
{
    return x - y;
}

int Mul(int x, int y)
{
    return x * y;
}

int Div(int x, int y)
{
    if (y == 0)
    {
        return 'F';
    }
    else
    {
        return x / y;
    }
}

int main()
{
    int a = 0;
    int b = 0;
    int input = 1;
    char ret = 0;
    int(*p[5])(int a, int b) = { 0, Add, Sub, Mul, Div }; 
    //
    //转移表
    //p是定义的一个函数指针数组，它有五个元素，每个元素是一个函数指针，这些指针存放着其对应函数的地址
    while (input)
    {
        printf("**********************************\n");
        printf("***** 1.Add            2.Sub *****\n");
        printf("***** 3.Mul            4.Div *****\n");
        printf("*****         0.Quit         *****\n");
        printf("**********************************\n");
        printf("\n请选择：");
        scanf("%d", &input);
        if (input >= 1 && input <= 4)
        {
            begin:
            printf("\n请输入操作数：");
            scanf("%d %d", &a, &b);
            ret = p[input](a, b);
            if (ret == 'F')
            {
                printf("\n输入有误,请重新输入\n");
                goto begin;
            }
            else
            {
                printf("\nret = %d\n\n", ret);
            }
        }
        else if (input == 0)
        {
            printf("\n退出\n\n");
        }
        else
        {
            printf("\n选择错误\n\n");
        }
    }
    return 0;
}

char* (*fun[3])(char* p1, char* p2) ;他是一个数组，数组名是 fun 。数组中存了3个数组中存了3个

指向函数的指针。把它变换一下char* (*)(char* p1, char* p2) fun[3] ;char* (*)(char* p1, char* p2) fun[3] ;

<span style="color:#cc0000"><strong>这3个指向函数的指针指向 {一些返回类型为指向字符的指针、参数为一个指向字符的指针的函数}。</strong></span>

 

 

 

 

 

五.指向函数指针数组的指针

 

• 指向函数指针数组的指针：名字很长，但本质是指针。这个指针指向一个数组，这个数组里面存放的是指向函数的指针。
• 举例

void test(int x)
{
    printf("hehe\n");
}

int main()
{
    //函数指针pfun
    void(*pfun)(int) = test;
    //函数指针数组pfunarr
    void(*pfunarr[5])(int);
    pfunarr[0] = test;
    //指向函数指针数组pfunarr的指针ppfunarr
    void(*(*ppfunarr)[10])(int) = &pfunarr;
    return 0;
}

<strong><span style="color:#cc0000">char* (*(*pf)[3])(char* p)。把变量名写在后边，</span></strong>

<strong><span style="color:#cc0000">再来看代码：char* (*(*)[3])(char* p) pf </span></strong>

<strong><span style="color:#cc0000">解释：pf 首先是一个指针，这个指针指向一个包含了3个元素的数组；这个数组里面存的是指向函数的</span></strong>

<strong><span style="color:#cc0000">指针；</span><span style="color:#cc0000">这些指针指向一些返回值类型为指向字符的指针、参数为一个指向字符的指针的函数。</span></strong>