This is an intermediate conversion course for C++, suitable for second year computing students who may have learned Java or another language in first year.

1. INHERITANCE
Michael Heron

2. Introduction
• There are three pillars fundamental to the edifice that is
object oriented programming.
• Inheritance
• Encapsulation
• Polymorphism
• It is these three things that turn object orientation from a
gimmick into an extremely powerful programming tool.

3. Inheritance
• In this lecture we are going to talk about inheritance and
how it can be applied to C++ programs.
• There are several important differences here between Java and
C++.
• Java and C# are single inheritance languages.
• C++ supports multiple inheritance.
• This is much more powerful, but also very difficult to do well.

4. Inheritance
• The concept of inheritance is borrowed from the natural
world.
• You get traits from your parents and you pass them on to your
offspring.
• In C++, any class can be the parent of any other object.
• The child class gains all of the methods and attributes of the
parent.
• This can be modified, more on that later.

5. Inheritance in the Natural World

6. Inheritance
• Inheritance is a powerful concept for several reasons.
• Ensures consistency of code across multiple different objects.
• Allows for code to be collated in one location with the concomitant
impact on maintainability.
• Changes in the code rattle through all objects making use of it.
• Supports for code re-use.
• Theoretically…

7. Inheritance
• In C++, the most general case of a code system belongs
at the top of the inheritance hierarchy.
• It is successively specialised into new and more precise
implementations.
• Children specialise their parents
• Parents generalise their children.
• Functionality and attributes belong to the most general
class in which they are cohesive.

8. Inheritance
• In Java, the concept is simple.
• You create an inheritance relationship by having one class extend
another.
• The newly extended class gains all of the attributes and
methods of the parent.
• It can be used, wholesale, in place of the parent if needed.
• We can also add and specialise attributes and
behaviours.
• This is the important feature of inheritance.

9. Inheritance in Java
public class BankAccount {
private int balance;
public void setBalance (int b) {
balance=b;
}
public int getBalance() {
return balance;
}
}
public class MainClass {
public static void main (String args[]) {
BankAccount myAccount;
myAccount = new BankAccount();
myAccount.setBalance (100);
System.out.println ("Balance is: " + myAccount.getBalance());
}
}

10. Inheritance in Java
public class ExtendedBankAccount extends BankAccount{
private int overdraft;
public boolean adjustBalance (int val) {
if (getBalance() - val < 0 - overdraft) {
return false;
}
setBalance (getBalance() - val);
return true;
}
}

11. Constructors And Inheritance
• When a specialised class is instantiated, it calls the
constructor on the specialised class.
• If it doesn’t find a valid one it will error, even if one exists in the
parent.
• Constructors can propagate invocations up the object
hierarchy through the use of the super keyword.
• super always refers to the parent object in Java.
• Easy to do, because each child has only one parent.
• In a constructor, must always be the first method call.
• Everywhere else, it can be anywhere.

12. Constructors and Inheritance
public class BankAccount {
private int balance;
public BankAccount() {
balance = 0;
}
public BankAccount (int
startBalance) {
setBalance (startBalance);
}
public void setBalance (int b) {
balance=b;
}
public int getBalance() {
return balance;
}
}
public class ExtendedBankAccount extends
BankAccount{
private int overdraft;
public ExtendedBankAccount (int startBalance) {
super (startBalance);
}
public ExtendedBankAccount (int startBalance, int
startOverdraft) {
super (startBalance);
overdraft = startOverdraft;
}
public boolean adjustBalance (int val) {
if (getBalance() - val < 0 - overdraft) {
return false;
}
setBalance (getBalance() - val);
return true;
}
}

13. Inheritance in C++
• At its basic level, very similar to Java.
• A single colon is used in place of the extends keyword.
• We also include public before the class name.
• We’ll talk about why later.
• We have no access to variables and methods defined as
private.
• More on that in the next lecture.

14. Inheritance in C++
class ExtendedCar : public Car {
private:
float mpg;
public:
ExtendedCar(float mpg = 50.0);
void set_mpg (float f);
float query_mpg();
};
ExtendedCar::ExtendedCar (float mpg) :
mpg (mpg) {
}
float ExtendedCar::query_mpg() {
return mpg;
}
void ExtendedCar::set_mpg (float f) {
mpg = f;
}

15. Constructors in C++
• Constructors in specialised C++ classes work in a slightly
different way to in Java.
• Constructors cannot set the value in parent classes.
• This syntactically forbidden in C++.
• By default, the matching constructor in the derived class (child class)
will be called.
• Then the default construtor in the parent will be called.
• From our earlier example, the code will call the matching
constructor in ExtendedCar, and then the parameterless
constructor in Car.

16. Constructors in C++
• If we want to change that behaviour, we must indicate so
to the constructor.
• In our implementation for the constructor, we indicate which of the
constructors in the parent class are to be executed.
• We must handle the provision of the values ourselves.

17. Constructors in C++
class ExtendedCar : public Car {
private:
float mpg;
public:
ExtendedCar(
float cost = 100.0,
string colour = "black",
int max_size = 10, float mpg = 50.0);
void set_mpg (float f);
float query_mpg();
};
ExtendedCar::ExtendedCar (float cost, string colour, int max_size, float mpg)
: Car(cost, colour, max_size),
mpg (mpg) {
}

18. Multiple Inheritance
• The biggest distinction between C++ and Java inheritance
models is that C++ permits multiple inheritance.
• Java and C# do not provide this.
• It must be used extremely carefully.
• If you are unsure what you are doing, it is tremendously easy to make
a huge mess of a program.
• It is in fact something best avoided.
• Usually.

19. Multiple Inheritance
• We will touch on syntax, rather than discuss it.
• Don’t want to introduce something I don’t want you using!
• However, important you understand what is happening when you
see it.
• Inheritance defined in the same way as with a single
class.
• Separate classes to be inherited with a comma
• Class SuperVehicle: public Car, public Plane

20. Multiple Inheritance
• What are the problems with multiple inheritance?
• Hugely increased program complexity
• Problems with ambigious function calls.
• The Diamond Problem
• Hardly ever really needed.
• For simple applications, interfaces suffice.
• For more complicated situations, design patterns exist to resolve all the
requirements.
• Some languages permit multiple inheritance but resolve some
of the technical issues.
• C++ isn’t one of them.

21. Summary
• Inheritance is an extremely powerful tool.
• Provides opportunities for code re-use and maintainability.
• Inheritance in C++ is very similar to inheritance in Java.
• With some exceptions.
• C++ permits multiple inheritance.
• Not something you often need.