Inheritance

1. Inheritance • The mechanism by which one class can inherit the properties of another. • It allows a hierarchy of classes to be built, moving from the most general to the most specific.

2. Base Class, Derived Class • Base Class • Defines all qualities common to any derived classes. • Derived Class • Inherits those general properties and adds new properties that are specific to that class.

3. Example: Base Class class base { int x; public: void setx(int n) { x = n; } void showx() { cout << x << ‘\n’ } };

4. Example: Derived Class // Inherit as public class derived : public base { int y; public: void sety(int n) { y = n; } void showy() { cout << y << ‘\n’;} };

5. Access Specifier: public • The keyword public tells the compiler that base will be inherited such that: • all public members of the base class will also be public members of derived. • However, all private elements of base will remain private to it and are not directlyaccessible by derived.

6. Example: main() int main() { derived ob; ob.setx(10); ob.sety(20); ob.showx(); ob.showy(); }

7. An incorrect example class derived : public base { int y; public: void sety(int n) { y = n; } /* Error ! Cannot access x, which is private member of base. */ void show_sum() {cout << x+y; } };

8. Access Specifier: private • If the access specifier is private: • public members of base become private members of derived. • these members are still accessible by member functions of derived.

9. Example: Derived Class // Inherit as private class derived : private base { int y; public: void sety(int n) { y = n; } void showy() { cout << y << ‘\n’;} };

10. Example: main() int main() { derived ob; ob.setx(10); // Error! setx() is private. ob.sety(20); // OK! ob.showx(); // Error! showx() is private. ob.showy(); // OK! }

11. Example: Derived Class class derived : private base { int y; public: // setx is accessible from within derived void setxy(int n, int m) { setx(n); y = m; } // showx is also accessible void showxy() { showx(); cout<<y<< ‘\n’;} };

12. Protected Members • Sometimes you want to do the following: • keep a member of a base class private • allow a derived class access to it • Use protected members! • If no derived class, protected members is the same as private members.

13. Protected Members The full general form of a class declaration: class class-name { // private members protected: // protected members public: // public members };

14. 3 Types of Access Specifiers • Type 1: inherit as private

15. 3 Types of Access Specifiers • Type 2: inherit as protected

16. 3 Types of Access Specifiers • Type 3: inherit as public

17. Constructor and Destructor • It is possible for both the base class and the derived class to have constructor and/or destructor functions. • The constructor functions are executed in order of derivation. • i.e.the base class constructor is executed first. • The destructor functions are executed in reverse order.

18. Passing arguments • What if the constructor functions of both the base class and derived class take arguments? • Pass all necessary arguments to the derived class’s constructor. • Then pass the appropriate arguments along to the base class.

19. Example: Constructor of base class base { int i; public: base(int n) { cout << “constructing base \n”; i = n; } ~base() { cout << “destructing base \n”; } };

20. Example: Constructor of derived class derived : public base { int j; public: derived (int n, int m) : base (m) { cout << “constructing derived\n”; j = n; } ~derived() { cout << “destructing derived\n”;} };

21. Example: main() int main() { derived o(10,20); return 0; } constructing base constructing derived destructing derived destructing base

22. Multiple Inheritance • Type 1: base 1 derived 1 derived 2

23. Multiple Inheritance • Type 2: base 1 base 2 derived

24. Example: Type 2 // Create first base class class B1 { int a; public: B1(int x) { a = x; } int geta() { return a; } };

25. Example: Type 2 // Create second base class class B2 { int b; public: B2(int x) { b = x; } int getb() { return b; } };

26. Example: Type 2 // Directly inherit two base classes. class D : public B1, public B2 { int c; public: D(int x, int y, int z) : B1(z), B2(y) { c = x; } void show() { cout << geta() << getb() << c;} } ;

27. Potential Problem • Base is inherited twice by Derived 3! Base Base Derived 2 Derived 1 Derived 3

28. Virtual Base Class • To resolve this problem, virtual base class can be used. class base { public: int i; };

29. Virtual Base Class // Inherit base as virtual class D1 : virtual public base { public: int j; }; class D2 : virtual public base { public: int k; };

30. Virtual Base Class /* Here, D3 inherits both D1 and D2. However, only one copy of base is present */ class D3 : public D1, public D2 { public: int product () { return i * j * k; } };

31. Pointers to Derived Classes • A pointer declared as a pointer to base class can also be used to point to any class derived from that base. • However, only those members of the derived object that were inherited from the base can be accessed.

32. Example base *p; // base class pointer base B_obj; derived D_obj; p = &B_obj; // p can point to base object p = &D_obj; // p can also point to derived // object

33. Virtual Function • A virtual function is a member function • declared within a base class • redefined by a derived class (i.e. overriding) • It can be used to support run-time polymorphism.

34. Example class base { public: int i; base (int x) { i = x; } virtual void func() {cout << i; } };

35. Example class derived : public base { public: derived (int x) : base (x) {} // The keyword virtual is not needed. void func() {cout << i * i; } };

36. Example int main() { base ob(10), *p; derived d_ob(10); p = &ob; p->func();// use base’s func() p = &d_ob; p->func(); // use derived’s func() }

37. Pure Virtual Functions • A pure virtual function has no definition relative to the base class. • Only the function’s prototype is included. • General form: virtual type func-name(paremeter-list) = 0

38. Example: area class area { public: double dim1, dim2; area(double x, double y) {dim1 = x; dim2 = y;} // pure virtual function virtual double getarea() = 0; };

39. Example: rectangle class rectangle : public area { public: // function overriding double getarea() { return dim1 * dim2; } };

40. Example: triangle class triangle : public area { public: // function overriding double getarea() { return 0.5 * dim1 * dim2; } };