klassenvariable vom eigenen typ?

class Abc
{
public:

    Abc test;
}

geht nicht, wie kann ich denn sowas machen?

Th

Und was stellst du dir praktischerweise darunter vor? Eine Klasse kann sich nicht rekursiv definieren.
Du hast stattdessen zwei Möglichkeiten:
1. eine statische Membervariable erstellen:

class Abc
{
public:
    static Abc test;
};

// in der Source-Datei dann noch die Definition
Abc Abc::test;

oder aber einen Zeiger bzw. Referenz auf eine Objekt derselben Klasse:

class Abc
{
public:
    Abc *test_pointer;
    Abc &test_reference;
};

Diese müßtest du dann im Konstruktor der Klasse initialisieren.

ich möchte aber keinen pointer auf ein objekt, sondern ich möchte, dass das objekt bei der übergabe an eine der methoden kopiert und auf der variable gespeichert wird. der hintergrund ist folgender:
das ganze ist eine partikelSpawner klasse, welche dynamisch partikel erstellt, verwaltet und zeichnet. jetzt möchte ich der klasse partikelSpawner übergeben, die dann an den stellen, an denen die partikel "sterben" gezündet werden (wie bei einem feuerwerk). da bringt es nix wenn ich nen pointer speichere, da ja jeder ablaufende partikel eine eigene kopie des partikelSpawner objektes braucht.

mikey

Vielleicht so?

class partikelSpawner
{
    Abc instanz;
    public:
        void PixelStirb(Abc instanz) {
            // Fertige Kopie der Instanz an:
            this->instanz = instanz;
        }
};

// In deiner Klasse dann...
partikelSpawner particle;
void Abc::Anwenden()
{
    particle.PixelStirb(*this);
}

Dadurch, dass du den eigenen Objektzeiger (this) dereferenzierst, und ihn der PixelStirb Methode übergibst, hast du schon eine Kopie der Klasseninstanz. Dann kannst du wie gewünscht damit arbeiten.

Das was du oben mit dem 'test' Objekt deiner Klasse versucht hast, ist im Prinzip schon in this enthalten. Damit kannst du also einen Zeiger auf deine eigene Klasseninstanz liefern. Indem du dann in den Funktionsparametern dementsprechend die Variable per call per value erwartest, und den this-Zeiger dereferenziert darauf loslässt, hast du eine Kopie.

*D*Evil

ich möchte aber keinen pointer auf ein objekt, sondern ich möchte, dass das objekt bei der übergabe an eine der methoden kopiert und auf der variable gespeichert wird. der hintergrund ist folgender:

Hab jetzt nicht alles hier gelesen ... ein Zeiger auf den Heap hält dich doch nicht vom Kopieren ab? Allerdings ist es nicht möglich sowas zu machen:

class foo { foo m_copy; };

... der Compiler kann mit der Foo-Membervariable nicht umgehen, da er nicht das vollständige Objekt kennt.

mikey schrieb:

Vielleicht so?
class partikelSpawner
{
    Abc instanz;
    public:
        void PixelStirb(Abc instanz) {
            // Fertige Kopie der Instanz an:
            this->instanz = instanz;
        }
};

// In deiner Klasse dann...
partikelSpawner particle;
void Abc::Anwenden()
{
    particle.PixelStirb(*this);
}
Dadurch, dass du den eigenen Objektzeiger (this) dereferenzierst, und ihn der PixelStirb Methode übergibst, hast du schon eine Kopie der Klasseninstanz. Dann kannst du wie gewünscht damit arbeiten.

Das was du oben mit dem 'test' Objekt deiner Klasse versucht hast, ist im Prinzip schon in this enthalten. Damit kannst du also einen Zeiger auf deine eigene Klasseninstanz liefern. Indem du dann in den Funktionsparametern dementsprechend die Variable per call per value erwartest, und den this-Zeiger dereferenziert darauf loslässt, hast du eine Kopie.

Das sieht nicht nach dem aus was er gesucht hat.
Er sucht eine Art Matruschka für Klassen.

Simon2

pixartist^2 schrieb:

......die dann an den stellen, an denen die partikel "sterben" gezündet werden ...

oleg_lolek schrieb:

...
Er sucht eine Art Matruschka für Klassen.

Und wann soll da Schluss sein ?

Mir klingt das noch nach einem Designfehler: Ein Verwalter von Partikeln ist kein Partikel.
Da sind also mindestens 2 verschiedene Klassen involviert - klingt für mich nach sowas:

struct Partikel; // forward declaration ist nötig;

struct PartikelVerwalter {
   vector<Partikel*> partikelMenge;
   Partikel* erzeugePartikel();
   void siehMichSterben(Partikel*);
};

class Partikel {
   PartikelVerwalter& verw;
   Partikel(PartikelVerwalter& v) : verw(v) {}
public:
   ~Partikel() { verw.siehMichSterben(this); }
   void PartikelStuff();
};

Partikel* PartikelVerwalter::erzeugePartikel() { 
      Partikel* p = new Partikel(*this);
      partikelMenge.push_back(p);
      return p;
}

void PartikelVerwalter::siehMichSterbn(Partikel* p) {
   // jetzt kannst Du irgendetwas machen .. z.B. den Pointer aus partikelMenge entfernen,
   // neue Partikel erzeugen ,...
};

Gruß,

Simon2.

Mir klingt das noch nach einem Designfehler.

Das klingt nicht nur so, das ist mit Sicherheit auch einer.
Weil sowas praktisch nicht machbar ist und vor allem auch keinen Sinn macht.