tipos - Sintaxis C para funciones que devuelven indicadores de funciones

tipos de funciones en lenguaje c

Question

Considere los siguientes typedefs:

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

f2 es una función que devuelve un puntero a la función. Lo mismo con f3 , pero el tipo de la función, el puntero al que regresa 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

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

Así es como se vería f2 :

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

Puedes hacer f3 como ejercicio, ya que supongo que es tarea;)

Answer 2

Aprende la regla de derecha a izquierda :

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

Answer 3

Comience con su declaración para f1 :

int (*f1)(float);

Usted quiere que f2 sea ​​un puntero a una función que devuelve f1 , entonces sustituya f1 en la declaración anterior con la declaración para f2 :

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

La declaración dice 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

Repite el proceso para f3 :

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

que dice como

          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 4

En C ++, el milagro de las plantillas puede hacer esto 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 5

Simplemente no lo hagas 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 toma argumentos y devuelve un puntero a la función int (*)(float) probablemente sería algo así como (no probado):

int (*f())(float);

Luego, para el resto, solo necesita seguir agregando paréntesis hasta que parezca lisp.

Answer 6

Use 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;