ponteiros de função abstratas

Question

Como eu poderia criar uma matriz de ponteiros de função dez? O que tenho é um loop for, e eu quero definir um ponteiro de função para uma função diferente em cada iteração. assim:

//pseudocode
for i (0..10)
    function = array_of_functions[i];
//...

Answer 1

// Define alias for function pointer type for convenience
typedef void (*action)(int);

// Example function
void print(int) { ... }

action fs[10] = { print, ... };
for (int i = 0; i < 10; ++i)
{
    action f = fs[i];

    // Call it somehow
    f(i * i);
}

Answer 2

Este código:

return_t (*array_of_functions[10])(arg1_t, arg2_t);

Declara "array_of_functions" como uma matriz de 10 elementos de ponteiros de função onde cada pontas-de função recebe dois argumentos do tipo arg1_t e arg2_t e retorna tipo return_t. Substituir tipos e ajustar o número de argumentos conforme o caso.

Answer 3

Toda vez que você tem que lidar com a função feio sintaxe ponteiro é melhor usar um typedef.

#include <iostream>

void a(int i)
{
    std::cout<<"a: "<<i<<std::endl;
}

void b(int i)
{
    std::cout<<"b: "<<i<<std::endl;
}

typedef void (*fn)(int);

int main(int argc, char**argv)
{

    fn foo[2];


    foo[0] = a;
    foo[1] = b;


    for(size_t i = 0; i < sizeof(foo) / sizeof(foo[0]); ++i)
    {
        foo[i](i);
    }

    return 0;
}

Answer 4

A maneira mais simples de fazer isso é criar um typedef para sua função, e em seguida, declarar uma matriz com esse tipo. Para criar um typedef para a função: typedef returntype (*typedefname)(argtype1,argtype2,...,argtypeN); EX:

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

typedef void (*functype)();

void func1()
{
 //...
}

void func2()
{
 //..
}

//...


void func10()
{
//...
}

int main(int argc, char* argv[])
{
     functype array[] = 
     { 
         &func1, 
         &func2, 
         &func3, 
         &func4, 
         &func5,
         &func6, 
         &func7, 
         &func8, 
         &func9, 
         &func10
     };

     // Use the array...
     return 0;   
}

Answer 5

T (*array_of_functions[10])();

Onde T é o tipo de retorno de cada função (todas as funções retornar o mesmo tipo, naturalmente). As coisas ficam complicadas se você deseja armazenar ponteiros para funções com diferentes números / tipos de parâmetros:

int foo(void) {...}
int bar(int x) {...}
int bletch(double y, double z) {...}
...
int (*array_of_functions[10])() = {foo, bar, bletch, ...};

Se assim for, você vai ter que acompanhar o que número e tipos de parâmetros de cada função exige alguma forma para que você possa chamá-lo corretamente.

Na verdade eu sou tipo de para baixo em typedefs para tipos de ponteiro de função; eles tendem a obscurecer tanto quanto eles simplificar.