Explore topic-wise MCQs in C++ Programming.

#include <iostream>
 using namespace std;
 template<typename type>
 class Test
 {
 public:
 virtual type Function(type num1)
 {
 return num1 * 2;
 }
 };
 int main()
 {
 Test<int> num1;
 cout << num1.Function(150) << endl;
 return 0;
 }

#include <iostream>
 using namespace std;
 template <class type>
 class Sample
 {
 public:
 Sample()
 {
 };
 ~Sample()
 { 
 };
 type FunA(type num1)
 {
 return num1;
 }
 type FunB(type num2)
 {
 return num2;
 }
 };
 int main()
 {
 Sample<int> num1;
 Sample<double> num2;
 cout << num1.FunA(250) << " ";
 cout << num2.FunB(5.225);
 return 0;
 }

#include <iostream>
 using namespace std;
 template <typename T = float, int count = 3>
 T Multiply(T num1)
 {
 for(int kk = 0; kk < count; kk++)
 {
 num1 = num1 * num1;
 }
 return num1;
 };
 int main()
 {
 float num2 = 1.25;
 cout << num2 << " " << Multiply<>(num2) << endl;
 }

#include <iostream>
 using namespace std;
 template <class T>
 inline T square(T n1)
 {
 T Output;
 Output = n1 * n1;
 return Output;
 };
 template <>
 string square<string>(string Str)
 {
 return (Str + Str);
 };
 int main()
 {
 int k = 4, kk;
 string bb("B");
 kk = square<int>(k);
 cout << k << ": " << kk;
 cout << square<string>(bb) << ":" << endl;
 }

#include <iostream>
 using namespace std;
 template<class T = float, int k = 5> class N
 {
 public:
 N();
 int value;
 };
 template<> class N<> 
 { 
 public: N(); 
 };
 template<> class N<double, 10>
 { 
 public: N(); 
 };
 template<class T, int k> N<T, k>::N() : value(k)
 {
 cout << value;
 }
 N<>::N() 
 {
 cout << " Out of ";
 }
 N<double, 10>::N() 
 {
 cout << "10" << endl;
 }
 int main() 
 {
 N<int, 8> x;
 N<> y;
 N<double, 10> z;
 }

#include <iostream>
 #include <string>
 #include <cstring>
 using namespace std;
 template <class type>
 type Maximum(const type value1, const type value2)
 {
 cout << "No Specialization";
 return value1 < value2 ? value2 : value1;
 }
 template <>
 const char *Maximum(const char *value1, const char *value2)
 {
 return (strcmp(value1, value2) < 0) ? value2 : value1;
 }
 int main()
 {
 string S1 = "class", S2 = "template";
 const char *value3 = "Interveiw";
 const char *value4 = "Mania";
 const char *q = Maximum(value3, value4);
 cout << q << endl;
 return 0;
 }

#include <iostream>
 using namespace std;
 template<typename type>
 type Maximum(type num1, type num2)
 {
 return num1 > num2 ? num1:num2;
 }
 int main()
 {
 int Res;
 Res = Maximum(150, 250);
 cout << Res << endl;
 return 0;
 }

#include <iostream>
 using namespace std;
 class classA 
 {
 public:
 virtual ~classA(){}
 protected:
 char p;
 public:
 char getChar();
 };
 class classB : public classA 
 {
 public:
 void printChar();
 };
 void classB::printChar()
 {
 cout << "False" << endl;
 }
 int main() 
 {
 classB ch;
 ch.printChar();
 return 1;
 }

#include <iostream>
 using namespace std;
 template <class T>
 inline T square(T p)
 {
 T result;
 result = p * p;
 return result;
 };
 template <>
 string square<string>(string str)
 {
 return (str+str);
 };
 int main() 
 {
 int k = 4, kk;
 string bb("A");
 kk = square<int>(k);
 cout << k << kk;
 cout << square<string>(bb) << endl;
 }

#include <iostream>
 using namespace std;
 class BaseClass
 {
 public:
 BaseClass( )
 {
 cout << "I ";
 }
 ~BaseClass ( )
 {
 cout << " Mania";
 }
 };
 class DerivedClass : public BaseClass
 {
 public:
 DerivedClass ( )
 {
 cout << "Love ";
 }
 ~DerivedClass ( )
 {
 cout << "Interview";
 } 
 }; 
 int main( )
 {
 DerivedClass x;
 }

#include <iostream>
 using namespace std;
 template <class type>
 class Example
 {
 public:
 Example();
 ~Example();
 type Data(type);
 };
 template <class type>
 type Example<type>::Data(type Value0)
 {
 return Value0;
 }
 template <class type>
 Example<type>::Example()
 {
 }
 template <class type>
 Example<type>::~Example()
 {
 }
 int main(void)
 {
 Example<char> Value1;
 cout << Value1.Data('L') << endl;
 return 0;
 }

#include <iostream>
 using namespace std;
 template <class T>
 class N
 {
 public:
 N(int p): q(p) {}
 protected:
 int q;
 };
 template <class T>
 class M: public N<char>
 {
 public:
 M(): N<char>::N(50) 
 {
 cout << q * 3 << endl;
 }
 };
 int main()
 {
 M<char> test;
 return 0;
 }