Inheritance

Introduction

What is Inheritance?

Inheritance is the process by which new classes called derived classes are created from existing classes called base classes. The derived classes have all the features of the base class and the programmer can choose to add new features specific to the newly created derived class.

For example, a programmer can create a base class named fruit and define derived classes as mango, orange, banana, etc. Each of these derived classes, (mango, orange, banana, etc.) has all the features of the base class (fruit) with additional attributes or features specific to these newly created derived classes. Mango would have its own defined features, orange would have its own defined features, banana would have its own defined features, etc.

This concept of Inheritance leads to the concept of polymorphism.

Features or Advantages of Inheritance:

Reusability:

Inheritance helps the code to be reused in many situations. The base class is defined and once it is compiled, it need not be reworked. Using the concept of inheritance, the programmer can create as many derived classes from the base class as needed while adding specific features to each derived class as needed.

Saves Time and Effort:

The above concept of reusability achieved by inheritance saves the programmer time and effort. Since the main code written can be reused in various situations as needed.

Increases Program Structure which results in greater reliability.

Polymorphism (to be discussed in detail in later sections)

General Format for implementing the concept of Inheritance:

class derived_classname: access specifier baseclassname

For example, if the base class is item and the derived class is sample it is specified as:

class sample: public item

The above makes sample have access to both public and protected variables of base class item. Reminder about public, private and protected access specifiers:

• If a member or variables defined in a class is private, then they are accessible by members of the same class only and cannot be accessed from outside the class.
  .
• Public members and variables are accessible from outside the class.
  .
• Protected access specifier is a stage between private and public. If a member functions or variables defined in a class are protected, then they cannot be accessed from outside the class but can be accessed from the derived class.

Inheritance Example:

class item { public: item(void) { x=0; } void f(int n1) { x= n1*5; } void output(void) { cout<<x; } private: int x; }; class sample: public item { public: sample(void) { s1=0; } void f1(int n1) { s1=n1*10; } void output(void) { item::output(); cout << s1; } private: int s1; }; int main(void) { sample s; s.f(10); s.output(); s.f1(20); s.output(); }

The output of the above program is

50
200

In the above example, the derived class is sample and the base class is item. The derived class defined above has access to all public and private variables. Derived classes cannot have access to base class constructors and destructors. The derived class would be able to add new member functions, or variables, or new constructors or new destructors. In the above example, the derived class sample has new member function f1( ) added in it. The line:

sample s;

creates a derived class object named as s. When this is created, space is allocated for the data members inherited from the base class item and space is additionally allocated for the data members defined in the derived class sample.

The base class constructor item is used to initialize the base class data members and the derived class constructor sample is used to initialize the data members defined in derived class.

In the previous lessons on inheritance, we’ve been making all of our data member’s public in order to simplify the examples. In this section, we’ll talk about the role of access specifies in the inheritance process, as well as cover the different types of inheritance possible in C++.

To this point, you’ve seen the private and public access specifiers, which determine who can access the members of a class. As a quick refresher, public members can be accessed by anybody. Private members can only be accessed by member functions of the same class. Note that this means derived classes cannot access private members!

view source

print?

1.class Base

2.{

3.private:

4.    int m_nPrivate; // can only be accessed by Base member functions (not derived classes)

5.public:

6.    int m_nPublic; // can be accessed by anybody

7.};

When dealing with inherited classes, things get a bit more complex.

First, there is a third access specifier that we have yet to talk about because it’s only useful in an inheritance context. The protected access specifier restricts access to member functions of the same class, or those of derived classes.

view source

print?

01.class Base

02.{

03.public:

04.    int m_nPublic; // can be accessed by anybody

05.private:

06.    int m_nPrivate; // can only be accessed by Base member functions (but not derived classes)

07.protected:

08.    int m_nProtected; // can be accessed by Base member functions, or derived classes.

09.};

10.  

11.class Derived: public Base

12.{

13.public:

14.    Derived()

15.    {

16.        // Derived's access to Base members is not influenced by the type of inheritance used,

17.        // so the following is always true:

18.  

19.        m_nPublic = 1; // allowed: can access public base members from derived class

20.        m_nPrivate = 2; // not allowed: can not access private base members from derived class

21.        m_nProtected = 3; // allowed: can access protected base members from derived class

22.    }

23.};

24.  

25.int main()

26.{

27.    Base cBase;

28.    cBase.m_nPublic = 1; // allowed: can access public members from outside class

29.    cBase.m_nPrivate = 2; // not allowed: can not access private members from outside class

30.    cBase.m_nProtected = 3; // not allowed: can not access protected members from outside class

31.}

Second, when a derived class inherits from a base class, the access specifiers may change depending on the method of inheritance. There are three different ways for classes to inherit from other classes: public, private, and protected.

To do so, simply specify which type of access you want when choosing the class to inherit from:

view source

print?

01.// Inherit from Base publicly

02.class Pub: public Base

03.{

04.};

05.  

06.// Inherit from Base privately

07.class Pri: private Base

08.{

09.};

10.  

11.// Inherit from Base protectedly

12.class Pro: protected Base

13.{

14.};

15.  

16.class Def: Base // Defaults to private inheritance

17.{

18.};

If you do not choose an inheritance type, C++ defaults to private inheritance (just like members default to private access if you do not specify otherwise).

That gives us 9 combinations: 3 member access specifiers (public, private, and protected), and 3 inheritance types (public, private, and protected).

The rest of this section will be devoted to explaining the difference between these.

Before we get started, the following should be kept in mind as we step through the examples. There are three ways that members can be accessed:

• A class can always access it’s own members regardless of access specifier.
• The public accesses the members of a class based on the access specifiers of that class.
• A derived class accesses inherited members based on the access specifiers of its immediate parent. A derived class can always access it’s own members regardless of access specifier.

This may be a little confusing at first, but hopefully will become clearer as we step through the examples.

Public inheritance

Public inheritance is by far the most commonly used type of inheritance. In fact, very rarely will you use the other types of inheritance, so your primary focus should be on understanding this section. Fortunately, public inheritance is also the easiest to understand. When you inherit a base class publicly, all members keep their original access specifications. Private members stay private, protected members stay protected, and public members stay public.

view source

print?

01.class Base

02.{

03.public:

04.    int m_nPublic;

05.private:

06.    int m_nPrivate;

07.protected:

08.    int m_nProtected;

09.};

10.  

11.class Pub: public Base

12.{

13.    // Public inheritance means:

14.    // m_nPublic stays public

15.    // m_nPrivate stays private

16.    // m_nProtected stays protected

17.  

18.    Pub()

19.    {

20.        // The derived class always uses the immediate parent's class access specifications

21.        // Thus, Pub uses Base's access specifiers

22.        m_nPublic = 1; // okay: anybody can access public members

23.        m_nPrivate = 2; // not okay: derived classes can't access private members in the base class!

24.        m_nProtected = 3; // okay: derived classes can access protected members

25.    }

26.};

27.  

28.int main()

29.{

30.    // Outside access uses the access specifiers of the class being accessed.

31.    // In this case, the access specifiers of cPub.  Because Pub has inherited publicly from Base,

32.    // no access specifiers have been changed.

33.    Pub cPub;

34.    cPub.m_nPublic = 1; // okay: anybody can access public members

35.    cPub.m_nPrivate = 2; // not okay: can not access private members from outside class

36.    cPub.m_nProtected = 3; // not okay: can not access protected members from outside class

37.}

This is fairly straightforward. The things worth noting are:

1. Derived classes can not directly access private members of the base class.
2. The protected access specifier allows derived classes to directly access members of the base class while not exposing those members to the public.
3. The derived class uses access specifiers from the base class.
4. The outside uses access specifiers from the derived class.

To summarize in table form:

Public inheritance
Base access specifier	Derived access specifier	Derived class access?	Public access?
Public	Public	Yes	Yes
Private	Private	No	No
Protected	Protected	Yes	No

Private inheritance

With private inheritance, all members from the base class are inherited as private. This means private members stay private, and protected and public members become private.

Note that this does not affect that way that the derived class accesses members inherited from its parent! It only affects the code trying to access those members through the derived class.

view source

print?

01.class Base

02.{

03.public:

04.    int m_nPublic;

05.private:

06.    int m_nPrivate;

07.protected:

08.    int m_nProtected;

09.};

10.  

11.class Pri: private Base

12.{

13.    // Private inheritance means:

14.    // m_nPublic becomes private

15.    // m_nPrivate stays private

16.    // m_nProtected becomes private

17.  

18.    Pri()

19.    {

20.        // The derived class always uses the immediate parent's class access specifications

21.        // Thus, Pub uses Base's access specifiers

22.        m_nPublic = 1; // okay: anybody can access public members

23.        m_nPrivate = 2; // not okay: derived classes can't access private members in the base class!

24.        m_nProtected = 3; // okay: derived classes can access protected members

25.    }

26.};

27.  

28.int main()

29.{

30.    // Outside access uses the access specifiers of the class being accessed.

31.    // Note that because Pri has inherited privately from Base,

32.    // all members of Base have become private when access through Pri.

33.    Pri cPri;

34.    cPri.m_nPublic = 1; // not okay: m_nPublic is now a private member when accessed through Pri

35.    cPri.m_nPrivate = 2; // not okay: can not access private members from outside class

36.    cPri.m_nProtected = 3; // not okay: m_nProtected is now a private member when accessed through Pri

37.  

38.    // However, we can still access Base members as normal through Base:

39.    Base cBase;

40.    cBase.m_nPublic = 1; // okay, m_nPublic is public

41.    cBase.m_nPrivate = 2; // not okay, m_nPrivate is private

42.    cBase.m_nProtected = 3; // not okay, m_nProtected is protected

43.}

To summarize in table form:

Private inheritance
Base access specifier	Derived access specifier	Derived class access?	Public access?
Public	Private	Yes	No
Private	Private	No	No
Protected	Private	Yes	No

Protected inheritance

Protected inheritance is the last method of inheritance. It is almost never used, except in very particular cases. With protected inheritance, the public and protected members become protected, and private members stay private.

To summarize in table form:

Protected inheritance
Base access specifier	Derived access specifier	Derived class access?	Public access?
Public	Protected	Yes	No
Private	Private	No	No
Protected	Protected	Yes	No

Protected inheritance is similar to private inheritance. However, classes derived from the derived class still have access to the public and protected members directly. The public (stuff outside the class) does not.

Summary

The way that the access specifiers, inheritance types, and derived classes interact causes a lot of confusion. To try and clarify things as much as possible:

First, the base class sets it’s access specifiers. The base class can always access it’s own members. The access specifiers only affect whether outsiders and derived classes can access those members.

Second, derived classes have access to base class members based on the access specifiers of the immediate parent. The way a derived class accesses inherited members is not affected by the inheritance method used!

Finally, derived classes can change the access type of inherited members based on the inheritance method used. This does not affect the derived classes own members, which have their own access specifiers. It only affects whether outsiders and classes derived from the derived class can access those inherited members.

A final example:

01.class Base

02.{

03.public:

04.    int m_nPublic;

05.private:

06.    int m_nPrivate;

07.protected:

08.    int m_nProtected;

09.};

Base can access it’s own members without restriction. The public can only access m_ n Public. Derived classes can access m_nPublic and m_nProtected.

01.class D2: private Base

02.{

03.public:

04.    int m_nPublic2;

05.private:

06.    int m_nPrivate2;

07.protected:

08.    int m_nProtected2;

09.}

D2 can access it’s own members without restriction. D2 can access Base’s members based on Base’s access specifiers. Thus, it can access m_nPublic and m_nProtected, but not m_nPrivate. Because D2 inherited Base privately, m_nPublic, m_nPrivate, and m_nProtected are now private when accessed through D2. This means the public can not access any of these variables when using a D2 object, nor can any classes derived from D2.

01.class D3: public D2

02.{

03.public:

04.    int m_nPublic3;

05.private:

06.    int m_nPrivate3;

07.protected:

08.    int m_nProtected3;

09.};

D3 can access it’s own members without restriction. D3 can access D2’s members based on D2’s access specifiers. Thus, D3 has access to m_nPublic2 and m_nProtected2, but not m_nPrivate2. D3 access to Base members is controlled by the access specifier of it’s immediate parent. This means D3 does not have access to any of Base’s members because they all became private when D2 inherited them.