Using Policy Based design C++

Question

My present class design is something like this (I have replicated the class hierarchy and function calls.):

  Helper* HelperFactory::create(const Advice& advice, const Handler& ah)
  {
       Helper* result = 0;
      switch(advice.getType())
      {
         case ONE:
         case TWO:
        {
                 if(advice.isTradeAdvice())
                      result = new SimpleHedgeHelper(advice, ah);
                 else
                     result = new SimpletradeHelper(advice, ah);
                break;
        } 
        case THREE
        case FOUR:
        case FIVE:
        {
             if(advice.isTradeAdvice())
                    result = new ComplexTradeHelper(advice, ah);
             else
                 result = new ComplexHedgeHelper(advice, ah);
            break;
        }
        case SIX:
        {
            if(!advice.getMsgID())
            {
                if(advice.isTradeAdvice())
                     result = new SimpleTradeHelper(advice, ah);
                else
                     result = new SimpleHedgeHelper(advice, ah);
            break;
             }
            else
             {
                   if(advice.isTradeAdvice())
                      result = new ComplexRateHelper(advice, ah);
                   else
                      result = new ComplexHedgeHelper(advice, ah);
                   break;
              }
       }
  }

I am trying to replace this logic with some templated policy based factory. I have not designed any classes earlier based on plicly Can some one please suggest How design should be?

[OT]: Better to return `std::unique_ptr`. – Jarod42 Aug 07 '14 at 06:48 — Jarod42, Aug 07 '14 at 06:48
@TemplateRex have a coffee and reconsider ;) – Quentin Aug 07 '14 at 07:26 — Quentin, Aug 07 '14 at 07:26
@Quentin ah, my bad, those damned CamelCase names. – TemplateRex Aug 07 '14 at 07:28 — TemplateRex, Aug 07 '14 at 07:28

Tony Delroy · Answer 1 · 2014-08-07T07:18:15.640

In considering a move to policy templates, you should evaluate whether the behavioural differences between your current classes can be factored using this kind of approach:

template <class Complexity_Policy, class Instrument_Policy>
class Helper : public Abstract_Helper
{
    // for any function Helper needs...
    virtual return_type f(arguments)
    {
         ...can reference Complexity_Policy and/or Instrument_Policy members for behaviours...
    }
};

That tends to work best when the behaviours are largely orthogonal (unrelated / decoupled).

If all your client code wants to continue to use run-time polymorphism you will still need your factory, but it should begin returning things like:

result = new Helper<Complexity_Policy__Simple, Instrument_Policy__Hendge>(advice, ah);

(Yes, I do know the Standard reserves use of double underscores in identifiers... I do accept the risk that this will have undefined behaviour, feeling the only imaginable use of double underscores the implementation may make is as prefixes or suffixes.... Not interested in side-tracking this Q to discuss further.).

You can make selective direct use of the template instantiations too. Another option is to not even have Helper derive from any base or have virtual functions, instead layering runtime polymorphism on top using an Abstract_Helper* get_polymorphic_accessor() member that creates a pointer-holding class derived from Helper that forwards calls/results.

Thanks Tony for a quick reply. But refactoring present class Hierarchy is not an option for me :( I was looking for some solution after which I should be able to get right object by just passing "type" which is an Enum value in my case something like Factort f; f.create(); — user1545583, Aug 07 '14 at 07:46
@user1545583: that doesn't sound at all useful, as you'll need each enumeration to be a compile-time constant in every context where you create such a `f` variable, which basically means your current factory's `switch`/`if`/`else` chain just to create a `Factort<...>` variable and use it to indirectly call `new`.... — Tony Delroy, Aug 07 '14 at 08:45

Using Policy Based design C++

1 Answers1