¿Cómo hacer que una función devuelva un puntero a una función? (C++)

Question

Estoy tratando de hacer una función que toma un carácter, luego devuelve un puntero a una función dependiendo de lo que el personaje era. Simplemente no estoy seguro de cómo hacer que una función devuelva un puntero a una función.

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

Este es el código para mostrar el retorno de un puntero a la función. Es necesario definir la "firma de la función" para volver primero:

int returnsOne() { 
    return 1; 
} 

typedef int(*fp)(); 

fp returnsFPtoReturnsOne() { 
    &returnsOne; 
} 

En su caso específico:

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

Answer 3

Crear un typedef para la firma de la función:

typedef void (* FuncSig)(int param); 

Entonces declaran su funcionar como FuncSig de retorno:

FuncSig GetFunction(); 

Answer 4

Estoy asumiendo C (aquí no hay objetos) :):

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

forma más fácil es el tipo typedef-puntero a la función que desee y, a continuación, utilizar ese

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

Answer 7

Prefiero devolver objetos y llamar al operador(). De esta forma, su función puede devolver una interfaz y todas las clases pueden heredar de esto. Es decir, si usa C++ y no C.

Luego puede usar el método del factor parametrizado para devolver los objetos según su entrada.

Answer 8

Algo como esto

#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, en serio, utilizar un typedef :)

Answer 10

Salida este sitio - http://cdecl.org

le ayuda a convertir Inglés de declaraciones de C y de vuelta!

Cool Stuff!

Este enlace decodifica el ejemplo en la respuesta de erikallen. int (*return_f())(char)

Answer 11

Aquí es cómo hacerlo sin necesidad de utilizar un typedef:

int c(){ return 0; } 

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

Answer 12

Sintaxis para el retorno de la función:

return_type_of_returning_function (*function_name_which_returns_function)(actual_function_parameters) (returning_function_parameters) 

Ej: en cuenta la función que tienen que ser devueltos como sigue,

void* (iNeedToBeReturend)(double iNeedToBeReturend_par) 
{ 
} 

Ahora la función iNeedToBeReturend puede ser devuelto como

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

me sentí muy mal para aprender este concepto después de 3 años de vida profesional de programación.

Bonificación para que espere a que aparezca el puntero de la función de desreferenciación.

C++ Interview questions

Ejemplo para la función que devuelve el puntero de función es dlopen in dynamic library in c++

Answer 13

En C++ 11 puede utilizar arrastra tipos de retorno para simplificar la sintaxis, por ejemplo asumiendo una función:

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

Esto puede ser devuelto de una función (que lleva una doble para demostrar que):

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

El uso de un tipo de retorno de arrastre, esto se convierte en un poco más fácil de leer:

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