a ver si te gusta:
----------------------------------------------------------------
struct lalala{
struct lalala (*fp)();
};
typedef struct lalala funct;
typedef funct (*fp)();
funct f1();
funct f2();
funct f1() { funct f; printf("f1()\n"); f.fp = f2; return f; }
funct f2() { funct f; printf("f2()\n"); f.fp = f1; return f; }
int main()
{
funct fp1 = f1();
funct fp2 = (*fp1.fp)();
funct fp3 = (*fp2.fp)();
return 0;
}
----------------------------------------------------------------
On 8/21/07, Leandro Lucarella <[EMAIL PROTECTED]> wrote:
> 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
>
>
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion
