C++ : kann eine Klasse ein Object von sich selbst haben?

[Harald (Gast)]

Kann man in C++ eine Klasse erzeugen, die ein Objekt dieser Klasse 
beinhaltet?

Also in etwas so:

class Test
{
  public:
      Test A;

};

[Thomas F. (Gast)]

nein, aber ein (smart) pointer geht.

[Markus F. (mfro)]

Harald schrieb:
> Kann man in C++ eine Klasse erzeugen, die ein Objekt dieser Klasse
> beinhaltet?

Rein interessehalber: wenn das ginge, bei welcher "Rekursionstiefe" 
würdest Du abbrechen wollen?

[jz (Gast)]

Du kannst ein statisches Objekt von der Klasse selbst definieren, also

class Test
{
  public:
      static Test A;
};

[Dr. Sommer (Gast)]

Überleg mal, wie groß eine Instanz davon wäre...

[Ben W. (ben_w)]

wie einer bereits schon schrieb, mit einem pointer auf das objekt geht 
es schon.

class Test
{
  public:
      Test *A;

};

[Yalu X. (yalu) (Moderator)]

Dr. Sommer schrieb:
> Überleg mal, wie groß eine Instanz davon wäre...

... und unterscheide dabei zwei Fälle:

Fall 1: Test ist so deklariert wie oben.
Fall 2: Test enthält neben A noch ein weiteres Element, bspw. ein char.

:)

Und wozu wäre eine solche Klasse gut?

Ben W. schrieb:
> wie einer bereits schon schrieb, mit einem pointer auf das objekt geht
> es schon.

Oder auch eine Referenz. Für beides gibt es auch genügend sinnvolle
Anwendungen.

[Achim H. (anymouse)]

stehe ich hier auf dem Schlauch (komme aus der Java-Welt), oder wäre so 
etwas in C++ wirklich ein Problem?

class TreeNode
{
  public:
      TreeNode leftNode;
      TreeNode rightNode;
};

Oder ist hier folgendes gemeint (in Java-Notation)?

class TreeNode
{
  public:
      class<TreeNode> myClazz;
};

[Chris F. (chfreund)]

Achim H. schrieb:
> stehe ich hier auf dem Schlauch (komme aus der Java-Welt), oder wäre so
> etwas in C++ wirklich ein Problem?

Natürlich nicht. Eine verkettete liste macht man aber mit Zeigern.

Ich gebe Dir mal ein Beispiel:

class elem
{
public:
  elem * pNext;
  elem * pPrev;
  int nData;
};
int _tmain(int argc, _TCHAR* argv[])
{
  elem * pStart = new elem;
  pStart ->pNext = new elem;

  elem * pT = pStart->pNext->pNext = new elem;
  ASSERT(pT->pPrev == pStart->pNext) //schlägt fehl
  return 0;
}

[TriHexagon (Gast)]

Achim H. schrieb:
> stehe ich hier auf dem Schlauch (komme aus der Java-Welt), oder wäre so
> etwas in C++ wirklich ein Problem?
> class TreeNode
> {
>   public:
>       TreeNode leftNode;
>       TreeNode rightNode;
> };

Ja den in Java sind alle Typen abseits von Standardtypen wie int, long 
Referenztypen, Java legt dir damit deine Member auf Objekte von 
Klassentypen als Referenzen an. In C++ gibt es aber nur Wertetypen (im 
Java/C#-Sprech) und legt sozusagen die Objekte in das tragende Objekt 
selbst hinein. Das funktioniert hier natürlich nicht, weil das eine 
unauflösbare Rekursion darstellt, in Java ist es kein Problem da nur 
Referenzen, die ja zudem auch null sein können.

[Chris F. (chfreund)]

Hier noch eine schönere Version, die auch kompiliert.

#include <assert.h>
class elem
{
public:
  elem() : pNext(0), pPrev(0), nData(0){};
  elem * pNext;
  elem * pPrev;
  int nData;
  elem* addNext()
  {
    pNext = new elem;
    pNext->pPrev = this;
    return pNext;
  }
  static void destroy(elem * pE)
  {
    while (pE->pPrev != 0) pE = pE->pPrev; //erstes Element finden
    elem * pN = 0;
    while (pE)
    {
      pN = pE->pNext;
      delete pE; pE = 0;
      pE = pN;
    }
  }
};
int main(int argc, char* argv[])
{
  elem * pStart = new elem;
  pStart->addNext()->addNext()->addNext()->addNext()->addNext();
  elem * pT = pStart->pNext->pNext->pNext;
  assert(pT->pPrev == pStart->pNext->pNext);
  elem::destroy(pT);
  return 0;
}

[Harald (Gast)]

Danke für die Antworten.

Kurz zum Hintergrund meiner Frage:
Jeder kennt ja die Möglichkeit bei z.B. Powerpoint, Ojekte zu 
gruppieren. Diese kann man dann mehrfach kopieren und dann wieder zu 
neuen Objekten gruppieren.
Jetzt suche ich nach einer Art Design-Pattern für C++.
Man müsste quasi eine Klasse "Panel" machen, bei der man graphische 
Objekte wie z.B. Kreise und Dreiecke und eben auch wieder Panels 
hinzufügen könnte:

Panel p1;
Panel.add(dreieck1);
Panel.add(dreieick2);

Panel p2;
p2.add(quadrat1);
p2.add(quadrat2);

p1.add(p2);

[Peter II (Gast)]

Harald schrieb:
> Man müsste quasi eine Klasse "Panel" machen, bei der man graphische
> Objekte wie z.B. Kreise und Dreiecke und eben auch wieder Panels

und wo hast du damit ein Problem? Verwende doch einfach Zeiger 
(SmartPointer) und gut ist. Es ist eh sinnlos Objekte ständig zu 
kopieren.

[Chris F. (chfreund)]

Harald schrieb:
> Man müsste quasi eine Klasse "Panel" machen, bei der man graphische
> Objekte wie z.B. Kreise und Dreiecke und eben auch wieder Panels
> hinzufügen könnte:

Dann lege eine (abstrakte) Basisklasse an, die einen Container für 
Objekte von "sich selbst" enthält.

Die Inhaltstypen erben dann davon und bei den Klassen am Ende vom Baum 
blendest Du den (Zugriff auf den) Container aus.

[Dr. Sommer (Gast)]

Suche vielleicht mal nach "Composite Pattern "

[Harald (Gast)]

>Suche vielleicht mal nach "Composite Pattern "

Guter Tipp, das könnte passen.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Achim H. schrieb:
> stehe ich hier auf dem Schlauch (komme aus der Java-Welt), oder wäre so
> etwas in C++ wirklich ein Problem?

In Java ist jedes Symbol nur ein Zeiger auf ein Objekt. In C++ ist das 
bei gleicher Syntax immer ein Objekt:

Type obj1 = f();
Type obj2 = obj1;

In Java sind obj1 und obj2 zwei Zeiger auf das selbe Objekt. In C++ sind 
obj1 und obj2 zwei unterschiedliche Objekte, die den gleichen Wert haben 
(sollten).

Ähnliches Verhalten erhältst Du in C++ mit Zeiger, Referenzen und 
Smart-Pointern.