CS 2133: Data Structures OOP, Virtual Functions and Inheritance.

CS 2133: Data Structures

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 Plants

Snakes Dogs Rats Grass Orchid

Inheritance

Animal

Mammal

Horse

Vehicle Toy

SUV

Direct Inheritance Multiple Inheritance

Base

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

A protected member may be accessed only by methods with its class hierarchy or friends

A public member is globally accessible

Public Inheritance

Each public member in the base class is public in the derived class

Each protected member in the base class is protected in the derived class

Each private member in the base class remains private in the base class and so is visible only in the base class

Private Inheritance

Each public member in the base class is private in the derived class

Each protected member in the base class is private in the derived class

Each private member in the base class remains private in the base class and so is visible in the base class

Protected Inheritance

Each public member in the base class is protected in the derived class

Each protected member in the base class is protected in the derived class

Each private member in the base class remains private in the base class and so is visible in the base class

Protected Example

class BC{// base classpublic: 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 classpublic: 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

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

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.

The scope resolution operator can be used if access to the base class member is required.

If a derived class adds a method with the same name in the base class, the added method hides the base class’s method

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 d1;

d1.h(“Data Structures!”); // DC::h

d1.h(707.7); // ****ERROR: DC::h hides BC::h

d1.BC::h(707.7); // OK BC::h

}

Constructors under Inheritance

class Animal{protected:char species[MaxName+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 firstAnimal::Animal()

Primate:Primate()

Human::Human()

Destructors under Inheritance

Constructors in an inheritance hierarchy fire in a a base class to derived class order

Destructors in an inheritance hierarchy fire in a derived class to a base class order

Constructors may not be virtual but destructors may be. Used when constructors for the base and derived class

dynamically allocated separate storage and the program dynamically allocates a class object

Constructors firing rulesassume D is derived from B

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 D1:public B{

public:D1( ):B( ) { cout << “D1” << endl; }

};

class D2: public D1( ){

public: D2( ): D1( ) {cout << “D2” << endl;

};

D2 d;Output:B D1 D2

Polymorphism & Virtual Methods

Polymorphism is the runtime binding of a pointer to a method

Non-virtual methods are bound at compile time

A method that needs to be bound at runtime is labeled Virtual.

Only methods may be virtual

Polymorphism

class Pet{

};

class Dog:public Pet{

public:virtual sound{cout<<“Bark”<<endl;}

};

class Cat:public Pet{

public:virtual sound{cout<<“Meow”<<endl;}

};

Pet

Dog Cat

Cat c; Dog d; Pet * ptr1, ptr2;

ptr1 = &c; ptr2=&d;

ptr1-> sound();

ptr2-> sound();

Inheritance and Virtual Methods

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

Ellipse Rect

Circle

Figure * ptr

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

An abstract class is one that has a pure virtual method in its class declaration

Class Pet { //abstract class

public:

virtual void sound()=0;

}

Multiple Inheritance

class Win{ //base class...}

class ScrollWin: public Win{Widget horizontalSB;Widget verticalSB;...}

class PopupMenu{protected: int menuChoices; Win * menuSubWins;...}

class ScrollPopupMenu: public PopupMenu, public ScrollWin{...}

Win

ScrollWin PopupMenu

ScrollPopupMenu

Virtual Base Classes

class B{//base classprotected; int x;}

class D1: public virtual B{protected:...}

class D2: public virtual B{protected:...}

class Z: public D1,public D2{...};

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!