Inheritance In C++ : MCQs & PYQs with Explanation

Option C

Virtual inheritance in C++ is used to solve the Diamond Problem that occurs in multiple inheritance. Without virtual inheritance, a derived class may receive multiple copies of the same base class due to different inheritance paths. To prevent this duplication, C++ allows a class to be inherited virtually.
This ensures that only one shared copy of the base class is passed to all derived classes, avoiding ambiguity and memory waste.
Diamond Problem:
When classes B and C both inherit from A, and D inherits from both B and C, D gets two copies of A's members.
   A
  /
 B   C
  /
   D

Option A

The given code demonstrates two core features of Object-Oriented Programming: encapsulation and inheritance.
Encapsulation means binding data and functions together inside a class. In the given code, class student { int marks; };, the variable marks is inside the class student. This shows encapsulation, because the data is protected inside the class structure.
Inheritance means creating a new class from an existing class.
class topper : public student { 
    int age;  
    topper(int age) { this.age = age; }
};
The toppers is inheriting from the student class using public inheritance. So, the class topper automatically gets the properties of the student class.
Since the code does not use virtual functions or method overriding, it does not show polymorphism.

Option D

In Inheritance, one class acquires the properties and functions of another class.
The existing class whose properties are inherited is called:

• Base Class / Parent Class / Super Class

The new class created from the existing class is called:

• Derived Class / Child Class / Sub Class

The derived class can use the features of the base class and can also add its own additional features.
#include<iostream>
using namespace std;
class Person          // Base class
{
public:
    void displayName()
    {
        cout<<"Name : Suresh Kulahry"<<endl;
    }
};
class Student : public Person    // Derived class
{
public:
    void displayCourse()
    {
        cout<<"Course : MCA";
    }
};
int main()
{
    Student s1;
    s1.displayName();
    s1.displayCourse();
    return 0;
}

Option C

In C++, private members of a class cannot be accessed directly by derived classes, even though they are technically inherited. They exist in memory but remain inaccessible to ensure encapsulation.

Option B

One of the main goals of C++ is to make programming easier by allowing developers to reuse code instead of writing everything from scratch. The concept in C++ that supports this is inheritance.
Inheritance allows a new class (derived class or child class or sub class) to acquire the properties and functions of an existing class (base class or parent class or super class).

Option D

In C++, inheritance means creating a new class (derived class) from an existing class (base class). The correct syntax places the derived class first, followed by a colon, then the access specifier (public, private, protected), and then the base class name.  Option (b) correctly follows this format.
However, if you do not specify any access specifier, the compiler does not produce an error, instead it uses a default access mode based on the type of class. In C++, the default inheritance for a class is private. This means class Derived : Base { }; is valid and treated as private inheritance. Therefore, option (c) is also a correct syntax.

Option A

Inheritance allows a class to inherit properties and behavior from another class, enabling code reuse through the "is-a" relationship.

• SportsBike (derived) is-a Bike (base).
• Student (derived) is-a Person (base).
• Teacher (derived) is-a Person (base).
• Dog (derived) is-a Animal (base).

Option B

In C++, access specifiers are keywords used inside a class to control how the members (data and functions) can be accessed from outside the class. They help in implementing the OOP concept called Data Hiding.
C++ PROVIDES THREE ACCESS SPECIFIERS:

• public: Members are accessible from anywhere in the program.
• private: Members are accessible only inside the same class.
• protected: Members are accessible inside the class and its derived classes.

Option A

In Object-Oriented Programming (Java or C++), a private method is accessible only inside the class in which it is declared. It cannot be accessed directly from outside the class, even by subclasses.
Private Methods are not inherited in a way that allows access, and they cannot be overridden because they are not visible in derived classes.