vererbungsfrage

[Azrael* il Meraz]

man hat 2 Klassen, sagen wir mal, A un B

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?

[queer_boy]

dein design:
A enthält ein B, das ein A enthält, das ein B enthält, das ein A enthält, das ein ...

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.

[Azrael* il Meraz]

Ich muss das so nicht aufbauen, es ist rein thoeretisches Interesse .

Wird sowas überhaupt genutzt? Ist es schlechter Stil?

[pizza tonno]

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.

[XaTrIxX]

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

[deha]

Man löst sowas mit einem Zeiger. Von dem kann der Compiler immer die Größe bestimmen. Das Problem, dass der Typ bekannt sein muss, löst man mit einer Vorwärtsdeklaration:

//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]

XaTrIxX schrieb:

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.