C++: Sélection d'une classe dérivée par une base à l'aide Surcharger au lieu de Cast dynamique

Question

À titre d'exemple à ma question, imaginez une classe de base comme ceci:

struct Agent { 

    void compete(const Agent& competitor) const = 0; 

}; 

associés à un dérivé comme celui-ci:

struct RockAgent; 
struct PaperAgent; 

struct ScissorsAgent: public Agent { 

    void compete(const Agent& competitor) const override { 
     if(dynamic_cast<const RockAgent*>(&competitor)) 
      std::cout << "I have lost" << std::endl; 

     else if(dynamic_cast<const PaperAgent*>(&competitor)) 
      std::cout << "I have won!" << std::endl; 

     //etc.... 
    } 

}; 

et le comparer à cette base:

struct PaperAgent; 
struct RockAgent; 
struct ScissorsAgent; 

struct Agent { 

    void compete(const PaperAgent& competitor) const = 0; 
    void compete(const RockAgent& competitor) const = 0; 
    void compete(const ScissorsAgent& competitor) const = 0; 

}; 

une d ce dérivé:

//forward needed classes..... 

struct PaperAgent: public Agent { 

    void compete(const PaperAgent& competitor) const override { 
     std::cout << "I have won!" << std::endl; 
    } 

    //etc...... 

}; 

Si je tente d'utiliser ces deux méthodes en passant à la concurrence() fonctionnent une instance polymorphes Agent (référence dans ce cas), seule la première compile. Dans le second cas, le compilateur se plaint qu'il n'y a pas de fonction telle que la concurrence (const Agent &). Je comprends pourquoi cela ne fonctionne pas, mais existe-t-il une alternative qui n'exige pas dynamic_cast et est plus proche du second cas montré ci-dessus en termes de conception? Peut-être un motif de conception que je ne connais pas, ou que je n'ai jamais imaginé pourrait être utilisé pour imiter cela?

Answer 1

changement Agent:

struct Agent { 
    virtual void competeWith(const Agent& competitor) const = 0; 
    void compete(const Agent& competitor) const { compeditor.competeWith(*this); } 
    virtual void compete(const PaperAgent& competitor) const = 0; 
    virtual void compete(const RockAgent& competitor) const = 0; 
    virtual void compete(const ScissorsAgent& competitor) const = 0; 
}; 

En PaperAgent:

struct PaperAgent: public Agent { 
    void competeWith(const Agent& competitor) const override final { 
    compeditor.compete(*this); 
    } 
    void compete(const PaperAgent& competitor) const final override; 
    void compete(const RockAgent& competitor) const final override; 
    void compete(const ScissorsAgent& competitor) const final override; 

};

cela peut être aidé avec le CRTP:

template<class D> 
struct AgentImpl: public Agent 
    void competeWith(const Agent& competitor) const override final { 
    compeditor.compete(*static_cast<D const*>(this)); 
    } 
}; 
struct PaperAgent: public AgentImpl<PaperAgent>{ 
    void compete(const PaperAgent& competitor) const final override; 
    void compete(const RockAgent& competitor) const final override; 
    void compete(const ScissorsAgent& competitor) const final override; 
}; 

pour réduire la réplication du code.

a1.compete(Agent const& a2) invoque a2.competeWith(a1), qui appelle à son tour a1.compete(a2) en utilisant le type de dynamique a2 et pleine résolution de surcharge.

Ceci est l'une des nombreuses manières standard de faire "double expédition" - agissant virtuellement sur deux arguments à la fois.