Как определить массив указателей функций в C

У меня есть маленький вопрос. Я пытаюсь определить массив указателей функций динамически с помощью calloc . Но я не знаю, как написать синтаксис. Большое спасибо.

    5 Solutions collect form web for “Как определить массив указателей функций в C”

    Тип указателя функции точно так же, как и объявление функции, но с «(*)» вместо имени функции. Итак, указатель на:

     int foo( int ) 

    было бы:

     int (*)( int ) 

    Чтобы назвать экземпляр этого типа, введите имя внутри (*), после звезды, так:

     int (*foo_ptr)( int ) 

    объявляет переменную foo_ptr, которая указывает на функцию этого типа.

    Массивы следуют нормальному синтаксису Си, помещая скобки рядом с идентификатором переменной, поэтому:

     int (*foo_ptr_array[2])( int ) 

    объявляет переменную foo_ptr_array, которая представляет собой массив из 2 указателей на функции.

    Синтаксис может стать довольно грязным, поэтому часто бывает проще сделать typedef для указателя функции, а затем объявить массив из них:

     typedef int (*foo_ptr_t)( int ); foo_ptr_t foo_ptr_array[2]; 

    В любом примере вы можете делать такие вещи, как:

     int f1( int ); int f2( int ); foo_ptr_array[0] = f1; foo_ptr_array[1] = f2; foo_ptr_array[0]( 1 ); 

    Наконец, вы можете динамически выделять массив с любым из:

     int (**a1)( int ) = calloc( 2, sizeof( int (*)( int ) ) ); foo_ptr_t * a2 = calloc( 2, sizeof( foo_ptr_t ) ); 

    Обратите внимание на добавочный * в первой строке, чтобы объявить a1 как указатель на указатель функции.

    Я приведу здесь небольшой пример, который может вам помочь

     typedef void (*fp)(int); //Declares a type of a void function that accepts an int void test(int i) { printf("%d", i); } int _tmain(int argc, _TCHAR* argv[]) { fp function_array[10]; //declares the array function_array[0] = test; //assings a function that implements that signature in the first position function_array[0](10); //call the cuntion passing 10 } 

    Вы объявляете массив указателей функций как

     T (*afp[N])(); 

    для некоторого типа T Поскольку вы динамически выделяете массив, вы бы сделали что-то вроде

     T (**pfp)() = calloc(num_elements, sizeof *pfp); 

    или

     T (**pfp)() = malloc(num_elements * sizeof *pfp); 

    Затем вы вызывали каждую функцию как

     T x = (*pfp[i])(); 

    или

     T x = pfp[i](); // pfp[i] is implicitly dereferenced 

    Если вы хотите быть неортодоксальным, вы можете объявить указатель на массив указателей на функции, а затем выделить следующее:

     T (*(*pafp)[N])() = malloc(sizeof *pafp); 

    хотя при совершении звонка вам придется почитать указатель массива:

     x = (*(*pafp)[i])(); 
     typedef R (*fptr)(A1, A2... An); 

    где R – тип возврата, A1, A2 … An – типы аргументов.

     fptr* arr = calloc(num_of_elements,sizeof(fptr)); 

    Предполагая, что все ваши функции имеют тип void ()(void) , что-то вроде этого

     typedef void (*fxptr)(void); fxptr *ptr; // pointer to function pointer ptr = malloc(100 * sizeof *ptr); if (ptr) { ptr[0] = fx0; ptr[1] = fx1; /* ... */ ptr[99] = fx100; /* use "dynamic array" of function pointers */ free(ptr); } 
    Давайте будем гением компьютера.