Question

目前我正在使用函数指针数组。但我需要将它扩展为函数指针数组的数组。伪代码如下：

#include<stdio.h>


int  AnalogValue1( int a)
{
    printf("\nF: AV1 %d", a);
    return 1;
}


int  AnalogValue2( int a)
{
    printf("\nF: AV2 %d", a);
    return 1;
}

int  BinaryValue1( int a)
{
    printf("\nF: BV1 %d", a);
    return 1;
}


int  BinaryValue2( int a)
{
  printf("\nF: BV2 %d", a);
  return 1;
}
int ( *Read_AV_Props[] )(int a)
=
{
 &AnalogValue1,
 &AnalogValue2,
};

int ( *Read_BV_Props[] )(int a) =
{
 &BinaryValue1,
 &BinaryValue2
};

void main()
{
    Read_AV_Props[0](55);   
    //*(Read_Ob_Props[0])(20);

}

这里需要一个函数指针数组，以便它可以获取Read_BV_Props和Read_AV_Props的地址。从主代码我可以调用该函数指针数组的数组。这可能在C？

Answer 1

这是你想要的声明：

int (**myArray[])(int) = {
    Read_AV_Props,
    Read_BV_Props
};

这是指向接收int并返回int的函数的指针的数组。它不是真正的2D数组，因为Read_AV_Props和Read_BV_Props会衰减成指向其第一个元素的指针，即指向函数接收int并返回int的指针。 / p>

你可以像这样使用它：

int a = (**(myArray[i]+j))(1);

或者，由于数组到指针递减规则（在表达式中），您还可以使用：

int a = (*myArray[i][j])(1);

如果你想要一个真正的2D数组，你必须在一个地方初始化它：

int (*myArray[][])(int) = {
    { &binaryValue1, &binaryValue2 },
    { ... }
};

用法类似。

或者你可以创建指向函数接收int的指针数组的指针数组，并返回int：

int (*(*myArray[])[sizeof(Read_AV_Props)/sizeof(*Read_AV_Props)])(int) = {
    &Read_AV_Props,
    &Read_BV_Props
};

但这假定Read_AV_Props和Read_BV_Props具有相同的尺寸。

您可以将其用于：

int a = (*(*myArray[i])[j])(1);

考虑到你的问题，我相信第一个选择是你正在寻找的。

Answer 2

如果您需要2D阵列，那么您可以这样做：

#include <stdio.h>
#include <stdlib.h>

int func1(int a)
{
    return a*2;
}

int func2(int a)
{
    return a*3;
}

typedef int (*FunctionPtrType)(int a);

FunctionPtrType myArray[2][2] =
{
    // func1, func2
 { func1,  func2, },
 { func2,  func1, }
};

int main()
{
    int i;
    printf("func1 = %p\n", func1);
    printf("func2 = %p\n", func2);

    for(i = 0; i < 2; i++)
    {
        printf("%p\n", myArray[0][i]);
        printf("%p\n", myArray[1][i]);
    }

    return 0;
}

C中函数指针数组的数组

2 个答案: