Object Oriented Programming OOP Virtual Functions and Inheritance

Object Oriented Programming OOP, Virtual Functions and Inheritance

Inheritance C++ Classes provide a way to enforce the walls of data abstraction by encapsulating the data and operations. Inheritance and polymorphism allow you to derive new classes from existing classes. Software reusability is the main reason we do this. Life Animals Snakes Dogs Rats Plants Grass Orchid

Inheritance Animal Base Vehicle Toy Mammal SUV Horse Direct Inheritance Multiple Inheritance Represents derived classes Represents base classes

Syntax of Inheritance Class Vehicle{ // base class public: float mph; float weight; } Class Car: public Vehicle { // derived class public: char brand_name[100]; }

Member Accessibility A private member may be accessed only by methods within its class or by friends l A protected member may be accessed only by methods with its class hierarchy or friends l A public member is globally accessible l

Public Inheritance Each public member in the base class is public in the derived class l Each protected member in the base class is protected in the derived class l Each private member in the base class remains private in the base class and so is visible only in the base class l

Private Inheritance Each public member in the base class is private in the derived class l Each protected member in the base class is private in the derived class l Each private member in the base class remains private in the base class and so is visible in the base class l

Protected Inheritance Each public member in the base class is protected in the derived class l Each protected member in the base class is protected in the derived class l Each private member in the base class remains private in the base class and so is visible in the base class l

Protected Example class BC{// base class public: void set_x( int a ){x=a; } protected: int get_x() const{return x; } private: int x; }; class DC: public BC { public: void add(){ int c = get_x(); set_x( c+2); } }; int main(){ DC d; d. set_x(3); cout<<d. get_x<<‘n’; d. x =234; d. add(); };

Example of Public Inheritance Class B{// base class public: int x; protected: int w; private: int z; }; class D: public B{ public: int y; void set_w(int z) { w=a; } void base_w(B b) { b. w=0; } }; int main() { D d; d. x = 33; d. y = 33; d. w = 77; d. z = 88; }

Further Discussion l l Why is this bad? void base_w(B b) { b. w=0; } A derived class may access protected members that it inherits from a base class. A derived class may access these protected members precisely because, once inherited, they belong to the derived class A derived class may not access protected members of a base class object, that is, an object that belongs to the base class but not to the derived class.

Notes about Inheritance l l A private member is inherited but not visible in a derived class. Except for a friend function, only methods of a class can access a private member of that class A protected member is inherited and visible in a derived class. In general protected data should be avoided. The data can be made private and made accessible by protected accessors. For example, a class with private data members and protected accessors can be completely re-implemented without disturbing the interface.

Name Hiding A member in a derived class of the same name as the base class hides it. l The scope resolution operator can be used if access to the base class member is required. l If a derived class adds a method with the same name in the base class, the added method hides the base class’s method l

Name Hiding Example class BC{//base class public: void h(float); //BC: : h }; class DC: public BC{ // derived class public: void h( char[ ]); // danger: hides BC: : h }; int main(){ DC d 1; d 1. h(“Data Structures!”); // DC: : h d 1. h(707. 7); // ****ERROR: DC: : h hides BC: : h d 1. BC: : h(707. 7); // OK BC: : h }

Constructors under Inheritance class Animal{ protected: char species[Max. Name+1]; public: Animal() { strcpy(species, “ Animal”); } Animal(char* s) { strcpy(species, s); } }; class Primate: public Animal{ protected: heartcham; public: Primate(): Animal(“Primate”){} Primate(int n): Animal(”Primate”){heartcham=n; } } class Human: public Primate{ public: Human(): Primate(){}; Human(int c): Primate(c){} }; executes first Animal: : Animal() Primate: Primate() Human: : Human()

Destructors under Inheritance Constructors in an inheritance hierarchy fire in a a base class to derived class order l Destructors in an inheritance hierarchy fire in a derived class to a base class order l Constructors may not be virtual but destructors may be. Used when l n n constructors for the base and derived class dynamically allocated separate storage and the program dynamically allocates a class object

Constructors firing rules assume D is derived from B l l If D has constructors but B has no constructors, then the appropriate D constructor fires automatically If D has no constructors but B has constructors, then B must have a default constructor so that B’s default constructor can fire whenever a D object is created. If D has constructors and B has a default constructor, then B’s default constructor fires automatically unless another is explicitly invoked. If D and B have constructors but B has no default constructor, then each D constructor must explicitly invoke, in its header, a B constructor.

What is the output? class B{ public: B( ) { cout << “B” << endl; } }; class D 1: public B{ public: D 1( ): B( ) { cout << “D 1” << endl; } }; class D 2: public D 1( ){ public: D 2( ): D 1( ) {cout << “D 2” << endl; }; D 2 d; Output: B D 1 D 2

Polymorphism & Virtual Methods Polymorphism is the runtime binding of a pointer to a method l Non-virtual methods are bound at compile time l A method that needs to be bound at runtime is labeled Virtual. l Only methods may be virtual l

Polymorphism class Pet{ Pet }; class Dog: public Pet{ public: virtual sound{cout<<“Bark”<<endl; } }; class Cat: public Pet{ Dog Cat c; Dog d; Pet * ptr 1, ptr 2; ptr 1 = &c; ptr 2=&d; public: virtual sound{cout<<“Meow”<<endl; } ptr 1 -> sound(); }; ptr 2 -> sound();

Inheritance and Virtual Methods l l l A pointer that points to a base class may also point to a subclass without casting. The reverse direction is not allowed. Once virtual always virtual. Figure * ptr Figure Ellipse Rect Circle

Pure Virtual Methods (Support for Programming Design) An abstract class is a base class that is required to have a derived class. No object may be dreated for an abstract class l An abstract class is one that has a pure virtual method in its class declaration l Class Pet { //abstract class public: virtual void sound()=0; }

Multiple Inheritance class Win{ //base class. . . } class Scroll. Win: public Win{ Widget horizontal. SB; Widget vertical. SB; . . . Win } Scroll. Win Popup. Menu Scroll. Popup. Menu class Popup. Menu{ protected: int menu. Choices; Win * menu. Sub. Wins; . . . } class Scroll. Popup. Menu: public Popup. Menu, public Scroll. Win{. . . }

Virtual Base Classes class B{//base class protected; int x; } class D 2: public virtual B{ protected: . . . } class D 1: public virtual B{ protected: . . . } class Z: public D 1, public D 2{. . . }; Note that the variable x gets inherited from B along two different paths. The virtual base classes guarantees that only one copy of x arrives at Z

Common Error (Slicing an Object) In C++ it is legal to copy a derived-class object into a base class variable. For example, when a Manager object is assigned to a variable of type Employee, the result is only the employee portion of the manager data; Manager m; Employee e=m // holds onlyt the Employee data The reverse assignment is not legal!