Anrufverfahren für Objekte von abgeleiteten Typ

Question

I eine Art Hierarchie haben:

class GameObject{...}; 
class Subject:public GameObject{...}; 
class Player:public Subject{...}; 
class Bullet:public Subject{...}; 
class Enemy:public Subject{...}; 

in der Anordnung von Gameobject * durchqueren, überprüfe ich den Zustand und die Call-Methode foo (* object1, * object2) (object1 Referenz to Bullet, object2 ist ein Verweis auf Player).

std::vector<GameObject*> objects; 
// fill array (pointers to Bullet, Enemy, Player) 
foreach(auto obj1 : objects) 
{ 
    foreach(auto obj2 : objects) 
    { 
    if(obj1.getID() != obj2.getID() 
    { 
     foo(*obj1, *obj2); 
    } 
    } 
} 

Auch schreibe ich einige überladene foo Methoden:

void foo(GameObject&, GameObject&) 
void foo(Bullet&, Player&) 
void foo(Bullet&, Enemy&) 

Aber nur foo (Gameobject &, Gameobject &) genannt wird. Warum?

Answer 1

Dies sind Zeiger auf GameObject. Sie dereferenzieren sie und erhalten Objekte vom Typ GameObject, und das macht Sinn. Wenn Sie einen Zeiger auf int dereferenziert haben und ein Objekt vom Typ Apple erhalten haben, wäre das sehr merkwürdig.

GameObject * (a Zeiger zu GameObject) bedeutet, daß es einige Teil des Speichers besteht, dass dieser Zeiger zeigt auf, und diese Speicher sollte GameObject als ein Objekt des Typs behandelt werden. Wenn Sie einen Zeiger dereferenzieren, erhalten Sie tatsächlich Zugriff auf diesen Speicher, der offensichtlich als GameObject behandelt wird.

Answer 2

foo() Überladung wird während der Programmkompilierung ausgewählt. Und der Compiler hat offensichtlich keine Ahnung, was die wirklichen Arten von Objekten sind, die Sie in Ihren Schleifen passieren, also wählt er das einzige, was es sicher weiß.

Es gibt verschiedene Möglichkeiten zur Lösung dieses Problems im Allgemeinen, Google "Double Dispatch" oder "Besucher Muster".