Jak funkcja zwraca wskaźnik do funkcji? (C++)

Question

Próbuję wykonać funkcję, która ma postać, a następnie zwraca wskaźnik do funkcji w zależności od charakteru postaci. Po prostu nie wiem, jak sprawić, aby funkcja zwróciła wskaźnik do funkcji.

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

To jest kod pokazujący powrót wskaźnika funkcji. Trzeba zdefiniować "podpis funkcja", aby powrócić pierwszy:

int returnsOne() { 
    return 1; 
} 

typedef int(*fp)(); 

fp returnsFPtoReturnsOne() { 
    &returnsOne; 
} 

W Twoim konkretnym przypadku:

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

Answer 3

utworzyć typedef dla podpisu funkcję:

typedef void (* FuncSig)(int param); 

Następnie zadeklarować funkcja jako zwrot FuncSig:

FuncSig GetFunction(); 

Answer 4

Jestem zakładając tu C (bez obiektów) :):

// 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

Najprostszym sposobem jest typedef typu wskaźnik do funkcji, którą chcesz, a następnie użyć tego

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

Answer 7

Preferuję zwracane obiekty i dzwonię do operatora(). W ten sposób twoja funkcja może zwrócić interfejs i wszystkie klasy mogą z tego dziedziczyć. Oznacza to, że jeśli używasz C++ i nie C

Następnie można użyć parametryzowane metodę współczynnika zwrotu obiektów opartych na wejściu.

Answer 8

coś takiego

#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; 
} 

Nie, poważnie, używać typedef :)

Answer 10

Sprawdź tę stronę - http://cdecl.org

pozwala konwertować angielski deklaracji C iz powrotem!

Fajne rzeczy!

Ten link dekoduje przykład w odpowiedzi erikallen użytkownika. int (*return_f())(char)

Answer 11

Oto jak to zrobić bez używania typedef:

int c(){ return 0; } 

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

Answer 12

Składnia na powrót funkcji:

return_type_of_returning_function (*function_name_which_returns_function)(actual_function_parameters) (returning_function_parameters) 

np Rozważmy funkcję, które muszą być zwrócone w następujący sposób:

void* (iNeedToBeReturend)(double iNeedToBeReturend_par) 
{ 
} 

Teraz funkcja iNeedToBeReturend mogą być zwracane jako

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

czułem się bardzo źle, aby dowiedzieć się tę koncepcję po 3 latach życia zawodowego programowania.

Premia za czekanie na wskaźnik funkcji dereferencji.

C++ Interview questions

Przykład funkcję, która zwraca wskaźnik funkcji jest dlopen in dynamic library in c++

Answer 13

C++ 11 można użyć spływu typu powrotne uproszczenie składni np zakładając funkcję:

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

To może być zwracana z funkcji (które trwa dwukrotnie, aby pokazać, że):

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

Korzystanie typ zwracanej spływu, to staje się nieco łatwiejsze do odczytania:

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