Class Inheritance

#include "Employee.h"
#include "Manager.h"
#include <iostream>

void func1(const Employee& emp)
{
  emp.Display();
  std::cout << std::endl;
}

void func2(const Manager& mgr)
{
  mgr.Display();
  std::cout << std::endl;
}

int main()
{
  Employee emp1("John", "Doe", 30000, 2);
  Manager mgr1("Mary", "Smith", 50000, 10, 5, 8); 

  func1(emp1);  // pass an Employee object
  func2(mgr1);  // pass a Manager object

  func1(mgr1);  // pass a Manager object
  func2(emp1);  // pass an Employee object
  return 0;
}

Output:

  Name: Doe, John
Salary: $30000.00
 Years: 2

  Name: Smith, Mary
Salary: $50000.00
 Years: 10
  Dept: 5
  Emps: 8

  Name: Smith, Mary
Salary: $50000.00
 Years: 10

This is what the compiler says:

#include "Employee.h"
#include "Manager.h"
#include <iostream>

int main()
{
  Employee emp1("John", "Doe", 30000, 2);
  Manager mgr1("Mary", "Smith", 50000, 10, 5, 8); 

  Employee* empPtr1 = &emp1;
  Manager* mgrPtr1 = &mgr1;

  empPtr1->Display();
  std::cout << std::endl;

  mgrPtr1->Display();
  std::cout << std::endl;

    // OK, a Manager is-an Employee
  empPtr1 = &mgr1;

  empPtr1->setYears(11);
  empPtr1->setNumEmployees(12);
  empPtr1->Display();
  std::cout << std::endl;
  return 0;
}

Output:

  Name: Doe, John
Salary: $30000.00
 Years: 2

  Name: Smith, Mary
Salary: $50000.00
 Years: 10
  Dept: 5
  Emps: 8

  Name: Smith, Mary
Salary: $50000.00
 Years: 11

The compiler complains:

This program creates an array of pointers to Employee objects. It displays each object using a for loop. Make sure you understand what the program is trying to do.

#include "Employee.h"
#include "Manager.h"
#include <iostream>

int main()
{
    // Create the personnel
  Employee emp1("John", "Doe", 30000, 2);
  Employee emp2("Nigel", "Tufnel", 35000, 4);
  Manager mgr1("Mary", "Smith", 50000, 10, 5, 8); 
  Manager mgr2("Derek", "Smalls", 60000, 13, 6, 5); 

    // Create an array to hold pointers to the 4 objects
  Employee* personnel[4];

    // Assign a pointer for each object
  personnel[0] = &emp1; // OK, an Employee
  personnel[1] = &emp2; // OK, an Employee
  personnel[2] = &mgr1; // OK, a Manager is an Employee
  personnel[3] = &mgr2; // OK, a Manager is an Employee

    // Loop through and display each object
  for (int i = 0; i < 4; i++)
  {
    personnel[i]->Display();
    std::cout << std::endl;
  }
  return 0;
}

Output:

  Name: Doe, John
Salary: $30000.00
 Years: 2

  Name: Tufnel, Nigel
Salary: $35000.00
 Years: 4

  Name: Smith, Mary
Salary: $50000.00
 Years: 10

  Name: Smalls, Derek
Salary: $60000.00
 Years: 13

What we really wanted was to have each object display all of its data. The Employee objects displayed all of their data, but the Manager objects only displayed the data that they have in common with an Employee. We really wanted this to display:

  Name: Doe, John
Salary: $30000.00
 Years: 2



  Name: Tufnel, Nigel
Salary: $35000.00
 Years: 4

  Name: Smith, Mary
Salary: $50000.00
 Years: 10
  Dept: 5
  Emps: 8

  Name: Smalls, Derek
Salary: $60000.00
 Years: 13
  Dept: 6
  Emps: 5

Because the personnel[] array is an array of pointers to Employee objects, when the compiler sees the statement:

#include "Figure.h"

class Rectangle : public Figure
{
  public:
      // Constructor (default)
    Rectangle(double x = 0, 
              double y = 0, 
              double length = 0, 
              double width = 0);

      // Rectangle-specific get/set methods
    double getLength() const;
    double getWidth() const;
    void setLength();
    void setWidth();

      // Methods from Figure that
      // we need to specialize
    virtual double Area() const;
    virtual void Draw() const;
    virtual void Scale(double scale);

  private:
    double length_; // "long" sides
    double width_;  // "short" sides
};

#include "Figure.h"

class Square : public Figure
{
  public:
      // Constructor (default)
    Square(double x = 0, 
           double y = 0, 
           double side = 0);


      // Square-specific get/set methods
    double GetSide() const;
    void SetSide(double side);



      // Methods from Figure that
      // we need to specialize
    virtual double Area() const;
    virtual void Draw() const;
    virtual void Scale(double scale);

  private:
    double side_; // length of a side
};

Sample client code:

Rectangle r(4, 5, 10, 3);
Square s(2, 3, 6);
Figure *figs[2] = {&r, &s};

for (int i = 0; i < 2; i++)
{
  figs[i]->Draw();
  cout << "Area: " << figs[i]->Area() << endl;
}

Output:

Drawing the rectangle: 10x3
Area: 30
Drawing the square: 6
Area: 36

Here are the simplistic Draw methods:

If I said: "Everyone take out a pencil and draw a figure centered at (0, 0) on an X-Y grid.", what would we see?

Designing a class heirarchy is an advanced skill usually performed by experienced programmers. Since a design may need to last for years, it is important to get it right the first time. This is why experience helps.

All 3 classes have the ability to attack (i.e. punch) another player, with varying degrees of damage. Each class will also have a secondary attack mode, which can be very different from each other.

Virtual Constructors

C++ does not have virtual constructors but you can simulate them when you need them by using covariant return types.

How would you support the client code below so that it compiles and runs correctly? Essentially, you need to code the functions: CopyArray, DisplayEmps, and ReleaseEmps.

int main()
{
  const int size = 4;
  Employee *emps[size]; // Employee default constructor?

  emps[0] = new Employee("Nigel", "Tufnel", 50000, 2);
  emps[1] = new Employee("Derek", "Smalls", 40000, 5);
  emps[2] = new Manager("Ian", "Faith", 80000, 5, 7, 25);
  emps[3] = new Manager("Bobbi", "Fleckman", 70000, 7, 9, 20);

    // Make a copy of the array and return a pointer to it
  Employee **dups = CopyArray(emps, size);

    // Display array elements
  std::cout << "***** Original array *****\n";
  DisplayEmps(emps, size);
  std::cout << "***** Copy of array *****\n";
  DisplayEmps(dups, size);

    // Delete array elements
  std::cout << "***** Releasing original *****\n";
  ReleaseEmps(emps, size);
  std::cout << "***** Releasing copy *****\n";
  ReleaseEmps(dups, size);

    // Delete array
  delete dups;

  return 0;
}

DisplayEmps, and ReleaseEmps are trivial. What is required of the Employee class for these to work properly?

// Displays each Employee in the array
void DisplayEmps(Employee *emps[], int size)
{
  for (int i = 0; i < size; i++)
    emps[i]->Display(); 
}

// Deletes each Employee in the array
void ReleaseEmps(Employee *emps[], int size)
{
  for (int i = 0; i < size; i++)
    delete emps[i];  // What function is called here?
}

The more challenging function is CopyArray which would start something like this:

Employee **CopyArray(Employee *emps[], int size)
{
    // Create array to hold new pointers
  Employee **copy = new Employee *[size];

    // Copy from 'emps' array to 'copy' array
  for (int i = 0; i < size; i++)
  {
    // Copy the ith element into the new array
    // How is this implemented?
  }

  return copy;
}

Right now, we have two potential constructs to make a copy: (think copy constructor)

copy[i] = new Employee(*emps[i]);// Will this compile/work?

copy[i] = new Manager(*emps[i]);// Will this compile/work?

Can we use either one?
Will they both work the same?
What mechanism are we in need of?

Using the copy constructor from Employee: (implicitly generated)

***** Original array ***** Name: Tufnel, Nigel Salary: $50000.00 Years: 2 Name: Smalls, Derek Salary: $40000.00 Years: 5 Name: Faith, Ian Salary: $80000.00 Years: 5 Dept: 7 Emps: 25 Name: Fleckman, Bobbi Salary: $70000.00 Years: 7 Dept: 9 Emps: 20

***** Copy of array ***** Name: Tufnel, Nigel Salary: $50000.00 Years: 2 Name: Smalls, Derek Salary: $40000.00 Years: 5 Name: Faith, Ian Salary: $80000.00 Years: 5 Name: Fleckman, Bobbi Salary: $70000.00 Years: 7

Using the copy constructor from Manager: (user-defined)

***** Original array ***** Name: Tufnel, Nigel Salary: $50000.00 Years: 2 Name: Smalls, Derek Salary: $40000.00 Years: 5 Name: Faith, Ian Salary: $80000.00 Years: 5 Dept: 7 Emps: 25 Name: Fleckman, Bobbi Salary: $70000.00 Years: 7 Dept: 9 Emps: 20

***** Copy of array ***** Name: Tufnel, Nigel Salary: $50000.00 Years: 2 Dept: 0 Emps: 0 Name: Smalls, Derek Salary: $40000.00 Years: 5 Dept: 0 Emps: 0 Name: Faith, Ian Salary: $80000.00 Years: 5 Dept: 0 Emps: 0 Name: Fleckman, Bobbi Salary: $70000.00 Years: 7 Dept: 0 Emps: 0

Now, we're really no better off. We could force the correct Manager constructor:

copy[i] = new Manager(*static_cast<Manager *>(emps[i]));

But that gives us this:

***** Copy of array *****
  Name: Tufnel, Nigel
Salary: $50000.00
 Years: 2
  Dept: -33686019
  Emps: -572662307
  Name: Smalls, Derek
Salary: $40000.00
 Years: 5
  Dept: -33686019
  Emps: -572662307
  Name: Faith, Ian
Salary: $80000.00
 Years: 5
  Dept: 7
  Emps: 25
  Name: Fleckman, Bobbi
Salary: $70000.00
 Years: 7
  Dept: 9
  Emps: 20

One solution would be to construct something like this:

for (int i = 0; i < size; i++)
{
  if (/* emps[i] is an Employee */)
    copy[i] = new Employee(*emps[i]);
  else if (/* emps[i] is a Manager */)
    copy[i] = new Manager(*emps[i]);
  else if (/* emps[i] is some other class */)
    copy[i] = new <some_other_class>(*emps[i]);
  else if (/* ... */)
    copy[i] = new ...
}

But this doesn't scale and is generally a bad idea. (The point of polymorphism is that you shouldn't need to know what type is being pointed to.)
Now you see why we would like a virtual constructor, which C++ doesn't have.
So, we create a method to act like a constructor and make it virtual.
The client will call that method instead of using the new operator:

Client:

  // clone is a virtual method that returns a new copy of itself
for (int i = 0; i < size; i++)
  copy[i] = emps[i]->clone();

Employee:

virtual Employee *clone() const; // declaration

Employee * Employee::clone() const
{
  return new Employee(*this);
}

Manager:

virtual Manager *clone() const; // declaration

Manager * Manager::clone() const
{
  return new Manager(*this);
}

Now, all works as it should:

***** Original array ***** Name: Tufnel, Nigel Salary: $50000.00 Years: 2 Name: Smalls, Derek Salary: $40000.00 Years: 5 Name: Faith, Ian Salary: $80000.00 Years: 5 Dept: 7 Emps: 25 Name: Fleckman, Bobbi Salary: $70000.00 Years: 7 Dept: 9 Emps: 20

***** Copy of array ***** Name: Tufnel, Nigel Salary: $50000.00 Years: 2 Name: Smalls, Derek Salary: $40000.00 Years: 5 Name: Faith, Ian Salary: $80000.00 Years: 5 Dept: 7 Emps: 25 Name: Fleckman, Bobbi Salary: $70000.00 Years: 7 Dept: 9 Emps: 20

The clone method can be called anything you want.
The function must be virtual (or else there's no polymorphism).

Sometimes you just need to create a new object rather than copy. You could implement a virtual create method something like this:

Employee * Employee::create() const
{
  return new Employee();
}

Manager * Manager::create() const
{
  return new Manager();
}

Of course, the create method would need either a default constructor or set the constructor parameters (none are provided by the client).

As a final example, if we emit a string in the destructor for each class, we'd get different results depending on whether or not the destructor in the base class was virtual:

// Deletes each Employee in the array
void ReleaseEmps(Employee *emps[], int size)
{
  for (int i = 0; i < size; i++)
    delete emps[i];  // What function is called here?
}

Output:

virtual
***** Releasing original ***** Employee dtor: Tufnel Employee dtor: Smalls Manager dtor: Faith Employee dtor: Faith Manager dtor: Fleckman Employee dtor: Fleckman ***** Releasing copy ***** Employee dtor: Tufnel Employee dtor: Smalls Manager dtor: Faith Employee dtor: Faith Manager dtor: Fleckman Employee dtor: Fleckman
non-virtual
***** Releasing original ***** Employee dtor: Tufnel Employee dtor: Smalls Employee dtor: Faith Employee dtor: Fleckman ***** Releasing copy ***** Employee dtor: Tufnel Employee dtor: Smalls Employee dtor: Faith Employee dtor: Fleckman

Default Arguments in Virtual Functions

Given this hierarchy:

class Foo
{
  public:
    virtual void f(int value = 10) 
    { 
      cout << "Foo: " << value << endl; 
    };
};

class Bar : public Foo
{
  public:
    virtual void f(int value = 20)
    {
      cout << "Bar: " << value << endl; 
    };
};

Why does this code work as shown?

Bar *pb = new Bar;
Foo *pf = pb;

pf->f(); // Bar::f(10)
pb->f(); // Bar::f(20)

The correct methods are called through polymorphism (determined at runtime).
The wrong parameter is applied in the second case (or so it appears).
Simply put, the default arguments are determined at compile time based on the type of the pointer.

Class Inheritance 2

Virtual Constructors

Default Arguments in Virtual Functions