Hola, gente.

Algo que empezó como una duda técnica ya se convirtió en una duda
existencial.

El problema original era lograr declarar un puntero a función que devuelva
un funtero a función con la misma firma en C (C++ en realidad, pero para
el caso es lo mismo). Es decir, necesitaría algo como una declaración
recursiva.

Si bien no encuentro forma de expresarlo, a nivel de lenguaje no veo
ningún motivo por el cual no pueda realizarse, esto debería simular lo que
busco (pero es HORRIBLE):

------->8------->8------->8------->8------->8-------
#include <stdio.h>

typedef void* (*fp)();

void* f1();
void* f2();

void* f1() { printf("f1()\n"); return (void*) &f2; }
void* f2() { printf("f2()\n"); return (void*) &f1; }

int main()
{
        fp fp1 = (fp) f1();
        fp fp2 = (fp) (*fp1)();
        fp fp3 = (fp) (*fp2)();
        return 0;
}
-------8<-------8<-------8<-------8<-------8<-------

Esto imprime, como es de esperarse:
f1()
f2()
f1()

Y como se imaginarán, la idea atrás de esto, es realizar un "camino" donde
cada función devuelve cual es el próximo paso a tomar.

Entonces, como queda demostrado, el lenguaje es perfectamente capaz de
soportar este tipo de construcciones pero no parece tener una sintaxis
capaz de expresarla.

En C en realidad pueden omitirse los casteos, lo que lo hace un poco más
potable, pero C++ es más quisquilloso en cuanto a esto y lo convierte en
algo prácticamente inusable. Y antes de que alguno salte con que
implementándolo con objetos con el operator() sobrecargado se puede hacer,
les cuento que ya lo sé y que no quiero resolverlo así. De hecho sí quiero
resolverlo así, pero también con funciones, porque el código quiero que
sea genérico y que pueda aceptar ambas construcciones. La idea es que
quien use esto sea algo así:
template < typename Paso >
void ejecutar()
{
        Paso* p = paso_inicial();
        while (p)
        {
                p = (*p)();
        }
}

Y esto me gustaría que funcione tanto con "functors" como con funciones de
a de veritas :), porque la mayor parte de las veces un "functor" va a ser
al pedo.

Esto es así o estoy pasando algo por alto y sí es posible hacerlo? Se
les ocurre alguna forma? Pasa con todos lenguajes tipados estáticamente
que conocen?

-- 
LUCA - Leandro Lucarella - Usando Debian GNU/Linux Sid - GNU Generation
------------------------------------------------------------------------
E-Mail / JID:     [EMAIL PROTECTED]
GPG Fingerprint:  D9E1 4545 0F4B 7928 E82C  375D 4B02 0FE0 B08B 4FB2 
GPG Key:          gpg --keyserver pks.lugmen.org.ar --recv-keys B08B4FB2
------------------------------------------------------------------------
PENE MUTILADO POR PENETRAR UNA ASPIRADORA
        -- Crónica TV
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion

Responder a