Multiple Inheritance and Casting

[JohnW@Wessex]

and encapsulating some orthogonal (or mostly orthogonal) aspect of the behavior of the instantiated host class.

Would you be able to expand on this in POE (Plain Old English)
I'm not entirely sure I understand the meaning of 'orthogonal' in this context.

(orthogonal usually means "at right angles to")

[TheCPUWizard]

Would you be able to expand on this in POE (Plain Old English)
I'm not entirely sure I understand the meaning of 'orthogonal' in this context.

(orthogonal usually means "at right angles to")

John,

I am suprised that someone would post a link to material for reference when they have problems understanding the first paragraph of the linked material..

Simply draw a diagram, inheritance is represented by vertical lines. A reference between peer classes as a horizontal line. Definately "right angles".

In the code sample that was posted, one would presume that the Printer classes knew how to convert "content" to "byte patterns: that would be understood by a given printer, and the Comm class would know how to transfer bytes across a media (USB, Serial, etc).

Therefore the Template class would typically implement the functionallity of taking the bytes output by the printer (base class #1) and passing them to the communications (base class #2).

[Eggman002]

Okay looking in further detail at the Double Dispatch idea, I still don't really see how I can make use of it. At least not with the current code base (which I am stuck with).

Looking at the Foo/Bar example, I would think my "Modes" in this case would be the "Bar" classes, and then the objects which use the Modes would then be the "Foo" class (assuming I follow correctly).

One problem in my situation is that the Foos out number the bars by far. There are potentially hundreds of different locations where I need to call functions on the modes. So defining multiple functions in each of those locations gets quite time consuming and annoying.

Another problem is that in the examples that I have looked at, the base class has the same members as the child class. This is not the case in my situation. For my situation the SpecialMode classes have methods unique to those modes. So I need to access it as a "SpecialMode" in order to access those methods.

However I feel like maybe I am missing something with the Double Dispatch.

[TheCPUWizard]

One problem in my situation is that the Foos out number the bars by far. There are potentially hundreds of different locations where I need to call functions on the modes. So defining multiple functions in each of those locations gets quite time consuming and annoying.

But that is a "fact of life". If I add a capability to a few hundred classes (my industrial automation library has over 5000 different control elements) and there is no direct relationship between them (IS-A), then it DOES mean going into a few hundred files and adding the code.

Now in many cases this can be minimized. If you have a group of conceptually related methods which by definition have a common grouping (but not an inheritance relationship), then simply use a #include to simplify the legwork..

[JohnW@Wessex]

I am suprised that someone would post a link to material for reference when they have problems understanding the first paragraph of the linked material..

I just googled for "c++ template policy" and that link popped up first. I understood the concepts described, it was just the word 'orthogonal' was unfamiliar for me in a programming context. Seems obvious now

[Eggman002]

But that is a "fact of life". If I add a capability to a few hundred classes (my industrial automation library has over 5000 different control elements) and there is no direct relationship between them (IS-A), then it DOES mean going into a few hundred files and adding the code.

Now in many cases this can be minimized. If you have a group of conceptually related methods which by definition have a common grouping (but not an inheritance relationship), then simply use a #include to simplify the legwork..

Actually I think I understand a way that I can use this technique now that I have thought about it a bit. As per my previous example if I have a SpecialModeCommon, then I can use the SpecialModeCommon as a wrapper so that I have something like this:

class SpecialModeCommon
{
public:
  static void ACommonFunction(SpecialModeType1 mode)
  {
    // Process SpecialModeType1
    ACommonFunctionCommonCode(...);
  }

  static void ACommonFunction(SpecialModeType2 mode)
  {
    // Process SpecialModeType2
    ACommonFunctionCommonCode(...);
  }

private:

  static void ACommonFunctionCommonCode(...)
  {
     // Common Code goes here.
  }
}

Then elsewhere if I need to call ACommonFunction I can just do:

SpecialModeCommon::ACommonFunction(mode);

And it should call the correct function and do the processing correctly. And in my hundreds of locations I only need to put one line of code.

I like this solution. It doesn't require any special casting or checking of types at runtime. I can re-use a fair amount of the code.

Thanks for all the help.