Come rendere una funzione restituire un puntatore a una funzione? (C++)

Question

Sto provando a creare una funzione che accetta un carattere, quindi restituisce un puntatore a una funzione in base al carattere. Non sono proprio sicuro di come fare in modo che una funzione restituisca un puntatore a una funzione.

Answer 1

#include <iostream> 
using namespace std; 

int f1() { 
    return 1; 
} 

int f2() { 
    return 2; 
} 

typedef int (*fptr)(); 


fptr f(char c) { 
    if (c == '1') { 
     return f1; 
    } 
    else { 
     return f2; 
    } 
} 

int main() { 
    char c = '1'; 
    fptr fp = f(c); 
    cout << fp() << endl; 
} 

Answer 2

Questo è il codice per mostrare il ritorno di un puntatore a funzione. È necessario definire la "firma funzione" per tornare prima:

int returnsOne() { 
    return 1; 
} 

typedef int(*fp)(); 

fp returnsFPtoReturnsOne() { 
    &returnsOne; 
} 

Nel vostro caso specifico:

fp getFunctionFor(char code) { 
    switch (code) { 
     case 'a': return &functionA; 
     case 'b': return &functionB; 
    } 
    return NULL; 
} 

Answer 3

Creare un typedef per la firma della funzione:

typedef void (* FuncSig)(int param); 

quindi dichiarare la vostra funziona come restituire FuncSig:

FuncSig GetFunction(); 

Answer 4

Sto assumendo C qui (nessun oggetto) :):

// Type of function which takes a char and returns an int: 
typedef int (*Func)(char a); 

// An example of the function you're trying to return and which does something 
// with char: 
int exampleFunc(char a) 
{ 
    return (int)(a + 42); 
} 

// The function returning the pointer to a function: 
Func *returnAfunc(void) 
{ 
    return exampleFunc; 
} 

Answer 5

typedef void (*voidFn)(); 

void foo() 
{ 
} 

voidFn goo(char c) 
{ 
    if (c == 'f') { 
     return foo; 
    } 
    else { 
     //.. 
    } 
    // .. 
} 

Answer 6

Il modo più semplice è quello di typedef il tipo di puntatore a funzione che si desidera, e quindi utilizzare tale

typedef void (*fnptr_t)(int, int); 
fptr_t myfunc(char *) { .... 

Answer 7

Preferisco restituire oggetti e chiamare l'operatore(). In questo modo la tua funzione può restituire un'interfaccia e tutte le classi possono ereditarlo. Cioè, se stai usando C++ e non C.

Quindi puoi utilizzare il metodo del fattore parametrico per restituire gli oggetti in base al tuo input.

Answer 8

Qualcosa di simile

#include <iostream> 

typedef char (*fn_ptr_t)(char); 

char a_fn(char c) 
{ 
    return c + 1; 
} 

char b_fn(char c) 
{ 
    return c + 2; 
} 

fn_ptr_t 
return_function(char c) 
{ 
    fn_ptr_t result = 0; 

    switch (c) 
{ 
    case 'a': 
     result = a_fn; 
     break; 
    case 'b': 
     result = b_fn; 
     break; 
} 

return result; 
} 

int 
main() 
{ 
    fn_ptr_t fn = return_function('a'); 

    std::cout << "a(l) = " << (fn)('l') << std::endl; 

    return 0; 
} 

Answer 9

int f(char) { 
    return 0; 
} 

int (*return_f())(char) { 
    return f; 
} 

No, sul serio, utilizzare un typedef :)

Answer 10

Dai un'occhiata a questo sito - http://cdecl.org

consente di convertire inglese alle dichiarazioni C e ritorno!

Cool Stuff!

Questo collegamento decodifica l'esempio nella risposta di erikallen. int (*return_f())(char)

Answer 11

Ecco come farlo senza utilizzare un typedef:

int c(){ return 0; } 

int (* foo (void))(){ //compiles 
return c; 
} 

Answer 12

sintassi per la restituzione della funzione:

return_type_of_returning_function (*function_name_which_returns_function)(actual_function_parameters) (returning_function_parameters) 

Esempio: Si consideri la funzione che devono essere restituiti come segue,

void* (iNeedToBeReturend)(double iNeedToBeReturend_par) 
{ 
} 

Ora la funzione iNeedToBeReturend può essere restituito come

void* (*iAmGoingToReturn(int iAmGoingToReturn_par))(double) 
{ 
    return iNeedToBeReturend; 
} 

mi sono sentito molto male per imparare questo concetto dopo 3 anni di vita programmazione professionale.

Bonus per l'attesa per il puntatore della funzione di dereferenziamento.

C++ Interview questions

Esempio di funzione che restituisce il puntatore funzione è dlopen in dynamic library in c++

Answer 13

In C++ 11 è possibile utilizzare tipi di trascinamento ritorno per semplificare la sintassi, ad esempio assumendo una funzione:

int c(int d) { return d * 2; } 

Questo può essere restituito da una funzione (che prende un doppio a mostrare che):

int (*foo(double e))(int) 
{ 
    e; 
    return c; 
} 

Usando un tipo di ritorno finale, questo diventa un po 'più facile da leggere:

auto foo2(double e) -> int(*)(int) 
{ 
    e; 
    return c; 
}