{"id":928,"date":"2024-08-09T20:25:02","date_gmt":"2024-08-09T20:25:02","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=928"},"modified":"2025-01-26T18:49:53","modified_gmt":"2025-01-26T18:49:53","slug":"inheritance","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/inheritance\/","title":{"rendered":"Inheritance"},"content":{"rendered":"\n

<\/span>Inheritance<\/span><\/h2>\n\n\n\n

<\/span>Overview<\/span><\/h3>\n\n\n\n

We have a fair amount to cover about Inheritance in C++<\/p>\n\n\n\n

    \n
  • Base and Derived Classes<\/li>\n\n\n\n
  • Access Control and Derivation\n
      \n
    • Member Access from Derived Classes<\/li>\n\n\n\n
    • protected<\/strong> Class Members<\/li>\n\n\n\n
    • Access Declarations<\/li>\n<\/ul>\n<\/li>\n\n\n\n
    • Inheritance and Constructors  <\/li>\n\n\n\n
    • Inheritance and Destructors<\/li>\n\n\n\n
    • Inherited Member Functions<\/li>\n\n\n\n
    • Non-inherited Member Functions<\/li>\n\n\n\n
    • Upcasting and Downcasting<\/li>\n<\/ul>\n\n\n\n

      So, let’s get on to those topics…<\/p>\n\n\n\n

      <\/span>Base and Derived Classes<\/span><\/h3>\n\n\n\n

      A class can inherit the features or functionality of another class through class derivation<\/em>.<\/p>\n\n\n\n

        \n
      • The class that inherits is called the derived class<\/em>. <\/li>\n\n\n\n
      • The class that is inherited from is called the base class<\/em>.<\/li>\n<\/ul>\n\n\n\n

        A class can be derived to :<\/p>\n\n\n\n

          \n
        • Restrict<\/em> or reinterpret<\/em> the base class.<\/li>\n\n\n\n
        • Factor out common functionality<\/em> for reuse.<\/li>\n\n\n\n
        • Specialize<\/em> or augment<\/em> the base class to add a new layer of functionality<\/li>\n<\/ul>\n\n\n\n

          The syntax is:<\/p>\n\n\n\n

          class Base \n{   \n\t\/\/ Base class members \n};\n\nclass Derived : public Base \/\/ inherits from Base<\/strong>\n{  \n\t\/\/ Derived class members \n};\n<\/code><\/pre>\n\n\n\n
          <\/span>Example<\/span><\/h4>\n\n\n\n
          \n
          \n
          This declares two classes: Student and GradStudent. GradStudent is a class derived from class Student<\/p>\n\n\n\n
          <\/path><\/path><\/svg><\/span>
          \/\/<\/span><\/span>\n\/\/  Student.hpp<\/span><\/span>\n\/\/  Base and Derived Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Student_hpp<\/span><\/span>\n#define<\/span> Student_hpp<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><string><\/span><\/span>\n<\/span>\n\/\/ Student.h<\/span><\/span>\nclass<\/span> <\/span>Student<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Student<\/span>(<\/span>const<\/span> <\/span>int<\/span>  <\/span>id<\/span>,<\/span><\/span>\n          <\/span>const<\/span> <\/span>std<\/span>::<\/span>string<\/span> <\/span>&<\/span>name<\/span>);<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>double<\/span> <\/span>GetGPA<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>void<\/span> <\/span>SetGPA<\/span>(<\/span>double<\/span> <\/span>gpa<\/span>);<\/span><\/span>\n  \/\/ ...<\/span><\/span>\nprivate:<\/span><\/span>\n   <\/span>int<\/span>         m_id;<\/span>  \/\/ Student ID<\/span><\/span>\n   <\/span>std<\/span>::string m_name;<\/span> \/\/ Student name<\/span><\/span>\n   <\/span>double<\/span>      m_gpa;<\/span> \/\/ Grade Point Average<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>GradStudent<\/span> : <\/span>public<\/span> <\/span>Student<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>GradStudent<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>id<\/span>,<\/span><\/span>\n              <\/span>const<\/span> <\/span>std<\/span>::<\/span>string<\/span> <\/span>&<\/span>name<\/span>,<\/span><\/span>\n              <\/span>const<\/span> <\/span>std<\/span>::<\/span>string<\/span> <\/span>&<\/span>dept<\/span>);<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>const<\/span> <\/span>std<\/span>::<\/span>string<\/span> <\/span>&<\/span>GetThesisTitle<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>void<\/span> <\/span>SetThesisTitle<\/span>(<\/span>std<\/span>::<\/span>string<\/span> <\/span>&<\/span>thesis_title<\/span>);<\/span><\/span>\n  \/\/ ...<\/span><\/span>\nprivate:<\/span><\/span>\n   <\/span>std<\/span>::string  m_dept;<\/span>         \/\/ Department<\/span><\/span>\n   <\/span>std<\/span>::string  m_thesis_title;<\/span> \/\/ Thesis title<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Student_hpp *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
          \n
          A class derived from <\/em><\/strong>class X<\/strong> is a kind of<\/em>  (or is a<\/em>) X<\/strong>.<\/p>\n\n\n\n
          A class containing<\/em><\/strong> a member of class Y<\/strong> has a<\/em> Y<\/strong>.<\/p>\n\n\n\n
          For example, classes Vehicle, Airplane, and Car. Vehicles have a Color, A Car has an Engine, and four Wheels.<\/p>\n\n\n\n
          <\/path><\/path><\/svg><\/span>
          \/\/<\/span><\/span>\n\/\/  Vehicle.hpp<\/span><\/span>\n\/\/  Base and Derived Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/25\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Vehicle_h<\/span><\/span>\n#define<\/span> Vehicle_h<\/span><\/span>\n<\/span>\nenum<\/span> <\/span>class<\/span> <\/span>Color<\/span>{<\/span>White<\/span>, <\/span>Black<\/span>, <\/span>Green<\/span>, <\/span>Blue<\/span>};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Vehicle<\/span><\/span>\n{<\/span><\/span>\n  \/\/ ...<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> max_speed;<\/span><\/span>\n  <\/span>int<\/span>    max_occupants;<\/span><\/span>\n  Color  color;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Airplane<\/span> : <\/span>public<\/span> <\/span>Vehicle<\/span><\/span>\n{<\/span><\/span>\n  \/\/ An Airplane is a Vehicle<\/span><\/span>\n  \/\/ ...<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> m_wingspan;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nenum<\/span> <\/span>class<\/span> <\/span>Engine<\/span>(<\/span>4Cylindar<\/span>, <\/span>8Cylinder<\/span>, <\/span>Rotary<\/span>)<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Car<\/span> : <\/span>public<\/span> <\/span>Vehicle<\/span><\/span>\n{<\/span><\/span>\n  \/\/ A Car is a Vehicle<\/span><\/span>\n  \/\/ ...<\/span><\/span>\n  \/\/ A Car has an Engine, wheels<\/span><\/span>\nprivate:<\/span><\/span>\n  Engine engine;<\/span><\/span>\n  Wheel  <\/span>wheel<\/span>[<\/span>4<\/span>];<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Vehicle_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
          An instance of a derived class can be used anywhere an instance of its base class can be used<\/em>:<\/p>\n\n\n\n
            \n
          • The derived class is a superset<\/em> of the base class and so contains all the members of the base class.<\/li>\n<\/ul>\n\n\n\n
            The reverse is not true<\/em>;  a base class cannot<\/em><\/strong> be used in place of a class derived from it:<\/p>\n\n\n\n
              \n
            • It does not have all the members of the derived class.<\/li>\n<\/ul>\n\n\n\n
              <\/span>Base & Derived Class Conversions<\/span><\/h3>\n\n\n\n
              For example, conversion can take place in one direction only:<\/p>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  Vehicle.cpp<\/span><\/span>\n\/\/  Base and Derived Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/25\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Vehicle.hpp"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>DoConversions<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Vehicle base;<\/span><\/span>\n  Car     derived;<\/span><\/span>\n  <\/span><\/span>\n  base = derived;<\/span><\/span>\n  derived = base;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              This code, given the previous class declarations for Vehicle and Car, produces the following:<\/p>\n\n\n\n
              base = derived compiles correctly.<\/p>\n\n\n\n
              \n
              Note that when a derived class is converted to a base class, the result has lost its derived class members<\/em> — it has been ‘sliced’<\/em>.<\/p>\n<\/blockquote>\n\n\n\n
              but:<\/p>\n\n\n\n
              derived = base produces a compile-time error:<\/p>\n\n\n\n
              Vehicle.cpp:18:11 No viable overloaded '='\n<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
              <\/span>Overriding Class Members<\/span><\/h3>\n\n\n\n
              A derived class can define a member with the same name as a base class  member.<\/p>\n\n\n\n
              This is called overriding<\/em> (or refinement<\/em>).<\/p>\n\n\n\n
              You can override a data member, or a member function:<\/p>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  Base.hpp<\/span><\/span>\n\/\/  Base and Derived Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/25\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Base_h<\/span><\/span>\n#define<\/span> Base_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Base<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Base<\/span>(<\/span>int<\/span> <\/span>i<\/span> = <\/span>0<\/span>) : <\/span>m_i<\/span>(i)  {}<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> m_i;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Derived<\/span> : <\/span>public<\/span> <\/span>Base<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Derived<\/span>(<\/span>int<\/span> <\/span>x<\/span>, <\/span>int<\/span> <\/span>i<\/span>) : <\/span>Base<\/span>(x), <\/span>m_i<\/span>(i) {}<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> m_i;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Base_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  Base.cpp<\/span><\/span>\n\/\/  Base and Derived Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/25\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Base.hpp"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Base<\/span>::<\/span>Print<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << m_i << <\/span>std<\/span>::endl;<\/span>  \/\/ Base m_i<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Derived<\/span>::<\/span>Print<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << m_i << <\/span>std<\/span>::endl;<\/span>  \/\/ Derived m_i<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Base and Derived Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Base.hpp"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  Base <\/span>b<\/span>(<\/span>37<\/span>);<\/span><\/span>\n  Derived <\/span>d<\/span>(<\/span>52<\/span>, <\/span>101<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>b<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>d<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              Produces the following output:<\/p>\n\n\n\n
              37\n101\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
              Can you explain this output?<\/p>\n<\/div>\n<\/div>\n\n\n\n
              <\/span>Class Vector<\/span><\/h4>\n\n\n\n
              Remember our Vector<\/strong> class?<\/p>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  Vector.h<\/span><\/span>\n\/\/  Base & Derived Classes - Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Vector_h<\/span><\/span>\n#define<\/span> Vector_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Vector<\/span> <\/span>\/\/ A vector of ints<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  \/\/ Constructors & destructors<\/span><\/span>\n  <\/span>explicit<\/span> <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>elements<\/span> = <\/span>10<\/span>);<\/span><\/span>\n  <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>Vector<\/span> <\/span>&<\/span>source<\/span>);<\/span><\/span>\n  <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>source<\/span>[],<\/span><\/span>\n         <\/span>const<\/span> <\/span>int<\/span> <\/span>elements<\/span>);<\/span><\/span>\n  <\/span>~Vector<\/span>() { <\/span>delete<\/span> <\/span>[]<\/span> m_p; }<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> <\/span>getElementCount<\/span>() { <\/span>return<\/span> m_elems; }<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Subscript operator overload<\/span><\/span>\n  <\/span>int<\/span> <\/span>&<\/span>operator[]<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>i<\/span>);<\/span><\/span>\n  <\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> *m_p;<\/span>    \/\/ Ptr to array<\/span><\/span>\n  <\/span>int<\/span>  m_elems;<\/span>  \/\/ Alloc. count<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Vector_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  Vector.cpp<\/span><\/span>\n\/\/  Base & Derived Classes - Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Vector.h"<\/span><\/span>\n<\/span>\nVector<\/span>::<\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> elements)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Allocate space for elements<\/span><\/span>\n  m_p = <\/span>new<\/span> <\/span>int<\/span>[m_elems = elements];<\/span><\/span>\n  \/\/ Set all elements to 0<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < m_elems; i++)<\/span><\/span>\n    <\/span>m_p<\/span>[i] = <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nVector<\/span>::<\/span>Vector<\/span>(<\/span>const<\/span> Vector &source)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Allocate space for elements<\/span><\/span>\n  m_p = <\/span>new<\/span> <\/span>int<\/span>[m_elems = <\/span>source<\/span>.<\/span>m_elems<\/span>];<\/span><\/span>\n  \/\/ Copy values from source elements<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < m_elems; i++)<\/span><\/span>\n    <\/span>m_p<\/span>[i] = <\/span>source<\/span>.<\/span>m_p<\/span>[i];<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nVector<\/span>::<\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> source[],<\/span><\/span>\n               <\/span>const<\/span> <\/span>int<\/span> elements)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Allocate space for elements<\/span><\/span>\n  m_p = <\/span>new<\/span> <\/span>int<\/span>[m_elems = elements];<\/span><\/span>\n  \/\/ Copy values from source elements<\/span><\/span>\n  \/\/ (assuming that source is properly sized)<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < m_elems; i++)<\/span><\/span>\n    <\/span>m_p<\/span>[i] = <\/span>source<\/span>[i];<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Subscript operator overload<\/span><\/span>\nint<\/span> <\/span>&<\/span>Vector<\/span>::<\/span>operator[]<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>i<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Do bounds checking...<\/span><\/span>\n  <\/span>if<\/span> ( (i < <\/span>0<\/span>) || (i >= m_elems) )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cerr << <\/span>"Illegal Vector index: "<\/span><\/span>\n              << i << <\/span>" (max: "<\/span><\/span>\n              << (m_elems - <\/span>1<\/span>) << <\/span>')'<\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>exit<\/span>(<\/span>1<\/span>);<\/span>  \/\/ Abrupt exit!<\/span><\/span>\n  }<\/span><\/span>\n  \/\/ We're within bounds<\/span><\/span>\n  <\/span>return<\/span> <\/span>m_p<\/span>[i];<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
              <\/span>Class BoundedVector<\/span><\/h4>\n\n\n\n
              Let’s create a class BoundedVector<\/code> that is, in effect, a more generalized form of the Vector<\/code> class: when an instance is created, the vector bounds are specified. While a Vector instance is created with a specified number of elements, and those elements may be accessed using the subscript operator, with subscripts from 0 to (<number-of-elements> – 1), a BoundedVector<\/code> is created with a low bound and a high bound, and a size calculated from the low and high bounds.<\/p>\n\n\n\n
              The BoundedVector<\/code> class is derived from the Vector<\/code> class, and relies on its base class for some of its features.<\/p>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  BoundedVector.h<\/span><\/span>\n\/\/  Base & Derived Classes - Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> BoundedVector_h<\/span><\/span>\n#define<\/span> BoundedVector_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Vector.h"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>BoundedVector<\/span> : <\/span>public<\/span> <\/span>Vector<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>BoundedVector<\/span>(<\/span>int<\/span> <\/span>low<\/span>, <\/span>int<\/span> <\/span>high<\/span>);<\/span><\/span>\n  <\/span>int<\/span> <\/span>LowBound<\/span>() { <\/span>return<\/span> m_low; }<\/span><\/span>\n  <\/span>int<\/span> <\/span>HighBound<\/span>() { <\/span>return<\/span> m_high; }<\/span><\/span>\n  <\/span>int<\/span> <\/span>&<\/span>operator[]<\/span>(<\/span>int<\/span> <\/span>i<\/span>)<\/span><\/span>\n  { <\/span>return<\/span> <\/span>Vector<\/span>::operator[](i-m_low); }<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span>    m_low;<\/span>  \/\/ Low bound<\/span><\/span>\n  <\/span>int<\/span>    m_high;<\/span>   \/\/ High bound<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* BoundedVector_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  BoundedVector.cpp<\/span><\/span>\n\/\/  Base & Derived Classes - Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"BoundedVector.h"<\/span><\/span>\n<\/span>\n\/\/ Constructor<\/span><\/span>\nBoundedVector<\/span>::<\/span>BoundedVector<\/span>(<\/span>int<\/span> low, <\/span>int<\/span> high)<\/span><\/span>\n  : <\/span>Vector<\/span>((high - low) + <\/span>1<\/span>),<\/span>  \/\/ NOTE!<\/span><\/span>\n    <\/span>m_low<\/span>(low), <\/span>m_high<\/span>(high)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> (low > high)<\/span>      \/\/ Check the bounds<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cerr << <\/span>"<\/span>\\n<\/span>Low bound "<\/span> << low<\/span><\/span>\n              << <\/span>" greater than high bound"<\/span><\/span>\n              << high << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>exit<\/span>(<\/span>0<\/span>);<\/span>      \/\/ Abrupt exit!<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
              Here’s a simple test program for these classes:<\/p>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Base & Derived Classes - Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"BoundedVector.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  Vector         <\/span>values<\/span>(<\/span>6<\/span>);<\/span><\/span>\n  BoundedVector  <\/span>bvalues<\/span>(-<\/span>5<\/span>, <\/span>3<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < <\/span>values<\/span>.<\/span>getElementCount<\/span>(); i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>values<\/span>[i] = i;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Vector contents: "<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < <\/span>values<\/span>.<\/span>getElementCount<\/span>(); i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"["<\/span> << i << <\/span>"] = "<\/span><\/span>\n              << <\/span>values<\/span>[i] << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>bvalues<\/span>.<\/span>LowBound<\/span>(); i <= <\/span>bvalues<\/span>.<\/span>HighBound<\/span>(); i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>bvalues<\/span>[i] = i*i;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"BoundedVector contents: "<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>bvalues<\/span>.<\/span>LowBound<\/span>(); i <= <\/span>bvalues<\/span>.<\/span>HighBound<\/span>(); i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"["<\/span> << i << <\/span>"] = "<\/span><\/span>\n              << <\/span>bvalues<\/span>[i] << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              Which outputs the following:<\/p>\n\n\n\n
              Vector contents: \n[0] = 0\n[1] = 1\n[2] = 2\n[3] = 3\n[4] = 4\n[5] = 5\nBoundedVector contents: \n[-5] = 25\n[-4] = 16\n[-3] = 9\n[-2] = 4\n[-1] = 1\n[0] = 0\n[1] = 1\n[2] = 4\n[3] = 9\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
              <\/span>Member Access Control from Derived Classes<\/span><\/h3>\n\n\n\n
              Remember that a class can use member access control <\/em>to specify access to members from outside the class:<\/p>\n\n\n\n
              class Bumble \n{    \n\tint   a;  \/\/ private \npublic:    \n\tfloat b;  \/\/ public \nprivate:    \n\tlong  c;  \/\/ private    \n\t\/\/ ... \n}; <\/code><\/pre>\n\n\n\n
              An access specifier<\/em> can be applied to a base class reference:<\/p>\n\n\n\n
              class Mumble : public<\/strong> Bumble \n{ \nprivate:    \n\tint   x; \npublic:    \n\tfloat y;    \n\tlong  z;    \n\t\/\/ ... \n};<\/code><\/pre>\n\n\n\n
              which controls what access the derived class will have to the base class members<\/em>.<\/p>\n\n\n\n
              The default access specifier for a base class is:<\/p>\n\n\n\n
                \n
              • private<\/strong> when the derived class is a class<\/strong> <\/li>\n\n\n\n
              • public<\/strong> when the derived class is a struct<\/strong><\/li>\n<\/ul>\n\n\n\n
                If we derive a class using a public<\/strong> base class (public inheritance<\/em>):<\/p>\n\n\n\n
                class Derived : public Base { ... };<\/strong><\/code><\/pre>\n\n\n\n
                then the public members of the base class become publicly accessible through the derived class.<\/p>\n\n\n\n
                If we derive a class using a private<\/strong> base class (private inheritance<\/em>):<\/p>\n\n\n\n
                class Derived : private Base { ... };<\/strong><\/code><\/pre>\n\n\n\n
                then the public members of the base class become privately accessible from within the derived class.<\/p>\n\n\n\n
                Regardless of the base class access specified, private members of a base class are not accessible from within the derived class or through it (unless access is explicitly granted through friend declarations — something to use very sparingly).<\/p>\n\n\n\n
                It’s analogous to a class being a member of another class:<\/p>\n\n\n\n
                class B { ... };\nclass C { ... };\nclass A\n{\npublic:\n\tB\tmy_b;\t\/\/ public members of B \n\t\t\t\/\/ accessible through class A\nprivate:\n\tC\tmy_c;\t\/\/ public members of C not<\/strong> \n\t\t\t\/\/ accessible through class A\n};<\/code><\/pre>\n\n\n\n
                When you inherit from a base class using public<\/strong> inheritance, you have an ‘is-a’ (or ‘is-a-kind-of’) relationship:<\/p>\n\n\n\n
                class Car : public Vehicle { ... };<\/strong><\/code><\/pre>\n\n\n\n
                A Car<\/strong> ‘is-a[-kind-of]’ Vehicle<\/strong>.<\/p>\n\n\n\n
                \n
                But beware!<\/strong><\/p>\n\n\n\n
                When you inherit from a base class not using<\/em> public<\/strong> inheritance, you do not have an ‘is-a’ relationship!<\/em><\/strong><\/p>\n<\/blockquote>\n\n\n\n
                \n
                Unfortunately, the default:<\/p>\n\n\n\n
                class Car : Vehicle { ... };<\/strong><\/code><\/pre>\n\n\n\n
                is equivalent to private<\/em> inheritance:<\/p>\n\n\n\n
                class Car : private Vehicle { ... };<\/strong><\/code><\/pre>\n\n\n\n
                which is not<\/em><\/strong> what you normally want!<\/p>\n<\/blockquote>\n\n\n\n
                For example:<\/p>\n\n\n\n
                private:    \n\tint a; \npublic:    \n\tint b; \t\/\/ Parent1's member functions have \n\t\t\t\/\/ access to:  a<\/strong>, b<\/strong> \n};\t\t\t\/\/ Normal code has access, through\n\t\t\t\/\/ class Parent1, to: b<\/strong>\n\nclass Child1 : private<\/strong> Parent1 { \nprivate:    \n\tint c; \npublic:    \n\tint d; \t\/\/ Child1's member functions have \n\t\t\t\/\/ access to:  b<\/strong>, c<\/strong>, d<\/strong> \n};\t\t\t\/\/ Normal code has access, through \n\t\t\t\/\/ class Child1, to: d<\/strong>\n\nclass Child2 : public<\/strong> Parent1 { \nprivate:    \n\tint e; \npublic:    \n\tint f; \t\/\/ Child2's member functions have \n\t\t\t\/\/ access to:  b<\/strong>, e<\/strong>, f<\/strong> \n};\t\t\t\/\/ Normal code has access, through \n\t\t\t\/\/ class Child2, to:  b<\/strong>, f<\/strong>\n<\/code><\/pre>\n\n\n\n
                <\/span>protected Class Members<\/span><\/h4>\n\n\n\n
                It quickly became apparent that the simple private<\/strong> vs public<\/strong> access control was too ‘all or nothing’ to handle inheritance appropriately. The relationship between a derived class and its base class(es) is often closer than that of a class with the rest of the world.<\/p>\n\n\n\n
                To allow access from derived classes to base class members, it often became necessary to make the base class members public<\/strong>. However, this exposes those members to the rest of the world.  Not good!<\/p>\n\n\n\n
                So, there came into being a third access specifier, protected<\/strong>, which provides a middle ground between private<\/strong> and public<\/strong>:<\/p>\n\n\n\n
                class Bumble\n{\nprivate:\t\/\/ accessible only within class\n\tint a;\nprotected:<\/strong>\t\/\/ ...class or derived classes<\/strong>\n\tfloat b;\npublic:\t    \/\/ ...anyone\n\tlong c;\n\t\/\/ ...\n};<\/code><\/pre>\n\n\n\n
                which can also be applied to a base class (protected inheritance<\/em>):<\/p>\n\n\n\n
                class Mather : protected<\/strong> Blather { ... };<\/code><\/pre>\n\n\n\n
                protected<\/strong> only affects access to base class members from derived classes. <\/p>\n\n\n\n
                Don’t bother using protected<\/strong> in a class if the class will never be used as a base class.  A class needs to be designed to act as a base class.<\/p>\n\n\n\n
                Here’s a summary:<\/p>\n\n\n\n
                Base Class Member Access Specifier<\/em><\/th>public Inheritance<\/em><\/th>protected Inheritance<\/em><\/th>private Inheritance<\/em><\/th><\/tr><\/thead>
                public<\/td>public in derived class<\/em><\/td>protected in derived class<\/em><\/td>private in derived class<\/em><\/td><\/tr>
                protected<\/td>protected in derived class<\/em><\/td>protected in derived class<\/em><\/td>private in derived class<\/em><\/td><\/tr>
                private<\/td>not accessible in derived class<\/em><\/td>not accessible in derived class<\/em><\/td>not accessible in derived class<\/em><\/td><\/tr><\/tbody><\/table>
                Summary of base class member access from a derived class<\/strong><\/figcaption><\/figure>\n\n\n\n
                For example:<\/p>\n\n\n\n
                \n
                \n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  Hierarchy.h<\/span><\/span>\n\/\/  Protected Class Members<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Hierarchy_h<\/span><\/span>\n#define<\/span> Hierarchy_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>A<\/span><\/span>\n{<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> a;<\/span><\/span>\nprotected:<\/span><\/span>\n  <\/span>int<\/span> b;<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>int<\/span> c;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>B<\/span> : <\/span>public<\/span> <\/span>A<\/span><\/span>\n{<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> d;<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>void<\/span> <\/span>Test<\/span>();<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>C<\/span> : <\/span>private<\/span> <\/span>A<\/span><\/span>\n{<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> e;<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>void<\/span> <\/span>Test<\/span>();<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Hierarchy_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                \n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  Hierarchy.cpp<\/span><\/span>\n\/\/  Protected Class Members<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Hierarchy.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>B<\/span>::<\/span>Test<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  a = <\/span>1<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  b = <\/span>2<\/span>;<\/span><\/span>\n  c = <\/span>3<\/span>;<\/span><\/span>\n  d = <\/span>4<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>C<\/span>::<\/span>Test<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  a = <\/span>1<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  b = <\/span>2<\/span>;<\/span><\/span>\n  c = <\/span>3<\/span>;<\/span><\/span>\n  e = <\/span>4<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
                Compile-time errors:<\/p>\n\n\n\n
                Hierarchy.cpp:12:3 'a' is a private member of 'A'\n\nHierarchy.cpp:20:3 'a' is a private member of 'A'\n<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
                \n
                \n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Protected Class Members<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Hierarchy.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  B  myB;<\/span><\/span>\n  C  myC;<\/span><\/span>\n  <\/span>myB<\/span>.<\/span>a<\/span> = <\/span>1<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  <\/span>myB<\/span>.<\/span>b<\/span> = <\/span>2<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  <\/span>myB<\/span>.<\/span>c<\/span> = <\/span>3<\/span>;<\/span><\/span>\n  <\/span>myB<\/span>.<\/span>d<\/span> = <\/span>4<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  <\/span>myC<\/span>.<\/span>a<\/span> = <\/span>1<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  <\/span>myC<\/span>.<\/span>b<\/span> = <\/span>2<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  <\/span>myC<\/span>.<\/span>c<\/span> = <\/span>3<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n  <\/span>myC<\/span>.<\/span>e<\/span> = <\/span>4<\/span>;<\/span>  \/\/ ERROR -- no access<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                \n
                Compile-time errors:<\/p>\n\n\n\n
                main.cpp:14:7 'a' is a private member of 'A'\nmain.cpp:15:7 'b' is a protected member of 'A'\nmain.cpp:17:7 'd' is a private member of 'B'\nmain.cpp:18:7 'a' is a private member of 'A'\nmain.cpp:19:7 'b' is a private member of 'A'\nmain.cpp:20:7 'c' is a private member of 'A'\nmain.cpp:21:7 'e' is a private member of 'C'\n<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
                <\/span>public, private, and protected Inheritance<\/span><\/h4>\n\n\n\n
                public<\/strong> inheritance is used when the inheritance is part of the interface.<\/p>\n\n\n\n
                  \n
                • The fact that X<\/strong> is-a<\/em> Y<\/strong> is something you are willing to tell your clients about.<\/li>\n<\/ul>\n\n\n\n
                  private<\/strong> inheritance is used when the inheritance is not<\/em><\/strong> part of the interface<\/p>\n\n\n\n
                    \n
                  • It is an implementation detail.<\/li>\n\n\n\n
                  • The relationship is more like reuses-a.<\/em><\/li>\n\n\n\n
                  • Rarely used — using composition (member class object) usually works as well, and often is simpler.<\/li>\n<\/ul>\n\n\n\n
                    protected<\/strong> inheritance is used when the inheritance is<\/em><\/strong> part of the interface to the derived classes, but is not<\/em><\/strong> part of the interface to the clients.<\/p>\n\n\n\n
                      \n
                    • Even more rarely used — using composition is usually as good and simpler.<\/li>\n<\/ul>\n\n\n\n
                      <\/span>Inheritance with Constructors and Destructors<\/span><\/h3>\n\n\n\n
                      <\/span>Constructors<\/span><\/h4>\n\n\n\n
                      Constructors are not inherited<\/p>\n\n\n\n
                      A derived class constructor can (and by default will) call base class constructors<\/p>\n\n\n\n
                      Constructors cannot be virtual<\/strong> (see later)<\/p>\n\n\n\n
                      A public<\/strong> default constructor and a  public<\/strong> copy constructor are generated by the compiler where they are needed.<\/p>\n\n\n\n
                      When an instance of a derived class is created:<\/p>\n\n\n\n
                        \n
                      • If the constructor for the derived class does not explicitly call a base class constructor in its initializer list, then the default base class constructor<\/em> is automatically called.  <\/li>\n\n\n\n
                      • If there is no default constructor for the base class, then a compile-time error occurs<\/em>.<\/li>\n\n\n\n
                      • If a base class constructor is explicitly called in the derived class initializer list, then that is the base class constructor executed; there is no default base class constructor initialization.<\/li>\n<\/ul>\n\n\n\n
                        The order of constructor execution is:<\/p>\n\n\n\n
                          \n
                        • Base class constructor(s)<\/em>, in declaration order (independent of initializer list order)<\/li>\n\n\n\n
                        • Derived class member constructor(s)<\/em>, in declaration order (independent of initializer list order) <\/li>\n\n\n\n
                        • The body of the derived class constructor<\/em>.<\/li>\n<\/ul>\n\n\n\n
                          Virtual base classes are a special case (see later).<\/p>\n\n\n\n
                          <\/span>Destructors<\/span><\/h4>\n\n\n\n
                          A destructor cannot be inherited.<\/p>\n\n\n\n
                          A derived class destructor can (and by default will) call its base class destructors.<\/p>\n\n\n\n
                          A destructor can be virtual<\/strong> (see later).<\/p>\n\n\n\n
                            \n
                          • In fact, a base class destructor <\/em>should<\/em><\/strong> be virtual<\/em>.<\/li>\n<\/ul>\n\n\n\n
                            A public<\/strong> default destructor is generated  by the compiler when no destructor is explicitly declared. It calls the destructors for base classes and members of the derived class.<\/p>\n\n\n\n
                            The order of destructor execution is:<\/p>\n\n\n\n
                              \n
                            • The body of the derived class destructor<\/em>.<\/li>\n\n\n\n
                            • Derived class member destructor(s)<\/em>, in reverse declaration order<\/li>\n\n\n\n
                            • Base class destructor(s)<\/em>, in reverse declaration order<\/li>\n<\/ul>\n\n\n\n
                              In other words, the exact opposite of constructor execution order<\/em>.<\/p>\n\n\n\n
                              Virtual base classes are a special case (see later).<\/p>\n\n\n\n
                              Example:<\/p>\n\n\n\n
                              \n
                              \n
                              <\/path><\/path><\/svg><\/span>
                              \/\/<\/span><\/span>\n\/\/  Hierarchy.h<\/span><\/span>\n\/\/  Constructors and Destructors<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Hierarchy_h<\/span><\/span>\n#define<\/span> Hierarchy_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>A<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>A<\/span>();<\/span><\/span>\n  <\/span>~A<\/span>();<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>B<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>B<\/span>();<\/span><\/span>\n  <\/span>~B<\/span>();<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>C<\/span> : <\/span>public<\/span> <\/span>A<\/span> \/\/ C is derived from A<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>C<\/span>();<\/span><\/span>\n  <\/span>~C<\/span>();<\/span><\/span>\nprivate:<\/span><\/span>\n  B b;<\/span> \/\/ Member class object<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>D<\/span> : <\/span>public<\/span> <\/span>C<\/span> \/\/ D is derived from C<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>D<\/span>();<\/span><\/span>\n  <\/span>~D<\/span>();<\/span><\/span>\nprivate:<\/span><\/span>\n  A a;<\/span> \/\/ Member class object<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Hierarchy_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                              \n
                              <\/path><\/path><\/svg><\/span>
                              \/\/<\/span><\/span>\n\/\/  Hierarchy.cpp<\/span><\/span>\n\/\/  Constructors and Destructors<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Hierarchy.h"<\/span><\/span>\n<\/span>\n\/\/ class A<\/span><\/span>\nA<\/span>::<\/span>A<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in A constructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nA<\/span>::~<\/span>A<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in A destructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ class B<\/span><\/span>\nB<\/span>::<\/span>B<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in B constructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nB<\/span>::~<\/span>B<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in B destructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ class C<\/span><\/span>\nC<\/span>::<\/span>C<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in C constructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nC<\/span>::~<\/span>C<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in C destructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ class D<\/span><\/span>\nD<\/span>::<\/span>D<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in D constructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nD<\/span>::~<\/span>D<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"in D destructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                              \n
                              \n
                              <\/path><\/path><\/svg><\/span>
                              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Constructors and Destructors<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Hierarchy.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  D d;<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                              \n
                              Produces the following output:<\/p>\n\n\n\n
                              in A constructor\nin B constructor\nin C constructor\nin A constructor\nin D constructor\nin D destructor\nin A destructor\nin C destructor\nin B destructor\nin A destructor\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
                              Can you explain it?<\/p>\n<\/div>\n<\/div>\n\n\n\n
                              <\/span>Safe & Unsafe Downcasting<\/span><\/h3>\n\n\n\n
                              You can suppress compiler errors resulting from implicit downcasting, by explicitly downcasting, but it’s usually not a good idea:<\/p>\n\n\n\n
                              \n
                              \n
                              <\/path><\/path><\/svg><\/span>
                              \/\/<\/span><\/span>\n\/\/  Header.h<\/span><\/span>\n\/\/  Safe Downcasting<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Header_h<\/span><\/span>\n#define<\/span> Header_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Base<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Base<\/span>() { a = <\/span>10<\/span>; }<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> a;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Derived<\/span> : <\/span>public<\/span> <\/span>Base<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Derived<\/span>() { myValue = <\/span>44<\/span>; }<\/span><\/span>\n  <\/span>double<\/span> <\/span>GetMyValue<\/span>() { <\/span>return<\/span> myValue; }<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> myValue;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Header_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                              \n
                              <\/path><\/path><\/svg><\/span>
                              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Safe Downcasting<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/26\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Header.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>process<\/span>(<\/span>Base<\/span> <\/span>&<\/span>b<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  Derived d;<\/span><\/span>\n  d = (Derived &)b;<\/span>    \/\/ OK, no compile time error<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Derived value = "<\/span> << <\/span>d<\/span>.<\/span>GetMyValue<\/span>() << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  Base b;<\/span><\/span>\n  Derived d;<\/span><\/span>\n  b = d;<\/span>        \/\/ OK, but sliced<\/span><\/span>\n  <\/span>process<\/span>(d);<\/span>   \/\/ No problems<\/span><\/span>\n  <\/span>process<\/span>(b);<\/span>   \/\/ Serious problems!  Why?<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                              \n
                              \n
                              Here’s what the above program produces:<\/p>\n\n\n\n
                              Derived value = 44\nDerived value = 6.95161e-310\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n\n\n\n
                              \n
                              See the problem?<\/p>\n\n\n\n
                              Can you explain it? <\/p>\n\n\n\n
                              What is the problem?<\/p>\n<\/div>\n<\/div>\n\n\n\n
                              Explicit casts from a base class (pointer or reference) are inherently unsafe<\/em>:<\/p>\n\n\n\n
                                \n
                              • You never know what the actual class instance really is<\/li>\n\n\n\n
                              • If it’s not the type you’re casting it to, then bad things will happen!<\/li>\n\n\n\n
                              • If it hurts, stop doing it!<\/em><\/strong><\/li>\n<\/ul>\n\n\n\n
                                But there are situations where you really need to do this. (Although I would think hard about whether you really want to do it!)<\/p>\n\n\n\n
                                How can we do this, and retain safety?<\/p>\n\n\n\n
                                We would like some kind of mechanism where, if the cast isn’t valid, a run-time error will occur.<\/p>\n\n\n\n
                                <\/span>dynamic_cast<\/strong><\/span><\/h4>\n\n\n\n
                                The ISO C++ committee invented the dynamic_cast<\/strong> for such situations:<\/p>\n\n\n\n
                                Shape *s = ...\nRectangle *r = dynamic_cast<Rectangle *>(s)<\/strong>;\nif (r != 0)\n\t\t\/\/ The object pointed to by s is a\n\t\t\/\/ Rectangle, and r points to it\nelse\n\t\t\/\/ The object pointed to by s is not a\n\t\t\/\/ Rectangle, and r is a null pointer<\/code><\/pre>\n\n\n\n
                                In general, the form of a dynamic_cast<\/strong> is:<\/p>\n\n\n\n
                                dynamic_cast<T>(v)<\/strong><\/code><\/pre>\n\n\n\n
                                where T<\/strong> is a type (subject to some restrictions), and v<\/strong> is an expression.<\/p>\n\n\n\n
                                \n
                                Note that <\/strong>dynamic_cast<\/strong> is not limited to downcasting.<\/p>\n<\/blockquote>\n\n\n\n
                                The type T<\/strong> must be:<\/p>\n\n\n\n
                                  \n
                                • A pointer to a complete class type<\/em>, in which case:\n
                                    \n
                                  • v<\/strong> must be an rvalue of a pointer to a complete class type<\/li>\n\n\n\n
                                  • the result is an rvalue of type T<\/strong><\/li>\n\n\n\n
                                  • if the cast fails, the result is a null pointer;<\/em>  you have to test for it!<\/em><\/li>\n\n\n\n
                                  • This case is like a test in your program.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                  • or a reference to a complete class type<\/em>, in which case:\n
                                      \n
                                    • v<\/strong> must be an lvalue of a complete class type<\/li>\n\n\n\n
                                    • the result is an lvalue of the type referred to by T<\/strong><\/li>\n\n\n\n
                                    • if the cast fails, a bad_cast<\/strong> <\/strong>exception occurs;<\/em>  you have to catch it!<\/em><\/li>\n\n\n\n
                                    • This case is like an assertion;  if it fails, then you get an exception. (More about exceptions, later…)<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                    • or a “pointer to cv<\/em> void<\/strong>“. (“cv” here is a shorthand for “possibly cv-qualified”, which means “may have a const<\/code> or a volatile<\/code> on it”) — Now, we’re really getting down into the weeds. Let’s ignore this for now…<\/em><\/li>\n<\/ul>\n\n\n\n
                                      <\/span>Summary<\/span><\/h2>\n\n\n\n
                                      Well, we’ve learned quite a bit about inheritance<\/em>:<\/p>\n\n\n\n
                                        \n
                                      • Base and Derived classes<\/li>\n\n\n\n
                                      • Access Control and Derivation\n
                                          \n
                                        • Member Access from Derived classes<\/li>\n\n\n\n
                                        • protected<\/strong> class members<\/li>\n\n\n\n
                                        • Access declarations<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                        • Inheritance and Constructors<\/li>\n\n\n\n
                                        • Inheritance and Destructors<\/li>\n\n\n\n
                                        • Inherited Member Functions<\/li>\n\n\n\n
                                        • Non-inherited Member Functions<\/li>\n\n\n\n
                                        • Upcasting and Downcasting<\/li>\n<\/ul>\n\n\n\n
                                          All of the above discussion was about single inheritance<\/em>.  We’ll see later the considerable complexities introduced by multiple inheritance<\/em>…<\/p>\n\n\n\n
                                          Onward!<\/p>\n","protected":false},"excerpt":{"rendered":"
                                          Inheritance Overview We have a fair amount to cover about Inheritance in C++ So, let’s get on to those topics… Base and Derived Classes A class can inherit the features or functionality of another class through class derivation. A class can be derived to : The syntax is: Example This declares two classes: Student and […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":910,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-928","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/928","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=928"}],"version-history":[{"count":20,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/928\/revisions"}],"predecessor-version":[{"id":1924,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/928\/revisions\/1924"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/910"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=928"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}