title: Double dispatch/multimethods in C++
body: <p>I have a question on C++ double dispatch. In the code below, I want the results from the second set to match the results from the first set. </p>
  
  <p>I don't know the actual type (unless I try dynamic_cast) but I do know that the object inherited from the BaseClass type. What is the most efficient (performance-wise) way to accomplish this?</p>
  
  <p>After googling around for a while I found out about double dispatch and the loki multimethods. The problem I have with the Shape examples is that in my application, Processor and BaseClass are entirely independent and don't have a common method that they can call in each other. Secondly, there is only one Processor (i.e. nothing inherits from it).</p>
  
  <p>Thanks for any help.</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;string&gt;
  using namespace std;
  
  class BaseClass{
  public:
         BaseClass(){}
         virtual void myFunction(){cout &lt;&lt; "base myFunction called" &lt;&lt; endl;}
  };
  
  class Derived1: public BaseClass{
  public:
         Derived1():BaseClass(){}
         void myFunction(){cout &lt;&lt; "Derived1 myFunction called" &lt;&lt; endl;}
  };
  
  
  class Derived2: public BaseClass{
  public:
         Derived2():BaseClass(){}
         void myFunction(){cout &lt;&lt; "Derived2 myFunction called" &lt;&lt; endl;}
  };
  
  class Derived3: public BaseClass{
  public:
         Derived3():BaseClass(){}
         void myFunction(){cout &lt;&lt; "Derived3 myFunction called" &lt;&lt; endl;}
  
  };
  
  class Processor{
  public:
         Processor(){}
         virtual void processObj(BaseClass* bc){cout &lt;&lt; "got a base object" &lt;&lt; endl; bc-&gt;myFunction();}
         virtual void processObj(Derived1* d1){cout &lt;&lt; "got a derived1 object" &lt;&lt; endl; d1-&gt;myFunction();}
         virtual void processObj(Derived2* d2){cout &lt;&lt; "got a derived2 object" &lt;&lt; endl; d2-&gt;myFunction(); }
  };
  
  
  int main() {
     BaseClass *bcp=new BaseClass();
     Derived1 *dc1p=new Derived1();   
     Derived2 *dc2p=new Derived2();
     Derived3 *dc3p=new Derived3();
  
     Processor p;//can also use Processor* p = new Processor()
  
     //first set results
     p.processObj(bcp);
     p.processObj(dc1p);
     p.processObj(dc2p);
     p.processObj(dc3p);
  
     BaseClass *bcp1=bcp;
     BaseClass *dc1p1=dc1p;   
     BaseClass *dc2p1=dc2p;
     BaseClass *dc3p1=dc3p;
  
     //second set results
     p.processObj(bcp1);
     p.processObj(dc1p1);
     p.processObj(dc2p1);
     p.processObj(dc3p1);
  
     return 0;
  }
  </code></pre>