Re: [Prog] Declarar puntero a función que dev uelva un puntero a función con la misma firma

[Esteban Ignacio Invernizzi]

Gente: me entusiasma mucho el nivel al que se comparten conocimientos en la
lista. Es todo fruto de aprendizaje en la Facu, o hay una cuota importante
de autodidáctica? Si no es molestia me gustaría saber en qué etapa de la
carrera están quienes discuten este thread, ya que habla bien del nivel de
la Facultad y quisiera saber si es mérito de la Institución o SOLAMENTE de
Uds. mismos. TIA, Esteban

El día 22/08/07, Leandro Lucarella <[EMAIL PROTECTED]> escribió:
>
>
> Hola, gente.
>
> Algo que empezó como una duda tÃ(c)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Ã(c) y que no quiero resolverlo así. De hecho sí
> quiero
> resolverlo así, pero tambiÃ(c)n con funciones, porque el código quiero que
> sea genÃ(c)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.
Programacion@listas.fi.uba.ar
http://listas.fi.uba.ar/mailman/listinfo/programacion