Polymorphy

Ich habe gehört, dass man meistens ein switch(type_info) mit Polymorphy umgehen kann. Allerdings weis ich nicht wie ich das in diesem Beispiel bewerkstelligen kann:

typedef unsigned int uint;
class Object{
     //Register
     static std::list<Object*> reg;
     std::list<Object*>::iterator reg_pos;
     //Position info
     int x;
     int y;
     uint width;
     uint height;

     void update_collision_state();
public:
     Object(){reg.push_back(this);reg_pos=--(reg.end())}
     ~Object(){reg.erase(reg_pos);}

     //T sollte von Object abgeleitet sein
     template<class T>
     virtual col(T&){}

     void move(int x_,int y_,int width_,int height_)
     {
         x=x_;
         y=y_;
         width_=width;
         height_=height;
         update_collision_state();
     }
};
void Object::update_collision_state()
{
     //Hier werden nun die Objecte in auf collision getested
     //(Checking Code ist glaub ich nicht wichtig für die Frage)

     //Nun hab ich festgestellt, dass Object nr.1 mit nr.3 collidirt
     //Wie rufe ich nun die entsprechenden Funktionen in denn Klassen auf?
     //Das heist wenn nr.1 vom Type her Ente ist und nr.3 Hund wie ruffe ich dann
     //nr1->col(*((Hund*)nr3));
     //nr3->col(*((Ente*)nr1));
     //auf?
}

Könnte jemand mir zeigen wie ich in dem Fall Polymorphy anwenden kann?

Auch und es hat keinen Zweck eine col(Object&) einzubauen denn wenn man verschiedenes Verhalten will wenn es sich um eine besondere Klasse handelt (wie zum Beispiel Hund oder Ente), dann endet man mit einem switch statement in der col Funktion und das soll ja gerade umgangen werden.

Knuddlbaer

Alles was mir dazu einfällt ist das Visitor Pattern. Da ich es aber selbst noch kein einziges mal Implementiert bzw. verwendet hab kann ich Dir da nich viel helfen.

Aber als Suchbegriff dürfte es eventuell schon was her geben.

Shade Of Mine

ist es wichtig, dass die objekte wissen mit was sie kollidieren?
normalerweise dürfte das ja nicht wichtig sein. wenn zB ein raumschiff mit einem planeten kollidiert, könnte man zB jeweils die Masse checken und je nachdem den Schaden an Raumschiff und Planet berechnen. (wobei ein Planet vermutlich nicht viel Schaden nimmt ;))

Ansonsten klingt es sehr nach 'Double Dispatching' (wenn du More Effective C++ hast: Item 31).

ist aber nicht ganz trivial

ist aber nicht ganz trivial

Hab ich auch schon gemerkt, also hab ich das jetzt richtig verstanden:
Jede abgeleitet Klasse erhält eine ID. Eine Collisions Funktion wird als Funktion implementiret die ausserhalb aller Klassen ist. Nun fügt man eine Struktur hinzu die 2 ID enthalten kann. Eine globale (oder auch statische) map enthält als Key eine dieser ID Strukturen und als Value ein Pointer eine der Collisions Funktionen. Die abgeleiteten Klasse hat eine Funktion die eine Referenze zu einer Klasse des Parent Types hat. Diese Funktion sieht dann in der Map nach und sucht die passende Funktion für ihre ID und die von der sie eine Referenz hat und fals gefunden ruft sie diese Funktion auf und gibt sich und ihr Argument als Reference an die Funktion in der map weiter.

Allerdings sehe ich nicht was das für einen Vorteil gegenüber dem hier gibt :

template<class T1,class T2>
inline void handle(T1&,T2&){cout<<"default handler"<<endl;}
void handle(int&,int&){cout<<"int handler"<<endl;}
void handle(char&,int&){cout<<"char handler"<<endl;}