250+ TOP MCQs on Specialization and Answers

By engineer / May 26, 2024

This section on C++ interview questions and answers on “Specialization “. One shall practice these interview questions to improve their C++ programming skills needed for various interviews (campus interviews, walk-in 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++ interview questions come with the detailed explanation of the answers which helps in better understanding of C++ concepts.

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

1. What is meant by template specialization?
a) It will have certain data types to be fixed
b) It will make certain data types to be dynamic
c) Certain data types are invalid
d) It will make all data types to be dynamic
Answer: a
Clarification: In the template specialization, it will make the template to be specific for some data types.

2. Which is similar to template specialization?
a) template
b) function overloading
c) function template overloading
d) overloading
Answer: c
Clarification: function template overloading is similar to template specialization.

3. Which is called on allocating the memory for the array of objects?
a) destructor
b) constructor
c) method
d) class
Answer: b
Clarification: When you allocate memory for an array of objects, the default constructor must be called to construct each object. If no default constructor exists, you’re stuck needing a list of pointers to objects.

250+ TOP MCQs on Exception Handling – 3 and Answers

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

```
    #include 
```
```
    using namespace std;
```
```
    template <class T>
```
```
    inline T square(T x)
```
```
    {
```
```
        T result;
```
```
        result = x * x;
```
```
        return result;
```
```
    };
```
```
    template <>
```
```
    string square<string>(string ss)
```
```
    {
```
```
        return (ss+ss);
```
```
    };
```
```
    int main()
```
```
    {
```
```
        int i = 2, ii;
```
```
        string ww("A");
```
```
        ii = square<int>(i);
```
```
        cout << i << ": " << ii;
```

        cout << square<string>(ww) << ":" << endl;

```
    }
```

a) 2: 4AA:
b) 2:4
c) AA
d) 2:4A
Answer: a
Clarification: Template specialization is used when a different and specific implementation is to be used for a specific data type. In this program, We are using integer and character.
Output:

$ g++ spec.cpp
$ a.out
2: 4AA:

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

```
    #include 
```
```
    using namespace std;
```

    template <typename T = float, int count = 3>

```
    T multIt(T x)
```
```
    {
```

        for(int ii = 0; ii < count; ii++)

```
        {
```
```
            x = x * x;
```
```
        }
```
```
        return x;
```
```
    };
```
```
    int main()
```
```
    {
```
```
        float xx = 2.1;
```

        cout << xx << ": " << multIt<>(xx) << endl;

```
    }
```

a) 2.1
b) 378.228
c) 2.1: 378.228
d) 376
Answer: c
Clarification: In this program, We specify the type in the template function. We need to compile this program by adding -std=c++0x.
Output:

$ g++ -std=c++0x spec1.cpp
$ a.out
2.1: 378.228

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

```
    #include 
```
```
    using namespace std;
```
```
    template <class T>
```
```
    class XYZ
```
```
    {
```
```
        public:
```
```
        void putPri();
```
```
        static T ipub;
```
```
        private:
```
```
        static T ipri; 
```
```
    };
```
```
    template <class T>
```
```
    void XYZ<T>::putPri()
```
```
    {
```
```
        cout << ipri++ << endl;
```
```
    }
```

    template <class T> T XYZ<T>::ipub = 1;

    template <class T> T XYZ<T>::ipri = 1.2;

```
    int main()
```
```
    {
```
```
        XYZ<int> a;
```
```
        XYZ<float> b;
```
```
        a.putPri();
```
```
        cout << a.ipub << endl;
```
```
        b.putPri();
```
```
    }
```

a) 1
b) 1.2
c)

   1
   1.2

   1
   1
   1.2

View Answer

Answer: d
Clarification: In this program, We are passing the value of specified type and printing it by specialization.
Output:

$ g++ spec2.cpp
$ a.out
1
1
1.2

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

```
    #include 
```
```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    template <class type>
```

    type MyMax(const type Var1, const type Var2)

```
    {
```
```
        cout << "no specialization";
```

        return Var1 < Var2 ? Var2 : Var1;

```
    }
```
```
    template <>
```

    const char *MyMax(const char *Var1, const char *Var2)

```
    {
```

        return (strcmp(Var1, Var2)<0) ? Var2 : Var1;

```
    }
```
```
    int main()
```
```
    {
```

        string Str1 = "class", Str2 = "template";

```
        const char *Var3 = "class";
```
```
        const char *Var4 = "template";
```

        const char *q = MyMax(Var3, Var4);

```
        cout << q << endl;
```
```
        return 0;
```
```
    }
```

a) template
b) class
c) no specialization
d) templateclass
Answer: a
Clarification: In this program, We are computing the result in the specialized block of the program.
Output:

$ g++ spec3.cpp
$ a.out
template

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

```
    #include 
```
```
    using namespace std;
```

    template<class T = float, int i = 5> class A

```
    {
```
```
        public:
```
```
        A();
```
```
        int value;
```
```
    };
```
```
    template<> class A<> 
```
```
    { 
```
```
        public: A(); 
```
```
    };
```
```
    template<> class A<double, 10>
```
```
    { 
```
```
        public: A(); 
```
```
    };
```

    template<class T, int i> A<T, i>::A() : value(i)

```
    {
```
```
        cout << value;
```
```
    }
```
```
    A<>::A() 
```
```
    {
```
```
        cout << "default";
```
```
    }
```
```
    A<double, 10>::A() 
```
```
    {
```
```
        cout << "10" << endl;
```
```
    }
```
```
    int main() 
```
```
    {
```
```
        A<int, 6> x;
```
```
        A<> y;
```
```
        A<double, 10> z;
```
```
    }
```

a) 6
b) 10
c) 6default10
d) 6default
Answer: c
Clarification: In this program, We are defining three templates and specializing it and passing the values to it and printing it.
Output:

$ g++ spec5.cpp
$ a.out
6default10

250+ TOP MCQs on Specialization and Answers

Leave a Comment Cancel Reply

Interview Questions List

Related Posts

Leave a Comment Cancel Reply