Inheritance

Door Class

object type:

• Door

attributes:

• Open or close

methods:

• Init as closed door

• Open if possible

• Close

• State if opened

// A generic door class (Door.h)
#pragma once
class Door {
protected:
  bool shut_;
public:
  Door(); // Constructs a shut door
  bool isOpen() const; // Is the door open?
  void open(); // Opens the door, if possible
  void close(); // Shuts the door
};

We used protected so that subclasses can use the attribute as well.

/* Door.cpp */
#include "Door.h"
Door :: Door() : shut_(true) { }
bool Door :: isOpen() const { return !shut_; }
// By default, it's always possible to open
void Door :: open() { shut_ = false; }
void Door :: close() { shut_ = true; }

/* Game.cpp */
#include "Door.h"

int main(){
  Door BigHouseDoor;
  Door BathroomDoor;
  BigHouseDoor.open();
  ...
  ...
  if ( BigHouseDoor.isOpen() )
    enterBigHouse();
  else
    lookForBackDoor();
}

• class: Door

• objects: BigHouseDoor, BathroomDoor

New Feature - version 2.0

Now the manager has added another feature to implement: track how many door at every instance of the game

An inexperienced would solve the problem by using a global variable and increment each time we added a new door and viceversa.

• This complicates the process and can cause errors later down the road.

• This also contradicts the OOD principle

Solution

Definition of a static class that is a friend. That counts the amount of doors at run and is incremented by the constuctor of each new door and decrements in the destructor.

Remember: A static method is part of the class and only one instance exists and not a different one for each object

// A generic door class (Door.h)
#pragma once
class Door {
protected:
  bool shut_;
  static int count_;
public:
  Door(); // Constructs a shut door
  bool isOpen() const; // Is the door open?
  void open(); // Opens the door, if possible
  void close(); // Shuts the door
  ~Door(); // Destructor
  // define a static class method, which return the number
  // of Door instances ( objects)
  static int getDoorCount();
};

Added features

• ~Door() will decrement each time a door is removed

• the static variable count_

• static method getDoorCount, returns count_

Remember: the static variable must be defined init in the .cpp file

/* Door.cpp */
#include "Door.h"

/* defining the static members first */
int Door::count_ = 0; /* defining and initializing count_*/
int Door::getDoorCount () {
/* this method can't access shut_ !! */
  return count_;
}

Door::Door() : shut_(true) {
  count_++;
}

bool Door::isOpen() const {
  return !shut_;
}

// By default, it's always possible to open
void Door::open() { shut_ = false; }
void Door::close() { shut_ = true; }

Door::~Door() {
  count_--;
}

/* Game.cpp */
#include <iostream>
#include "Door.h"
int main() {
    Door D;
    Door* Dp;
    // calling non-static methods of the object
    D.open();
    D.close();
    cout << "At start, we have " << Door::getDoorCount() << " Door(s)" << endl;
    // pay attention: when calling static method, you
    // should use the scope of the class ( Door::...)

    Dp = new Door();
    Dp->isOpen();
    cout << "After new, we have " << Door::getDoorCount() << " Door(s)" << endl;
    delete Dp;
    cout << "After delete, we have " << Door::getDoorCount() << " Door(s)" << endl;
}

At start, we have 1 Door(s)
After new, we have 2 Door(s)
After delete, we have 1 Door(s)

Inheritance - version 3.0

There are 2 ways to use a class:

• make a new instance of the class (what we did until now)

• Inherit from an existing class

Question

Which fields and methods from the base class can be accessed from the derived class?

Answer

public and protected

Therefore, each sub-class of Door can use every method and variable of Door

Example of sub-class

In a game there may be many types of doors. Here we will design a door with a lock

object type:

• LockableDoor

attributes:

• Open or close

• Locked or not locked

methods:

• Init as closed door and locked

• Open if not locked

• Close

• State if opened

• Lock

• Open lock

• State if locked

// A lockable door class (LockableDoor.h)
#pragma once
#include "Door.h"

class LockableDoor : public Door {
protected:
    bool locked_;
public:
    LockableDoor(); // Constructs a shut door
    bool isLocked() const; // Is the door locked?
    void open(); // Opens the door, if not locked
    void lock(); // Locks the door
    void unlock(); // Unlocks the door
};

Notice: that this is more compact that Door.h this is because we will reuse Door and dont have to redefine everything a second time.

class LockableDoor : public Door

when we inherit using public before Door we can access any public and protected variables and methods. If not specified the default is private

We could also inherit from multiple classes as so:

class ClockRadio : public Clock, public Radio

Lets now define our .cpp file

// A lockable door class (LockableDoor.cpp)
#pragma once
#include "LockableDoor.h"

LockableDoor::LockableDoor() : Door(), locked_(true) { }
bool LockableDoor :: isLocked() const { return locked_; }
void LockableDoor :: lock() { locked_ = true; }
void LockableDoor :: unlock() { locked_ = false; }

void LockableDoor :: open() {
    if (!locked_)
        Door::open(); // could use shut_=false too
}

and our main.cpp

/* Game.cpp */
#include <iostream>
#include "LockableDoor.h"

int main() {
    Door generic; // generic.shut_ is true
    LockableDoor bathDoor; // bathDoor.shut_ and bathDoor.locked_ are true
    generic.open(); // generic.shut_ is false
    bathDoor.lock(); // bathDoor.shut_ and bathDoor.locked_ are true
    bathDoor.open(); // bathDoor.shut_ and bathDoor.locked_ are still true
    if (!bathDoor.isOpen())
        bathDoor.unlock(); // bathDoor.shut_ is true and bathDoor.locked_ is false
}

or in one file for simplicity

#include <iostream>
using namespace std;

class Door {
protected:
    bool shut_;
    static int count_;
public:
    Door(); // Constructs a shut door
    bool isOpen() const; // Is the door open?
    void open(); // Opens the door, if possible
    void close(); // Shuts the door
    ~Door(); // Destructor
    // define a static class method, which return the number
    // of Door instances ( objects)
    static int getDoorCount();
};

// A lockable door class (LockableDoor.cpp)

/* defining the static members first */
int Door::count_ = 0; /* defining and initializing count_*/
int Door::getDoorCount () {
/* this method can’t access shut_ !! */
    return count_;
}

Door::Door() : shut_(true) {
    count_++;
}

bool Door::isOpen() const {
    return !shut_;
}

// By default, it's always possible to open
void Door::open() { shut_ = false; }
void Door::close() { shut_ = true; }

Door::~Door() {
    count_--;
}


class LockableDoor : public Door {
protected:
    bool locked_;
public:
    LockableDoor(); // Constructs a shut door
    bool isLocked() const; // Is the door locked?
    void open(); // Opens the door, if not locked
    void lock(); // Locks the door
    void unlock(); // Unlocks the door
};

LockableDoor::LockableDoor() : Door(), locked_(true) { }
bool LockableDoor :: isLocked() const { return locked_; }
void LockableDoor :: lock() { locked_ = true; }
void LockableDoor :: unlock() { locked_ = false; }

void LockableDoor :: open() {
    if (!locked_)
        Door::open(); // could use shut_=false too
}

int main() {
    Door generic; // generic.shut_ is true
    LockableDoor bathDoor; // bathDoor.shut_ and bathDoor.locked_ are true
    generic.open(); // generic.shut_ is false
    bathDoor.lock(); // bathDoor.shut_ and bathDoor.locked_ are true
    bathDoor.open(); // bathDoor.shut_ and bathDoor.locked_ are still true
    if (!bathDoor.isOpen()){
        bathDoor.unlock(); // bathDoor.shut_ is true and bathDoor.locked_ is false
        cout << "Bathroom door is now unlocked" << endl;
    }
}

What is the size of the following?

This question was asked to me by a fellow student

#include <iostream>
using namespace std;

class A{
private:
    int i;
};

class B : public A{
public:
    int j;
};

int main(){
   A a;
   B b;
   b.j = 100;
//   b.i = 100; won't compile
   cout << sizeof(a) << endl;
   cout << sizeof(b) << endl;
}

4
8

As we can see even though b doesn't have access to i (unless we use a setter/getter) it will still use memory

Inheritance: order of construction / destruction

Class objects are constructed from the bottom up:

1. The base.

2. The members (may want to use init list)

3. The derived class itself

They are destroyed in the opposite order:

1. The derived class itself.

2. The members.

3. The base.

How to rember: Think about this, first someones parents were born and then him (construction). Now this makes alot of sense because our parent class probably has to initialize a few fields and only after can we use them.

In our LockableDoor example

1. Doors' constuctor, which inits shut_ and count_

2. Initialize _locked

3. LockableDoor constuctor which is empty

Base and Derived Compatibility

Lets say we have 2 functions and 2 objects

void f1(LockableDoor d);
void f2(Door d);

Door myDoor;
LockableDoor keyedDoor;

Giving a derived type to a base type is compatible

f1(keyedDoor); // is legal
f2(keyedDoor); // is legal

The opposite is not true

f1(myDoor); // illegal !!!
f2(myDoor); // is legal

and

myDoor = keyedDoor; // is legal, may slice object
keyedDoor = myDoor; // illegal!!!

myDoor = keyedDoor can cause object slicing, since the compiler will ignore any variables or methods not in the base type. We will explore how to solve some of the problems with virtual methods later on.

Has-a and Is-a relationship

• Is-A relation- Interface Inheritance: creating a subtype of an existing class for purpose of setting up dynamic binding.

  • Circle is a subclass of Shape (i.e., Is-A relation).

  • A Birthday is a subclass of Date.

• Has-A relation - Code Reuse: reusing an implementation to create a new class type.

  • Class Clock that inherits from class Window the ability to represent itself graphically. A stack is not really a subtype or specialization of Vector.

  • In this case, inheritance makes implementation easier, because there is no rewrite and debug existing code.

  • This is called using inheritance for reuse, i.e., a pseudo-Has-A relation.

Now here LockableDoor is-a Door

Adding more Classes

// A combination lock door with single Date
class CombinationLockDoor : public LockableDoor {
protected:
    const Date combination_;
public:
     // Constructs new door with combination c
     CombinationLockDoor(const Date& c);
     // Attempts to unlock the door with combination c; hides LockableDoor::unlock
     void unlock(const Date& c);
};

CombinationLockDoor::CombinationLockDoor(const Date& c)
                : lockableDoor(), combination_(c) { }

void CombinationLockDoor :: unlock(const Date& c) {
 if (c.theYear() == combination_.theYear() && c.theMonth() == combination_.theMonth() && c.theDay() == combination_.theDay())
    LockableDoor :: unlock();
 // could use locked_ = false;
}

Build visual Chest

├── Chest
│     ├── LockableChest

Makefile

all: main.cpp
    clang++-10 -c main.cpp -std=c++17 && clang++-10 main.o -o sfml-app -lsfml-graphics -lsfml-window -lsfml-system -std=c++17

main.cpp

#include <iostream>
#include <SFML/Graphics.hpp>
#include <time.h>
#include <list>
#include <cmath>
using namespace sf;
using namespace std;

const int W = 1200;
const int H = 800;

float DEGTORAD = 0.017453f; // Degrees TO Radians

class Animation{
public:
    float Frame, speed;
    Sprite sprite;
    std::vector<IntRect> frames;

    Animation(){}

    Animation (Texture &t, int x, int y, int w, int h, int count, float Speed){
        Frame = 0;
        speed = Speed;

        for (int i=0;i<count;i++)
            frames.push_back( IntRect(x+i*w, y, w, h)  );

        sprite.setTexture(t);
        sprite.setOrigin(w/2,h/2);
        sprite.setTextureRect(frames[0]);
    }


    void update(){
        Frame += speed;
        int n = frames.size();
        if (Frame >= n) Frame -= n;
        if (n>0) sprite.setTextureRect( frames[int(Frame)] );
    }

    bool isEnd(){
        return Frame+speed>=frames.size();
    }

};

class Chest {
protected:
    bool shut_;
    static int count_;
    float x,y,dx,dy,R,angle;
public:
    Animation anim;

    Chest(); // Constructs a shut door
    bool isOpen() const; // Is the door open?
    void open(); // Opens the door, if possible
    void close(); // Shuts the door
    ~Chest(); // Destructor
    // define a static class method, which return the number
    // of Door instances ( objects)
    static int getDoorCount();

    void settings(Animation &a,int X,int Y,float Angle=0,int radius=1){
        anim = a;
        x=X; y=Y;
        angle = Angle;
        R = radius;
    }

    void draw(RenderWindow &app){
        anim.sprite.setPosition(x,y);
        anim.sprite.setRotation(angle+90);
        app.draw(anim.sprite);

        CircleShape circle(R);
        circle.setFillColor(Color(255,0,0,170));
        circle.setPosition(x,y);
        circle.setOrigin(R,R);
        //app.draw(circle);
    }

};

// A lockable door class (LockableDoor.cpp)

/* defining the static members first */
int Chest::count_ = 0; /* defining and initializing count_*/
int Chest::getDoorCount () {
/* this method can't access shut_ !! */
    return count_;
}

Chest::Chest() : shut_(true) {
    count_++;
}

bool Chest::isOpen() const {
    return !shut_;
}

// By default, it's always possible to open
void Chest::open() { shut_ = false; }
void Chest::close() { shut_ = true; }

Chest::~Chest() {
    count_--;
}


class LockableChest : public Chest {
protected:
    bool locked_;
public:
    LockableChest(); // Constructs a shut door
    bool isLocked() const; // Is the door locked?
    void open(); // Opens the door, if not locked
    void lock(); // Locks the door
    void unlock(); // Unlocks the door
};

LockableChest::LockableChest() : Chest(), locked_(true) { }
bool LockableChest :: isLocked() const { return locked_; }
void LockableChest :: lock() { locked_ = true; }
void LockableChest :: unlock() { locked_ = false; }

void LockableChest :: open() {
    if (!locked_)
        Chest::open(); // could use shut_=false too
}

int main() {
    Chest generic; // generic.shut_ is true
    LockableChest bathDoor; // bathDoor.shut_ and bathDoor.locked_ are true
    generic.open(); // generic.shut_ is false
    bathDoor.lock(); // bathDoor.shut_ and bathDoor.locked_ are true
    bathDoor.open(); // bathDoor.shut_ and bathDoor.locked_ are still true
    if (!bathDoor.isOpen()){
        bathDoor.unlock(); // bathDoor.shut_ is true and bathDoor.locked_ is false
        cout << "Bathroom door is now unlocked" << endl;
    }



    sf::Text text;
    text.setFillColor(sf::Color::Red);
    sf::Font font;
    font.loadFromFile("door_images/arial.ttf");
    text.setFont(font);

    std::list<Chest*> doors;
    srand(time(0));

    RenderWindow app(VideoMode(W, H), "Open Chest!");
    app.setFramerateLimit(60);

    Texture t1;
//    t1.loadFromFile("door_images/doors.png");
    t1.loadFromFile("door_images/chest.png");

    //door - sprite
//    Animation sPlayer(t1, 65,0,65,96, 1, 0);
//    Animation sPlayer_go(t1, 125,0,65,96, 1, 0);

    //chest - sprite
    Animation sChestClosed(t1, 0, 0, 590, 600, 1, 0);
    Animation sChestOpen(t1, 600, 0, 590, 600, 1, 0);

    LockableChest *lockableDoor = new LockableChest();
    lockableDoor->settings(sChestOpen, 500, 500, 270, 20);
    doors.push_back(lockableDoor);


    /////main loop/////
    while (app.isOpen()){
        Event event;
        while (app.pollEvent(event)){
            if (event.type == Event::Closed)
                app.close();

            if (event.type == Event::KeyPressed)
                if (event.key.code == Keyboard::Space){}
        }


        if (Keyboard::isKeyPressed(Keyboard::C)){
            text.setString("Pressed C - closed");
            text.setCharacterSize(24); // in pixels, not points!
            lockableDoor->close();
        }
        if (Keyboard::isKeyPressed(Keyboard::L)) {
            text.setString("Pressed L - locked");
            text.setCharacterSize(24); // in pixels, not points!
            lockableDoor->lock();
        }
        if (Keyboard::isKeyPressed(Keyboard::O)){
            text.setString("Pressed O - opened");
            text.setCharacterSize(24); // in pixels, not points!
            lockableDoor->open();
        }
        if (Keyboard::isKeyPressed(Keyboard::U)){
            text.setString("Pressed U - unlocked");
            text.setCharacterSize(24); // in pixels, not points!
            lockableDoor->unlock();
        }


        app.clear(Color::White);
        app.draw(text);
        if (lockableDoor->isOpen())
            lockableDoor->anim = sChestOpen;
        else if (!lockableDoor->isOpen())
            lockableDoor->anim = sChestClosed;

        //////draw//////
//        app.draw(background);
        for(auto i:doors) i->draw(app);
        app.display();
    }
}

Instructions:

• O opens chest

• C closes chest

• L locks chest

• U unlocks chest

Needs files:

• ariel.ttf

• chest.png

Door sprite

Ariel font

Another Example

C++ Inheritance example