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.

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.

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();
 
}