C sintaxis para funciones que devuelven punteros de función

Question

Tenga en cuenta las siguientes typedefs:

typedef int (*f1)(float); 
typedef f1 (*f2)(double); 
typedef f2 (*f3)(int); 

f2 es una función que devuelve un puntero a función. Lo mismo con f3, pero el tipo de función, el puntero al que devuelve f3, es f2. ¿Cómo puedo definir f3 sin los typedefs? Sé que los typedefs son la manera más limpia y fácil de entender para definir f3. Sin embargo, mi intención aquí es comprender mejor la sintaxis C.

Answer 1

de inicio con su declaración de f1:

int (*f1)(float); 

¿Quieres f2 ser un puntero a una función que devuelve f1, por lo que sustituir f1 en la declaración anterior con la declaración de f2:

int (*  f1 )(float); 
      | 
     +-----+-----+ 
     |   | 
     v   v 
int (*(*f2)(double))(float); 

La declaración se lee como

 f2     -- f2 
     *f2     -- is a pointer 
     (*f2)( )   -- to a function 
     (*f2)(double)   -- taking a double parameter 
    *(*f2)(double)   -- returning a pointer 
    (*(*f2)(double))( ) -- to a function 
    (*(*f2)(double))(float) --  taking a float parameter 
int (*(*f2)(double))(float) --  returning int 

se repite el proceso para f3:

int (*(* f2 )(double))(float); 
      | 
     +---+----+ 
     |  | 
     v  v 
int (*(*(*f3)(int))(double))(float); 

que dice lo

  f3       -- f3 
     *f3       -- is a pointer 
     (*f3)( )      -- to a function 
     (*f3)(int)      -- taking an int parameter 
     *(*f3)(int)      -- returning a pointer 
     (*(*f3)(int))( )   -- to a function 
     (*(*f3)(int))(double)   --  taking a double parameter 
    *(*(*f3)(int))(double)   --  returning a pointer 
    (*(*(*f3)(int))(double))( ) --  to a function 
    (*(*(*f3)(int))(double))(float) --  taking a float parameter 
int (*(*(*f3)(int))(double))(float); --  returning int 

Answer 2

Al igual que con typedef, solo coloca la definición de su función en lugar de su nombre.

Así es como f2 se vería así:

typedef int (*(*f2)(double))(float); 

Usted puede hacer f3 como un ejercicio, ya que estoy asumiendo que esto es tarea;)

Answer 3

En C++, el milagro de las plantillas puede hacer esta un poco más fácil.

#include <type_traits> 

std::add_pointer< 
    std::add_pointer< 
     std::add_pointer< 
      int(float) 
     >::type(double) 
    >::type(int) 
>::type wow; 

Answer 4

Just do not no. Se puede hacer, pero será muy confuso. Los Typedef están ahí para facilitar la escritura y la lectura de este código corto.

Una función f que no tiene argumentos y devuelve un puntero a función int (*)(float) probablemente sería algo así (no probado):

int (*f())(float); 

A continuación, el resto sólo tiene que seguir añadiendo entre paréntesis hasta que quede como Lisp.

Answer 5

Uso std::function:

typedef std::function<int(float)> f1; 
typedef std::function<f1(double)> f2; 
typedef std::function<f2(int)> f3; 

o

typedef std::function<std::function<std::function<int(float)>(double)>(int)> f3; 

Answer 6

aprender el the right-left rule:

La regla de "derecha-izquierda" es una regla totalmente regular para descifrar C declaraciones. También puede ser útil para crearlos.