undefined | unit 2 inheritance and pointers

OOP

UNIT 2

Inheritance and Pointers

Explain Single Inheritance in detail with example

Single inheritance is defined as the inheritance in which a derived class is inherited from the only one base class.

Where 'A' is the base class, and 'B' is the derived class.

C++ Single Level Inheritance Example: Inheriting Fields

When one class inherits another class, it is known as single level inheritance. Let's see the example of single level inheritance which inherits the fields only.

#include <iostream>

using namespace std;

class Account {

public:

float salary = 60000;

};

class Programmer: public Account {

public:

float bonus = 5000;

};

int main(void) {

Programmer p1;

cout<<"Salary: "<<p1.salary<<endl;

cout<<"Bonus: "<<p1.bonus<<endl;

return 0;

}

Output:

Salary: 60000

Bonus: 5000

In the above example, Employee is the base class and Programmer is the derived class.

C++ Single Level Inheritance Example: Inheriting Methods

Let's see another example of inheritance in C++ which inherits methods only.

#include <iostream>

using namespace std;

class Animal {

public:

void eat() {

cout<<"Eating..."<<endl;

}

};

class Dog: public Animal

{

public:

void bark(){

cout<<"Barking...";

}

};

int main(void) {

Dog d1;

d1.eat();

d1.bark();

return 0;

}

Output:

Eating...

Barking...

Let's see a simple example.

#include <iostream>

using namespace std;

class A

{

int a = 4;

int b = 5;

public:

int mul()

{

int c = a*b;

return c;

}

};

class B : private A

{

public:

void display()

{

int result = mul();

std::cout <<"Multiplication of a and b is : "<<result<< std::endl;

}

};

int main()

{

B b;

b.display();

return 0;

}

Output:

Multiplication of a and b is : 20

In the above example, class A is privately inherited. Therefore, the mul() function of class 'A' cannot be accessed by the object of class B. It can only be accessed by the member function of class B.

2. Explain Multilevel Inheritance in detail with example

Multilevel inheritance is a process of deriving a class from another derived class.

C++ Multi Level Inheritance Example

When one class inherits another class which is further inherited by another class, it is known as multi level inheritance in C++. Inheritance is transitive so the last derived class acquires all the members of all its base classes.

Let's see the example of multi level inheritance in C++.

#include <iostream>

using namespace std;

class Animal {

public:

void eat() {

cout<<"Eating..."<<endl;

}

};

class Dog: public Animal

{

public:

void bark(){

cout<<"Barking..."<<endl;

}

};

class BabyDog: public Dog

{

public:

void weep() {

cout<<"Weeping...";

}

};

int main(void) {

BabyDog d1;

d1.eat();

d1.bark();

d1.weep();

return 0;

}

Output:

Eating...

Barking...

Weeping...

C++ Multiple Inheritance

Multiple inheritance is the process of deriving a new class that inherits the attributes from two or more classes.

Syntax of the Derived class:

class D : visibility B-1, visibility B-2, ?

{

// Body of the class;

}

Let's see a simple example of multiple inheritance.

#include <iostream>

using namespace std;

class A

{

protected:

int a;

public:

void get_a(int n)

{

a = n;

}

};

class B

{

protected:

int b;

public:

void get_b(int n)

{

b = n;

}

};

class C : public A,public B

{

public:

void display()

{

std::cout << "The value of a is : " <<a<< std::endl;

std::cout << "The value of b is : " <<b<< std::endl;

cout<<"Addition of a and b is : "<<a+b;

}

};

int main()

{

C c;

c.get_a(10);

c.get_b(20);

c.display();

return 0;

}

Output:

The value of a is : 10

The value of b is : 20

Addition of a and b is : 30

In the above example, class 'C' inherits two base classes 'A' and 'B' in a public mode.

3. Explain Hierarchical Inheritance in detail with example

Hierarchical inheritance is defined as the process of deriving more than one class from a base class.

Syntax of Hierarchical inheritance:

class A

{

// body of the class A.

}

class B : public A

{

// body of class B.

}

class C : public A

{

// body of class C.

}

class D : public A

{

// body of class D.

}

Let's see a simple example:

#include <iostream>

using namespace std;

class Shape // Declaration of base class.

{

public:

int a;

int b;

void get_data(int n,int m)

{

a= n;

b = m;

}

};

class Rectangle : public Shape // inheriting Shape class

{

public:

int rect_area()

{

int result = a*b;

return result;

}

};

class Triangle : public Shape // inheriting Shape class

{

public:

int triangle_area()

{

float result = 0.5*a*b;

return result;

}

};

int main()

{

Rectangle r;

Triangle t;

int length,breadth,base,height;

std::cout << "Enter the length and breadth of a rectangle: " << std::endl;

cin>>length>>breadth;

r.get_data(length,breadth);

int m = r.rect_area();

std::cout << "Area of the rectangle is : " <<m<< std::endl;

std::cout << "Enter the base and height of the triangle: " << std::endl;

cin>>base>>height;

t.get_data(base,height);

float n = t.triangle_area();

std::cout <<"Area of the triangle is : " << n<<std::endl;

return 0;

}

Output:

Enter the length and breadth of a rectangle:

Area of the rectangle is : 460

Enter the base and height of the triangle:

Area of the triangle is : 5

4. Explain public members with example

The public Members

A public member is accessible from anywhere outside the class but within a program. You can set and get the value of public variables without any member function as shown in the following example −

#include <iostream>

using namespace std;

class Line {

public:

double length;

void setLength( double len );

double getLength( void );

};

// Member functions definitions

double Line::getLength(void) {

return length ;

}

void Line::setLength( double len) {

length = len;

}

// Main function for the program

int main() {

Line line;

// set line length

line.setLength(6.0);

cout << "Length of line : " << line.getLength() <<endl;

// set line length without member function

line.length = 10.0; // OK: because length is public

cout << "Length of line : " << line.length <<endl;

return 0;

}

When the above code is compiled and executed, it produces the following result −

Length of line : 6

Length of line : 10

5. Explain private members with example

The private Members

A private member variable or function cannot be accessed, or even viewed from outside the class. Only the class and friend functions can access private members.

By default all the members of a class would be private, for example in the following class width is a private member, which means until you label a member, it will be assumed a private member −

class Box {

double width;

public:

double length;

void setWidth( double wid );

double getWidth( void );

};

Practically, we define data in private section and related functions in public section so that they can be called from outside of the class as shown in the following program.

#include <iostream>

using namespace std;

class Box {

public:

double length;

void setWidth( double wid );

double getWidth( void );

private:

double width;

};

// Member functions definitions

double Box::getWidth(void) {

return width ;

}

void Box::setWidth( double wid ) {

width = wid;

}

// Main function for the program

int main() {

Box box;

// set box length without member function

box.length = 10.0; // OK: because length is public

cout << "Length of box : " << box.length <<endl;

// set box width without member function

// box.width = 10.0; // Error: because width is private

box.setWidth(10.0); // Use member function to set it.

cout << "Width of box : " << box.getWidth() <<endl;

return 0;

}

When the above code is compiled and executed, it produces the following result −

Length of box : 10

Width of box : 10

6. Explain protected members with examples

The protected Members

A protected member variable or function is very similar to a private member but it provided one additional benefit that they can be accessed in child classes which are called derived classes.

You will learn derived classes and inheritance in next chapter. For now you can check following example where I have derived one child class SmallBox from a parent class Box.

Following example is similar to above example and here width member will be accessible by any member function of its derived class SmallBox.

#include <iostream>

using namespace std;

class Box {

protected:

double width;

};

class SmallBox:Box { // SmallBox is the derived class.

public:

void setSmallWidth( double wid );

double getSmallWidth( void );

};

// Member functions of child class

double SmallBox::getSmallWidth(void) {

return width ;

}

void SmallBox::setSmallWidth( double wid ) {

width = wid;

}

// Main function for the program

int main() {

SmallBox box;

// set box width using member function

box.setSmallWidth(5.0);

cout << "Width of box : "<< box.getSmallWidth() << endl;

return 0;

}

When the above code is compiled and executed, it produces the following result −

Width of box : 5

7. Explain constructor in detail with examples

The Class Constructor

A class constructor is a special member function of a class that is executed whenever we create new objects of that class.

A constructor will have exact same name as the class and it does not have any return type at all, not even void. Constructors can be very useful for setting initial values for certain member variables.

Following example explains the concept of constructor −

#include <iostream>

using namespace std;

class Line {

public:

void setLength( double len );

double getLength( void );

Line(); // This is the constructor

private:

double length;

};

// Member functions definitions including constructor

Line::Line(void) {

cout << "Object is being created" << endl;

}

void Line::setLength( double len ) {

length = len;

}

double Line::getLength( void ) {

return length;

}

// Main function for the program

int main() {

Line line;

// set line length

line.setLength(6.0);

cout << "Length of line : " << line.getLength() <<endl;

return 0;

}

When the above code is compiled and executed, it produces the following result −

Object is being created

Length of line : 6

Parameterized Constructor

A default constructor does not have any parameter, but if you need, a constructor can have parameters. This helps you to assign initial value to an object at the time of its creation as shown in the following example −

#include <iostream>

using namespace std;

class Line {

public:

void setLength( double len );

double getLength( void );

Line(double len); // This is the constructor

private:

double length;

};

// Member functions definitions including constructor

Line::Line( double len) {

cout << "Object is being created, length = " << len << endl;

length = len;

}

void Line::setLength( double len ) {

length = len;

}

double Line::getLength( void ) {

return length;

}

// Main function for the program

int main() {

Line line(10.0);

// get initially set length.

cout << "Length of line : " << line.getLength() <<endl;

// set line length again

line.setLength(6.0);

cout << "Length of line : " << line.getLength() <<endl;

return 0;

}

When the above code is compiled and executed, it produces the following result −

Object is being created, length = 10

Length of line : 10

Length of line : 6

Using Initialization Lists to Initialize Fields

In case of parameterized constructor, you can use following syntax to initialize the fields −

Line::Line( double len): length(len) {

cout << "Object is being created, length = " << len << endl;

}

Above syntax is equal to the following syntax −

Line::Line( double len) {

cout << "Object is being created, length = " << len << endl;

length = len;

}

If for a class C, you have multiple fields X, Y, Z, etc., to be initialized, then use can use same syntax and separate the fields by comma as follows −

C::C( double a, double b, double c): X(a), Y(b), Z(c) {

....

}

8. Explain destructor with examples

The Class Destructor

A destructor is a special member function of a class that is executed whenever an object of it's class goes out of scope or whenever the delete expression is applied to a pointer to the object of that class.

A destructor will have exact same name as the class prefixed with a tilde (~) and it can neither return a value nor can it take any parameters. Destructor can be very useful for releasing resources before coming out of the program like closing files, releasing memories etc.

Following example explains the concept of destructor −

#include <iostream>

using namespace std;

class Line {

public:

void setLength( double len );

double getLength( void );

Line(); // This is the constructor declaration

~Line(); // This is the destructor: declaration

private:

double length;

};

// Member functions definitions including constructor

Line::Line(void) {

cout << "Object is being created" << endl;

}

Line::~Line(void) {

cout << "Object is being deleted" << endl;

}

void Line::setLength( double len ) {

length = len;

}

double Line::getLength( void ) {

return length;

}

// Main function for the program

int main() {

Line line;

// set line length

line.setLength(6.0);

cout << "Length of line : " << line.getLength() <<endl;

return 0;

}

When the above code is compiled and executed, it produces the following result −

Object is being created

Length of line : 6

Object is being deleted

9. Explain Overriding Member Functions in detail with examples

If base class and derived class have member functions with same prototypes, such functions are called as overrided functions. They are used only in inheritance.

Example

class Base

{

public:

void Data()

{

cout<<”Base class”;

}

};

class Derived: public Base

{

public:

void Data() // overrided function

{

cout<<”Derived class”;

}

};

Object of base class is used to access base class version of member function and derived class object is used to access derived class version of member function. This is shown in program given below.

 Program

class Base

{

public:

void Data()

{

cout<<”Base class”;

}

};

class Derived: public Base

{

public:

void Data()

{

cout<<”Derived class”;

}

};

int main()

{

Base b;

Derived d;

b.Data();

d.Data ();

return 0;

}

//Defines Base class

//Defines function Data of Base class

//Defines “Derived” class that is sub class of “Base”.

//Defines function Data of “Derived” class

//Defines main

//Creates base class object

//Creates derived class object

//Calls Data function of base class

//Calls Data function of derived class

So output of above program will be :

Output

Base class

Derived class

Overriding is used in Inheritance and it is different than function overloading.

In function overloading functions have different prototypes while in function overriding functions have same prototypes.

10. Explain Class Hierarchies in detail with examples

When several classes are derived from common base class it is called hierarchical inheritance.

In C++ hierarchical inheritance, the feature of the base class is inherited onto more than one sub-class.

For example, a car is a common class from which Audi, Ferrari, Maruti etc can be derived.

Following block diagram highlights its concept.

C++ Hierarchical Inheritance Block Diagram

As shown in above block diagram, in C++ hierarchical inheritance all the derived classes have common base class. The base class includes all the features that are common to derived classes.

As in other inheritance, based on the visibility mode used or access specifier used while deriving, the properties of the base class are derived. Access specifier can be private, protected or public.

C++ Hierarchical Inheritance Syntax

class A // base class

{

..............

};

class B : access_specifier A // derived class from A

{

...........

} ;

class C : access_specifier A // derived class from A

{

...........

} ;

class D : access_specifier A // derived class from A

{

...........

} ;

C++ Hierarchical Inheritance Example

// hierarchial inheritance.cpp

#include <iostream>

using namespace std;

class A //single base class

{

public:

int x, y;

void getdata()

{

cout << "\nEnter value of x and y:\n"; cin >> x >> y;

}

};

class B : public A //B is derived from class base

{

public:

void product()

{

cout << "\nProduct= " << x * y;

}

};

class C : public A //C is also derived from class base

{

public:

void sum()

{

cout << "\nSum= " << x + y;

}

};

int main()

{

B obj1; //object of derived class B

C obj2; //object of derived class C

obj1.getdata();

obj1.product();

obj2.getdata();

obj2.sum();

return 0;

} //end of program

Output

Enter value of x and y:

Product= 6

Enter value of x and y:

Sum= 5

Explanation
In this example, there is only one base class A from which two class B and C are derived.

Both derived class have their own members as well as base class members.

The product is calculated in the derived class B, whereas, the sum is calculated in the derived class C but both use the values of x and y from the base class.

Sign Up