Foro de elhacker.net

Buenas tardeS

Tengo 2 objetos:
ClaseA
ClaseB

ClaseA tiene una referencia a ClaseB en su cuerpo, pero ClaseB no debe tener referencia a ClaseA

//ClaseA
class ClaseA {
 
private:
    ClaseB* b {nullptr};
 
public:
   void Alpha();
 
};
 
 
//ClaseB
class ClaseB {
public:
    void Beta();
};

Lo que busco hacer es llamar desde ClaseA::Alpha() a ClaseB::Beta(), luego ClaseB::Beta() debe invocar a ClaseA::Alpha() de vuelta.

//ClaseA fuente
void ClaseA::Alpha(){
     //hacer algo
     b->Beta();      //invoco a ClaseB::Beta()
 
}
 
//ClaseB fuente
void ClaseB::Beta(){
     //el hilo proveniente de ClaseA::Alpha pasa por aqui...
     //hacer algo
     //invocar de vuelta a ClaseA::Alpha() desde un principio...
}

Pienso que puedo colocar algun parametro en ClaseB::Beta(), por ejemplo:

ClaseB::Beta(algun tipo o puntero a funcion miembro que apunte a la funcion anterior)

Entonces la invocacion seria:

b->Beta(&ClaseA::Alpha);

...cosa que al terminar Beta, ya sabe que funcion tiene que invocar despues, en este caso ClaseA::Alpha

Como se puede lograr esto?

gracias de antemano.

A voz de pronto se me ocurre que alpha tuviera un flag que pueda activar beta (esto para evitar una recursión infinita). Si ese flag se activa a continuará con su ejecución, sino se repetirá desde el principio. No se C++, pero en C sería algo así:

#include <stdio.h>
#include <stdbool.h>
 
bool beta() {
    static int i=0;
    puts("Ejecuto beta");
    i++;
    return i<5;
}
 
void alpha() {
void alpha() {
    do {
        puts("Ejecuto alpha");
    } while(beta());
    puts("Fin de alpha");
}
    puts("Fin de alpha");
}
 
int main() {
    alpha();
}

Si no quieres usar el do/while puedes usar el goto (si no le tienes manía)

#include <stdio.h>
#include <stdbool.h>
 
bool beta() {
    static int i=0;
    puts("Ejecuto beta");
    i++;
    return i<5;
}
 
void alpha() {
    inicio:
    puts("Ejecuto alpha");
    if(beta())
        goto inicio;
    puts("Fin de alpha");
}
 
int main() {
    alpha();
}

O mediante setjmp/longjmp (no recomendado)

#include <stdio.h>
#include <setjmp.h>
 
jmp_buf buf;
 
void beta() {
    static int i=0;
    puts("Ejecuto beta");
    i++;
    longjmp(buf, i);
}
 
void alpha() {
    if(setjmp(buf)<5) {
        puts("Ejecuto alpha");
        beta();
    }
    puts("Fin de alpha");
}
 
int main() {
    alpha();
}

Esto parece un error en el diseño de tu programa. No sólo por el bucle infinito que provocará, lo cual tiene solución simple (aunque no muy limpia) sino porque ese tipo de interdependencia casi nunca es bueno. Si es curiosidad lo que tienes, sí puedes pasar punteros a funciones miembro, pero teniendo en cuenta algunos detalles.

Las funciones miembro no static, como Alpha(), siempre se ejecutan en el contexto de un objeto concreto (el puntero this, que reciben como parámetro implícito). No puedes simplemente pasar el puntero a la función, sino que necesitas saber sobre qué objeto operar. Hay varias formas de hacerlo. Una simple que podrías probar es algo así:

Declaras Beta de esta manera

void Beta(void (ClaseA::*funcion)(void), ClaseA& o);

La invocas desde Alpha así:

b->Beta(&ClaseA::Alpha, *this);

Y dentro de Beta:

(o.*funcion)();

No es lo más limpio, pero simplifica el código (lo de evitar el bucle infinito te lo dejo. Hay muchas maneras de hacerlo). Aún así, reitero que te recomiendo que rediseñes el programa para no necesitar esto.

Gracias ambos!

El estilo C no deseo emplear mucho ya que este codigo es para continuar mi proyecto en Unreal Engine.. pero gracias de todas formas MAFUS porque me sirve de conocimiento general tu solucion.

RayR, si, efectivamente es un caso especial, estoy trabajando con corutinas, .. en este caso la clase B es una clase global, generalizada que se usa para muchos niveles, pero Clase A es una clase local que solo se utiliza para un nivel, podria haber hecho una interdependencia pero eso seria manchar ClaseB con informacion que no necesitaria mas tarde...

Lo solucione con std::function y std::bind  .. similar a lo que tu planteas.

El caso es que necesito hacerlo asi ya que es parte de una conversacion donde el hilo espera la senal del jugador (un boton) para pasar al siguiente comentario, luego con un parametro bool le digo a ClaseB que ese es el ultimo comentario para que no repita la funcion.


Saludos y gracias nuevamente.

Hola!
Acá puedes usar el concepto de "friends" (https://isocpp.org/wiki/faq/friends)

Una cosa espantosa puede ser algo así...

#include <iostream>
 
//ClaseB
class ClaseB {
    friend class ClaseA;
public:
    void Beta(class ClaseA* a);
};
 
//ClaseA
class ClaseA {
private:
    ClaseB* b;
    bool hecho = false;
    friend class ClaseB; // https://isocpp.org/wiki/faq/friends
 
public:
    ClaseA() : b{ new ClaseB } {}
    ~ClaseA() { delete b; }
    void Alpha();
 
};
 
 
//ClaseA fuente
void ClaseA::Alpha() {
    //hacer algo
    if (hecho)
        return;
    b->Beta(this);      //invoco a ClaseB::Beta()
    std::cout << "Alpha";
    hecho = true;
}
 
//ClaseB fuente
void ClaseB::Beta(class ClaseA* a) {
    //el hilo proveniente de ClaseA::Alpha pasa por aqui...
    //hacer algo
    //invocar de vuelta a ClaseA::Alpha() desde un principio...
 
    if (a->hecho)
        return;
    a->hecho = true;
    std::cout << "Beta";
    a->Alpha();
}
 
// Lo que busco hacer es llamar desde ClaseA::Alpha() a ClaseB::Beta(), luego ClaseB::Beta() debe invocar a ClaseA::Alpha() de vuelta.
 
int main()
{
    ClaseA a;
    a.Alpha();
 
}