Upcasting:
First, we will look into the upcasting. Converting the derived class pointer to the base class pointer or converting the derived class reference to the base class reference is called upcasting. It allows public inheritance without the need for an explicit typecast.
A Derived object is-a relationship with the base class. The derived class can get the properties of the base class, nothing but it can inherit the data members and member function of the base class.
This means, anything that we can do to a Base object, we can do to a Derived class object.
Downcasting:
Downcasting is exactly opposite to upcasting the opposite of upcasting. It is a process of converting a base-class pointer or reference to a derived-class pointer or reference.
It should possible with the explicit type conversion. Because a derived class could add new data members, the class member functions that used these data members wouldn’t apply to the base class.
Let us look into the small example which will give us clear picture about the upcasting and down casting
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
#include <iostream> using namespace std; class MyPrince { private: int id; public: void DispId () { cout << "I am in the principle class" << endl; } }; class MyStuent : public MyPrince { public: void Disaply () { cout << "I am in the MyStudent class" << endl; } }; int _tmain (int argc, _TCHAR* argv[]) { MyPrince ocPrince; MyStuent ocStuent; // upcast - implicit upcast allowed MyPrince *prince = &ocStuent; // downcast - explicit type cast required MyStuent *pcStudent = (MyStuent *)&ocPrince; // Upcasting: safe - prince->DispId (); pcStudent->DispId (); // Downcasting: unsafe - pcStudent->Disaply(); getchar (); return 0; } |
The output of the above program is:
|
1 2 3 4 5 |
I am in the principle class I am in the principle class I am in the MyStudent class |
The typeid in C++:
If we want to find the two objects are of the same type, we will have the option of typeid. Using the typeid we will find the type of the object.
In the previous example for Upcasting and Downcasting, MyStudent gets the method Disaply() which is not desirable. So, we need to check if a pointer is pointing to the MyStudent object before we use the method, Disaply ().
Note that we included <typeinfo> in the example. The typeid operator returns a reference to a type_info object, where type_info is a class defined in the typeinfo header file.
Here is a new code showing how to use typeid:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
#include <typeinfo> class Principle { private: int id; public: void DispId() { cout << "I am in the Principle class" << endl;} }; class MyStudent : public Principle { public: void Disaply() { cout << "I am in the MyStudent class" << endl; } }; int main() { Principle ocPrince; MyStudent ocStudent; Principle *pcPri = &ocPrince; Principle *pcPri2 = &ocStudent; // check if two object is the same if(typeid(MyStudent) == typeid(ocPrince)) { MyStudent *pProg = (MyStudent *)&ocPrince; pProg->Disaply(); } if(typeid(MyStudent) == typeid(ocStudent)) { MyStudent *pProg = (MyStudent *)&ocStudent; pProg->Disaply(); } pcPri->DispId(); pcPri2->DispId(); getchar (); return 0; } |
The output of the above program is:
|
1 2 3 |
I am in the MyStudent class I am in the Principle class I am in the Principle class |
Only a MyStudent uses the Disaply () method.