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

<\/span>Polymorphism<\/span><\/h2>\n\n\n\n

<\/span>Forms of Polymorphism<\/span><\/h3>\n\n\n\n

In C++, there are three forms of polymorphism:<\/p>\n\n\n\n

    \n
  • Overloading<\/em>:  the same function name may be overloaded, using different signatures (also known as ad hoc <\/em>polymorphism)<\/li>\n\n\n\n
  • Parameterized Polymorphism<\/em>: (see later, class templates<\/em>) <\/li>\n\n\n\n
  • Pure Polymorphism:<\/em> selection of a function at run time, based on the class type and its position in an inheritance hierarchy.  <\/li>\n<\/ul>\n\n\n\n

    Here we are concerned with pure polymorphism<\/em>.<\/strong><\/p>\n\n\n\n

    <\/span>What’s the Problem we’re Solving?<\/span><\/h3>\n\n\n\n

    Imagine that we have a Fruit<\/strong> class, and two classes, Kiwi<\/strong> and Kumquat<\/strong>, derived from it:<\/p>\n\n\n\n

    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Fruits.h<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Fruits_h<\/span><\/span>\n#define<\/span> Fruits_h<\/span><\/span>\n<\/span>\n\/\/  fruits.h<\/span><\/span>\nclass<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Fruit"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kiwi<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Kiwi"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kumquat<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Kumquat"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Fruits_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Assume we wish to represent a collection of Fruits using a linked list:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  FruitList.h<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> FruitList_h<\/span><\/span>\n#define<\/span> FruitList_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Fruits.h"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>FruitList<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>FruitList<\/span>(<\/span>Fruit<\/span> <\/span>*<\/span>fruit<\/span>, <\/span>FruitList<\/span> <\/span>*<\/span>list<\/span> = <\/span>0<\/span>)<\/span><\/span>\n    : <\/span>m_elem<\/span>(fruit), <\/span>m_next<\/span>(list)<\/span>  \/\/ add to front of list<\/span><\/span>\n  {}<\/span><\/span>\n  <\/span>~FruitList<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span>  \/\/ Print out list contents<\/span><\/span>\nprivate:<\/span><\/span>\n  FruitList  *m_next;<\/span>  \/\/ next FruitList in list<\/span><\/span>\n  Fruit      *m_elem;<\/span>  \/\/ ptr to current fruit<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* FruitList_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  FruitList.cpp<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"FruitList.h"<\/span><\/span>\n<\/span>\nFruitList<\/span>::~<\/span>FruitList<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Clean up...<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>FruitList<\/span>::<\/span>Print<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>const<\/span> FruitList *ptr = <\/span>this<\/span>;<\/span><\/span>\n       ptr != <\/span>0<\/span>;<\/span><\/span>\n       ptr = <\/span>ptr<\/span>-><\/span>m_next<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>ptr<\/span>-><\/span>m_elem<\/span>-><\/span>Type<\/span>()<\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    And we have a program to test this out:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"FruitList.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  FruitList *list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Fruit, <\/span>0<\/span>);<\/span><\/span>\n                       \/\/ A lone Fruit entry<\/span><\/span>\n  list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Kiwi, list);<\/span><\/span>\n                       \/\/ Kiwi -> Fruit<\/span><\/span>\n  list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Kumquat, list);<\/span><\/span>\n                       \/\/ Kumquat -> Kiwi -> Fruit<\/span><\/span>\n  <\/span>list<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
    We expect the output to reflect the specific kinds of Fruit we have in the list.<\/p>\n\n\n\n
    \n
    \n
    But the program outputs:<\/p>\n\n\n\n
    Fruit\nFruit\nFruit\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n\n\n\n
    \n
    What’s wrong?<\/p>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>The Solution: virtual Functions<\/span><\/h3>\n\n\n\n
    The problem is that the compiler took us literally when we said, in the FruitList<\/strong> class:<\/p>\n\n\n\n
    Fruit *elem;<\/strong><\/code><\/pre>\n\n\n\n
    We need some way of telling the compiler that this means “Pointer to a Fruit<\/strong>, or anything derived from <\/em>Fruit<\/strong>“, so that it can invoke the proper Type()<\/strong> member function at run time.<\/p>\n\n\n\n
    Enter virtual functions<\/em>:<\/p>\n\n\n\n
    \n
    \n
    We simply add the keyword virtual in front of the Type() function:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Fruits.h<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Fruits_h<\/span><\/span>\n#define<\/span> Fruits_h<\/span><\/span>\n<\/span>\n\/\/  fruits.h<\/span><\/span>\nclass<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Fruit"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kiwi<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Kiwi"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kumquat<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Kumquat"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Fruits_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    … and the program now works as we expected:<\/p>\n\n\n\n
    Kumquat\nKiwi\nFruit\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
    What happened?<\/p>\n\n\n\n
    The code in the Print()<\/strong> member function:<\/p>\n\n\n\n
    ptr->elem->Type()<\/strong><\/code><\/pre>\n\n\n\n
    now determines the type of *elem<\/strong> at run time, and from it figures out which Type()<\/strong> function to invoke.<\/p>\n\n\n\n
    A class that declares or inherits a virtual function is called a Polymorphic Class<\/em>.<\/p>\n\n\n\n
    \n
    The virtual<\/code><\/strong> keyword can be used when declaring overriding functions in a derived class, but it is unnecessary; overrides of virtual functions are always virtual.<\/p>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Another Example: Vector & BoundedVector<\/span><\/h3>\n\n\n\n
    Remember our old standby, the Vector<\/strong> class, and its derivative, BoundedVector<\/strong>?   <\/p>\n\n\n\n
    \n
    \n
    We had some code that looked like:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Polymorphic Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/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 produced output like this:<\/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
    \n
    \n
    Imagine we wanted to reduce some of the redundant code, to<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Polymorphic Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/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>\nvoid<\/span> <\/span>Print<\/span>(<\/span>const<\/span> <\/span>Vector<\/span> <\/span>&<\/span>v<\/span>, <\/span>int<\/span> <\/span>low<\/span>, <\/span>int<\/span> <\/span>high<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = low; i <= high; i++)<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"["<\/span> << i << <\/span>"] = "<\/span> << <\/span>v<\/span>[i] << <\/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  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>Print<\/span>(values, <\/span>0<\/span>, <\/span>values<\/span>.<\/span>getElementCount<\/span>() - <\/span>1<\/span>);<\/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>Print<\/span>(bvalues, <\/span>bvalues<\/span>.<\/span>LowBound<\/span>(), <\/span>bvalues<\/span>.<\/span>HighBound<\/span>());<\/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
    and to cause everything to compile, I had to change one small thing here:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Vector.h<\/span><\/span>\n\/\/  Polymorphic Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/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  \/\/ Default constructor<\/span><\/span>\n  <\/span>explicit<\/span> <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>elements<\/span> = <\/span>10<\/span>);<\/span><\/span>\n  \/\/ Copy constructor<\/span><\/span>\n  <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>Vector<\/span> <\/span>&<\/span>source<\/span>);<\/span><\/span>\n  \/\/ Destructor<\/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>int<\/span> <\/span>i<\/span>) <\/span>const<\/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<\/div>\n\n\n\n
    \n
    \n
    … and:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Vector.cpp<\/span><\/span>\n\/\/  Polymorphic Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span><assert.h><\/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>\n\/\/ Copy Constructor<\/span><\/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>\nint<\/span> <\/span>&<\/span>Vector<\/span>::<\/span>operator[]<\/span>(<\/span>int<\/span> <\/span>i<\/span>) <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Do bounds checking...<\/span><\/span>\n  <\/span>assert<\/span>( (i >= <\/span>0<\/span>) && (i < m_elems) );<\/span><\/span>\n<\/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\n\n\n
    \n
    … and:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  BoundedVector.h<\/span><\/span>\n\/\/  Polymorphic Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/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  \/\/ Constructor<\/span><\/span>\n  <\/span>BoundedVector<\/span>(<\/span>int<\/span> <\/span>low<\/span>, <\/span>int<\/span> <\/span>high<\/span>);<\/span><\/span>\n  <\/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>const<\/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<\/div>\n\n\n\n
    \n
    \n
    … and:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  BoundedVector.cpp<\/span><\/span>\n\/\/  Polymorphic Vector<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/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\n\n\n
    \n
    So, when we run the program, now we get:<\/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] = Assertion failed: ((i >= 0) && (i < m_elems)), function operator[], file Vector.cpp, line 34.<\/code><\/pre>\n\n\n\n
    In other words, the Print() function called by the main program worked for the Vector, but failed for the BoundedVector.<\/p>\n\n\n\n
    Why? How would you fix it?<\/p>\n\n\n\n
    \n
    Hint:<\/strong> Adding a single word to the declaration for a member function in the Vector class will fix it.<\/p>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Another Important Case<\/span><\/h3>\n\n\n\n
    Let’s go back to the Fruit<\/code>s example, and make some modifications.  Let’s change the FruitList<\/strong> class so that its destructor cleans up the list and its fruits:<\/p>\n\n\n\n
    \n
    \n
    Let’s change the FruitList class, so that its destructor cleans up the list and its Fruits:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  FruitList.cpp<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"FruitList.h"<\/span><\/span>\n<\/span>\nFruitList<\/span>::~<\/span>FruitList<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>delete<\/span> m_elem;<\/span>  \/\/ delete this one's fruit<\/span><\/span>\n  <\/span>if<\/span> (m_next != <\/span>0<\/span>)<\/span><\/span>\n    <\/span>delete<\/span> m_next;<\/span>  \/\/ delete next in list<\/span><\/span>\n        \/\/ How does this work?<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span>\nvoid<\/span> <\/span>FruitList<\/span>::<\/span>Print<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>const<\/span> FruitList *ptr = <\/span>this<\/span>;<\/span><\/span>\n       ptr != <\/span>0<\/span>;<\/span><\/span>\n       ptr = <\/span>ptr<\/span>-><\/span>m_next<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>ptr<\/span>-><\/span>m_elem<\/span>-><\/span>Type<\/span>()<\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    We also add some explicit destructors for Fruit, Kiwi, and Kumquat, so we can instrument them with output:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Fruits.h<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Fruits_h<\/span><\/span>\n#define<\/span> Fruits_h<\/span><\/span>\n<\/span>\n\/\/  fruits.h<\/span><\/span>\nclass<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>~Fruit<\/span>();<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Fruit"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kiwi<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span>  <\/span><\/span>\n  <\/span>~Kiwi<\/span>();<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Kiwi"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kumquat<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>~Kumquat<\/span>();<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Kumquat"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Fruits_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Fruits.cpp<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Fruits.h"<\/span><\/span>\n<\/span>\nFruit<\/span>::~<\/span>Fruit<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"In ~Fruit()"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nKiwi<\/span>::~<\/span>Kiwi<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"In ~Kiwi()"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nKumquat<\/span>::~<\/span>Kumquat<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"In ~Kumquat()"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Finally, we add a line of code to the main program, so that the program cleans up after itself by deleting the allocated list<\/strong>:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"FruitList.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  FruitList *list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Fruit, <\/span>0<\/span>);<\/span><\/span>\n                       \/\/ A lone Fruit entry<\/span><\/span>\n  list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Kiwi, list);<\/span><\/span>\n                       \/\/ Kiwi -> Fruit<\/span><\/span>\n  list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Kumquat, list);<\/span><\/span>\n                       \/\/ Kumquat -> Kiwi -> Fruit<\/span><\/span>\n  <\/span>list<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>delete<\/span> list;<\/span> \/\/ delete allocated list<\/span><\/span>\n  <\/span><\/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
    But the program now outputs the following:<\/p>\n\n\n\n
    Kumquat\nKiwi\nFruit\nIn ~Fruit()\nIn ~Fruit()\nIn ~Fruit()\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n\n\n\n
    \n
    What’s wrong?<\/p>\n\n\n\n
    How would you fix it?<\/p>\n\n\n\n
    \n
    Hint<\/strong>: Again, adding a single keyword to a single declaration of a member function produces the correct output:<\/p>\n\n\n\n
    Kumquat\nKiwi\nFruit\nIn ~Kumquat()\nIn ~Fruit()\nIn ~Kiwi()\nIn ~Fruit()\nIn ~Fruit()\nProgram ended with exit code: 0<\/code><\/pre>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Invoking the virtual Mechanism<\/span><\/h3>\n\n\n\n
    When a virtual member function is invoked like this:<\/p>\n\n\n\n
    void Mumble()\n{\n  Fruit f;\n  cout << \"Type = \" << f.Type() << endl;\n}<\/code><\/pre>\n\n\n\n
    then the Fruit::Type()<\/strong> function is always invoked (i.e. non-virtual).<\/p>\n\n\n\n
    However, when it is invoked like this:<\/p>\n\n\n\n
    void Sub(Fruit &f)\n{\n  cout << \"Type = \" << f.Type()<\/strong> << endl;\n}\n\nvoid Mumble()\n{\n  Kiwi  k;\n  Fruit *f = &k;<\/strong>\n  cout << \"Type = \" << f->Type()<\/strong> << endl;\n  Sub(k);\n}<\/code><\/pre>\n\n\n\n
    then the virtual mechanism is used.<\/p>\n\n\n\n
    <\/span>Summary of virtual Functions<\/span><\/h3>\n\n\n\n
    A function is virtual if it is declared <\/em>virtual<\/strong>, or if there is a base class function with the same signature that is virtual<\/em>.<\/p>\n\n\n\n
      \n
    • The signature match must be exact<\/em><\/li>\n\n\n\n
    • In addition, the return type must also match<\/em>\n
        \n
      • if the return type is a pointer or reference to a class, then special rules apply<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
        The virtual mechanism only works through pointers or references<\/em>.<\/p>\n\n\n\n
        A virtual function must be a non-static member function<\/em> of its class.<\/p>\n\n\n\n
        If a virtual function is defined in a base class, but is not defined in a derived class, then the base class function is the one used.<\/p>\n\n\n\n
        Only the base class needs to specify a member function be virtual<\/strong>.<\/p>\n\n\n\n
          \n
        • A member function of the same signature in a derived class will automatically become virtual<\/strong>.<\/li>\n\n\n\n
        • It is a good idea, however, to repeat the virtual<\/strong> keyword in derived class member functions.<\/li>\n<\/ul>\n\n\n\n
          Remember:<\/p>\n\n\n\n
            \n
          • Overloaded operators that are member functions are no different from any other kind of member functions:  they may need to be virtual<\/strong>, also.<\/li>\n\n\n\n
          • A base class destructor needs to be virtual<\/strong>.  Forget this at your peril!<\/em><\/strong><\/li>\n<\/ul>\n\n\n\n
            <\/span>virtual Function Caveats<\/span><\/h3>\n\n\n\n
            If a member function in a base class is not overridden in the derived class and a function with the same name but different arguments is declared in the derived class, the function in the base class is hidden<\/em>.  <\/p>\n\n\n\n
            For example:<\/p>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            class<\/span> <\/span>Airplane<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n\t\/\/ ...<\/span><\/span>\n\t<\/span>void<\/span> <\/span>Steer<\/span>(<\/span>int<\/span> <\/span>degrees<\/span>);<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>AutoPilot<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n\t<\/span>AutoPilot<\/span>();<\/span><\/span>\n\t\/\/ ...<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Airliner<\/span> : <\/span>public<\/span> <\/span>Airplane<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n\t\/\/ ...<\/span><\/span>\n\t<\/span>void<\/span> <\/span>Steer<\/span>(<\/span>AutoPilot<\/span> <\/span>&<\/span>);\t<\/span><\/span>\n\t\t\/\/ hides Airplane::Steer(int)<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            <\/div>\n<\/div>\n\n\n\n
            \n
            \n
            Virtual functions work differently than you might expect in constructors and destructors:<\/p>\n\n\n\n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Virtual Function Caveats<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Base<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Base<\/span>() { <\/span>InConstr<\/span>(); }<\/span><\/span>\n  <\/span>~Base<\/span>() { <\/span>InDestr<\/span>(); }<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>void<\/span> <\/span>InConstr<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>std<\/span>::cout << <\/span>"In Base::Base()"<\/span> << <\/span>std<\/span>::endl; }<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>void<\/span> <\/span>InDestr<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>std<\/span>::cout << <\/span>"In Base::~Base()"<\/span> << <\/span>std<\/span>::endl; }<\/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>virtual<\/span> <\/span>void<\/span> <\/span>InConstr<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>std<\/span>::cout << <\/span>"In Derived::Derived()"<\/span> << <\/span>std<\/span>::endl; }<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>void<\/span> <\/span>InDestr<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>std<\/span>::cout << <\/span>"In Derived::~Derived()"<\/span> << <\/span>std<\/span>::endl; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Base b;<\/span><\/span>\n  Derived d;<\/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
            This program outputs:<\/p>\n\n\n\n
            In Base::Base()\nIn Base::Base()\nIn Base::~Base()\nIn Base::~Base()\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
              \n
            • When the Base<\/strong> constructor<\/em> executes, the Derived<\/strong> class data members haven’t yet been initialized.<\/li>\n\n\n\n
            • When the Base<\/strong> destructor<\/em> executes, the Derived<\/strong> class data members have already been destroyed.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
              <\/span>Abstract Base Classes<\/span><\/h3>\n\n\n\n
              Sometimes we know the interface to some functionality, but we don’t know the implementation of that interface for every class in a hierarchy. For example, say we have a base class Shape that ‘represents’ different shapes which we will implement as derived classes. We know that every actual Shape that we can implement must have a draw() method, but Shape is too abstract a concept for us to be able to specify the implementation for it.<\/p>\n\n\n\n
              An abstract base class<\/em> is a class that can be used only as a base class for some other class.<\/p>\n\n\n\n
                \n
              • No instances of an abstract base class may be created, except as objects representing a base class of a class derived from it.<\/li>\n<\/ul>\n\n\n\n
                A class is abstract if it has at least one pure virtual function<\/em>:<\/p>\n\n\n\n
                class Fruit\n{\npublic:\n\tvirtual const char *Type() const = 0;<\/strong>\n\t\/\/ Make Fruit an abstract base class\n\t\/\/ (it's too generic to be instantiated here)<\/strong>\n}<\/code><\/pre>\n\n\n\n
                whether that be directly, or through inheritance.<\/p>\n\n\n\n
                \n
                The ‘<\/strong>= 0<\/code>‘<\/strong> is known as a pure-specifier<\/em>, and appears either immediately after the declarator for the virtual function.<\/p>\n<\/blockquote>\n\n\n\n
                So, let’s look at our previous Fruit<\/code>s example:<\/p>\n\n\n\n
                \n
                \n
                First, we make the Fruit::Type() method be pure virtual, and comment out the Kiwi::Type() method, to show the results:<\/p>\n\n\n\n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  Fruits.h<\/span><\/span>\n\/\/  Abstract Base Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/29\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Fruits_h<\/span><\/span>\n#define<\/span> Fruits_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span> = <\/span>0<\/span>;<\/span> \/\/ Pure virtual<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kiwi<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  \/* Intentionally omitted for exposition<\/span><\/span>\n  virtual const char *Type() const<\/span><\/span>\n  { return "Kiwi"; }<\/span><\/span>\n  *\/<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kumquat<\/span> : <\/span>public<\/span> <\/span>Fruit<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Type<\/span>() <\/span>const<\/span><\/span>\n  { <\/span>return<\/span> <\/span>"Kumquat"<\/span>; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Fruits_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                \n
                The other files, Fruits.cpp, FruitList.h, FruitList.cpp, and main.cpp have no changes.<\/p>\n\n\n\n
                But main.cpp no longer compiles:<\/p>\n\n\n\n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Abstract Base Classes<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/29\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"FruitList.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  FruitList *list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Fruit, <\/span>0<\/span>);<\/span><\/span>\n      \/\/ ERROR: Cannot instantiate Fruit<\/span><\/span>\n  list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Kiwi, list);<\/span><\/span>\n      \/\/ ERROR: Cannot instantiate Kiwi<\/span><\/span>\n  list = <\/span>new<\/span> <\/span>FruitList<\/span>(<\/span>new<\/span> Kumquat, list);<\/span><\/span>\n      \/\/ No problem with Kumquat<\/span><\/span>\n  <\/span>list<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
                main.cpp:12:39 Allocating an object of abstract class type ‘Fruit’
                Unimplemented pure virtual method ‘Type’ in ‘Fruit’<\/p>\n\n\n\n
                main.cpp:14:28 Allocating an object of abstract class type ‘Kiwi’
                Unimplemented pure virtual method ‘Type’ in ‘Kiwi’<\/p>\n<\/div>\n<\/div>\n\n\n\n
                In the case of Fruit<\/strong>, this is goodness — class Fruit<\/strong> is too generic to be instantiated.<\/p>\n\n\n\n
                In the case of Kiwi<\/strong>, this is a way of discovering an omission in the class.<\/p>\n\n\n\n
                An abstract base class may not<\/em><\/strong> be used as:<\/p>\n\n\n\n
                  \n
                • a parameter type<\/li>\n\n\n\n
                • a function return type<\/li>\n\n\n\n
                • the type of an explicit conversion<\/li>\n<\/ul>\n\n\n\n
                  However, pointers and references to an abstract base class may be declared.  In fact, this is how they are typically used.<\/p>\n\n\n\n
                  <\/span>Defining and Enforcing an Interface<\/span><\/h3>\n\n\n\n
                  A very useful application of an abstract base class is to define and enforce a common interface that all classes derived from it must supply.<\/p>\n\n\n\n
                  For example:<\/p>\n\n\n\n
                  \n
                  \n
                  <\/path><\/path><\/svg><\/span>
                  typedef<\/span> <\/span>int<\/span> <\/span>Operate<\/span>(<\/span>void<\/span> *context, Containee &);<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Container<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n\t<\/span>virtual<\/span> <\/span>void<\/span> <\/span>add<\/span>(<\/span>Containee<\/span> <\/span>&<\/span>) = <\/span>0<\/span>;<\/span><\/span>\n\t<\/span>virtual<\/span> <\/span>void<\/span> <\/span>remove<\/span>(<\/span>Containee<\/span> <\/span>&<\/span>) = <\/span>0<\/span>;<\/span><\/span>\n\t<\/span>virtual<\/span> <\/span>int<\/span>  <\/span>forAll<\/span>(<\/span>void<\/span> <\/span>*<\/span>context<\/span>,<\/span><\/span>\n\t\t\t                <\/span>Operate<\/span> <\/span>*<\/span>func<\/span>) = <\/span>0<\/span>;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Set<\/span> : <\/span>public<\/span> <\/span>Container<\/span> ( ... }; <\/span><\/span>\n<\/span>\nclass<\/span> <\/span>List<\/span> : <\/span>public<\/span> <\/span>Container<\/span> { ... };<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Dictionary<\/span> : <\/span>public<\/span> <\/span>Container<\/span> { ... };<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                  <\/div>\n<\/div>\n\n\n\n
                  <\/span>The Role of a Base Class Virtual Function<\/span><\/h3>\n\n\n\n
                  A base class virtual function can:<\/p>\n\n\n\n
                    \n
                  • Be non-pure virtual<\/em>\n
                      \n
                    • Useful when the base class provides a commonly used implementation.<\/li>\n\n\n\n
                    • Derived classes may choose to use it, or provide their own.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                    • Be pure virtual with no implementation<\/em>\n
                        \n
                      • Derived classes must provide their own implementation.  There is no ‘default’.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                      • Be pure virtual with an implementation<\/em>\n
                          \n
                        • Derived classes must provide their own implementation.<\/li>\n\n\n\n
                        • The base class implementation may supply a ‘default’ behaviour;  derived classes may choose to use it or augment it (by making an explicit call to the base implementation), or may completely override it.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                          <\/span>Polymorphic Constructors?<\/span><\/h3>\n\n\n\n
                          It seems reasonable to ask:<\/p>\n\n\n\n
                          “If we have polymorphic destructors, what about polymorphic constructors?”<\/em><\/strong><\/p>\n\n\n\n
                          A good question!  In fact, C++ does not support polymorphic constructors.  You have to resort to the use of a Factory Method.<\/em><\/p>\n\n\n\n
                          A Factory Method<\/em> is an implementation of the Factory<\/strong> pattern, as defined in the ‘Gang of Four’ Patterns book…<\/p>\n\n\n\n
                          <\/span>The ‘Gang of Four’ Patterns Book<\/span><\/h4>\n\n\n\n
                          \n
                          \n
                          \"\"<\/figure>\n<\/div>\n\n\n\n
                          \n
                          Design Patterns: Elements of Reusable Object-Oriented Software<\/strong><\/em> <\/p>\n\n\n\n
                          Erich Gamma<\/strong>, Richard Helm<\/strong>, Ralph Johnson<\/strong>, John M. Vlissides<\/strong>, <\/p>\n\n\n\n
                          ISBN-10 \u200f : \u200e <\/strong>0201633612 
                          ISBN-13 \u200f : \u200e <\/strong>978-0201633610
                          Publisher: Addison Wesley Professional<\/p>\n\n\n\n
                          Highly recommended!<\/em><\/p>\n<\/div>\n<\/div>\n\n\n\n
                          <\/span>Summary<\/span><\/h2>\n\n\n\n
                          Well, we’ve covered a fair bit of ground:<\/p>\n\n\n\n
                            \n
                          • Virtual functions<\/li>\n\n\n\n
                          • Virtual destructors<\/li>\n\n\n\n
                          • Abstract base classes<\/li>\n\n\n\n
                          • Interfaces<\/li>\n\n\n\n
                          • Virtual constructors; Factory patterns<\/li>\n<\/ul>\n\n\n\n
                            There’s still much more to learn…<\/p>\n\n\n\n
                            Onward!<\/p>\n","protected":false},"excerpt":{"rendered":"
                            Polymorphism Forms of Polymorphism In C++, there are three forms of polymorphism: Here we are concerned with pure polymorphism. What’s the Problem we’re Solving? Imagine that we have a Fruit class, and two classes, Kiwi and Kumquat, derived from it: Assume we wish to represent a collection of Fruits using a linked list: And we […]<\/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-932","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/932","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=932"}],"version-history":[{"count":15,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/932\/revisions"}],"predecessor-version":[{"id":1925,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/932\/revisions\/1925"}],"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=932"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}