habe folgendes Problem:

class X
{

}

class Y : public X
{
}

class Z : public X
{
}

in einer anderen Klasse habe ich einen stack

static std::stack<X*> myStack;

In diesen stack will ich nur Y und Z Objekte schreiben. Wenn ich aber folgendes mache:

Y myY;
...
myStack.push(myY);

dann werden nur die Eigenschaften von der Superklasse X übernommen. Was mache ich falsch?

danke!
mfg,
shed

Im Ernst, das was du machen willst erreicht man in C++ über virtuelle Funktionen.

MfG mikey.

Verstehe aber trotzdem nicht ganz wie ich das über virtuelle Funktionen lösen kann.
Bitte um einen kleinen Denkanstoß

Danke!
mfg,
shed

class Base
{
  public:
    int attrBase;
}

class Derived1 : public Base
{
  public:
   int attrDerived1;
}

class Derived2 : public Base
{
  public:
   int attrDerived2;
} 

int main()
{
  static std::stack<Base*> myStack; 
  Derived1 myDerived1;
  myStack.push(myDerived1);
}

Mein Problem ist also, dass wenn ich eine Subklasse in den Stack schreibe dann habe ich nur das Attribute 'attrBase' nicht aber "attrDerived1". Dies kann ich ja durch virtual nicht lösen oder?

Danke!

Base* p = s.top ();
s.pop ();
p->Booyakah ();

p zeigt doch auf das oberste element aus s oder?
bei s.top(), wird da nicht auch p ungültig?

@sadsadsadsa (sehr einfallsreicher Name :D):
s.pop() entfernt nur das oberste Element (der Zeiger) aus dem Stack - die Daten hinter dem Zeiger werden dabei nicht angefasst. Das Objekt selbst überlebt so lange, bis du es per delete vernichtest.

...
In diesen stack will ich nur Y und Z Objekte schreiben...

Warum ?
Ich bin immer sehr skeptisch, wenn jemand in einen Container "wirklich unterschiedliche" Sachen reintun will. Eigentlich fallen mir nur 3 Gründe für sowas ein:

• Entweder "packt" man sie doch nur aufgrund einheitlicher Eigenschaften (die dann auch der Basisklasse bekannt sind),
• Oder man wird durch "harte technische Fakten" zu dieser Bedienung einer Schnittstelle gezwungen ("weiß nicht, wie's besser geht" zählt da nicht )
• Oder man hat sich tatsächlich das Problem noch nicht sauber durchdacht.

Mal eine Frage: Wie heißt Dein Stack fachlich ? "Y_oder_Z_Objekte_Oder_sonstiges" ?

Also nochmal mein Tipp: Gemeinsamem Eigenschaften identifizieren, in eine Basisklasse auslagern (per virtual) und Laufzeitpolymorphie nutzen (=> .filmor).

Ach ja:

shed schrieb:

...

...
  static std::stack<Base*> myStack; 
  Derived1 myDerived1;
  myStack.push(myDerived1);
}

...

Hier fehlt noch ein Adressoperator:

...
  myStack.push(&myDerived1);
}

Gruß,

Simon2.

Naja dann werde ich mir das Problem noch einmal durchdenken. Vielleicht is es ja wirklich besser, nicht beides in den gleichen Container zu packen.

Vielen Dank für die Tipps! (ich hab bis jetzt nur java programmiert, merkt man wahrscheinlich an meinen posts )

mfg,
shed

...
  static std::stack<Base*> myStack;
  Derived1 myDerived1;
  myStack.push(&myDerived1);
}

halte ich für keine gute Idee. Du hättest hier nach der schließenden Klammer lauter ungültige Objekte in deinem Stack, da du Pointer auf lokale Objekte speicherst. Mach es liebe wie .filmor.

Danke nochmal!

Das hier

...
  static std::stack<Base*> myStack;
  Derived1 myDerived1;
  myStack.push(&myDerived1);
}

halte ich für keine gute Idee....

Huuups - hast natürlich Recht !
(Hatte gar nicht gesehen, dass er den Scope wieder verlässt).

shed schrieb:

Hab das Problem lösen können Danke! Und ich hab jetzt für jeden Typ einen eigenen Stack ...

Sehr gut !

Gruß,

Simon2.