Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
94 views

Object Oriented Programming (OOP) - CS304 Power Point Slides Lecture 22

Object-Oriented Programming (OOP) Lecture No. 22 discusses inheritance in classes. Inheritance allows a derived class to inherit characteristics from a base class. The derived class inherits all public members of the base class and can define its own unique characteristics. When a derived class object is created, the base class constructor is executed first before the derived class constructor. Destructors are called in the reverse order of constructors, with the derived class destructor called first.

Uploaded by

Sameer Hane
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
94 views

Object Oriented Programming (OOP) - CS304 Power Point Slides Lecture 22

Object-Oriented Programming (OOP) Lecture No. 22 discusses inheritance in classes. Inheritance allows a derived class to inherit characteristics from a base class. The derived class inherits all public members of the base class and can define its own unique characteristics. When a derived class object is created, the base class constructor is executed first before the derived class constructor. Destructors are called in the reverse order of constructors, with the derived class destructor called first.

Uploaded by

Sameer Hane
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 34

Object-Oriented Programming (OOP) Lecture No.

22

Inheritance in Classes
If

a class B inherits from class A, then B contains all the characteristics (information structure and behavior) of class A The parent class is called base class and the child class is called derived class Besides inherited characteristics, derived class may have its own unique characteristics

UML Notation
Parent Class Base Class

Child Class

Derived Class

Inheritance in C++
There

are three types of inheritance in C++

Public Private Protected

IS A Relationship
IS

A relationship is modeled with the help of public inheritance

Syntax

class ChildClass : public BaseClass{ ... };

Example
class Person{ ... }; class Student: public Person{ ... };

Accessing Members
Public

members of base class become public member of derived class Private members of base class are not accessible from outside of base class, even in the derived class (Information Hiding)

Example
class Person{ char *name; int age; ... public: const char *GetName() const; int GetAge() const; ... };

Example
class Student: public Person{ int semester; int rollNo; ... public: int GetSemester() const; int GetRollNo() const; void Print() const; ... };

Example
void Student::Print() ERROR { cout << name << is in << semester << semester; }

Example
void Student::Print() { cout << GetName() << is in semester << semester; }

Example
int main(){ Student stdt; stdt.semester = 0;//error stdt.name = NULL; //error cout << stdt.GetSemester(); cout << stdt.GetName(); return 0; }

Allocation in Memory
The

object of derived class is represented in memory as follows

base member1 base member2 ...

Data members of base class

derived member1 derived member2 ...

Data members of derived class

Allocation in Memory
Every

object of derived class has an anonymous object of base class

Constructors
The

anonymous object of base class must be initialized using constructor of base class When a derived class object is created the constructor of base class is executed before the constructor of derived class

Constructors
base member1 base member2 ... derived member1 derived member2 ... Base class constructor initializes the anonymous object
Derived class constructor initializes the derived class object

Example
class Parent{ public: Parent(){ cout << Parent Constructor...;} }; class Child : public Parent{ public: Child(){ cout << Child Constructor...;} };

Example
int main(){ Child cobj; return 0; }

Output: Parent Constructor... Child Constructor...

Constructor
If

default constructor of base class does not exist then the compiler will try to generate a default constructor for base class and execute it before executing constructor of derived class

Constructor
If

the user has given only an overloaded constructor for base class, the compiler will not generate default constructor for base class

Example
class Parent{ public: Parent(int i){} }; class Child : public Parent{ public: Child(){} } Child_Object; //ERROR

Base Class Initializer


C++

has provided a mechanism to explicitly call a constructor of base class from derived class syntax is similar to member initializer and is referred as base-class initialization

The

Example
class Parent{ public: Parent(int i){}; }; class Child : public Parent{ public: Child(int i): Parent(i) {} };

Example
class Parent{ public: Parent(){cout << Parent Constructor...;} ... }; class Child : public Parent{ public: Child():Parent() {cout << Child Constructor...;} ... };

Base Class Initializer


User

can provide base class initializer and member initializer simultaneously

Example
class Parent{ public: Parent(){} }; class Child : public Parent{ int member; public: Child():member(0), Parent() {} };

Base Class Initializer


The

base class initializer can be written after member initializer for derived class The base class constructor is executed before the initialization of data members of derived class.

Initializing Members
Derived

class can only initialize members of base class using overloaded constructors
Derived class can not initialize the public data member of base class using member initialization list

Example
class Person{ public: int age; char *name; ... public: Person(); };

Example
class Student: public Person{ private: int semester; ... public: Student(int a):age(a) { //error } };

Reason
It

will be an assignment not an initialization

Destructors
Destructors

are called in reverse order of constructor called Derived class destructor is called before the base class destructor is called

Example
class Parent{ public: Parent(){cout <<Parent Constructor;} ~Parent(){cout<<Parent Destructor;} }; class Child : public Parent{ public: Child(){cout << Child Constructor;} ~Child(){cout << Child Destructo;} };

Example
Output:

Parent Constructor Child Constructor Child Destructor Parent Destructor

You might also like