Question

I got these virtual classes from a library that implement an algorithm in the form of abstract classes

class A{
    public : 
    virtual void foo() = 0 ;
};


class B{
    public:
        void setA(A * a) { m_a = a ;}

        virtual void f() = 0;
        void g() {m_a->foo();}
    protected:
        A * m_a ;
 };

To use the library you just have to derive the classes and implement the pure virtual functions, like foo(), and provide other methods specific to the implementation as well (bar()).

class dA : public A {
    public :
         void foo() {/* ... */}
         void bar() {/* ... */}
};

class dB : public B {
     public :
          void f() ;
};

I would typically use these class by calling

dB * mydB = new dB() ;
mydB->setA(new dA() );
mydB->f() ;
mydB->g() ;

But I have a design problem when implementing dB::f(), because I need to call dA::bar() which is specific to dB. But in the class, I only keep a reference to dB trough a B*. Then I have thought of two options :

• use a dynamic_cast each time f()is called to cast B::m_a into a dB*
• add a m_dA member to dB which stores the same pointer as m_a, but can be used to access dB specific functions.

Of course I can’t change the the base classes.

I would like to know if there is a more elegant solution to this problem (like a design pattern I did not thought of). If not, which one should I choose ?

Answer 1

You’ve a third solution. Add a function setA() in the dB. Of course, this function will hide B::setA() which is good for you if dB::setA() is implemeted as:

class dB : public B 
{
     dA *m_dA ; //add this member also!
     public :
          void f()
          {
             m_dA->bar(); //fast forward : no cast here!
          }
          void setA(A *a) //this hides B::setA()
          {
             m_dA= dynamic_cast<dA*>(a); //just one time dynamic cast!
             if ( m_dA == 0 )
             {  
                 throw std::runtime_error("invalid argument");
             }
             B::setA(a); //now call the hidden function in the base!
          }
};

In this way, you don’t need to dynamic_cast each time you call dB::f(), which makes the call fast!