Beide sind in eigenen Headern deklariert

nun soll Klasse A eine memberInstanz der Klasse B besitzen und B soll eine memberInstanz der Klasse A besitzen

also etwa sowas:

A.h:

#include "B.h"

class A
{
private:
    B b;
}

B.h:

#include "A.h"

class B
{
private:
    A a;
}

das geht natürlich nicht. Ich hab das mithilfe eines templates realisiert:
A.h

template<typename bType>
class A
{
private:
    bType b;
}

B.h:

#include "A.h"

class B
{
private:
    A a;
}

und dann wenn man die A Klasse instanziert, B als typename verwenden. Gibts eine bessere lösung? oder wird das so gemacht?

siehst du das problem?

reicht es nicht bspw., in einer der beiden klassen eine referenz (referenz, zeiger, whatever) auf eine instanz der anderen zu halten?

erläutere mal, warum du die klassen überhaupt so aufbauen willst/musst, dann kann dir wahrscheinlich besser geholfen werden.

Wird sowas überhaupt genutzt? Ist es schlechter Stil?

Sowas geht nicht. Damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist.

Achso geht das, das hab ich nie verstanden...also muss der Compiler das die 10 mal durchlaufen... Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist. Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist. Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist. Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist.

Und dann funktioniert die Vererbung...nicht schlecht. Eigentlich nur eine aufarbeitung des Wertes von ganz unten.

thumbs down mann

//A.h
#include "B.h"
class A
{
private:
  B b;
};

//B.h
class A;
class B
{
private:
  A* a;
};

//B.cpp
#include A.h
...

Die Frage, ob das gutes Design ist, ist damit aber noch nicht beantwortet.

pizza tonno schrieb:

Sowas geht nicht. Damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist. Aber, damit der Compiler weiß wie groß A ist, müsste er wissen wie groß B ist, dazu müsste er aber wissen, wie groß A ist.

Achso geht das, das hab ich nie verstanden...also muss der Compiler das die 10 mal durchlaufen... Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist. Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist. Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist. Dann weiß der wie groß A ist, daraus kann er wohl schließen wie groß B ist, woraus er wiederum Schließen kann wie groß A ist.

Und dann funktioniert die Vererbung...nicht schlecht. Eigentlich nur eine aufarbeitung des Wertes von ganz unten.

thumbs down mann

Da fehlt ein ...
Es geht immer so weiter.