Initialize

Author: skn1998

tutorial19.cpp

@@ -0,0 +1,42 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+/*
+1. We can define a function in the sub class having same return type, same name, same arguments as that of one in the base class.
+2. In this case the method in the base class will get overridden by the method in the subclass. 
+3. To call the overridden base class method we can use scope resolution operator.
+4. We can aslo call the base class method inside the sub class method using svoe resolution operator.
+5. We can also call the base calss method by receiving the argument of type base class.
+*/
+
+class Human
+{
+	public:
+		void Introduce()
+		{
+			cout<<"Hello! I am a Human."<<endl;
+		}
+};
+
+class Student : public Human
+{
+	public:
+		void Introduce()
+		{
+			cout<<"Hello! I am a Student."<<endl;
+			Human :: Introduce(); // calling base class method from inside the class method.
+		}	
+};
+
+void WhoseThis(Human h) // here we are receiving saurav as of type Human instead of Person
+{
+	h.Introduce(); // since here saurav is of type human, Introduce of Human will get called
+}
+
+int main()
+{
+	Student saurav;
+	saurav.Introduce();
+	saurav.Human :: Introduce();  // calling base class overridden method.
+	WhoseThis(saurav);
+}

tutorial19.exe

@@ -0,0 +1,30 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+/*
+1. this pointer - this pointer holds the address of the current object when we call any (non - static) member function for any object.
+2. this pointer is available locally inside the function.
+3. this pointer is not available for static member functions and in friend functions. 
+4. it gets implicitally used inside the member function but we can also use it explicitally if needed.
+*/
+
+class Human
+{
+	int age;
+	public:
+		void setAge(int age) // local variable name is same as that of data member name 
+		{
+			this->age = age; // or *(this).age = age;
+		}
+		void showAge()
+		{
+			cout<<"My age is "<<age<<"."<<endl;
+		}
+};
+
+int main()
+{
+	Human saurav;
+	saurav.setAge(22);
+	saurav.showAge();
+}

tutorial20.cpp

@@ -0,0 +1,36 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+/*
+POLYMORPHISM - many forms
+1. Polymorphism can be classified into two categories : Compile Time and Run Time.
+2. Compile Time Polymorphism can be achieved using Function Overloading and Operator Overloading.
+3. Run Time Polymorphism is achieved using virtual functions.
+*/
+
+// Compile time polymorphism - Function Overloading
+
+class Number
+{
+	public:
+		void num()
+		{
+			cout<<"No number obtained."<<endl;
+		}
+		void num(int x)
+		{
+			cout<<"Number obtained is "<<x<<"."<<endl;
+		}
+		void num(int x, int y)
+		{
+			cout<<"Numbers obtained are "<<x<<" and "<<y<<"."<<endl;
+		}
+};
+
+int main()
+{
+	Number n;
+	n.num();
+	n.num(34);
+	n.num(12, 24);
+}

tutorial20.exe

@@ -0,0 +1,56 @@
+#include<bits/stdc++.h>
+using namespace std;
+/*
+POLYMORPHISM - many forms
+1. Polymorphism can be classified into two categories : Compile Time and Run Time.
+2. Compile Time Polymorphism can be achieved using Function Overloading and Operator Overloading.
+3. Run Time Polymorphism is achieved using virtual functions.
+*/
+
+// Run time polymorphism - Virtual Functions
+class Human
+{
+	public:
+		virtual void speak()
+		{
+			cout<<"Human is speaking."<<endl;
+		}
+		void sing()
+		{
+			cout<<"Human is singing."<<endl;
+		}
+};
+
+class Student : public Human
+{
+	public:
+		void speak()
+		{
+			cout<<"Student is speaking."<<endl;
+		}
+		void sing()
+		{
+			cout<<"Student is singing."<<endl;
+		}
+};
+
+void LetsSpeak(Human &h)  // Do not forget to receive as reference
+{
+	h.speak();
+}
+
+void LetsSing(Human &h)  // Do not forget to receive as reference
+{
+	h.sing();
+}
+
+int main()
+{
+	Student saurav;
+	LetsSpeak(saurav);
+	LetsSing(saurav);
+	
+	Human nishant;
+	LetsSpeak(nishant);
+	LetsSing(nishant);
+}

tutorial21.cpp

@@ -0,0 +1,49 @@
+#include<bits/stdc++.h>
+using namespace std;
+/*
+Run time polymorphism - Virtual Functions
+
+note - Even if we inherit a class that has inherited the class having a virtual function. The virtual nature gets inherited too.
+ 
+*/
+class Human
+{
+	public:
+		virtual void speak()
+		{
+			cout<<"Human is speaking."<<endl;
+		}
+};
+
+class Student : public Human
+{
+	public:
+		void speak()
+		{
+			cout<<"Student is speaking."<<endl;
+		}
+};
+
+class ChemicalStudent : public Student
+{
+	public:
+		void speak()
+		{
+			cout<<"Chemical Student is speaking."<<endl;
+		}
+};
+
+void LetsSpeak(Human &h)  // Do not forget to receive as reference
+{
+	h.speak();
+}
+
+int main()
+{
+	Human saurav;
+	Student ravi;
+	ChemicalStudent nishant;
+	LetsSpeak(saurav);
+	LetsSpeak(ravi);
+	LetsSpeak(nishant); 
+}