Quiz on Overloading and Overriding in C++

What is the right way to describe operator overloading in C++?

Which of the following operators cannot be overloaded?

What is the output of the following code snippet?
#include <iostream>
using namespace std;
class Division
{
            int num, num1;
public:
             Division(int a, int b) { num = a; num1 = b; }
             operator double() const {
             return double(num) / double(num1);
       }
};
int main() {
               Division d(10, 15);
               double val = d;
               cout << val;
               return 0;
}

If a binary operator is being overloaded by using the member function, how many arguments must be provided?

What is the output of the following code snippet? 
#include <iostream>
using namespace std;
class QuizOrbit {
  private:
     int quizes;
   public:
    QuizOrbit() {
        quizes = 0;
     }
     QuizOrbit(int q) {
      quizes = q;
    }
     friend ostream &operator<<( ostream &output, const QuizOrbit &O ) {
     output<< O.quizes;
     return output;
   }
};
int main() {
       QuizOrbit Q1(11), Q2(5);
       cout << “No. of Questions in Quiz1 are : ” << Q1 << endl;
       cout << “No. of Questions in Quiz2 are : ” << Q2 << endl;
       return 0;
}

What is the output of the following code snippet?
#include <iostream>
#include <string>
using namespace std;
class Student
{
            static int rollno;
  public:
           void show()
    {
                   rollno++;
                   cout<<rollno<<endl;
          }
};
int Student::rollno = 15;
int main()
{
            Student stu;
            stu.show();
            return 0;
}

What is the output of the following code snippet?
#include <iostream>
#include <string>
using namespace std;
class Student
{
            string name;
   public:
            void concatenate(string name, string surname)
      {
              cout<<name+surname<<endl;
          }

};
int main()
{
                Student stu;
                stu.concatenate(“annu”,”mehla”);
                return 0;
}

What is the output of the following code snippet?
#include<iostream>
using namespace std;
class Parent1
{
              int a;
public:
              Parent1(int aa = 0) : a(aa) {}
              void show() { cout << a << endl; }
};
class Parent2
{
                int b;
public:
                Parent2(int bb) :b(bb) {}
                operator Parent1() const { return Parent1(b); }
};
void display(Parent1 p)
{
               p.show();
}
int main()
{
              Parent2 p(1010);
              display(p);
              display(20);
              return 0;
}

What is the output of the following code snippet?
#include<iostream>
using namespace std;
int Addition(int x , int y = 20, int z=10)
{ return (x + y + z); }
int main()
{
   cout << Addition(10);
   return 0;
}

What is the output of the following code snippet?
#include <iostream>
using namespace std;
int Multiplication(int=0, int = 2);
int main()
{
   cout << Multiplication(5);
   return 0;
}
int Multiplication(int x, int y) { return (x*y); }

What is the output of the following code snippet?
#include <iostream>
using namespace std;
class Parent {
  public:
   void display() {
      cout << “Parent Function” << endl;
    }
};
class Child: public Parent {
  public:
    void display() {
       cout << “QuizOrbit” << endl;
   }
};
int main() {
  Child c1;
  c1.display();
  return 0;
}

What is the output of the following program?
#include <iostream>
using namespace std;
class Parent {
  public:
   void display() {
      cout << “Parent Function” << endl;
   }
};
class Child: public Parent {
 public:
   void display() {
     cout << “Child Function” << endl;
   }
};
int main() {
  Child c1;
  c1.Parent::display();
  return 0;
}

What is the output of the following program?
#include <iostream>
using namespace std;
class Parent {
 public:
  void display() {
    cout << “Parent Function” << endl;
  }
};
class Child: public Parent {
    public:
    void display() {
      cout << “Child Function” << endl;
        Parent::display();
     }
};
int main() {
    Child c1;
    c1.display();
    return 0;
}

What is the output of the following program?
#include <iostream>
using namespace std;
class Parent {
 public:
   void display() {
     cout << “Parent Function” << endl;
  }
};
class Child: public Parent {
   public:
     void display() {
        cout << “Child Function” << endl;
         Parent::display();
    }
};
int main() {
       Child c1;
       Parent* ptr = &c1;
       ptr->display();
       return 0;
}

Overriding the functions consists of the following: