title: Do Sub-Classes Really Inherit Private Member Variables?
body: <p>Basically as far as I know, when you create a base class with a public, protected, and private section and variables/functions in each the public and protected sections will get inherited into the appropriate section of the sub-class (defined by class subclass : private base, which will take all public and protected members of base and put them into public, changing the word private to public puts them all in public and changing it to protected puts them all into protected).</p>
  
  <p>So, when you create a sub-class you never receive anything from the private section of the previous class (the base class in this case), if this is true then an object of the sub-class should never have it's own version of a private variable or function from the base class correct?</p>
  
  <p>Let's run over an example:</p>
  
  <pre><code>#include &lt;iostream&gt;
  
  class myClass     // Creates a class titled myClass with a public section and a private section.
  {
  public:
    void setMyVariable();
    int getMyVariable();
  private:
    int myVariable;     // This private member variable should never be inherited.
  };
  
  class yourClass : public myClass {};    // Creates a sub-class of myClass that inherits all the public/protected members into  the
  // public section of yourClass. This should only inherit setMyVariable()
  // and getMyVariable() since myVariable is private. This class does not over-ride any
  // functions so it should be using the myClass version upon each call using a yourClass
  // object. Correct?
  
  int main()
  {
    myClass myObject;           // Creates a myClass object called myObject.
    yourClass yourObject;       // Creates a yourClass object called yourObject
    yourObject.setMyVariable(); // Calls setMyVariable() through yourObject. This in turn calls the myClass version of it    because
    // there is no function definition for a yourClass version of this function. This means that this
    // can indeed access myVariable, but only the myClass version of it (there isn't a yourClass
    // version because myVariable is never inherited).
  
    std::cout &lt;&lt; yourObject.getMyVariable() &lt;&lt; std::endl;   // Uses the yourClass version of getMyVariable() which in turn
    // calls the myClass version, thus it returns the myClass myVariable
    // value. yourClass never has a version of myVariable Correct?
  
    std::cout &lt;&lt; myObject.getMyVariable() &lt;&lt; std::endl;     // Calls the myClass version of getMyVariable() and prints myVariable.
  
    return 0;
  }
  
  void myClass::setMyVariable()
  {
    myVariable = 15;        // Sets myVariable in myClass to 15.
  }
  
  int myClass::getMyVariable()
  {
    return myVariable;      // Returns myVariable from myClass.
  }
  </code></pre>
  
  <p>Now, in theory based on what I think, this should print:
  15
  15
  Due to it simply always using the myClass version of the functions (thus using the myClass myVariable). But, strangely, this is not the case. The result of running this program prints:
  15
  0
  This makes me wonder, are we actually not only inheriting myVariable, but do we also have the ability to mess around with it? Clearly this is creating an alternate version of myVariable somehow otherwise there wouldn't be a 0 for the myClass version. We are indeed editing a second copy of myVariable by doing all this.</p>
  
  <p>Can someone please explain this all to me, this has torn apart my understanding of inheritance.</p>