ich habe folgendes problem, hoffe jemand hat einen loesungsanstoss parat ->

(aufgelisteter code ist aufs wesentlichste gekuerzt)

ich schreibe eine C++ applikation die eine fremd-library verwendet.
diese library stellt mir folgende klassen zur verfuegung:

class Base
{
};
class SubA : public Base
{
};
class SubB : public Base
{
};

und folgende Klasse in meiner eigenen Applikation

class Handler
{
  public:
   void DoSomeThing( SubA *pA )
   {
     // hier passieren SubA spezifische Sachen
   }
};

meine C++ Applikation beinhaltet ferner Datenstrukturen die auf SubA aufbauen wie z.B. eine Liste von SubA Instanzen. Bei Abarbeitung solch einer Liste wird eine Instanz von Handler verwendet und fuer jedes Element ein DoSomeThing(element) aufgerufen.

Nun mein Problem:
Ich moechte das Handler::DoSomeThing auch mit SubB objekten bedienen können.
Also quasi eine weitere methode von der Handler Klasse:

void Handler::DoSomeThing( SubB *pB )
{
// hier passieren SubB spezifische Sachen
}

Die besagte Listen-Datenstruktur die dann bisher SubA elemente enthielt muesste entsprechend auch SubB elemente erlauben sodass bei jedem Handler::DoSomeThing( ??? ) typabhaengig klar ist welches Handler::DoSomeThing(..) verwendet werden soll.
wie ist sowas moeglich ?

danke vorab.

Aber guck dir erst einmal Polymorphie an, dann verstehst du, wovon ich rede.

klar weiss ich was polymorphie ist und wozu es gut ist.
ich denke auch dass sie zur loesung meines problems beitragen kann, jedoch nicht ausschliesslich.

es geht um folgendes:

ich habe eine lineare liste von instanzen einer bestimmten klasse X

std::list<X> myList;

Die Klasse X wird mir von der Fremd-Library zur Verfuegung gestellt. Genauso auch
eine weitere Klasse Y.
Beide Klassen haben keine direkte Verwandtschaft sondern sind beide Ableitungen einer Basisklasse B:

class B{};
class X : public B {};
class Y : public B {};

Ich möchte nun in der besagten Listen-Datenstruktur nicht nur X Instanzen sondern auch Y Instanzen abspeichern können. Das würde gehen, falls man sie wie folgt deklariert:

std::list<B> myList;

Jetzt habe ich das Problem beim Hineinpacken geloest, jedoch muss beim Rausnehmen auch eine Unterscheidungsmoeglichkeit gegeben sein, da ich je nach Typ eine andere Operation auf dem listen-elemen durchfuehren moechte.

class ObjHandler
{
  void DoSomeThingWithObject( B obj )
  {
     // hier festellung was obj eigentlich genau ist ... 
  }
};

oder aber

class ObjHandler
{
  void DoSomeThingWithObject( X x )
  {
     // X spezifisches hier 
  }
  void DoSomeThingWithObject( Y y )
  {
    // Y spezifisches hier
  }
};

Klar laesst sich obiges nicht auf anhieb kompilieren aber ich hoffe ich habe mein problem etwas genauer beschreiben koennen.
Ich habe die Vermutung das ein bestimmtes Design Pattern (Visitor) evtl. angewendet werden muesste, bin mir aber nicht ganz sicher.

Vielen Dank vorab.

Ich möchte nun in der besagten Listen-Datenstruktur nicht nur X Instanzen sondern auch Y Instanzen abspeichern können. Das würde gehen, falls man sie wie folgt deklariert:

std::list<B> myList;

Das würde nicht gehen. Du speicherst so nur Bs keine Xs oder Ys. Der Teil von einem X der kein B ist würde abgeschnitten. Das nennt sich Splicing. Dein Ansatz ist somit technisch falsch und die Probleme die im folgenden noch auftreten stellen sich gar nicht erst.

Was ist denn dein eigentliches Problem? Klassen mit gemeinsamer Basisklasse gemeinsam zu verwalten, geht normalerweise über Basisklassenzeiger. Und um dann mit diesen Zeigern was machen zu können, das nicht nur die Basisklasse betrifft, kann man Polymorphie nutzen.

mein eigentliches problem ist, dass ich die eine liste behalten moechte.
vielleicht doch ein bischen mehr zum kontext:

die software um die es geht, bedient eine 3D Engine und die klassen
X,Y und B sind messages die an die engine geschickt werden.

die software parst hierbei eine xml-datei und erzeugt eine liste von messages die an die engine (spaeter) geschickt werden sollen.

bisher wurden hierbei nur messages vom typ X betrachtet und nun soll auch Y dazukommen, jedoch die listen-struktur nicht zerstoert werden, da weiter teile der software auf dieser struktur aufbauen.

der interessante teil passiert an der stelle, wo ein element rausgenommen und verschickt werden soll. Hier muessen dann naemlich noch auf dem jeweiligen Listen-Element (je nach Typ) bestimmte vorarbeiten vorgenommen werden
(das entspricht ungefaehr der ObjHandler Klasse aus meinem Vorpost und dessen Methode DoSomeThing(..)).

Was mir fehlt ist der geeignete (elegante) Programmier-Formalismus der obiges ermöglicht ohne die listen-struktur aufzubrechen.

vielen dank (auch wenn es immer noch nicht klar sein sollte )

Dann nehm dynamic_cast

Schlechte Idee.

Das Problem schreit nach virtuellen Methoden.

struct Base {
  virtual void preprocess() {}
};
struct SubA : Base {
  virtual void preprocess() { doSomethingWithSubA(*this); }
}

Vorher musst du allerdings das Problem mit dem Splicing in den Griff kriegen. Wenn du C++11 verwenden kannst, nimm eine std::list<std::unique_ptr<Base>> .

@phyax und @lazycoder:

- die Klassen der zu behandelnden Elemente meiner Listenstruktur kann ich nicht veraendern. lazycoder hat aufgepasst: sind fremd-library klassen.

- was ich allerdings machen kann, ist die Klasse der Instanz zu aendern, die die Elemente bearbeitet. Es muss dort eine Art preprocessing stattfinden und lazycoders ansatz mit den virtuellen methoden fuehrt glaube ich in die richtige richtung. Ich habe das gefuehl, dass hier das Visitor Pattern umgesetzt werden muss. Auf Fallstricke wie das genannte splicing problem etc. muss ich nochmal genauer schauen, denke aber dass es mit virtuellen methoden und der verwendung von boost::shared_ptr<Base> als Elemente meiner Liste gehen muesste (!?)

Vielen Dank, ein hoch auf das Forum