Question

I have 6 classes which all perform the same actions. I would like to move common behavior to a common [base] class.

There are actions to be performed on 6 separate objects. The six objects are located in derived classes. Intuitively, the private member objects would be accessed through the child (derived class) in the base class.

What is the C++ pattern I am looking for?

class Base
{
  // Common behavior, operate on m_object
  ...
  void Foo()
  {
    m_object.Bar();
  }
};

class Derived1 : public Base
{
  // No methods, use Base methods

  private:
  MyObject1 m_object;
}

class Derived2 : public Base
{
  // No methods, use Base methods

  private:
  MyObject2 m_object;
}

The thing that is boxing me into this situation is MyObject1, MyObject2, etc offer Bar(), but don’t share a common base class. I really can’t fix the derivation because the objects come from an external library.

Answer 1

If they are introduced in the derived classes, then the base class cannot directly access them. How would the base class know that all derived classes have a specific member?

You could use virtual protected methods like so:

class my_base
{
protected:
    virtual int get_whatever();
    virtual double get_whatever2();
private:
    void process()
    {
       int y = get_whatever();
       double x = get_whatever2();
       //yay, profit?
    }
}

class my_derived_1 : my_base
{
protected:
    virtual int get_whatever()
    {
        return _my_integer;
    }

    virtual double get_whatever2()
    {
       return _my_double;
    }
}

Another possibility (if you want to call the base methods from the derived classes) is to simply supply the arguments to the base methods.

class my_base
{
protected:
    void handle_whatever(int & arg);
};

class my_derived : my_base
{
    void do()
    {
      my_base::handle_whatever(member);
    }

    int member;
};