C++ L10-Inheritance

Mohammad Shaker
mohammadshaker.com
@ZGTRShaker
2010, 11, 12, 13, 14
C++
Programming Language
L10-INheritance

Introduction to Inheritance
•Two common types:
–“has –a ”
•Composition (as we have learned)
–Object containing one or more objects of other classes as members.
»A car has a steering wheel
–“Is –a ”
•Inheritance
–Derived class object treated as base class objects
»A car is a vehicle
»Vehicle properties / behaviors also car properties / behaviors

Inheritance
Computer
Computer
Keyboard
PC
“has –a ”
“ is –a ”

Inheritance, “ is –a ” Relationship
The link between classes in an “is –a ” relationship comes from the fact that the subclasses share all the attributes and behaviors found in the supper class, plus more!
Computer
PC
“ is –a ”

Computer
PC
“ is –a ”

Vehicle
Car
Bicycle
Motorcycle
“ is –a ”

Vehicle
Car
Boat
wheeled
Bicycle
Two-doors
four-doors

Inheritance
•Let’s have the following relationship
–Student and instructor (teacher)
•Fields:
–Name, address, phone
•Now, let’s build a class called person

Inheritance
•Now, we think that we can create the following class and carry on
•But we have the idea?
–Inheritance!
classStudent
{
private:
person UniversityStudent;
intStuID;
intStuRate;
};
classInstructor
{
private:
person UniversityInstructor;
intInsID;
intInsSalary;
};

Advantages of Inheritance
Person
Person
Student
Instructor
“has –a ” relationship

Person
Student
Instructor
“has –a ” relationship
ID, StuRate
Person
ID, InsSalary

Person
Person
Student
Instructor
“ is –a ”
“ is –a ”

Person
Student
Instructor
“ is –a ”

•What we do now, is that
–We create a “person” class then
•Inherit from it!
•What to inherit fromto?
–We Inherit class person to class
»Student
»Instructor
–And then, we carry on and add for each class of them their unique features! (ID, StuRate, StuSalaryetc)

•Advantages of inheritance:
–Saving time
–After saving time building the first part of the solution
•We can concentrate on building more complex materials up ahead
–Can extend or revise (edit) the parent class without corrupting the existing parent class features
–Absorb existing parent class’s data and behaviors
•All public, protected member variables in the main class are accessible from the derived class
•All behaviors inherited too
–Enhance with new capabilities
•Customizing
•Additional behaviors

Thinking Inheritance
•C++ Usability
•Creating a “Derived class” from “Base Class” *
•Base Class usually represent:
–Larger set of objects than derived class
–Characteristics that are shared between all of the derived classes
•Derived classes usually represent more specialized group of objects
•Sometimes
–Derived class inherit data members and data functions it does doesn’t need or should shouldn’t not have
______________________________________
*Base Class: also called Parent class, Super class, Ancestor
*Derived Class: also called Child Class, Sub Class, Descendant

Class Hierarchy types
•Direct Indirect:
–Direct class access
•Inherited explicitly (one level up)
–Indirect class access
•(one or two levels up hierarchy)
•Single Multiple:
–Single Inheritance
•From one base class
–Multiple Inheritance
•From multiple base class (only in C++, not in C++.NET, C#, Java, etc.)

Inheritance
Base class
Derived classes
Student
GraduateStudent, UndergraduateStudent
Shape
Circle, Triangle, Rectangle, Sphere, Cube
Loan
CarLoan, HomeImprovementLoan, MortgageLoan
Employee
Faculty, Staff
Account
CheckingAccount, SavingsAccount

Creating a Derived Class
•Notes:
–When inheriting with public specifier
•friend Functions are not inherited!
–When inheriting with private specifier
•Non of the public methods of the base class are accessible to the users of the derived class

#include<iostream>
usingnamespace::std;
classBaseClass
{
};
classDerivedClass: privateBaseClass
{
};
#include<iostream>
classBaseClass
{
};
classDerivedClass: publicBaseClass
{
};
#include<iostream>
classBaseClass
{
};
classDerivedClass: protectedBaseClass
{
};
#include<iostream>
classBaseClass
{
};
classDerivedClass:BaseClass
{
};
When ommiting private, public or protected then the default is private

classVehicle
{
public:
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
voidSetWeight (intx )
{weight = x;};
private:
intweight;
};
classCar: publicVehicle
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
{SetWeight(wt); speed = sp; }
intGetSpeed ()
{returnspeed; }
voidSetSpeed (intx )
{speed = x; }
private:
intspeed;
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
cout << MyCar.GetSpeed() << endl;
cout << MyCar.GetWeight() << endl;
MyCar.SetWeight(5);// member function in base class
MyCar.SetSpeed(10);
cout << "Printing"<< endl;
}
3
2
Printing
10
5
Press any key to continue

Live Demowith Lord of the Rings(Humans and Goblins inherit from Creatures)

Don’t forgetfriendfunctions are not inherited!

classVehicle
{
public:
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
friendvoidfoo(Car &C);
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9; }
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
cout << "After 1st change"<< endl;
MyCar.SetWeight(5);
MyCar.SetSpeed(10);
foo(MyCar);
cout << "After 2nd change"<< endl;
}
3
2
After 1st change
10
5
After 2nd change
9
5

classVehicle
{
public:
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
friendvoidfoo(Car C);
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
voidfoo(Car C)
{C.speed = 9; }
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.SetWeight(5);
MyCar.SetSpeed(10);
foo(MyCar);
}
3
2
After 1st change
10
5
After 2nd change
10
5

classVehicle
{
public:
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
friendvoidfoo(Car C);
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
voidfoo(Car C)
{C.weight= 9; }
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.SetWeight(5);
MyCar.SetSpeed(10);
foo(MyCar);
}
Compiler error, function foo must not access private data members of Vehicle

classVehicle
{
public:
Vehicle (){weight = 0; }
Vehicle (intwt){weight = wt; };
intGetWeight (){returnweight; }
voidSetWeight (intx ){weight = x;};
inttempWeight;
private:
intweight;
};
{
public:
Car(){speed = 0; }
Car(intwt, intsp){SetWeight(wt); speed = sp; }
intGetSpeed () {returnspeed; }
voidSetSpeed (intx ){speed = x; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.tempWeight = 5;
}
3
2
3
2

classVehicle
{
public:
inttempWeight;
private:
intweight;
};
{
public:
Car(){speed = 0; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9; C.TempWeight = 10; }
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
cout << MyCar.tempWeight << endl;
MyCar.tempWeight = 5;
foo(MyCar);
cout << MyCar.tempWeight << endl;
}
3
2
-858993460
9
2
10

protectedMembers
•Base class protected members
–Intermediate level of protection between public and private
–Protected data members are accessible through their own class and their own class’s derived classes
•Accessible to
–Base class members(like public)
–Base class friends(like public, private)
–Derived class members (like public)
–Derived class friends(like public)
•BUT NO ONE using base class directly can access them directly (like private)

protectedMembers
#include<iostream>
classVehicle
{
public:
private:
intweight;
};
{
public:
Car(){speed = 0; }
voidPrint() const{ cout << speed << "n"<< weight << endl; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.Print();
}
Compile error Car can’t access private data membes declared in its base class

protectedMembers
#include<iostream>
classVehicle
{
public:
protected:
intweight;
};
{
public:
Car(){speed = 0; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.Print();
}
3
2

protectedMembers
#include<iostream>
classVehicle
{
public:
protected:
intweight;
};
{
public:
Car(){speed = 0; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.weight = 3;
cout << MyCar.weight << endl;
}
Compiler error, can’t access protected data members directly from outside the class

protectedMembers
classVehicle
{
public:
protected:
intweight;
};
{
public:
Car(){speed = 0; }
Car(intwt, intsp){weight = wt; speed = sp; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.Print();
}
3
2

protectedMembers
•Problems of protected
–No validity checking between derived class and the base one
–Derived class can assign illegal values to protected members (since they can access them directly.)
–Implementation dependent
•Fragile (brittle) software

protectedMembers
#include<iostream>
classVehicle
{
public:
intGetWeight() const{returnweight; }
voidGetName1() const{ cout << "I'm a vehicle "<< endl; }
private:
intweight;
};
{
public:
Car(){speed = 0; }
Car(intwt, intsp){SetWeight(wt);speed = sp; }
voidGetName2() const{ cout << "I'm a car "<< endl; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
MyCar.GetName2();
}
I'm a car

protectedMembers
#include<iostream>
classVehicle
{
public:
voidGetName1() const{ cout << "I'm a vehicle "<< endl; }
private:
intweight;
};
{
public:
Car(){speed = 0; }
voidGetName2() const{ cout << "I'm a car "<< endl; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle MyVehicle;
MyVehicle.GetName1();
Car MyCar(2,3);
MyCar.GetName2();
}
I'm a vehicle
I'm a car

protectedMembers
classVehicle
{
public:
voidOverFun(){cout<< "In Vehicle class n";}
private:
intweight;
};
{
public:
Car(){speed = 0; }
voidOverFun()
{
cout << "In car class"<< endl; Vehicle::OverFun();
// overriding here with::
}
private:intspeed;};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle MyVehicle;
Car MyCar(2,3);
cout << "Printing with Vehicle:"<< endl;
MyVehicle.OverFun();
cout << "Printing with car:"<< endl;
MyCar.OverFun();
}
Printing with Vehicle:
In Vehicle class
Printing with car:
In car class
In Vehicle class

What You Can’t Inherit
•The following never ever can be inherited
–Constructors
–Destructors
–Friends
–Static data members
–Static member functions
–new operator
–“=“ operator

Overriding Base Class Behavior

Overriding Base Class Behavior
•What’s overriding overloading?
–Any child class function with the same name and same argument list as the parent
•overrides the parent function
–Any child class with the same name, yet with different argument list as for the parent
•overloads the parent function

Constructors and Inheritance
•When instantiate a derived class, a constructor for its base class is called first followed by the derived class constructor.
•Chains of constructors calls
–Base class constructor called last, but
–First to finish executing
•Example: Point Circle Cylinder
–Point constructor called last, but
–Point constructor body finishes executing first

#include<iostream>
classVehicle
{
public:
Vehicle (){cout << "I'm a vehicle!"<< endl; weight = 0; }
private:
intweight;
};
{
public:
Car(){ cout << "I'm a car!"<< endl; speed = 0; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle MyVehicle;
}
I'm a vehicle!

#include<iostream>
classVehicle
{
public:
private:
intweight;
};
{
public:
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar;
}
I'm a vehicle!
I'm a car!

#include<iostream>
classVehicle
{
public:
private:
intweight;
};
{
public:
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar();
}

#include<iostream>
classVehicle
{
public:
private:
intweight;
};
{
public:
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle My();
}

#include<iostream>
classVehicle
{
public:
private:
intweight;
};
{
public:
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle My();
My.GetWeight();
}
Compiler error

#include<iostream>
classVehicle
{
public:
private:
intweight;
};
{
public:
intGetSpeed () {Vehicle::Vehicle(); returnspeed; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar;
}
I'm a vehicle!
I'm a car!
I'm a vehicle!
0

classVehicle
{
public:
Vehicle (intwt){cout << "I'm a vehicle!"<< endl; weight += wt; };
private:
intweight;
};
{
public:
intGetSpeed () {Vehicle::Vehicle(5); returnspeed; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar;
}
I'm a vehicle!
I'm a car!
0
I'm a vehicle!
0
I'm a vehicle!
0
0

classVehicle
{
public:
private:
intweight;
};
{
public:
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar;
MyCar.SetWeight(4);
}
I'm a vehicle!
I'm a car!
0
I'm a vehicle!
0
4

classVehicle
{
public:
private:
intweight;
};
{
public:
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar;
MyCar.SetWeight(4);
}
I'm a vehicle!
I'm a car!
0
I'm a vehicle!
0
4
I'm a vehicle!
0
4

classVehicle
{
public:
Vehicle (){ weight = 0; }
Vehicle (intwt){ weight = wt; };
private:
intweight;
};
{
public:
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar (2,3);
}
3
2

Code Cracking
classVehicle
{
public:
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
Compiler error. We didn’t define the 0 parameter Vehicle constructor and but we used it in the (0 parameter constructor of the) derived class

Code Cracking
classVehicle
{
public:
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
The derived class implicitly call the base class constructor!

Code Cracking
classVehicle
{
public:
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
The compiler looks for a matching non- parameter base class constructor but can’t find one!

Code Cracking
classVehicle
{
public:
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
To solve this, 2 ways:
1.define an non-parameter base class constructor.
2.call the parametric base class constructor (the one with parameters) and make an explicit call for it from the derived class.

Code Cracking
classVehicle
{
public:
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
classCar: private Vehicle
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
Error1error C2247: 'Vehicle::GetWeight' not accessible because 'Car' uses 'private' to inherit from 'Vehicle'c:userszmeedocumentsvisual studio 2008projectsexamexamexam.cpp11Exam
Error2error C2247: 'Vehicle::SetWeight' not accessible because 'Car' uses 'private' to inherit from 'Vehicle'c:userszmeedocumentsvisual studio 2008projectsexamexamexam.cpp13Exam

Code Cracking
classVehicle
{
public:
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
{weight = wt; speed = sp; }
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
Compiler error. Can’t access private data member of the base class directly

Creating a Derived ClassAs we have seen, derived class can affect state changes in private base-class members. BUT ONLY THROUGH, Non-private functions provided in the base class and inherited into the derived class.

Code Cracking
classVehicle
{
public:
friendvoidfoo(Vehicle &V);
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
voidfoo(Vehicle &V)
{V.weight = 9; }
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle V;
Car MyCar(2,3);
MyCar.SetSpeed(10);
MyCar.foo(V);
}
Printing
10
5

Code Cracking
classVehicle
{
public:
friendvoidfoo(Vehicle &V);
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
voidfoo(Vehicle &V)
{V.weight = 9; }
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle V;
Car MyCar(2,3);
MyCar.SetSpeed(10);
foo(V);
}
Compiler error. foo is not a member functions in Car. It’s not inherited!

Constructors and Destructors
•Chain of destructors calls
–Reverse order of constructor chain
–Destructor of the derived class called first
–Destructor of the next class up hierarchy called next
•Continue up hierarchy until final base class is reached
•After final base class destructor, object is removed from memory

classVehicle
{
public:
Vehicle (intwt){ weight = wt; cout <<"Vehicle class "<< weight << endl;};
~Vehicle(){cout << "Destructing vehicle class for "<< weight << endl; }
private:
intweight;
};
{
public:
Car(intwt, intsp):Vehicle(wt){speed = sp; cout <<"Car class for "
<< speed << "-"<< GetWeight() << endl; }
~Car(){cout << "Destructing car class for "<< speed << "-" << GetWeight() << endl; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
#include<iostream>
#include"Testing.h"
voidmain()
{
Vehicle V1;
{
Vehicle V2;
Car MyCar1 (2,3);
}
Car MyCar2 (2,3);
Car MyCar3 (2,3);
Vehicle V3;
}
Vehicle class 2
Car class for 3-2
Destructing car class for 3-2
Destructing vehicle class for 2
Vehicle class 2
Car class for 3-2
Vehicle class 2
Car class for 3-2

classVehicle
{
public:
Vehicle (intwt){ weight = wt; cout <<"Vehicle class "<< weight << endl;};
~Vehicle(){cout << "Destructing vehicle class for "<< weight << endl; }
private:
intweight;
};
{
public:
Car(intwt, intsp):Vehicle(wt){speed = sp; cout <<"Car class for "
<< speed << "-"<< GetWeight() << endl; }
~Car(){cout << "Destructing car class for "<< speed << "-" << weight << endl; }
private:
intspeed;
};
voidfoo(Car &C)
{C.speed = 9;}
Compiler error, accessing private data member of vehicle

Single VS Multiple Inheritance

Multiple Inheritance
•Looks like the single inheritance
•Except!
–There’s multiple base classes
–Separated by commas
–Individually can be declared as public, protected or private
•Default is private
–Inherited member variables are accessible according to the rules of single inheritance
•Name conflicts
–Can result in a member of a base class being hidden by the member of the derived class with the same name.

#include<iostream>
classOptionList
{
public:
OptionList(){cout << "OptionList constructor n";};
~OptionList(){cout << "OptionList destructor n";};
};
classWindow
{
public:
Window(){cout << "Window constructor n";};
~Window(){cout << "Window destructor n";};
};
classMenu: publicOptionList, publicWindow
{
public:
Menu(){cout << "Menu constructor n";};
~Menu(){cout << "Menu destructor n";};
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M;
}
OptionList constructor
Window constructor
Menu constructor
Menu destructor
Window destructor
OptionList destructor

#include<iostream>
classOptionList
{
public:
};
classWindow
{
public:
};
classMenu: publicWindow, publicOptionList
{
public:
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M;
}
Window constructor
Menu constructor
Menu destructor
Window destructor
The constructors runs in order of declaration

#include<iostream>
classOptionList
{
public:
};
classWindow
{
public:
};
{
public:
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M();
}

#include<iostream>
classOptionList
{
public:
//OptionList(){cout << "OptionList constructor n";};
};
classWindow
{
public:
//Window(){cout << "Window constructor n";};
};
{
public:
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M;
}
Menu constructor
Menu destructor
Window destructor

#include<iostream>
classOptionList
{
public:
OptionList(intx){cout << "OptionList constructor n";};
};
classWindow
{
public:
Window(inty){cout << "Window constructor n";};
};
{
public:
};
Compiler error

#include<iostream>
classOptionList
{
public:
};
classWindow
{
public:
};
{
public:
Menu(intn, intm):Window(n),OptionList(m){cout<<"Menu constructor n";};
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M;
}
Window constructor
Menu constructor
Menu destructor
Window destructor

#include<iostream>
classOptionList
{
public:
};
classWindow
{
public:
};
{
public:
Menu(intn, intm):OptionList(m),Window(n){cout<<"Menu constructor n";};
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M;
}
Window constructor
Menu constructor
Menu destructor
Window destructor

#include<iostream>
classOptionList
{
public:
voidHighLighting(){cout << "In OptionList n";};
};
classWindow
{
public:
voidHighLighting(){cout << "In Windown";};
};
{
public:
Menu(intn, intm):OptionList(n), Window(m){cout << "Menu constructor n";};
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M(2,3);
}
Compile and run

#include<iostream>
classOptionList
{
public:
};
classWindow
{
public:
};
{
public:
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M(2,3);
M.HighLighting();
}
Now, it’s a compiler error

#include<iostream>
classOptionList
{
public:
};
classWindow
{
public:
};
{
public:
};
#include<iostream>
#include"Testing.h"
voidmain()
{
Menu M(2,3);
M.Window::HighLighting();
M.OptionList::HighLighting();
}
Window constructor
Menu constructor
In Window
In OptionList
Menu destructor
Window destructor

Float, double, long double
C++ data types
Structured
Simple
Address
Pointer
Reference
enum
Floating
Array
Struct
Union
Class
Char, Short, int, long, bool
Integral

Nested ClassesClassesthat are defined inside another classes are called nested classesIn the public, private or protected sectionSuch a nested class can be considered a member of the outer class

Nested classes
•Visibility
–In public section:
•Visible outside the outer class
–In private section:
•Visible only for the member of the outer class
–In protected section:
•Subclasses, derived from the outer class

Nested classes
classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst()
{returnxFirst; }
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond()
{returnxSecond
}
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
Class FirstWithin
Visibility
Both outside and inside
Member functions are globally visible
Intvariable is only visible to the class FirstWithin
Neither Surroundnor SecondWithincan access the variable of the class FirstWithin directly

Nested classes
classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst()
{returnxFirst; }
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond()
{returnxSecond
}
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
Class FirstWithin
Visibility
Both outside and inside
Member functions are globally visible
Intvariable is only visible to the class FirstWithin
Neither Surroundnor SecondWithincan access the variable of the class FirstWithin directly
Class SecondWith
Visibility
Just inside surround
Member functions can only be reached by the members of class SecondWithinonly
Intvariable is only visible to the class SecondWithin
Neither Surroundnor FirstWithincan access the variable of the class SecondWithindirectly

classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst();
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond();
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
intSurround::FirstWithin::GetVarFirst()
{returnxFirst; }
intSurround::SecondWithin::GetVarSecond()
{returnxSecond; }
Nested classes
classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst()
{returnxFirst; }
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond()
{returnxSecond
}
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
Note how we define the
member functions here

classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst();
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond();
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
{returnxFirst; }
{returnxSecond; }
Nested classes
classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst()
{returnxFirst; }
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond()
{returnxSecond
}
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
#include<iostream>
#include"MyFile.h"
voidmain()
{
Surround s;
Surround::FirstWithin First;
}
Compile & Run

classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst();
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond();
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
{returnxFirst; }
{returnxSecond; }
Nested classes
classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst()
{returnxFirst; }
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond()
{returnxSecond
}
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
voidmain()
{
Surround s;
Surround::SecondWithin Second;
}
Compiler error, can’t access private data members SecondWithin

classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst();
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond();
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
{returnxFirst; }
{returnxSecond; }
Nested classes
classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst()
{returnxFirst; }
private:
intxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond()
{returnxSecond
}
private:
intxSecond;
};
SecondWithin obj;
intxSurround;
};
voidmain()
{
Surround s;
s.obj.GetVarSecond();
}
Compile & Run

How can we access private data members is Nested Classes?

friend! Allowing the surrounding class to access private data members of the nested classes. The nested class to access the private data members of the surrounding class and other nested classes.

Access Private Members in Nested classes
classSurround
{
public:
classFirstWithin
{
friendclassSurround;
public:
FirstWithin();
intGetVarFirst();
private:
staticintxFirst;
};
private:
classSecondWithin
{
friendclasssurround;
public:
SecondWithin();
intGetVarSecond();
private:
staticintxSecond;
};
public:
SecondWithin obj;
intxSurround;
};
{FirstWithin::xFirst = SecondWithin::xSecond; returnxFirst; }
{FirstWithin::xFirst = 9; returnxSecond; }
Allowing The surrounding class to access private data members of the nested classes

classSurround
{
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst();
private:
staticintxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond();
private:
staticintxSecond;
};
public:
SecondWithin obj;
intxSurround;
};
{FirstWithin::xFirst = SecondWithin::xSecond; returnxFirst; }
{FirstWithin::xFirst = 9; returnxSecond; }
But we are still missing something
What is it?

classSurround
{
class FirstWithin;
class SecondWithin;
friend class FirstWithin;
friend class SecondWithin;
public:
classFirstWithin
{
public:
FirstWithin();
intGetVarFirst();
private:
staticintxFirst;
};
private:
classSecondWithin
{
public:
SecondWithin();
intGetVarSecond();
private:
staticintxSecond;
};
public:
SecondWithin obj;
intxSurround;
};
We should use Forward Declaration
So that classes can know other classes exist

Quiz #1
classVehicle
{
public:
Vehicle (char*n){ name = n; weight = 0; }
Vehicle (intwt, char* n ){ name=n; cout <<"Vehicle class "<< name << weight << endl;weight = wt; };
~Vehicle(){cout << "Destructing vehicle class for "<< name << weight << endl; }
private:
intweight;
char*name;
};
{
public:
Car(intwt, intsp, char*n1, char*n2):Vehicle(wt,n2){name = n1; cout <<"Car class for "<< name << speed << "-"<< GetWeight() << endl; speed = sp;}
~Car(){cout << "Destructing car class for "<< name << speed << "-"<< GetWeight() << endl; }
private:
intspeed;
char*name;
};
#include<iostream>
#include"Testing.h"
staticVehicle VG1("VG1");
Vehicle VG2("VG2");
voidmain()
{
Vehicle V1("1");
{
staticVehicle V2("2");
Car MyCar1 (2,3,"1","temp1");
}
Vehicle V3 ("3");
}
Vehicle class temp1-858993460
Car class for 1-858993460-2
Destructing vehicle class for temp12
Destructing vehicle class for VG20
Destructing vehicle class for VG10

Quiz #2
#include<iostream>
classVehicle
{
public:
Vehicle ()
{weight = 0; }
Vehicle (intwt)
{weight = wt; };
intGetWeight ()
{returnweight; }
{weight = x;};
private:
intweight;
};
{
public:
Car()
{speed = 0; }
Car(intwt, intsp)
intGetSpeed ()
{returnspeed; }
{speed = x; }
private:
intspeed;
};
voidfoo(Car &C)
{staticintx = 6; C.speed =+ x;x++; }
#include<iostream>
#include"Testing.h"
voidmain()
{
Car MyCar(2,3);
foo(MyCar);
MyCar.SetWeight(5);
MyCar.SetSpeed(10);
foo(MyCar);
foo(MyCar);
foo(MyCar);
}
3
2
7
5
8
5
9
5

C++ L10-Inheritance

More Related Content

What's hot

Similar to C++ L10-Inheritance

More from Mohammad Shaker

Recently uploaded

C++ L10-Inheritance