说明一个指向3个函数的指针数组：void(*ptr[3])(int)={fun0,fun1,fun2}。根据不同输入选择不同的函数，例如：输入1，则打印，"这是1号函数的打印输出。"；输入2，则打印，

这是一个指向函数的指针数组，它包含三个元素`ptr[0]`、`ptr[1]`和`ptr[2]`，每个元素都是一个指向接受整数作为参数并返回`void`类型的函数指针。数组声明`void(*ptr[3])(int)`表明了这一点。这里`fun0`, `fun1`, 和 `fun2` 是实际的函数名，假设它们分别是处理不同输入的行为。

例如，如果你有一个这样的结构：

void fun0(int x) {
    printf("这是0号函数的打印输出，输入：%d\n", x);
}

void fun1(int x) {
    printf("这是1号函数的打印输出，输入：%d\n", x);
}

void fun2(int x) {
    printf("这是2号函数的打印输出，输入：%d\n", x);
}

你可以通过索引来动态调用这些函数，比如：

int input;
scanf("%d", &input);

switch (input) {
    case 1:
        (*ptr[0])(1); // 执行fun0(1)
        break;
    case 2:
        (*ptr[1])(2); // 执行fun1(2)
        break;
    // ... 其他case...
    default:
        printf("无效的输入！\n");
        break;
}

当你输入1时，会调用`fun0(1)`并打印相应的消息，依此类推。

相关问题

使用C语言数组指针实现以下功能：存在函数，原型为：int* fun(char*,float); 1,定义一个函数，该函数的形参为fun函数类型的指针 2,定义一个函数，该函数的返回值为fun函数类型的指针 3,定义fun函数类型的指针数组

好的，以下是使用 C 语言数组指针实现定义一个函数，该函数的形参为 `fun` 函数类型的指针，定义一个函数，该函数的返回值为 `fun` 函数类型的指针，以及定义 `fun` 函数类型的指针数组的代码：

#include <stdio.h>

int* fun(char* str, float f) {
    static int result[2];
    result[0] = strlen(str);
    result[1] = (int)f;
    return result;
}

void test(int* (*p)(char*, float)) {
    char str[100];
    float f;
    printf("请输入一个字符串和一个浮点数：\n");
    scanf("%s %f", str, &f);

    int* result = p(str, f);
    printf("字符串长度：%d\n", *result);
    printf("浮点数转换为整数：%d\n", *(result+1));
}

int* (*fun_ptr)(char*, float);

int main() {
    fun_ptr = fun;
    test(fun_ptr);

    int* (*fun_ptr_array[5])(char*, float);
    fun_ptr_array[0] = fun;
    printf("fun_ptr_array[0](\"hello\", 3.14) = {%d, %d}\n", *(fun_ptr_array[0]("hello", 3.14)), *(fun_ptr_array[0]("hello", 3.14)+1));

    return 0;
}

这个程序中，我们首先定义了一个函数 `fun`，该函数的参数为一个字符串和一个浮点数，返回值为一个包含两个整数的数组指针。在函数中，我们使用 `strlen` 函数计算字符串长度，并将浮点数转换为整数，将结果存储在静态数组中，并返回该数组指针。

接着，我们定义了一个名为 `test` 的函数，该函数的参数为一个函数指针，指向一个 `fun` 类型的函数。在函数中，我们提示用户输入一个字符串和一个浮点数，调用传入的函数指针 `p`，并将结果存储在 `result` 变量中。最后，我们输出字符串长度和浮点数转换为整数的结果。

在 `main` 函数中，我们定义了一个 `fun` 函数类型的指针 `fun_ptr`，并将其指向 `fun` 函数。然后，我们调用 `test` 函数，传入 `fun_ptr` 作为参数。接着，我们定义了一个长度为 5 的 `fun` 函数类型的指针数组 `fun_ptr_array`，并将其第一个元素指向 `fun` 函数。最后，我们输出 `fun_ptr_array[0]` 函数的结果。

需要注意的是，在实际应用中，可以将 `fun` 函数类型的指针定义为一个更具有实际意义的类型，例如函数指针类型 `typedef int* (*FunPtr)(char*, float)`，这样可以提高代码的可读性。

写结果。 class A { public: virtual void Print()=0；}； class A1:public A { public: void Print() { cout<<"A1P"; } }; class B1:public A { public: void Print() { cout<<"B1P"; } }; void fun(A*p) { p->Print()； } int main() { A *ptr; A1 a1; B1 b1; ptr=&a1； fun(ptr); ptr=&b1； fun(ptr); return 0； }

程序的输出结果为：

A1P B1P

程序中定义了一个抽象基类 A 和两个派生类 A1 和 B1。A 类中有一个纯虚函数 Print，A1 和 B1 类分别重载了该函数并输出不同的字符串。

在 main 函数中，定义了一个指向 A 类的指针 ptr，并分别用 a1 和 b1 对象初始化它。首先将 ptr 指向 a1，然后通过函数 fun 调用 ptr 所指向对象的 Print 函数，输出 A1P。

接着将 ptr 指向 b1，再次通过函数 fun 调用 ptr 所指向对象的 Print 函数，输出 B1P。

因为 A 类中的 Print 函数是纯虚函数，所以 A 类是一个抽象基类，不能实例化对象。因此在定义指向 A 类对象的指针时，需要用到其派生类的对象来初始化指针。