[SOLUCIONADO] Punteros a plantillas de funciones...¿posible?

[dehm]

Bueno, sigo con otro capítulo de mi culebrón:

Cap 1
Cap 2

Una vez aprendido a manejarme con punteros a funciones, punteros a métodos de clase y punteros a métodos de instancias, sigo sin tener claro cómo hacer uso de ellos de forma flexible y conseguir que me sirvan para varias cosas diferentes.

Me explico:

parto de esté método de una clase que representa a un grafo:

Código C++:

template <typename datonodo_t, typename datoarista_t>
void Grafo<datonodo_t,datoarista_t>::recorrerHijos(pNodo& padre, void (*pfunc)(pArista& a))
{
    if (padre->adyacente!=0)
        {
            pArista A=padre->adyacente;
             while (A->siguiente!=0)
                {
                    pfunc(A);
                    A=A->siguiente;
                }
            pfunc(A);
        }
}
 

Haciendo uso de una función miembro estática

Código C++:

static void imprimir(arista<datoarista,datonodo>*& a)
{
     cout<<a->dato;
}
 

La puedo invocar desde otro método de la misma clase

Código C++:

void Manejador::MostrarHijos()
{
   G.recorrerHijos(padre, imprimir);
 }
 

Pero a este sistema le veo una limitación (aparte de mi ) y es que estoy obligado a crear todas las funciones con la firma:

Código C++:

(void)(pfunc*)(arista<datoarista,datonodo>*& a)
 

Supongamos que ahora quiero usar la misma función que recorre los hijos directos de un nodo, pero para comparar sus valores.....pues ya no me sirve esa forma, o al menos no encuentro la manera de hacerlo.

Entonces se me ocurre que tal vez, si la firma de la función fuera una plantilla, algo como:

Código C++:

template <typename T, typename D>
(T)(pfunc*)(D)
 

me podría ofrecer algo más de flexibilidad a la hora de su uso.
Pero no se me ocurre cómo implementarlo.

Por otro lado, he leído algo sobre functores, pero igualmente no sé como podría implementarlo en mi caso.

En fin, que como siempre, cualquier ayuda será agradecida

[dehm]

Bueno, pues al menos poder, parece que se puede....pero no sé cómo aplicarlo en mi caso.

Código C++:

#include <iostream>
using namespace std;
 
template <typename T>
T maximo (T a, T b)
{
    if (a>b)
    {
        return a;
    }
    return b;
}
 
template <typename TT>
struct functor
{
    TT _a;
    TT _b;
    functor (TT a=0, TT b=0): _a(a),_b(b){}
    TT operator()()
    {
        if (_a>_b)
        {
            return _a;
        }
        return _b;
    }
};
 
int main()
{
 
    int(*maxint)(int a,int b)=&maximo;
    float(*maxfloat)(float a, float b)=&maximo;
 
    cout<<maxint(800,80)<<endl;
    cout<<maxfloat (6.75,6.755)<<endl;
 
    functor<int>i(4,5);
    cout<<i()<<endl;
 
    functor<float>f(4.5,3.2);
    cout<<f()<<endl;
 
    return 0;
}
 

A ver si alguien me echa una mano...

[L3m0n]

Buenas, supongo que con C++ habrá alguna manera mejor de hacer lo que voy a decir, sino será cuestión de investigar. Yo te voy a decir lo que haría yo en C:

La cosa es poner todos tus punteros a funciones en una union. Imagina que tienes dos funciones muy tontas: suma y doble. Pues harías algo así:

Código C:

typedef union
{
    int (*suma)(int a, int b);
    int (*doble)(int a);
}funciones;
 

Ahora, creas una union en el main o en la funcion que estés y le asignas la funcion que vayas a usar:

Código C:

funciones func;
 
if("quieres sumar")
    func.suma = suma; //supon que tienes la funcion suma ya hecha
else if("quieres usar el doble")
    func.doble = doble;
 

Y ahora tienes que definir la funcion a la que mandas esto para que reciba una union:

Código C:

int funcion(funciones f);
 

O directamente puedes hacer la funcion para que segun una condicion que tu pases haga una cosa o otra:

Código C:

enum {SUMA = 1, DOBLE = 2};
 
int funcion(funciones f, int condicion)
{
     if(condicion == SUMA)
           f.suma = suma;
     else if(condicion == DOBLE)
           f.doble = doble;
 
     // Y ahora llamas a la funcion:
     return f.suma(2,3);
}
 

Para finalizar te dire que hay una cosa bastante divertida a la que se le puede sacar bastante utilidad y es que aunque tu llames a la funcion f.suma, en realidad siempre se usara la ultima funcion que hayas asignado, así que si yo pongo f.suma pero la ultima que he asingnado ha sido doble, me usara la funcion doble.

Y hay una cosa aún mas "divertida", y es que aunque llames a la funcion

Código C:

f.suma(2,3);
 

Si tu lo ultimo que has definido ha sido doble, hara doble y lo bueno es que sin ningun problema, simplemente usara el primer argumento y del otro se olvidará, sin dar ningún problema.


Espero haber ayudado, aunque no sea C++, siempre sirve de algo xD

[CalgaryCorpus]

La explicacion parece un trabalenguas:

El desvío usando functors permite pasar 1 o mas argumentos a una funcion, pero esto en realidad no se hace al invocar la funcion, sino que se pasan al crear el objeto functor. Si este objeto provee del operador () las funciones que reciben y usan el functor la llaman para obtener el resultado.
En resumen lo que se hace es desplazar la responsabilidad de QUE HACER en el functor, dejando la responsabilidad de CUANDO HACERLO en la funcion que lo recibe.

Mirar, en el ejemplo, la funcion imprimeResultado(), recibe un tipo generico, se usa con 2 functors distintos

Los functors

Código C++:

#include <iostream>
using namespace std;
 
template <typename T>
class FMenor {
   T _a;
   T _b;
public:
   FMenor ( const T& a, const T& b ) : _a(a), _b(b) {}
   T operator()() {
     if( _a < _b ) { return _a; }
     return _b;
   }
};
 
template <typename T>
class Fagrega1 {
   T _a;
public:
   Fagrega1 ( const T& a ) : _a(a) {}
   T operator()() {
     return _a+1;
   }
};
 

La funcion

Código C++:

template <typename T>
void imprimeResultado( T f ) {
  cout << f() << endl;
}
 

El uso

Código C++:

int main()
{
   Fagrega1<int> fa(2);
   FMenor<int> fm( 30, 4 );
 
   imprimeResultado( fa );
   imprimeResultado( fm );
 
   return 0;
}
 

Mirar funcionando aqui: http://goo.gl/qqkXPt

[dehm]

Gracias L3m0n por la interesante respuesta. La verdad es que a veces me parece que las uniones son las grandes desaprovechadas...están ahí y se usan poco. Me ha gustado mucho el enfoque que le has dado para guardar la lista de funciones a usar.

Pero al final he usado el "invento" de los functores.
La verdad es que me proporciona la ventaja del polimorfismo de C++.
Así, por ahora (y espero que me dure) lo he he hecho de ésta forma:

Código C++:

template <typename datonodo_t, typename datoarista_t>
void Grafo<datonodo_t,datoarista_t>::recorrerHijos(const pNodo& padre, Tratar& tratamiento)
{
    if (padre->adyacente!=0)
        {
            pArista A=padre->adyacente;
             while (A->siguiente!=0)
                {
                    tratamiento(A);
                    A=A->siguiente;
                }
            tratamiento(A);
        }
}
 

en lugar del puntero a función le paso un objeto de la clase Tratar

y luego la clase Tratar es abstracta, y voy definiendo "la perrería" que le quiero hacer en cada clase derivada.

Código C++:

struct Tratar;
 

y de ahí derivo:

Código C++:

struct Buscar:public Tratar
 

ó

Código C++:

struct Imprimir:public Tratar
 

Y por supuesto, en las funciones miembro de la clase que maneja al grafo, tengo:

Código C++:

Tratar* tratamiento= new Buscar (nombreNodo, auxiliar);
 

ó

Código C++:

Tratar* tratamiento=new Imprimir (nombreNodo, auxiliar);
 

en cada función miembro.

Bueno, marco el tema como solucionado y me compro una botella de vino chileno para celebrarlo

[dehm]

Hola de nuevo:

Complemento un poco la respuesta por si a alguien le puede venir bien saber cómo ha quedado resuelto mi problema.

Parto de que tengo una clase grafo, que entre otros métodos tiene uno que muestra los hijos de un nodo dado:

Código C++:

class TratarArista;//declaración previa Importante!!
 
 
template <typename datonodo_t, typename datoarista_t>
void Grafo<datonodo_t,datoarista_t>::recorrerHijos(const pNodo& padre, TratarArista& tratamiento)
{
    if (padre->adyacente!=0)
        {
            pArista A=padre->adyacente;
            while (A->siguiente!=0)
                {
                    tratamiento(A);
                    A=A->siguiente;
                }
            tratamiento(A);
        }
}
 

Esta función me puede venir bien para mostrar los nodos de un hijo, o buscar algún valor entre ellos, etc.

Entonces, por sugerencia de CalgaryCorpus, he usado functores.

Los he definido así (algo ha cambiado desde el post anterior):

Pongo el ejemplo de Imprimir

(Todos los functores los he metido en un fichero Functores.h)

Código C++:

struct TratarArista
{
    //miembros:
    string Nombre;
    arista<Medicion,Concepto>*& AA;
 
    //constructor:
    TratarArista(string nombre, arista<Medicion,Concepto>*& aux);
 
    //función miembro:
    virtual void operator()(arista<Medicion,Concepto>* a)=0;
};
 
struct Imprimir:public TratarArista
{
    Imprimir (string nombre, arista<Medicion,Concepto>*& aux);
 
    virtual void operator()(arista<Medicion,Concepto>* a)
    {
        cout<<"│"<<a->destino->datonodo.LeeCodigo()<<"│"<<a->destino->datonodo.LeeUd()<<a->destino->datonodo.LeeResumen()<<"│"<<endl;        
    }
};
 

Ahora sólo me queda llamarlos dentro de la clase que contiene al grafo.
Por ejemplo:

Código C++:

void Contenedor::MostrarHijos()
{
    string nombreNodo="";
    TratarArista* tratamiento=new Imprimir (nombreNodo, auxiliar);    
    G.recorrerHijos(padre, *tratamiento);
}
 

(En este caso no me interesa el valor del string, por eso entro con una cadena vacía. Hay otros casos en los que quiero buscar el Codigo de un nodo, y entonces sí me interesa entrar con el string teniendo ese valor, y lo que hará la función entonces es comparar y en caso de encontrar el código asignar la arista a auxiliar, que es una arista que tiene la clase contenedora y que sirve para estos temas auxiliares)

En otro momento puedo necesitar imprimir los nodos, pero no los hijos directos de un nodo, sino toda la rama que sale de un nodo (aclaro que el objetivo es tener un grafo acíclico, cuyo desarrollo desde cualquier nodo es un árbol...no sé si lo he dicho bien):

Código C++:

template <typename datonodo_t, typename datoarista_t>
void Grafo<datonodo_t,datoarista_t>::recorrerGrafo(pNodo& inicio, TratarArista& tratamiento)
{
    pArista A;
    if (inicio)
        {
            guardaAristas (inicio);//meto las aristas en la pila
            while (!pila.empty())
                {
                    A=pila.top();
                    pila.pop();
                    tratamiento(A);
                    recorrerGrafo(A->destino,tratamiento);
                }
        }
}
 

Sólo he de añadir al método que recorre el grafo de ésta forma otro objeto de la clase TratarArista, y en caso de querer imprimir actúo como en el caso anterior:

Código C++:

void Contenedor::VerArbol()
{
    auxiliar=padre->adyacente;
    TratarArista* tratamiento=new Imprimir ("", auxiliar);
    G.recorrerGrafo(padre, *tratamiento);
}
 

Bueno, me explico regular, pero dicho queda