title: Is multiple inheritance from the same base class via different parent classes really an issue here?
body: <p>I want to implement an inheritance hierarchy in my C++ game engine that has some analogies from Java:</p>
  
  <ul>
  <li>all objects inherit from <code>Object</code> class,</li>
  <li>some functionality is provided by interfaces.</li>
  </ul>
  
  <p>It's <strong>just an analogy</strong> that gives me some benefits (<strong>not a strict 1:1 Java:C++ mapping</strong> which is not possible). </p>
  
  <p><strong>By "interface" I mean here a class with only pure virtual, public methods.</strong> I know that it's not a strict and precise definition of it.</p>
  
  <p>So I've made:</p>
  
  <pre><code>class Object{...};
  
  /* interfaces */
  class Nameable : public Object{...};
  class Moveable : public Object{...};
  class Moveable3D : public Moveable{...};
  class Moveable2D : public Moveable{...};
  
  class Model3D : public Moveable3D, public Nameable{...}
  class Line3D : public Moveable3D{...}
  class Level: public Nameable{...}
  class PathSolver : public Object{...}
  </code></pre>
  
  <p>As you can see, <code>Model3D</code> now inherits from <code>Object</code> via multiple ways:</p>
  
  <ul>
  <li><code>Moveable3D -&gt; Moveable -&gt; Object</code>,</li>
  <li><code>Nameable -&gt; Object</code>.</li>
  </ul>
  
  <p>And my compiler in VS2013 (VC++) <strong>warns me about it</strong>.</p>
  
  <p><strong>Is that an issue?</strong> </p>
  
  <p><strong>If so, how to solve it to get a better inheritance structure?</strong></p>
  
  <p>I was thinking about two ways, but both have more disadvantages then advantages:</p>
  
  <ol>
  <li>Dropping the inheritance between e.g. <code>Nameable</code> and <code>Object</code>. But that way <code>Level</code> would lost its inheritance from <code>Object</code> too (and my first goal was: <em>all objects inherit from <code>Object</code> class</em>). </li>
  <li>I could also drop <code>: public Object</code> <strong>from each interface</strong>. But that way I would be force to manually type <code>:public Object</code> in each of many engine final classes (<code>Model3D</code>, <code>Line3D</code>, <code>Level</code>, <code>PathSolver</code>). <strong>That way both refactoring and creating new final types would be harder.</strong> Moreover the information that each interface will be guaranteed to inherit from <code>Object</code> is lost that way.</li>
  </ol>
  
  <p>I would like to avoid virtual inheritance (one level of abstraction further) <strong>if</strong> it's not necessary. But maybe it is (at least for <code>: public Object</code>)?</p>