¿Puedo declarar una función que puede tomar el puntero a sí mismo como argumento?

Question

Al leer una pregunta en stackoverflow, me pregunté si es posible declarar una función que toma un puntero a sí mismo. Es decir. para hacer tal declaración de foo, para los cuales los siguientes sería correcta:

foo(foo); 

La idea más simple es emitir a otro puntero de función (no pueden transmitir contenido a void*, ya que puede ser más pequeño), por lo que la declaración de la función se parece a esto:

void foo(void (*)()); 

Mientras eso está bien en C (y trabajará con el bastidor en C++), me pregunto, si puede hacerse sin dicha información "reinterpretar" casting o perder tipo duro.

En otras palabras, quiero que la siguiente declaración:

void foo(void (*)(void (*)(void (*) (...)))); 

pero, por supuesto, las declaraciones son ilimitadas imposible. Naive typedef ing tampoco ayuda.

Las plantillas de C++ son bienvenidas, incluso si hacen que el código de llamada (foo(foo)) parezca un poco menos conciso, pero igual finito.

Las respuestas de tipo C que muestran cómo se puede soltar información de tipo sin transmitir, u otros trucos de ese tipo son, por supuesto, interesantes, pero no serán aceptados.

Answer 1

En general, estoy de acuerdo con Darío - hacer esto en el tipo de nivel parece imposible.

Pero puede utilizar clases ("patrón de estrategia"):

class A { 
    void evil(A a) {  // a pointer to A is ok too 
    } 
}; 

Usted puede incluso agregar operador():

void operator()(A a) { return evil(a); } 

Generalmente este tipo de cosas se hacen mejor en los idiomas de PF. versión Haskell es simplemente:

data Evil = Evil (Evil -> Integer) 

Este utiliza un envoltorio (Evil) que corresponde a la utilización de una clase.

Del interrogador: lo que le faltaba a esta respuesta era la capacidad de pasar varias funciones diferentes como argumento de una de ellas. Esto puede resolverse haciendo evil() virtual o almacenando explícitamente en el objeto un puntero de función que lo implementa (que es básicamente el mismo).

Con esta aclaración, la respuesta es lo suficientemente buena para ser aceptada.

Answer 2

Aparentemente no - vea this thread. El tipo requerido aquí siempre sería infinito.

Answer 3

Este es un uso perfectamente válido de void *.

typedef void T(void *); 

void f(T *probably_me) 
{ 
    (*probably_me)(f); 
} 

Answer 4

Si una función podría tomarse como argumento, entonces podría realizar una recursión anónima llamándose a sí misma. Pero la recursión es imposible en el cálculo lambda simplemente tipado (que es básicamente lo que tienes aquí, con tipos de funciones).Debe implementar un combinador de punto fijo utilizando funciones recursivas o tipos recursivos para realizar recursiones anónimas.

Answer 5

Un problema relacionado es devolver un puntero de función del mismo tipo. Aparece al implementar máquinas de estado, por lo que obtuvo su propio entry in the C FAQ.

Se pueden aplicar las mismas soluciones a su problema.

Answer 6

No creo que pueda tener una función que pueda tomarse como argumento en C++ sin algún tipo de engaño, como poner su función en una clase, y hacer que la función tome esa clase como argumento.

Otra forma en que será posible una vez que los nuevos estándares de C++ coincidan es usar lambdas, y hacer que la captura lambda misma. Creo que sería más o menos así:

auto recursive_lambda = [&recursive_lambda] { recursive_lambda(); }; 

ser advertidos de que tal declaración es totalmente no probado en cualquier compilador que apoya lambdas. Su experiencia puede ser diferente.

Answer 7

SÍ

Es una variante de "Can you write a function that returns a pointer to itself?", excepto que, en su caso, el tipo de función recursiva aparece como un argumkent, no como el tipo de retorno. Sin embargo, la respuesta de Herb Sutters es reutilizable: ajusta el puntero en una clase proxy declarada hacia delante.

Answer 8

Otro truco sucio.

void Foo(...) 
{ 
} 

int main() 
{ 
Foo(Foo); 
} 

El programa anterior se compilará sin ningún error. Pero no es recursivo. La siguiente función modificada es la versión recursiva con un limitador.

#define RECURSIVE_DEPTH (5) 

typedef void (*FooType)(int, ...); 

void Foo(int Depth, ...) 
{ 
void (*This)(int, ...); 

va_list Arguments; 

va_start(Arguments, Depth); 

if(Depth) 
{ 
    This = va_arg(Arguments, FooType); 

    This(Depth - 1, This); 
} 

va_end (Arguments); 
} 

int main() 
{ 
Foo(RECURSIVE_DEPTH, Foo); 
}