Überladen Sie eine Funktion mit einem abgeleiteten Klassenargument, wenn Sie nur einen Zeiger auf die Basisklasse in C++ haben

Question

Ich habe Leute gesehen, die Behälter mit Zeigern zu der Basisklasse verwenden, um Gruppen von Objekten zu halten, die die gleichen virtuellen Funktionen teilen. Ist es möglich, überladene Funktionen der abgeleiteten Klasse mit diesen Basisklassenzeigern zu verwenden. Es ist schwer zu erklären, was ich meine, aber (glaube ich) einfach mit Code zu erhalten

class PhysicsObject // A pure virtual class 
{ 
    // Members of physics object 
    // ... 
}; 

class Circle : public PhysicsObject 
{ 
    // Members of circle 
    // ... 
}; 

class Box : public PhysicsObject 
{ 
    // Members of box 
    // ... 
}; 

// Overloaded functions (Defined elsewhere) 
void ResolveCollision(Circle& a, Box& b); 
void ResolveCollision(Circle& a, Circle& b); 
void ResolveCollision(Box& a, Box& b); 

int main() 
{ 
    // Container to hold all our objects 
    std::vector<PhysicsObject*> objects; 

    // Create some circles and boxes and add to objects container 
    // ... 

    // Resolve any collisions between colliding objects 
    for (auto& objA : objects) 
     for (auto& objB : objects) 
      if (objA != objB) 
       ResolveCollision(*objA, *objB); // !!! Error !!! Can't resolve overloaded function 
} 

Meine erste Idee dieser Funktionen seines virtuellen Klassenmitglieder auch (siehe unten) zu machen, aber ich merkte schnell, dass es genau das hat das gleiche Problem.

class Circle; 
class Box; 
class PhysicsObject // A pure virtual class 
{ 
    virtual void ResolveCollision(Circle& a) = 0; 
    virtual void ResolveCollision(Box& a) = 0; 
    // Members of physics object 
    // ... 
}; 

class Box; 
class Circle : public PhysicsObject 
{ 
    void ResolveCollision(Circle& a); 
    void ResolveCollision(Box& a); 
    // Members of circle 
    // ... 
}; 

class Circle; 
class Box : public PhysicsObject 
{ 
    void ResolveCollision(Circle& a); 
    void ResolveCollision(Box& a); 
    // Members of box 
    // ... 
}; 

Von googeln das Problem es wie vielleicht scheint es kann unter Verwendung von Guss gelöst werden, aber ich kann nicht herausfinden, wie man den richtigen Typen zu finden, um zu werfen (auch sie ist hässlich). Ich vermute, dass ich die falsche Frage stelle, und es gibt einen besseren Weg, meinen Code zu strukturieren, der dieses Problem umgeht und das gleiche Ergebnis erzielt.

Answer 1

Mit Doppel-Ausgabe, es wäre so etwas wie:

class Circle; 
class Box; 

// Overloaded functions (Defined elsewhere) 
void ResolveCollision(Circle& a, Box& b); 
void ResolveCollision(Circle& a, Circle& b); 
void ResolveCollision(Box& a, Box& b); 
class PhysicsObject // A pure virtual class 
{ 
public: 
    virtual ~PhysicsObject() = default; 

    virtual void ResolveCollision(PhysicsObject&) = 0; 
    virtual void ResolveBoxCollision(Box&) = 0; 
    virtual void ResolveCircleCollision(Circle&) = 0; 
}; 

class Circle : public PhysicsObject 
{ 
public: 
    void ResolveCollision(PhysicsObject& other) override { return other.ResolveCircleCollision(*this); } 
    void ResolveBoxCollision(Box& box) override { ::ResolveCollision(*this, box);} 
    void ResolveCircleCollision(Circle& circle) override { ::ResolveCollision(*this, circle);} 
    // ... 
}; 

class Box : public PhysicsObject 
{ 
public: 
    void ResolveCollision(PhysicsObject& other) override { return other.ResolveBoxCollision(*this); } 
    void ResolveBoxCollision(Box& box) override { ::ResolveCollision(box, *this);} 
    void ResolveCircleCollision(Circle& circle) override { ::ResolveCollision(circle, *this);} 
    // ... 
}; 

Answer 2

So wie ich das tun würde dies eine Extent Klasse zu bauen, ist, dass Sie über den physischen Umfang eines Objekt sagt, vielleicht in Bezug auf ihren Barycentrum. Darüber hinaus würden Sie

virtual const Extent& getExtent() const = 0;

in der PhysicsObject Klasse. Sie implementieren dann getExtent einmal pro Objekttyp.

Ihre Kollisionserkennung Linie wird

ResolveCollision(objA->getExtent(), objB->getExtent()); 

Obwohl in gewissem Sinne, tut dies etwas mehr als die Dose auf der Straße kicken wie die Komplexität der Extent Klasse geschoben wird, wird der Ansatz, da Sie skaliert gut Sie müssen nur eine Methode pro Objekt erstellen.

Der alternative Doppelversandmechanismus ist insofern intrusiv, als eine neue Form eine Anpassung an alle vorhandenen Formen erfordert. Die Klasse Circle neu kompilieren, zum Beispiel, wenn Sie eine Ellipse Klasse einführen, sagen, ist ein Code-Geruch für mich.

Answer 3

Ich werde eine Implementierung skizzieren, die nicht auf Doppelversand angewiesen ist. Stattdessen verwendet es eine Tabelle, in der alle Funktionen registriert sind. Auf diese Tabelle wird dann über den dynamischen Typ der Objekte zugegriffen (als Basisklasse übergeben).

Zuerst haben wir einige Beispielformen. Ihre Typen sind in einem enum class eingetragen. Jede Formklasse definiert einen MY_TYPE als ihren jeweiligen Enum-Eintrag. Darüber hinaus müssen sie rein virtuelle type Methode der Basisklasse implementieren:

enum class ObjectType 
{ 
    Circle, 
    Box, 
    _Count, 
}; 

class PhysicsObject 
{ 
public: 
    virtual ObjectType type() const = 0; 
}; 

class Circle : public PhysicsObject 
{ 
public: 
    static const ObjectType MY_TYPE = ObjectType::Circle; 

    ObjectType type() const override { return MY_TYPE; } 
}; 

class Box : public PhysicsObject 
{ 
public: 
    static const ObjectType MY_TYPE = ObjectType::Box; 

    ObjectType type() const override { return MY_TYPE; } 
}; 

Als nächstes müssen Sie Ihre Kollisionsauflösung Funktionen, müssen sie je nach den Formen umgesetzt werden, natürlich.

void ResolveCircleCircle(Circle* c1, Circle* c2) 
{ 
    std::cout << "Circle-Circle" << std::endl; 
} 

void ResolveCircleBox(Circle* c, Box* b) 
{ 
    std::cout << "Circle-Box" << std::endl; 
} 

void ResolveBoxBox(Box* b1, Box* b2) 
{ 
    std::cout << "Box-Box" << std::endl; 
} 

Beachten Sie, dass wir nur Circle-Box hier keine Box-Circle, wie ich ihre Kollision übernehmen in der gleichen Art und Weise erfasst wird.Mehr zu dem Kollisionsfall Box - Circle später.

Nun zu dem Kernteil, die Funktionstabelle:

std::function<void(PhysicsObject*,PhysicsObject*)> 
    ResolveFunctionTable[(int)(ObjectType::_Count)][(int)(ObjectType::_Count)]; 
REGISTER_RESOLVE_FUNCTION(Circle, Circle, &ResolveCircleCircle); 
REGISTER_RESOLVE_FUNCTION(Circle, Box, &ResolveCircleBox); 
REGISTER_RESOLVE_FUNCTION(Box, Box, &ResolveBoxBox); 

Der Tisch selbst ist ein 2D-Array aus std::function s. Beachten Sie, dass diese Funktionen Zeiger auf PhysicsObject akzeptieren, nicht die abgeleiteten Klassen. Dann verwenden wir einige Makros für die einfache Registrierung. Natürlich könnte der entsprechende Code von Hand geschrieben werden und ich bin mir durchaus der Tatsache bewusst, dass die Verwendung von Makros typischerweise als schlechte Angewohnheit betrachtet wird. Meiner Meinung nach sind diese Dinge jedoch genau das, wofür Makros gut sind, und solange Sie aussagekräftige Namen verwenden, die Ihren globalen Namensraum nicht durcheinander bringen, sind sie akzeptabel. Beachten Sie nochmals, dass nur Circle - Box registriert ist, nicht umgekehrt.

Nun zur Phantasie Makro:

#define CONCAT2(x,y) x##y 
#define CONCAT(x,y) CONCAT2(x,y) 

#define REGISTER_RESOLVE_FUNCTION(o1,o2,fn) \ 
    const bool CONCAT(__reg_, __LINE__) = []() { \ 
     int o1type = static_cast<int>(o1::MY_TYPE); \ 
     int o2type = static_cast<int>(o2::MY_TYPE); \ 
     assert(o1type <= o2type); \ 
     assert(!ResolveFunctionTable[o1type][o2type]); \ 
     ResolveFunctionTable[o1type][o2type] = \ 
      [](PhysicsObject* p1, PhysicsObject* p2) { \ 
        (*fn)(static_cast<o1*>(p1), static_cast<o2*>(p2)); \ 
      }; \ 
     return true; \ 
    }(); 

Das Makro definiert einen eindeutig benannte Variable (mit der Zeilennummer), aber diese Variable dient lediglich um den Code zu bekommen innerhalb der Initialisierung Lambda-Funktion ausgeführt werden. Die Typen (aus der ObjectType enum) der übergebenen zwei Argumente (das sind die konkreten Klassen Box und Circle) werden genommen und verwendet, um die Tabelle zu indizieren. Der gesamte Mechanismus geht davon aus, dass es eine Gesamtordnung für die Typen gibt (wie in der Enumeration definiert), und prüft, ob für die Argumente in dieser Reihenfolge tatsächlich eine Funktion für die Kollision Circle10 registriert ist. Die assert sagt Ihnen, wenn Sie es falsch machen (versehentlich Registrierung Box - Circle). Dann wird eine Lambda-Funktion in der Tabelle für dieses spezielle Typenpaar registriert. Die Funktion selbst nimmt zwei Argumente vom Typ PhysicsObject* und wandelt sie vor dem Aufruf der registrierten Funktion in die konkreten Typen um.

Als nächstes können wir uns ansehen, wie die Tabelle dann verwendet wird. Es ist nun leicht eine einzige Funktion zu implementieren, die Kollision von zwei beliebigen PhysicsObject s überprüft:

void ResolveCollision(PhysicsObject* p1, PhysicsObject* p2) 
{ 
    int p1type = static_cast<int>(p1->type()); 
    int p2type = static_cast<int>(p2->type()); 
    if(p1type > p2type) { 
     std::swap(p1type, p2type); 
     std::swap(p1, p2); 
    } 
    assert(ResolveFunctionTable[p1type][p2type]); 
    ResolveFunctionTable[p1type][p2type](p1, p2); 
} 

Es nimmt die dynamischen Typen des Arguments und übergibt sie an die Funktion für die jeweiligen Typen innerhalb der ResolveFunctionTable registriert. Beachten Sie, dass die Argumente ausgetauscht werden, wenn sie nicht in der richtigen Reihenfolge sind. Somit können Sie ResolveCollision mit Box und Circle aufrufen und intern die für Circle - Box registrierte Kollision aufrufen.

Schließlich werde ich ein Beispiel geben, wie man es benutzt:

int main(int argc, char* argv[]) 
{ 
    Box box; 
    Circle circle; 

    ResolveCollision(&box, &box); 
    ResolveCollision(&box, &circle); 
    ResolveCollision(&circle, &box); 
    ResolveCollision(&circle, &circle); 
} 

Leicht ist es nicht? Siehe this für eine funktionierende Implementierung der obigen.

---

Nun, was ist der Vorteil dieses Ansatzes? Der obige Code ist im Grunde alles, was Sie benötigen, um eine beliebige Anzahl von Formen zu unterstützen. Angenommen, Sie fügen eine Triangle hinzu. Alles, was Sie tun müssen, ist:

1. Triangle zum ObjectType Enum einen Eintrag hinzufügen.
2. Implementieren Sie Ihre ResolveTriangleXXX Funktionen, aber Sie müssen dies in allen Fällen tun.
3. sie auf den Tisch mit dem Makro registrieren:

Das ist es. Es müssen keine weiteren Methoden zu PhysicsObject hinzugefügt werden, es müssen keine Methoden in allen vorhandenen Typen implementiert werden.

Ich bin mir einiger 'Fehler' dieses Ansatzes bewusst, wie die Verwendung von Makros, die eine zentrale enum aller Typen haben und sich auf eine globale Tabelle verlassen. Der letztere Fall könnte zu Problemen führen, wenn die Formklassen in mehrere gemeinsam genutzte Bibliotheken integriert sind. Meiner bescheidenen Meinung nach ist dieser Ansatz jedoch ziemlich praktisch (außer für sehr spezielle Anwendungsfälle), da er nicht zur Codeexplosion führt, wie dies bei anderen Ansätzen der Fall ist (z. B. Doppelversand).