OBJECT-ORIENTED
PROGRAMMING
(OOP)
INHERITANCE IN CLASSES
Ifa 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
Parent Class Base Class
Child Class Derived Class
“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)
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 Data members of
derived member2 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 class constructor
base member2 initializes the
... anonymous object
derived member1 Derived class
derived member2 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
BASE CLASS INITIALIZER
C++ has provided a mechanism to explicitly call a
constructor of base class from derived class
The syntax is similar to member initializer and is
referred as base-class initialization
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
}
};
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
