Am I in a specific case justifying multiple inheritance?

Question

Currently, I have the following classes managing different kinds of variables :

class Variable;
class Number : public Variable;
class Boolean : public Variable;
class RealNumber : public Number;
class IntegerNumber : public Number;

This is a classical inheritance tree, and it works well. I manage vectors of Number* instances and vectors of Boolean* instances.

I would like to add another type of variable : a 'virtual variable' with a specific behaviour but a similar interface. Then, I want to work with vectors of 'virtual numbers' and vectors of 'virtual booleans'.

A first solution is adding a flag in Variable, but I prefer the compilation security and manage std::vector<VirtualResponse*> and std::vector<VirtualBoolean*> in order to have the guarantee the variables are virtual in the vector.

Then, I think maybe I am in a specific case where multiple inheritance is justified, but I'm new with multiple inheritance. What do you think about this kind of classes ?

class VirtualVariable : public virtual Variable;
class VirtualNumber : public virtual Number, public virtual VirtualVariable;
class VirtualBoolean : public virtual Boolean, public virtual VirtualVariable;
class VirtualRealNumber : public virtual RealNumber, public virtual VirtualNumber;
class VirtualIntegerNumber : public virtual IntegerNumber, public virtual VirtualVariable;

Is it a classical way to do that ? Could it be a trap ? Do I abuse of the virtual key-word ?

EDIT: example of what I want to do :

void my_function(const std::vector<SpecItem>& spec)
{
  // First : create the description from the spec
  std::vector<Number*> descr;
  std::vector<VirtualNumber*> virt_descr;
  for(unsigned long int i = 0; i < spec.size(); ++i)
  {
    if(spec[i].isNumber())
      if(spec[i].isReal())
      {
        double lower_bound = spec[i].lowerBound();
        double upper_bound = spec[i].upperBound();
        if(spec[i].isVirtual())
        {
          std::string formula = spec[i].formula();
          virt_descr.push_back(new VirtualRealNumber(lower_bound,upper_bound,formula));
        }
        else
          descr.push_back(new RealNumber(lower_bound,upper_bound));
      }
      else if(spec[i].isInteger())
      {
        long int lower_bound = ceil(spec[i].lowerBound());
        long int upper_bound = floor(spec[i].upperBound());
        if(spec[i].isVirtual())
        {
          std::string formula = spec[i].formula();
          virt_descr.push_back(new VirtualIntegerNumber(lower_bound,upper_bound,formula));
        }
        else
          descr.push_back(new IntegerNumber(lower_bound,upper_bound));
      }
  }
  // Now, descr is a vector of Number*, virt_descr is a vector of VirtualNumber*

  // Second step : assign values to the numbers
  std::vector<double> values;
  for(unsigned long int i = 0; i < descr.size(); ++i)
  {
    double new_value = (descr[i]->lowerBound() + descr[i]->upperBound()) / 2.0;
    values.push_back(descr[i]->adjust(new_value));
  }

  // Third step : evaluate virtual numbers
  std::vector<double> virt_values;
  for(unsigned long int i = 0; i < virt_descr.size(); ++i)
  {
    double new_value = virt_descr[i]->evaluate(values);
    values.push_back(descr[i]->adjust(new_value));
  }

  return 0;
}

Answer 1

Multiple inheritance is meant to favour clean design by ensuring separation of concerns. So it can be perfectly justified.

It's difficult to advise on the best possible class design without knowing more about the reasons and the constraints. But there are some questions that may help you.

It starts at the line:

    class VirtualVariable : public virtual Variable;

1) Do you need virtual inheritance ?

Multiple inheritance is really simple and fun until you come to virtual inheritance. It means that for a class inheriting several times from VirtualVariable, all the VirtualVariable sub-object instances would share a single Variable base object. For more information, read on the diamond problem.

In your design, you might need it for every inheritance of Variable (including for the non "Virtual" ones) in order to avoid having several Variable subobjects, where you really should have only one. You shouldn't need it for the other inheritance.

This virtual inheritance will require that, for every constructor, you explicitly initialize your virtual base.

2) What is the real relation between Variable and VirtualVariable ?

According to your explanation, I've understood that the "Virtuality" concept is independent of the "Variable" concept. On the other hand, in your code you pretend that VirtualVariable is a Variable.

If it is something independent you should keep it independent. This would be better separation of concerns. The good news is that you then no longer need virtual inheritance:

class Virtuality;     
class VirtualVariable : public Variable, public Virtuality;
class VirtualNumber : public Number, public Virtuality;
class VirtualBoolean : public Boolean, public Virtuality;
class VirtualRealNumber : public RealNumber, public Virtuality;
class VirtualIntegerNumber : public IntegerNumber, public Virtuality;

3) Have you looked at templates ?

You said:

A first solution is adding a flag in Variable, but I prefer the compilation security and manage

If it's only for compilation type checking, you could use templates:

template <bool isvirtual>
Variable { ...};
template <bool isvirtual>
class Number :  Variable<isvirtual> { ...};
...
std::vector<Number<true>*> v; 

For more complex things than just a variable, you could use policy based design. Roughly speaking, instead of providing a bool as template parameter, you provide a utility class as parameter, the class encapsulating a family of behaviors.

EDIT: for your edit

Solution 2 and 3 should perfectly be able to implement what you intend to do.

I have posted here an online demo of solution 2 with polymorphism to demonstrate how easily you could mix "Virtual" and non "Virtual" elements. It defines a function IntegerNumber add (IntegerNumber &a, IntegerNumber&b);, and uses it in this scenario:

IntegerNumber n(27);  // number with an inital value
VirtualIntegerNumber k;   // value will be calculated from some formula 
add (n, k);            // ok, my demo just displays the value of each parameter ;-)

*By the way, I think that the constructs if (isxxx())... if (isyyy()) ... in your code strongly suggest that you should use polymorphism.

Answer 2

I try to avoid multiple inheritance as every possible. Its sound like you want an object what acts like the base objects but with changes for specific cases. Sounds like a class specification. I am not sure whats your goal but maybe you can change your design to a classical hierarchy model. To achieve this make all specific code in seperate functions and call then in the base class.

class Number : public Variable
{
    ...
    protected:
        virtual void functionWithSpecialUsage() { // Empty in base class, used by inheritance only };
}

class VirtualNumber : public Number
{
    ...
    protected:
        void functionWithSpecialUsage() { // Add class specific behavior here };
}