Advanced C++ Interview Questions - Derivation & Templates

This section on advanced C++ interview questions focuses on “Derivation and Templates”. One shall practice these advanced C++ 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 advanced C++ questions come with detailed explanation of the answers which helps in better understanding of C++ concepts.

Here is a listing of advanced C++ interview questions on “Derivation and Templates” along with answers, explanations and/or solutions:

1. Which is dependant on template parameter?
a) base class
b) abstract class
c) method
d) static class
View Answer

Answer: a
Explanation: Base class is dependant on template parameter.

2. Which value is placed in the base class?
a) derived values
b) default type values
c) both default type & derived values
d) null value
View Answer

Answer: b
Explanation: We can place the default type values in a base class and overriding some of them through derivation.

3. How many bits of memory needed for internal representation of class?
a) 1
b) 2
c) 4
d) no memory needed
View Answer

Answer: d
Explanation: classes that contain only type members, nonvirtual function members, and static data members do not require memory at run time.

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

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class class0 
```
```
    {
```
```
        public:
```
```
        virtual ~class0(){}
```
```
        protected:
```
```
        char p;
```
```
        public:
```
```
        char getChar();
```
```
    };
```
```
    class class1 : public class0 
```
```
    {
```
```
        public:
```
```
        void printChar();
```
```
    };
```
```
    void class1::printChar()
```
```
    {
```
```
        cout  << "True" << endl;
```
```
    }
```
```
    int main() 
```
```
    {
```
```
        class1 c;
```
```
        c.printChar();
```
```
        return 1;
```
```
    }
```

a) True
b) error
c) no output
d) runtime error
View Answer

Answer: a
Explanation: In this program, We are passing the values and inheriting it to the other class and printing the result.

Subscribe Now: C++ Newsletter | Important Subjects Newsletters

$ g++ dert.cpp
$ a.out
True

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

```
    #include <iostream>
```
```
    using namespace std; 
```

    template<typename T>class clsTemplate

```
    {
```
```
        public:
```
```
        T value;
```
```
        clsTemplate(T i)
```
```
        {
```
```
            this->value = i;
```
```
        }
```
```
    void test()
```
```
    {
```
```
        cout << value << endl;
```
```
    }
```
```
    };
```

    class clsChild : public clsTemplate<char>

```
    {
```
```
        public:
```

        clsChild(): clsTemplate<char>( 0 )

```
        {
```
```
        }
```

        clsChild(char c): clsTemplate<char>( c )

```
        {    
```
```
        }
```
```
    void test2()
```
```
    {
```
```
        test();
```
```
    }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        clsTemplate <int> a( 42 );
```
```
        clsChild b( 'A' );
```
```
        a.test();
```
```
        b.test();
```
```
        return 0;
```
```
    }
```

a) 42
b) A
c)

42
A

A
42

View Answer

Answer: c
Explanation: In this program, We are passing the values by using the template inheritance and printing it.
Output:

$ g++ dert.cpp
$ a.out
42
A

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

```
    #include <iostream>
```
```
    using namespace std;
```
```
    template <class T>
```
```
    class A
```
```
    {
```
```
        public:
```
```
        A(int a): x(a) {}
```
```
        protected:
```
```
        int x;
```
```
    };
```
```
    template <class T>
```
```
    class B: public A<char>
```
```
    {
```
```
        public:
```
```
        B(): A<char>::A(100) 
```
```
        {
```
```
            cout << x * 2 << endl;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        B<char> test;
```
```
        return 0;
```
```
    }
```

a) 100
b) 200
c) error
d) runtime error
View Answer

Answer: b
Explanation: In this program, We are passing the values and manipulating it by using the template inheritance.
Output:

$ g++ dert2.cpp
$ a.out
200

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

```
    #include <iostream>
```
```
    using namespace std;
```
```
    template <class type>
```
```
    class Test
```
```
    {
```
```
        public:
```
```
        Test();
```
```
        ~Test();
```
```
        type Data(type);
```
```
    };
```
```
    template <class type>
```
```
    type Test<type>::Data(type Var0)
```
```
    {
```
```
        return Var0;
```
```
    }
```
```
    template <class type>
```
```
    Test<type>::Test()
```
```
    {
```
```
    }
```
```
    template <class type>
```
```
    Test<type>::~Test()
```
```
    {
```
```
    }
```
```
    int main(void)
```
```
    {
```
```
        Test<char> Var3;
```
```
        cout << Var3.Data('K') << endl;
```
```
        return 0;
```
```
    }
```

a) k
b) l
c) error
d) runtime error
View Answer

Answer: a
Explanation: In this program, We are passing the values and printing it by using template inheritance.
Output:

$ g++ dert3.cpp
$ a.out
k

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

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class Base
```
```
    {
```
```
        public:
```
```
        Base ( )
```
```
        {
```
```
            cout << "1" << endl;
```
```
        }
```
```
        ~Base ( )
```
```
        {
```
```
            cout << "2" << endl;
```
```
        }
```
```
    };
```
```
    class Derived : public Base
```
```
    {
```
```
        public:
```
```
        Derived  ( )
```
```
        {
```
```
            cout << "3" << endl;
```
```
        }
```
```
        ~Derived ( )
```
```
        {
```
```
            cout << "4" << endl;
```
```
        }    
```
```
    }; 
```
```
    int main( )
```
```
    {
```
```
        Derived x;
```
```
    }
```

a) 1234
b) 4321
c) 1423
d) 1342
View Answer

Answer: d
Explanation: In this program, We are printing the order of execution of constructor and destructor in the class.
Output:

$ g++ dert4.cpp
$ a.out
1342

9. How many kinds of entities are directly parameterized in c++?
a) 1
b) 2
c) 3
d) 4
View Answer

Answer: c
Explanation: C++ allows us to parameterize directly three kinds of entities through templates: types, constants, and templates.

10. How many kinds of parameters are there in C++?
a) 1
b) 2
c) 3
d) 5
View Answer

Answer: c
Explanation: There are three kinds of parameters are there in C++. They are type, non-type, template.

Sanfoundry Global Education & Learning Series – C++ Programming Language.

To practice all areas of C++ language, here is complete set of 1000+ Multiple Choice Questions and Answers.

« Prev - C++ Programming MCQ – Specialization

» Next - C++ Programming Questions and Answers – Standard Template Library

Related Posts:

Practice Computer Science MCQs
Practice Programming MCQs
Check Computer Science Books
Apply for Information Technology Internship
Check Programming Books

Recommended Articles: