einziehenden Best-Practice (C++)

Question

Statische Code-Analyse-Tools ist in der Regel viel über „einziehe eine Basisklasse auf eine abgeleitete Klasse“ schweifen und ich fand auch ein paar Standard-Führer der Codierung, die diese so nicht zu tun, erwähnt ich war frage mich, was ist der Best-Practice-Weg.

Hier ist meine Anwendungsfall:

ich eine Base (Schnittstelle) haben, DerivedA, DerivedB Klassen und dann ein Array Basiszeiger enthält.

Dann Iterate durch das Array und basierend auf einem Flag, ich feststellen, ob das Objekt DerivedA oder DerivedB ist, werfen Sie es nieder und einige zufällige Sachen zu dem Objekt von außen.

Im Grunde so etwas wie diese:

// arr is of type Base** 
for (int i = 0; i < size; ++i) 
{ 
    // doMagic has an overload for both types 
    if (arr[i]->isDerivedA()) 
    { 
     doMagic(reinterpret_cast<DerivedA*>(arr[i])); 
    }  
    else if (arr[i]->isDerivedB()) 
    { 
     doMagic(reinterpret_cast<DerivedB*>(arr[i])); 
    } 
} 

Bout die reinterpret, kann ich nicht wegen Embedded-Plattform Einschränkungen verwenden dynamic_cast (das gleiche gilt für 11 C++), aber die Basisklasse, dass das Objekt eine Schnittstelle garantiert sein ist entweder DerivedA oder DerivedB.

Ich könnte DerivedA und DerivedB nur reine virtuelle Aufrufe implementieren, so würde ich keine Angst vor dem Downcasting etwas haben müssen, aber die DerivedA und DerivedB Klassen sind sehr spezialisiert und DoMagic macht völlig andere Dinge mit den Instanzen ...

Also habe ich mich gefragt, wie ihr euch nähert - mit einem einzigen Array von sehr unterschiedlichen Objekten, aber geerbt von einer einzigen Basis, durch sie hindurch und einige spezialisierte Sachen von außen.

Answer 1

Sie sollten wahrscheinlich versuchen Besuchermuster zu verwenden. Hier ist ein einfaches Beispiel:

#include <cstdio> 

class A; 
class B; 
class Visitor { 
public: 
    void visit(A &a) { 
     printf("Visited A\n"); 
    } 

    void visit(B &) { 
     printf("Visited B\n"); 
    } 
}; 


class A { 
public: 
    virtual ~A() { } 

    virtual void applyVisitor(Visitor &v) { 
     v.visit(*this); 
    } 
}; 

class B : public A { 
public: 
    ~B() override { } 

    void applyVisitor(Visitor &v) override { 
     v.visit(*this); 
    } 
}; 


int main() { 
    A a; 
    B b; 

    Visitor v; 

    a.applyVisitor(v); 
    b.applyVisitor(v); 


    return 0; 
} 

Answer 2

Wenn Sie wissen, dass ein Zeiger einer Basisklasse auf ein Objekt einer abgeleiteten Klasse, können Sie static_cast verwenden. Der Compiler entsprechenden Code einfügen Offsets einzustellen, im Gegensatz zu reinterpret_cast oder einem C-Cast.