250+ TOP MCQs on Multiple Inheritance and Answers

By engineer / May 26, 2024

This section on C++ programming questions and answers on “Multiple Inheritance”. One shall practice these questions to improve their C++ programming skills needed for various interviews (campus interviews, walkin interviews, company interviews), placements, entrance exams and other competitive exams. These questions can be attempted by anyone focusing on learning C++ programming language. They can be a beginner, fresher, engineering graduate or an experienced IT professional. Our C++ programming questions come with detailed explanation of the answers which helps in better understanding of C++ concepts.

Here is a listing of C++ programming questions on “Multiple Inheritance” along with answers, explanations and/or solutions:

1. What is meant by multiple inheritance?
a) Deriving a base class from derived class
b) Deriving a derived class from base class
c) Deriving a derived class from more than one base class
d) Deriving a derived base class
Answer: c
Clarification: Multiple inheritance enables a derived class to inherit members from more than one parent.

2. Which symbol is used to create multiple inheritances?
a) Dot
b) Comma
c) Dollar
d) star
Answer: b
Clarification: For using multiple inheritance, simply specify each base class (just like in single inheritance), separated by a comma.

3. Which of the following advantages we lose by using multiple inheritances?
a) Dynamic binding
b) Polymorphism
c) Both Dynamic binding & Polymorphism
d) Constructor
Answer: c
Clarification: The benefit of dynamic binding and polymorphism is that they help making the code easier to extend but by multiple inheritance it makes harder to track.

4. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    class polygon 
```
```
    {
```
```
        protected:
```
```
        int width, height;
```
```
        public:
```
```
        void set_values (int a, int b)
```
```
        { 
```
```
            width = a; height = b;}
```
```
        };
```
```
        class output1 
```
```
        {
```
```
            public:
```
```
                void output (int i);
```
```
        };
```
```
    void output1::output (int i) 
```
```
    {
```
```
        cout << i << endl;
```
```
    }
```

    class rectangle: public polygon, public output1

```
    {
```
```
        public:
```
```
        int area ()
```
```
        { 
```
```
            return (width * height); 
```
```
        }
```
```
    };
```

    class triangle: public polygon, public output1

```
    {
```
```
        public:
```
```
        int area ()
```
```
        {
```

            return (width * height / 2);

```
        }
```
```
    };
```
```
    int main () 
```
```
    {
```
```
        rectangle rect;
```
```
        triangle trgl;
```
```
        rect.set_values (4, 5);
```
```
        trgl.set_values (4, 5);
```
```
        rect.output (rect.area());
```
```
        trgl.output (trgl.area());
```
```
        return 0;
```
```
    }
```

a) 20
b) 10
c)

   20
   10

d) 30
Answer: c
Clarification: We are using the multiple inheritance to find the area of rectangle and triangle.
Output:

$ g++ mul.cpp
$ a.out
20
10

5. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    class Base
```
```
    {
```
```
        public:
```
```
        virtual void print() const = 0;
```
```
    };
```
```
    class DerivedOne : public Base
```
```
    {
```
```
        public:     
```
```
        void print() const
```
```
        {
```
```
            cout << "DerivedOnen";
```
```
        }
```
```
    };
```
```
    class DerivedTwo : public Base
```
```
    {
```
```
        public:
```
```
        void print() const
```
```
        {
```
```
            cout << "DerivedTwon";
```
```
        }     
```
```
    }; 
```

    class Multiple : public DerivedOne, public DerivedTwo

```
    {
```
```
        public:
```
```
        void print() const
```
```
        {
```
```
            DerivedTwo :: print();
```
```
        } 
```
```
    }; 
```
```
    int main()
```
```
    {
```
```
        int i;
```
```
        Multiple both; 
```
```
        DerivedOne one; 
```
```
        DerivedTwo two; 
```
```
        Base *array[ 3 ]; 
```
```
        array[ 0 ] = &both; 
```
```
        array[ 1 ] = &one;
```
```
        array[ 2 ] = &two;
```
```
        array[ i ] -> print();
```
```
        return 0;
```
```
    }
```

a) DerivedOne
b) DerivedTwo
c) Error
d) DerivedThree
Answer: c
Clarification: In this program, ‘Base’ is an ambiguous base of ‘Multiple’. So it is producing an error. And this program is a virtual base class.

6. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    class student
```
```
    {
```
```
        public:
```
```
        int rno , m1 , m2 ;
```
```
        void get()
```
```
        {
```
```
            rno = 15, m1 = 10, m2 = 10;
```
```
        }
```
```
    };
```
```
    class sports
```
```
    {
```
```
        public:
```
```
        int sm;
```
```
        void getsm()
```
```
        {
```
```
            sm = 10;
```
```
        }
```
```
    };
```

    class statement:public student,public sports

```
    {
```
```
        int tot,avg;
```
```
        public:
```
```
        void display()
```
```
        {
```
```
            tot = (m1 + m2 + sm);
```
```
            avg = tot / 3;
```
```
            cout << tot;
```
```
            cout << avg;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        statement obj;
```
```
        obj.get();
```
```
        obj.getsm();
```
```
        obj.display();
```
```
    }
```

a) 3100
b) 3010
c) 2010
d) 1010
Answer: b
Clarification: In this program, We are calculating the total and average marks of a student by using multiple inheritance.
Output:

$ g++ mul1.cpp
$ a.out
3010

7. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    struct a
```
```
    {
```
```
        int count;
```
```
    };
```
```
    struct b
```
```
    {
```
```
        int* value;
```
```
    };
```
```
    struct c : public a, public b
```
```
    {
```
```
    };
```
```
    int main()
```
```
    {
```
```
        c* p = new c;
```
```
        p->value = 0;
```
```
        cout << "Inherited";
```
```
        return 0;
```
```
    }
```

a) Inherited
b) Error
c) Runtime error
d) inherited
Answer: a
Clarification: In this program, We apply the multiple inheritance to structure.
Output:

$ g++ mul2.cpp
$ a.out
Inherited

8. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    class Base1
```
```
    {
```
```
        protected:
```
```
        int SampleDataOne;
```
```
        public:
```
```
        Base1()
```
```
        {
```
```
            SampleDataOne = 100;
```
```
        }
```
```
        ~Base1()
```
```
        {
```
```
        }
```
```
        int SampleFunctOne()
```
```
        {
```
```
            return SampleDataOne;
```
```
        }
```
```
    };
```
```
    class Base2
```
```
    {
```
```
        protected:
```
```
        int SampleDataTwo;
```
```
        public:
```
```
        Base2()
```
```
        {
```
```
            SampleDataTwo = 200;
```
```
        }
```
```
        ~Base2()
```
```
        {
```
```
        }
```
```
        int SampleFunctTwo()
```
```
        {
```
```
            return SampleDataTwo;
```
```
        }
```
```
    };
```

    class Derived1 : public Base1, public Base2

```
    {
```
```
        int MyData;
```
```
        public:
```
```
        Derived1() 
```
```
        {
```
```
            MyData = 300;
```
```
        }
```
```
        ~Derived1()
```
```
        {
```
```
        }    
```
```
        int MyFunct()
```
```
        {
```

            return (MyData + SampleDataOne + SampleDataTwo);

```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        Base1 SampleObjOne;
```
```
        Base2 SampleObjTwo;
```
```
        Derived1 SampleObjThree;
```

        cout << SampleObjThree.Base1 :: SampleFunctOne() << endl;

        cout << SampleObjThree.Base2 :: SampleFunctTwo() << endl;

```
        return 0;
```
```
    }
```

a) 100
b) 200
c) Both 100 & 200
d) 150
Answer: c
Clarification: In this program, We are passing the values by using multiple inheritance and printing the derived values.
Output:

$ g++ mul4.cpp
$ a.out
100
200

250+ TOP MCQs on Multiple Inheritance and Answers

Leave a Comment Cancel Reply

Interview Questions List

Related Posts

Leave a Comment Cancel Reply