Test: Templates - 2 - Back-End Programming MCQ

During runtime, We can choose the appropriate type for the function and it is called as template type parameters.

Non-type template parameters provide the ability to pass a constant expression at compile time. The constant expression may also be an address of a function, object or static class member.

A template parameter is a special kind of parameter that can be used to pass a type as argument.

The following are legal for non-type template parameters: integral or enumeration type, Pointer to object or pointer to function, Reference to object or reference to function, Pointer to member.

• When we write overloaded function we must code the function for each usage. Correct
• When we write function template we code the function only once. Correct
• It is difficult to debug macros Correct
• Templates are more efficient than macros Correct

So, option (D) is correct.

The following are legal for non-type template parameters:integral or enumeration type, Pointer to object or pointer to function, Reference to object or reference to function, Pointer to member.

Since count is static, it is not counted in sizeof.

In the template specialization, it will make the template to be specific for some data types.

We can pass non-type arguments to templates. Non-type parameters are mainly used for specifying max or min values or any other constant value for a particular instance of template. The important thing to note about non-type parameters is, they must be const. Compiler must know the value of non-type parameters at compile time. Because compiler needs to create functions/classes for a specified non-type value at compile time. Following is another example of non-type parameters.

#include <iostream>
using namespace std;

template < class T, int N >
 T fun (T arr[], int size)
{
    if (size > N)
      cout << "Not possible";
    T max = arr[0];
   for (int i = 1; i < size; i++)
      if (max < arr[i])
          max = arr[i];
   return max;
}

int main ()
{
    int arr[] = {12, 3, 14};
    cout << fun  (arr, 3);
}

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.

Above program is an example of template specialization. Sometime we want a different behaviour of a function/class template for a particular data type. For this, we can create a specialized version for that particular data type.

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

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

cin is mainly used to get the input during the runtime.

Every string template is used to replace the string with another string at runtime.

The compiler can determine at compile time whether the type associated with a template definition can perform all of the functions required by that template definition.