Übergeordnete Klasse in untergeordnete Klasse umwandeln, um Redundanz zu vermeiden

Question

Ich habe die folgenden Klassen in Bezug auf Mathematik/Geometrie: MathLine, MathPoint, MathVector, MathPlane.

Auf jeder dieser Funktionen können Sie Rotations- und Translationstransformationen durchführen. Also habe ich eine Elternklasse namens GeometricObject geschaffen, Objekte, die im geometrischen Raum transformiert werden können.

Jetzt bin ich in der Lage, reine virtuelle Klassenfunktionen mit verschiedenen Implementierungen für jede Kindklasse zu erstellen. Nun mag ich eine allgemeine Funktion, die GeometricObject nehmen kann, aber „intelligent“ zurückkehren, welche Art ich tatsächlich setzte in Zum Beispiel, ich habe die folgende Funktion, die ein geometrisches Objekt zu einem anderen Koordinatensystem dreht.

GeometricObject rotate_object_to_global_coordinate_system(GeometricObject object) { 
    object.rotateX(90); // Pure virtual functions 
    object.rotateY(90); 
    object.rotateZ(90); 

    return object; 
} 

Wenn ich eine MathLine hineinlege, erwarte ich, dass die Funktion in eine MathLine "caste", die Implementierung meiner virtuellen Funktionen MathLine ausführt und eine MathLine zurückgibt.

Ich habe überall nach diesem gesucht und es scheint, als ob dies entweder mit Zeigern (auto_ptr) oder Gießen (dynamic_cast) getan werden kann. Das scheint nicht gut zu sein, weil ich gelesen habe, dass es ein schlechter Weg ist, es zu tun, weil es eine merkliche Menge an Leistung opfert. Es scheint auch ein einfaches Feature zu sein, das eine höhere Programmiersprache haben sollte. Kann das gemacht werden?

Ich denke, es ist wirklich wichtig für mich, dies zu tun, weil ich sonst separate Funktionen schreiben müsste, die im Grunde die gleichen virtuellen Funktionen für verschiedene Kindklassen ausführen. Ich müsste schreiben:

MathLine rotate_line_to_global_coordinate_system(MathLine object); 
MathPoint rotate_point_to_global_coordinate_system(MathPoint object); 
MathPlane rotate_plane_to_global_coordinate_system(MathPlane object); 
// etc. 

Answer 1

Dies ist, was Vorlagen sind. Implementieren Sie Ihre Rotationsfunktion vorzugsweise als Vorlage, die direkt auf einer Ihrer vier Unterklassen ausgeführt werden kann. Wenn das nicht machbar ist, ist eine andere, weniger bevorzugte, aber immer noch meist tolerierbare Option, diese Rotationsfunktion in eine Fassadenvorlage zu übernehmen, die ihren Parameter weiterleitet und dann den Rückgabewert der Rotationsfunktion annimmt den entsprechenden Typ und gibt es dann zurück.

Answer 2

Solange Ihre Methoden in der Mutterklasse virtuell sind, ruft sie die Implementierung automatisch auf, wenn Sie sie aufrufen.
Ihr Code kann folgende sein:

class GeometricObject 
{ 
    virtual void rotateX(float angle) = 0; 
    virtual void rotateY(float angle) = 0; 
    virtual void rotateZ(float angle) = 0; 
}; 

Dann jede Funktion von dieser Klasse erben müssen diese Funktionen implementiert haben:

class MathLine : public GeometricObject 
{ 
    void rotateX(float angle) { /* Implementation */ } 
    void rotateY(float angle) { /* Implementation */ } 
    void rotateZ(float angle) { /* Implementation */ } 
}; 

Jetzt

, wenn Sie es Ihre Funktion rotate_object_to_global_coordinate_system und vorbei rufen ein MathLine, ruft es automatisch seine Implementierung von Rotationsfunktionen auf.

Und wenn Sie die gleichen Regeln für andere Objekte folgen, wäre es das gleiche für MathPoint tun, MathPlane usw.