C++ 2 Klassen gegenseitigem Pointer auf Member Funktionen include loop

[holli (Gast)]

Hallo

ich habe eine Klasse in der Datei

parent.h

class Parent
{
public:
    Parent();
    void askChild();
    void doSomething();
    ...
    ...
    private:
    Child* child;
};
...
...

parent.cpp

...
...
void Parent::askChild()
{
    child->getAnswer();    
}

und eine andere Klasse in der Datei child.cpp

child.h

class Child
{
public:
    Child();
    void tellParent();
    void getAnswer();
    ...
    ...
    private:
    Parent* parent;
};
...
...

child.cpp

...
...
void Child::tellParent()
{
    parent->doSomething();    
}

Der Sinn ist, dass jede Parent Klasse eine child Klase beinhalet und 
dort getAnswer() aufrufen kann.
Manchmal macht Child aber auch Sachen die es Parent mitteilen will und 
macht dieses über tellParent()

Wie kann ich das Include Problem denn hier Lösen? Denn auch wenn ich 
eine forward declaration machen
vor der Definition von Parent

Class Child;

und vor der Definition von Child

Class Parent;

einfügen sind zwar die Klassen bekannt, aber ja nicht die Methoden der 
Klassen?

[MikeH (Gast)]

In den Headerdateien machst du jeweils die forward Deklaration und in 
den .cpp Dateien inkludierst du die jeweilige andere Headerdatei.

[holli (Gast)]

Super, Danke, das klappt.

[Dr. Sommer (Gast)]

Und was hat das jetzt mit Pointern auf Member-Funktionen zu tun? Das ist 
doch nur ein ganz normaler direkter Aufruf einer Member-Funktion.

holli schrieb:
> Der Sinn ist, dass jede Parent Klasse eine child Klase beinhalet
Immer genau eine? Warum dann nicht einfach "Child child", warum als 
Pointer? Und wenn schon, warum nicht per unique_ptr<Child> ?

[Tom (Gast)]

Manchmal ist es sinnvoll, die Rollen, die die Beteiligten erfüllen, in 
Interfaces auszulagern. Damit kann man die beiden Klassen unabhängig von 
der Implementation der jeweils anderen gestalten:

class IMuellrausbringer
{
public:
    virtual void bringe_muell_raus() = 0;
};

class ITaschengeldgeber
{
public:
    virtual int gib_geld() = 0;
};

class Child : public IMuellrausbringer
{
public:
    void bringe_muell_raus() override { cout << "ist erledigt\n"; }
    void tuwas() { int euros = m_versorger->gib_geld(); }
private:
    ITaschengeldgeber* m_versorger;
};

class Parent: public ITaschengeldgeber
{
public:
    int gib_geld() override { return 10; }
    void fruehjahrsputz() { m_helfer->bringe_muell_raus(); }
private:    
    IMuellrausbringer* m_helfer;
};

In einfachen Fällen erzeugt das nur überflüssige Komplexität, aber wenn 
es kompliziert wird, kann es die Struktur klarer machen.