Zeiger auf Objekt an Objekt selbst übergeben?

It0101

hi leute

Meine normale Stuktur ist immer so gebaut, dass es ne Hauptklasse gibt, die wiederum einige Unterklassen kennt, usw. .

class Hauptklasse
{
   public:
   ...

   private: 
       Nebenklasse *nebenklassenobjekte;
};

Dabei wissen die "Nebenklassenobjekte" nichts von der Hauptklasse, sondern erledigen nur Aufgaben für die Hauptklasse.

Nun wäre es in einem Fall sinnvoll, wenn jedes "Nebenklassenobjekt" auch die anderen "Nebenklassenobjekte" kennt. Ich würde praktisch, nachdem ich die Objekte erzeugt habe, mittels einer Funktion einen Zeiger auf die "Nebenklassenobjekte" an jedes "Nebenklassenobjekt" übergeben.

Das würde dann bedeuten, dass jedes Objekt seine eigene Adresse kennt, und sich dann sozusagen "selbst von aussen betrachten kann".

(Ich würde in dem Objekt nichts mit dem eigenen Objekt machen wollen. Nur eben mit den anderen "Nebenklassenobjekten". ).

Gibt das früher oder später Konfikte?

Ist das vom Programmierstil her vertretbar?

gruß Tobi

Wenn du die "Nebenklassenobjekte" nur in deiner Hauptklasse verwendest kannst du doch auf die anderen Member, also die anderen "Nebenklassenobjekte" zugreifen, ohne das die einzelnen "Nebenklassenobjekte" Zeiger auf die anderen "Nebenklassenobjekte" halten.

MfG

It0101

Es ist aber in dem Fall praktischer wenn die Nebenklassenobjekte die Aufgaben selbst erledigen und das nicht von der Hauptklasse machen lassen.

Also die Nebenklasse ist eine Klasse für Knoten. Und bei der Aufgabe geht es um die Verbindung der Knoten untereinander. Das könnte zwar auch von der Hauptklasse erledigt werden, ich hätte es aber gern so dass jeder Knoten seine Verbindungen zu den anderen Knoten selbst erzeugt.

drakon

In etwa so ist auch die sonstige Idee von Bäumen. Die haben auch Zeiger auf das jewelige nächste Element.

It0101

Ja genau. Ich wollte halt nur wissen ob man sowas machen kann. Dass ein Objekt einer Klasse seine eigene Adresse kennt (und die seiner nachbarn)... (was ja normalerweise recht unüblich ist)

drakon

It0101 schrieb:

Ja genau. Ich wollte halt nur wissen ob man sowas machen kann. Dass ein Objekt einer Klasse seine eigene Adresse kennt (und die seiner nachbarn)... (was ja normalerweise recht unüblich ist)

Also die eigene Adresse kennt das Objekt sowieso. - Ob es viel Sinn macht die irgendwo noch zu speichern, ist die andere Frage.
Aber auf irgendwelche Nachbarelemente Zeiger zu speichern ist nicht unüblich (Litotes ).
z.B bei einer Liste, Queue, oder sonst was.

It0101

ok danke dann werd ichs einfach mal machen

Nexus

Kleiner Tipp für die eigene Adresse:

this

It0101

Naja das ist ja nur ne Nebensache. Ein Knoten soll sich nicht mit sich selbst verbinden, sondern vorrangig mit anderen Das mit der eigenen Andresse war nicht so ernst gemeint

Fellhuhn

Also quasi this+1 und this-1 wobei du die Grenzen einhalten musst? Naja... Sauber ist anders.
Kannst die "Nebenklassen" ja in einem Container der Hauptklasse ablegen und eine Referenz auf eben jenen Container an den Konstruktor der Nebenklasse geben oder ähnliches.

It0101

Nee also

this+1

und

this-1

würde mir nie im Traum einfallen Ich mach das schon ordentlich

zwutz

sind die Unterklassen denn vom selben Typ?

wenn es dir um eine Baumstruktur geht, kannst du ja den parent und eine liste mit den child-elementen anlegen.

void Unterklasse1::setParent( AbstrakteOberKlasse* parent )
{
    if ( !parent )
    {
        return;
    }

    this->_parent = parent;
    parent->_childItems.append( this );
}

andernfalls gibst du jeder Unterklasse im Konstruktor einen Pointer zur Oberklasse mit. Ueber den kannst du ja dann in den Unterklassen auf die jeweils anderen Unterklassen zugreifen.

It0101

mhmh das mit dem parent klingt auch gut danke euch für eure Ideen

It0101

Ich hab nun das Problem, dass jede Klasse die andere braucht. Allerdings bekomm ich jetzt die (zu erwartende) Fehlermeldung, dass im Konstruktur der Klasse B (wo der Zeiger auf Objekte der Klasse A übergeben wird) die Klasse A nicht bekannt ist.

Der Compiler braucht zum Kompilieren vom Klasse A die Klasse B und zum Kompilieren der Klasse B braucht er Klasse A - ein Teufelskreis...

Klasse A:

class A
{
    // C-TOR, D-TOR
    ...

private:
    B *objekte_B;

Klasse B:

class B
{
    // C-TOR, D-TOR
    ...

private:
    A *objekte_A;

wie macht man sowas am geschicktesten? (falls das überhaupt irgendwie geht)

bin grad etwas ratlos.

It0101

Um es nochmal genauer zu erklären:

Die Klasse A ist in dem Fall die Knoten-Klasse und die Klasse B die Kanten-Klasse ist.
Logischerweise benötigt somit jeder Knoten Informationen über alle Kanten die von ihm weg gehen. Wenn ich ein Signal von einem Knoten zum anderen übertragen will muss ich es zuerst an die Kante weitergeben, die das Signal wiederum an den Ziel-Knoten weitergibt (wozu sie wieder die Knotenklasse kennen muss).

Ich weiß dass es auch andere Lösungen gibt, aber ich würde es gern so machen, wie beschrieben.

Nexus

Das ist wohl eines der ersten "richtigen" Designprobleme, denen man sich in C++ stellen muss

Falls die eine Klasse nur Zeiger bzw. Referenzen auf die andere besitzt, kannst du eine Vorwärtsdeklaration machen:

class B;       // Vorwärtsdeklaration - Name "B" wird bekanntgemacht

class A
{
   B* ptr;     // A hat Zeiger auf B - geht, weil Zeigergrösse immer gleich
};

class B
{
   A obj;      // B darf Objekte von A haben, weil A schon definiert wurde
};

Klassen, die gegenseitig Objekte voneinander haben, sind nicht möglich, weil jeweils die andere Klasse noch nicht definiert wurde, und der Compiler deshalb die Grösse nicht kennt. Zeiger dagegen brauchen unabhängig vom Zieltyp immer gleich viel Speicherplatz (normalerweise 4 Byte). Aber dieser Fall sollte bei gutem Design sowieso nicht vorkommen.