C++ Multiple Dispatch-

Question

Gegeben folgendes Problem:

class Instrument { 
}; 

class Guitar : public Instrument { 
    public: 
    void doGuitar() const; 
}; 

class Piano : public Instrument { 
    public: 
    void doPiano() const; 
}; 

habe ich eine Liste von Zeigern auf Instrument

list<shared_ptr<Instrument>> instruments; 

, in denen ich Instrumente über (zum Beispiel) hinzufügen

Guitar myGuitar; 
instruments.push_back(make_shared<Guitar>(myGuitar)); 

Jetzt , Ich möchte über die Liste instruments iterieren und doPiano() wenn der curr aufrufen Ent Instrument ist ein Klavier und doGuitar() wenn es eine Gitarre ist. Diese beiden Funktionen unterscheiden sich sehr und können daher in der Klasse Instrument nicht abstrakt gemacht werden.

Das Problem ist, dass C++ den Typ der Instrument nicht zur Laufzeit identifizieren kann, nicht wahr (wegen Einzelversand)? Wie erreiche ich, dass es die Klavier- oder die Gitarrenfunktion in Abhängigkeit vom aktuellen Typ, auf den der Iterator zeigt, aufruft.

Ich würde mich freuen, wenn ich etw. Arbeiten wie diese Pseudo-Code:

list<shared_ptr<Instrument>>::const_iterator it; 
if ("current type == Guitar") 
    (*it)->doGuitar(); 
else if ("current type == Piano") 
    (*it)->doPiano(); 

Ergebnis

Eigentlich lief ich in mehrere Probleme mit meinem Ansatz. Ich habe mit diesem Post viel Refactoring gemacht: How does one downcast a std::shared_ptr?. Vielen Dank an alle für Ihre Hilfe :)

Answer 1

Eine Möglichkeit zur Identifizierung von Klassen zur Laufzeit ist die Verwendung von dynamic_cast. Um das zu nutzen, müssen Sie mindestens eine virtuelle Methode in Ihrer Klasse haben. Zu diesem Zweck kann der Instrumentenklasse eine leere virtuelle Methode hinzugefügt werden.

class Instrument { 
    private: 
    virtual void emptyMethod_doNotCall() {} // Add this method. 
}; 

class Guitar : public Instrument { 
    public: 
    void doGuitar() const; 
}; 

class Piano : public Instrument { 
    public: 
    void doPiano() const; 
}; 

Der Objekttyp kann, indem Sie eine dynamic_cast zu der Zielklasse Zeiger überprüft werden. dynamic_cast gibt NULL zurück, wenn das Objekt nicht in die gewünschte Zielklasse umgewandelt werden kann.

list<shared_ptr<Instrument>>::const_iterator it; 
if (dynamic_cast<Guitar*>(it) != NULL) 
    (*it)->doGuitar(); 
else if (dynamic_cast<Piano*>(it) != NULL) 
    (*it)->doPiano(); 

Answer 2

Der Entwurf kann wahrscheinlich verbessert werden, um dieses Problem zu beseitigen, aber die Arbeit im Rahmen des bestehenden Design können Sie eine virtuelle Memberfunktion Instrument::play_it hinzufügen, die ein Player als polymorphes Argument. In Player haben zwei Funktionen play_guitar (unter Gitarrenargument) und play_piano (Piano-Argument). In der Gitarrenklasse überschreiben Sie play_it, um Player::play_guitar mit Selbst als Argument zu benennen. In der Klavierklasse überschreiben Sie play_it, um Player::play_piano mit self als Argument aufzurufen. Schau ma keine Gussstücke.

Dies ist nicht genau mehrere Versand, es ist bekannt als das Besucher-Muster. Aber es ist vielleicht am besten, sich nicht zu sehr darauf zu konzentrieren, damit Sie nicht beginnen, die Dinge visitor oder solche nicht-beschreibende Torheit zu nennen.

Answer 3

Eine Doppel-Ausgabe funktioniert wie diese (Pseudo-Code, wichtig, aber trivial Sachen weggelassen):

struct InstrumentVisitor{ 
    // knows all instruments 
    virtual void doGuitar(Guitar*) = 0; 
    virtual void doPiano(Piano*) = 0; 
}; 

class Instrument { 
    virtual void doInstrument(InstrumentVisitor*) = 0; 
    ... 
}; 

class Piano : public Instrument { 
    void doInstrument (InstrumentVisitor* v) { 
     v->doPiano(this); 
}; 

class Guitar : public Instrument { 
    void doInstrument (InstrumentVisitor* v) { 
     v->doGuitar(this); 
}; 

Jetzt können wir konkrete Besucher entwickeln.

struct Player : InstrumentVisitor { 
    // does vastly different things for guitar and piano 
    void doGuitar (Guitar* g) { 
     g->Strum(pick, A6); 
    } 
    void doPiano (Piano* p) { 
     p->Scale (Am, ascending); 
}; 

Answer 4

Typ Löschung ist eine weitere Option:

std::vector<std::function<void()>> playInstrument; 
playInstrument.emplace_back([g = Guitar{}]() { return g.doGuitar(); }); 
playInstrument.emplace_back([p = Piano{} ]() { return p.doPiano(); }); 

playInstrument[0](); 

Dazu Sie auch keine gemeinsame Basisklasse benötigen.