geht nicht, wie kann ich denn sowas machen?

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.

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.

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.

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.

......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.