Lecture 15

Consider the following: When is a book heavy?

• ordinary books: >200 pages

• textbooks: >500 pages

• comicbooks: >30 pages

class Book {
  ...
  protected:
    int length;
  public:
    bool isHeavy() const {
      return length > 200;
    }
};

class Text: public Book {
  ...
  public:
    bool isHeavy() const {
      return length > 500;
    }
};

class Comic: public Book {
  ...
  public:
    bool isHeavy() const {
      return length > 30;
    }
};

// client:
Book b {"small", 50};
Comic c {"Big", 80, "Lushman"};
Book b = Comic{"Big", 80, "Lushman"};
b.isHeavy(); // **What does this return?

**It returns false since Book::isHeavy() runs

Why does Book::isHeavy() run?

Book b = Comic {...};

• Tries to fit a comic object in b while there's only space for a Book object

• Comic is sliced (i.e. the hero field is chopped off)

• The Comic is a Book now!

Comic {__, 40, __};
Book *pb = &c;
Book *pc = &c;

• When accessing objects through pointers, slicing is unnecessary (so it won't happen)

pc->isHeavy(); // runs Comic::isHeavy()
pb->isHeavy(); // runs Book::isHeavy()

How does compiler decide which method to run?

• Uses the type of the pointer or reference to decide which isHeavy to run. (it does not consider the type of the actual object)

• So a comic is only a comic if you point to it by a comic pointer or reference

How can we make Comic act like a comic even when pointed to by a Book pointer?

Solution: Declare the method virtual!

Virtual Methods/Dynamic Dispatch

Dynamic Dispatch:

• Type of the object is considered at runtime, rather than from the type of the variable i.e. Choose which class method to run based on the actual type of the object at run time

• To get dynamic dispatch, you need virtual methods

virtual bool Book::isHeavy() const;
Bool Comic::isHeavy() const override;

// Now:
Comic {__, 40, __};
Comic *pc = &c;
Book *pb = &c;
Book &rb = c;

pc->isHeavy(); // runs Comic::isHeavy()
pb->isHeavy(); // runs Comic::isHeavy()
rb.isHeavy(); // runs Comic::isHeavy()
Book b = c; // runs Book::isHeavy(), you can't stop slicing even if it's virtual!

Polymorphism

• Accomodating multiple types under one abstraction

• Dynamic dispatch allows us to do this

Example of polymorphic code:

Book *myBooks[20];
...
for (int i=0; i < 20; ++i) {
  cout << myBooks[i]->isHeavy();
}

Remark: This is why we can pass an ifstream to a function

void f(istream &in);

• ifstream is a subclass of istream

DANGER:

class One {
  int n, y;
}

class Two: public One {
  int z;
}

void f(one *n) {
  a[0] = {6,7};
  a[1] = {6,9};
}

Two myArray[2] = {{1,2,3},{4,5,6}};
f(myArray);

// myArray: 1 2 3 | 4 5 6
// a[0] = {6,7}: 6 7 3 | 4 5 6
// a[1] = {8, 9}: 6 7 8 | 9 5 6
// wanted: 6 7 3 | 8 9 6
// compilier thinks it has an order of one's not two's!, therefore misaligned

The Point: Never use an array of objects polymorphically

Destructors (Polymorphism)

class X {
  int *x;
  public:
    x(int n): n{new int[n]}} {};
    ~x() {
      delete [] n;
    }
};

class Y: public X {
  int *y;
  public:
    Y(int n, int m): X{n}, y{new int[m]}} {}
    ~Y() {
      delete [] y;
    }
};

// Y's destructor calls X's destructor!

What happens when an object is destroyed?

1. Destructor body runs

2. Fields are destructed in reverse dealing order

3. Superclass part is destructed (it's destructor called)

4. space is deallocated

Consider:

X *myX = new Y{10, 20};
delete myX; // **This leaks, but why?

** This calls X's destructor only (since the type of the pointer was X*), Fix this by making X's destructor virtual

The Point: Always make the destructor virtual in classes that have subclasses, even if the destructor does not do anything!

• Otherwise when we have a polymorphic variable with the type of the base class, it will not call the destructors of the subclasses

Final

If a class is not meant to have subclasses, declare it final.

// Now you cannot make subclasses of Y
class Y final: public X {
  ...
}